Methodenaufrufe zählen

  • Themenstarter Themenstarter tanye
  • Beginndatum Beginndatum
T

tanye

Gast
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:
 
^^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 ?
 
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?
 
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" ...
 
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

Java: 
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
 
Java: 
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...
 
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.
Etwas generisches, sprich automatisches gibt's aber nicht.

Es sei denn Du hast etwas so banales wie

Java: 
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
Zum Vergrößern anklicken....

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
 
Java: 
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) ));
                                        }

	 
	}
 
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.
 
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.
Zum Vergrößern anklicken....

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 -.-
 
du erstellst dir ne Klassenvariable
Java: 
static int ichZaehleDieMethodenaufrufe

und jetzt ergänst du einfach in jeder Methode am Anfang oder Ende
Java: 
ichZaehleDieMethodenaufrufe++;
und zum Schluss in deine Main-Methode schreibst du rein:
Java: 
System.out.println("Aufrufe: " +  ichZaehleDieMethodenaufrufe);
 
Zuletzt bearbeitet:
WIaimy hat gesagt.:
du erstellst dir ne Klassenvariable
Java: 
int ichZaehleDieMethodenaufrufe

und jetzt ergänst du einfach in jeder Methode am Anfang oder Ende
Java: 
ichZaehleDieMethodenaufrufe++;
und zum Schluss in deine Main-Methode schreibst du rein:
Java: 
System.out.println("Aufrufe: " +  ichZaehleDieMethodenaufrufe);
Zum Vergrößern anklicken....

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 ...
 
tanye hat gesagt.:
hab ich getan ... wär auch super gewesen wenn das geklappt hätte ... aber ich krieg iwas mit 42000 raus ^^
Zum Vergrößern anklicken....

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.
 
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.
Java: 
public static void main(String[] args) {

zaehler = 0;

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

aufruf();
zaehler++;

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

oder so
Java: 
private static int zaehler = 0;

public void aufruf() {
 zaehler++;
 usw.
 
XHelp hat gesagt.:
@asdasdjk, was glaubst du, wann das Programm aus einer
Code: 
for(;;)
-Schleife springen wird?
Zum Vergrößern anklicken....

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.
 
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.
Zum Vergrößern anklicken....

Ach ... klar ... Ok dann ergibts Sinn 😀 Stimmt dass kann natürlich sein ich schreibs um für jede Methode nen eigenen Zähler 😉
 
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 😉
 

Aktuelle Jobs

Neue Themen

Ähnliche Themen

Java Methodenaufrufe zählen
Antworten: 4
Methodenaufrufe zählen
Antworten: 11
Methodenaufrufe wie state maschine
Antworten: 4
Methodenaufrufe abstrakte Klassen, Interfaces
Antworten: 17
Zuweisungen und Methodenaufrufe in Bedingung der while Schleife?
Antworten: 2

Zurück
Oben