# Attribut Werte eines Objekts mit gettern ausgeben



## WonderWoman (28. Jan 2014)

Hallo 
So ich habe eine Klasse Student angelegt und sie mit einer Main getestet. Dort sollte ich alle Attribute mit Hilfe der Setter setzen und das Objekt mittels System.out.... ausgeben.
Das funktioniert aus und sieht so aus:

//Klasse Student

```
public class Student {

	private String name;
	private String vorname;
	private int telenummer;
	private int geburtsjahr;
	
	public void setName(String name){
		this.name = name;
	}
	
	public String getName(){
		return name;
	}
	
	public void setVorname(String vorname){
		this.vorname = vorname;
	}
	
	public String getVorname(){
		return vorname;
	}
	
	public void setTelenummer(int telenummer){
		this.telenummer = telenummer;
	}
	
	public int getTelenummer(){
		return telenummer;
	}
	
	public void setGeburtsjahr(int geburtsjahr){
		this.geburtsjahr = geburtsjahr;
	}
	
	public int getGeburtsjahr(){
		return geburtsjahr;
	}
	
	public String toString(){
		String erg = "Name: " + name + " " + "Vorname: " + vorname + " " + "Tel: " + telenummer + " " + "Geburtsjahr: " + geburtsjahr;
		return erg;
	}
}
```

//Main


```
public class Main {

	public static void main(String[] args) {
		
		Student s;
		s = new Student();
		
		s.setName("Mueller");
		s.setVorname("Melanie");
		s.setTelenummer(62534);
		s.setGeburtsjahr(1986);
		
		System.out.println(s);
}
}
```

*Der Zweite Teil der Aufgabe und mein Problem ist das wir nun die Werte der Attribute des Objekts mit Hilfe der Getter ausgeben sollen?!?
Ich habe es so versucht:*

//Selbe Main wie oben plus den Code

```
Student t;
		t = new Student();
		
		t.getName();
		t.getVorname();
		t.getTelenummer();
		t.getGeburtsjahr();
		
		System.out.println(t);
```

Allerdings bekomme ich da die Ausgabe Name: null Vorname: null Tel: 0 Geburtsjahr: 0 und nicht 
Name: Mueller Vorname: Melanie Tel: 62534 Geburtsjahr: 1986. 
Irgendwie werden meine vorher gesetzten Werte nicht übernommen?!? Ich verstehe wohl etwas grundlegendes absolut falsch bei den gettern. Vielleicht kann mir ja jemand von euch helfen und mir erklären was es auf sich hat mit der Ausgabe über die Getter.

Lieben Gruss


----------



## Rock45 (28. Jan 2014)

1.
Das Objekt s und das Objekt t sind zwei unterschiedliche Objekte. Du hast dem Objekt s "Müller Melanie etc..." zugewiesen.
Dein Objekt t gibt dir deshalb überall null/0 aus, weil du auch dieses Objekt mit Werten initialisieren musst. Tust du dies nicht, wird automatisch alles mit 0 initialisiert.
 Entweder machst du das im Konstruktor oder, wie in deiner Variante, mit den setter Methoden. Sprich. Jedes neue Objekt muss auch neu befüllt werden. 

2.
Wenn du in deine Klassendefinition schaust wirst du sehen, dass deine getter Methoden einen Wert zurück liefern. Wenn du jetzt die getter nacheinander aufrufst, dann sind die Werte schon da (vorausgesetzt du hast sie richtig initialisiert, wie oben geschrieben), aber du machst mit ihnen nichts.

Der Unterschied zwischen der ersten und zweiten Teilaufgabe ist folgender.

Das Objekt s übergibst du der Methode System.out.println(); die wiederum das Objekt in Zeichenkettendarstellung ausgibt. Genau genommen wird die toString() Methode aufgerufen, die du in deiner Klasse auch definiert hast. Dort verknüpfst du die einzelnen Werte und gibst sie als String (zeichenkette) zurück, also genau das was die Methode println() als Parameter möchte.

Mit dem Objekt t kannst du das ebenfalls machen, in dem du als Parameter die Getter Methoden übergibst und diese mit dem + Operator verknüpfst. Also sprich

System.out.println("Name " + t.getName() + " Vorname " +....)


----------



## WonderWoman (28. Jan 2014)

Hey Danke fuer deine schnelle Antwort. Leider verstehe ich es aber immer noch nicht ganz.

Ich habe meiner Klasse Student den folgenden Konstruktor mitgegeben:


```
public Student (String name, String vorname, int telenummer, int geburtsjahr){
		setName("Mueller");
		setVorname("Melanie");
		setTelenummer(65432);
		setGeburtsjahr(1986);
	}
```

und außerdem meiner Main den folgenden Code


```
Student t;
		t = new Student();
		
		t.getName();
		t.getVorname();
		t.getTelenummer();
		t.getGeburtsjahr();
		
		System.out.println("Name: " + t.getName() +" "+ "Vorname: " + t.getVorname()+ " " + "Telefonnummer: " + t.getTelenummer()+" " + "Geburtsjahr: " + t.getGeburtsjahr());
```

Eclipse meckert nun an 

```
t = new Student();
```
rum. Weil der Konstruktor Student() undefiniert ist. Eclipse löst das Problem per Klick mit 


```
t = new Student(null, null, 0, 0);
```

Meine Frage ist nun, ob ich jedesmal wenn ich die Methode ueber die Getter wähle fuer einen String das Argument null und fuer ein int das Argument 0 übergeben muss?

Danke Dir!!


----------



## Big-Taylor (28. Jan 2014)

Wenn du eine Klasse schreibst, existiert immer auch ein Default-Konstruktor. Dieser wird automatisch von Java erzeugt. Dieser Konstruktor hat keine Parameter und du kannst ihn aufrufen mit:

```
Student t = new Student();
```
Wobei Student() die Konstruktor-Methode (der von Java spendierte Default-Konstruktor) ist.

Solltest du jetzt aber einen eigenen Konstruktor deklarieren, ob mit oder ohne Parameter, so existiert der von Java vorgegebene Konstruktor nicht mehr und du musst den von dir erstellten benutzen.
Da du einen Konstruktor mit Parameter gewählt hast, musst du bei der Erzeugung eines Objektes diese Parameter auch angeben, sonst meckert der Compiler.

Also nicht:

```
Student t = new Student();
```

sondern:

```
Student t = new Student(Mueller, Melanie, 65432, 1986);
```


----------



## Big-Taylor (28. Jan 2014)

Um deine unten stehende Frage konkret zu beantworten. Das was du vergessen hast, hat Eclipse nachgeholt. Da aber Eclipse nicht weiß, welche Werte die Attribute deines Objektes haben sollen, setzt er dafür Default-Werte ein. Bei primitiven Datentypen wie Integer ist das "0" und bei Refenzen "null".


----------



## WonderWoman (28. Jan 2014)

Vielen Dank für deine Hilfe, jetzt hab ich den Rest auch noch verstanden 

Lieben Gruß


----------

