was kann ich mit Methode10 aufrufen ohne einen Error??

okay okay, nun woher kommt denn das ganze zeug her und wie werde ich das los? getStackTrace methode10 methode9 methode8 methode7 methode6 methode5 methode4 methode3 methode2 methode1 main invoke0 invoke invoke invoke callMainMethod execute execute main main getStackTrace methode10 main invoke0 invoke invoke invoke callMainMethod execute execute main main

Nehmen wir mal eine Methodendefinition...

public static StackTraceElement[] methode7()

Sie ist public, static und erwartet einen Rückgabewert StackTraceElement Array. Du kannst also am Ende der Methodenaufrufkaskade keinen weiteren Methodenaufruf zurückgeben sondern musst einen passenden Wert finden, und das ist getStacktrace(). Alleine dadurch wird dir schon mal viel verraten. Der Stacktrace ist ein Array und vom Typ StackTraceElement. Jetzt könntest du meine Vorschlag von oben umsetzen und durch den Stacktrace iterieren und dir anzeigen lassen, was so drin ist. Ohne es jetzt genau zu wissen, denke ich mal, war der Sinn der Aufgabe, das herauszufinden und auszuprobieren.

die liste resultiert auf deinen tipps: public class Solution { public static void main(String[] args) throws Exception { //methode1(); int stacktraceLaenge = methode1().length - methode10().length + 1; } public static StackTraceElement[] methode1() { methode2(); return Thread.currentThread().getStackTrace(); } public static StackTraceElement[] methode2() { //schreib hier deinen Code methode3(); return Thread.currentThread().getStackTrace(); } public static StackTraceElement[] methode3() { //schreib hier deinen Code methode4(); return Thread.currentThread().getStackTrace(); } public static StackTraceElement[] methode4() { //schreib hier deinen Code methode5(); return Thread.currentThread().getStackTrace(); } public static StackTraceElement[] methode5() { //schreib hier deinen Code methode6(); return Thread.currentThread().getStackTrace(); } public static StackTraceElement[] methode6() { //schreib hier deinen Code methode7(); return Thread.currentThread().getStackTrace(); } public static StackTraceElement[] methode7() { //schreib hier deinen Code methode8(); return Thread.currentThread().getStackTrace(); } public static StackTraceElement[] methode8() { //schreib hier deinen Code methode9(); return Thread.currentThread().getStackTrace(); } public static StackTraceElement[] methode9() { methode10(); return Thread.currentThread().getStackTrace(); } public static StackTraceElement[] methode10() { StackTraceElement[] met = Thread.currentThread().getStackTrace(); for(StackTraceElement s : met){ System.out.println(s.getMethodName()); } return Thread.currentThread().getStackTrace(); } }

Das hier

for (StackTraceElement ste : Thread.currentThread().getStackTrace()) {
     System.out.println(ste);

war ein Vorschlag, um zu verstehen, was der Stacktrace ist. So, zur Lösung habe ich mich vorhin wohl missverständlich ausgedrückt. Du musst eine Methodenkaskade erstellen und am Ende den Stacktrace zurückgeben. Das war schon mal ganz richtig. Am Ende muss der Wert, der am Anfang erwartet wird zurückgegeben werden. 10 gibt StackTraceElement[] zurück, 9 soll das auch. Ein Aufruf von 10 ist also gleichzusetzen mit einem StackTraceElement[]. Somit machst du in 9 nichts anderes als den Methodenaufruf von 10 zurückzugeben usw.

public static StackTraceElement[] method9() {
    return method10();
}

public static StackTraceElement[] method10() {
    return Thread.currentThread().getStackTrace();
}

sorry ich weiss nicht was du meinst.. jetzt gibst du ja methode 10 zurück in methode 9. public static StackTraceElement[] methode9() { methode10(); return Thread.currentThread().getStackTrace(); } public static StackTraceElement[] methode10() { //StackTraceElement[] std = Thread.currentThread().getStackTrace(); //for(StackTraceElement s : std){ // System.out.println(s); //} return Thread.currentThread().getStackTrace(); } der int stacktraceLaenge = methode1().length - methode10().length + 1; gibt 1 aus, und was macht diese berechnung eigentlich? .length ergibt doch die zeichenketten-länge, warum rechnet man das so und nicht zB mit ++?

Dem Stacktrace wird halt jeder Methodenaufruf hinzugefügt. Rufst du 10 direkt auf, ist im Stacktrace der getStacktraceaufruf, Mainmethode und der Aufruf von Methode10, also 3 Methoden. Rufst du 1 auf, dann kaskadiest du dich hoch bis 10, dann enthält der Stacktrace hier also den Aufruf von getStacktrace, von main und die Methodenaufrufe 1-10, also 12 Einträge ( -> 12 - 3 + 1 ist dann die Berechnung). Jetzt wird der gesamte StackTrace zurückgegeben. Zuerst an 9, dann 8 bis in main. Hier wird nur die length genommen. Du könntest dir aber auch den gesamten Stacktrace wieder anzeigen lassen. Das wird irgendwann interessant, solltest du versuchen Fehler zu finden. Length minus main minus getStacktrace zeigt dir dann, wieviele Methoden aufgerufen wurden, der Stacktrace selbst welche. length ist in arrays eine public Variable, die die Größe des Arrays enthält. length() ist eine Mehode der String Klasse und gibt die Länge einer Zeichenkette zurück.

also was muss ich hier ändern damit der 10 ausdruckt? public static void main(String[] args) throws Exception { int stacktraceLaenge = methode1().length - methode10().length + 1; } public static StackTraceElement[] methode8() { //schreib hier deinen Code methode9(); return Thread.currentThread().getStackTrace(); } public static StackTraceElement[] methode9() { return methode10(); } public static StackTraceElement[] methode10() { StackTraceElement[] ass = Thread.currentThread().getStackTrace(); for(StackTraceElement s : ass){ System.out.println(s.getMethodName()); ==> wird nur für mich ausgedruckt } return Thread.currentThread().getStackTrace(); }

Oben hab ich dir doch schon Methode 9 und 10 hingeschrieben. 1 - 9 musst du nur so wie 9 machen 1 und 2 also dann:

public static StackTraceElement[] methode1() {
    return methode2();
}

public static StackTraceElement[] methode2() {
    return methode3();
}