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

假设我有一个动物类，以及它的两个子类，即Dog和Cat。我想记录Dog和Cat类的实例数（例如，{Dog:3，Cat:1}）

---

我可以使用

Animal.instances

获得所有动物的计数。但是，我想分别计算每种动物的数量。如何在不重复所有子类的构造函数中的相同代码的情况下实现这一点？

类似的内容可能会有所帮助：

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);
    }
}

类动物{
静态映射实例=new HashMap（）；
公共动物（）{
if（instances.get（this.getClass（））==null）
instances.put（this.getClass（），0）；
instances.put（this.getClass（）、instances.get（this.getClass（））+1）；
}
}

---

现在，如果您想获取猫的数量，请使用

实例.get（Cat.class）

类似的内容可能会有所帮助：

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);
    }
}

类动物{
静态映射实例=new HashMap（）；
公共动物（）{
if（instances.get（this.getClass（））==null）
instances.put（this.getClass（），0）；
instances.put（this.getClass（）、instances.get（this.getClass（））+1）；
}
}

---

现在，如果您想获取猫的数量，请使用

实例.get（Cat.class）

您可以维护一个地图：

class Animal {

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

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

类动物{
静态映射计数=新HashMap（）；
公共动物（）{
counts.compute（this.getClass（）.getName（），
（s，old）->old==null？1:old+1）；
}
}

---

如果您预见到竞争条件，那么您可能应该进行

计数
a
ConcurrentHashMap
您可以维护一个映射：

class Animal {

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

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

类动物{
静态映射计数=新HashMap（）；
公共动物（）{
counts.compute（this.getClass（）.getName（），
（s，old）->old==null？1:old+1）；
}
}

如果您预见到竞争条件，那么您可能应该进行
计数
a
ConcurrentHashMap
不要依赖于静态或统计

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

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;
    }
}

interface AnimalFactory
{
T create（）；
}
接口计数AnimalFactory扩展AnimalFactory
{
int numberOfAnimals（）；
}
公共类CountingDogFactory实现CountingAnimalFactory
{
私家犬；
公犬创建（）{
numberOfDogs++；
归还新狗（）；
}
公共动物国际号码（）{
返回狗的数目；
}
}

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

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

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;
    }
}

interface AnimalFactory
{
T create（）；
}
接口计数AnimalFactory扩展AnimalFactory
{
int numberOfAnimals（）；
}
公共类CountingDogFactory实现CountingAnimalFactory
{
私家犬；
公犬创建（）{
numberOfDogs++；
归还新狗（）；
}
公共动物国际号码（）{
返回狗的数目；
}
}

您可以将
Dog
和
Cat
包的构造函数设置为私有，以强制它们通过工厂实例化。
^就是这样+1^就是这样+1以上所有答案都可以，但不要忘记，如果重新定义无参数构造函数，则必须执行以下操作：类Cat扩展Animal{public Cat（arg arg）{super（）；}}}以上所有答案都可以，但不要忘记，如果重新定义无参数构造函数，则必须执行以下操作：类Cat扩展Animal{public Cat（Arg Arg）{super（）；}}