Comment compter le nombre d'instances d'une classe

Question

Quelqu'un peut-il me dire comment compter le nombre d'instances d'une classe?

Voici mon code

public class Bicycle { 

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

    //getters and setters 
    public int getGear() { 
     return gear; 
    } 
    public void setGear(int Gear) { 
     this.gear = Gear; 
    } 

    public int getSpeed() { 
     return speed; 
    } 
    public void setSpeed(int Speed){ 
     this.speed = Speed; 
    } 

    public int getSeatHeight() { 
     return seatHeight; 
    } 
    public void setSeatHeight(int SeatHeight) { 
     this.seatHeight = SeatHeight; 
    } 

    public String getColor() { 
     return color; 
    } 
    public void setColor(String Color) { 
     this.color = Color; 
    } 

}//end class 



public class Variable extends Bicycle { 

    public Variable(int gear, int speed, int seatHeight, String color) { 
     super(gear, speed, seatHeight, color); 

    } 

}//end class 


public class Tester { 

    public static void main(String args[]){ 


     Bicycle bicycle1 = new Bicycle(0, 0, 0, null); 
     bicycle1.setColor("red"); 
     System.out.println("Color: "+bicycle1.getColor()); 
     bicycle1.setSeatHeight(4); 
     System.out.println("Seat Height: "+bicycle1.getSeatHeight()); 
     bicycle1.setSpeed(10); 
     System.out.println("Speed: "+bicycle1.getSpeed()); 
     bicycle1.setGear(6); 
     System.out.println("Gear: "+bicycle1.getGear()); 

     System.out.println("");//space 

     Bicycle bicycle2 = new Bicycle(0, 0, 0, null); 
     bicycle2.setColor("black"); 
     System.out.println("Color: "+bicycle2.getColor()); 
     bicycle2.setSeatHeight(6); 
     System.out.println("Seat Height: "+bicycle2.getSeatHeight()); 
     bicycle2.setSpeed(12); 
     System.out.println("Speed: "+bicycle2.getSpeed()); 
     bicycle2.setGear(6); 
     System.out.println("Gear: "+bicycle2.getGear()); 

     System.out.println("");//space 

    }//end method 
}//end class 

La variable de classe doit être utilisé pour tenir le compte du nombre d'instances de la classe de vélos créé et la classe de testeur crée un certain nombre d'instances de la classe de bicyclette et démontre la fonctionnements de la classe Bicycle et de la variable de classe. J'ai regardé partout sur Internet et je n'arrive pas à trouver quelque chose, quelqu'un pourrait me montrer comment le faire s'il vous plaît, merci d'avance :)

Answer 1

Depuis static variables initialisées une seule fois, et ils sont partagés entre tous les cas, vous pouvez:

class MyClass { 

    private static int counter; 

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

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

En savoir plus sur static champs dans le JLS - 8.3.1.1. static Fields:

Si une champ est déclaré static, il existe exactement une incarnation du champ, quel que soit le nombre d'instances (éventuellement zéro) de la classe peut eventua Peut être créé. Un champ static, parfois appelé variable de classe, est incarné lors de l'initialisation de la classe (§12.4).

^{Notez que counter est implicitement mis à zéro}

Answer 2

pourquoi ne pas utiliser un compteur statique?

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

........ 

Answer 3

Une approche de base est de déclarer un thats champ membre numériques statiques incrémentés chaque fois que le constructeur est invoqué.

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

Answer 4

Vous avez juste besoin d'un compteur statique en classe.

public class Bicycle { 
    private static volatile int instanceCounter; 

    public Bicycle() { 
     instanceConter++; 
    } 

    public static int getNumOfInstances() { 
     return instanceCounter; 
    } 

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

Comme mentionné dans de nombreux commentaires finalize() est recommandé de ne pas utiliser donc il pourrait y avoir une autre approche pour compter les instances de bicyclette -

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

Answer 5

En outre, vous devez remplacer méthode finalize pour décrémenter le compteur

Vous devez garder à l'esprit que les variables statiques ont une portée CLASS (il n'y en a pas pour chaque instance, une seule par classe)

Ensuite, vous pouvez démontrer décrémentation exemple avec:

... 
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 

Answer 6

Pleae essayer l'outil de java

jmap -histo <PDID> 

eteint

 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