# Methoden/Klassenattribut



## Guest (2. Dez 2008)

hi, habe ein problem und zwar:

1.

folgende methode soll geschrieben werden:


Methode *Konto erstelleNeuesKonto*(Kunde kunde)
Erzeugt ein neues Konto-Objekt für den übergebenen Kunden als Kontoinhaber, legt das Konto im Array
konten ab und gibt das neue Konto zurück.

Mein Frage wenn ich die methode benennen soll, welcher name muss dann stehen Konto oder erstelleNeuesKonto.

2. problem was ist der unterschied zwischen einem klassenattribut und einem normalen atribut? mein bisherigen attribute habe ich alle so geschrieben:

public class banking{
int []konten;
	String name;
	int blz;

.
.
.
.


----------



## hdi (2. Dez 2008)

Also dieMethode heisst "erstelleNeuesKonto", und ihr ihr Rückgabewert ist ein Objekt vom Typ "Konto". 

Generell bei Methoden:

(1)public              (2) Konto                                   (3)erstelleNeuesKonto ((4)Kunde                               (5)  kunde)

1: Sichtbarkeit
2: Typ des Rückgabe-Objekts
3: Name der Methode 
4: Typ des zu übergebenden Objekts
5: Name des übergebenen Objekts innerhalb der Methode

Und der Unterscheid zwischen Klassen-Attribut und normalem Attribut...naja diese Begriffe sind immer etwas schwammig, darunter verstehen die Leute verschiedenste Dinge.

Als Klassen-Variable bezeichnet man meist statische Variablen, als (Klassen-)Attribute bezeichnet man nicht-statische Variablen (die also an ein Objekt gebunden sind).

So, wie du bisher die Attribute geschrieben hast, kannst du das auch weiter machen. Aber es ist eig. Konvention
dass man die alle "private" macht.

Ausserdem sollten Klassen-Namen immer mit einem Grossbuchstaben beginnen, das macht man halt so


----------



## Gast (2. Dez 2008)

ok danke dir^^


----------



## maki (2. Dez 2008)

> Und der Unterscheid zwischen Klassen-Attribut und normalem Attribut...naja diese Begriffe sind immer etwas schwammig, darunter verstehen die Leute verschiedenste Dinge.


Ach wirklich? 

Das wäre mir neu


----------



## hdi (2. Dez 2008)

ja denke schon. ich zB sehe gar keinen Unterschied zwischen Klassen-Attribut und Attribut.
Aber manche Leuten sehen zB auch keinen Unterschied zwischen Methode und Prozedur, und nennen beides
eine Methode. Usw... die Begriffe sind da nicht eindeutig, zumindest is das meine Erfahrung


----------



## Wildcard (2. Dez 2008)

Ein Klassen Attribut ist static.


> Aber manche Leuten sehen zB auch keinen Unterschied zwischen Methode und Prozedur, und nennen beides
> eine Methode. Usw...


Methode kommt aus der Objektorientierung und ersetzt Prozedur und Funktion.
Prozedur: kein Rückgabewert
Funktion: mit Rückgabewert


----------



## maki (2. Dez 2008)

> ich zB sehe gar keinen Unterschied zwischen Klassen-Attribut und Attribut.



 :?: 
Du hast den Unerschied doch selbst erklärt.



> Aber manche Leuten sehen zB auch keinen Unterschied zwischen Methode und Prozedur, und nennen beides und nennen beides eine Methode.


Manche Leute nennen eine Banane einen Apfel, ist aber trotzdem eine Banane... der Unterschied zwischen Apfelsine und Orange dagegen ist reine Ansichtssache.
Prozedur kenne ich in dem Zusammenhang nicht, eher "Function"  vs. "Operation", ist aber nicht so "hart" definiert wie Objektvariable und Klassenvariable.

Naja, bleibt festzuhalten das Klassenvariable vs. (Objekt/Instanz)Variable klar definiert ist, die beiden sind eindeutig, jede Re-Interpretation stellt einen Fehler dar, "schwammig" sind diese beiden sicherlich nicht.


----------



## hdi (2. Dez 2008)

Na schau da geht's los... ich hab das anders gelernt:

(Klassen-) Variablen = static
Attribut = non-static 

Das macht meiner Meinung nach auch nur so Sinn. Das dt. Wort "Attribut" impliziert finde ich auch, dass es
an ein Objekt gebunden ist. 

Und:
Methode = non-static Funktion
Prozedur = static Funktion

Das mit Methode und Prozedur hab ich irgendwo gelesen, vllt sogar Java-Insel, oder in nem c++ buch kA.


----------



## maki (2. Dez 2008)

> Na schau da geht's los... ich hab das anders gelernt:
> 
> (Klassen-) Variablen = static
> Attribut = non-static


Wieso anders?
Du wiederholst nur Wildcards Aussage.

Nachtrag: Achso meintest du das. Naja, jetzt wird es klarer was du meinst.
Aber eine Klasse ist auch ein Objekt in Java 
Lokale Variablen dagegen sind wohl klar, oder? 



> Methode = non-static Funktion
> Prozedur = static Funktion
> 
> Das mit Methode und Prozedur hab ich irgendwo gelesen, vllt sogar Java-Insel, oder in nem c++ buch kA.


Methoden sind imho immer Methoden, static oder nicht.
Die Insel ist nur was für Anfänger, sonst niemanden.


----------



## hdi (2. Dez 2008)

Attribut ist für mich nicht static, auch kein Klassen-Attribut, ich hab nich wiederholt was Wildcard sagte.
Sowas nenne ich einfach "Variable".

Ja..und naja das geht jetz ewig hin und her. Methoden sind auch für mich immer Methoden, nur sind sie
halt immer non-static, sonst nenne ich es Prozedur. Und beides sind Funktionen..
Du kennst das anders, ich sag ja: Ich hab schon des öfteren die verschiedensten Aussagen gehört, und
das bestätigt sich ja jetz hier 

Wer Recht hat, falls es das überhaupt gibt, naja is auch nich so wichtig, wenn sowieso fast jeder es 
anders kennt, bringt es auch nix wenn es was "richtiges" gbit


----------



## Wildcard (2. Dez 2008)

hdi hat gesagt.:
			
		

> Attribut ist für mich nicht static, auch kein Klassen-Attribut, ich hab nich wiederholt was Wildcard sagte.
> Sowas nenne ich einfach "Variable".
> 
> Ja..und naja das geht jetz ewig hin und her. Methoden sind auch für mich immer Methoden, nur sind sie
> halt immer non-static, sonst nenne ich es Prozedur. Und beides sind Funktionen..


Du kannst die Sachen nennen wie du magst, nur versteht dich dann keiner. Wo hast du in der JLS zum Beispiel von einer Prozedur gelesen?


----------



## hdi (2. Dez 2008)

Wie gesagt ich weiss nich genau woher ich das hab, habs mir nur gemerkt. Aber was is dann für dich eine Variable?
Nur lokale Variablen? Und alles andere sind Attribute? Ist das so verbreitet?


----------



## maki (2. Dez 2008)

Da eine Klasse in Java ein Objekt ist, kann sie doch auch Attribute haben, schliesslich ist sie der Klasse zugeordnet und hängt nicht irgendwo im Block, wie es bei lokalen Variablen der Fall ist.


----------



## maki (2. Dez 2008)

Nachtrag: Dank dem Hinweis von Wildcard auf die JLS weiss ich jetzt wie es richtig ist:

In Java gibt es (englisch)
- local variables
- instance variables
- class variables

Die Zuordnung sollte selbsterklärend sein.

Der Begriff  "member variable" kommt gar nicht vor, ein einziges vorkommen von "attribute" in diesem Kontext spezifiert nicht näher ob es sich sich um eine "instance variable" oder "class variable" handelt (seite 183 der PDF Version).

Des weiteren spricht die JLS nur von "Methods", "functions" und "procedures" gibt es da nicht(in dem hier relevanten Kontext).

Alles eindeutig.
Naja, wieder etwas dazu gelernt 

Die von mir angesprochene Unterscheidung von "functions" und "operations" ist von Eric Evans aus seinem Buch "Domain Driven Design", nicht Java spezifisch. Erstere habe keine Seiteneffekte, letztere schon, ist aber nicht auf Java gemünzt und damit "schwammig".


----------



## Gast (3. Dez 2008)

ok doch noch eine frage.

also folgender teil ist aus einer aufgabe:

Klasse Bank:
 Attribut kunden: Array vom Typ Kunde
Attribut konten: Array vom Typ Konto
Attribut name: Typ String
 Attribut blz: Typ int
 Methode: Kunde legeNeuenKundenAn(String name, String vorname)
Erzeugt ein neues Kunde-Objekt mit dem übergebenen Namen, legt es im Array kunden ab und gibt
anschließend den neuen Kunden zurück.
 Methode Konto erstelleNeuesKonto(Kunde kunde)
Erzeugt ein neues Konto-Objekt für den übergebenen Kunden als Kontoinhaber, legt das Konto im Array
konten ab und gibt das neue Konto zurück.
 Klassenattribut naechsteKundenNummer: Typ int
Dieses Klassenattribut dient als Zähler für die Kunden, die mittels der Methode
legeNeuenKundenAn() erzeugt werden, um eine eindeutige Kundennummer vergeben zu
können. Initialer Wert: 1.
 Klassenattribut naechsteKontoNummer: Typ int
Analog zu vorigem Attribut, jedoch für Konten anstatt Kunden.

so nun gehe ich ja wie folgt vor:

public class Bank {
	String [] kunden;
	int []konten;
	String name;
	int blz;
	int naechsteKundenNummer;
	int naechsteKontoNummer;

damit habe ich ja schon mal die membervariablen weg. meine frage muss ich nun setter und getter methoden machen oder zuerst die methoden aus der aufgabenstellung oder nur eins von beidem. 

P.S. Weshalb sind diese setter und getter methoden eigentlich so speziell?


----------



## hdi (3. Dez 2008)

Erstmal sind deine Arrays falsch, sie sollen nicht int bzw. String Werte haben, sondern Kunden bzw. Konten.

Die Methoden musst du natürlich anlegen, das ist ja die Logik von deinem Programm.

Zu den Gettern/Settern: 
Sie sind nur für einen einzigen Zweck da: Man macht für gewöhnlich alle Attribut "private", wie schon
weiter oben bereits erwähnt. Daran solltest du dich auch halten!
Private heisst: Die Attribute sind in anderen Klassen nicht sichtbar, man kann nicht darauf zugreifen.
(Kannstes ja mal versuchen, du kriegst nen Fehler)

Daher getter und Setter: Über diese Methoden, die dann *public* sind natürlich, kannst du aus
anderen Klassen heraus bestimmte Werte abfragen (getter) bzw. verändern (setter).

d.h. ein getter sieht immer so aus:


```
public <AttributTyp> get<AttributName>(){
     return <Attribut>;
}
```

ein setter sieht immer so aus:


```
public void set<AttributName>(<AttributTyp> <AttributName>){
      this.<AttributName> = <AttributName>
}
```

Und weil die *immer nur genau so ** aussehen (ich hoffe es ist klar, dass du das in <> natürlich durch deine spefizischen Attribute ersetzen musst), kannste dir ja jetz selbst überlegen ob sowas zB nen
Ersatz für eine Methode "legeNeuenKundenAn()" sein kann.

Du kannst genauso gut getter/setter weglassen, und alle Attribute direkt public machen. Aber
das macht man wie gesagt *nicht*, weil es ein Sicherheitsrisiko ist.

Zusammenfassung: Du brauchst alle deine Methoden, Getter und Setter können die nicht ersetzen, 
und du schreibst dir für jedes Attribut, dass du aus einer anderen Klasse LESEN willst, einen getter,
und wenn du es SCHREIBEN (verändern) willst, einen setter.

Und für Attribute, die dich in anderen Klassen nicht interessieren, brauchst du folglich weder getter
noch setter.

* PS: Wenn ich sagen immer "genau" so, meine ich damit, dass das halt Konvention ist.
Natürlich kannst du auch sowas schreiben:


```
public String getIrgendwasAberIchVerrateNichtWas(){
     return name;
}
```

oder


```
public void setName(String lustigeKleineVariable){
      name = lustigeKleineVariable;
}
```

Aber du wirst mir Recht geben, dass das so nich so geil ist


----------



## Gast (3. Dez 2008)

ok jetzt habe ich erst mal alle klassen/objekte erstellt die ich benötige. eine frage noch zu dem konstruktor. wenn ich z.b. ein attribut benötige mache ich ja nun setter und getter methoden aber für was brauche ich dann den konstruktor


----------



## hdi (3. Dez 2008)

Der Konstruktor wird aufgerufen, wenn du ein Objekt der Klasse mittels "new" anlegst.

In den Konstruktor schreibt man rein, mit welchen Attribut-Werten ein Objekt "starten" soll bei seiner
Erstellung.

zB willst du, dass wenn ein Kunde ein Konto eröffnet, er eine Willkommens-Prämie von 50€ bekommt.
Dann würdest du im Konstruktor von der Klasse Konto zB das Attribut "geldbetrag" auf 50 setzen.

Du kannst den Konstruktor auch weglassen, dann wird der Default-Konstruktor aufgerufen, der nix weiter macht als das Objekt zu erstellen und alle Attribute auf ihren Initialwert zu setzen.

Initialwerte:

int/long/double: 0
Objekte (zB String, ein Array, oder ein "Kunde" etc): null

Du willst aber nicht, dass beim Erstellen einer Instanz deiner Klasse "Bank" das Array von Kunden und Konto
"null" ist, das is ein Objekt mit dem man nicht arbeiten kann (weil es quasi nicht existiert).

D.h. im Konstruktor der Bank würdest du zB das hier machen:

```
public Bank(){

   kunden = new Kunde[100] // erstellt ein Array mit Platz für 100 kunden
   // analog zu "konten" 
}
```

In einem Satz: Der Konstruktor tut 2 Dinge: 1) das Objekt erstellen, 2) die Attribute auf die Werte setzen, die du im Konstruktor zuweist.

Auch hier gilt wieder: Das is nur Konvention, theoretisch kannste in den Konstruktor alles reinschreiben, was du willst, es ist so gesehen auch nix anders als eine Methode, die sequentiell abgearbeitet wird.


----------



## Gast (3. Dez 2008)

also in meiner aufgabenstelung steht:

"Erzeugen Sie für jede Klasse außerdem einen Konstruktor, der die unterstrichenen Attribute initialisiert, Getter-
Methoden für alle Membervariablen und Setter-Methoden für die nicht unterstrichenen."


Das heißt ich brauche in der klasse bank z.b.  nur für name und blz einen konstruktor machen.
der sieht ja dann so aus:

public Bank( String name,int blz){
		setName (name);
		setBankleitzahl (blz);
	}

brauch ich sonst noch was? weil im moemnt wird es mir noch unterringelt


----------



## maki (3. Dez 2008)

Die (Instanz-)Variablen die im Konstruktor mitgegeben werden sollen keine Setter bekommen.


----------



## hdi (3. Dez 2008)

Moment mal, du sollst die unterstrichenen initialisieren, und für die *nicht* unterstrichenen sollst du
setter machen.

D.h. es kann nicht sein, dass du im Konstruktor setter aufrufst, damit initialisierst du ja genau die falschen 
Du musst im Konstruktor die Attribute initialisieren, für die du keine Setter hast. 
Das machste halt direkt dann.

Und: Es ist zwar durchaus schön gemacht, dass du im Konstruktor setter aufrufst, aber dir ist schon klar
dass die Setter eben für andere Klassen gemacht sind? Die Klasse selber kann ja auch auf ihre private
Attribute zugreifen, sind ja ihre eigenen! Wie gesagt, ist keinesfalls falsch was du gemacht hast
(ausser halt dass du es verwechselt hast), aber nur damit dir das mit Settern und Gettern klar ist...


----------



## Gast (3. Dez 2008)

also dann einfach Name = name;
Bankleitzahl = blz;

?


----------



## hdi (3. Dez 2008)

nein, so:


```
this.blz = blz;
this.name = name;
```

Du kannst ja nur Variablen einen Wert zuweisen, was du da geschrieben hast geht nicht.

Das mit dem "this" is dir klar? Oder nicht?


----------



## Wildcard (3. Dez 2008)

hdi hat gesagt.:
			
		

> Und: Es ist zwar durchaus schön gemacht, dass du im Konstruktor setter aufrufst, aber dir ist schon klar
> dass die Setter eben für andere Klassen gemacht sind? Die Klasse selber kann ja auch auf ihre private
> Attribute zugreifen, sind ja ihre eigenen!


Besser man verwendet immer setter und getter. Ansonsten nimmst du dir viel Flexibilität bezüglich Vererbung.


----------



## hdi (3. Dez 2008)

Ich sagte ja, es ist schön gemach, aber ich hab nur Angst dass er jetz denkt er braucht die Setter und Getter
um irgendwelche Werte zu verändern innerhalb der Klasse. Wie du siehst hat er ja auch keine Ahnung wie er ganz
normal die Werte setzt


----------



## Gast (3. Dez 2008)

ok...^^

also für die unterstrichenen mache ich nun nur konstruktoren mit this.

die anderen bekommen setter und keine knstruktoren.

komischerweise taucht diese this in meinen unterlagen nur bei den setter und getter methoden auf. ich gehe mal von aus, dass es dazu dient einen wert zuzuordnen


----------



## hdi (3. Dez 2008)

du hast *einen* Konstruktor. Wenn du einen Wert zuweist im Konstruktor, ist das...nun eben eine "Zuweisung", und nicht irgendwie ein Konstruktor für den Wert.. Naja du verstehst ja schon denk ich.

this taucht meistens in Verbindung mit Settern auf, eben wegen der Konvention, wie man sie schreibt.
Du hast auch Recht, es dient dazu, einen Wert zuzuordnen.

Denn wenn du ein Attribut hast "name", und eine Methode:


```
public void setName (String name){
     name = name;
}
```

Dann weiss Java jetzt nicht, ob er dem Attribut "name" den übergebenen String "name" zuordnen soll,
oder eben andersherum. "this" ist das Objekt, auf dem die Methode aufgerufen wurde, und this.name sagt
dann eben, das es hier um das Attribut "name" geht, und nicht den übergebenen Parameter.

Wenn du den übergebenen Parameter nicht "name" nennst, sondern anders, brauchste kein this


----------



## maki (3. Dez 2008)

Besser wäre noch:

```
public void setName (final String name){ 
     this.name = name; 
}
```
Dann muss der Entwickler nicht raten und der Compiler meldet einen Fehler falls etwas nicht stimmt.


----------



## Guest (3. Dez 2008)

hdi hat gesagt.:
			
		

> this taucht meistens in Verbindung mit Settern auf, eben wegen der Konvention, wie man sie schreibt.
> Du hast auch Recht, es dient dazu, einen Wert zuzuordnen.


Nein. Und this dient auch nicht der Wertzuweisung... das macht =



			
				hdi hat gesagt.:
			
		

> Dann weiss Java jetzt nicht, ob er dem Attribut "name" den übergebenen String "name" zuordnen soll,
> oder eben andersherum. "this" ist das Objekt, auf dem die Methode aufgerufen wurde, und this.name sagt
> dann eben, das es hier um das Attribut "name" geht, und nicht den übergebenen Parameter.


Java weiss da schon ganz genau was er wem zuordnen soll und macht da auch nichts falsch. Ein "andersherum" gibt es da nicht. Wer es richtig definieren muss, bist du selbst. this ist der Zeiger auf sich (Objekt) selbst.


----------



## hdi (3. Dez 2008)

maki das versteh ich nicht, wieso ist das "final" besser? Hab das bisher immer ohne final gemacht

@Gast:
Was is das für ne Haar-Spalterei? Vllt solltest du nicht meine Sätze auseinander nehmen und den Sinn verdrehen, sondern meinen Satz im Kontext des Threads lesen. Ich denke es ist jedem Deppen klar, was ich gemeint habe


----------



## Guest (3. Dez 2008)

hdi hat gesagt.:
			
		

> maki das versteh ich nicht, wieso ist das "final" besser? Hab das bisher immer ohne final gemacht


Besser ist daran eigentlich gar nichts. Aber der Compiler würde einen Fehler melden, wenn da nur name = name stehen würde (ohne dem this.).


----------



## tfa (3. Dez 2008)

Das final verhindert, dass man das "this" vergisst.


----------



## maki (3. Dez 2008)

hdi hat gesagt.:
			
		

> maki das versteh ich nicht, wieso ist das "final" besser? Hab das bisher immer ohne final gemacht


Ist ein Idiom.

final heisst, dass man der Refrenz kein neues Object zuweisen kann, verhindert dass man versehentlich einem sog. "in" Parameter etwas zuweisst, einfach mal probieren 

Anstatt einer Warnung gibt es dann nämlich einen Error, nicht zu übersehen.


----------



## hdi (3. Dez 2008)

Ah ok. Naja ich weiss ja nicht, ob die Wahrscheinlichkeit das "final" zu vergessen geringer ist als das "this" zu vergessen


----------



## Guest (3. Dez 2008)

hdi hat gesagt.:
			
		

> @Gast:
> Was is das für ne Haar-Spalterei? Vllt solltest du nicht meine Sätze auseinander nehmen und den Sinn verdrehen, sondern meinen Satz im Kontext des Threads lesen. Ich denke es ist jedem Deppen klar, was ich gemeint habe


Ich verdrehe nicht den Sinn, sondern korrigiere nur falsche Aussagen. Es ist fakt, dass "this" nichts setzt und auch, dass Java auch bei name = name ohne this weiss was er tut (und nicht wie von dir beschrieben "vor einem Rätsel" stünde).

Und jedem "Deppen" ist das sicherlich nicht klar. Sehr wohl Leuten, die sich mit Java auskennen. Anfängern hingegen können dadurch eher was falsches lernen.


----------



## Gast (3. Dez 2008)

Hallo ich habe eine frage,ich habe eine Klasse Verbraucher 
mein Problem ist ich verstehe die bedeutung jede Zeile nicht ist eine, oder einen so nett das mir zu erklären
package berechnung;

public class Verbraucher {

	public double energiebedarf(){
            return 0.;
}
}
habe eine Klasse Verbraucher


----------



## hdi (3. Dez 2008)

doppelpost


----------



## hdi (3. Dez 2008)

Welche Zeilen verstehst du denn nicht?

@gast: Naja ich will keine Diskussion entfachen. Wenn man aber vor meiner Antwort den Post des Thread-Erstellers gelesen hat, ist mmN nach eindeutig klar, dass ich mit "zuordnen" keine Wert-Zuweisung meinte, aber lassen wir das
(Mit "Deppen" meinte ich übrigens auch nicht den Thread-Ersteller oder irgendeinen anderen Anfänger. Normales Kontext-Verständnis in einem Gespräch hat nix mit Java am Hut)

edit: Bei der name=name Zuweisung geb ich dir aber völlig Recht, das war wohl falsch gesagt. Ich dachte das Verhalten von Java bei sowas sei undefiniert. Was macht er denn in dem Fall?


----------



## maki (3. Dez 2008)

hdi hat gesagt.:
			
		

> Ah ok. Naja ich weiss ja nicht, ob die Wahrscheinlichkeit das "final" zu vergessen geringer ist als das "this" zu vergessen


Das final muss man in der Methode nur einmal setzen, bei den Parametern, das this bei jeder Zuweisung 

Das einzige was dagegen spricht das final immer zu setzen ist lesbarkeit, vielleicht noch faulheit


----------



## hdi (3. Dez 2008)

ich find das mit der Lesbarkeit sogar ganz gut - man hat sehr selten in Methoden finale Variablen.
So würde man setter noch schneller im Code erkennen wenn man viele Methoden hat, also ich denk ich
werd das ab jetzt so machen

ps: aber wenn man einmal this schreibt, denkt man wohl auch bei allen weiteren Variablen daran. Das final
musst du ja genauso oft schreiben wie das this, nur eben bei den Parametern statt im Rumpf  
D.h. wir haben mal wieder eine völlige Unwichtigkeit bis zum Ende ausdiskutiert, sehr gut  :bae:


----------



## maki (3. Dez 2008)

Wenn du nur eine Zuweisung hast, dann hast du Recht.

Da Java Call by value verwendet gilt das nicht nur für einfache Setter 

Wie gesagt, ist ein Idiom, vor allem Anfänger solltenm sich daran halten.



> edit: Bei der name=name Zuweisung geb ich dir aber völlig Recht, das war wohl falsch gesagt. Ich dachte das Verhalten von Java bei sowas sei undefiniert. Was macht er denn in dem Fall?


Eine Warnung, sonst nix, denn dann wird wirklich der Parameter dem Parameter zugewiesen, also recht wenig gemacht


----------



## Gast (3. Dez 2008)

package berechnung;//Paket Berechnung
//Klass Verbraucher im Paket Berechnung ist der Vaterklasse
public class Verbraucher {
	//erstellen einer Methode,die keinen Wert zurück gibt
	public double energiebedarf(){
            return 0.;
}
}
ich habe diese kommentare hinzugefügt, aber weiss nicht, ob sie richtig sind


----------



## hdi (3. Dez 2008)

Also die Klasse ist keine "Vaterklasse" von irgendeinem Paket. Eine Vaterklasse hast du dann, wenn du eine Klasse
machst, die davon erbt (extends). Ich meine das is nur n Begriff, jede Klasse ist sozusagen Vaterklasse, aber man spricht nur in Verbindung mit Vererbung davon.

und deine Methode gibt einen Wert zurück, nämlich einen Wert vom typ double. Genau genommen gibt sie 0.0 zurück.
(0. ist eine Kurzschreibweise für 0.0)
Das Stichwort "return" sagt dir schon, dass da irgendwas zurückgegeben wird.

Nur Methoden, wo das fehlt, geben nix zurück. Da schreibt man dann beim Rückgabewert "void", also zb:


```
public void gibtNixZurück(){
       System.out.println("Hallo, ich gebe nix zurück sondern rufe nur Seiten-Effekte hervor");
}
```


----------



## Gast (3. Dez 2008)

danke fürs Antwort, ist auch Vererbung, ich habe nur die anderen sub Klassen separat, nur dass ich es mit der return 0. nicht verstanden habe


----------



## Gast (3. Dez 2008)

so ich habe nun folgendes gemacht wie es die stellung verlangt:

public class Bank {
	private Kunde[] kunden;
	private Konto[]konten;
	private String name;
	private int blz;
	private static int naechsteKundenNummer;
	private static int naechsteKontoNummer;

	public Bank( String name,int blz){
		this.blz = blz;
		this.name = name;
	}

	public Kunde getkunden(){
		return kunden[];}
	public Konto getkonten(){
		return konten[];
	}
	public String getname(){
		return name;
	}
	public int getblz(){
		return blz;
	}
	public int getnaechsteKundenNummer(){
		return naechsteKundenNummer;
	}
	public int getnaechsteKontoNummer(){
		return naechsteKontoNummer;
	}

	public void setkunden(Kunde[]kunden){
		this.kunden = kunden;
	}
	public void setkonten(Konto[]konten){
		this.konten =konten;
	}
	public void setnaechsteKundenNummer(int naechsteKundenNummer){
		this.naechsteKundenNummer = naechsteKundenNummer;
	}
	public void setnaechsteKontoNummer(int naechsteKontoNummer){
		this.naechsteKontoNummer = naechsteKontoNummer;
	}

nun mkomme ich ja noch zu den 2 methoden :

aufgabenstellung:
 Methode: Kunde legeNeuenKundenAn(String name, String vorname)
Erzeugt ein neues Kunde-Objekt mit dem übergebenen Namen, legt es im Array kunden ab und gibt
anschließend den neuen Kunden zurück.

leider werde ich aus dieser methode nicht wirklich schlau. greift sie nun auf die klasse kunde zu die ich schon angelegt habe? oder kreiert sie  eine neue klasse kunde...


----------



## hdi (3. Dez 2008)

Es wäre gut, wenn du Code in Code-Blöcke setzt. Das geht mit (ohne die Leerzeichen beim Wort code):
[c ode] DEIN_CODE_HIER [/c ode]
Damit ist der Code leichter lesbar.

So, zu deiner Frage:

Du sollst ja einen neuen Kunden anlegen, also eine instanz der Klasse Kunde. Und nicht eine neue Klasse.
Das ist ja der Sinn von Klassen: Du kannst mit dem new-Operator Instanzen dieser Klassen erstellen,
die dann alle Attribute und Methoden haben, die du in dieser Klasse erstellt hast.

Wenn du nun also einen Kunden anlegen willst, geht das so:


```
Kunde einKunde = new Kunde();
```

beim new wird der Konstruktor der Klasse "Kunde" aufgerufen, d.h. wenn der jetzt Parameter verlangt
(zB vor-und nachnamen) dann musst du in der Klammer ihm das übergeben.

Und deine Methode 


```
legeNeuenKundenAn(String name, String vorname)
```

soll dir jetzt so einen Kunden erstellen (s.o.), dann im Array ablegen:


```
kunden[?] = einKunde;
```

und am Ende als Rückgabewert zurückgeben:


```
return einKunde;
```

So, dein Problem nun ist, dass du den Kunden nicht in das Array ablegen kannst, denn wie ich vorhin 
sagte: Objekte werden standardmässig mit "null" instantiiert, wenn du sie im Konstruktor nicht erstellst.
D.h. dein Array:

Kunde[] kunden

ist noch "null". Deshalb solltest du das im Konstruktor der Klasse "Bank" instantiieren:


```
kunden = new Kunde[100]; // hatte ich ja oben schon gepostet
```

Das "?" oben in der eckigen Klammer musst du natürlich anpassen. Es muss durch einen int-Wert ersetzt werden,
der angibt, an welche Stelle im Array du den Kunden ablegen willst.

Dazu solltest du wissen: Arrays beginnen mit dem Index 0, nicht 1.
D.h. dein 1. Element im Array ist an Stelle 0, daher würdest du den ersten Kunden auch dahin setzen:

kunden[0] = einKunde;

Allerdings musst du ja irgendwie herausfinden, wieviele Kunden schon da drin sind, um den richtigen
Platz für einen neuen Kunden zu ermitteln (du willst ja keinen alten Kunden überschreiben).

D.h. deine Methode legeNeuenKundenAn() sollte den richtigen Platz erstmal berechnen.

Herauszufinden, wieviele Elemente im Array sind, geht über eine Schleife: Du kuckst dir von Anfang an alle
Plätze im Array an, und suchst solange, bis du einen leeren Platz gefunden hast, indem noch kein Kunde drin ist.

In so einem Fall, wenn derPlatz also leer ist, ist sein Element "null", d.h. angenommen das Array hat schon 3 
Kunden, dann würde 

kunden[3]

erstmals null returnen! (wie gesagt, die Stelle 3 ist das *vierte* Element!) 
Mit null returnen meine ich, diese Abfrage:


```
(kunden[3] == null)
```
würde "true" liefern!

So, und da kannste den 
neuen Kunden jetzt reinlegen. Das mit der Schleife musst du halt jetzt noch machen.


----------



## Gast (3. Dez 2008)

ah ok das werde ich morgen früh gleich mal probiern. ich schätze mal bei konto geht es dann genauso.

thx aber für die schnelle super hilfe


----------

