Von Datei X auf Klasse in Datei Y zugreifen!

[ven000m]

Hallo,

ich muss von einem Programm: Aufgabe23.java eine Klasse in der Zaehler.java aufrufen.

Die Zaehler.java lautet wie folgt:

public class Zaehler
{
	int stand=0;
	String name;
	
	
	
	public void reset()
	{	
		stand=0;		
	}
	
	public void erhoehe()
	{
		stand++;
	}
	
	public void print(int n)
	{
		System.out.println("Zähler ist bei:" + n);
	}
}

Aus dem Programm Aufgabe23.java versuche ich nun auf diese Datei zuzugreifen und es tut nisch. :?

Hier die Quick Sort Funktion des Hauptprogrammes wo ich jetzt die Zaehler Methoden aufrufen möchte:
Das fett gedruckte klappt nicht, sowieso möchte ich hier und da mal was aufrufen aber es klappt auch nicht mit print() etc.

public class Aufgabe23
{
	static int[] Quicksort(int[] $zahlen, int i, int j)
	{
	int p = $zahlen[(i + j)/2];
	int l = i; int r = j;
	
		while (l < r)
		{
			while ($zahlen[l] < p) l++;  
			while ($zahlen[r] > p) r--;
			if (l<=r)
			{
				int temp = $zahlen[l];
				$zahlen[l] = $zahlen[r];
				$zahlen[r] = temp;
				l++; r--;
				[b]erhoehe();[/b]
			}
	
			if (i < r) Quicksort($zahlen,i,r);
			if (l < j) Quicksort($zahlen,l,j);
		}
		
		return $zahlen;
	}

Es geht jetzt nicht darum einen eleganteren Zähler zu definieren, dass ist mir auch klar aber unser Prof. will das exakt so mit dem objekt orientierten Zeug haben.


Vielen Dank für Eure Hilfe..

 

[bygones]

Methode benötigt eine Instanz von Zaehler damit ein methodenaufruf klappt

Zaehler z = new Zaehler();
z.erhoehe();

 

[ven000m]

while (l < r)
		{
			while ($zahlen[l] < p) l++;  
			while ($zahlen[r] > p) r--;
			if (l<=r)
			{
				int temp = $zahlen[l];
				$zahlen[l] = $zahlen[r];
				$zahlen[r] = temp;
				l++; r--;
				
				Zaehler z = new Zaehler();
				z.erhoehe();
				
			}
	
			if (i < r) Quicksort($zahlen,i,r);
			if (l < j) Quicksort($zahlen,l,j);
		}
		Zaehler f = new Zaehler();
		f.print();

Hallo,

jo danke, aber jetzt führt er immer die gesamte Klasse aus und gibt in der Schleife bereits das von print() mehrfach aus. Ebenso erhöht er es nicht:

public class Zaehler
{
	int stand=0;
	String name;
	
	
	
	public void reset()
	{	
		stand=0;		
	}
	
	public void erhoehe()
	{
		stand=stand+1;
	}
	
	public void print()
	{
		System.out.println("Zähler ist bei: " + stand);
	}
}

 

[Griffin]

Die Instanzierung solltest du außerhalb der While-Schleife machen, da immer wieder ein neues Objekt mit den Startwerten erstellt wird.

//Man braucht nur eine Instanz (in diesem Fall)
Zaehler z = new Zaehler();

while (l < r)
      {
         while ($zahlen[l] < p) l++; 
         while ($zahlen[r] > p) r--;
         if (l<=r)
         {
            int temp = $zahlen[l];
            $zahlen[l] = $zahlen[r];
            $zahlen[r] = temp;
            l++; r--;
            
            z.erhoehe();
            
         }
   
         if (i < r) Quicksort($zahlen,i,r);
         if (l < j) Quicksort($zahlen,l,j);
      }
      Zaehler f = new Zaehler();
      f.print();

 

[ven000m]

Hallo,

leider habe ich noch immer das Problem, dass die Klasse komplett ausgeführt wird und alles aus der Zaehler.java ausgegeben wird.

	//	Man braucht nur eine Instanz (in diesem Fall) 
  		Zaehler z = new Zaehler(); 
	
		while (l < r)
		{
			while ($zahlen[l] < p) l++;  	
			while ($zahlen[r] > p) r--;
			if (l<=r)
			{
				int temp = $zahlen[l];
				$zahlen[l] = $zahlen[r];
				$zahlen[r] = temp;
				l++; r--;
				z.erhoehe();
				
			}
	
			if (i < r) Quicksort($zahlen,i,r);
			if (l < j) Quicksort($zahlen,l,j);
		}
		
		//Zaehler f = new Zaehler(); 
		z.print();

public class Zaehler
{
	int stand=0;
	String name;
	
	
	
	public void reset()
	{	
		stand=0;		
	}
	
	public void erhoehe()
	{
		stand++; 
	}
	
	public void print()
	{
		System.out.println("Zähler ist bei: " + stand);
	}
}

 

[Griffin]

Willst du das der Zähler öfter die print() methode benutzt und nicht nur einmal am schluß solltest du den befehl z.print() auch in die While-Schleife setzen:

    //   Man braucht nur eine Instanz (in diesem Fall)
        Zaehler z = new Zaehler();
   
      while (l < r)
      {
         while ($zahlen[l] < p) l++;     
         while ($zahlen[r] > p) r--;
         if (l<=r)
         {
            int temp = $zahlen[l];
            $zahlen[l] = $zahlen[r];
            $zahlen[r] = temp;
            l++; r--;
            z.erhoehe();
            //ich weiss nicht wo die Ausgabe sein soll, ich mach die mal hier
            z.print();
         }

         if (i < r) Quicksort($zahlen,i,r);
         if (l < j) Quicksort($zahlen,l,j);
      }

 

[ven000m]

Hallo,

erstmal danke für deine Antwort.

Ich habe soebend mit meinen Kommulitoden das Problem gelößt und zwar ruft sich der Quicksort ja rekursiv auf. So muss ich also nach jedem Durchgang auch damit rechnen das return auch nur einen einen zurück Springt.

Beispiel:

1 durchlauf > 2 durchlauf >n ter Durchlauf

Return bewirkt nun:

< 1. Rücksprung < 2 Rücksprung < n ter Rücksprung

D.h nach n Rücksprüngen bin ich also erst wieder im Hauptprogramm, so hat es direkt auch nichts damit zu tun, wenn ich es hinter die while bzw. for Schleife setze, dass es dauernd ausgegeben wurde.


Mein lauffähiges Programm ist nun folgendes, teste es mal.. ;-) Quicksort ist aber sehr langsam strange eigentlich?

 import java.io.*;
import java.util.*;

							

public class Aufgabe23
{
	
	static int[] Quicksort(int[] $zahlen, int i, int j,Zaehler zaehler)
	{
	int p = $zahlen[(i + j)/2];
	int l = i; int r = j;
	
	zaehler.erhoehe();
	
		while (l < r)
		{
			while ($zahlen[l] < p) l++;  	
			while ($zahlen[r] > p) r--;
			if (l<=r)
			{
				int temp = $zahlen[l];
				$zahlen[l] = $zahlen[r];
				$zahlen[r] = temp;
				l++; r--;				
			}
	
			if (i < r)
			Quicksort($zahlen,i,r,zaehler);
									  
			if (l < j)
			Quicksort($zahlen,l,j,zaehler);				 
			
		}
		
				
		return $zahlen;
		
	}
	
	static int[] bubblesort(int[] $zahlen,Zaehler zaehler)
	{
		int $anzahl = $zahlen.length;
        
		int $temp;
		for (int $i = 0; $i < $anzahl; $i++)
		{
			for (int $j = 0; $j < ($anzahl - 1); $j++)
			{
				zaehler.erhoehe();
				
				if ($zahlen[$j+1] > $zahlen[$j])
				{
					$temp = $zahlen[$j];
					$zahlen[$j] = $zahlen[$j+1];
					$zahlen[$j+1] = $temp;
				}
			}
			
		}
		
		return $zahlen;    
	}
    
	static int[] insertionsort(int[] $zahlen,Zaehler zaehler)
	{
		int $anzahl = $zahlen.length;
        
		int $merker = 0, $j = 0;
		for (int $i = 0; $i < $anzahl; $i++)
		{
			$j = 0;
			while (($j < $i) && ($zahlen[$i] >= $zahlen[$j]))
				   $j++;zaehler.erhoehe();
			if ($j != $i)
			{
				$merker = $zahlen[$i];
				for (int $o = $i; $o > $j; $o--)
					$zahlen[$o] = $zahlen[$o-1];
				$zahlen[$j] = $merker;
			}
		}
                        
		return $zahlen;    
	}    

	static int[] selectionsort(int[] $zahlen,Zaehler zaehler)
	{
		int $anzahl = $zahlen.length;
        
		int $i, $j, $pos, $min;
		for ($i = 0; $i < ($anzahl-1); $i++)
		{
			$pos = $i;
			$min = $zahlen[$i];
			for ($j = $i + 1; $j < $anzahl; $j++)
			{   
				zaehler.erhoehe();
				if ($zahlen[$j] < $min)
				{
					$pos = $j;
					$min = $zahlen[$j];
				}
			}
			$zahlen[$pos] = $zahlen[$i];
			$zahlen[$i] = $min;
		}
                        
		return $zahlen;    
	}    
    
	public static void main(String[] args) throws IOException
	{
		
		int $antwort=0;
	    
		
		BufferedReader din = new BufferedReader(new InputStreamReader(System.in));
   
   do{		
		int[] $zahlen = new int[2000];
		Random r = new Random();
        
		for (int $i = 0; $i < 2000-1; $i++)
		{
			// Zufallszahl erzeugen (bis 5000)
			int num = 1 + Math.abs(r.nextInt()) % 5000;
			$zahlen[$i]=num;
			
		}
        
        
        
        
		System.out.print("Bitte wählen Sie Ihren Sortier-Algorithmus aus!\n");
		System.out.print("1 = Bubble-Sort\n");
		System.out.print("2 = Insert-Sort\n");
		System.out.print("3 = Selection-Sort\n");
		System.out.print("4 = Quick-Sort\n");
		System.out.print("Ihre Auswahl: ");
		int $sort_art = Integer.parseInt(din.readLine());
        
		long $time = System.currentTimeMillis();
		
		// Für Quick-Sort
		int erste_feld=0;
		int letzte_feld=2000-1;
		
	    // Zähler erzeugen
		Zaehler z = new Zaehler(); 
		

        
		switch ($sort_art)
		{
			case 1: $zahlen = bubblesort($zahlen,z);break;
			case 2: $zahlen = insertionsort($zahlen,z);break;
			case 3: $zahlen = selectionsort($zahlen,z);break;
			case 4: $zahlen = Quicksort($zahlen,erste_feld,letzte_feld,z);break;
			default: System.out.print("Bitte eine Zahl zwischen 1 und 3 eingeben!");
		}
        
		$time = System.currentTimeMillis() - $time;
                
		System.out.println("Sortierdauer: " + $time + " ms");
		z.print();
		z.reset();
		
		
		System.out.println("Möchten Sie wiederholen: (1)Ja    (2)Nein");
	    $antwort = Integer.parseInt(din.readLine());
		
	 }while($antwort==1);

	}
}

 

[bygones]

kommst du von new Skripsprache ?? du brauchst kein $ in java

 

[ven000m]

Hi,

ich komme aus dem PHP. 8)