java-如何创建泛型类型T的实例

我正在编写一个服务器，如下所示

public class Server<T extends RequestHandler> {

    public void start() {

        try{
            this.serverSocket = new ServerSocket(this.port, this.backLog);
        } catch (IOException e) {
            LOGGER.error("Could not listen on port " + this.port, e);
            System.exit(-1);
        }

        while (!stopTheServer) {
            socket = null;
            try {
                socket = serverSocket.accept();
                handleNewConnectionRequest(socket);
            } catch (IOException e) {
                LOGGER.warn("Accept failed at: " + this.port, e);
                e.printStackTrace();
            }
        }

    }

    protected void handleNewConnectionRequest(Socket socket) {
        try {
            executorService.submit(new T(socket));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Server<HttpRequestHandler> httpServer = new Server<HttpRequestHandler>();
Server<FtpRequestHandler> ftpServer = new Server<FtpRequestHandler >();
Server<SmtpRequestHandler> smtpServer = new Server<SmtpRequestHandler >();

然后像下面那样使用它们

public class Server<T extends RequestHandler> {

    public void start() {

        try{
            this.serverSocket = new ServerSocket(this.port, this.backLog);
        } catch (IOException e) {
            LOGGER.error("Could not listen on port " + this.port, e);
            System.exit(-1);
        }

        while (!stopTheServer) {
            socket = null;
            try {
                socket = serverSocket.accept();
                handleNewConnectionRequest(socket);
            } catch (IOException e) {
                LOGGER.warn("Accept failed at: " + this.port, e);
                e.printStackTrace();
            }
        }

    }

    protected void handleNewConnectionRequest(Socket socket) {
        try {
            executorService.submit(new T(socket));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Server<HttpRequestHandler> httpServer = new Server<HttpRequestHandler>();
Server<FtpRequestHandler> ftpServer = new Server<FtpRequestHandler >();
Server<SmtpRequestHandler> smtpServer = new Server<SmtpRequestHandler >();

Server httpServer=newserver（）；
服务器ftpServer=新服务器（）；
服务器smtpServer=新服务器（）；

您不能像Java中的泛型那样直接执行。如果使用

getClass（）

获取RequestHandler的实际类对象，则可以使用反射。您可以尝试在构造函数中保存该项的类，然后编写如下帮助器方法：

Save the class object (in constructor for example):
this.clazz = requestHandler.getClass()

Then create new object of same class:
E instantiate(Class<E> clazz)
{
    return clazz.newInstance();
}

保存类对象（例如在构造函数中）：
this.clazz=requestHandler.getClass（）
然后创建同一类的新对象：
E实例化（类clazz）
{
返回clazz.newInstance（）；
}

您将需要该类的实例。泛型类型T是不够的。所以你要做：

class Server <T extends RequestHandler> {
    Class<T> clazz;
    public Server(Class<T> clazz) {
        this.clazz = clazz;
    }

    private T newRequest() {
        return clazz.newInstance();
    }
}

类服务器{
课堂讨论；
公共服务器（clazz类）{
this.clazz=clazz；
}
private T newRequest（）{
返回clazz.newInstance（）；
}
}

可能使不同的

服务器

子类适合不同的处理程序类型。一个例子：

public class HttpServer extends Server<HttpRequestHandler> {

    protected HttpRequestHandler wrapSocket(Socket socket) {
        return new HttpRequestHandler(socket);
    }

}

公共类HttpServer扩展服务器{
受保护的HttpRequestHandler wrapSocket（套接字）{
返回新的HttpRequestHandler（套接字）；
}
}

并对服务器进行如下调整：

public abstract class Server<T extends RequestHandler> {

    protected abstract T wrapSocket(Socket socket);

    protected void handleNewConnectionRequest(Socket socket) {
        try {
            executorService.submit(wrapSocket(socket));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

公共抽象类服务器{
受保护的抽象T包装盒（插座）；
受保护的无效handleNewConnectionRequest（套接字）{
试一试{
提交（wrapSocket（socket））；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
}
}

---

只是一个想法…

你没有。这没有道理。在这种情况下，我可能会避免使用泛型。普通的旧接口或抽象类不起作用。您可以使用抽象工厂方法创建抽象服务器

abstract class Server {
    abstract protected RequestHandler newRequest(Socket socket);
    ... same as before
}

---

+1.或者让服务器使用RequestHandlerFactory，并要求此工厂在服务器每次需要时创建RequestHandler。@JBNizet嘿，更好！我发现抽象类/实现和类型参数对于OO设计来说是非常好的朋友。我不确定这里的工厂模式能带来多少好处。语言结构是一条路要走。