Как подсчитать количество экземпляров класса

Поскольку переменные static инициализируются только один раз и используются всеми экземплярами, вы можете:

class MyClass {

    private static int counter;

    public MyClass() {
        //...
        counter++;
    }

    public static int getNumOfInstances() {
        return counter;
    }
}

Подробнее о полях static читайте в . JLS — 8.3.1.1. статические поля:

Если поле объявлено как static, существует ровно одно воплощение поля, независимо от того, сколько экземпляров (возможно, ноль) класса может быть создано в конечном итоге. Поле static, иногда называемое переменной класса, воплощается при инициализации класса (§12.4).

^{Обратите внимание, что counter неявно устанавливается равным нулю}

Пожалуйста, попробуйте инструмент java

jmap -histo <PDID>

Выход

     num     #instances         #bytes  class name
----------------------------------------------
   1:       1105141       97252408  java.lang.reflect.Method
   2:       3603562       86485488  java.lang.Double
   3:       1191098       28586352  java.lang.String
   4:        191694       27035744  [C

Кроме того, вы должны переопределить метод finalize, чтобы уменьшить значение счетчика.

public class Bicycle {
...
    public static int instances = 0;

    {
        ++instances; //separate counting from constructor
    }
...
    public Bicycle(int gear, int speed, int seatHeight, String color) {
        gear = 0;
        speed = 0;
        seatHeight = 0;
        color ="Unknown";
    }

    @Override
    protected void finalize() {
        super.finalize();
        --instances;
    }

}

Вы должны иметь в виду, что статические переменные имеют область видимости CLASS (нет одной для каждого экземпляра, только одна для каждого класса)

Затем вы можете продемонстрировать уменьшение экземпляра с помощью:

...
System.out.println("Count:" + Bicycle.getNumOfInstances()); // 2
bicycle1 = null;
bicycle2 = null;
System.gc(); // not guaranteed to collect but it will in this case
Thread.sleep(2000); // you expect to check again after some time
System.out.println("Count again:" + Bicycle.getNumOfInstances()); // 0

почему бы не использовать статический счетчик?

public class Bicycle {

    private static int instanceCounter = 0;

    //instance variables
    public int gear, speed, seatHeight;
    public String color;

    //constructor
    public Bicycle(int gear, int speed, int seatHeight, String color) {
        gear = 0;
        speed = 0;
        seatHeight = 0;
        color ="Unknown";      
instanceCounter++;
    }

    public int countInstances(){
        return instanceCounter;
    }

........

Вам просто нужен статический счетчик в классе.

public class Bicycle {
    private static volatile int instanceCounter;

    public Bicycle() {
        instanceConter++; 
    }

    public static int getNumOfInstances() {
        return instanceCounter;
    }

    protected void finalize() {
        instanceCounter--;
    }
}

Как упоминалось во многих комментариях, finalize() не рекомендуется использовать, поэтому может быть другой подход для подсчета экземпляров Bicycle -

public class Bicycle {

    private static final List<PhantomReference<Bicycle>> phantomReferences = new LinkedList<PhantomReference<Bicycle>>();
    private static final ReferenceQueue<Bicycle> referenceQueue = new ReferenceQueue<Bicycle>();
    private static final Object lock = new Object();
    private static volatile int counter;
    private static final Runnable referenceCleaner = new Runnable() {
        public void run() {
            while (true) {
                try {
                    cleanReferences();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    };

    static {
        Thread t = new Thread(referenceCleaner);
        t.setDaemon(true);
        t.start();
    }

    private Bicycle() {
    }

    public static Bicycle getNewBicycle() {
        Bicycle bicycle = new Bicycle();
        counter++;
        synchronized (lock) {
            phantomReferences.add(new PhantomReference<Bicycle>(new Bicycle(), referenceQueue));
        }
        System.out.println("Bicycle added to heap, count: " + counter);
        return bicycle;
    }

    private static void cleanReferences() {
        try {
            PhantomReference reference = (PhantomReference) referenceQueue.remove();
            counter--;
            synchronized (lock) {
                phantomReferences.remove(reference);
            }
            System.out.println("Bicycle removed from heap, count: " + counter);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static int getNumOfBicycles() {
        return counter;
    }
}

public class BicycleTest {

    public static void main(String[] args) {
        int i = 0;
        while (i++ < 1000) {
            Bicycle.getNewBicycle();
        }
        while (Bicycle.getNumOfBicycles() > 0) {
            try {
                Thread.sleep(1000);
                System.gc(); // just a request
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

Кроме того, вы можете создать счетчик с помощью блока инициализации и статическая переменная.

class SomeClass
{
    private static int instanceCounter;
    {
         instanceCounter++;
    }
}

Блоки инициализатора копируются компилятором в каждый конструктор, поэтому вам придется написать его один раз, независимо от того, сколько конструкторов вам понадобится (как указано в приведенной выше ссылке). Блок в {} запускается каждый раз, когда вы создаете новый объект класса, и увеличивает счетчик переменной на единицу. И, конечно же, получите счетчик примерно так:

public static int getInstanceCounter()
{
    return instanceCounter;
}

или напрямую

int numOfInstances = SomeClass.instanceCounter;

Если вы не сделаете numOfInstances приватным

Один из основных подходов заключается в объявлении статического числового поля-члена, которое увеличивается при каждом вызове конструктора.

public class Bicycle {

    //instance variables
    public int gear, speed, seatHeight;
    public String color;
    public static int bicycleCount = 0;

    //constructor
    public Bicycle(int gear, int speed, int seatHeight, String color) {
        gear = 0;
        speed = 0;
        seatHeight = 0;
        color ="Unknown";
        bicycleCount++;      
    }
    ...
  }

Если вы хотите подсчитать и протестировать экземпляры на основе количества созданных объектов, вы можете использовать цикл, чтобы увидеть, что происходит на самом деле. Создайте конструктор и используйте статический счетчик

public class CountInstances {
public static int count;
public CountInstances() {
    count++;
}
public int getInstaces() {
    return count;
}
public static void main(String []args) {
    for(int i= 0; i<10; i++) {  
        new CountInstances();
    }       
    System.out.println(CountInstances.count);
  } 
}