# Methodenaufrufe zählen



## tanye (15. Jan 2011)

Hey Leutz  , 

Hab mal ne Frage : Ich habn Programm geschrieben und möchte es jetzt um folgendes ergänzen ... Im Main-Teil werden Funktionen aufrufen ... Jetzt soll ganz am Ende des Programm noch die Anzahl der Funktionsaufrufe ausgegeben werden ... also errechnet (wahrscheinlich mit einer for schleife ?) und ausgegeben ... 
Aber keine Ahnung wie ich da vorgehen muss :noe:


----------



## XHelp (15. Jan 2011)

Du machst ein Counter und machst bei jedem Aufruf +1?


----------



## tanye (15. Jan 2011)

^^ok so weit hätte ich mir das auch denken können ... aber was soll ich zählen ich hab 5 vershiedene funktionen die alle anders heißen ... wonach kann/soll ich counten ?


----------



## XHelp (15. Jan 2011)

K.a., dafür hast du ja die Aufgabenstellung. Da wird es bestimmt stehen was du zu machen hast...
Aber mal ein anderer Gedankenanstoß: mit *einem* Counter kannst du die Anzahl der Aufrufe von *einer* Methode zählen. Wieviele Counter benötigst du um für *5 verschiedene* Methoden einzeln die Aufrufe zu zählen?


----------



## tanye (15. Jan 2011)

hmm aber wieso soll ich denn 5 mal nen zähler benutzen ... ist doch iwie umständlich nicht ? kann man denn nicht eine methode schreiben mit *einer* for schleife die die anzahl der methoden im main teil zählt ? ps: in der aufgabe steht nur folgendes : "erweitern sie ihre funktion so , dass die gesamtzahl der funktionsaufrufe gezählt wird" ...


----------



## XHelp (15. Jan 2011)

Was willst du mit einer Schleife?

Dann kannst du ja auch IN der Methode den Zähler hochsetzen.


----------



## tanye (15. Jan 2011)

ein zähler ohne for ? ... sorry ich hab grad kein plan was du meinst ???:L


----------



## Sekundentakt (15. Jan 2011)

Hi,

ist das eine Hausaufgabe, oder geht's Dir um was Praktisches?
Für die Praxis würde ich an Deiner Stelle einen Logger nutzen, der innerhalb der Methode mitloggt, wenn diese aufgerufen wird.
Etwas generisches, sprich automatisches gibt's aber nicht.

Es sei denn Du hast etwas so banales wie


```
for(int i = 0; i < x; i++)
{
   myObj.doSomething();
}

//oder

while(myObj.isSomethingTrue())
{
  myObj.doSomething();
}
```

In so einem Fall kannst Du mit einem simplen Zähler arbeiten.

Grüße


----------



## Landei (15. Jan 2011)

```
public class Foo {
   private int counterBar = 0;
   private static int counterBaz = 0;
 
   public void bar(String s) {
       counterBar++;
       ...   
   }

   public static double baz(int k, String s) {
       counterBaz++;
       ...   
   }

}
```

Ist dir das zu "umständlich"? Das Problem "allgemein" zu lösen (ohne die Methoden ändern zu müssen) ist ohne AOP nicht ganz einfach. Man könnte sicher was mit DynamicProxy zusammenschrauben, aber ich glaube nicht dass dein Leerkörper sowas sehen will...


----------



## tanye (16. Jan 2011)

Sekundentakt hat gesagt.:


> Hi,
> 
> ist das eine Hausaufgabe, oder geht's Dir um was Praktisches?
> Für die Praxis würde ich an Deiner Stelle einen Logger nutzen, der innerhalb der Methode mitloggt, wenn diese aufgerufen wird.
> ...



Also wenn ich dass so mit der for Schleife mache kommt immer was raus ... immer das gleiche aber leider immer was falsches ^^Weil ansich gibt es 5 Eingaben die der User tätigen muss für 3 Methoden , aber es sind eben nur 3 Methoden ... und IN der Schleife steht dann doch nur 1 Methode drin ... also müsste da doch nur 1 rauskommen ... ps: is ne HA


----------



## XHelp (16. Jan 2011)

Zeig man dein Code... ich weiß absolut nicht, was du da mit einer for Schleife willst.


----------



## tanye (16. Jan 2011)

```
import javax.swing.JOptionPane;

public class teiler {

	public static void main (String[] args){
	
//** Eingabe der Integer a & b 		
	System.out.println("Berechnung der größten gemeinsamen Teilers zwischen a und b : ");
	String s = JOptionPane.showInputDialog("Gib a ein:");
	int a = Integer.parseInt(s);
	System.out.println("a Saved");
	
	String t = JOptionPane.showInputDialog("Geb b ein:");
	int b = Integer.parseInt(t);
	System.out.println("b Saved");
//*
	
	 
//** Ausgabe des Ergebnisses	
	System.out.println("Der größte gemeinsame Teiler zwischen a und b ist :" + ggT(a, b) ) ;
//*		

//** Eingabe von n für Fibonacci	
	System.out.println("Berechnung der n-ten Fibonacci Zahl : ");
	String u = JOptionPane.showInputDialog("Gebe n ein : ");
	int n = Integer.parseInt(u);
//*
	System.out.println ( "Die"+" "+n+". Fibonacci-Zahl ist :" + fibonacci(n));
	
//** Eingabe von a1 und b1 für die Ackermann Funktion : 
	System.out.println("Berechnung der Ackermann Funktion : ");
	String v = JOptionPane.showInputDialog("Gebe a1 ein : ");
	int a1 = Integer.parseInt(v);
	System.out.println("a1 Saved");
	
	String w = JOptionPane.showInputDialog("Gebe b1 ein :");
	int b1 = Integer.parseInt(w);
	System.out.println("b1 Saved");
//*

//** Ausgabe des Ackermann Wertes 
	System.out.println("Der entsprechende Ackermann Wert ist : " + ack (a1,b1) );
//*
	System.out.println("Anzahl der Funktionsaufrufe : " );

	                                                
	
	}
	
//** Berechnung des größten gemeinsamen Teilers :
	public static int ggT(int a ,int b){		
	if ( b == 0 ) {
         		return a ;
	               }   
	else    {
		        return ggT ( b , a%b) ;
	         }
	                                    }
//*
	
//** Berechnung der n-ten Fibonacci Zahl :	
public static int fibonacci (int n) {	

	if(n<2){		
		return n;
	       }
	else  {		
	return (fibonacci(n-1) + fibonacci(n-2));	
	      }

                                   }
//*

//** Berechnung der Ackermann Funktion : 
public static int ack (int a1 , int b1){	
	if(a1==0){
		return ( b1+ 1);
	}
	if(b1==0){
		return ( ack (a1-1,1) );
	}
	else return ( ack ((a1-1) , ack (a1,b1-1) ));
                                        }

	 
	}
```


----------



## XHelp (16. Jan 2011)

Und wo ist da die Schleife? :autsch:
Aber es ist ziemlich offensichtlich, dass du es wie von mir im 6. Post gesagt und von Landei im 9. Post gezeigt machen musst.


----------



## tanye (16. Jan 2011)

XHelp hat gesagt.:


> Und wo ist da die Schleife? :autsch:
> Aber es ist ziemlich offensichtlich, dass du es wie von mir im 6. Post gesagt und von Landei im 9. Post gezeigt machen musst.



Ich würde deine Variante gerne mal probieren ... aber was meinst du mit "in der methode den zähler hochsetzen" ? bei zählern denke ich direkt an for schleifen aber die brauch ich nicht sagst du ja ... sorry aber tu mich grad was schwer damit -.-


----------



## XHelp (16. Jan 2011)

Hat Landei doch alles geschrieben. Nur dass die Methode nicht bar und buz heißen, sondern ggT und fibonaci


----------



## WIaimy (16. Jan 2011)

du erstellst dir ne Klassenvariable

```
static int ichZaehleDieMethodenaufrufe
```

und jetzt ergänst du einfach in jeder Methode am Anfang oder Ende

```
ichZaehleDieMethodenaufrufe++;
```
und zum Schluss in deine Main-Methode schreibst du rein:

```
System.out.println("Aufrufe: " +  ichZaehleDieMethodenaufrufe);
```


----------



## tanye (16. Jan 2011)

WIaimy hat gesagt.:


> du erstellst dir ne Klassenvariable
> 
> ```
> int ichZaehleDieMethodenaufrufe
> ...



hab ich getan ... wär auch super gewesen wenn das geklappt hätte ... aber ich krieg iwas mit 42000 raus ^^ wenn ich den zähler nur in eine funktion reinstelle kommt 2 raus ... bei 2 , 27 ...


----------



## XHelp (16. Jan 2011)

tanye hat gesagt.:


> hab ich getan ... wär auch super gewesen wenn das geklappt hätte ... aber ich krieg iwas mit 42000 raus ^^



Und warum soll es falsch sein? Du berechnest ja auch die Ackermannfunktion... Außerdem ist deine Aussage ziemlich bedeutungslos, da hier die Parameter fehlen.
Ich bin mir aber ziemlich sicher, dass du jede Methode für sich zählen musst, sonst ist das ganze ja ziemlich sinnlos.


----------



## asdasdjk (16. Jan 2011)

Hochzählen kannst du entweder in dem Programmabschnitt, der den Methodenaufruf enthält, oder im Rumpf der Methode. Bei rekursiven Methoden muss es in der Methode sein.
Wenn dein Programm multi-thread ist, muss der Zugriff auf die Hilfsvariable synchronisiert werden, aber das ist es ja nicht.

```
public static void main(String[] args) {

zaehler = 0;

for (;;) {
 aufruf();
 zaehler++;
}

aufruf();
zaehler++;

System.out.println("zaehler: " + zaehler);
```

oder so
	
	
	
	





```
private static int zaehler = 0;

public void aufruf() {
 zaehler++;
 usw.
```


----------



## XHelp (16. Jan 2011)

@asdasdjk, was glaubst du, wann das Programm aus einer 
	
	
	
	





```
for(;;)
```
-Schleife springen wird?


----------



## asdasdjk (16. Jan 2011)

XHelp hat gesagt.:


> @asdasdjk, was glaubst du, wann das Programm aus einer
> 
> 
> 
> ...



keine ahnung, er wird es ja dann eh annpassen - und der computer wird nicht schmilzen 

er könnte auch einen paramter nehmen und hochzählen lassen, das muss dann aber via einem objekt geschehen, auf dem methoden aufgerufen werden. das wär'n dann wohl alle möglichkeiten.


----------



## tanye (16. Jan 2011)

XHelp hat gesagt.:


> Und warum soll es falsch sein? Du berechnest ja auch die Ackermannfunktion... Außerdem ist deine Aussage ziemlich bedeutungslos, da hier die Parameter fehlen.
> Ich bin mir aber ziemlich sicher, dass du jede Methode für sich zählen musst, sonst ist das ganze ja ziemlich sinnlos.



Ach ... klar ... Ok dann ergibts Sinn  Stimmt dass kann natürlich sein ich schreibs um für jede Methode nen eigenen Zähler


----------



## tanye (16. Jan 2011)

So bin zufrieden mit dem Ergebnis  Danke euch


----------



## WIaimy (16. Jan 2011)

Ich hab bei meiner Variable das static vergessen, keine Ahnung ob das etwas ändert aber probier es damit nochmal aus (hab es oben geändert). 
War schon spät


----------



## tanye (16. Jan 2011)

WIaimy hat gesagt.:


> Ich hab bei meiner Variable das static vergessen, keine Ahnung ob das etwas ändert aber probier es damit nochmal aus (hab es oben geändert).
> War schon spät



hehe jop hab ich schon ergänzt gehabt  danke dir auch alles funktioniert :toll:


----------

