Java Methodenaufrufe zählen

[schlelia]

Angenommen ich hab verschiedene Methoden:

public class test{
    private int countertest2;

    public test1(){}
    public static test2(){
        countertest2++;
    }
    ...
    public int zaehlen(String methodenName) {
        if (methodenName == "test2") return countertest2
    }
}

Mit der Methode zaehlen will ich die Anzahl der Methodenaufrufe zählen. Ich würde es jetzt so machen, dass ich für jede einzelne Methode eine eigene Zählvariable deklariere. Aber gibt es dafür auch noch eine elegantere Lösung? Und muss ich beim Zählen von Instanzmethoden etwas beachten?

 

[kneitzel]

a) Strings vergleicht man mit equals und nicht per ==.
b) Deine Methode test2 ist statisch, kann also direkt auf der Klasse aufgerufen werden. countertest2 ist nicht statisch und kann daher in test2 nicht verändert werden. Dein Code übersetzt so also nicht.

 

[schlelia]

a) Strings vergleicht man mit equals und nicht per ==.
b) Deine Methode test2 ist statisch, kann also direkt auf der Klasse aufgerufen werden. countertest2 ist nicht statisch und kann daher in test2 nicht verändert werden. Dein Code übersetzt so also nicht.

Das static in countertest2 hab ich natürlich vergessen. Aber ist das wirklich der Weg um Methodenaufrufen zu zählen?

 

[kneitzel]

Es ist ein Weg. Die Frage ist, wieso du sowas machst und was da der Hintergrund ist. Es es um das Erlernen von Java geht und da speziell um das static Keyword: ja, das wäre dann wohl die vorgesehene Lösung.

Ansonsten gibt es auch noch weitere Möglichkeiten, um da nicht den gleichen Code überall zu haben. Hier wäre z.B. AOP (Aspect Oriented Programming) denkbar. Aber wenn Du gerade mit Java anfängst, dann ist das ein Punkt, den du getrost erst einmal vergessen kannst

 

[Robert Zenz]

Aber gibt es dafür auch noch eine elegantere Lösung?

Ich gehe mal davon aus dass es eine Uebungsaufgabe ist. Wenn das keine Uebungsaufgabe, ist musst du deinen genauen Anwendungsfall sagen (wie @kneitzel schon meinte).

---

Gehen wir das mal durch, nehmen wir an wir haben einen Klasse mit drei Methoden:

public class Test {
    public void doSomething1() { }
    public void doSomething2() { }
    public void doSomething3() { }
}

Wenn wir hier jetzt die Aufrufe innerhalb dieser Klasse zaehlen wollen wuerden, muessten wir drei Variablen anlegen zum zaehlen:

public class Test {
    private int doSomething1CallCounter = 0;
    private int doSomething2CallCounter = 0;
    private int doSomething3CallCounter = 0;

    public void doSomething1() {
        doSomething1CallCounter++;
    }

    public void doSomething2() {
        doSomething2CallCounter++;
    }

    public void doSomething3() {
        doSomething3CallCounter++;
    }
}

Wie wir merken, wird das sehr schnell sehr wiederholend und langweilig, desweiteren haben wir dann in unserer Klasse sehr viele Variablen herum liegen. Wir koennten zum Beispiel die Variablen zusammen fassen in ein Array:

public class Test {
    private int[] callCounter = new int[3];

    public void doSomething1() {
        callCounter[0]++;
    }

    public void doSomething2() {
        callCounter[1]++;
    }

    public void doSomething3() {
        callCounter[2]++;
    }
}

Das reduziert zwar die Variablen, aber die Verwendung ist jetzt nicht mehr so toll (welche Methode hat Index 2?). Wir koennten dann noch Konstanten mit Name und Index anlegen, aber dann sind wir wieder zurueck bei vielen Variablen. Eine Map waere eine bessere Loesung, da wir dann per Namen auf die Zahlen zugreifen koennten. Der Nachteil ist, dass wir dann einen Integer verwenden muessen anstelle eines ints, was die Handhabung etwas erschwert. Daher werden wir uns eine Methode zum zaehlen anlegen:

public class Test {
    private Map<String, Integer> callCounters = new HashMap<>();

    public void doSomething1() {
        countCall("doSomething1");
    }

    public void doSomething2() {
        countCall("doSomething2");
    }

    public void doSomething3() {
        countCall("doSomething3");
    }
    
    private void countCall(String methodName) {
        Integer callCounter = callCounters.get(methodName):
        
        if (callCounter == null) {
            callCounter = Integer.valueOf(0);
        }
        
        callCounter = Integer.valueOf(callCounter.intValue() + 1);
        
        callCounters.put(methodName, callCounter);
    }
}

Ist relativ mehr geworden (ja, Teile davon wuerde der Compiler automatisch machen mit Boxing/Autoboxing, aber ich mache so etwas nicht, verklagt mich). Der Vorteil hier ist dass wir sehr einfach neue Methoden hinzunehmen koennen zum zaehlen, wir muessen einfach nur die Methode aufrufen. Der Nachteil ist, dass wir den Methodennamen duplizieren, wenn wir die Methode einmal umbenennen, koennten wir den Aufruf vergessen. Fuer eine Ubuengsaufgabe waere eine solche Loesung aber absolut ausreichend.

Wenn man auch nicht den Methodennamen im Aufruf warten will, kann man noch per Reflection auf den aktuellen Callstack zugreifen. Da sind wir aber schon sehr tief in einer komplett anderen Thematik, aber der Vollstaendigkeit halber:

public class Test {
    private Map<String, Integer> callCounters = new HashMap<>();

    public void doSomething1() {
        countCall();
    }

    public void doSomething2() {
        countCall();
    }

    public void doSomething3() {
        countCall();
    }
    
    private void countCall(String methodName) {
        StackTraceElement[] callStackTrace = Thread.currentThread().getStackTrace();
        StackTraceElement callingMethod = callStackTrace[2];
        String methodName = callingMethod.getMethodName();

        Integer callCounter = callCounters.get(methodName):
        
        if (callCounter == null) {
            callCounter = Integer.valueOf(0);
        }
        
        callCounter = Integer.valueOf(callCounter.intValue() + 1);
        
        callCounters.put(methodName, callCounter);
    }
}

Das setzt natuerlich immer vorraus dass die Methode direkt aufgerufen wird.