泛型类在Java中的泛型类型参数化责任链模式

在Java中，泛型类可以用于实现责任链模式。责任链模式是一种行为设计模式，它允许对象以链式结构处理请求。每个对象都有一个后继者，请求会沿着链传递，直到找到一个能够处理该请求的对象。

下面是一个使用泛型类实现责任链模式的示例：

public abstract class Handler<T> {
    protected Handler<T> successor;

    public void setSuccessor(Handler<T> successor) {
        this.successor = successor;
    }

    public abstract void handleRequest(T request);
}

public class ConcreteHandlerA<T> extends Handler<T> {
    @Override
    public void handleRequest(T request) {
        if (request instanceof ConcreteRequestA) {
            System.out.println("ConcreteHandlerA handled the request.");
        } else if (successor != null) {
            successor.handleRequest(request);
        }
    }
}

public class ConcreteHandlerB<T> extends Handler<T> {
    @Override
    public void handleRequest(T request) {
        if (request instanceof ConcreteRequestB) {
            System.out.println("ConcreteHandlerB handled the request.");
        } else if (successor != null) {
            successor.handleRequest(request);
        }
    }
}

public class Request {
    // Request interface or abstract class
}

public class ConcreteRequestA extends Request {
    // ConcreteRequestA implementation
}

public class ConcreteRequestB extends Request {
    // ConcreteRequestB implementation
}

public class Client {
    public static void main(String[] args) {
        Handler<Request> handlerA = new ConcreteHandlerA<>();
        Handler<Request> handlerB = new ConcreteHandlerB<>();

        handlerA.setSuccessor(handlerB);

        Request requestA = new ConcreteRequestA();
        Request requestB = new ConcreteRequestB();

        handlerA.handleRequest(requestA); // Output: ConcreteHandlerA handled the request.
        handlerA.handleRequest(requestB); // Output: ConcreteHandlerB handled the request.
    }
}

在这个示例中，我们定义了一个抽象泛型类Handler，它有一个类型参数T和一个后继者successor。Handler类有一个抽象方法handleRequest，用于处理请求。

然后，我们定义了两个具体的处理程序类ConcreteHandlerA和ConcreteHandlerB，它们都继承自Handler类，并实现了handleRequest方法。这些具体处理程序类检查请求的类型，如果它们能够处理该请求，则处理它；否则，它们将请求传递给后继者。

最后，我们创建了一个客户端，它创建了两个处理程序对象，并将它们链接在一起。然后，它创建了两个请求对象，并将它们传递给链中的第一个处理程序。输出表明，请求被正确地传递给了能够处理它的处理程序。