Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

@@ Zeile 1: / Zeile 1: @@
+====== Klassen/Objekte mit Attributen ======
+<WRAP center round info 80%>
+{{ :klassen2:attribute:pasted:20201108-211818.png?400}}
+Ein **Attribut** eine Objektes ist eine **Eigenschaft**, die **einen Wert annehmen** kann. Im Bild rechts etwa ist ein Objekt der Klasse ''Rectangle'' zu sehen mit den Attributen ''width'' (Wert: 800), ''height'' (Wert: 400) und ''FillColor'' (Wert: ''blue''). Es kann viele weitere Objekte derselben Klasse geben. Sie haben **die selben Attribute** (''width'', ''height'', ...), aber diese können **andere Werte** haben. \\ \\
+Siehe dazu auch das [[klassen1:grundbegriffe:start|Kapitel "Grundbegriffe der Objektorientierung"]].
+</WRAP>
+===== Beispiel 1: Die Klasse Person =====
+Wir beginnen mit einem künstlichen - dafür aber sehr einfachen - Beispiel: Einer Klasse ''Person'' mit den Attributen ''name'' und ''geschlecht'' (Datentyp: ''String'') sowie ''größe'' (Datentyp: ''double'', gemeint ist: in m).
+<WRAP center round tip 60%>
+Unter Programmierern ist es ''Konvention'' Attribute mit Kleinbuchstaben zu beginnen. Attributbezeichner dürfen keine Leerzeichen enthalten. Setzt sich ein Attribut aus mehreren Wörtern zusammen, so trennt man sie entweder mit Unterstrichen (weniger üblich, z.B. ''handbreite_in_cm'') oder verwendet Großschreibung mitten im Wort ([[https://en.wikipedia.org/wiki/Camel_case|camel case]], auf deutsch: [[https://de.wikipedia.org/wiki/Binnenmajuskel|Binnenmajuskel]], z.B. ''handbreiteInCm'').
+</WRAP>
+<HTML>
+<div class="java-online" style="height: 450px; width: 100%" data-java-online="{'withBottomPanel': false, 'id': 'Attribute1'}">
+<script type="text/plain" title="Attribute1.java">
+Person fritzi = new Person();
+fritzi.name = "Fritzi Fleißig";
+fritzi.geschlecht = "weiblich";
+fritzi.größe = 1.67;
+Person max = new Person();
+max.name = "Max Munter";
+max.geschlecht = "männlich";
+max.größe = 1.66;
+println("Fritzis Name ist: " + fritzi.name);
+println("Max ist " + max.größe + " m groß.");
+class Person {
+   String name;
+   String geschlecht;
+   double größe;
+}
+</script>
+</div>
+</HTML>
+<WRAP center round info 80%>
+**Deklaration von Attributen:** \\
+Attribute werden deklariert, indem man auf oberster Ebene innerhalb der Klassendeklaration (also **nicht** innerhalb einer Methode!) den Datentyp des Attributs gefolgt von seinem Bezeichner schreibt, z.B.
+<code myJava>
+class Person {
+   String name;
+   String geschlecht;
+   double größe;
+}
+</code>
+Es ist auch möglich, bei der Attributdeklaration einen Anfangswert anzugeben, z.B.
+<code myJava>
+   String geschlecht = "weiblich";
+</code>
+Auf die Attribute von Objekten kann man außerhalb der Klassendeklaration mithilfe der Punktschreibweise zugreifen. Wie das geht, siehst Du im obigen Beispiel in den Zeilen 2 - 12.
+</WRAP>
+===== Beispiel 2: Klassen mit Attributen und Methoden =====
+<WRAP center round info 80%>
+Attributdeklarationen und Methodendeklarationen dürfen innerhalb einer Klassendeklaration beliebig hintereinander stehen. Es ist aber üblich, **gleich zu Beginn** einer Klassendeklaration **alle Attribute** der Klasse zu deklarieren und danach erst die Methoden. \\ \\
+<code myJava>
+class Person {
+   String name;
+   String geschlecht;
+   double größe;
+   // Jetzt kommt eine Methodendeklaration:
+   void schreibeName(){
+      println(name);
+   }
+}
+</code>
+Innerhalb von Methodendeklarationen kann man auf Attribute wie auf gewöhnliche Variablen durch Angabe ihres Bezeichners zugreifen. Du siehst das im obigen Beispiel in der Anweisung ''println(name)''. Ausgegeben wird der Wert des Attributs Name desjenigen Objekts, für das die Methode aufgerufen wurde.
+//Du fragst Dich vielleicht, wie der Compiler Attributdeklarationen und Methodendeklarationen unterscheiden kann?// \\ Den Unterschied macht die runde Klammer hinter dem Bezeichner einer Methode. Jetzt ist Dir sicher auch klar, weshalb bei Methoden ohne Parameter trotzdem die runden Klammern ''()'' benötigt werden.
+</WRAP>
+<HTML>
+<div class="java-online" style="height: 550px; width: 100%" data-java-online="{'withBottomPanel': false, 'id': 'Attribute2'}">
+<script type="text/plain" title="Attribute2.java">
+Person fritzi = new Person();
+fritzi.name = "Fritzi Fleißig";
+fritzi.geschlecht = "weiblich";
+fritzi.größe = 1.67;
+Person max = new Person();
+max.name = "Max Munter";
+max.geschlecht = "männlich";
+max.größe = 1.66;
+fritzi.schreibeName();
+fritzi.begrüßen();
+println();
+max.begrüßen();
+class Person {
+   String name;
+   String geschlecht;
+   double größe;
+   void schreibeName(){
+      print(name);
+   }
+   void begrüßen(){
+      println("Guten Tag, ");
+      if(geschlecht == "weiblich"){
+         print("Frau ");
+      } else {
+         print("Herr ");
+      }
+      println(name + "!");
+   }
+}
+</script>
+</div>
+</HTML>
+<WRAP center round tip 60%>
+Führe das Programm schrittweise mit "step into ({{:klassen2:constructors:step-into-dark.png?nolink|}})" aus und beobachte, welchen Wert die Attribute ''name'' und ''geschlecht'' jeweils innerhalb der Methoden haben! Öffne dazu rechts den Variablen-Reiter. Die Objekte werden jeweils im "zugeklappten" Zustand gezeigt. Klappe sie auf! \\ \\
+Wenn sich der Aktuelle Ausführungspunkt des Programms (grün hinterlegte Programmzeile) gerade innerhalb einer Methode befindet, wird das Objekt, für das die Methode aufgerufen wurde, immer mit ''this'' bezeichnet. Klappe daher auch das ''this''-Objekt im Reiter "Variablen" auf und schau' Dir seine Attributwerte an.
+</WRAP>
+{{ :klassen2:attribute:objekte_betrachten.gif |}}
+{{ :klassen2:attribute:pasted:20201122-202223.png?300}}
+===== Beispiel 4: Ampel =====
+Wir programmieren eine Klasse ''Ampel'', die eine einfache Fußgängerampel Zeichnet und Methoden ''schalteGrün()'' und ''schalteRot()'' zum Umschalten besitzt. Die Ampel besteht aus einem ''Rectangle''-Objekt und zwei ''Circle''-Objekten. Diese speichern wir als Attribute der Klasse ''Ampel''. Sie werden in der Methode ''init()'' instanziert und initialisiert.
+<WRAP center round todo 60%>
+Ich habe Dir noch etwas Arbeit im Programm hinterlassen (siehe die Kommentare). Vielleicht möchtest Du die Ampel auch noch etwas umfangreicher gestalten:
+  * Umgib das Gehäuse mit einem dunkelgrauen Rahmen (Methode ''setBorderColor'' der ''Rectangle''-Klasse!)
+  * Füge ein gelbes Licht hinzu!
+  * Füge eine "Fuß" hinzu!
+</WRAP>
+<HTML>
+<div class="java-online" style="height: 550px; width: 100%" data-java-online="{'withBottomPanel': true, 'id': 'Attribute4'}">
+<script type="text/plain" title="Attribute4.java">
+Ampel a = new Ampel();
+a.init();
+a.schalteRot();
+Input.readString("Drücke die Taste Enter!");
+a.schalteGrün();
+Input.readString("Drücke die Taste Enter!");
+a.schalteAus();
+class Ampel {
+   Rectangle gehäuse;
+   Circle lichtOben;
+   Circle lichtUnten;
+   void init() {
+      // Instanzieren und Initialisieren des Gehäuses:
+      gehäuse = new Rectangle(340, 140, 120, 220);
+      gehäuse.setFillColor(Color.gray);
+      // Ergänze den Code zum Instanzieren und initialisieren der beiden Lichter!
+      // Die Lichter sollen initial beide mit der Farbe Color.darkgray gefüllt sein.
+   }
+   void schalteRot() {
+      lichtOben.setFillColor(Color.red);
+      lichtUnten.setFillColor(Color.darkgray);
+   }
+   // Ergänze Methoden schalteGrün() und schalteAus()!
+}
+</script>
+</div>
+</HTML>
+[[.ampelloesung:start|Hier geht's zur Lösung!]]
+===== Aufgabe 1: Tiere =====
+Erstelle eine Klasse ''Tier'' mit den Attributen ''art'' (Typ ''String''), ''name'' (Typ ''String'') und ''beinzahl'' (Typ ''int'') sowie einer Methode ''vorstellen()'', die im Falle der Katze Snoopy (mit zum Glück noch 4 Beinen) folgende Meldung ausgibt:
+<code>
+Ich heiße Snoopy und bin ein/e Katze mit 4 Beinen.
+</code>
+<HTML>
+<div class="java-online" style="height: 550px; width: 100%" data-java-online="{'withBottomPanel': false, 'id': 'AttributeAufgabe1'}">
+<script type="text/plain" title="AttributeAufgabe1.java">
+Tier s = new Tier();
+s.name = "Snoopy";
+s.art = "Katze";
+s.beinzahl = 4;
+Tier c = new Tier();
+c.name = "Caruso";
+c.art = "Hahn";
+c.beinzahl = 2;
+s.vorstellen();
+c.vorstellen();
+// Jetzt bist Du dran: Definiere hier die Klasse Tier, so dass das Programm oben
+// fehlerfrei läuft.
+</script>
+</div>
+</HTML>
+[[.Aufgabe1Loesung:start|Hier geht's zur Lösung.]]
+===== Aufgabe 2: Längeneinheiten =====
+<WRAP center round tip 80%>
+Sind Dir schon mal Längenangaben wie //12 in// oder //17 zoll// oder //14%%''%%// begegnet? Sie bezeichnen dieselbe Längeneinheit [[https://www.typolexikon.de/inch/| Inch (im deutschen auch als "englischer Zoll" bezeichnet)]] und werden in Deutschland bespielsweise zur Angabe von Monitor-Diagonalen verwendet. In England und den USA sind sie neben den international vereinbarten [[https://de.wikipedia.org/wiki/Internationales_Einheitensystem|SI-Einheiten]] bis heute weit verbreitet. \\ \\
+**Umrechnung:** 1 in = 2.54 cm
+</WRAP>
+Schreibe eine Klasse ''Länge'' mit den Methoden ''speichere(double länge, String einheit)'', ''schreibeInch()'' und ''schreibeCm()'', die bei der Umrechnung der beiden Längeneinheiten hilft. Hier ein beispielhaftes Hauptprogramm zusammen mit der Ausgabe, durch das die Bedeutung der Methoden klar wird:
+== Programm: ==
+<code myJava>
+Länge a = new Länge();
+a.speichere(3.0, "inch");
+a.schreibeCm();
+a.speichere(25.4, "cm");
+a.schreibeInch();
+</code>
+== Ausgabe ==
+<code>
+.62 cm
+inch
+</code>
+**Tipp: ** Natürlich benötigt die Klasse auch ein Attribut, um die Länge zu speichern. Es bietet sich an, nur ein einziges Attribut zu deklarieren, in dem die Länge immer in cm gespeichert wird und nur beim Speichern von inch und der Ausgabe in inch umzurechnen.
+<HTML>
+<div class="java-online" style="height: 550px; width: 100%" data-java-online="{'withBottomPanel': false, 'id': 'AttributeAufgabe2'}">
+<script type="text/plain" title="AttributeAufgabe2.java">
+Länge a = new Länge();
+a.speichere(3.0, "inch");
+a.schreibeCm();
+a.speichere(25.4, "cm");
+a.schreibeInch();
+// Jetzt bist Du dran: schreibe die Definition der Klasse Länge!
+</script>
+</div>
+</HTML>
+[[.Aufgabe2Loesung:start|Hier geht's zur Lösung.]]
+===== Aufgabe 3: RechteckHelfer =====
+Schreibe eine Klasse ''RechteckHelfer'' mit den Methoden ''setzeLängeBreite(double länge, double breite)'', ''gibUmfang()'', ''gibFlächeninhalt()'' und ''gibDiagonalenlänge()''. Hier ein Hauptprogramm mit Ausgabe, das die Bedeutung der Methoden zeigt:
+== Programm: ==
+<code myJava>
+RechteckHelfer rh = new RechteckHelfer();
+rh.setzeLängeBreite(3, 4);
+println(rh.gibUmfang());
+println(rh.gibFlächeninhalt());
+println(rh.gibDiagonalenlänge());
+</code>
+== Ausgabe ==
+<code>
+</code>
+**Tipp: ** Natürlich benötigt die Klasse auch zwei Attribute, um die Länge und Breite des Rechtecks zu speichern!
+<HTML>
+<div class="java-online" style="height: 550px; width: 100%" data-java-online="{'withBottomPanel': false, 'id': 'AttributeAufgabe3'}">
+<script type="text/plain" title="AttributeAufgabe3.java">
+RechteckHelfer rh = new RechteckHelfer();
+rh.setzeLängeBreite(3, 4);
+println(rh.gibUmfang());
+println(rh.gibFlächeninhalt());
+println(rh.gibDiagonalenlänge());
+// Jetzt bist Du dran: schreibe die Definition der Klasse RechteckHelfer!
+</script>
+</div>
+</HTML>
+[[.Aufgabe3Loesung:start|Hier geht's zur Lösung.]]
+===== Aufgabe 4: Eine Klasse zum Bruchrechnen =====
+Studiere die Klasse Bruch im Programm unten genau und ergänze folgende Methoden:
+  * ''subtrahiere(Bruch b2)''
+  * ''multipliziere(Bruch b2)''
+  * ''dividiere(Bruch b2)''
+  * ''gibAusEcht()'' (gibt den Bruch ggf. als echten Bruch aus, also 3 1/2 statt 7/2)
+  * ''erweitere(int faktor)''
+<HTML>
+<div class="java-online" style="height: 550px; width: 100%" data-java-online="{'withBottomPanel': false, 'id': 'AttributeAufgabe4'}">
+<script type="text/plain" title="AttributeAufgabe4.java">
+Bruch b1 = new Bruch();
+b1.setzeWert(7, 2);
+Bruch b2 = new Bruch();
+b2.setzeWert(2, 3);
+b1.addiere(b2);
+b1.gibAusUnecht();
+class Bruch {
+   int zähler;
+   int nenner;
+   void setzeWert(int z, int n) {
+      zähler = z;
+      nenner = n;
+   }
+   void gibAusUnecht() {
+      println(zähler + "/" + nenner);
+   }
+   void kürze() {
+      // Ermittle den größten gemeinsamen Teiler von Zähler und Nenner
+      int z1 = zähler;
+      int z2 = nenner;
+      while(z1 != z2) {
+         int z3 = Math.abs(z2 - z1);
+         if(z1 > z2) {
+            z1 = z3;
+         } else {
+            z2 = z3;
+         }
+      }
+      // Der ggT von zähler und Nenner befindet sich jetzt in z1 und z2.
+      // Wir kürzen jetzt den Bruch, indem wir Zähler und Nenner durch deren
+      // größten gemeinsamen Teiler teilen:
+      zähler = zähler / z1;
+      nenner = nenner / z1;
+   }
+   void addiere(Bruch b) {
+      zähler = zähler * b.nenner + b.zähler * nenner;
+      nenner = nenner * b.nenner;
+      kürze();
+   }
+}
+</script>
+</div>
+</HTML>
+[[.Aufgabe4Loesung:start|Hier geht's zur Lösung.]]
+<WRAP center round tip 60%>
+**Für die Mathematik-Interessierten unter Euch: \\ Algorithmus zur Berechnung des größten gemeinsamen Teilers zweier Zahlen** \\ \\
+In der Methode ''kürzen'' wird der größte gemeinsame Teiler von Zähler und Nenner berechnet. Die Strategie ist eine vereinfachte Variante des [[https://de.wikipedia.org/wiki/Euklidischer_Algorithmus|Euklidischen Algorithmus]] und basiert auf folgendem einfachen Satz: \\ \\
+Wenn eine Zahl $x$ ein Teiler der Zahlen $a$ und $b$ ist, dann ist $x$ auch ein Teiler von $|a - b|$ und von $a + b$. \\ \\
+**In Folgenden ein Beispiel zur Durchführung des Algorithmus, das - basierend auf dem eben genannten Satz - auch den Korrektheitsbeweis des Algorithmus skizziert:** \\
+Wir bestimmen den ggT von $24$ und $80$ (und nennen ihn im Folgenden kurz $x$).
+  * $x$ ist Teiler beider Zahlen und teilt daher auch $80 - 24 = 56$. Wir nehmen jetzt die kleineren beiden dieser drei Zahlen (also $24$ und $56$) und setzen das Spiel damit fort.
+  * $x$ ist Teiler von $24$ und $56$ und teilt daher auch $56 - 24 = 32$. Wir nehmen jetzt die kleineren beiden dieser drei Zahlen (also $32$ und $24$) und setzen das Spiel damit fort.
+  * $x$ ist Teiler von $32$ und $24$ und teilt daher auch $32 - 24 = 8$. Wir nehmen jetzt die kleineren beiden dieser drei Zahlen (also $24$ und $8$) und setzen das Spiel damit fort.
+  * $x$ ist Teiler von $24$ und $8$ und teilt daher auch $24 - 8 = 16$. Wir nehmen jetzt die kleineren beiden dieser drei Zahlen (also $16$ und $8$) und setzen das Spiel damit fort.
+  * $x$ ist Teiler von $16$ und $8$ und teilt daher auch $16 - 8 = 8$. Wir nehmen jetzt die kleineren beiden dieser drei Zahlen (also $8$ und $8$) und sind fertig, denn wir wissen jetzt, dass der ggT von $24$ und $80$ ein Teiler von $8$ ist. Gleichzeitig ist aber $8$ auch ein Teiler von $24$ und $80$, teilt also auch deren ggT. Daher ist $8$ der gesuchte ggT.
+  * **Halt, halt, nicht so schnell!!** \\ Warum ist $6$ auch ein Teiler von $24$ und $80$? \\ \\ Denk' Dir einfach alle Schritte wieder rückwärts: die $8$ teilt $8$ und $8$, also teilt sie auch die Summe $16 = 8 + 8$. Da sie also die $8$ und die $16$ teilt, teilt sie auch $8 + 16 = 24$. Da sie $8$ und $24$ teilt, teilt sie auch $8 + 24 = 32$,  usw. Am Ende all dieser Schritte steht fest: $8$ teilt auch $24$ und $80$.
+</WRAP>
+===== Aufgabe 5: Bild mit verschiedenen Tageszeiten =====
+{{ :klassen2:attribute:pasted:20201122-212921.png}}
+{{:klassen2:attribute:pasted:20201122-212757.png }}
+{{ :klassen2:attribute:pasted:20201122-212839.png }}
+ \\
+Die Klasse Bild zeichnet das Bild einer Wüste mit Sonne und Himmel (s.u.) zu drei verschiedenen Tageszeiten. Sie besitzt die Methoden ''init()'' (zum Instanzieren und Initialisieren der Objekte), ''schalteMorgen()'' (schaltet auf das "Morgenbild" um), ''schalteMittag()'' und ''schalteAbend()''. \\ \\
+**Tipp:** Orientiere Dich beim Programmieren am [[#beispiel_4ampel|Ampel-Beispiel oben]]!
+<HTML>
+<div class="java-online" style="height: 550px; width: 100%" data-java-online="{'withBottomPanel': false, 'id': 'AttributeAufgabe5'}">
+<script type="text/plain" title="AttributeAufgabe5.java">
+Bild b = new Bild();
+b.init();
+b.schalteMorgen();
+b.schalteMittag();
+b.schalteAbend();
+class Bild {
+}
+</script>
+</div>
+</HTML>
+[[.aufgabe5loesung:startxx|Hier geht's zur Lösung!]]