Java泛型类，它可以使用工厂生成的自己的产品

对不起，有线标题，但它归结为一点

问题可以这样描述：

我有一个

工人

类，可以配置它来生产“一些”产品。这名

员工必须能够消费自己的产品（并且只有自己的产品，这是练习的重点）：

interface Worker
{
公共产品（；
公共空间消费（P）；
}

（无法更改）

到目前为止还很简单，但现在可以配置产品本身：

interface ConfiguredProduct<T> {
    public T value();
}

接口配置产品{
公共价值观（）；
}

（无法更改）

现在工人由工厂生成（在现实生活中，工厂本身是使用配置文件创建的）

静态类孵化场{
公职人员（）{
返回新的StringWorker（）；//类型不匹配：无法从Test.StringWorker转换为Test.Worker
}
}

（可以更改）

我喜欢这样使用它：

public static <perhapse some wired arguments> void main( String [] args ) throws Exception {

    Hatchery hatchery = new Hatchery(); // Cannot be parametrized here

    Worker<T> worker = hatchery.breed();

    ConfiguredProduct<wired arguments> product = worker.produce();

    worker.consume( product );
}

publicstaticvoidmain（字符串[]args）引发异常{
Hatchery Hatchery=new Hatchery（）；//不能在此处参数化
工人=孵化场。繁殖（）；
ConfiguredProduct product=worker.product（）；
工人消费（产品）；
}

工人的例子可能是：

static class StringWorker implements Worker<ConfiguredProduct<String>> {

    @Override
    public ConfiguredProduct<String> produce() {
        return () -> "Hello";
    }

    @Override
    public void consume( ConfiguredProduct<String> p ) {
        System.out.println( "Hello " + p.value() );
    }
}

static class StringBufferWorker implements Worker<ConfiguredProduct<StringBuffer>> {

    @Override
    public ConfiguredProduct<StringBuffer> produce() {
        return () -> new StringBuffer( "Hello" );
    }

    @Override
    public void consume( ConfiguredProduct<StringBuffer> p ) {
        System.out.println( "Hello " + p.value().toString() );
    }
}

静态类StringWorker实现Worker{
@凌驾
公共配置产品生产（）{
return（）->“你好”；
}
@凌驾
公共无效消费（配置的产品p）{
System.out.println（“Hello”+p.value（））；
}
}
静态类StringBufferWorker实现Worker{
@凌驾
公共配置产品生产（）{
return（）->newstringbuffer（“Hello”）；
}
@凌驾
公共无效消费（配置的产品p）{
System.out.println（“Hello”+p.value（）.toString（））；
}
}

这甚至可以不疯狂地施放吗？我在我能想到的任何地方尝试了所有通用参数的组合，但它确实在某一点上产生了错误

编辑：添加了无法更改零件的注释。为孵化场添加了用法和注释

这是怎么回事：

public class Test {

    private interface Product<X> {
        public X getValue();
    }

    private static class StringProduct implements Product<String> {

        @Override
        public String getValue() {
            return "Hello World!";
        }
    }

    private interface Worker<X> {
        public Product<X> produce();

        public void consume(Product<? extends X> p);
    }

    private static class StringWorker implements Worker<String> {

        @Override
        public StringProduct produce() {
            return new StringProduct();
        }

        @Override
        public void consume(Product<? extends String> p) {
            System.out.println(p.getValue());
        }
    }

    private interface WorkerFactory<T extends Worker<?>> {
        public T breed();
    }

    private static class StringWorkerFactory implements WorkerFactory<StringWorker> {

        @Override
        public StringWorker breed() {
            return new StringWorker();
        }
    }

    public static void main(String[] args) {
        WorkerFactory<StringWorker> factory = new StringWorkerFactory();
        Worker<String> worker = factory.breed();

        Product<String> product = worker.produce();

        worker.consume(product);
    }
}

公共类测试{
专用接口产品{
公共X getValue（）；
}
私有静态类StringProduct实现产品{
@凌驾
公共字符串getValue（）{
返回“你好，世界！”；
}
}
专用接口工作者{
公共产品生产（）；
公共虚空消费（产品这个呢：

public class Test {

    private interface Product<X> {
        public X getValue();
    }

    private static class StringProduct implements Product<String> {

        @Override
        public String getValue() {
            return "Hello World!";
        }
    }

    private interface Worker<X> {
        public Product<X> produce();

        public void consume(Product<? extends X> p);
    }

    private static class StringWorker implements Worker<String> {

        @Override
        public StringProduct produce() {
            return new StringProduct();
        }

        @Override
        public void consume(Product<? extends String> p) {
            System.out.println(p.getValue());
        }
    }

    private interface WorkerFactory<T extends Worker<?>> {
        public T breed();
    }

    private static class StringWorkerFactory implements WorkerFactory<StringWorker> {

        @Override
        public StringWorker breed() {
            return new StringWorker();
        }
    }

    public static void main(String[] args) {
        WorkerFactory<StringWorker> factory = new StringWorkerFactory();
        Worker<String> worker = factory.breed();

        Product<String> product = worker.produce();

        worker.consume(product);
    }
}

公共类测试{
专用接口产品{
公共X getValue（）；
}
私有静态类StringProduct实现产品{
@凌驾
公共字符串getValue（）{
返回“你好，世界！”；
}
}
专用接口工作者{
公共产品生产（）；
公共无效消费（产品如果您将有不同的工厂，返回不同的工人，那么您将有如下情况：

static interface Hatchery {
    public <X extends CharSequence, Y extends ConfiguredProduct<X>> Worker<Y> breed();
}

static class WorkerHatchery implements Hatchery{
    public   Worker<ConfiguredProduct<String>> breed(){
        return new StringWorker();
    }
}

静态接口孵化器{
公职人员（繁育）；
}
静态类WorkerWatchery实现孵化器{
公职人员（）{
返回新的StringWorker（）；
}
}

然后这个代码就可以正常工作了

public static void main(String[] args) throws Exception {
    Hatchery hatchery = new WorkerHatchery();
    Worker<ConfiguredProduct<String>> worker = hatchery.breed();
    ConfiguredProduct<String> product = worker.produce();
    worker.consume(product);
}

publicstaticvoidmain（字符串[]args）引发异常{
孵化场孵化场=新工人孵化场（）；
工人=孵化场。繁殖（）；
ConfiguredProduct product=worker.product（）；
工人消费（产品）；
}

编辑
如果您不希望出现任何警告，还有另一种选择，您可以在类上移动泛型值，您将有：

 interface Hatchery<X extends CharSequence, Y extends ConfiguredProduct<X>>{ 
       Worker<Y> breed();
    }

class WorkerHatchery implements Hatchery<String,ConfiguredProduct<String>> { 
        public Worker<ConfiguredProduct<String>> breed() {  
        return new  StringWorker();     
    }   
}

接口孵化场{
工人品种（）；
}
类WorkerHatchery实现孵化{
公职人员{
返回新的StringWorker（）；
}   
}
如果有不同的工厂返回不同的工人，那么您将有如下情况：

static interface Hatchery {
    public <X extends CharSequence, Y extends ConfiguredProduct<X>> Worker<Y> breed();
}

static class WorkerHatchery implements Hatchery{
    public   Worker<ConfiguredProduct<String>> breed(){
        return new StringWorker();
    }
}

静态接口孵化器{
公职人员（繁育）；
}
静态类WorkerWatchery实现孵化器{
公职人员（）{
返回新的StringWorker（）；
}
}

然后这个代码就可以正常工作了

public static void main(String[] args) throws Exception {
    Hatchery hatchery = new WorkerHatchery();
    Worker<ConfiguredProduct<String>> worker = hatchery.breed();
    ConfiguredProduct<String> product = worker.produce();
    worker.consume(product);
}

publicstaticvoidmain（字符串[]args）引发异常{
孵化场孵化场=新工人孵化场（）；
工人=孵化场。繁殖（）；
ConfiguredProduct product=worker.product（）；
工人消费（产品）；
}

编辑
如果您不希望出现任何警告，还有另一种选择，您可以在类上移动泛型值，您将有：

 interface Hatchery<X extends CharSequence, Y extends ConfiguredProduct<X>>{ 
       Worker<Y> breed();
    }

class WorkerHatchery implements Hatchery<String,ConfiguredProduct<String>> { 
        public Worker<ConfiguredProduct<String>> breed() {  
        return new  StringWorker();     
    }   
}

接口孵化场{
工人品种（）；
}
类WorkerHatchery实现孵化{
公职人员{
返回新的StringWorker（）；
}   
}
你能详细介绍一下产品和配置产品吗？我不清楚后者是否是前者的扩展接口。还有，你为什么在你的breed（）方法中定义Y？它没有被使用。请过滤掉你问题中所有不需要的东西，因为它会让人困惑。嗨，Timmos.X/Y是一个拼写错误，现在被更正了。“产品”它本身不是一个类，只是泛型参数
P
（阅读：可能产生的特定内容）.
ConfiguredProduct
就是这样一种东西。有时很难找到与实际代码完全不同的东西的名称/类似物。您能解释一下为什么希望在
breed
方法中使用泛型吗？与参数无关，您总是会返回
StringWorker
@user902383:St的实例ringWorker只是本例中的一个例子。它可能返回StringBufferWorker或类似的东西。就像我写的：“现在工人是由工厂生成的（在现实生活中，工厂本身是使用配置文件创建的）”。不同的事实