Question

我有时遇到这种情况并且不确定我是否使用了糟糕的方法，或者我只是不知道如何解决它。

让我们说我有两个班级和两个这样的豆子：

public class BeanOne {
    public void methodBeanOne() {
        //...
    }
}

public class BeanTwo {
    public void methodBeanTwo() {
        //...
    }
}

public class ClassOne {
    private BeanOne bean;

    public ClassOne(BeanOne bean) {
        this.bean = bean;
    }

    public void methodclassOne() {
        bean.methodBeanOne();
    }
}

public class ClassTwo {
    private BeanTwo bean;

    public ClassTwo(BeanTwo bean) {
        this.bean = bean;
    }

    public void methodClassTwo() {
        bean.methodBeanTwo();
    }
}

我想创建一个通用的抽象类，所以我可以从ClassOne和ClassTwo中提取一些逻辑，以及一个使用常用方法的抽象bean：

public abstract class AbstractBean {
    public void commonMethod() {
        //...
    }
}

public class BeanOne extends AbstractBean {
    public void methodBeanOne() {
        //...
    }
}

public class BeanTwo extends AbstractBean {
    public void methodBeanTwo() {
        //...
    }
}

public abstract class AbstractClass<T extends AbstractBean> {
    protected T bean;

    public AbstractClass(T bean) {
        this.bean = bean;
    }

    public void commonClassMethod(){
        bean.commonMethod();
    }
}

public class ClassOne extends AbstractClass<BeanOne> {

    public ClassOne(BeanOne bean) {
        super(bean);
    }

    public void methodclassOne() {
        bean.methodBeanOne();
    }
}

public class ClassTwo extends AbstractClass<BeanTwo> {

    public ClassTwo(BeanTwo bean) {
        super(bean);
    }

    public void methodClassTwo() {
        bean.methodBeanTwo();
    }
}

到目前为止，非常好。

下一步是创建一个工厂，例如基于enum获得一个实现，这就是我开始收到错误的地方：

public class ClassFactory {

    public enum MyEnum {
        ONE, TWO;
    }

    private ClassFactory() {
    }

    public static AbstractClass newInstance(MyEnum value, AbstractBean bean) {
        switch(value){
        case ONE:
            return new ClassOne(bean);
        case TWO:
            return new ClassTwo(bean);
        default:
            throw new IllegalArgumentException();
        }
    }
}

这会产生以下编译错误：

The constructor ClassOne(AbstractBean) is undefined
The constructor ClassTwo(AbstractBean) is undefined

我也尝试过：

public class ClassFactory {

    public enum MyEnum {
        ONE, TWO;
    }

    private ClassFactory() {
    }

    public static <T extends AbstractBean> AbstractClass<T> newInstance(MyEnum value, T bean) {
        switch(value){
        case ONE:
            return new ClassOne(bean);
        case TWO:
            return new ClassTwo(bean);
        default:
            throw new IllegalArgumentException();
        }
    }
}

但后来我得到了：

Type mismatch: cannot convert from ClassOne to AbstractClass<T>
Type mismatch: cannot convert from ClassTwo to AbstractClass<T>

我几乎被困在那里。我想我理解这个错误，但是，是否可以创建这样的工厂类试图避免铸件？

我还检查了this post，但无法完全理解它是如何帮助我的。

编辑：访客模式

好的，所以我尝试过普通邮件中描述的访客模式：

public interface Visitor<T> {
    T visit(BeanOne bean);

    T visit(BeanTwo bean);
}

public abstract class AbstractBean {
    public void commonMethod() {
        // ...
    }

    public abstract <T> T accept(Visitor<T> visitor);
}

public class BeanOne extends AbstractBean {
    public void methodBeanOne() {
        // ...
    }

    @Override
    public <T> T accept(Visitor<T> visitor) {
        return visitor.visit(this);
    }
}

public class BeanTwo extends AbstractBean {
    public void methodBeanTwo() {
        // ...
    }

    @Override
    public <T> T accept(Visitor<T> visitor) {
        return visitor.visit(this);
    }
}

public class ClassFactory {
    private ClassFactory() {
    }

    public static AbstractClass<? extends AbstractBean> newInstance(AbstractBean bean) {
        return bean.accept(new AbstractClassVisitor());
    }
}

public class AbstractClassVisitor implements Visitor<AbstractClass<? extends AbstractBean>> {

    @Override
    public AbstractClass<? extends AbstractBean> visit(BeanOne bean) {
        return ClassFactory.newInstance(bean);
    }

    @Override
    public AbstractClass<? extends AbstractBean> visit(BeanTwo bean) {
        return ClassFactory.newInstance(bean);
    }
}

但是像这样使用它：

AbstractBean bean = new BeanOne();
AbstractClass<? extends AbstractBean> clazz = ClassFactory.newInstance(bean);
clazz.commonClassMethod();

我收到以下异常：

Exception in thread "main" java.lang.StackOverflowError
    at test.AbstractClassVisitor.<init>(AbstractClassVisitor.java:3)
    at test.ClassFactory.newInstance(ClassFactory.java:9)
    at test.AbstractClassVisitor.visit(AbstractClassVisitor.java:7)
    at test.AbstractClassVisitor.visit(AbstractClassVisitor.java:1)
    at test.BeanOne.accept(BeanOne.java:10)
    at test.ClassFactory.newInstance(ClassFactory.java:9)
    at test.AbstractClassVisitor.visit(AbstractClassVisitor.java:7)
    at test.AbstractClassVisitor.visit(AbstractClassVisitor.java:1)
    at test.BeanOne.accept(BeanOne.java:10)
    at test.ClassFactory.newInstance(ClassFactory.java:9)
    at test.AbstractClassVisitor.visit(AbstractClassVisitor.java:7)
    at test.AbstractClassVisitor.visit(AbstractClassVisitor.java:1)
    at test.BeanOne.accept(BeanOne.java:10)
    ...

我可以看到为什么会发生这种情况，我错过了什么？

Answer 1

根据您自己提供的问题，请参阅以下答案：https://stackoverflow.com/a/12630501/144302

同样的原则适用于您的问题：使用具有重载方法的工厂

public class ClassFactory {

  private ClassFactory() {
  }

  public static AbstractClass<BeanOne> newInstance(BeanOne bean) {
    return new ClassOne(bean);
  }

  public static AbstractClass<BeanTwo> newInstance(BeanTwo bean) {
    return new ClassTwo(bean);
  }
}

或者，如答案中所指出的，应用双重调度等原则，在AbstractClass<T> newInstance()中添加方法AbstractBean并在每个专业化中适当地实施。 E.g。

class BeanOne { /* ... */ 
   public AbstractBean<BeanOne> newInstance() {
      return ClassFactory.newInstance(this);
   }
}

您最后可以将以下方法添加到ClassFactory

public static <T> AbstractClass<T> newInstance(AbstractBean<T> bean) {
   return bean.newInstance();
}

对于具体的优点和缺点，我鼓励你在另一个问题中阅读整个答案（这是非常好的，我不想盲目地复制其他人的工作）。

Answer 2

我认为这是因为构造函数参数public ClassOne(BeanOne bean)。您尝试提供AbstractBean的父项BeanOne作为构造函数参数。 Java只允许扩展对象而不缩小范围。尝试将父对象类型转换为特定子对象，如下所示：

public static AbstractClass newInstance(MyEnum value, AbstractBean bean) {
    switch(value):
    case ONE:
        return new ClassOne((BeanOne)bean);
    case TWO:
        return new ClassTwo((BeanTwo)bean);
    default:
        throw new IllegalArgumentException();
}

但请确保在调用newInstance方法时，提供正确的对象实例。否则可能会发生ClassCastException。

编辑：

public static AbstractClass newInstance(MyEnum value) {
    switch(value):
    case ONE:
        return new ClassOne(new BeanOne());
    case TWO:
        return new ClassTwo(new BeanTwo());
    default:
        throw new IllegalArgumentException();
}

工厂模式和泛型

2 个答案: