Vererbung Countable mit Vererbung

[eclipseworker]

Ich möchte gerne ganz genau die Instanzen mehrere Klassen zählen, dazu habe ich folgendes mir überlegt:

public class InstanceCounter {
 
    private int instances;
    private final String nameOfCountedObject;
 
    public InstanceCounter(String objectName){
        instances=0;
        nameOfCountedObject=objectName;
    }
 
    public String getNameOfCountedObject(){
        return nameOfCountedObject;
    }


    public void increaseInstanceCounter(){
        instances++;
    }
 
    public void restetCounter(){
        instances=0;
    }
 
    public boolean noInstance(){
        return instances==0;
    }

    public void reduceInstanceCounter(){
        if(instances>0){
            instances--;
        }
    }

    public int getNumberOfInstances(){
        return instances;
    }

    /* (non-Javadoc)
     * @see java.lang.Object#toString()
     */
    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder();
        builder.append("InstanceCounter [countedObject=");
        if (nameOfCountedObject != null) {
            builder.append("nameOfCountedObject=");
            builder.append(nameOfCountedObject);
        }
        builder.append(", instances=");
        builder.append(instances);
        builder.append("]");
        return builder.toString();
    }
}

Eine Counter Klasse, verwaltet in einer Map Wrapperklasse:

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class InstanceCounterSingletonList {
 
    private Map<String, InstanceCounter> map;

    public InstanceCounterSingletonList() {
        map = new ConcurrentHashMap<String, InstanceCounter>();
    }
 
    public InstanceCounter getInstanceCounterForClass(String classname, boolean increase){
        InstanceCounter returnCounter;
        if(map.containsKey(classname)){
            returnCounter=map.get(classname);
        }else{
            returnCounter=new InstanceCounter(classname);
            map.put(classname, returnCounter);
        }
        if(increase){
            returnCounter.increaseInstanceCounter();
        }
        return returnCounter;
    }
 
    public InstanceCounter getInstanceCounterForClass(String classname){
       return getInstanceCounterForClass(classname, false);
    }

    public void increaseInstanceCounterForClass(String classname){
        getInstanceCounterForClass(classname).increaseInstanceCounter();
    }
 
    public void restetCounterForClass(String classname){
        getInstanceCounterForClass(classname).restetCounter();
    }
 
    public boolean noInstanceOfClass(String classname){
        return getInstanceCounterForClass(classname).noInstance();
    }

    public void reduceInstanceCounterForClass(String classname){
        getInstanceCounterForClass(classname).reduceInstanceCounter();
    }

    public int getNumberOfInstancesForClass(String classname){
        return getInstanceCounterForClass(classname).getNumberOfInstances();
    }
}

Man bemerke, dass ich ConcurrentHashMap genommen habe, wenn möglich soll das ganze Thread sicher sein.
Nun die Liste sollte Möglichst auch nicht doppelt vorkommen, und das Interface hat sich Singleton für sie angeboten:

/**
* Acts as a Singleton for the InstanceCounterSingletonList itself, countable things should easily
* tell their names.
*/

public interface Countable {
 
    InstanceCounterSingletonList instanceCounterList=new InstanceCounterSingletonList();
 
    public String getClassName();
 
    public static InstanceCounter createInstanceCounter(String callingName){
        return instanceCounterList.getInstanceCounterForClass(callingName, true);
    }
 
    public static InstanceCounter getInstanceCounter(String callingName){
        return instanceCounterList.getInstanceCounterForClass(callingName);
    }
 
    public static void increaseInstanceCounter(String callingName){
        instanceCounterList.increaseInstanceCounterForClass(callingName);
    }
 
    public static void restetCounter(String callingName){
        instanceCounterList.restetCounterForClass(callingName);
    }
 
    public static boolean noInstance(String callingName){
        return instanceCounterList.noInstanceOfClass(callingName);
    }

    public static void reduceInstanceCounter(String callingName){
        instanceCounterList.reduceInstanceCounterForClass(callingName);
    }

    public static int getNumberOfInstances(String callingName){
        return instanceCounterList.getNumberOfInstancesForClass(callingName);
    }
 
    public static InstanceCounter createInstanceCounter(Countable calling){
        return instanceCounterList.getInstanceCounterForClass(calling.getClassName(), true);
    }
 
    public static InstanceCounter getInstanceCounter(Countable calling){
        return instanceCounterList.getInstanceCounterForClass(calling.getClassName());
    }
 
    public static void increaseInstanceCounter(Countable calling){
        instanceCounterList.increaseInstanceCounterForClass(calling.getClassName());
    }
 
    public static void restetCounter(Countable calling){
        instanceCounterList.restetCounterForClass(calling.getClassName());
    }
 
    public static boolean noInstance(Countable calling){
        return instanceCounterList.noInstanceOfClass(calling.getClassName());
    }

    public static void reduceInstanceCounter(Countable calling){
        instanceCounterList.reduceInstanceCounterForClass(calling.getClassName());
    }

    public static int getNumberOfInstances(Countable calling){
        return instanceCounterList.getNumberOfInstancesForClass(calling.getClassName());
    }
 
    public static InstanceCounterSingletonList getCounterList(){
        return instanceCounterList;
    }
}

Das ganze funktioniert auch gut, aber ich habe 1 Problem:
Vererbung, wenn ich folgende 2 Klassen habe:

public class CountableA implements Countable
{
 
    public String getClassName(){
        return this.getClass().getName();
    }

    /**
     * Constructor for objects of class CountableA
     */
    public CountableA() {
   System.out.println(Countable.createInstanceCounter(this));
    }
}

und

public class CountableAA extends CountableA{

    /**
     * Constructor for objects of class CountableAA
     */
    public CountableAA()
    {
        super();
System.out.println(Countable.createInstanceCounter(this.getClass().getName()));
    }
}

ist der Output wenn ich ein CountableAA erstelle:

InstanceCounter [countedObject=nameOfCountedObject=CountableAA, instances=1]
InstanceCounter [countedObject=nameOfCountedObject=CountableAA, instances=2]

statt dem eigentlichen gewünschten:

InstanceCounter [countedObject=nameOfCountedObject=CountableA, instances=1]
InstanceCounter [countedObject=nameOfCountedObject=CountableAA, instances=1]

Ich weiß schon, dass irgendwie das getName sich nur um die Aufrufende Instanz kümmert, nicht um die Klasse wo es drinnen steht, aber kann man das entsprechend besser machen?
Diese ganze Möglichkeit im Interface auch direkt den String zu übergeben, gehen schon ein bisschen in diese Richtung, aber ich habe gehofft, dass ich drumherum komme die Namen hart coden zu müssen. Und vorallem was mache ich bei abstrakten Klassen? Auch kann ich es im Interface erzwingen, dass eine untere Klasse wie zum Beispiel CountableAA ihre eigenen Methoden verwenden muss?

 

[Flown]

Ich würde das eher über eine Factory machen, da das hier ein wenig gegen das SRP verstößt.
Die Factory mit den Klassen in ein package werfen, Konstruktoren auf package-private (ohne Modifier) und dann sieht das vl. so aus:

public class Test {
  
  public static void main(String... args) {
    var instance = StatisticsFactory.getInstance();
    var countA = instance.createCountableA();
    var countB = instance.createCountableB();
    System.out.println(instance);
  }
}
final class StatisticsFactory {
  private static StatisticsFactory INSTANCE = new StatisticsFactory();
  private Map<Class<?>, Integer> countings;
  
  private StatisticsFactory() {
    this.countings = new ConcurrentHashMap<>();
  }
  
  public static StatisticsFactory getInstance() {
    return INSTANCE;
  }
  
  public CountableA createCountableA() {
    return count(new CountableA());
  }
  
  public CountableB createCountableB() {
    return count(new CountableB());
  }
  
  private <T> T count(T o) {
    countings.merge(o.getClass(), 1, Integer::sum);
    return o;
  }
  
  @Override
  public String toString() {
    return countings.entrySet().stream()
        .map(e -> String.format("%s: %d", e.getKey(), e.getValue()))
        .collect(Collectors.joining("\n"));
  }
}

class CountableA {
  
  CountableA() {
  }
}

class CountableB extends CountableA {
  CountableB() {
    super();
  }
}

 

[eclipseworker]

Ich würde das eher über eine Factory machen, da das hier ein wenig gegen das SRP verstößt.

Könntest du dass genauer erklären? In welchen Bereich wird hier mehr als eine Klasse geändert?
Das ist ja das gemeinte SRP oder?

 

[eclipseworker]

Ich würde das eher über eine Factory machen, da das hier ein wenig gegen das SRP verstößt.
Die Factory mit den Klassen in ein package werfen, Konstruktoren auf package-private (ohne Modifier) und dann sieht das vl. so aus:

public class Test {
 
  public static void main(String... args) {
    var instance = StatisticsFactory.getInstance();
    var countA = instance.createCountableA();
    var countB = instance.createCountableB();
    System.out.println(instance);
  }
}
final class StatisticsFactory {
  private static StatisticsFactory INSTANCE = new StatisticsFactory();
  private Map<Class<?>, Integer> countings;
 
  private StatisticsFactory() {
    this.countings = new ConcurrentHashMap<>();
  }
 
  public static StatisticsFactory getInstance() {
    return INSTANCE;
  }
 
  public CountableA createCountableA() {
    return count(new CountableA());
  }
 
  public CountableB createCountableB() {
    return count(new CountableB());
  }
 
  private <T> T count(T o) {
    countings.merge(o.getClass(), 1, Integer::sum);
    return o;
  }
 
  @Override
  public String toString() {
    return countings.entrySet().stream()
        .map(e -> String.format("%s: %d", e.getKey(), e.getValue()))
        .collect(Collectors.joining("\n"));
  }
}

class CountableA {
 
  CountableA() {
  }
}

class CountableB extends CountableA {
  CountableB() {
    super();
  }
}

Ich habe den Code "ausgebessert" und laufen lassen:

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;

public class Test {
 
  public Test(){}
  public static void main(String[] args) {
    StatisticsFactory instance = StatisticsFactory.getInstance();
    CountableA countA = instance.createCountableA();
    CountableB countB = instance.createCountableB();
    System.out.println(instance);
  }
}
final class StatisticsFactory {
  private static StatisticsFactory INSTANCE = new StatisticsFactory();
  private Map<Class<?>, Integer> countings;
  private StatisticsFactory() {
    this.countings = new ConcurrentHashMap<>();
  }
  public static StatisticsFactory getInstance() {
    return INSTANCE;
  }
  public CountableA createCountableA() {
    return count(new CountableA());
  }
  public CountableB createCountableB() {
    return count(new CountableB());
  }
  private <T> T count(T o) {
    countings.merge(o.getClass(), 1, Integer::sum);
    return o;
  }
  @Override
  public String toString() {
    return countings.entrySet().stream()
        .map(e -> String.format("%s: %d", e.getKey(), e.getValue()))
        .collect(Collectors.joining("\n"));
  }
}

class CountableA {
  CountableA() {
  }
}

class CountableB extends CountableA {
  CountableB() {
    super();
  }
}

Der Output ist:

class CountableA: 1
class CountableB: 1

gwünscht wäre aber:

class CountableA: 2
class CountableB: 1

Da B eine Supklasse von A ist.

 

[Flown]

Das ist ja das gemeinte SRP oder?

Äh ja.

Ich habe den Code "ausgebessert" und laufen lassen:

Ist Java 10

gwünscht wäre aber:
Da B eine Supklasse von A ist.

private <T> T count(T o) {
  for(Class<?> clazz = o.getClass(); clazz.getSuperclass() != null; clazz = clazz.getSuperclass()) {
    countings.merge(clazz, 1, Integer::sum);
  }
  return o;
}

Dann sollte es gehen.

 

[eclipseworker]

Ist Java 10

Interessant, wusste ich nicht.

private <T> T count(T o) {
  for(Class<?> clazz = o.getClass(); clazz.getSuperclass() != null; clazz = clazz.getSuperclass()) {
    countings.merge(clazz, 1, Integer::sum);
  }
  return o;
}

Dann sollte es gehen.

Sehr schön. Zwei fragen:
1) Wenn die Superclass gleich null ist sind wir ohne hin schon im Objekt oder?
2) Diese Schleife iteriert also über den ganzen Vererbungsbaum bis hinauf zum Objekt oder?

 

[Flown]

1) Wenn die Superclass gleich null ist sind wir ohne hin schon im Objekt oder?

Lt. Dokumentation

Returns the Class representing the direct superclass of the entity (class, interface, primitive type or void) represented by this Class. If this Class represents either the Object class, an interface, a primitive type, or void, then null is returned. If this object represents an array class then the Class object representing the Object class is returned.

2) Diese Schleife iteriert also über den ganzen Vererbungsbaum bis hinauf zum Objekt oder?

Sozusagen