WEBVTT

00:05.100 --> 00:08.620
Dann begrüße ich Sie zur siebten Veranstaltung vom Vorkurs Informatik.

00:09.100 --> 00:12.040
Wir haben uns gestern angeschaut, wie man Klassen deklariert, einer

00:12.040 --> 00:17.420
Klassenvariablen zuordnet und dann Klassen benutzt, um Objekte daraus

00:17.420 --> 00:21.140
mit dem New Operator zu erzeugen, in Felder einzusetzen und zu

00:21.140 --> 00:21.580
verwenden.

00:22.060 --> 00:25.380
Heute schauen wir uns an, wie man diesen Klassenmethoden zufügt, also

00:25.380 --> 00:29.580
Programmcode, der irgendetwas mit den Attributen in der Klasse tut.

00:29.580 --> 00:33.980
Und dazu stelle ich Ihnen kurz erst nochmal vor, wie die Syntax für

00:33.980 --> 00:34.840
die Klasse aussah.

00:35.240 --> 00:39.020
Sie schreiben eine Java-Datei, die mit class anfängt, geben der einen

00:39.020 --> 00:42.700
Namen, das muss dann auch der Dateiname sein, deklarieren Attribute

00:42.700 --> 00:46.820
mit Dateiname plus Variablen-Name und heute kommen die Methoden dazu.

00:46.940 --> 00:50.020
Die deklarieren Sie, indem Sie die Methodensignatur plus den

00:50.020 --> 00:51.140
Programmcode angeben.

00:51.200 --> 00:54.760
Die Details dazu machen wir heute, auch die wichtigsten Modifikatoren,

00:55.120 --> 00:55.880
die dazu gehören.

00:55.880 --> 00:58.780
Und sobald Sie das getan haben, können Sie wie gestern mit dem New

00:58.780 --> 01:00.280
Operator ein Objekt bzw.

01:00.440 --> 01:04.180
ein Exemplar oder eine Instanz anlegen und über eine Referenzvariable

01:04.180 --> 01:04.700
verwalten.

01:05.240 --> 01:09.360
Styleguide dabei ist, wie immer, Klassen, Groß, Objekte, Attribute und

01:09.360 --> 01:11.540
Methoden mit kleinen Buchstaben zu schreiben.

01:11.920 --> 01:13.220
Das ist relativ einfach.

01:14.340 --> 01:16.300
Ich mache mal ein kurzes Einführungsbeispiel.

01:16.400 --> 01:18.040
Den Student hatte ich ja gestern schon.

01:19.160 --> 01:22.700
Der hat diese vier Attribute, die Nummer, das Geschlecht, den Namen

01:22.700 --> 01:23.400
und das Alter.

01:23.400 --> 01:27.400
Und jetzt hat er drei Methoden, die irgendetwas mit diesen Attributen

01:27.400 --> 01:27.740
tun.

01:28.200 --> 01:32.500
Also da gibt es zum Beispiel eine, die das Alter um 1 hochzählt und es

01:32.500 --> 01:36.120
gibt eine Methode, die bekommt einen Parameter n und schreibt den in

01:36.120 --> 01:39.080
die Nummer oder eine Methode, die den Namen überschreibt.

01:40.160 --> 01:43.720
Einsetzen tun Sie die, indem Sie einen Studenten mit new erzeugen,

01:43.800 --> 01:48.160
hier unten im Hauptprogramm und dann diese Methoden aufrufen, indem

01:48.160 --> 01:51.860
Sie die Referenzvariable hinschreiben, dann den Referenzpunkt, dann

01:51.860 --> 01:55.480
die Bezeichnung von der Methode und in runden Klammern die Eingabe,

01:55.580 --> 01:56.800
die diese Methode bekommen soll.

01:56.880 --> 01:57.940
Das ist so das grobe Programm.

01:58.500 --> 02:02.040
Aber dahinter stecken ganz viele Details, die wir uns heute anschauen

02:02.040 --> 02:05.180
müssen, bevor wir die Methoden selber ordentlich programmieren können.

02:05.280 --> 02:06.360
Zunächst einmal, was ist das?

02:06.720 --> 02:07.940
Methode ist ein Fachbegriff.

02:08.520 --> 02:12.060
Das ist ein benanntes Programmstück, das eine bestimmte Aufgabe zu

02:12.060 --> 02:13.660
bestimmten Bedingungen erfüllen soll.

02:14.180 --> 02:17.680
Das ist etwas anderes als der Begriff Funktion in Pascal oder in der

02:17.680 --> 02:18.260
Mathematik.

02:18.260 --> 02:21.920
Eine Methode stellt keinen funktionalen Zusammenhang zwischen ihren

02:21.920 --> 02:25.300
Ein - und Ausgaben her, sondern führt irgendwie Befehle aus.

02:25.440 --> 02:28.760
Also die muss auch keinen Rückgabewert oder keine Eingabe akzeptieren.

02:29.400 --> 02:32.480
Methoden können Werte berechnen, Attribute des Objekts verändern, neue

02:32.480 --> 02:35.980
Objekte erzeugen oder sonst irgendeine Aufgabe ausführen, die man

02:35.980 --> 02:39.020
sinnvoll zu einem einzigen Codeblock zusammenfassen möchte.

02:40.540 --> 02:44.940
Die Idee dahinter ist, dass die Methode, sobald sie mal da ist,

02:45.220 --> 02:47.340
außerhalb des Objekts aufgerufen werden kann.

02:47.340 --> 02:50.180
Also das tun sie, wie ich eben schon gesagt habe, indem sie die

02:50.180 --> 02:52.860
Referenzvariable für das Objekt hinschreiben, dann ein Punkt und dann

02:52.860 --> 02:53.880
den Methodennamen.

02:54.360 --> 02:57.480
Zum Beispiel s.geburtstag, Runde, Klammer auf, Runde, Klammer zu,

02:57.600 --> 02:58.080
Semikolon.

02:58.820 --> 03:01.760
Sie können Werte übergeben, das haben sie auch schon gemacht, zum

03:01.760 --> 03:03.340
Beispiel mit dieser println-Methode.

03:04.020 --> 03:05.460
System.out ist das Objekt.

03:06.320 --> 03:10.800
Punkt ruft eine Eigenschaft von out auf, und zwar hier das println und

03:10.800 --> 03:13.580
in den runden Klammern haben sie ja in der Regel ein String oder

03:13.580 --> 03:17.200
andere Variablen übergeben, die dann durch dieses System.out-Objekt

03:17.200 --> 03:21.380
auf der Konsole ausgegeben werden, oder halt irgendwo hin, wo dieses

03:21.380 --> 03:23.020
System.out-Projekt hin verknüpft ist.

03:23.840 --> 03:26.580
Eine Methode kann auch Werte zurückgeben, auch das haben sie schon

03:26.580 --> 03:26.940
gemacht.

03:27.140 --> 03:30.060
Zum Beispiel dieser Sinus hier, den sie irgendwann mal benutzt haben,

03:30.500 --> 03:34.060
ist auch eine Methode, dem geben sie einen Eingabewert, dann berechnet

03:34.060 --> 03:36.500
er irgendetwas und das Ergebnis speichern sie mit dem

03:36.500 --> 03:39.760
Gleichheitszeichen in der Regel in einer neuen Variablen ab.

03:40.460 --> 03:43.660
Falls kein Objekt gegeben ist, also falls sie vor diesem Referenzpunkt

03:43.660 --> 03:46.620
nichts schreiben, sucht Java die Methode in der Klasse,

03:46.740 --> 03:49.360
beziehungsweise in dem Objekt, in dem sie sich gerade befinden.

03:50.300 --> 03:53.340
Also wenn sie ihre Public Static Vault Main schreiben, sind sie ja

03:53.340 --> 03:55.940
auch in einer Klasse drin, haben sie ja bisher immer gemacht.

03:56.440 --> 03:59.080
Und wenn die mehrere Methoden hat und sie schreiben nichts vor den

03:59.080 --> 04:02.160
Referenzpunkt, dann sucht Java die Methode in ihrer

04:02.160 --> 04:03.360
Hauptprogrammklasse.

04:04.160 --> 04:05.660
Das muss man einfach im Hinterkopf haben.

04:06.260 --> 04:07.480
Ein allererstes Beispiel.

04:08.520 --> 04:11.180
Wir haben ja den Raumvektor gestern auf dem Übungsblatt gehabt, der

04:11.180 --> 04:13.300
hat diese drei Komponenten x, y und z.

04:13.300 --> 04:16.200
Und jetzt kriegt er eine sogenannte ToString Methode.

04:16.440 --> 04:18.980
Das ist eine Methode, die bekommt nichts als Eingabe.

04:19.360 --> 04:22.280
Deshalb hier Runde Klammer auf, Runde Klammer zu, ohne was dazwischen.

04:22.880 --> 04:25.520
Und sie liefert einen String als Rückgabe.

04:26.220 --> 04:30.640
Und zwar macht diese Methode einen neuen String, indem sie die

04:30.640 --> 04:34.100
Komponenten, diese drei Doubles, mit Kommata und Klammern

04:34.100 --> 04:38.000
zusammensetzt, sodass ein lesbarer Vektor entsteht und gibt den als

04:38.000 --> 04:39.720
String mit Return zurück.

04:39.720 --> 04:43.680
Diese Methode kann man benutzen jetzt, indem man mit v einen neuen

04:43.680 --> 04:44.640
Raumvektor erzeugt.

04:44.680 --> 04:45.800
v gleich nu Raumvektor.

04:46.320 --> 04:48.880
Dann String s gleich v Punkt ToString.

04:49.020 --> 04:53.240
Jetzt ist in s diese Darstellung des Vektors drin und die kann man

04:53.240 --> 04:55.100
über System.out.println ausgeben.

04:55.640 --> 04:58.340
Einige von Ihnen haben das gestern auch schon getan mit einer Print

04:58.340 --> 04:58.760
Methode.

04:59.420 --> 05:02.300
Also das heißt, der Raumvektor bekommt eine Print Methode und gibt das

05:02.300 --> 05:03.560
selber auf der Konsole aus.

05:03.560 --> 05:07.840
Jetzt wird Ihnen der Style Guide später vorschreiben, dass Objekte

05:07.840 --> 05:10.960
generell nicht selbst auf der Konsole ausgeben sollen, sondern dass

05:10.960 --> 05:15.660
das immer so läuft, dass das Objekt einen String produziert und der

05:15.660 --> 05:17.740
Aufrufer diesen String dann ausgeben muss.

05:17.840 --> 05:18.920
Warum macht man das denn so?

05:19.040 --> 05:22.880
Warum ist es Aufgabe des Aufrufers zu entscheiden, wo dieser String

05:22.880 --> 05:23.380
hingeht?

05:23.980 --> 05:26.580
Können Sie sich Situationen vorstellen, wo das nicht sinnvoll ist,

05:26.800 --> 05:29.800
wenn der Raumvektor selbst auf die Konsole schreibt?

05:31.340 --> 05:31.480
Ja?

05:31.480 --> 05:32.260
Also

05:36.130 --> 05:42.470
diese andere Ausgabe, was Sie gesagt haben, das hat sogar zwei

05:42.470 --> 05:43.170
Möglichkeiten.

05:43.310 --> 05:46.510
Einmal könnte es sein, dass der Aufrufer das gar nicht auf der Konsole

05:46.510 --> 05:49.550
ausgeben, sondern vielleicht in eine Datei schreiben möchte und dann

05:49.550 --> 05:52.490
muss er diesen String anders verarbeiten als mit System.out.println.

05:52.750 --> 05:55.650
Und das kann er nicht, wenn der Raumvektor nur nach System.out.println

05:55.650 --> 05:55.990
schreibt.

05:56.410 --> 05:58.870
Aber es gibt noch eine andere Situation, die man auch als anders

05:58.870 --> 05:59.890
interpretieren könnte.

06:01.130 --> 06:03.870
Und zwar, es könnte ja sein, dass dieser Raumvektor Bestandteil von

06:03.870 --> 06:07.790
einem größeren Objekt ist und dieses größere Objekt wird gefragt, sich

06:07.790 --> 06:08.410
auszugeben.

06:08.590 --> 06:11.110
Dann hat dieses größere Objekt eine ToString-Methode und ruft

06:11.110 --> 06:15.710
innerhalb ihrer ToString-Methode das ToString von dem Raumvektor auf.

06:15.990 --> 06:18.530
Und aus diesen Raumvektoren, die es da bekommt, setzt es seinen

06:18.530 --> 06:19.550
eigenen String zusammen.

06:20.270 --> 06:22.370
Das ist das Konzept, was Sie da im Hinterkopf haben sollen.

06:22.410 --> 06:24.790
Das hatte ich gestern nochmal so ein bisschen angesprochen, dass das

06:24.790 --> 06:25.550
delegiert wird.

06:26.130 --> 06:29.350
Dass der Aufrufer seine Bestandteile fragen kann, wie sie heißen, wie

06:29.350 --> 06:32.350
sie aussehen und daraus seine eigene Beschreibung zusammensetzt.

06:32.430 --> 06:34.610
Das werden wir heute auch etwas genauer sehen.

06:36.450 --> 06:38.990
Das war jetzt nur ein einführendes Beispiel.

06:39.390 --> 06:44.370
An sich kann eine Methode ja alles tun und Parameter bekommen oder

06:44.370 --> 06:46.330
nicht und Rückgabewerte liefern oder nicht.

06:46.650 --> 06:49.430
Das erste, was Sie da lernen müssen, ist die Signatur der Methode zu

06:49.430 --> 06:49.810
verstehen.

06:50.170 --> 06:51.370
Signatur ist ein Fachbegriff.

06:51.910 --> 06:55.030
Das ist die einleitende Zeile, in der die Eigenschaften der Methode

06:55.030 --> 06:55.950
festgelegt werden.

06:56.550 --> 06:58.870
Hinter der Signatur kommt der Körper oder Rumpf.

06:59.750 --> 07:02.010
Dort stehen in Mengenklammern der Programmtext.

07:02.970 --> 07:03.770
Einfaches Beispiel.

07:04.650 --> 07:08.270
Public Double Product, Klammer auf, Double A, Komma Double B, Klammer

07:08.270 --> 07:08.430
zu.

07:08.570 --> 07:09.470
Das ist die Signatur.

07:10.230 --> 07:12.590
Und dann in geschweiften Klammern das, was die Methode tut.

07:12.730 --> 07:14.490
Die rechnet einen neuen Double P aus.

07:14.550 --> 07:15.790
Der ist das Produkt von A und B.

07:16.230 --> 07:18.450
Und gibt den als Rückgabewert mit Returns zurück.

07:19.090 --> 07:20.270
Styleguide schreibt Ihnen vor.

07:20.710 --> 07:23.770
Attribut und Methodennamen klein, wie bei Variablen.

07:23.910 --> 07:24.830
Also hier kleines p.

07:26.630 --> 07:28.450
Okay, das ist die vereinfachte Version.

07:28.670 --> 07:30.350
Die vollständige Version sieht so aus.

07:31.250 --> 07:33.790
Eine Methode hat die folgenden 5 Bestandteile.

07:33.890 --> 07:35.270
Die lernen Sie bitte auswendig.

07:37.870 --> 07:41.290
Modifikatoren, Rückgabetyp, Name, Parameterliste und Körper.

07:41.410 --> 07:43.930
Schreiben Sie sich zumindest diese 5 Begriffe untereinander auf.

07:43.990 --> 07:46.830
Das müssen Sie reproduzieren können, immer und immer wieder.

07:47.390 --> 07:50.750
So, ich gebe Ihnen jetzt einfach eine ganze Reihe von Beispielen dazu.

07:51.570 --> 07:54.410
Und erkläre, wie die 5 Bestandteile in diesen Beispielen aussehen.

07:55.010 --> 07:57.130
Zuerst gucken wir uns mal die Modifikatoren an.

07:57.710 --> 08:01.230
Es gibt sehr viele Modifikatoren in Java, aber im praktischen

08:01.230 --> 08:03.010
Programmieren brauchen Sie nur diese 4.

08:04.290 --> 08:06.830
Public setzt, also das würde ich mir jetzt nicht aufschreiben, sondern

08:06.830 --> 08:09.250
die Modifikatoren sind ja so genannt, dass man es sich einfach merken

08:09.250 --> 08:09.450
kann.

08:09.990 --> 08:13.010
Public bedeutet, die Methode oder das Attribut, was Sie deklarieren,

08:13.110 --> 08:14.090
ist öffentlich sichtbar.

08:14.670 --> 08:18.430
Das heißt, jeder kann es aufrufen, auch außerhalb Ihres Projekts, in

08:18.430 --> 08:20.850
dem Sie gerade sind, oder außerhalb Ihrer Klasse.

08:21.270 --> 08:23.050
Das Gegenstück ist private.

08:23.050 --> 08:26.290
Dann ist die Methode oder das Attribut oder die Variable, die Sie

08:26.290 --> 08:29.750
deklarieren, nur innerhalb der eigenen Klasse sichtbar.

08:30.870 --> 08:33.350
Warum man sowas haben möchte, werden wir später sehen.

08:33.950 --> 08:36.890
Wenn Sie weder Public noch Private hinschreiben, kriegen Sie so einen

08:36.890 --> 08:40.510
Zwischenzustand, dann ist die Methode oder Variable innerhalb Ihres

08:40.510 --> 08:41.390
Packages bzw.

08:41.730 --> 08:43.090
Ihres Eclipse-Projekts sichtbar.

08:44.470 --> 08:47.790
Wenn Sie Static davor schreiben, ist die Methode bzw.

08:47.950 --> 08:49.610
Variable unabhängig vom Objekt.

08:49.610 --> 08:53.150
Warum man sowas haben möchte, werden wir morgen genauer anschauen.

08:53.630 --> 08:56.450
Im Moment benutzen Sie Static bitte noch nicht, außer bei Public,

08:56.530 --> 08:57.290
Static, Void, Main.

08:58.210 --> 09:01.450
Und dann gibt es noch Final, dadurch wird erzwungen, dass die Methode

09:01.450 --> 09:03.150
oder Variable unveränderlich ist.

09:03.630 --> 09:07.610
Typisches Beispiel, wenn Sie die konstante Pi deklarieren, würden Sie

09:07.610 --> 09:10.490
das mit Final machen, damit niemand später im Programm hier sowas

09:10.490 --> 09:10.990
machen kann.

09:13.730 --> 09:16.610
Okay, das sind die vier einfachen Modifikatoren, mehr brauchen wir am

09:16.610 --> 09:17.130
Anfang nicht.

09:18.250 --> 09:20.450
Dann kommt der Rückgabedatentyp.

09:20.810 --> 09:23.300
Ich zeige Ihnen, wie der funktioniert, an einigen Beispielen.

09:24.790 --> 09:30.050
Entweder ist der Rückgabedatentyp ein Datentyp, also Int, Byte, Long

09:30.050 --> 09:31.550
oder eine Referenz oder ein Feld.

09:32.150 --> 09:35.830
Oder Sie benutzen das Schlüsselwort Void, um anzudeuten, dass Ihre

09:35.830 --> 09:37.110
Methode nichts zurückgibt.

09:37.290 --> 09:40.690
Das hier ist ein Beispiel für eine Methode, die nichts zurückgibt.

09:40.830 --> 09:42.550
Public, Static, Void, Main kennen Sie ja.

09:43.090 --> 09:45.270
Die gibt einfach nur Hallo aus und tut sonst nichts.

09:45.270 --> 09:48.990
Aber derjenige, der die Methode aufgerufen hat, in dem Fall die Java

09:48.990 --> 09:51.430
Virtual Machine, bekommt keinen Rückgabewert.

09:52.030 --> 09:53.630
Ich gehe mal die einzelnen Teile durch.

09:53.730 --> 09:57.350
Die ist Public, Static, das heißt, sie ist öffentlich sichtbar und

09:57.350 --> 09:58.750
unabhängig von einem Objekt.

09:58.850 --> 10:01.930
Man kann sie aufrufen, auch wenn noch kein Objekt mit New erzeugt

10:01.930 --> 10:02.250
worden ist.

10:02.330 --> 10:03.690
Das muss bei der Hauptmethode so sein.

10:04.310 --> 10:07.290
Sie hat den Rückgabetyp Void, das heißt, sie gibt keinen Wert zurück,

10:07.450 --> 10:08.250
sie berechnet nichts.

10:09.130 --> 10:11.930
Sie heißt Main, muss bei der Hauptmethode so sein.

10:12.890 --> 10:17.330
Sie bekommt ein Feld aus Strings als Parameter.

10:18.050 --> 10:20.910
Das ist in der Regel leer, wenn Sie das Programm mit Eclipse starten.

10:21.270 --> 10:24.270
Wenn Sie das Programm von der Linux-Konsole aus starten, haben Sie die

10:24.270 --> 10:27.430
Möglichkeit, dem Programm Parameter mitzugeben und die landen dann in

10:27.430 --> 10:28.230
diesem String-Feld.

10:28.730 --> 10:30.850
Das benutzen wir aber bei uns im Vorkurs noch nicht.

10:30.970 --> 10:31.870
Später brauchen Sie das.

10:32.730 --> 10:36.970
Und innerhalb der geschweiften Klammern ist der Rumpf oder der Körper

10:36.970 --> 10:37.750
dieser Methode.

10:37.890 --> 10:41.070
Der besteht aus den Befehlen, die in der Methode ausgeführt werden.

10:41.070 --> 10:42.910
Das ist hier nur diese eine Zeile.

10:43.930 --> 10:46.770
Anderes Beispiel mit echter Berechnung.

10:47.990 --> 10:48.630
Double Summe.

10:50.350 --> 10:51.650
Modifikatoren gibt es hier keine.

10:52.230 --> 10:54.990
Das heißt, der Sichtbarkeitsbereich ist weder Public noch Private,

10:55.230 --> 10:57.570
sondern auf Ihr Eclipse-Projekt beschränkt.

10:58.350 --> 11:00.290
Das ist auch das, was man in der Regel haben möchte.

11:01.370 --> 11:04.230
Rückgabetyp ist Double, das heißt, derjenige, der diese Methode

11:04.230 --> 11:07.650
aufruft, erwartet, dass er eine reelle Zahl als Rückgabewert bekommt.

11:09.090 --> 11:10.590
Der Name ist Summe.

11:10.890 --> 11:12.390
Der beschreibt auch, was die Methode tut.

11:12.630 --> 11:15.590
Wenn es zu kompliziert ist, machen Sie einen Kommentar darüber, der

11:15.590 --> 11:16.850
sagt, was die Methode tut.

11:18.170 --> 11:21.670
Die Methode bekommt zwei Eingabewerte, Double A und Double B, die

11:21.670 --> 11:22.830
werden durch Komma getrennt.

11:24.050 --> 11:27.810
Also jemand, der diese Summe aufruft, muss zwei Eingabewerte

11:27.810 --> 11:29.910
mitliefern, in den runden Klammern.

11:29.910 --> 11:33.710
Und der Körper nimmt diese beiden Eingabewerte, berechnet die Summe

11:33.710 --> 11:37.650
von den beiden und liefert das Ergebnis hier als diesen Rückgabedouble

11:37.650 --> 11:38.110
zurück.

11:39.390 --> 11:40.370
Relativ einfach.

11:40.470 --> 11:44.150
Normalerweise würden es ja in einer Methode kompliziertere Dinge tun.

11:45.110 --> 11:48.130
Aufrufen ist, wenn die Methode mal da ist, relativ einfach.

11:48.310 --> 11:51.690
Sie erzeugen sich zum Beispiel ein Objekt, hier ein Student S mit New.

11:52.450 --> 11:56.150
Und das ist ein typischer Methodenaufruf über einen Referenzpunkt ohne

11:56.150 --> 11:58.270
Parameter und ohne Rückgabewerte.

11:58.270 --> 11:59.950
Sie führen die Methode einfach nur aus.

12:00.310 --> 12:02.230
Die bekommt nichts und liefert nichts zurück.

12:03.270 --> 12:05.990
Das ist eine Methode, die was bekommt und auch was zurückliefert.

12:06.110 --> 12:08.450
Math.pow haben Sie ja öfters schon benutzt.

12:08.770 --> 12:12.170
Die bekommt zwei Eingabewerte und liefert einen Double als

12:12.170 --> 12:15.170
Rückgabewert und den speichern Sie typischerweise in der Variablen,

12:15.470 --> 12:16.310
müssen es aber nicht.

12:16.390 --> 12:19.350
Sie können Rückgabewerte von Methoden, wie zum Beispiel hier diesen

12:19.350 --> 12:22.290
Sinuswert, auch direkt in einem Vergleich auswerten.

12:22.850 --> 12:25.970
Der kriegt sozusagen keine Variable, sondern wird nur für diesen einen

12:25.970 --> 12:27.310
Vergleich benutzt und ist dann weg.

12:27.310 --> 12:30.150
Oder Sie können den Rückgabewert auch verwerfen.

12:30.770 --> 12:34.390
Also wenn Sie so etwas schreiben, Math.random, dieses Math.random

12:34.390 --> 12:37.250
produziert eine Zufallszahl, aber wenn Sie die nicht in eine Variable

12:37.250 --> 12:39.050
geben, dann verschwindet die einfach.

12:39.370 --> 12:41.270
Die wird sozusagen berechnet und sofort weggeworfen.

12:41.790 --> 12:42.570
Ist nicht verboten.

12:45.370 --> 12:46.570
Haben Sie dazu Fragen?

12:46.730 --> 12:47.850
Verstehen Sie diese Aufrufe?

12:47.890 --> 12:49.590
Die haben Sie ja die ganze Zeit schon vorgenommen.

12:50.170 --> 12:51.610
Nur jetzt wird das systematisiert.

12:51.610 --> 12:53.890
Ja, das ist eine gute Frage.

12:54.030 --> 12:58.470
Die runden Klammern gehören zur Signatur, zur Parameterliste dazu.

12:59.190 --> 13:01.190
Die geschweiften Klammern gehören zum Körper.

13:02.470 --> 13:05.950
Ob jetzt die geschweifte Klammer als Symbol selbst zum Körper gehört

13:05.950 --> 13:08.930
oder ob das, was durch sie eingeklammert wird, der Körper ist, das ist

13:08.930 --> 13:10.170
irgendwie eine philosophische Frage.

13:10.810 --> 13:12.910
Denn die Klammer selbst wird ja nicht ausgeführt, sondern nur die

13:12.910 --> 13:14.210
Befehle, die hinter der Klammer sind.

13:14.670 --> 13:17.350
Das werden Sie in Ihrer Programmieren-Vorlesung noch exakt machen.

13:17.350 --> 13:21.770
Aber jetzt im Moment, also wenn Sie sich an meine Folien halten, ist

13:21.770 --> 13:23.850
der Bereich zwischen den Klammern der Körper.

13:24.490 --> 13:25.530
Das, was hier orange ist.

13:26.390 --> 13:29.410
Da müssen Sie aber darauf achten, wie das dann auf den Folien von

13:29.410 --> 13:30.930
Ihrer ersten Vorlesung aussieht.

13:31.070 --> 13:33.010
Es kann sein, dass Ihr Professor das anders haben möchte.

13:34.030 --> 13:36.350
Das kommt darauf an, was er später damit tun möchte.

13:38.230 --> 13:38.510
Gut.

13:39.630 --> 13:40.610
Methoden aufrufen.

13:41.150 --> 13:42.830
Ein paar weitere Beispiele.

13:42.830 --> 13:44.890
System.out.println kennen Sie schon.

13:45.630 --> 13:49.490
Und genau genommen haben Sie da eine Systembibliothek, die Funktionen

13:49.490 --> 13:50.970
Ihres Betriebssystems realisiert.

13:51.550 --> 13:55.350
Darin das Objekt out, das ist der Ausgabedatenstrom von Java und von

13:55.350 --> 14:00.090
dem rufen Sie die println-Methode auf und geben diesen Parameter hier

14:00.090 --> 14:00.290
mit.

14:00.670 --> 14:03.410
Das haben Sie ja permanent schon getan, aber jetzt machen wir das halt

14:03.410 --> 14:06.110
etwas systematischer, was diese Bestandteile bedeuten.

14:06.770 --> 14:07.690
Das hier auch.

14:08.070 --> 14:09.730
Da gibt es eine Klasse, die heißt Math.

14:09.910 --> 14:11.710
Die hat eine Methode, die heißt Pow.

14:11.830 --> 14:13.330
Und die bekommt zwei Parameter.

14:15.290 --> 14:16.650
Das da kennen Sie vielleicht auch schon.

14:16.730 --> 14:19.510
Wenn Sie einen String s haben und den fragen, wie lang er ist,

14:19.990 --> 14:22.210
benutzen Sie s.length, Klammer auf Klammer zu.

14:22.370 --> 14:25.290
Das ist eine Methode, die berechnet, wie lang dieser String ist.

14:25.370 --> 14:26.210
Die geht Ihnen wirklich durch.

14:26.870 --> 14:28.070
Bei Feldern ist das anders.

14:28.450 --> 14:31.650
Da fragen Sie mit feld.length ohne runde Klammern.

14:31.650 --> 14:34.130
Das ist keine Methode, das ist ein Attribut.

14:34.270 --> 14:36.330
Das ist eine Zahl, die in dieser Referenz drin steht.

14:36.710 --> 14:37.810
Die fragen Sie einfach ab.

14:38.570 --> 14:38.890
Warum?

14:39.450 --> 14:41.870
Können Sie sich aus den Bemerkungen, die ich letzte Woche darüber

14:41.870 --> 14:45.650
gemacht habe, erklären, warum das bei Feldern ein Attribut ist und

14:45.650 --> 14:47.130
beim String eine Methode?

14:47.290 --> 14:50.350
Was ist denn bei Strings anders als bei Feldern?

14:50.670 --> 14:51.650
Gibt es zwei Gründe.

14:54.030 --> 14:55.670
Warum muss man bei einem String rechnen?

14:55.750 --> 14:58.030
Warum kann man nicht einfach zählen, wie viele Zeichen da drin sind?

14:58.830 --> 15:01.350
Er sagt, Strings sind erstmal eine Klasse.

15:03.710 --> 15:06.450
Eine Klasse könnte aber auch ein Attribut length anbieten.

15:06.570 --> 15:07.510
Warum macht sie es denn nicht?

15:08.350 --> 15:10.310
Strings verlängern und verkürzen sich sehr oft.

15:10.450 --> 15:13.550
Deshalb wird die Länge da nicht immer aktualisiert, sondern immer zu

15:13.550 --> 15:15.370
dem Zeitpunkt ausgerechnet, wo Sie das fragen.

15:15.770 --> 15:18.110
Es gibt aber noch einen anderen, viel wichtigeren Grund.

15:18.210 --> 15:18.870
Sogar noch zwei.

15:20.890 --> 15:23.110
Das ist jetzt sozusagen eine Effizienzentscheidung.

15:23.110 --> 15:26.210
Dass man sagt, Stringe verkürzen und verlängern sich so oft, da ist es

15:26.210 --> 15:28.130
besser, die Länge immer konkret auszurechnen.

15:29.590 --> 15:32.570
Ja, allerdings ist die hier auch so gemacht, dass Sie die von außen

15:32.570 --> 15:33.390
nicht verändern können.

15:33.470 --> 15:35.290
Wenn Sie das versuchen, kriegen Sie eine Fehlermeldung.

15:35.970 --> 15:36.570
Das geht schon.

15:37.470 --> 15:39.130
Obwohl Sie als Grund natürlich recht haben.

15:39.190 --> 15:41.510
Sie wollen natürlich nicht, dass jemand von außen in der Länge von

15:41.510 --> 15:43.390
Ihrem String oder von Ihrem Feld rumschreibt.

15:44.590 --> 15:47.170
Was habe ich Ihnen letzte Woche denn zu den Strings erklärt?

15:47.270 --> 15:48.410
Die hatten einige Besonderheiten.

15:48.450 --> 15:51.010
Die durften Sie zum Beispiel nicht mit gleich gleich vergleichen.

15:52.150 --> 15:53.170
Woran lag das denn?

15:53.910 --> 15:54.210
Genau.

15:54.610 --> 15:56.970
Die Strings werden optimiert verwaltet.

15:57.410 --> 16:00.850
Wenn Sie ganz, ganz viele Strings im Speicher abgelegt haben, in denen

16:00.850 --> 16:03.350
das gleiche drinsteht, dann wird Java das optimieren und die alle an

16:03.350 --> 16:04.270
die gleiche Stelle legen.

16:04.910 --> 16:07.290
Und deshalb kann man nicht vorhersehen, wie lang die sind, sondern

16:07.290 --> 16:08.150
muss es ausrechnen.

16:08.210 --> 16:09.330
Das ist der erste wichtige Grund.

16:09.470 --> 16:12.470
Die String-Verwaltung in Java ist sehr, sehr kompliziert.

16:12.710 --> 16:13.770
Es gibt noch einen zweiten Grund.

16:14.290 --> 16:17.490
Und zwar kann man Strings mit verschiedenen Zeichensätzen kodieren.

16:17.490 --> 16:21.370
Sie kennen wahrscheinlich Unicode oder Ice-Code, haben Sie vielleicht

16:21.370 --> 16:22.390
mal in der Schule gehört.

16:23.150 --> 16:26.110
Und die Frage, wie viele Schriftzeichen in diesem String drin sind,

16:26.230 --> 16:29.070
ist eine völlig andere als die Frage, wie viele Bytes der im Speicher

16:29.070 --> 16:29.410
belegt.

16:30.150 --> 16:30.550
Leider.

16:30.830 --> 16:33.970
Also Unicode braucht zum Beispiel jedes Zeichen, wenn Sie 16-Bit

16:33.970 --> 16:35.430
haben, zwei Bytes.

16:36.250 --> 16:38.550
Deshalb muss die Methode auch noch ein bisschen rechnen und kann nicht

16:38.550 --> 16:39.570
einfach nur die Länge fragen.

16:40.330 --> 16:42.090
Okay, das ist aber nur so am Rande.

16:42.530 --> 16:44.550
Das ist etwas, was Sie sich einfach merken müssen, um später

16:44.550 --> 16:45.830
Syntaxfehler zu vermeiden.

16:45.830 --> 16:49.730
Bei Strings fragen Sie die Länge über eine Methode ab und bei Feldern

16:49.730 --> 16:50.890
über ein Attribut.

16:51.930 --> 16:53.930
Das ist in vielen Programmiersprachen anders.

16:56.050 --> 16:58.950
Gut, Programmcode gibt es in Java generell nur in Methoden.

16:59.030 --> 17:01.890
Sie dürfen gar keine Befehle außerhalb von Methoden haben.

17:02.070 --> 17:04.110
Das haben Sie vielleicht schon gemerkt, wenn Sie vergessen, Ihre

17:04.110 --> 17:05.950
Public Static Fold Main reinzuschreiben.

17:06.490 --> 17:09.390
Und Befehle schreiben, dass Sie dann rote Fehlabmeldungen von Eclipse

17:09.390 --> 17:10.790
kriegen und Sie wissen nicht, wo die herkommen.

17:11.230 --> 17:14.770
Es ist grundsätzlich so, Befehle darf es nur in Methoden geben.

17:15.510 --> 17:17.890
Methoden darf es nur in Klassen geben und wenn Sie wollen, können Sie

17:17.890 --> 17:19.550
die auch noch zu Packages zusammenfassen.

17:19.630 --> 17:21.570
Das machen wir halt im Vorkurs nicht, weil wir hier keine riesen

17:21.570 --> 17:22.790
Programmbibliotheken schreiben.

17:23.990 --> 17:27.150
Grundsätzlich ist es aber so organisiert und bei Java ist es auch so

17:27.150 --> 17:29.710
gedacht, dass Sie Packages aus dem Internet runterladen und

17:29.710 --> 17:30.450
installieren können.

17:30.930 --> 17:34.330
Dann sind da Klassen drin, die Sie mit new instanziieren können und

17:34.330 --> 17:36.110
davon können Sie dann Methoden aufrufen.

17:36.330 --> 17:37.090
So ist das gedacht.

17:37.530 --> 17:39.150
Nur im Vorkurs schreiben wir halt alles selbst.

17:39.530 --> 17:40.470
Deshalb sehen Sie das nicht.

17:41.910 --> 17:45.570
Das Prinzip dabei ist, eine Methode hat eine Signatur, das ist die

17:45.570 --> 17:47.930
einleitende Zeile, die beschreibt, was die Methode tut.

17:48.470 --> 17:50.550
Mit Parameter, Rückgabewerten und Modifikatoren.

17:51.030 --> 17:53.450
Diese Information ist für jeden, der das Package hat, sozusagen

17:53.450 --> 17:53.930
sichtbar.

17:54.590 --> 17:57.710
Und dann gibt es den Rumpf oder Körper, der beschreibt, wie die

17:57.710 --> 17:58.670
Methode etwas tut.

17:58.750 --> 18:01.430
Und das sieht nur der Programmierer, der das Package erstellt hat, in

18:01.430 --> 18:01.790
der Regel.

18:01.790 --> 18:05.390
Wenn Sie die .java-Datei nicht mitgeben, sondern nur diese .class

18:05.390 --> 18:10.110
-Datei, haben Sie keine Möglichkeit, um herauszukriegen, wie der

18:10.110 --> 18:12.370
Programmierer diese Methode jetzt konkret geschrieben hat.

18:12.510 --> 18:13.970
Und das sollte Sie auch nicht interessieren.

18:14.550 --> 18:17.510
Denn der Programmierer muss die Möglichkeit haben, seinen Rumpf später

18:17.510 --> 18:18.190
auszutauschen.

18:18.230 --> 18:21.410
Wenn er einen besseren Algorithmus gefunden hat, wo er etwas anpassen

18:21.410 --> 18:24.230
möchte, ohne dass das übergeordnete Programm verändert werden soll.

18:24.810 --> 18:27.690
Das Vorgehen ist also, dass Sie erst einmal, wenn Sie die Methode

18:27.690 --> 18:31.110
machen, die Methode genau beschreiben, durch Kommentare zum Beispiel.

18:31.430 --> 18:34.470
Dann entwerfen Sie eine Signatur mit den fünf Bestandteilen, die Sie

18:34.470 --> 18:35.270
vorhin gelernt haben.

18:35.830 --> 18:38.970
Und dann erst schreiben Sie den Körper mit den eigentlichen Befehlen.

18:39.650 --> 18:40.810
Und das üben wir jetzt mal.

18:41.030 --> 18:45.330
Und zwar sei die Aufgabe, einen Mittelwert einer beliebigen Zahl von

18:45.330 --> 18:47.170
Zahlen in einer Methode zu berechnen.

18:47.750 --> 18:51.250
Da gebe ich Ihnen mal vor, wie Sie die Signatur designen und Sie

18:51.250 --> 18:52.210
schreiben dann den Körper.

18:52.210 --> 18:55.450
Also zunächst einmal, es soll ein Mittelwert berechnet werden.

18:55.610 --> 18:59.410
Das heißt, wenn es beliebig viele Zahlen sind, bekommt die Methode ein

18:59.410 --> 19:02.210
Feld aus Doubles als Eingabewert.

19:02.470 --> 19:04.130
Das ist hier diese Parameterliste.

19:04.330 --> 19:06.690
Ein Feld aus Doubles und das nennen wir x.

19:07.590 --> 19:10.490
Dann soll die Methode einen Mittelwert ausrechnen, also ist der

19:10.490 --> 19:13.130
Rückgabetyp dieser Methode auch wieder ein Double.

19:13.530 --> 19:14.390
Und zwar dieser hier.

19:15.130 --> 19:18.470
Dieses Wort Double beschreibt den Rückgabetyp der Methode.

19:18.470 --> 19:21.470
Jetzt müssen Sie sich fragen, Static oder nicht.

19:22.710 --> 19:24.630
Static haben wir noch gar nicht gelernt, was das heißt.

19:24.790 --> 19:26.450
Static heißt unabhängig vom Objekt.

19:26.590 --> 19:29.670
Sie können die Methode schon benutzen, obwohl noch kein Objekt da ist.

19:29.770 --> 19:33.350
Wenn Sie so Funktionen haben, wie Sinus oder Mittelwert oder

19:33.350 --> 19:36.890
irgendetwas, wo Sie eine Eingabe und eine Ausgabe haben, aber es hängt

19:36.890 --> 19:39.970
gar nicht von einem konkreten Objekt ab, dann ist das immer Static.

19:40.150 --> 19:41.330
Werden wir morgen genau machen.

19:42.050 --> 19:43.690
Also sieht die Signatur so aus.

19:43.830 --> 19:47.030
Static, Double, Mittelwert, Klammer auf, Double, Klammer auf, Klammer

19:47.030 --> 19:49.510
zu, x, runde Klammer zu.

19:49.590 --> 19:50.470
Das ist nur die Signatur.

19:51.170 --> 19:54.170
Alle damit einverstanden oder könnte man noch was modifizieren?

19:55.210 --> 19:56.770
Da gibt es mehrere Möglichkeiten.

19:56.930 --> 19:58.130
Was könnte man denn anders machen?

19:58.850 --> 20:00.870
Könnte man noch mehr Modifikatoren davor schreiben?

20:01.250 --> 20:02.390
Ja, Listen kennen wir aber noch nicht.

20:02.570 --> 20:03.310
Da haben Sie schon recht.

20:03.810 --> 20:09.310
Liste ist ein anderer Datentyp, um eine unspezifizierte Anzahl von

20:09.310 --> 20:12.390
elementaren Variablen zu speichern, aber kennen wir noch nicht.

20:13.970 --> 20:15.030
Da bleibt uns nur das Feld.

20:15.570 --> 20:17.750
Könnte man noch andere Modifikatoren davor schreiben?

20:18.790 --> 20:20.170
Zwei Möglichkeiten gibt es noch.

20:20.910 --> 20:24.310
Sie könnten es auf Public setzen, Mittelwert ausrechnen ist jetzt kein

20:24.310 --> 20:26.350
Geheimnis, wäre eine Möglichkeit.

20:26.850 --> 20:28.390
Könnte ich da auch ein Final davor schreiben?

20:30.330 --> 20:31.750
Das ist eine Frage an die Experten.

20:32.230 --> 20:35.250
Das heißt ja nicht, dass der Mittelwert unveränderlich ist, sondern es

20:35.250 --> 20:37.590
heißt, dass die Methode unveränderlich ist.

20:37.650 --> 20:38.430
Sinnvoll oder nicht?

20:39.430 --> 20:41.330
Da bin ich gar nicht so sicher.

20:43.370 --> 20:46.490
Das könnte sein, dass Sie recht haben, aber nehmen wir mal an, es wäre

20:46.490 --> 20:47.110
erlaubt.

20:47.770 --> 20:50.450
Wäre es in der Situation sinnvoll, die auf Final zu setzen?

20:50.550 --> 20:54.410
Oder könnte es irgendwie sinnvoll sein, bei gleicher Signatur den

20:54.410 --> 20:56.490
Rumpf, der da hinten dran ist, irgendwann zu überschreiben?

20:57.210 --> 20:59.450
Ja, Sie dürfen sie nicht überschreiben oder überladen.

21:00.890 --> 21:03.830
Oder Ihnen fällt ein besserer Algorithmus ein, um den zu berechnen.

21:04.010 --> 21:05.490
Und dann wollen Sie die vielleicht überschreiben.

21:05.590 --> 21:06.930
Also Final möchte ich da nicht haben.

21:07.210 --> 21:10.570
Es könnte sein, dass es für Static sowieso nicht erlaubt ist, aber man

21:10.570 --> 21:11.350
möchte es da nicht haben.

21:11.850 --> 21:13.250
Gut, jetzt haben wir also das hier.

21:13.470 --> 21:15.150
Das steht so in Ihrer Java-Datei drin.

21:15.230 --> 21:16.970
Static Double Mittelwert, Double X.

21:17.870 --> 21:19.650
Und dann soll ein Mittelwert M berechnet werden.

21:19.710 --> 21:21.110
Das machen Sie jetzt auf einem Blatt Papier.

21:21.790 --> 21:23.850
Und dann wird der mit Return M zurückgegeben.

21:23.950 --> 21:26.950
Fügen Sie mal die passenden Code-Zeilen ein, da wo die Punkte sind.

21:27.610 --> 21:30.930
Das X dürfen Sie dabei wie eine ganz normale Variable benutzen.

21:31.010 --> 21:31.650
Das ist schon da.

21:31.850 --> 21:32.810
Das müssen Sie auch nicht füllen.

21:33.350 --> 21:35.610
Das hat Ihnen der Aufrufer von der Methode ja gegeben.

21:36.190 --> 21:38.610
Gut, Mittelwert berechnen sollten Sie ja mittlerweile können.

21:39.430 --> 21:40.630
Diktieren Sie mir mal was.

21:41.690 --> 21:45.410
Klasse und Methodensignatur habe ich Ihnen schon vorgegeben.

21:46.230 --> 21:47.330
Was schreibe ich da rein?

21:47.610 --> 21:50.110
Also da mache ich eine Schleife von K gleich 0.

21:50.330 --> 21:51.170
Wie lange läuft denn die?

21:51.390 --> 21:52.250
Wie groß ist denn das?

21:52.310 --> 21:53.190
Wie kriege ich denn das raus?

21:54.250 --> 21:56.650
X-Punkt-Length ohne runde Klammern, genau.

21:57.910 --> 22:03.590
K++ Und wie Sie richtig gesagt haben addiere ich die Sachen aus dem

22:03.590 --> 22:04.530
Feld zusammen.

22:05.050 --> 22:10.850
M gleich M plus XK Soweit alle einverstanden?

22:11.030 --> 22:13.950
Ich behaupte an der Stelle gibt es schon einen Syntax-Fehler in

22:13.950 --> 22:14.370
Eclipse.

22:14.990 --> 22:16.170
Eine Winzigkeit fehlt.

22:16.810 --> 22:18.270
Ja, M hat noch keinen Wert.

22:18.470 --> 22:20.670
Dann müssen Sie mit M... mit was fangen Sie an?

22:21.630 --> 22:22.570
0, genau.

22:23.710 --> 22:25.810
In Java ist 0 was anderes als nichts.

22:26.230 --> 22:28.490
Wenn nichts drin ist, kriegen Sie ja den Fehler, dass die Variante

22:28.490 --> 22:29.750
noch nicht initialisiert ist.

22:30.550 --> 22:30.750
Okay.

22:31.570 --> 22:32.350
Soweit zufrieden?

22:33.810 --> 22:35.470
Soweit fertig oder fehlt noch was?

22:36.830 --> 22:38.890
Syntaktisch jetzt richtig, semantisch aber noch nicht.

22:39.190 --> 22:42.410
Ja, Sie müssen den Gesamtwert durch die Feldlänge nochmal teilen,

22:42.590 --> 22:42.810
genau.

22:43.150 --> 22:44.190
Sonst ist es ja nicht der Mittelwert.

22:45.490 --> 22:46.170
Soweit okay?

22:46.990 --> 22:47.850
Alle zufrieden?

22:50.090 --> 22:52.030
Denken Sie dran, was ich Ihnen gesagt habe.

22:52.290 --> 22:55.930
Sie müssen davon ausgehen, dass derjenige, der diese Methode aufruft,

22:56.350 --> 22:58.710
entweder unfähig oder böswillig ist.

22:58.890 --> 23:02.050
Sie müssen alle Fälle abprüfen, wo das, was Sie da programmiert haben,

23:02.110 --> 23:05.570
scheitern könnte, weil Ihnen der Aufrufer hier irgendeinen Schrott

23:05.570 --> 23:06.190
gegeben hat.

23:06.830 --> 23:08.790
Es gibt zwei Möglichkeiten, dass das Schrott ist.

23:08.990 --> 23:09.330
Welche?

23:10.550 --> 23:12.250
Ja, das ist die erste Möglichkeit.

23:12.530 --> 23:15.590
Es könnte sein, dass man Ihnen ein leeres Feld gegeben hat.

23:15.590 --> 23:17.770
Und das fragen Sie mit einer IF-Abweisung einfach ab.

23:18.490 --> 23:20.530
IF x.Length gleich 0.

23:21.090 --> 23:22.390
Geben wir mal 0 zurück.

23:23.030 --> 23:25.030
Und rechnen den Rest sozusagen nicht aus.

23:28.130 --> 23:30.830
Klammer das auch ein bisschen ein, dass Sie da die Struktur sehen.

23:31.330 --> 23:34.770
Wenn die Länge des Feldes 0 ist, dann machen Sie das nicht.

23:35.550 --> 23:38.450
Und die Berechnung da unten machen Sie nur, wenn sichergestellt ist,

23:39.610 --> 23:41.790
dass das mindestens ein Element hat.

23:43.450 --> 23:44.150
So besser?

23:45.730 --> 23:48.750
Das ist die erste Möglichkeit, wie der Aufrufer Sie reinlegen könnte,

23:48.810 --> 23:49.630
aber es gibt noch eine zweite.

23:51.130 --> 23:54.130
Es könnte noch schlimmer sein, als dass das Feld leer ist.

24:01.310 --> 24:04.650
Wie ich vorhin gesagt habe, nichts ist was anderes als Null und nichts

24:04.650 --> 24:06.610
ist auch was anderes als ein leeres Feld.

24:07.510 --> 24:08.310
Ja, genau.

24:08.410 --> 24:09.990
Es könnte sein, dass das gar kein Feld ist.

24:10.190 --> 24:11.330
Also, wie prüfen Sie das denn?

24:11.590 --> 24:12.790
Was ist das Schlüsselwort?

24:14.050 --> 24:14.850
Null, genau.

24:14.950 --> 24:18.070
Das ist nicht die Zahl 0, sondern das ist das Schlüsselwort für eine

24:18.070 --> 24:19.830
Referenz, die noch nicht belegt ist.

24:20.830 --> 24:24.810
Ja, also nichts ist etwas anderes als ein leeres Feld und ein leeres

24:24.810 --> 24:27.090
Feld ist etwas anderes als ein Feld, wo eine 0 drinsteht.

24:27.210 --> 24:29.470
Das ist in der Mathematik später auch so.

24:31.370 --> 24:34.250
Okay, in dem Fall würden Sie auch 0 und vielleicht irgendwie eine

24:34.250 --> 24:35.470
Fehlermeldung ausgeben.

24:36.630 --> 24:39.230
Das sollten Sie eigentlich später über Exceptions machen, aber die

24:39.230 --> 24:39.950
kennen wir noch nicht.

24:42.990 --> 24:44.610
Das würde ich jetzt mal so machen.

24:46.810 --> 24:49.130
So, jetzt sind alle Möglichkeiten abgeprüft.

24:49.250 --> 24:52.110
Dieses Programm funktioniert in jedem Fall ganz egal, was Ihnen der

24:52.110 --> 24:53.370
Aufrufer da serviert hat.

24:54.810 --> 24:55.690
Alle einverstanden?

24:57.030 --> 24:58.290
Das werden wir später lernen.

24:58.370 --> 25:00.110
Dieser Return-Befehl bricht die Methode ab.

25:00.230 --> 25:01.510
Eigentlich brauche ich es da unten auch nicht.

25:03.330 --> 25:05.930
Return übergibt den Rückgabewert und bricht die Methode ab.

25:05.990 --> 25:07.330
Das machen wir aber gleich noch im Detail.

25:08.030 --> 25:12.310
Gut, es kann sein, dass das auf meiner Lösung jetzt nicht so ist, weil

25:12.310 --> 25:14.310
ich auf der Folie nicht so viel Platz gehabt habe.

25:16.550 --> 25:17.290
Schauen wir mal.

25:17.430 --> 25:20.370
Ja, ich habe es nicht geprüft, aber das hat reine Platzgründe.

25:20.730 --> 25:22.130
Sie müssen es ab jetzt immer prüfen.

25:24.050 --> 25:28.550
Gut, wenn die Methode mal da ist, dann kann man sie so benutzen.

25:28.550 --> 25:30.530
Also das ist jetzt eine Klasse.

25:31.130 --> 25:34.370
Da gibt es dieses StaticDoubleMittelwert, was wir eben programmiert

25:34.370 --> 25:34.650
haben.

25:35.130 --> 25:38.470
Und unten gibt es eine PublicStaticVoidMain, das ist die Methode, wo

25:38.470 --> 25:40.830
die Java Virtual Machine die Ausführung startet.

25:41.510 --> 25:43.070
Die legt jetzt erstmal ein Feld an.

25:43.210 --> 25:45.910
Double, Klammer, Aufklammer zu Werte gleich New Double 3.

25:46.310 --> 25:47.910
Feld mit drei Einträgen drin.

25:48.490 --> 25:50.090
Schreibt drei Werte rein.

25:50.750 --> 25:52.210
Werte 0, Werte 1, Werte 2.

25:52.710 --> 25:55.030
Und ruft dann diese Mittelwertmethode auf.

25:56.250 --> 25:59.070
Warum muss ich hier keinen Referenzpunkt davor schreiben?

25:59.970 --> 26:04.110
Schauen wir mal, ob Sie sich an die vorvorvorletzte Folie erinnern.

26:06.610 --> 26:09.730
Was macht Java, wenn nichts vor dem Referenzpunkt steht oder der Punkt

26:09.730 --> 26:10.190
nicht da ist?

26:11.610 --> 26:15.850
Wenn keine Referenz gegeben ist, sucht Java die Methode in der Klasse,

26:15.970 --> 26:16.730
wo Sie gerade sind.

26:16.850 --> 26:17.910
Und da ist sie auch tatsächlich.

26:18.730 --> 26:21.490
Das liegt jetzt aber daran, dass es in der gleichen Datei ist.

26:21.650 --> 26:22.750
Sonst würde das nicht funktionieren.

26:22.750 --> 26:27.350
Die könnten Sie auch private machen, weil die in der gleichen Klasse

26:27.350 --> 26:27.670
ist.

26:27.990 --> 26:28.590
Das ist richtig.

26:29.490 --> 26:31.810
Wollen wir aber nicht, weil Mittelwert ausrechnen soll.

26:32.210 --> 26:33.150
Ist ja kein Geheimnis.

26:34.490 --> 26:35.690
Okay, weitere Fragen.

26:36.130 --> 26:37.290
Verstehen Sie die Anwendung?

26:37.490 --> 26:40.110
Was übergeben Sie denn hier in den runden Klammern?

26:41.230 --> 26:42.310
Was ist das ganz genau?

26:44.230 --> 26:45.810
Auch das müssen Sie verstanden haben.

26:46.930 --> 26:49.710
Sie übergeben die Referenz auf das Feld.

26:49.790 --> 26:52.850
Sie übergeben nicht so ein langes Feld, sondern Sie übergeben nur

26:52.850 --> 26:54.210
diesen Pfeil, der da drauf zeigt.

26:54.810 --> 26:57.770
Und deshalb müssen Sie da oben auch prüfen, ob der Pfeil überhaupt da

26:57.770 --> 27:00.230
ist und ob hinter dem Pfeil überhaupt Werte hängen.

27:01.370 --> 27:02.470
Ganz genau so ist das.

27:02.630 --> 27:05.190
Double M gleich Mittelwert, Klammer auf Werte, Klammer zu.

27:05.290 --> 27:08.150
So rufen Sie das auf und dann ist in M der Mittelwert drin und mehr

27:08.150 --> 27:09.110
tut das Programm nicht.

27:09.630 --> 27:10.210
Fragen dazu?

27:11.070 --> 27:11.930
Sie müssen beides können.

27:12.570 --> 27:15.890
Methoden so designen und unten dann richtig aufrufen.

27:17.590 --> 27:19.590
Okay, ich fasse Ihnen das mal zusammen.

27:19.590 --> 27:23.470
Eine Methode in Java fasst Programmcode zusammen, der eine bestimmte

27:23.470 --> 27:24.430
Aufgabe, wie z.B.

27:24.510 --> 27:26.050
ein Mittelwert ausrechnen, erfüllen soll.

27:26.490 --> 27:29.470
Sie kann Parameter erhalten, in runden Klammern, muss aber nicht.

27:29.970 --> 27:31.730
Sie kann ein Ergebnis produzieren.

27:32.030 --> 27:34.170
Das wird mit Return zurückgegeben, muss aber nicht.

27:34.930 --> 27:37.190
Sie kann beliebig oft verwendet werden, wenn sie mal da ist.

27:37.690 --> 27:40.470
Und in der Regel gehört sie zu einem Objekt, außer wenn Sie sie

27:40.470 --> 27:41.570
statisch deklariert haben.

27:43.070 --> 27:46.770
Sie kann Attribute des eigenen Objekts einsetzen, außer wenn es

27:46.770 --> 27:48.390
statisch ist und gar kein Objekt da ist.

27:48.390 --> 27:50.730
Und sie kann andere Methoden aufrufen.

27:50.930 --> 27:54.290
Wenn Sie das strukturiert einhalten, dann bekommen Sie strukturierten

27:54.290 --> 27:58.070
und verständlichen Code, der in sachlich getrennte Programmstücke

27:58.070 --> 28:01.690
unterteilt ist, sodass es austauschbar und erweiterbar ist.

28:01.750 --> 28:04.570
Das gehört zu diesem objektorientierten Konzept dazu.

28:05.150 --> 28:07.810
Programme, die Sie so schreiben, sind leicht modifizierbar und

28:07.810 --> 28:12.490
erweiterbar, weil Sie Methoden verwenden, verbessern, austauschen oder

28:12.490 --> 28:13.750
überschreiben können.

28:14.910 --> 28:16.230
Ein weiteres Beispiel.

28:17.090 --> 28:19.810
Sie haben vielleicht gestern, haben Sie ja dieses Feld mit den

28:19.810 --> 28:23.170
Vektoren programmiert und da haben Sie gemerkt, dass Java keine Ahnung

28:23.170 --> 28:25.110
hat, wie man Vektoren addiert.

28:25.450 --> 28:27.630
Das kann man Java aber beibringen.

28:27.650 --> 28:31.010
Und zwar, indem Sie so einem Vektor eine Addieremethode mitgeben.

28:31.670 --> 28:35.990
Damit bringen Sie Java sozusagen bei, wie man einen Vektor v zu dem

28:35.990 --> 28:38.450
Vektor, wo Sie gerade sind, dazu addieren kann.

28:38.450 --> 28:43.670
Und die Methode bekommt den Vektor v als Eingabe und addiert zu dem x

28:43.670 --> 28:47.410
von dem Objekt, wo Sie gerade sind, das x von dem v dazu.

28:47.610 --> 28:50.230
Genau so funktioniert ja die Vektoraddition.

28:50.350 --> 28:51.910
Im Programm selbst sieht es so aus.

28:52.610 --> 28:55.410
Vektor v gleich NuVektor mit irgendwelchen Werten drin, Vektor z

28:55.410 --> 28:59.750
gleich NuVektor mit irgendwelchen Werten drin und v Punkt addiere z.

29:00.330 --> 29:03.430
Mit der Methode da oben wirkt dann so, als hätten Sie in der

29:03.430 --> 29:06.090
Mathematik v gleich v plus z geschrieben.

29:07.270 --> 29:08.270
Verstehen Sie das?

29:10.430 --> 29:14.190
Also aus mathematischer Sicht können Sie Java sozusagen beibringen,

29:14.290 --> 29:17.130
welche mathematischen Operationen Ihre Objekte unterstützen.

29:17.790 --> 29:21.090
Und aus objektorientierter Sicht bekommt jetzt dieser Vektor

29:21.090 --> 29:23.990
Programmcode, der zur Verwaltung dieses Vektors dient.

29:27.870 --> 29:30.890
Es ist natürlich ein bisschen umständlich, dass man nicht direkt das

29:30.890 --> 29:32.150
Pluszeichen verwenden darf.

29:32.150 --> 29:34.710
In manchen Programmiersprachen können Sie das Pluszeichen

29:34.710 --> 29:35.290
überschreiben.

29:35.430 --> 29:37.190
In C++ ist das relativ beliebt.

29:37.650 --> 29:39.890
In Java hat man sich entschieden, das nicht zu tun.

29:40.430 --> 29:43.590
Sondern wenn Sie in Java eine neue Rechenoperation programmieren

29:43.590 --> 29:47.550
wollen, wie hier das Addieren von Vektoren, dann müssen Sie der einen

29:47.550 --> 29:48.990
Buchstabennamen geben.

29:49.450 --> 29:50.310
Das wird erzwungen.

29:51.130 --> 29:53.770
Das ist aber auch okay so, Sie sollten den Namen auch so wählen, dass

29:53.770 --> 29:55.330
jeder sofort versteht, was das tut.

29:55.330 --> 29:58.330
Und dann müssen Sie sich einfach nur dran gewöhnen, dass es jetzt eben

29:58.330 --> 30:01.370
nicht mehr V gleich V plus Z heißt, sondern V Punkt Addiere Z.

30:02.150 --> 30:05.830
Das ist das Einzige, wo man sich da umgewöhnen muss.

30:06.970 --> 30:07.830
Zweites Beispiel.

30:08.770 --> 30:11.030
Also ich baue jetzt hier diese Klasse Vektor auf.

30:11.130 --> 30:13.670
Die Methode Addiere ist fertig, deshalb schreibe ich da nur noch

30:13.670 --> 30:14.230
Punkt, Punkt, Punkt.

30:14.550 --> 30:16.710
Und jetzt kriegt der eine Methode Kopie dazu.

30:17.370 --> 30:19.630
Die soll eine Kopie von dem Vektor erzeugen.

30:20.190 --> 30:22.570
Deshalb hat die einen Vektor als Rückgabetyp.

30:22.570 --> 30:25.350
Public Vektor Kopie.

30:26.570 --> 30:30.530
Das tut sie, indem sie einen neuen Vektor erzeugt, die Komponenten

30:30.530 --> 30:30.770
überträgt.

30:31.230 --> 30:34.590
Das ist das X da oben und das Y ist das Y da oben.

30:35.170 --> 30:38.850
Das schreibt sie in diesen neuen Vektor rein und übergibt den an den

30:38.850 --> 30:39.410
Aufrufer.

30:39.790 --> 30:42.370
Und dann kriegt der Aufrufer einen neuen Vektor, in dem das gleiche

30:42.370 --> 30:44.210
drin steht wie im Original.

30:44.690 --> 30:47.630
Die Idee dahinter ist wieder beim objektorientierten Konzept, dass es

30:47.630 --> 30:49.030
an den Vektor delegiert wird.

30:49.030 --> 30:52.130
Der Vektor weiß selbst, welche Bestandteile er kopieren muss.

30:52.250 --> 30:56.090
Er weiß selbst, welche Bestandteile er addieren muss und so weiter.

30:56.690 --> 30:57.850
Verstehen Sie dieses Konzept?

30:58.730 --> 31:02.310
Wenn Sie eine Kopie von einem Vektor machen, schreiben Sie nicht von

31:02.310 --> 31:05.490
außen in den Komponenten rum, sondern Sie programmieren das in den

31:05.490 --> 31:07.150
Vektor rein, dass er es selber tut.

31:08.610 --> 31:09.910
Versuchen Sie das mal,

31:13.030 --> 31:15.530
indem Sie eine Methode schreiben.

31:16.470 --> 31:20.430
Also das Blaue, was schon da ist, außer vielleicht das Betrag, müssen

31:20.430 --> 31:21.290
Sie nicht mit abschreiben.

31:21.810 --> 31:24.910
Aber schreiben Sie mal da eine Methode, die den Betrag des Vektors

31:24.910 --> 31:26.410
ausrechnet und zurückliefert.

31:28.150 --> 31:30.890
Betrag oder Länge eines Vektors wissen alle, was das ist.

31:34.270 --> 31:36.370
Spätestens seit der Hausaufgabe sollten Sie das wissen.

31:41.030 --> 31:42.250
Das ist ein Einzeiler.

31:42.530 --> 31:44.510
Da müssen Sie nicht groß grübeln, sondern das ist nur eine

31:44.510 --> 31:47.110
mathematische Formel, die Sie richtig umsetzen und mit Return

31:47.110 --> 31:47.930
zurückgeben müssen.

31:48.770 --> 31:50.510
Deshalb lasse ich Ihnen da auch gar nicht so viel Zeit.

31:51.670 --> 31:53.230
So, wie lautet die eine Zeile?

31:53.630 --> 31:54.510
Was schreibe ich da rein?

31:55.190 --> 31:56.290
Naja, ist relativ einfach.

31:56.970 --> 32:01.830
Betrag ist Wurzel aus x² plus y² und in Java formuliert würde das

32:01.830 --> 32:06.030
heißen return math.sqrt x mal x plus y mal y.

32:07.270 --> 32:09.110
Das müssen Sie genau so haben.

32:12.150 --> 32:14.810
Und zwar mit diesem x und diesem y da oben.

32:15.410 --> 32:16.310
Hier gibt es kein v.

32:17.710 --> 32:20.310
Das v hier oben gibt es nur in dieser Addiere-Methode.

32:21.890 --> 32:25.590
Das ist gar keine so einfache Frage, von welchem Vektor jetzt dieses x

32:25.590 --> 32:26.990
und dieses y kommt.

32:27.070 --> 32:28.030
Von welchem kommt es denn?

32:29.810 --> 32:32.470
Da müssen Sie jetzt grundlegend erstmal den Unterschied zwischen

32:32.470 --> 32:34.150
Klasse und Objekt verstanden haben.

32:34.150 --> 32:35.850
Die Klasse ist eine Vorlage.

32:36.910 --> 32:37.670
Eine Blaupause.

32:39.110 --> 32:42.190
Irgendjemand muss mit dem new Befehl aus dieser Klasse erstmal einen

32:42.190 --> 32:43.830
konkreten Vektor erzeugt haben.

32:44.430 --> 32:47.250
Und von diesem Vektor aus ruft er die Betrag-Methode auf.

32:47.870 --> 32:51.710
Und dann ist das x von diesem konkreten Vektor und das y von diesem

32:51.710 --> 32:54.270
konkreten Vektor, den er erzeugt hat, gefragt.

32:55.450 --> 32:58.110
Das ist schon das x da oben.

32:58.390 --> 33:01.510
Aber wenn Sie viele Vektoren im Speicher haben, hat jeder sein eigenes

33:01.510 --> 33:02.890
x und jeder sein eigenes y.

33:02.890 --> 33:07.290
Und dann stehen hier diejenigen Werte von dem Objekt, von dem aus die

33:07.290 --> 33:08.850
Betrags -Methode aufgerufen wurde.

33:09.090 --> 33:10.590
Ich mache gleich ein paar Beispiele dazu.

33:10.890 --> 33:12.850
Ja, das fehlt hier eigentlich.

33:13.110 --> 33:13.710
Kommt aber gleich.

33:14.110 --> 33:14.690
Das kommt gleich.

33:16.010 --> 33:18.230
Der Style-Guide wird sich später zwingen, das zu benutzen.

33:18.670 --> 33:19.990
Im Moment kennen wir es noch nicht.

33:21.330 --> 33:22.790
Muss ich hier irgendwas überprüfen?

33:22.930 --> 33:23.810
Funktioniert das immer?

33:24.550 --> 33:26.290
Wurzel darf man nicht aus allen Zahlen ziehen.

33:26.370 --> 33:27.470
Ist es okay, was da steht?

33:28.030 --> 33:30.750
Also hier können Sie jetzt aus mathematischen Gründen sicher sein,

33:30.850 --> 33:32.630
dass das nicht negativ ist, was da steht.

33:32.730 --> 33:34.190
Und deshalb müssen Sie nichts überprüfen.

33:34.710 --> 33:38.670
Nehmen Sie mal an, da würde nicht x² und y², sondern nur x und y

33:38.670 --> 33:39.010
stehen.

33:39.450 --> 33:41.570
Und das ist jetzt eine schwierige Frage.

33:41.730 --> 33:46.310
Müssen Sie dann überprüfen, ob in x und in y nicht negative Werte

33:46.310 --> 33:46.710
stehen?

33:47.070 --> 33:47.550
Ja, okay.

33:48.170 --> 33:51.070
Also Sie müssen überprüfen, dass das Gesamtergebnis nicht negativ ist.

33:51.250 --> 33:53.030
In die Richtung meinte ich die Frage nicht.

33:53.030 --> 33:57.030
Sondern müssen Sie jetzt wieder sozusagen einem böswilligen Aufrufer

33:57.030 --> 33:59.890
unterstellen, dass in x und in y krumme Werte drinstehen?

34:01.190 --> 34:02.450
Oder müssen Sie das nicht?

34:02.830 --> 34:05.350
Das ist jetzt x und y, das Sie geschrieben haben.

34:05.690 --> 34:07.490
Und Sie vertrauen sich, glaube ich.

34:08.270 --> 34:11.110
Also das kommt ja gar nicht von außen, sondern Sie schreiben ja den

34:11.110 --> 34:11.510
Vektor.

34:11.590 --> 34:15.010
Und wenn Sie sicherstellen, dass x und y zum Beispiel immer positiv

34:15.010 --> 34:16.370
sind, müssen Sie es hier nicht prüfen.

34:16.890 --> 34:20.090
Auf das Problem, das ist das sogenannte Konsistenzproblem, gehen wir

34:20.090 --> 34:21.150
morgen noch im Detail ein.

34:21.150 --> 34:25.490
Im Moment, Sachen, die nicht von außen kommen, müssen Sie auch nicht

34:25.490 --> 34:26.070
überprüfen.

34:26.350 --> 34:27.270
Und die kommen von innen.

34:27.430 --> 34:28.670
Die haben Sie selbst belegt.

34:29.650 --> 34:33.390
Okay, jetzt wie er eben richtig angesprochen hat, gibt es ein

34:33.390 --> 34:34.550
spezielles Schlüsselwort.

34:34.930 --> 34:40.150
Das liefert Ihnen dasjenige Objekt, von dem aus der Aufrufer die

34:40.150 --> 34:41.310
Methode aufgerufen hat.

34:41.770 --> 34:44.610
Wenn Sie so ein Speicherbild haben, wie ich es vorhin gezeichnet habe,

34:44.690 --> 34:48.930
dann ist das derjenige Kasten, in dem Sie gerade drin sind, wenn die

34:48.930 --> 34:49.910
Methode aufgerufen wird.

34:49.910 --> 34:51.390
Das ist natürlich eine Visualisierung.

34:51.850 --> 34:52.890
Ist in Wirklichkeit nicht so.

34:54.170 --> 34:56.450
Anwenden tun Sie das zum Beispiel in so einer Situation.

34:56.750 --> 34:59.550
Jetzt setze ich die mal auf private, sodass man von außen nicht drin

34:59.550 --> 35:00.390
rumschreiben kann.

35:00.930 --> 35:02.590
Und jetzt gibt es eine Sätze-Methode.

35:02.870 --> 35:05.010
Da gibt Ihnen von außen jemand zwei Werte.

35:05.890 --> 35:09.130
Und die sollen Sie in Ihr eigenes x und Ihr eigenes y schreiben.

35:09.310 --> 35:11.230
Aber die haben jetzt dummerweise den gleichen Namen.

35:11.850 --> 35:15.230
Also jetzt gibt es ein x in Ihrem Objektkasten und es gibt ein x, das

35:15.230 --> 35:16.690
Ihnen jemand von außen gegeben hat.

35:16.690 --> 35:20.890
Und um die zu unterscheiden, schreiben Sie this davor, um

35:20.890 --> 35:24.330
klarzustellen, dass das das this.x aus dem Objekt ist.

35:25.130 --> 35:29.930
Das this.x ist das x da oben und das x ohne this ist dieses, was man

35:29.930 --> 35:31.230
Ihnen von außen gegeben hat.

35:31.670 --> 35:33.730
Damit können Sie die beiden unterscheiden.

35:34.430 --> 35:36.290
Wir zwingen Sie ab sofort auch das zu tun.

35:36.750 --> 35:38.130
Das ist, glaube ich, auf der nächsten Folie.

35:38.270 --> 35:38.710
Ne, noch nicht.

35:39.710 --> 35:42.390
Aber ab sofort sollten Ihre Methoden, wenn Sie von außen Werte

35:42.390 --> 35:45.470
kriegen, immer this benutzen, wenn Sie auf eigene Attribute zugreifen.

35:46.090 --> 35:48.170
Werde ich später nochmal wiederholen.

35:49.570 --> 35:51.490
Bevor wir zu den Konstruktoren kommen.

35:53.490 --> 35:57.010
Verstehen Sie, warum ich hier eine Methode brauche, um in x und in y

35:57.010 --> 35:58.690
Werte hineinzuschreiben?

36:00.190 --> 36:01.570
Das ist ja eigentlich unsinnig.

36:01.630 --> 36:04.550
Warum schreibe ich eine Methode, die ein x nach x schreibt und ein y

36:04.550 --> 36:05.470
nach y schreibt?

36:07.970 --> 36:11.050
Warum kann der Aufrufer nicht von außen, wenn der Vektor meinetwegen v

36:11.050 --> 36:13.030
heißt, v.x gleich 5 machen?

36:13.030 --> 36:15.750
Warum muss er jetzt diese Sätze-Methode aufrufen?

36:16.590 --> 36:17.870
Da gibt es zwei mögliche Antworten.

36:17.930 --> 36:20.710
Einmal einen syntaktischen Grund und einmal, warum man das so haben

36:20.710 --> 36:21.010
möchte.

36:21.210 --> 36:22.170
Jawohl, es ist private.

36:22.750 --> 36:24.830
Es ist außerhalb der Klasse, sieht man die gar nicht.

36:25.730 --> 36:28.410
Zum Beispiel, um zu verhindern, dass da Werte reingeschrieben werden.

36:28.590 --> 36:31.670
Also er sagt, man möchte, die Klasse verwaltet es selbst und man

36:31.670 --> 36:34.150
möchte verhindern, dass von außen jemand Werte einfach so

36:34.150 --> 36:34.790
hineinschreibt.

36:35.590 --> 36:39.090
Bei Vektoren ist es jetzt ja egal, was in x und in y steht, aber

36:39.090 --> 36:41.730
können Sie sich irgendwie mathematische Objekte vorstellen, wo es

36:41.730 --> 36:42.630
nicht egal ist?

36:42.630 --> 36:45.650
Wo Sie verhindern möchten, dass beliebige Werte reingeschrieben

36:45.650 --> 36:45.970
werden?

36:46.510 --> 36:48.450
Naja, wir werden gleich ein paar Beispiele sehen.

36:48.910 --> 36:51.890
Bevor wir dazu kommen, erkläre ich Ihnen aber erstmal, was ein

36:51.890 --> 36:52.670
Konstruktor ist.

36:52.970 --> 36:55.290
Das ist gar nicht so schwer, es ist nur ein Fachwort, das Sie lernen

36:55.290 --> 36:55.590
müssen.

36:56.250 --> 36:59.110
Vielleicht als Einführung, eine Klasse ist ja ein selbst erstellter

36:59.110 --> 36:59.710
Datentyp.

36:59.910 --> 37:03.650
Und erzeugen tun wir ein Objekt von dieser Klasse mit dem new Befehl.

37:04.190 --> 37:07.910
Und im Moment müssen wir das, wenn wir es erzeugt haben, noch

37:07.910 --> 37:08.490
beschreiben.

37:08.490 --> 37:13.250
Das heißt entweder von außen x und y mit dem Gleichheitszeichen mit

37:13.250 --> 37:13.930
Werten belegen.

37:14.470 --> 37:16.750
Habe ich Ihnen gerade erklärt, dass wir das später nicht mehr so haben

37:16.750 --> 37:17.010
wollen.

37:17.550 --> 37:21.290
Oder wir haben solche Sätze-Methoden, denen man die Werte als

37:21.290 --> 37:24.790
Parameter übergibt und die die Werte in die Variablen schreiben.

37:25.990 --> 37:28.490
Das ist beides schön, aber wir möchten eigentlich, dass das so

37:28.490 --> 37:31.910
funktionieren soll wie bei unseren elementaren Datentypen, die man

37:31.910 --> 37:35.310
sofort bei der Initialisierung mit irgendwelchen sinnvollen Werten

37:35.310 --> 37:35.970
beschreiben kann.

37:35.970 --> 37:36.470
Also z.B.

37:36.610 --> 37:40.270
int j gleich 1 oder boolean b gleich false oder dieses Feld hier

37:40.270 --> 37:40.510
unten.

37:40.850 --> 37:44.210
Wir wollen so eine sofortige Initialisierung jetzt auch für Objekte

37:44.210 --> 37:44.490
haben.

37:45.110 --> 37:48.390
Und dafür brauchen wir spezielle Methoden, die das Objekt mit

37:48.390 --> 37:49.310
Startwerten füllen.

37:50.670 --> 37:54.170
Warum brauchen wir denn dafür jetzt spezielle Methoden?

37:54.510 --> 37:58.230
Warum können wir nicht wie bei einem Feld einfach sagen, das sieht so

37:58.230 --> 37:58.450
aus?

38:03.360 --> 38:05.660
Bei Vektoren könnte man es sich noch vorstellen.

38:05.660 --> 38:10.000
Aber wenn Sie an dieses Studentobjekt denken, warum würde ich da jetzt

38:10.000 --> 38:13.360
nicht einfach Name, Geschlecht, Nummer, Nummer hinschreiben?

38:15.680 --> 38:17.720
Und Java verbietet Ihnen das auch.

38:18.500 --> 38:21.360
Bei Feldern ist es ja schon klar, das hat ja eine feste Reihenfolge

38:21.360 --> 38:22.580
und alle haben den gleichen Typ.

38:22.700 --> 38:24.940
Das da ist Feld 0, das Feld 1, das ist Feld 2.

38:25.420 --> 38:28.480
Bei Objekten, wie referenzieren Sie denn da die Bestandteile?

38:30.160 --> 38:31.140
Über Ihren Namen.

38:31.480 --> 38:32.960
Da hat jeder Bestandteil einen Namen.

38:32.960 --> 38:37.020
Und Sie müssen Java sagen, welches Ihrer Startwerte in welches

38:37.020 --> 38:37.780
Attribut geht.

38:38.280 --> 38:39.200
Und das ist nicht so einfach.

38:39.300 --> 38:41.620
Dafür müssen Sie eine spezielle Methode schreiben, die das für Sie

38:41.620 --> 38:41.860
tut.

38:42.300 --> 38:44.280
Und zwar einen sogenannten Konstruktor.

38:45.040 --> 38:50.320
Das ist eine spezielle Methode zur Erzeugung eines Objekts, die

38:50.320 --> 38:53.260
verantwortlich ist, die Startwerte in die Attribute zu schreiben.

38:53.400 --> 38:55.040
Und auch zu kontrollieren, dass die okay sind.

38:55.780 --> 38:57.980
Dazu kann Sie Parameter vom Aufrufer bekommen.

38:58.720 --> 39:02.020
Der Konstruktor, den können Sie nicht explizit aufrufen, sondern der

39:02.020 --> 39:04.980
wird automatisch ausgeführt, wenn Sie den new Befehl durchführen.

39:06.540 --> 39:08.340
Das sieht man am besten an einem Beispiel.

39:08.760 --> 39:11.520
Also ich habe jetzt hier wieder diese Vektorklasse mit privaten x und

39:11.520 --> 39:11.760
y.

39:14.540 --> 39:19.060
Und Java erkennt eine Methode als Konstruktor daran, dass sie den

39:19.060 --> 39:20.560
gleichen Namen wie die Klasse hat.

39:21.220 --> 39:23.940
Das ist eine Methode, die heißt Vektor, die hat den gleichen Namen wie

39:23.940 --> 39:24.700
die Klasse hier oben.

39:24.700 --> 39:30.000
Und die bekommt ein x und ein y als Startwert und sortiert das x, was

39:30.000 --> 39:34.100
es bekommen hat, in seine x-Komponente ein und das y in seine y

39:34.100 --> 39:34.860
-Komponente.

39:35.480 --> 39:37.060
Das Rote ist der Konstruktor.

39:37.380 --> 39:39.140
Der hat keinen Rückgabetyp, auch nicht void.

39:39.900 --> 39:43.920
Heißt genauso wie die Klasse und ordnet die Parameter, die er bekommt,

39:44.720 --> 39:46.660
den Attributen des Objekts zu.

39:49.540 --> 39:51.440
So sieht das in der Anwendung aus.

39:51.440 --> 39:55.740
Sie können jetzt schreiben Vektor v gleich new Vektor, dann geben Sie

39:55.740 --> 39:59.180
die zwei Koordinaten an, Runde Klammer zu, Semikolon.

39:59.320 --> 40:03.300
Und der Konstruktor sorgt dafür, dass diese 1 in die x-Komponente und

40:03.300 --> 40:05.460
die minus 7 in die y-Komponente kommt.

40:06.000 --> 40:09.820
Sobald Sie das getan haben, haben Sie Java sozusagen gezwungen, diesen

40:09.820 --> 40:12.380
Datentyp ab jetzt immer so zu initialisieren.

40:12.500 --> 40:15.900
Sobald Sie das machen, akzeptiert es Java nicht mehr, wenn Sie keine

40:15.900 --> 40:19.220
Startwerte mitgeben oder wenn Sie versuchen, in diesen privaten

40:19.220 --> 40:20.500
Attributen rumzuschreiben.

40:20.500 --> 40:21.900
Das ist verboten.

40:22.820 --> 40:26.920
Sie können nur noch über den Konstruktor diese Variablen ab jetzt

40:26.920 --> 40:27.440
zuweisen.

40:27.860 --> 40:29.100
Und das kontrolliert Java auch.

40:30.880 --> 40:31.780
Verstehen Sie das?

40:34.140 --> 40:39.960
Gut, dann schauen wir uns noch kurz den Styleguide an.

40:40.840 --> 40:42.780
Und dann mache ich ein ausführliches Beispiel für Sie.

40:43.760 --> 40:45.520
Und dann machen wir das Übungsblatt.

40:45.520 --> 40:49.100
Also, was wir bis jetzt hatten, war, wie Java das haben möchte und wie

40:49.100 --> 40:49.920
es organisiert ist.

40:49.980 --> 40:52.040
Und jetzt kommt sozusagen der KIT-Styleguide dazu.

40:52.500 --> 40:56.780
Ab jetzt müssen Sie alle Attribute in Ihrem Objekt auf private setzen.

40:56.920 --> 41:00.360
Es ist ab jetzt für Sie grundsätzlich verboten, dass jemand von außen

41:00.360 --> 41:01.760
in Ihren Attributen rumschreibt.

41:02.340 --> 41:06.320
Für jedes Attribut schreiben Sie stattdessen eine set- und eine get

41:06.320 --> 41:09.180
-Methode, mit der man auslesen bzw.

41:09.880 --> 41:11.360
kontrolliert hineinschreiben kann.

41:11.360 --> 41:14.860
Ein typisches Beispiel, wo Sie etwas haben möchten, das kontrolliert

41:14.860 --> 41:15.600
ist, ist z.B.

41:15.740 --> 41:16.800
eine rationale Zahl.

41:17.420 --> 41:18.800
Was ist denn eine rationale Zahl?

41:24.960 --> 41:28.080
Das ist einfach ein Bruch aus Zähler und Nenner, mit der

41:28.080 --> 41:29.880
Nebenbedingung, dass der Nenner nicht Null ist.

41:30.000 --> 41:32.700
Also Sie wollen dann nicht, dass jemand, wenn er eine rationale Zahl

41:32.700 --> 41:34.540
hat, r.Nenner gleich Null schreibt.

41:34.660 --> 41:38.020
Dann hat er Ihnen Ihr Objekt nicht im Sinne der Informatik, sondern im

41:38.020 --> 41:39.460
Sinne der Mathematik kaputt gemacht.

41:39.460 --> 41:43.900
Um das zu verhindern, setzen Sie Zähler und Nenner auf private und

41:43.900 --> 41:47.480
erlauben nur noch den Zugriff über solche set- und get-Funktionen.

41:47.500 --> 41:51.480
Das heißt, Sie müssen eine set-Funktion aufrufen, um in den Nenner was

41:51.480 --> 41:53.800
reinzuschreiben und die kontrolliert, ob das Null ist.

41:54.400 --> 41:56.700
Und wenn es Null ist, dann wird es eben nicht reingeschrieben.

41:57.520 --> 42:01.720
Diese Methoden prüfen die Parameter und kommen mit allen möglichen und

42:01.720 --> 42:03.220
unmöglichen Eingaben klar.

42:03.360 --> 42:05.160
Das haben Sie vorhin bei dem Mittelwert auch gesehen.

42:05.580 --> 42:07.500
Sie müssen alle möglichen Fälle abfangen.

42:07.500 --> 42:10.760
Sie müssen abfangen, dass man Ihnen eine leere Referenz gegeben hat.

42:10.820 --> 42:13.660
Sie müssen abfangen, dass jemand eine Null in den Nenner schreibt oder

42:13.660 --> 42:15.480
eine negative Zahl in die Wurzel setzt.

42:15.880 --> 42:17.160
In was für einer Notation?

42:17.380 --> 42:18.900
Nein, das benutzen Sie bitte nicht.

42:20.340 --> 42:26.900
Machen Sie eine if-Methode, die if irgendwas gleich Null abfragt und

42:26.900 --> 42:29.800
dann entweder ein Exception wirft später in der Vorlesung oder im

42:29.800 --> 42:31.820
Vorkurs mit Print ausgibt, dass es nicht geht.

42:32.680 --> 42:33.980
Das ist im Moment nicht so schön.

42:34.080 --> 42:36.660
Es gibt in Java Konstrukte, um das kürzer zu machen.

42:36.660 --> 42:39.140
Aber jetzt will ich erstmal, dass Sie das Grundprinzip verstehen.

42:39.580 --> 42:43.960
Dass Sie da Programmlogik einbauen müssen, dass jemand von außen nicht

42:43.960 --> 42:46.420
unzulässige Werte in Ihr Objekt schreibt.

42:47.400 --> 42:49.440
Das ist der erste Teil vom Styleguide.

42:50.400 --> 42:54.000
Ab jetzt nur noch Private Variablen und mit Set und Get reinschreiben

42:54.000 --> 42:54.640
und rauslesen.

42:54.720 --> 42:55.700
Ich zeige Ihnen gleich, wie es geht.

42:56.160 --> 42:59.780
Der zweite Teil ist, dass ab jetzt jede Klasse, die Sie schreiben,

43:00.100 --> 43:04.920
jede eine ToString-Methode anbieten muss, um das Objekt auszugeben.

43:04.920 --> 43:07.580
So wie Sie es vielleicht gestern für den Vektor auch schon gemacht

43:07.580 --> 43:08.080
haben.

43:08.660 --> 43:12.020
Dabei schreiben Sie nicht selber in die Konsole, sondern dieses

43:12.020 --> 43:15.280
ToString gibt einfach einen String als Rückgabewert zurück, der Ihr

43:15.280 --> 43:16.460
Objekt irgendwie beschreibt.

43:16.900 --> 43:19.560
Später in den Vorlesungen müssen Sie das auch für diese Kopier- und

43:19.560 --> 43:23.060
Vergleichsmethoden Clone, Equals und Compare programmieren.

43:23.260 --> 43:26.220
Auch für jedes Objekt, das Sie schreiben, aber noch nicht im Vorkurs.

43:26.340 --> 43:27.800
Das würde es jetzt zu aufwendig machen.

43:28.580 --> 43:32.460
Heute erstmal nur ToString und diese Set und Get-Methoden.

43:33.160 --> 43:36.920
Damit Sie ein Gefühl dafür bekommen, wie das konkret aussieht,

43:37.620 --> 43:40.700
schreibe ich einfach mal ein Objekt, das so designt ist, wie es der

43:40.700 --> 43:41.760
Style -Guide vorschreibt.

43:42.580 --> 43:44.980
Also sagen wir mal Glasbruch.

43:45.540 --> 43:47.440
Das wird später auch eine Übungsaufgabe sein.

43:48.560 --> 43:50.320
Aber ich gebe es Ihnen trotzdem mal kurz vor.

43:52.100 --> 43:54.520
Was würden Sie mir als Attribute vorschlagen für einen Bruch?

44:00.780 --> 44:02.020
Zähler und Nenner.

44:02.640 --> 44:03.360
Datentyp?

44:04.560 --> 44:05.280
Double?

44:05.520 --> 44:07.220
Na ne, genau das will man doch nicht.

44:07.940 --> 44:08.880
Integer, genau.

44:09.840 --> 44:15.280
Integer für den Zähler und Integer für den Nenner.

44:16.060 --> 44:16.740
Okay so?

44:17.840 --> 44:21.480
Nicht okay, denn es fehlt... ja, Private.

44:21.480 --> 44:24.080
Ab jetzt, nach dem Style-Guide, alles Private.

44:24.920 --> 44:29.100
Es soll verboten sein, dass jemand von außen Werte da reinschreibt.

44:29.880 --> 44:31.740
Und das erreicht man, indem man es nach außen versteckt.

44:32.480 --> 44:37.260
So, jetzt wenn ich das mache und ich erzeuge einen Bruch, was passiert

44:37.260 --> 44:37.580
denn dann?

44:38.720 --> 44:39.940
Was steht denn da am Anfang drin?

44:41.500 --> 44:41.940
Ja?

44:42.280 --> 44:43.060
Null oder Null?

44:43.200 --> 44:44.600
Und das ist ganz schlecht bei einem Bruch.

44:44.920 --> 44:47.220
Also schreibe ich einen Konstruktor, kommentiere ich sogar.

44:49.680 --> 44:52.660
Ein Konstruktor sollte Public sein, sonst macht er nicht viel Sinn.

44:53.220 --> 44:56.800
Er hat keinen Rückgabetyp, auch nicht Void, und heißt genauso wie die

44:56.800 --> 44:57.120
Klasse.

44:57.300 --> 45:04.940
Public Bruch und kriegt einen Zähler und einen Nenner als Eingabe, als

45:04.940 --> 45:06.040
Parameter mitgegeben.

45:07.420 --> 45:09.640
Was macht der Konstruktor mit diesen Startwerten?

45:11.260 --> 45:15.100
Er schreibt die Eingabewerte in seinen eigenen und die eigenen kriegen

45:15.100 --> 45:15.740
sie mit this.

45:15.740 --> 45:20.660
This.Zähler ist der Zähler aus ihrem Objekt und Zähler ohne this ist

45:20.660 --> 45:22.760
der Zähler, den man ihnen von außen gegeben hat.

45:23.460 --> 45:27.520
Genauso this.Nenner, ihren eigenen Nenner, beschreiben sie mit dem

45:27.520 --> 45:29.980
Nenner, den man ihnen von außen gegeben hat.

45:30.120 --> 45:30.520
So okay?

45:32.580 --> 45:32.760
Ja?

45:33.500 --> 45:36.500
Das ist eine Spezialsache von dem Konstruktor, ich zeige es Ihnen auf

45:36.500 --> 45:37.500
den Folien gerade nochmal.

45:40.000 --> 45:42.140
Ich habe es eben vielleicht etwas schnell gesagt.

45:46.640 --> 45:50.780
Ein Konstruktor ist eine Methode ohne Rückgabetyp, die den Namen der

45:50.780 --> 45:51.340
Klasse hat.

45:51.440 --> 45:54.940
Das ist eine ganz spezielle Methode mit einer Signatur, an der Java

45:54.940 --> 45:57.320
erkennt, dass das ein Konstruktor ist.

45:57.860 --> 46:01.260
Und Java erkennt das an diesen beiden Sachen, kein Rückgabewert, Name

46:01.260 --> 46:02.480
stimmt mit Klasse überein.

46:03.060 --> 46:05.720
Dann ist das nicht irgendeine Methode, sondern es ist ein Konstruktor.

46:06.420 --> 46:06.860
Genau.

46:07.100 --> 46:10.800
Und hier erkennt jetzt Java, dass das ein Konstruktor ist, weil das

46:10.800 --> 46:14.000
auch Bruch heißt und kein Rückgabewert und auch nicht void dasteht.

46:14.920 --> 46:15.960
Ist der so fertig?

46:17.780 --> 46:18.160
Ja?

46:18.780 --> 46:19.180
Genau.

46:19.300 --> 46:22.420
Beim Zähler ist es unproblematisch, aber jetzt ist es die Aufgabe des

46:22.420 --> 46:25.940
Konstruktors dafür zu sorgen, dass mir da niemand eine Null in den

46:25.940 --> 46:27.040
Nenner schummelt.

46:27.260 --> 46:28.220
Also prüfe ich das ab.

46:29.600 --> 46:32.040
Und das ist jetzt keine so einfache Frage.

46:32.040 --> 46:35.480
Was sollte ich in dieser IF-Anweisung tun, wenn der Nenner denn Null

46:35.480 --> 46:35.860
ist?

46:37.660 --> 46:40.520
Also wenn ein Aufrufer von außen Unfug treibt.

46:40.980 --> 46:41.640
Was mache ich dann?

46:42.620 --> 46:42.680
Ja?

46:45.120 --> 46:47.300
Eigentlich müsste ich eine Exception werfen, weil wir noch nicht

46:47.300 --> 46:48.060
wissen, wie das geht.

46:48.540 --> 46:50.340
Gebe ich es einfach auf der Konsole aus.

46:53.660 --> 46:54.440
So okay?

46:58.280 --> 47:01.380
Syntaktisch ja, aber semantisch was passiert?

47:06.030 --> 47:07.710
Die Null ist trotzdem im Nenner.

47:08.590 --> 47:09.870
Es ist trotzdem passiert.

47:09.950 --> 47:11.050
Wie kann ich das denn verhindern?

47:14.150 --> 47:17.150
Indem man den Nenner auf irgendwas mathematisch Sinnvolles setzt.

47:17.590 --> 47:19.730
Zum Beispiel die 1 ist das Beste, was mir jetzt einfällt.

47:22.170 --> 47:22.650
Genau.

47:22.650 --> 47:24.090
So sollte das ablaufen.

47:24.090 --> 47:28.190
Und jetzt ist sichergestellt, dass Sie einen ordentlichen Bruch

47:28.190 --> 47:28.490
kriegen.

47:29.010 --> 47:33.290
Wäre es an der Stelle richtig, das abzubrechen und einfach nur Return

47:33.290 --> 47:33.770
zu machen?

47:37.650 --> 47:40.810
Das ist auch eher eine Frage an die Spezialisten, die schon wissen,

47:40.930 --> 47:42.090
wie Java funktioniert.

47:44.150 --> 47:44.230
Ja?

47:47.750 --> 47:49.210
Genau, das wollen wir auch nicht.

47:49.210 --> 47:50.990
Genau das dürfen Sie hier nicht machen.

47:51.450 --> 47:54.510
Weil dann haben Sie wieder was Inkonsistenzes in Ihrem Objekt.

47:54.590 --> 47:57.210
Sie müssen schon einen ordentlichen Wert vorgeben.

47:58.190 --> 48:00.850
Und das wäre hier Nenner gleich 1.

48:01.810 --> 48:02.050
Genau.

48:02.250 --> 48:05.590
So jetzt brauchen Sie noch Methoden, dass jemand von außen auf Zähler

48:05.590 --> 48:06.910
und Nenner zugreifen kann.

48:07.130 --> 48:08.270
Also eine Set-Methode.

48:09.230 --> 48:10.570
Nenne ich mal SetNenner.

48:11.630 --> 48:12.530
Int Nenner.

48:14.930 --> 48:16.630
Das ist jetzt kein Konstruktor.

48:16.630 --> 48:18.090
Das ist eine gewöhnliche Methode.

48:18.170 --> 48:20.830
Da muss ich sagen, dass sie nichts zurückgibt mit Void.

48:21.690 --> 48:22.710
Was würden Sie da reinschreiben?

48:26.130 --> 48:28.550
Sagen Sie es mir einfach nur, muss jetzt nicht genau sein.

48:28.930 --> 48:31.490
Genau dasselbe wie im Konstruktorband.

48:31.630 --> 48:32.810
Genau dasselbe wie da oben.

48:34.110 --> 48:36.050
Sie müssen wieder prüfen...

48:37.030 --> 48:38.270
Achso, der hat es nicht kopiert.

48:38.390 --> 48:38.890
Kleinen Moment.

48:41.730 --> 48:45.230
Sie müssen auch hier wieder prüfen, hat mir der Benutzer eine 0

48:45.230 --> 48:46.590
untergeschummelt, dann mache ich es nicht.

48:47.570 --> 48:49.470
Und dann ansonsten schreibe ich das da rein.

48:50.590 --> 48:53.530
Beim Zähler geht es etwas schneller, weil da besteht keine Gefahr,

48:53.690 --> 48:55.430
dass ein ungültiger Wert reingeschrieben wird.

48:55.810 --> 48:56.850
Also SetZähler.

48:57.070 --> 49:03.010
Int Zähler könnte man sozusagen als Einzeiler machen und einfach this

49:03.010 --> 49:05.750
.Zähler gleich Zähler schreiben.

49:09.750 --> 49:11.530
Gewöhnen Sie sich auch diese Syntax an.

49:11.610 --> 49:15.050
Der Parameter, den Sie bekommen, hat immer den gleichen Namen wie das

49:15.050 --> 49:16.310
Attribut, das Sie beschreiben.

49:16.750 --> 49:18.150
Und Sie unterscheiden das mit this.

49:20.390 --> 49:22.930
Dann vielleicht noch als Beispiel so eine Get-Methode.

49:26.250 --> 49:27.950
Was hatten die dann für einen Rückgabetyp?

49:31.450 --> 49:31.850
Int.

49:32.350 --> 49:33.450
Und dann machen wir z.B.

49:34.010 --> 49:34.410
GetZähler.

49:35.970 --> 49:36.590
Parameter.

49:40.510 --> 49:43.510
Keine, weil wir wollen es ja auslesen.

49:44.670 --> 49:47.650
Und die würde einfach nur den Zähler zurückgeben.

49:48.430 --> 49:49.270
Und zwar den eigenen.

49:51.130 --> 49:57.570
return this.Zähler Das heißt, jeder kann den Zähler lesen, jeder kann

49:57.570 --> 49:58.190
ihn beschreiben.

49:58.190 --> 50:01.510
Und jeder kann den Nenner lesen und kann ihn beschreiben, aber es wird

50:01.510 --> 50:04.370
kontrolliert, dass er keine ungültigen Werte reinschreibt.

50:04.550 --> 50:06.090
Das ist der Sinn hinter diesem Konzept.

50:06.950 --> 50:09.490
Und so müssen Sie alle Ihre Objekte heute programmieren.

50:10.090 --> 50:11.890
Es darf nicht mehr direkt reingeschrieben werden.

50:12.030 --> 50:16.270
Es muss über Set und Get-Methoden und über diese Konstruktoren

50:16.270 --> 50:19.290
kontrolliert beschrieben werden.

50:20.150 --> 50:21.290
Dazu Fragen von Ihnen?

50:21.290 --> 50:24.570
Ja, also wenn Sie das da unten jetzt schon haben, könnte ich hier Set

50:24.570 --> 50:25.250
Nenner benutzen.

50:25.390 --> 50:27.410
Aber zu dem Zeitpunkt, wo ich den Konstruktor geschrieben habe, war

50:27.410 --> 50:28.230
das unten noch nicht da.

50:29.010 --> 50:30.350
Haben Sie aber prinzipiell recht.

50:30.630 --> 50:33.290
Macht prinzipiell keinen Sinn, diese Sachen hier zweimal zu schreiben.

50:34.190 --> 50:35.250
Weitere Fragen dazu?

50:36.150 --> 50:38.890
Das ist aber nur eine Optimierung gewesen, die er vorgeschlagen hat.

50:40.110 --> 50:42.850
Viele von diesen Details werden Sie erst verstehen, wenn Sie jetzt

50:42.850 --> 50:44.350
anfangen, selber zu programmieren.

50:44.350 --> 50:48.910
Und auf dem Übungsblatt machen Sie das jetzt mit Vektoren in der

50:48.910 --> 50:49.270
Ebene.

50:49.530 --> 50:51.730
Mit einem XX und XY als Komponente.

50:52.310 --> 50:54.750
Und die bekommen ganz viele Methoden und Konstruktoren.

50:55.290 --> 50:56.530
Gehen Sie da schrittweise durch.

50:56.930 --> 50:59.670
Programmieren Sie immer eine Methode, spielen Sie dann ein bisschen

50:59.670 --> 51:00.850
mit Ihren Vektoren herum.

51:01.250 --> 51:02.990
Und dann programmieren Sie die nächste Methode.

51:04.130 --> 51:05.690
Gut, ich teile es dann aus.

