Question

假设我有一个Animal类，它的两个子类是Dog and Cat。我想保留Dog和Cat类的实例计数（例如{Dog：3，Cat：1}）。

class Animal{
  static int instances = 0;
  public Animal(){
    instances++;
  }
}

我可以使用Animal.instances来获取所有动物的数量。但是，我想分别获取每种动物的计数。如何在不重复所有子类的构造函数相同代码的情况下实现这一目标？

Answer 1

您可以维护地图：

class Animal {

    static Map<String, Long> counts = new HashMap<>();

    public Animal() {
        counts.compute(this.getClass().getName(), 
                (s, old) -> old == null ? 1 : old + 1);
    }
}

如果您预见到比赛情况，则应该将counts设为ConcurrentHashMap

Answer 2

不要依赖静态变量或reflexively checking the class name。

解决此问题的最佳方法是将创建对象的责任推迟到工厂：

interface AnimalFactory<T extends Animal>
{
    T create();
}

interface CountingAnimalFactory<T extends Animal> extends AnimalFactory<T>
{
    int numberOfAnimals();
}

public class CountingDogFactory implements CountingAnimalFactory<Dog>
{
    private int numberOfDogs;

    public Dog create() {
        numberOfDogs++;
        return new Dog();
    }

    public int numberOfAnimals() {
         return numberOfDogs;
    }
}

您可以将Dog和Cat的构造函数设为包私有，以强制通过工厂实例化它们。

Answer 3

类似的事情可能会有所帮助：

class Animal {
    static Map<Class, Integer> instances = new HashMap<>();

    public Animal() {
        if (instances.get(this.getClass()) == null)
            instances.put(this.getClass(), 0);
        instances.put(this.getClass(), instances.get(this.getClass()) + 1);
    }
}

现在，如果要获取猫的数量，请使用instances.get(Cat.class)。

有没有办法模仿Java中Ruby的类实例变量概念？

3 个答案: