Java 计算现有对象的数量

所以我正在制作一个可以创建和滚动一个骰子的骰子类，返回值和大小。我试图找出如何告诉程序已经创建了多少个，这样我就可以根据创建的数量做出不同的响应。IE我希望printDie的响应是Die Value:5（如果只有一个Die），如果有多个Die，则为Die 1 Value:5

这是到目前为止我的代码

package com.catalyse.die;

import java.util.Random;

public class Die
{
    // instance variables 
    private int myDieValue;
    private int myDieSides;
    private Random myRandom;

    // Dice Class Constructors


    public Die()
    {
        this.myDieValue = 1;
        this.myDieSides = 4;
    }


    public Die(int numSides)
    {
        if ((numSides < 4) || (numSides > 100)) {
            System.out.println("Error! You cannot have more than 100 sides or less than four!");
            System.exit(0);
        }
        else {
            myDieSides = numSides;
        }
    }

    // getter methods

    public int getDieSides()
    {
        return myDieSides;
    }


    public int getDieValue()
    {
        return myDieValue;
    }

    // setter methods

    private void setDieSides(int newNumSides)
    {
        myDieSides = newNumSides;
    }


    public void rollDie()
    {
        Random rand = new Random(); 
        int i = (rand.nextInt(myDieSides) + 1);
        myDieValue = i;
    }

public void printDie(int dieNum)
{
    if (dieNum == 1) {
        System.out.println("Die Value: "+myDieValue);
    }
    else {
        System.out.println("Die "+dieNum+" Value: "+myDieValue);
    }
}

package com.catalyse.die；
导入java.util.Random；
公共级模具
{
//实例变量
私人投资价值；
密迪赛德私人酒店；
私人随机myRandom；
//骰子类构造函数
公众死亡（）
{
这个.myDieValue=1；
这个。myDieSides=4；
}
公共骰子（整数）
{
如果（（天体数<4）| |（天体数>100））{
System.out.println（“错误！您不能有超过100条边或少于四条边！”）；
系统出口（0）；
}
否则{
myDieSides=裸体；
}
}
//吸气剂法
公共int getDieSides（）
{
返回myDieSides；
}
public int getDieValue（）
{
返回myDieValue；
}
//setter方法
私有void setDieSides（int newNumSides）
{
myDieSides=newNumSides；
}
公共无效rollDie（）
{
Random rand=新的Random（）；
int i=（兰特·奈克斯汀（myDieSides）+1）；
myDieValue=i；
}
公共无效打印模块（int dieNum）
{
如果（dieNum==1）{
System.out.println（“模具值：+myDieValue”）；
}
否则{
System.out.println（“Die”+dieNum+”值：“+myDieValue”）；
}
}

---

}使用静态成员，即“类”变量，而不是“实例”变量：

private static int count = 0;

在构造函数中：

public Die()
{
    count++;
    this.myDieValue = 1;
    this.myDieSides = 4;
}

还有一个能手：

public static int getCount() {
    return count;
}

---

在类中可以有静态字段，该字段可以在构造函数中始终递增。之所以应该是

static

，是因为类的所有实例都共享

static

字段，因此不会为创建的每个实例创建字段的本地副本

private static int counter = 0;
public Die()
{
    counter++;
    // Other stuffs
}
// Have a getter method for the counter so that you can 
// get the count of instances created at any point of time
public static int getCounter() {
    return counter;
}

然后你可以像这样在你的调用方法中调用上面的方法

void someMethodInAnotherClass() {
    int instanceCount = Die.getCounter(); // You need to call static method using the Class name
    // other stuffs.
}

使用静态变量

public class Die{
    static int dieCount = 0;

    public Die(){
        dieCount++;
    }
}

每次创建

Die

对象时，计数都会增加

public static void main(String[] args){
    Die die1 = new Die();
    Die die2 = new Die();

    int count = Die.dieCount;

}

---

查看我在应用程序中计算对象的解决方案

import java.util.Map;
import java.util.TreeMap;

public abstract class ObjectCounter {

    private static Map<String, Long> classNameCount = new TreeMap<String, Long>();

    public ObjectCounter() {
        String key = this.getClass().getName();
        if (classNameCount.containsKey(key)) {
            classNameCount.put(key, classNameCount.get(key) + 1);
        } else {
            classNameCount.put(key, 1L);
        }
    }

    public static <T extends ObjectCounter> long getCount(Class<T> c) {
        String key = c.getName();
        if (classNameCount.containsKey(key)) {
            return classNameCount.get(key);
        } else {
            return 0;
        }
    }

    public static long totalObjectsCreated() {
        long totalCount = 0;

        for (long count : classNameCount.values()) {
            totalCount += count;
        }

        return totalCount;
    }

} 

现在，所有其他类都在扩展文章类

package com.omt.factory;

public class Bio extends Article {

}

这是我们的主要课程

package com.omt.factory;

public class Main {

    public static void main(String... a) {
        Bio b = new Bio();
        Bio b1 = new Bio();
        Bio b2 = new Bio();
        Bio b3 = new Bio();
        Bio b4 = new Bio();
        com.omt.temp.Bio bio = new com.omt.temp.Bio();

        // Total Objects are created
        System.out.println("Total Objects Created By Application :" + ObjectCounter.totalObjectsCreated());
        // Get Number Of Objects created for class.
        System.out.println("[" + com.omt.temp.Bio.class.getName() + "] Objects Created :"
                + ObjectCounter.getCount(com.omt.temp.Bio.class));
        System.out.println("[" + Bio.class.getName() + "] Objects Created :" + ObjectCounter.getCount(Bio.class));
        System.out.println("[" + Maths.class.getName() + "] Objects Created :" + ObjectCounter.getCount(Maths.class));

    }

}

---

注意：Java没有解构器，因此通过使用静态字段，如果一个字段被删除，计数将不会反映此更改。您提供的信息非常好，但我必须问您，您所说的一个字段被删除到底是什么意思？因为没有析构函数，所以没有删除。我猜你的意思是，可能是垃圾收集太棒了，同样的代码，新问题。当我尝试测试这个类时，滚动骰子会给我一个nullpointerexception。模具一=新模具（）；一、rollDie（）；一、getDieValue（）；线程“main”java.lang.NullPointerException中的异常虽然这应该是另一个问题，但我会为您回答。您有2个构造函数。一个接受一个值来设置

myDieSides

，另一个不接受。尝试调用另一个，它接受一个值<代码>模具一=新模具（6）在测试的扩展版本中，我有三个骰子，一个是新骰子（5）和新骰子（99），我尝试了每一个，它们都抛出相同的异常。我建议您将其作为一个新问题发布，包括完整的错误堆栈跟踪和问题的确切场景。它需要得到应有的关注。此外，我无法从当前的场景中了解更多。这就是为什么要考虑创建一个新的问题！）当对象被取消引用时会发生什么情况，我们如何减少计数器的值？

package com.omt.factory;

public class Main {

    public static void main(String... a) {
        Bio b = new Bio();
        Bio b1 = new Bio();
        Bio b2 = new Bio();
        Bio b3 = new Bio();
        Bio b4 = new Bio();
        com.omt.temp.Bio bio = new com.omt.temp.Bio();

        // Total Objects are created
        System.out.println("Total Objects Created By Application :" + ObjectCounter.totalObjectsCreated());
        // Get Number Of Objects created for class.
        System.out.println("[" + com.omt.temp.Bio.class.getName() + "] Objects Created :"
                + ObjectCounter.getCount(com.omt.temp.Bio.class));
        System.out.println("[" + Bio.class.getName() + "] Objects Created :" + ObjectCounter.getCount(Bio.class));
        System.out.println("[" + Maths.class.getName() + "] Objects Created :" + ObjectCounter.getCount(Maths.class));

    }

}