每个扩展类的静态变量[重复]答案

【问题标题】：Static variable for each extended class [duplicate]每个扩展类的静态变量[重复]
【发布时间】：2018-12-28 17:21:07
【问题描述】：

假设我有一个基本/主要abstract 类：AbstractObject。 AbstractObject 扩展了两个类：Object1 和 Object2。

这两个模板也有许多不同的类从它们扩展而来，例如，Object3、Object4 和 Object5 继承自 Object1，而 Object6、Object7 继承自 @987654332 @。

我希望每个单独的类（Object1、Object2、...、Object7）都有一个计数器来计算由它构成的实例数。

我以为我可以使用一些public static 变量counter，但我不确定如何在AbstractObject 中声明它，所以我的所有对象都不会复制代码。有什么想法吗？

abstract class AbstractObject {
  ...
  public static counter = ?
}

class Object1 extends AbstractObject {
  ...
}

class Object2 extends AbstractObject {
  ...
}

class Object3 extends Object1 {
  ...
}

class Object4 extends Object1 {
  ...
}

class Object7 extends Object2 {
  ...
}

【问题讨论】：

你不能。每个类都需要有自己的计数器字段（为什么要公开？）。或者您可以使用单个共享的 CountManager，它会使用一些包含每个类的计数的 Map。
也就是说，你为什么要计算一个类的实例？你想解决什么具体问题？
澄清一下，您希望每个对象都有一个单独的计数器（即 3 Object1、2Object2 等），而不是计算每种类型的数量的计数器总共（即 20 个对象）？
@JBNizet 没错，每个不同的类都有不同的计数器

标签： java inheritance

【解决方案1】：

我想要...有一个计数器来计算实例数 用它做的。

实例——意思是“为每个类实例化的对象”？
如果是，则使用静态地图。例如：

public class AbstractObject {

    private static Map<Class, Integer> map = Collections.synchronizedMap(new HashMap<>());

    public AbstractObject() {
        Class clazz = this.getClass();
        map.merge(clazz, 1, (x, y) -> x + y);
    }

    public static Map<Class, Integer> getCounters() {
        return Collections.unmodifiableMap(map);
    }
}

public class Object1 extends AbstractObject {
}

public class Object11 extends Object1 {
}

public class Object2 extends AbstractObject {
}

public class Object12 extends Object11{
}

现在：

public static void main(String[] args) {
    AbstractObject o1 = new Object1();
    o1 = new Object1();
    o1 = new Object2();
    o1 = new Object11();
    o1 = new Object11();
    o1 = new Object12();

    AbstractObject.getCounters().forEach((k, v) -> System.out.println(k + " ==> " + v));
}

给出这个结果：

class somepackage.Object11 ==> 2
class somepackage.Object12 ==> 1
class somepackage.Object1 ==> 2
class somepackage.Object2 ==> 1

【讨论】：

是的，您可以使用每个类都必须实现的抽象方法来从静态映射中获取自己的记录数。

【解决方案2】：

每个类中都必须有一个静态字段count。如果我们只在AbstractObject 类中有一个静态字段，它不会被继承到其他类（因为它是静态的）。

要计算每个类的对象数量，您必须使用“工厂”方法（如以下示例中的getNewInstance()）。

public abstract class AbstractObject {
  public static void main(String[] args) {
    Object1 a = Object1.getNewInstance();
    Object2 b = Object2.getNewInstance();
    Object2 c = Object2.getNewInstance();

    System.out.println("Number of Object1 instances = " + Object1.getCount());
    System.out.println("Number of Object2 instances = " + Object2.getCount());
  }
}

class Object1 extends AbstractObject {
  private static int count;

  private Object1() {
  }

  static Object1 getNewInstance() {
    count++;
    return new Object1();
  }

  static int getCount() {
    return count;
  }
}

class Object2 extends AbstractObject {
  private static int count;

  private Object2() {
  }

  static Object2 getNewInstance() {
    count++;
    return new Object2();
  }

  static int getCount() {
    return count;
  }
}

【讨论】：