Objektorientierte Programmierung Bis jetzt in Java primitiver Variable
Objektorientierte Programmierung
Bis jetzt in Java: primitiver <---> Variable Datentyp In Java darf man einen Datentyp selbst basteln Dieser heisst dann: Objekt. Klasse <---> variable ist eine. Variable
Es gibt jetzt also zwei verschiedene Typen: 1) primitive Datentypen 2) Klassentyp (kurz Klasse) = höherer, selbstgebastelter Datentyp
Eine Klasse ist ein Bauplan (Schablone, Objektfabrik) (anschaulich: Backform). In diesem Bauplan steht genau beschrieben, wie ein konkretes Objekt, das nach diesem Bauplan gebastelt wird, auszusehen hat.
Mit dieser Backform können dann ganz konkret z. B. Marmorkuchen gebacken werden. In der Fachsprache sagt man: Ein Objekt ist eine Instanz einer Klasse.
Beispiel:
Klasse Backform Marmorkuchen <---> Objektvariable Geburtstagskuchen von Rolf
Weiteres Beispiel:
Klasse <---> Objektvariable Fertighaus. S haus. Maier
Herr Maier will ein Fertighaus des Modelltyps Fertighaus. S (S wie super) kaufen. Die Klasse Fertighaus. S stellt einen Bauplan dar (der z. B. von einem Architekten gezeichnet wurde). An Hand dieses Bauplans wird nun an einer bestimmten Stelle der Erde (=Arbeitsspeicher) eine bestimmte Menge Raum (z. B. Bauplatz in Kirchheim Stuttgarterstr. 137) reserviert (dem man z. B. den Namen haus. Maier gibt). Dann wird dieses konkrete Stück Raum nach der Vorschrift des Bauplans "formatiert" (bearbeitet), indem dort die Fertigteile des Hauses genau nach dem Bauplan Fertighaus. S zusammengesetzt werden. Der Bauplan verlangt zum Beispiel u. a. , dass sich der Getränkekeller neben dem Schlafzimmer befindet, 10 m breit und 12 m lang ist, also eine zentrale Rolle einnimmt.
Sehr WICHTIG: Man muss unterscheiden zwischen dem Bauplan (nur eine Beschreibung) und dem konkreten Objekt (= Haus), in dem man nachher wohnen und leben kann. Zu einem Bauplan kann es mehrere Objekte geben!!
Eine Klasse enthält Daten und Methoden. Die Daten heissen Attribute, Der Sammelbegriff für Daten und Methoden ist Member (Mitglieder).
Sinn: Mit Hilfe der Methoden soll man auf die Attribute zugreifen (lesen bzw. ändern der Attribute)
Uns bereits bekannt ist die Methode main(. . . ). Eine Methode kann man als ein Unterprogramm auffassen, das bestimmte Anweisungen ausführt.
Methoden kann man systemisch als Black-Box auffassen
Input. Parameter Output. Parameter Black Box
Input - Schnittstellenkanal zahl 1 Methode: zahl 2 Minimum von zahl 1 und zahl 2 mini Output - Schnittstellenkanal
WICHTIG: Die Schnittstellenkanäle bzw. Input und Output werden hier durch Variablen realisiert.
Wenn man eine Black-Box (wie z. B. einen Fernseher) nutzen will, gibt es eine unausgesprochene Vereinbarung (Vertrag) zwischen dem Auftraggeber (Nutzer) der Black-Box und dem Auftragnehmer (Entwickler) der Black-Box.
Jeder Vertragsnehmer hat Pflichten und Rechte:
Pflicht des Entwicklers: Der Entwickler der Black-Box trägt zur Nutzung dieser dadurch bei, indem er die Funktionsweise der Black-Box garantiert (insbesondere muss der Nutzer keine Kenntnisse von den "Innereien" der Black. Box haben).
Recht des Entwicklers: Wenn der Vertragspartner (Auftraggeber) seine Pflichten nicht erfüllt, haftet der Entwickler nicht für die sich daraus ergebenden Konsequenzen.
Frage: Durch was trägt der Nutzer der Black-Box zur Nutzung dieser bei? Was muss er machen, wenn er diese nutzen will (z. B. Fernsehapparat)? Konkret: Was sind seine Pflichten?
Er muss ein Fernsehprogramm auswählen. Er muss – ganz allgemein den Input der Black-Box "füttern".
Was muss er bei der Nutzung der Methode mini also machen?
Er muss den Input-Parametern zahl 1 und zahl 2 bestimmte Werte zuweisen.
Beispiel einer Methode:
Dies ist der Datentyp des Outputs. Den Output garantiert der Entwickler. Hier ist der Aufgabenbereich des Nutzers. Er muss diese sogenannten formalen Parameter mit Werten bestücken. int mini(int zahl 1, int zahl 2){ // Hier ist der // Aufgabenbereich // des Entwicklers. Er muss // hier die dazu nötigen // Anweisungen schreiben. }
Zur besseren Vorstellung kann man sich einen möglichen Output wie folgt vorstellen:
mini(13, 2); Ein Zapfhahn wird in den Aufruf angebracht. Die Anzahl der Tropfen (bzw. der Flüssigkeit), d. h. min(13, 2) wird. . min 1 in einem Behälter (einer Variablen) mit z. B. dem Namen min 1 aufgefangen (abgespeichert).
Beispiel einer Klasse:
Angenommen, wir sind im Jahre 2789. Viele Tierarten sind schon ausgestorben und deshalb versuchen Gentechniker den Bauplan eines Hundes wieder zu konstruieren und an Hand dieses Bauplans einzelne dieser Hunde zu produzieren.
class Hund{ private String name; private double gewicht; Attributname vom Typ double Methode set. Name public void set. Name(String p. Name){ name = p. Name; Attributname vom Typ String } Name der Klasse public String get. Name(){ return(name); privater Bereich: } die Member des privaten Bereichs kann außerhalb (d. h. von // Auf nächste Folie geht es weiter einer anderen Klasse) nicht direkt, sondern nur indirekt über Methoden des public Bereichs dieser Klasse zugegriffen werden. Direkter Zugriff ist nur innerhalb der Klasse möglich. öffentlicher Bereich: Auf die Member dieses Bereichs Methode get. Name kann man jederzeit zugreifen.
public void set. Gewicht(double p. Gewicht){ gewicht = p. Gewicht; } public double get. Gewicht(){ return(gewicht); } public void bellen(){ System. out. println("u 0007"); } } Vereinbarung zwischen den Programmierern: Der erste Buchstabe eines formalen Parameters soll mit p beginnen: p wie Parameter! Methode set. Gewicht Methode get. Gewicht Methode bellen
public void set. Gewicht(double p. Gewicht){ gewicht = p. Gewicht; } public double get. Gewicht(){ return(gewicht); } public void bellen(){ System. out. println("u 0007"); } Das ASCII-Zeichen mit dem ASCII-Wert 7 bedeutet } "normalerweise" einen Alarmton. Wenn dieses Programm allerdings innerhalb der Entwicklungsumgebung Eclipse ausgeführt wird, schluckt deren Konsole den Ton des Lautsprechers und gibt ein Platzhalterzeichen aus. Deswegen kann man das Programm in der Eingabeaufforderung ("DOS-Fenster") mit Java aufrufen. Dann wird auch der Ton des Lautsprechers erzeugt.
private und public sind Bezeichner. Man nennt sie Sichtbarkeits- und Zugriffsmodifizierer
Schauen wir uns ein paar dieser Methoden genauer an:
class Hund{ private String name; private double gewicht; public void set. Name(String name = p. Name; } Der sogenannte formale Parameter ist ein Input-Parameter, weil er einen reinen Input darstellt. Dies nennt man auch call by value Typ der Methode p. Name){ Methode set. Name liefert KEINEN Output. Dies wird durch den Bezeichner void realisiert. Der Input p. Name wird dem Attribut name zugewiesen und dort abgespeichert.
class Hund{ private String name; private double gewicht; public String get. Name(){ return(name); } Methode hat keinen formalen Parameter (Input -Parameter). Dies wird durch eine "leere" Klammer realisiert. Typ der Methode return veranlasst, dass der Wert des Attributs name zurückgegeben wird und danach die Methode sofort verlassen wird. Damit sind also mehrere Rückgaben nicht möglich. Methode get. Name liefert einen Output: Wert des Attributs name. Der Output (es gibt nur einen!) wird durch den Bezeichner return veranlasst.
class Hund{ private String name; private double gewicht; public void set. Name(String p. Name){ name = p. Name; } public String get. Name(){ return(name); } // weiter wie vorher Man kann sich die Attribute einer Klasse als Speicherstellen einer Black-Box vorstellen. In einer Speicherstelle der Black-Box Fernsehapparat könnte z. B. der Sender stehen, der am Öftesten (seit Erstbenutzung des Apparats) gewählt wurde.
Bis jetzt haben wir nur den Bauplan eines Hundes gebastelt, aber noch keinen Hund erzeugt (bzw. eine Zeugung veranlasst). Wie werden ein oder mehrere Hunde nach dem Bauplan erzeugt?
public class Main. Klassen 1 { Zuerst mal etwas formales. . . public static void main(String[] args){ double my. Gewicht; String my. Name; Startklasse Fachklasse Hund myh 1; myh 1=new Hund(); Alle Klassen mit myh 1. set. Name("Goldi"); Großbuchstaben beginnen! myh 1. set. Gewicht(12); my. Name=myh 1. get. Name(); my. Gewicht=myh 1. get. Gewicht(); System. out. println("Name: "+my. Name); System. out. println("Gewicht: "+my. Gewicht); } Übrigens: } Der Name der (Haupt)Klasse - wir nennen sie in Zukunft Startklasse - in der das class Hund{ Hauptprogramm main steht, muss den // wie vorher gleichen Namen haben wie die Datei, in der } diese (Haupt)Klasse steht.
public class Main. Klassen 1 { public static void main(String[] args){ double my. Gewicht; Aus Platzgründen wurde die String my. Name; Variable mit myh 1 abgekürzt. Hund myh 1; Bitte nicht nachmachen!!!!! myh 1=new Hund(); myh 1. set. Name("Goldi"); Selbstsprechenden Namen benutzen: my. Hund 1 myh 1. set. Gewicht(12); my. Name=myh 1. get. Name(); my. Gewicht=myh 1. get. Gewicht(); System. out. println("Name: "+my. Name); System. out. println("Gewicht: "+my. Gewicht); } } class Hund{ // wie vorher }
public class Main. Klassen 1 { Die Variable myh 1 public static void main(String[] args){ wird deklariert. double my. Gewicht; Mit new wird Speicher für das jetzt String my. Name; neu angelegte Objekt reserviert. Hund myh 1; myh 1=new Hund(); myh 1. set. Name("Goldi"); Genauer: myh 1. set. Gewicht(12); Die Klasse Hund stellt einen Bauplan dar (ähnlich dem Bauplan eines my. Name=myh 1. get. Name(); Architekten). An Hand dieses Bauplans wird nun ein konkreter Hund (= einmy. Gewicht=myh 1. get. Gewicht(); Objekt) mit dem Namen myh 1 erzeugt. Der Bauplan verlangt: System. out. println("Name: "+my. Name); 1) dass im Arbeitsspeicher eine bestimmte Menge Bytes für den Hund System. out. println("Gewicht: "+my. Gewicht); reserviert werden. 2) }dass diese Bytes nach der Vorschrift des Bauplans angeordnet, }"formatiert", angelegt, werden, d. h. z. B. dass in den ersten 8 Bytes das Gewicht. Hund{ des angelegten Hundes als double-Zahl gespeichert werden class und den nachfolgenden Bytes der Name des angelegten Hundes //in wie vorher }gespeichert werden.
public class Main. Klassen 1 { public static void main(String[] args){ Hund myh 1; Wie funktioniert dieser myh 1=new Hund(); Mechanismus der myh 1. set. Name("Goldi"); Parameterübergabe? myh 1. set. Gewicht(12); Eine Objektvariable und die //. . . Methode muss durch einen Punkt } voneinander getrennt werden. } Die Methoden set. Name und set. Gewicht werden aufgerufen. Der sogenannte aktuelle Parameter ist "Goldi" bzw. 12 Dem mit myh 1 bezeichneten Objekt wird durch den aktuellen Parameter "Goldi" in der Methode set. Name der Name zugewiesen, den der Nutzer der Black-Box laut Vertragsbedingung festlegen muss. Dem mit myh 1 bezeichneten Objekt wird durch den aktuellen Parameter 12 in der Methode set. Gewicht das Gewicht zugewiesen, das der Nutzer der Black-Box laut Vertragsbedingung festlegen muss.
Was geschieht ganz genau beim Aufruf der Methode myh 1. set. Name("Goldi");
myh 1. set. Name("Goldi"); Der konkrete Wert des Input. Parameters (nämlich "Goldi") wird in den formalen Parameter p. Name kopiert. Kurznotation: Welchen Wert hat also p. Name? p. Name="Goldi" (Kopie) name = p. Name; "Goldi" Welchen Wert bekommt dann das Attribut name zugewiesen? Diese Beschreibung ist noch nicht ganz richtig (weil p. Name einen Klassentyp hat). Näheres dazu später. "Goldi"
Was geschieht ganz genau beim Aufruf der Methode myh 1. set. Gewicht(12);
myh 1. set. Gewicht(12); Der konkrete Wert des Input. Parameters (nämlich 12 wird in den formalen Parameter p. Gewicht kopiert. p. Gewicht=12 (Kopie) gewicht = p. Gewicht; Kurznotation: 12 12 Welchen Wert hat also p. Gewicht? Welchen Wert bekommt dann das Attribut gewicht zugewiesen?
Was geschieht ganz genau beim Aufruf der Methode my. Name=myh 1. get. Name();
"Goldi" my. Name = myh 1. get. Name(); Es gibt keinen Input-Parameter (also muss auch nichts kopiert werden) return(name); Welchen Wert hat aktuell das Attribut name? Auf diesen Wert wurde es vor ein paar Folien gesetzt! "Goldi" Welchen Wert hat also my. Name?
Den Methodenaufruf: my. Name myh 1. get. Name(); kann man sich als einen Kanal vorstellen, der den Output von rechts nach links transportiert.
Was geschieht ganz genau beim Aufruf der Methode my. Gewicht=myh 1. get. Gewicht( );
my. Gewicht = myh 1. get. Gewicht(); 12 Es gibt keinen Input. Parameter (also muss auch nichts kopiert werden) Welchen Wert hat aktuell das Attribut gewicht? Auf diesen Wert wurde es vor ein paar Folien gesetzt! return(gewicht); 12 Welchen Wert hat also my. Gewicht?
Der durch eine Methode gelieferte (erzeugte) Output, kann selbst wieder innerhalb einer anderen Methode verwendet werden, wie z. B:
System. out. println("Gewicht="+ myh 1. get. Gewicht()); Der von dieser Methode gelieferte Output kann direkt in der Methode System. out. println(. . . ) verwendet werden. Der Output muss also. . . System. out. println("Gewicht="+ my. Gewicht); nicht (kann aber) vorher in einer Variablen gespeichert werden.
Eine Bemerkung zu den Namen von Objekten. . .
public class Main. Klassen 1 { public static void main(String[] args){ // Hund myh 1; Das gleiche Programm, wie new Hund(); vorher, außer dass das Objekt new Hund(). set. Name("Goldi"); keinen Namen bekommt. new Hund(). set. Gewicht(12); new Hund(). get. Name(); Was passiert ? new Hund(). get. Gewicht(); } Es werden 5 verschiedene Hunde angelegt. Da } jedes Objekt (Hund) nicht mit einer Variablen class Hund{ bezeichnet wird (wie früher z. B. mit myh 1), // wie vorher kann nur einmal auf dieses Objekt (nämlich } wenn es mit new angelegt wird) zugegriffen werden.
public class Main. Klassen 1 { public static void main(String[] args){ // Hund myh 1; new Hund(). set. Name("Goldi"); new Hund(). set. Gewicht(12); new Hund(). get. Name(); new Hund(). get. Gewicht(); Das ist wie, wenn man im Urlaub (kurz vor der } Abreise) nachts eine Person zum 1. Mal auf } einer Party trifft, sie sympathisch findet und class Hund{ tiefer kennen lernen will. Man schreibt sich die // wie vorher Telefonnummer von ihr auf, verliert diese aber } aus Versehen. Dann ist der "Zugriff" auf diese Person nur einmal (nämlich auf dieser Party) möglich. Danach gibt es aber keinen Zugriff mehr, weil der Link bzw. Verweis nicht mehr vorhanden ist.
Eine Frage zum Zugriff. . .
public class Main. Klassen 1 { public static void main(String[] args){ double my. Gewicht; Warum meldet der Compiler String my. Name; einen Fehler? Hund myh 1; myh 1=new Hund(); name und gewicht sind als // myh 1. set. Name("Goldi"); private deklarierte // myh 1. set. Gewicht(12); Attribute. Deshalb kann myh 1. name="Goldi"; auf sie nicht von außerhalb myh 1. gewicht=12; (d. h. von einer anderen } Klasse) zugegriffen } werden. class Hund{ // wie vorher }
Gerade wurden Zugriffe von außerhalb gemacht. Das sind Zugriffe über eine Objektvariable, die durch einen Punkt von einem Member getrennt sind, wie z. B: myh 1. set. Gewicht(12);
Zur vollständigen Klärung werden jetzt Zugriffe innerhalb von Klassen (d. h. Methoden) vorgestellt.
class Hund{ Wo sind die Zugriffe (Aufruf private String name; von Methoden oder Benutzung private double gewicht; von Attributen) innerhalb von Methoden? public void set. Name(String p. Name){ name = p. Name; } public String get. Name(){ return(name); } Merke: public void set. Gewicht(double p. Gewicht){ gewicht = p. Gewicht; } Ein Aufruf einer Methode (in //. . . einer Methode) kommt hier nicht vor (siehe später).
class Hund{ private String name; private double gewicht; public void set. Name(String p. Name){ name = p. Name; public (öffentlicher) Bereich : } Zugriff von außerhalb der Klasse: ja Zugriff innerhalb der Klasse: ja public String get. Name(){ return(name); } public void set. Gewicht(double p. Gewicht){ gewicht = p. Gewicht; } privater Bereich: //. . . Zugriff von außerhalb der Klasse: nein Zugriff innerhalb der Klasse: ja
Zugriff von innerhalb auf das Objekt selbst
Wie kann man in einer Methode auf das mit new erzeugte Objekt zugreifen (sozusagen von innen)? Woher weiß die Methode den Namen des Objekts?
Die Methode kann den Namen nicht wissen, weil im Bauplan nicht schon der Name des Objekts stehen kann, das irgendein Programmierer später (nach der Erstellung des Bauplans) dem Objekt beim Anlegen mit new. . vergibt!
Um trotzdem innerhalb eines Objekts auf das Objekt selbst zugreifen zu können, wird in Java beim Zugriff auf das Objekt selbst der Name this verwendet.
class Hund{ private String name; private double gewicht; Wie könnte man dann also noch auf die Attribute name und gewicht zugreifen? public void set. Name(String p. Name){ name = p. Name; } public String get. Name(){ return(name); } public void set. Gewicht(double p. Gewicht){ gewicht = p. Gewicht; } //. . .
class Hund{ private String name; private double gewicht; public void set. Name(String p. Name){ this. name = p. Name; } public String get. Name(){ return(this. name); } public void set. Gewicht(double p. Gewicht){ this. gewicht = p. Gewicht; } //. . .
Beispiel (aus dem "Alltag"), um sich public und private besser vorstellen bzw. merken zu können.
Die Küche einer Gaststätte ist private. Die Bedienungen (Methoden) sind alle public. Von außerhalb (z. B. telefonische Bestellung) kann nicht direkt auf ein Gericht in der Küche zugegriffen werden, sondern nur indirekt über die Bedienungen (public). Beispiel eines Zugriffs: Bahnhofsgaststätte-Kirchheim. bestellen(Gericht Nr 13) Von innerhalb (also von allen Bedienungen) kann direkt auf das Gericht in der Küche zugegriffen werden. Beispiel eines Zugriffs: Die Bedienung geht in die Küche und leert – weil sie von dem "Gast" beleidigt wurde - eine hohe Dosis eines Abführmittels auf das von ihm bestellte Gericht.
Unter den Programmierern gibt es folgende stillschweigende Vereinbarung:
Methoden, in denen Attribute auf bestimmte Werte gesetzt werden, mit set zu beginnen und Methoden, in denen die Werte von Attributen besorgt werden, mit get zu beginnen.
Übung: Am Ende eines jeden Jahres summiert der Hundehalter alle Ausgaben für seinen Hund will aus dieser Zahl die monatlichen Kosten seines Hundes berechnen.
Aufgabe: 1) Geben Sie in main(. . . ) die jährlichen Kosten für den Hund über Tastatur ein. 2) Implementieren Sie die Methode get. Monatliche. Kosten(. . . ), in welcher die monatlichen Kosten des Hundes berechnet werden. 3) Geben Sie in main(. . . ) das Ergebnis auf dem Bildschirm aus.
Lösung 1) Besprechung der Methode
Der Output liefert die monatliche Kosten des Hundes formale Parameter p. Kosten public double getm. Kosten(double p. Kosten){ Aus Platzgründen wurde die double kosten; kosten=p. Kosten/12. 0; Methode monatliche. Kosten mit getm. Kosten abgekürzt. return(kosten); Bitte nicht nachmachen!!!!! } Dies ist eine sogenannte lokale Variable. Sie wird verwendet um Werte innerhalb der Methode zwischenzuspeichern. Diese Variable ist - genauso wie der formale Parameter p. Kosten außerhalb der Methode unsichtbar, weil die Black-Box undurchsichtig ist. Genauso wie die Innereien eines Fernsehapparats (Platinen, Widerstände, usw. ) außerhalb des Apparats für den Nutzer unsichtbar sind.
public double getm. Kosten(double p. Kosten){ double kosten; kosten=p. Kosten/12. 0; return(kosten); } Bemerkung Die berechneten monatlichem Kosten werden hier nicht in einem Attribut gespeichert. Man könnte das machen, muss es aber nicht machen. Dies ist eine Sache des sogenannten Designs, das der Entwickler festlegt und zu dem es "eigene Philosophien" gibt.
Erstellen Sie die Methode monatliche. Kosten() ohne Verwendung einer lokalen Variablen.
public double getm. Kosten(double p. Kosten){ return(p. Kosten/12. 0); } Eine lokale Variablen kann man mit einem Zimmer vergleichen, das man (eine kurze Zeit) mietet. Ein Attribut kann man mit einem Zimmer vergleichen, das man längere Zeit mietet oder kauft.
Lösung 2) Gesamte Programm
Der aktuelle Parameter j. Kosten muss keine import java. io. *; Konstantejava. util. Scanner; - wie z. B. 3. 0 - sein, er kann import auch - wieclass hier - eine Variable sein!! { public Main. Klassen 1 public static void main(String[] args) throws IOException{ Was sind dies für Hund myh 1; Variablen ? double j. Kosten; double m. Kosten; Scanner scanner; scanner = new Scanner(System. in); System. out. println("Jahreskosten eingeben"); j. Kosten = scanner. next. Double(); myh 1 = new Hund(); myh 1. set. Name("Goldi"); m. Kosten = myh 1. getm. Kosten(j. Kosten); System. out. println("Monatskost. : "+m. Kosten); } } lokale Variablen!
class Hund{ // Alles wie vorher. . . private String name; private double gewicht; public void set. Name(String p. Name){ name = p. Name; } public String get. Name(){ return(name); } public void set. Gewicht(double p. Gewicht){ gewicht = p. Gewicht; } public double get. Gewicht(){ return(gewicht); }
public void bellen(){ System. out. println("Wau. Wau"); System. out. println("u 0007"); } // Die Methode getm. Kosten kommt jetzt // in der Klasse Hund neu dazu public double getm. Kosten(double p. Kosten){ double kosten; kosten=p. Kosten/12. 0; return(kosten); } }
Was geschieht ganz genau beim Aufruf der Methode m. Kosten=myh 1. getm. Kosten(j. Kosten) ; Wir nehmen dazu an, der Anwender hätte über Tastatur den Wert 240. 0 eingegeben.
m. Kosten=myh 1. getm. Kosten(j. Kosten); Der konkrete Wert des Input-Parameters (nämlich 240. 0 wird in den formalen Parameter p. Kosten kopiert. Kurznotation: p. Kosten=240 (Kopie) 240 double kosten; kosten=p. Kosten/12. 0; return(kosten);
m. Kosten=myh 1. getm. Kosten(j. Kosten); Der konkrete Wert des Input-Parameters (nämlich 240. 0 wird in den formalen Parameter p. Kosten kopiert. Kurznotation: p. Kosten=240 (Kopie) 240 double kosten; kosten=p. Kosten/12. 0; return(kosten);
m. Kosten=myh 1. getm. Kosten(j. Kosten); Der konkrete Wert des Input-Parameters (nämlich 240. 0 wird in den formalen Parameter p. Kosten kopiert. Kurznotation: p. Kosten=240 (Kopie) 240 double kosten; kosten=p. Kosten/12. 0; return(kosten);
m. Kosten=myh 1. getm. Kosten(j. Kosten); Der konkrete Wert des Input-Parameters (nämlich 240. 0 wird in den formalen Parameter p. Kosten kopiert. Kurznotation: p. Kosten=240 (Kopie) 240 double kosten; kosten=p. Kosten/12. 0; return(kosten);
m. Kosten=myh 1. getm. Kosten(j. Kosten); Der konkrete Wert des Input-Parameters (nämlich 240. 0 wird in den formalen Parameter p. Kosten kopiert. Kurznotation: p. Kosten=240 (Kopie) double kosten; 240 kosten=p. Kosten/12. 0; return(kosten);
m. Kosten=myh 1. getm. Kosten(j. Kosten); Der konkrete Wert des Input-Parameters (nämlich 240. 0 wird in den formalen Parameter p. Kosten kopiert. Kurznotation: p. Kosten=240 (Kopie) double kosten; 240 kosten=p. Kosten/12. 0; return(kosten);
m. Kosten=myh 1. getm. Kosten(j. Kosten); Der konkrete Wert des Input-Parameters (nämlich 240. 0 wird in den formalen Parameter p. Kosten kopiert. Kurznotation: p. Kosten=240 (Kopie) double kosten; 240 kosten=p. Kosten/12. 0; return(kosten);
m. Kosten=myh 1. getm. Kosten(j. Kosten); Der konkrete Wert des Input-Parameters (nämlich 240. 0 wird in den formalen Parameter p. Kosten kopiert. Kurznotation: p. Kosten=240 (Kopie) double kosten; 240 kosten=p. Kosten/12. 0; return(kosten);
20 m. Kosten=myh 1. getm. Kosten(j. Kosten); Der konkrete Wert des Input-Parameters (nämlich 240. 0 wird in den formalen Parameter p. Kosten kopiert. Kurznotation: Welchen Wert bekommt dann kosten? Welchen Wert hat also m. Kosten? p. Kosten=240 (Kopie) double kosten; 20 240 kosten=p. Kosten/12. 0; 20 return(kosten);
Überladen von Methoden und Signatur einer Methode
In Java kann der gleiche Methodenname für unterschiedliche Methoden verwendet werden, vorausgesetzt die Signatur der Methode ist verschieden.
Die Signatur einer Methode ist gekennzeichnet durch die Anzahl und/oder den jeweiligen Datentyp der Parameter der Methode. Der Rückgabetyp der Methode gehört nicht zur Signatur.
Beispiele:
Sind folgende Methoden gleichzeitig innerhalb der gleichen Klasse möglich? Warum ? void drucke(int i, int j){. . . } void drucke(char c){. . . } void drucke(int i, char c){. . . }
Ja ! Die Signatur ist jeweils verschieden
Parameterübergabe und Konvertierung
Wenn eine Methode verlangt, dass ein Parameter einen primitiven Datentypen wie z. B. double haben muss, aber beim Methodenaufruf ein integer Wert benutzt wird, dann wird der "kleinere" Datentyp (hier also int) automatisch in den "größeren" Datentyp konvertiert (impliziter cast).
Beispiel (siehe Klasse Hund): Es soll der Hund Bello mit 10. 5 Kg Gewicht erzeugt werden. Anschließend soll dieses Gewicht auf 15 Kg abgeändert werden (Hund hat zugenommen).
public class Main. Klassen 1 { public static void main(String[] args){ Hund myh 1; myh 1=new Hund(); myh 1. set. Name("Goldi"); myh 1. set. Gewicht(10. 5); myh 1. set. Gewicht(15); } 10. 5 ist ein Literal und hat den } Welchen Datentyp hat dieser class aufrufende. Hund{ (aktuelle) Parameter wie Datentyp vorher und// welchen müsste er }laut Deklaration der Methode set. Gewicht(. . . ) haben? Datentyp double. Laut der Deklaration der Methode set. Gewicht(. . . ) muß er auch diesen Datentyp haben.
public class Main. Klassen 1 { eine Fehlermeldung Der Compiler müsste also streng genommen bringen. . public static void main(String[] args){ myh 1; Er Hund macht dies allerdings nicht, sondern wandelt automatisch den myh 1=new Hund(); „kleineren“ Datentyp integer (also konkret 15) in den „größeren“ Datentyp double (also konkret 15. 0) um! myh 1. set. Name("Goldi"); myh 1. set. Gewicht(10. 5); myh 1. set. Gewicht(15); } 15 ist ein Literal und hat den } Welchen Datentyp hat dieser class aufrufende. Hund{ (aktuelle) Parameter wie Datentyp vorher und// welchen müsste er }laut Deklaration der Methode set. Gewicht (. . . ) haben? Datentyp integer. Laut der Deklaration der Methode set. Gewicht(. . . ) müsste er aber den Datentyp double haben.
- Slides: 107