# static, non-static... was denn nun & warum überhaupt



## WebOlli (25. Mai 2004)

Hallo!
Nachdem ich jetzt schon so einiges in Java programmiert habe, begreife ich immer noch nicht das Problem mit static/non-static....
Ich habe hier folgendes Proramm, dass einige zufällig erzeute Datensätze vom Typ CDatenSart in einem array per Heapsort sortiert. Der einzige Fehler, den ich bekomme, ist in der Main-funktion wenn ich den Heapsort mit der Funktion "Heap (Feldname)" aufrufen will. da sag mir der compiler irgendwas mit static, bla, bla. Was zum Teufel muss ich ändern, damit das funktioniert? und worauf genau muss ich beim Programmieren achten, um so etwas zu vermeiden?
Kann mir das jemand hier erklären?
Ach ja: sollten im Code irgendwelche konventienen verletzt oder ähnliches untypisches sein, wundert euch nicht, der stammt nämlich zu 90% von meinem Prof.!  
Vielen Dank!


```
import java.util.Random;
import java.util.Date;


public class Heapsort {
	
	void Senke(CDatenSatz[]Feld,int Vater,int Ende){
		CDatenSatz swap = Feld[Vater];
		int Sohn, SohnL, SohnR;
		int key = swap.key;
		while (true) {
			SohnL = (Vater << 1) + 1;
			if (SohnL > Ende) break;
			SohnR = SohnL + 1;
			Sohn = SohnL;
			if (SohnR <= Ende && Feld[SohnL].key < Feld[SohnR].key)
				Sohn = SohnR;
			if (Feld[Sohn].key <= key) break;
			Feld[Vater] = Feld[Sohn];
			Vater = Sohn;
		}
	Feld[Vater] = swap;
	}
	
	void Heap(CDatenSatz[] Feld) {
		if(Feld.length<=1) return;
		int Ende = Feld.length - 1;
		for(int Knoten = Ende/2; Knoten >= 0; Knoten--)
			Senke(Feld, Knoten, Ende);
		for(int Knoten=Ende; Knoten>=1; Knoten--){
			CDatenSatz swap = Feld[Knoten];
			Feld[Knoten] = Feld[0];
			Feld[0] = swap;
			Senke(Feld, 0, Knoten - 1);
		} 
	}
	
	void SenkeUp(CDatenSatz[] Feld,int Vater, int Ende) {
		CDatenSatz swap = Feld[Vater];
		int Vater0 = Vater;
		int Sohn = Vater;
		int key = swap.key;
		int SohnL, SohnR;
		while (true) {
			SohnL = (Sohn << 1) + 1;
			if (SohnL > Ende) break;
			SohnR = SohnL + 1;
			if (SohnR <= Ende) {
				if (Feld[SohnL].key < Feld[SohnR].key) {
					Feld[Sohn]=Feld[SohnR];
					Sohn = SohnR;
				} 
				else {
					Feld[Sohn] = Feld[SohnL];
					Sohn = SohnL;
				} 
			} 
			else {
				Feld[Sohn]=Feld[SohnL];
				Sohn = SohnL;
			} 
		}
		while (true) {
			if (Sohn == 0) {
				Feld[0]= swap;
				return;
			}
			Vater = (Sohn-1)/2;
			if (Feld[Vater].key < swap.key) {
				Feld[Sohn]=Feld[Vater];
				Sohn = Vater;
			} 
			else {
				Feld[Sohn]=swap;
				return;
			} 
		} 
	}
	
	void HeapUp(CDatenSatz[] Feld) {
		if(Feld.length<=1) return;
		int Ende = Feld.length - 1;
		for(int Knoten=Ende/2; Knoten>=0; Knoten--)
			Senke(Feld, Knoten, Ende);
		for(int Knoten=Ende; Knoten>=1; Knoten--) {
			CDatenSatz swap = Feld[Knoten];
			Feld[Knoten] = Feld[0];
			Feld[0] = swap;
			SenkeUp(Feld, 0, Knoten - 1);
		} 
	}
	
	public static void main (String args[]) {
			
		int elZahl=IO.readInt("Anzahl der Werte?: ");//Eingabe Feldlänge
		CDatenSatz[] Feld = new CDatenSatz[elZahl];
 		Random random = new Random();
		for (int i=0; i<elZahl; i++) { 
			//Erzeugen von Zufallszahlen
			Feld[i] = new CDatenSatz(random.nextInt());
			//negative Werte filtern
			if (Feld[i].getKey()<0) {
					int temp = Feld[i].getKey() * -1;
				Feld[i].key = temp;
			}
		//System.out.println("Erzeugtes Array: ");			
		//System.out.print( Feld[i].getKey()+" ");			
		}
		//arrayAusgeben (test);
		long timeA=System.currentTimeMillis();
		Heap(Feld);
		long timeB=System.currentTimeMillis()-timeA;
		//arrayAusgeben (test);
		System.out.println("Laufzeit: "+timeB);
	}
}

class CDatenSatz {

	int key;
	
	public CDatenSatz (int key) {
		
		this.key = key;
	}
	public int getKey() {
		return this.key;
	}
	public void setKey(int key) {
		this.key = key;
	}

}
```


----------



## Christian Fein (25. Mai 2004)

static bla bla

sagt der Compiler wirklich nicht. Er wird dir sagen das du aus einer Statischen Methode nur eine Statische Methode aufrufen kannst, und keine Membermethode.

Wenn du anstatt static bla bla zu schreiben, die Fehlermeldung im genauen Wortlaut hier gepostet hättest dann hätte ich dir die Antwort geben können ohne in den Code zu schauen.

Du rufst die Methode Heap() auf. Diese Methode ist aber einer Instanz der Klasse zugehörig und nicht der Klasse selber.

Ich könnte dir jetzt raten deine Anwendung so umzuschreiben das Heap() eine statische Methode ist, das werde ich nicht machen, denn das währe Grausames OOP Design.

Du solltest deine Anwendung so umschreiben das in der Main-Methode nicht mehr als eine instanzierung und dann nur noch 2-3 Methoden aufrufe stehen. Sprich sämtliche Logic in die Klasse kapseln.

Das heisst wenn deiner Sotierer Objecte von CDatensatz sotieren soll, dann verpass ihm eine Methode sort() (Wo wir gerade dabei sind. 
offizielle Java-Konvention damit wird der Code lesbarer und professioneller
Klassennamen Gross:
   CDataSorter 
Variablennamen klein
   CDataSorter sorter = new CDataSorter();
Methoden klein:
   sorter.sort(feld);

Geh bei deinem Programm davon aus das du den Sorter später wieder nutzen willst. Gleichzeitig nenne deine Methode so das es ein Sinn ergibt. Wenn ein Aufruf von Heap() sotieren soll dann nenne die Methode sort();

```
public static void main(String[] args) {
    CDatenSatz[] data =  { new CDatenSatz[1], new CDatenSatz[2] };
    data = new CDataSorter().sort(data);
}
```

Dann benenne Heap in sort um, bennnene die anderen Methoden wie die Konvention in kleinschrift um dann geht das auch.

grüsse.

PSu solltest dir Zudem nochmal OOP ein bischen anlesen. Insbesondere was genau der Unterschied zwischen Instanzen und Klassen sind.


----------



## Snape (25. Mai 2004)

> _Original geschrieben von WebOlli _
> *Hallo!
> Nachdem ich jetzt schon so einiges in Java programmiert habe, begreife ich immer noch nicht das Problem mit static/non-static....
> Ich habe hier folgendes Proramm, dass einige zufällig erzeute Datensätze vom Typ CDatenSart in einem array per Heapsort sortiert. Der einzige Fehler, den ich bekomme, ist in der Main-funktion wenn ich den Heapsort mit der Funktion "Heap (Feldname)" aufrufen will. da sag mir der compiler irgendwas mit static, bla, bla. Was zum Teufel muss ich ändern, damit das funktioniert? und worauf genau muss ich beim Programmieren achten, um so etwas zu vermeiden?
> ...




1) Schnapp Dir ein Anfängerbuch und lies mal nach, was static bedeutet

2) public static void main(...) sollte m.E. nur als Programmstart verwendet werden. Jegliche weitere Funktionalität gehört in die entsprechenden Klassen, Konstruktoren und Methoden. Dann würde Dein Problem gar nicht auftreten. Denn: Innerhalb einer static Methode hast Du nur Zugriff auf andere static Methoden und Variablen. Im Code wird jedoch in der main(...) auf Methoden zugegriffen, die nicht static sind, -> Compilerfehlermeldung

3) Schönen Gruß an den Prof: Variablennamen beginnen mit einem Kleinbuchstaben. Nur Klassennamen beginnen mit einem Großbuchstaben, und Konstanten werden komplett in großen Buchstaben deklariert.


----------



## WebOlli (25. Mai 2004)

*Re: Re: static, non-static... was denn nun & warum überhaupt*



> _Original geschrieben von Snape _
> *
> 3) Schönen Gruß an den Prof: Variablennamen beginnen mit einem Kleinbuchstaben. Nur Klassennamen beginnen mit einem Großbuchstaben, und Konstanten werden komplett in großen Buchstaben deklariert.
> *



das ist mir klar... und damit ihr das nicht mir anlastet, hatte ich's ja extra erwähnt...

Auf jeden Fall Danke für die Tipps!
....auch wenn ihr mein mühsam angeeignetes Java-Wissen ganzschön nieder macht :-(


----------



## Christian Fein (25. Mai 2004)

*Re: Re: Re: static, non-static... was denn nun & warum überhaupt*



> _Original geschrieben von WebOlli _
> *das ist mir klar... und damit ihr das nicht mir anlastet, hatte ich's ja extra erwähnt...
> 
> Auf jeden Fall Danke für die Tipps!
> ....auch wenn ihr mein mühsam angeeignetes Java-Wissen ganzschön nieder macht :-( *



Hey, mann fängt irgendwo immer an.

Und wäre es dir lieber wir würden lieber nur Ja & Amen sagen, obwohl wir sehen das 
du auf der falschen Färte bist?
Das sollte kein Kommentar sein aller: Ach geh weg, und lies nochmal ...

Sondern eher in der Richtung:
Du hast da was noch nicht ganz verstanden. Ich könnte es jetzt versuchen dir zu erklären, aber dann würde ich genauso viel schreiben müssen wie das was der Author des Buches schon geschrieben hat.

PS: Richte das bitte wirklich an deinen Prof aus, das seine Benennung und Konvention allen offiziellen Java Standards widerspricht.


----------



## Snape (25. Mai 2004)

*Re: Re: Re: static, non-static... was denn nun & warum überhaupt*



> _Original geschrieben von WebOlli _
> *das ist mir klar... und damit ihr das nicht mir anlastet, hatte ich's ja extra erwähnt...
> 
> Auf jeden Fall Danke für die Tipps!
> ....auch wenn ihr mein mühsam angeeignetes Java-Wissen ganzschön nieder macht :-( *



Das übliche Problem eben. Viele Bücher sind mit fehlerhaftem und/oder suboptimalem Code "gesegnet". Dazu fehlen oftmals Erklärungen zu den einfachen Dingen. Deshalb ist das Lernen einer Programmiersprache autodidaktisch anhand eines oder mehrerer Bücher weder einfach noch zwangsläufig richtig.
(Dein Prof scheint mir auch einer aus dieser Kategorie zu sein ;-) Ein Mann der Praxis würde es jedenfalls besser machen...)


----------



## Christian Fein (25. Mai 2004)

*Re: Re: Re: Re: static, non-static... was denn nun & warum überhaupt*



> _Original geschrieben von Snape _
> *Das übliche Problem eben. Viele Bücher sind mit fehlerhaftem und/oder suboptimalem Code "gesegnet". Dazu fehlen oftmals Erklärungen zu den einfachen Dingen. Deshalb ist das Lernen einer Programmiersprache autodidaktisch anhand eines oder mehrerer Bücher weder einfach noch zwangsläufig richtig.
> (Dein Prof scheint mir auch einer aus dieser Kategorie zu sein ;-) Ein Mann der Praxis würde es jedenfalls besser machen...) *



Sorry aber da übereinstimme ich nicht mit dir. 

Ich kenne noch kein Buch das sich nicht mit Java Konventionen befasst. 
Und ich habe doch nicht wenige Zuhause rumstehen 

Das problem ist eher oftmals der Leser der solchen "nebensächlichkeiten" kein Vertrauen 
schenkt das sie wirklich wichtig sind.

aber drinn stehen tuts


----------



## Snape (25. Mai 2004)

*Re: Re: Re: Re: Re: static, non-static... was denn nun & warum überhaupt*



> _Original geschrieben von Christian Fein _
> *Sorry aber da übereinstimme ich nicht mit dir.
> 
> Ich kenne noch kein Buch das sich nicht mit Java Konventionen befasst.
> ...



Wird aber selten explizit darauf hingewiesen, auch wenn es im Code Verwendung findet. Mir fällt nur auf, dass in letzter Zeit vermehrt Beispiele gepostet werden (nicht nur hier), die die Konventionen verletzen. Schieben wir es auf die Profs? ;-)


----------



## Christian Fein (25. Mai 2004)

*Re: Re: Re: Re: Re: Re: static, non-static... was denn nun & warum überhaupt*



			
				Snape hat gesagt.:
			
		

> Wird aber selten explizit darauf hingewiesen, auch wenn es im Code Verwendung findet. Mir fällt nur auf, dass in letzter Zeit vermehrt Beispiele gepostet werden (nicht nur hier), die die Konventionen verletzen.



Ok ich habe nur OReilly, Addisson-Wesley, sAms, Sun Bücher  Kann sein das die x. Ausgabe von Java in 21 Tagen, oder Java für Dummies usw nicht drauf hinweist.

Das Buch tut es:
http://www.dpunkt.de/java/Die_Sprache_Java/Die_Sprachelemente_von_Java/22.html

Das auch:
http://www.galileocomputing.de/open...l_260000.htm#Rxxjavainsel_260000256StyleGuide




> Schieben wir es auf die Profs? ;-)



Einverstanden


----------

