Question

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

这两个模板还具有许多不同的类，例如，Object3，Object4和Object5继承自Object1和{{1} }，Object6继承自Object7。

我希望每个单独的类（Object2，Object1，...，Object2）都具有一个计数器，该计数器可以对由该类构成的实例数进行计数。

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

AbstractObject

Answer 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

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

每个扩展类的静态变量

2 个答案: