首页 文章

如何使用带有限类型参数的抽象工厂模式？

提问于
浏览 次
0

我试图使用带有有界类型参数的抽象工厂模式，示例如下：

CageAbstractFactory.java

public interface CageAbstractFactory {
    public Cage<?> createCage();
}

CageFactory.java

public class CageFactory {
    public static Cage<?> getCage(CageAbstractFactory factory) {
        return factory.createCage();
    }
}

XxxCageFactory.java（Xxx =狮子，老鼠等）

public class XxxCageFactory implements CageAbstractFactory {
    @Override
    public Cage<Xxx> createCage() {
        return new XxxCage();
    }
}

Cage.java

public abstract class Cage<T extends Animal> { 
    protected Set<T> cage = new HashSet<T>();
    public abstract void add(T animal);
    public void showAnimals() {
        System.out.println(cage);
    }
}

XxxCage.java（Xxx =狮子，老鼠等）

public class XxxCage extends Cage<Xxx> {
    @Override
    public void add(Xxx r) {
        cage.add(r);
    }
}

Animal.java

public class Animal {
    public String toString() {
        return getClass().getSimpleName();
    }   

}

class Rat extends Animal {}
class Lion extends Animal {}

AFP.java（主类）

public class AFP {

    public static void main(String[] args) {
        Cage<?> rc = CageFactory.getCage(new RatCageFactory());
        Cage<?> lc = CageFactory.getCage(new LionCageFactory());
        rc.add(new Rat());
        rc.showAnimals();
        lc.add(new Lion());
    }

}

在行 rc.add(new Rat()) 或 rc.add(new Lion()) ，出现以下错误：

The method add(capture#3-of ?) in the type Cage<capture#3-of ?> is not applicable for the arguments (Rat)

似乎从 Cage<?> 到 Cage<Rat> / Cage<Lion> 存在类型转换错误

但问题是 CageFactory.getCage(CageAbstractFactory factory) 正在返回 Cage<?> ，这只是在运行时通过选择作为参数传递的 CageAbstractFactory 类来决定的（即 LionCageFactory 或 RatCageFactory ）

java generics design-patterns

2 回答

  • 1

    请勿使用 wildcard ?

    public static Cage<?> getCage(CageAbstractFactory factory) {
    return factory.createCage();
}

    但使用通用

    public static <T extends Animal> Cage<T> getCage(CageAbstractFactory factory) {
    return factory.createCage();
}
    回复于
  • 1

    您还需要概括 CageAbstractFactory ：

    public interface CageAbstractFactory<T> {
    public Cage<T> createCage();
}

public class CageFactory {
    public static <T> Cage<T> getCage(CageAbstractFactory<T> factory) {
        return factory.createCage();
    }
}

public class XxxCageFactory implements CageAbstractFactory<Xxx> {
    @Override
    public Cage<Xxx> createCage() {
        return new XxxCage();
    }
}
    回复于

相关问题