Erste Schritte Verständnis Problem Konstruktoren

[MrPii2]

Hallo liebes Forum
Da ich zum nächsten Wintersemester ein Informatik Studium anstrebe, dachte ich es wäre doch an der Zeit sich schon einmal ein wenig ein zu lesen

Nach ein wenig Recherche hielt ich das Buch "Jetzt lerne ich Java 7" für geeignet, mich in die Welt des Programmierens begeben.

Von der ersten Seite an fand ich die Erklärungen ansprechend und verständlich, auf erste Versuchen mit dem klassischen "Hallo Welt" folgten stehts Erfolge. Nach nun knapp 50 Seiten schleicht sich aber das erste "Häh" ein xD

Im genaueren geht es um diesen Code, der eine Mitarbeiter-Software, zur abfrage der Mitarbeiterdaten und eine Gehaltserhöhung, ermöglichen soll. Vorrangig dient er dem Verständnis von Klassen, Objekten und Konstruktoren :

class Mitarbeiter {
  String m_name;
  String m_vorname;
  int m_gehalt;
  
   Mitarbeiter(String name, String vorname, int gehalt) {
     m_name = name;
	 m_vorname = vorname;
	 m_gehalt = gehalt;
	 }
   
   void datenAusgeben() {
     System.out.println("\n");
	 System.out.println(" Name	   : " + m_name);
	 System.out.println(" Vorname  : " + m_vorname);
	 System.out.println(" Gehalt   : " + m_gehalt + "Euro");
	 }

   void gehaltErhoehen(int erhoehung) {
     m_gehalt += erhoehung;
	 }
}

public class Mitarbeiterbeispiel {
  public static void main(String[] args) {
  Mitarbeiter billy  = new Mitarbeiter("Gates","Bill",3000);
  Mitarbeiter stevie = new Mitarbeiter("Jobs","Steve",3500);


  billy.datenAusgeben();
  stevie.datenAusgeben();
  
  
  billy.gehaltErhoehen(500);
  
  billy.datenAusgeben();
  stevie.datenAusgeben();
  
  }
}

Ich würde mir nun kein vollkommenes Fehlverstehen dieses Quellcodes vorwerfen, vielmehr kämpfe ich mit dem Konstruktor "Mitarbeiter" :

   Mitarbeiter(String name, String vorname, int gehalt) {
     m_name = name;
	 m_vorname = vorname;
	 m_gehalt = gehalt;
	 }

Zu diesem Part finde ich die Erklärungen des Buches leider etwas dürftig. Zum einen wird nur erwähnt das in den Klammern hinter dem Namen des Konstruktors, Variablen einzufügen sind, welche aus anderen Klassen zur Bearbeitung mit einbezogen werden. Jedoch scheint es mit hier so als würden sie hier erst Deklariert.

Als zweites wird mir der Sinn der Zuweisung der Klassen (z.B: m_name = name) nicht klar, da die Klassen "name", "vorname" und die Variable "gehalt", im restlichen Quellcode nicht mehr vorkommen.

Ich hoffe ich konnte den Sachverhalt verständlich darstellen, und es ist ein wenig nachvollziehbar ^^

Geht nicht zu hart mit mir um, bin wie gesagt noch ein blutiger Anfänger

Bereits im vorhinein vielen Dank!

Grüße
Pii2

 

[HimBromBeere]

Mit einem Konstruktor baust du ein Objekt auf. Jedes Objekt hat einen Satz Eigenschaften (Attribute genannt), die du zur Erzeugung des Objektes mit angibst (durch die Parameterliste im Konstruktor). Die Klasse Mitarbeiter hat z.B. die Eigenschaft name. Willst du nun einen neuen Menschen bauen, musst du ihm natürlich auch einen Namen mit auf den Weg geben:

Mensch m = new Mensch("Hans");

class Mensch {
    String _name;
    Mensch(String name) {
        _name = name;
    }
}

Damit gibst du dieser Instanz den gewünschten Namen und kannst ihn überall innerhalb der Klasse Mensch verwenden.

da die Klassen "name", "vorname" und die Variable "gehalt", im restlichen Quellcode nicht mehr vorkommen.

Das sind weiterhin keine Klassen, sondern Instanzen von Klassen, also konkrete Objekte (in dem Fall allerings recht "einfache" - nämlich Zeichenketten).

[EDIT]Damit wir nicht gleich von irgendjemandem auf die Mütze bekommen, weil wir die Java-Konventionen nicht eingehalten haben, vergessen wir auch ganz schnell, dass wir hier eine Variable _name erstellt haben und heucheln, dass wir sowas nie wieder tun [/EDIT]

 

[njans]

   Mitarbeiter(String name, String vorname, int gehalt) {
     m_name = name;
	 m_vorname = vorname;
	 m_gehalt = gehalt;
	 }

Zu diesem Part finde ich die Erklärungen des Buches leider etwas dürftig. Zum einen wird nur erwähnt das in den Klammern hinter dem Namen des Konstruktors, Variablen einzufügen sind, welche aus anderen Klassen zur Bearbeitung mit einbezogen werden. Jedoch scheint es mit hier so als würden sie hier erst Deklariert.

Als zweites wird mir der Sinn der Zuweisung der Klassen (z.B: m_name = name) nicht klar, da die Klassen "name", "vorname" und die Variable "gehalt", im restlichen Quellcode nicht mehr vorkommen.

Erst einmal etwas zum CodeStil. Wird in dem Buch vorgeschlagen Instanzvariablen mit "m_" anzugeben? Das ist nämlich nicht das, was in Java gemacht werden sollte. Da man heutzutage vernünftige Entwicklungsumgebungen hat (BlueJay, Eclipse, Netbeans) werden diese eh farblich hervorgehoben. Daher das m_ lieber weglassen.

Was da passiert ist, dass du dem Konstruktor Parameter (name, vorname und gehalt) mit gibst (das sind keine Klassen, String ist eine Klasse, das sind nur Variablenbezeichnungen).
Ein Objekt der Klasse Mitarbeiter hat interne Variablen:name, vorname, gehalt. Diese werden dann, wenn ein Objekt erstellt wird (mittels new Mitarbeiter(...)) mit werten belegt.
Wenn du einem Objekt keinen Wert zuweist, initialisiert Java es mit null (bei Zahlen entsprechend 0). Um den Zustand (die internen Variablen) von Anfang an zu setzten, übergibst du dem Konstruktor die 3 Parameter, welche dann die internen Variablen (Instanzvariablen) auf den jeweilig zugewiesenen Wert setzen:

         m_name = name;
	 m_vorname = vorname;
	 m_gehalt = gehalt;

[EDIT]
Auch das, was HimBromBeere macht, sollte man in Java nicht machen:
_variable ist nicht gewollt. Präfixe werden bei Instanzvariablen von Java in den Konventionen extra angesprochen. Die Unterstrichnotation verwenden zwar einige Betriebe und Universitäten, diese sind aber eher ein Relikt aus alten Zeiten.

[/EDIT]

 

[MrPii2]

Vielen Dank für die Hilfreichen Beiträge!

Ich versuche das ganze jetzt mal so wieder zu geben wie ich es verstanden habe

Also :

Zunächst werden erstmal die Variablen der Klasse deklariert:

class Mitarbeiter {
  String m_name;
  String m_vorname;
  int m_gehalt;

diese sind ja für alle Methoden nutzbar.

Mit dieser Zeile des Konstruktors werden zunächst Lokale Variablen innerhalb des Konstruktors "Mitarbeiter" deklariert

Mitarbeiter(String name, String vorname, int gehalt) {

Der Code

Mitarbeiter billy  = new Mitarbeiter("Gates","Bill",3000);

legt dann durch den Konstruktor ein Objekt "billy" an was durch die Werte in der Klammer folgende Zuteilung bekommt:

name = Gates
vorname = Bill
gehalt = 3000

aber da diese ja nur Lokale Variablen sind, werden sie mit

     m_name = name;
	 m_vorname = vorname;
	 m_gehalt = gehalt;

in die Membervariablen der Klasse "Mitarbeiter" geschrieben, damit die Methode "datenAusgabe" darauf zugriff hat und diese Ausgeben kann.

Hoffentlich nicht totaler Blödsinn ^^

 

[HimBromBeere]

Hoffentlich nicht totaler Blödsinn ^^

Nö, total richtig

 

[AquaBall]

PS: Gewöhn dir gleich die korrekten Variablennamen an.
Schau dir dazu an.
Das scheint in deinem Buch nicht optimal zu sein.

Underlines sind verpönt.
Präfix ist nicht nötig
Zusammengesetze Worte in CamelCase.

class Mitarbeiter {
  String nachName;
  String vorName;
  int gehalt;

  Mitarbeiter(String newNachName, String newVorName, int newGehalt) {
// Dieses 'new' mach ich halt, ist aber Geschmacksache, Es geht ums Prinzip.)
     this.nachName = newNachName;
     this.vorName = newVorName;
     this.gehalt = newGehalt;
  }
...

 

[MrPii2]

Nö, total richtig

Find ich gut

Mir bleibt dann noch eine Frage:
Wenn ich nun aber den Mitarbeiter "billy" erstellt habe:

public class Mitarbeiterbeispiel {
  public static void main(String[] args) {
  Mitarbeiter billy  = new Mitarbeiter("Gates","Bill",3000);
  Mitarbeiter stevie = new Mitarbeiter("Jobs","Steve",3500);


  billy.datenAusgeben();
  stevie.datenAusgeben();

und dieser dann in die Variablen

class Mitarbeiter {
  String m_name;
  String m_vorname;
  int m_gehalt;

geschrieben wird, müsste dieser dann nicht wieder überschrieben werden, in dem Moment wo "stevie" erstellt wird?

 

[HimBromBeere]

müsste dieser dann nicht wieder überschrieben werden, in dem Moment wo "stevie" erstellt wird?

Nö, weil stevie eine ganz andere Instanz von Mensch ist und damit auch eigene Variablen hat. Jede Instanz einer Klasse bekommt ihre eigenen Variablen.

 

[AquaBall]

Mir bleibt dann noch eine Frage:
Wenn ich nun aber den Mitarbeiter "billy" erstellt habe:
und dieser dann in die Variablen
geschrieben wird, müsste dieser dann nicht wieder überschrieben werden, in dem Moment wo "stevie" erstellt wird?

Nein, weil durch

new Mitarbeiter()

neue Instanzen erstellt werden.
Das ist der Sinn von OOP! (und von programmieren)

Die Klasse beschreibt nur ein Objekt, das du dann beliebig oft erzeugen kannst, mit jeweils eigenen Speicherbereichen und Werten.

 

[MrPii2]

OOOkay,

durch den Befehl

Mitarbeiter billy  = new Mitarbeiter("Gates","Bill",3000);

wird also das neue Object "billy" mit den o.g. Variablen in der Klasse "Mitarbeiter" erzeugt.

welches der "Mitarbeiter" also entweder das links oder rechts von dem =, bezieht sich denn nun auf die Klasse, und welches auf den Konstruktor?

Oder müssen Klassen und konstruktor immer die selben Namen tragen ?

 

[HimBromBeere]

Oder müssen Klassen und konstruktor immer die selben Namen tragen ?

Genau so is es.

wird also das neue Object "billy" mit den o.g. Variablen in der Klasse "Mitarbeiter" erzeugt.

Es wird eine neue Instanz der Klasse Mitarbeiter erstellt (

new Mitarbeiter(...)

) und diese wird mittels des Zuweisungsoperators eine Referenz zugeordnet, also ein Namen, mit der man an dieses Objekt rankommt.

 

[MrPii2]

Okay, dann sollten alle Klarheiten beseitigt sein xD

Vielen dank!

 

[Fab1]

Hier legst du eine Referenz auf den Typ Mitarbeiter mit dem Variablennamen "billy" fest. Damit du später mit dem Objekt etwas machen kannst.

Mitarbeiter billy

Und hier

new Mitarbeiter("Gates","Bill",3000);

erzeugst du eine neue Instanz/ neues Objekt der Klasse Mitarbeiter. Die Parameter werden dem Objekt übergeben.

Anfangs ist der Typ des Objektes und die erzeugte Instanz gleich, später wird sich hier mit Polymorphie etwas ändern, aber das musst du anfangs mal nicht beachten.

wird also das neue Object "billy" mit den o.g. Variablen in der Klasse "Mitarbeiter" erzeugt.

Es wird ein neues Objekt mit dem Variablennamen "billy" von der Klasse "Mitarbeiter" erzeugt und nicht in der Klasse "Mitarbeiter"

[EDIT]zu spät ;([/EDIT]

 

[njans]

OOOkay,

durch den Befehl

Mitarbeiter billy  = new Mitarbeiter("Gates","Bill",3000);

Typ VariablenNamen = ObjektDesTyps;
Das wäre hier der Aufbau.
Klassen sind in Java Typen. Dabei ist jede Klasse wie ein Bauplan, der beschreibt, wie ein Objekt von ihm auszusehen hat (Zustand, sprich die internen Variablen) und was es kann (Methoden).