WEBVTT

15:44.410 --> 15:45.350
...

16:42.550 --> 16:46.670
So, darf ich mal etwas Ruhe bitten.

16:50.250 --> 16:55.850
Das ist ein Hörsaal, der dazu neigt, von der Akustik her sehr viele

16:55.850 --> 16:57.270
Geräusche von der Decke her zu machen.

16:57.830 --> 17:01.310
Also werden wir uns wohl darum bemühen, ein bisschen außer mir selbst,

17:01.850 --> 17:06.810
ruhig zu sein, während der Vorlesungszeit abschließt.

17:08.130 --> 17:10.790
Darf ich mich zunächst mal vorstellen, mein Name ist Peter Lockermann.

17:10.790 --> 17:17.450
Ich bin ein Institutskollege von meinem Vorgänger, dem Herrn Groß, der

17:17.450 --> 17:19.050
ja die Informatik 1 gehalten hat.

17:19.430 --> 17:24.650
Die Vorlesung bleibt also am gleichen Institut, aber sie wechselt den

17:24.650 --> 17:25.290
Dozenten.

17:25.610 --> 17:31.350
Sie wird im ganzen Zyklus, Informatik 1 bis 4, jeweils den Dozenten

17:31.350 --> 17:31.970
wechseln.

17:32.810 --> 17:35.750
So kriegen sie auch die Art, hat das den einen Vorteil, sie kriegen

17:35.750 --> 17:38.830
sozusagen unterschiedliche Sichten auf das gleiche Thema.

17:38.950 --> 17:41.550
Jeder reitet ja sein Hobby, so etwas in der Vorlesung.

17:41.990 --> 17:44.430
Und sie werden auch sehen, dass ich manche Dinge etwas anders mache,

17:45.110 --> 17:50.330
als das, was beispielsweise mein Vorgänger letztes Jahr in der

17:50.330 --> 17:51.630
Informatik 2 getrieben hat.

17:51.830 --> 17:53.170
Vieles davon ist aber auch nicht bekannt.

17:55.610 --> 18:02.810
So, wir sehen, dass wir hier in großer Stärke erschienen sind.

18:02.950 --> 18:07.750
Die Stärke besteht direkt darin, dass ich selbst am Kabel hänge.

18:08.630 --> 18:12.150
Ich hoffe, dass das nur eine Woche lang dauert.

18:12.870 --> 18:16.550
Ich bin auch gefühlt über zwei Mikrofone, eines an der Krawatte und

18:16.550 --> 18:17.210
hier eines.

18:17.210 --> 18:21.110
Ich bin sehr zufrieden, dass die neuen Medien direkt an mir körperlich

18:21.110 --> 18:22.930
zu entdecken sind.

18:23.610 --> 18:30.270
Zwei Mikrofone, drei Mitarbeiter, die ich hier vorstellen darf, ich

18:30.270 --> 18:32.690
nehme mal von links nach rechts.

18:33.390 --> 18:36.710
Der erste ganz links ist Herr Philipp Ender.

18:37.310 --> 18:39.590
Der zweite ist Herr Daniel Pfeiffer.

18:40.090 --> 18:42.050
Und der dritte ist Herr Gabor Schori.

18:42.050 --> 18:46.830
Herr Schori ist dazu zu sagen, dass wir ihn gewonnen haben aus

18:46.830 --> 18:48.410
Budapest für ein halbes Jahr.

18:48.730 --> 18:50.240
Er wird also diese Vorlesung mit betreuen.

18:51.290 --> 18:55.110
Und wir sehen gleich, dass das bei uns als international zugeht.

18:56.690 --> 18:59.610
So, bevor wir in der Vorlesung selbst beginnen, gibt es eigentlich

18:59.610 --> 19:00.870
eine organisatorische Vorlesung.

19:01.370 --> 19:03.210
Und das würde ich gleich mal zeigen.

19:22.080 --> 19:23.540
...und fertig für zwei.

19:24.600 --> 19:27.860
Dort erhält man auch die organisatorische Vorlesung, sonst kann man

19:27.860 --> 19:28.200
die Art

19:38.400 --> 19:41.460
des Namens unter den Punkten für zwei.

19:43.680 --> 19:47.520
Die normale Freizeitvorlesung steht auf der anderen Seite.

19:59.420 --> 20:00.780
Links genommen, Herr Mutter.

20:06.350 --> 20:08.970
Das ist nur das gleichzeitige Tier.

20:12.910 --> 20:13.590
Ausnahmsweise.

20:15.410 --> 20:19.570
Im Gegensatz zu dem, was ich vorhin als Vorlesung gemacht habe, das

20:19.570 --> 20:20.830
ist noch unzufällig.

20:20.990 --> 20:23.590
Diese Vorlesung ist auch aus der Art des Namens.

20:25.050 --> 20:27.010
Das ist auch aus der Vorlesung gesehen.

20:27.290 --> 20:29.390
Da kann man eine Rückenschneidungsweise machen.

20:29.590 --> 20:30.650
Das ist nachvollziehbar.

20:36.040 --> 20:37.280
Das ist die Webseite.

20:38.060 --> 20:40.240
Da kann man sich mal ein Anzeichen holen.

20:41.380 --> 20:42.580
Das ist eine Webseite.

20:42.760 --> 20:45.120
Da kann man sich mal ein Anzeichen holen.

20:48.420 --> 20:49.820
Das ist auch aus dem Namen.

20:50.600 --> 20:51.360
Und das ist

20:57.050 --> 20:59.670
aus der Vorlesung.

21:00.330 --> 21:03.530
Genauso Daten wie genau Raum, wie auch die Webseite.

21:21.460 --> 21:23.920
Die Ausnahme ist nachvollziehbar.

21:35.780 --> 21:39.260
Die Ausnahme ist in der Vermittlung.

21:39.680 --> 21:40.420
Die nächste Vermittlung.

21:51.270 --> 21:54.930
Das war ein bisschen schneller, da sind noch ein paar Schwächsten in

21:54.930 --> 21:55.550
der Zeit gegangen.

21:56.130 --> 21:57.950
Die werden wir aber nicht mehr sehen.

21:59.510 --> 22:01.530
Diese Vermittlung wird dann mit einreihen.

22:01.670 --> 22:04.690
Das sind die schwarzen Zahlen, die grünen Zahlen.

22:05.830 --> 22:07.990
Wenn ich da reingehe, dann sind das 5,8.

22:08.150 --> 22:09.290
2,9 waren die Zahlen.

22:09.730 --> 22:11.890
Da kommen dann die genannten Rundfunktionen ran.

22:12.570 --> 22:13.790
Das war das in der nächsten Runde.

22:14.210 --> 22:15.950
Das war das in der letzten Runde.

22:24.160 --> 22:25.120
Das war das in der letzten Runde.

22:25.840 --> 22:26.960
Das war das in der letzten Runde.

22:28.340 --> 22:30.220
Die 3,9 waren die Rundfunktionen.

22:30.380 --> 22:31.580
Das war die 1,5 Webseite.

22:32.180 --> 22:32.680
Das war die 4,5.

22:33.440 --> 22:35.540
Und auch die genannten Zahlen.

22:36.540 --> 22:37.880
Das war das in der letzten Runde.

22:38.660 --> 22:40.500
Das war die 2,5 Webseite.

22:41.160 --> 22:41.960
Und keine Vorlesung.

22:42.520 --> 22:42.920
Vielen Dank.

22:55.350 --> 22:59.150
Ja, diese Vorlesung, die ist natürlich im Wettbewerb mit anderen

22:59.150 --> 22:59.730
Vorlesungen.

22:59.950 --> 23:02.670
Nämlich den aus der Mathematik beispielsweise.

23:02.670 --> 23:06.730
Und die Erfahrung zeigt, ja, die haben sie ja inzwischen auch schon

23:06.730 --> 23:10.790
ein Semester lang gemacht, dass die Mathematikvorlesungen selbst ja

23:10.790 --> 23:12.350
eine Menge Zeit beanspruchen.

23:12.810 --> 23:17.910
Trotzdem möchte ich an Sie appellieren, die Übungen in dieser

23:17.910 --> 23:20.050
Vorlesung, Informatik II, ernst zu nehmen.

23:21.770 --> 23:24.890
Denn letzten Endes, die meisten unter Ihnen jedenfalls studieren

23:24.890 --> 23:25.690
Informatik.

23:26.030 --> 23:29.810
Und das, was wir in diesem Semester eben tun werden, ist, da werde ich

23:29.810 --> 23:32.430
auch gleich noch etwas zum Inhalten sagen, aber wird zumindest auch

23:32.430 --> 23:35.170
eine erhebliche Dosis an Programmierung enthalten.

23:35.690 --> 23:41.350
Und es gibt relativ viel Klagen immer wieder, trotz des ersten Ranges

23:41.350 --> 23:45.570
bei allen Befragungen, dass eine Menge unserer Absolventen zu wenig

23:45.570 --> 23:47.010
Programmiererfahrung hat.

23:47.410 --> 23:50.570
Wir meinen also, dass wir ihnen zumindest mal die Gelegenheit geben

23:50.570 --> 23:52.070
sollten, möglichst viel zu programmieren.

23:52.730 --> 23:55.050
Das sollte man auch nicht abwarten, bis sie die Diplomarbeit machen

23:55.050 --> 23:57.970
oder zu einer Studienarbeit, sondern das sollte in den frühen

23:57.970 --> 23:59.270
Semestern geschehen.

23:59.270 --> 24:02.230
Also etwa die Hälfte, das hat Herr Bender gerade schon angedeutet,

24:02.650 --> 24:06.450
werden Übungen im Bereich des Programmierens sein.

24:06.570 --> 24:08.430
Da müssen wir auch gleich fragen, welche Programmiersprache, werden

24:08.430 --> 24:09.030
wir auch gleich sehen.

24:10.590 --> 24:14.250
Sie experimentieren etwas, ein Experiment besteht darin, dass ich hier

24:14.250 --> 24:15.410
einen Permanentrechner habe.

24:16.130 --> 24:18.770
Mit dem bin ich ungefähr so erfahren wie hier, und wenn Sie jetzt in

24:18.770 --> 24:21.590
die Hand geputzt bekommen, also werden wir sicherlich immer wieder

24:21.590 --> 24:25.710
Pannen unterlaufen, das wird sicherlich ziemlich schnell losgehen,

24:25.710 --> 24:27.190
aber Sie sehen mir darüber nach.

24:27.570 --> 24:30.130
Ich habe in diesem Erlebnis größeren Tablett gearbeitet.

24:31.090 --> 24:41.550
Das weitere Experiment besteht darin, dass die Fakultät ja auch auf

24:41.550 --> 24:48.230
Initiative der Studenten selbst einen Kanon entwickeln soll, der

24:48.230 --> 24:52.530
einigermaßen stabil über viele Jahre den Stoff aus Informatik 1-4

24:52.530 --> 24:53.130
absetzt.

24:53.830 --> 24:57.010
Da gibt es immer noch Diskussionen innerhalb der Fakultät, und in der

24:57.010 --> 24:59.810
Vorlesung Informatik 2, in diesem Augenblick sind wir wieder

24:59.810 --> 25:02.670
kompromiss, zwischen dem, was in der Vergangenheit gemacht worden ist,

25:02.690 --> 25:04.950
und dem, was in der Zukunft gemacht werden soll.

25:05.590 --> 25:08.690
Aber das ist jedenfalls ein Versuch, schon etwas in die zukünftige

25:08.690 --> 25:12.110
Planung hinein, auch die Vorlesung zu entwickeln.

25:13.410 --> 25:21.770
Sie sehen, dass wir die Vorlesungsreihe aus der Informatik 2 unter ein

25:21.770 --> 25:25.530
Motto stellen, nämlich, wie da steht, Systemverständnis.

25:27.070 --> 25:30.910
Wir meinen, dass die Informatik unter anderem eine Systemwissenschaft

25:30.910 --> 25:36.970
ist, und dass man nach vier Semestern ein Gefühl dafür haben soll, wie

25:36.970 --> 25:41.470
Systeme entwickelt werden, insbesondere sind das ja Systeme, bei denen

25:41.470 --> 25:44.890
wir als Informatiker außerordentlich viele Gestaltungsmöglichkeiten

25:44.890 --> 25:45.130
haben.

25:45.270 --> 25:49.730
Wir programmieren ja eine Software, um die Software dann entsprechend

25:49.730 --> 25:53.470
zusammenzusetzen, zu großen Funktionseinheiten, denke ich nur, dass

25:53.470 --> 25:56.670
wir bestimmt schon auf den Weg gekommen sind, über die Software von

25:56.670 --> 25:59.150
großen Firmen wie SAP oder Google kommt.

26:00.230 --> 26:04.030
Da sind wir noch weit entfernt, und selbst am Ende ihres Studiums sind

26:04.030 --> 26:09.450
wir nicht sehr nah an der Entwicklung solcher Systeme, aber die

26:09.450 --> 26:14.570
Aufgabe der Informatikerpolitik ist eben, solche großen Systeme zu

26:14.570 --> 26:17.750
entwerfen und zu gestalten, und am Schluss auch einsetzen zu können.

26:18.250 --> 26:21.810
Und wir versuchen mal ganz wenig schon in die Richtung des

26:21.810 --> 26:24.750
Systemverständnisses zu kommen, in dieser Vorlesung, allerdings

26:24.750 --> 26:28.230
natürlich an sehr bescheidenen und kleinen Elementen.

26:28.870 --> 26:32.570
Wenn man über Systeme aber spricht, dann gibt es sozusagen zwei

26:32.570 --> 26:32.990
Hiften.

26:33.330 --> 26:36.310
Der eine ist von außen, das ist der Benutzer, der will halt die

26:36.310 --> 26:40.630
Funktionen haben, und das andere ist der Informatiker, der gestaltet

26:40.630 --> 26:42.890
die Systeme, und der Informatiker muss die Funktionalität hinsetzen,

26:42.990 --> 26:45.650
am Schluss wird etwas, was auf einer Maschine laufen kann.

26:46.050 --> 26:49.530
Und vor allen Dingen wird diese Vorlesung auch so aus zwei Aspekten

26:49.530 --> 26:50.350
herauskommen.

26:50.690 --> 26:53.810
Sie wird gelegentlich mehr die Außensicht ansehen, und sie wird

26:53.810 --> 26:56.670
gelegentlich auch mehr die Innensicht betrachten.

26:56.770 --> 26:59.390
Das heißt, wir werden immer wieder wechseln zwischen mehr der Sicht

26:59.390 --> 27:02.990
von außen, was können wir über Systeme, über Systembestandteile im

27:02.990 --> 27:12.450
Einzelnen sagen, und was müssen wir denn intern tun, damit diese

27:12.450 --> 27:14.390
Außensicht auch tatsächlich erfüllt ist.

27:14.770 --> 27:18.250
Hier habe ich nochmal eine Aufstellung dessen, was unser Stoff alles

27:18.250 --> 27:19.350
erwarten wird.

27:20.450 --> 27:23.250
Wir beginnen zunächst einmal, interessanterweise immer noch mit der

27:23.250 --> 27:25.490
Innensicht, die kennen Sie auch schon aus dem Format I.

27:26.870 --> 27:30.810
Wir versuchen zunächst einmal vom funktionalen Programmieren in eine

27:30.810 --> 27:34.210
etwas andere Form der Programmierung überzulegen, nämlich in das

27:34.210 --> 27:35.890
sogenannte imperative Programmieren.

27:36.050 --> 27:38.170
Und dann wird man sagen, was wir darunter bestehen.

27:38.530 --> 27:42.130
Wir werden auf jeden Fall zur Illustration des imperativen

27:42.130 --> 27:45.430
Programmierens die Programmiersprache Java verwenden.

27:45.910 --> 27:49.430
Das ist ja die, die Sie heute im Internet eigentlich überall antreffen

27:49.430 --> 27:49.770
können.

27:51.450 --> 27:55.730
Wir werden dann in die Richtung marschieren, das heißt, wenn wir etwas

27:55.730 --> 27:59.110
näher über das imperative Programmieren müssen, dann werden wir mal

27:59.110 --> 28:03.390
uns auf den umgekehrten Standpunkt stellen und sagen, ich bin Kunde,

28:03.830 --> 28:06.930
der Informatiker, ich will eigentlich ganz bestimmte Dienste in

28:06.930 --> 28:10.730
Anspruch nehmen, die mir ein Software-System oder auch ein Programm

28:10.730 --> 28:11.830
bieten soll.

28:12.150 --> 28:15.610
Also müssen wir mal darüber sprechen, wie sieht denn eigentlich ein

28:15.610 --> 28:16.870
solches System von außen aus?

28:17.570 --> 28:18.850
Wie können wir das charakterisieren?

28:19.070 --> 28:21.510
Also werden wir hier etwas über Dienste sprechen und deren

28:21.510 --> 28:22.870
Charakterisierung von außen.

28:22.870 --> 28:27.910
Und wir werden gleich noch eine spezielle Form solcher Systeme

28:27.910 --> 28:32.330
betrachten, die man mit Objekten bezeichnet.

28:32.710 --> 28:37.910
Wir werden die Objektorientierung als eine spezifische Technik für die

28:37.910 --> 28:41.310
Programmierung einführen, die es heute sehr weit verbreitet,

28:41.430 --> 28:44.830
eigentlich schon seit etwa 15, fast 20 Jahren.

28:45.450 --> 28:48.830
Hat sich auch sehr bewährt, zwar nicht in allen Situationen, aber in

28:48.830 --> 28:50.290
einer Großteil der Situationen.

28:50.290 --> 28:54.410
Wir werden heute das imperative Programmieren unter dem spezifischen

28:54.410 --> 28:58.590
Blickwinkel der Objektorientierung betrachten und werden uns da von

28:58.590 --> 29:04.570
den Spezifikations- und den Entwurfstechniken wieder bis hin zur

29:04.570 --> 29:05.990
Implementierung arbeiten.

29:06.250 --> 29:11.170
Also werden wir am Ende wieder übergehen und uns ansehen, wie die

29:11.170 --> 29:14.950
jetzt, nachdem wir eine solche objektorientierte Sichtweise entwickelt

29:14.950 --> 29:19.010
haben, und jetzt mal von außen eine solche Systeme beschreiben, wie

29:19.010 --> 29:23.410
muss es dann intern denn umgesetzt werden, damit wir diese Objektsicht

29:23.410 --> 29:25.250
auch intern fortführen können.

29:25.830 --> 29:30.590
Wenn wir das haben, dann gehen wir weiter und betrachten einige

29:30.590 --> 29:35.950
weitere Eigenschaften, beispielsweise, was uns besonders wichtig ist,

29:36.030 --> 29:36.810
Skalierbarkeit.

29:37.370 --> 29:39.590
Wie kann man die Systeme jetzt immer größer werden lassen?

29:39.890 --> 29:43.230
Und wie beherrschen wir das Wachstum der Systeme?

29:43.230 --> 29:46.730
Da wird die Mengenorientierung, die ja auch schon aus der Informatik 1

29:46.730 --> 29:48.590
geläufig ist, eine Rolle spielen.

29:49.030 --> 29:52.430
Wir werden folgendes dann wieder zurückgehen und sagen, wie sehen denn

29:52.430 --> 29:55.750
jetzt die Algorithmen aus, um insbesondere mit solchen

29:55.750 --> 29:57.650
Skalierbarkeitsproblemen umzugehen.

29:58.070 --> 30:00.690
Das werden wir auch noch etwas ansehen zur Persistenz, also der

30:00.690 --> 30:04.870
Tatsache, dass wir die umständlichen Dinge über viele, viele Jahre

30:04.870 --> 30:06.390
hinweg aufbewahren müssen.

30:07.050 --> 30:09.350
Also gehen wir wieder hier zurück zur Persistenz.

30:09.350 --> 30:13.610
Dann betrachten wir uns noch das dynamische Geschehen.

30:13.750 --> 30:15.990
Was passiert denn eigentlich, wenn so ein Programm abläuft?

30:16.110 --> 30:18.590
Was passiert denn, wenn ich auf dem Rechner plötzlich eine Umphase im

30:18.590 --> 30:19.630
Programm laufen lasse?

30:21.210 --> 30:24.050
Wie gerate ich miteinander in Konflikten?

30:24.470 --> 30:31.290
Wie kann ich den Ablauf solcher Durchführung von Programmen verfolgen?

30:31.430 --> 30:33.450
Gibt es da auch irgendein systematisches Vorgehen?

30:33.550 --> 30:36.150
Wir werden feststellen, die Systematik, die sich dahinter verbirgt,

30:36.490 --> 30:38.210
lässt sich für sogenannte Prozesse beschreiben.

30:38.210 --> 30:42.010
Und am Ende gehen wir doch mal in die Verteilung rein und sagen, die

30:42.010 --> 30:44.450
Welt, wie wir alle wissen, wenn wir aufs Internet gehen, ist ja völlig

30:44.450 --> 30:45.010
verteilt.

30:45.130 --> 30:51.690
Riesige Mengen an Dienstgebern und Klienten sind da im Netz.

30:52.130 --> 30:55.470
Wie können wir eigentlich mit Diensten umgehen, die jetzt in einem

30:55.470 --> 30:57.450
solchen Netz funktionieren?

30:58.450 --> 31:00.970
So sehen, das ist ein sehr ehrgeiziges Programm.

31:01.830 --> 31:03.970
Wir werden auch ein ordentliches Tempo entwickeln müssen, um da

31:03.970 --> 31:04.610
durchzugehen.

31:04.610 --> 31:09.510
Ich werde vermutlich noch einige Dinge, die auf den Folien sind, nicht

31:09.510 --> 31:13.010
in den Detailen der Vorlesung behandeln, aber es stehen in den Folien

31:13.010 --> 31:14.770
dann zur Verfügung.

31:15.590 --> 31:18.750
Und Sie können dann ja noch zu Hause etwas nacharbeiten.

31:19.530 --> 31:21.550
Ich hoffe auch, dass die Folien so sind, dass ich es mir eigentlich

31:21.550 --> 31:22.430
fest erklären kann.

31:24.830 --> 31:26.510
So, damit haben wir unser Programm.

31:28.030 --> 31:33.750
Und das Programm beginnt dann damit, dass wir etwas über das

31:33.750 --> 31:36.710
imperative Programmieren sagen.

31:36.830 --> 31:41.070
Das heißt, wir wollen Sie eigentlich jetzt in diesen ersten beiden

31:41.070 --> 31:45.530
Stunden mit den Grundzügen des imperativen Programmierens vertraut

31:45.530 --> 31:49.730
machen, sodass Sie von da ab bereits mühelos alle Übungsaufgaben

31:49.730 --> 31:50.290
überstellen.

31:50.290 --> 31:53.550
Denn wir werden ja nicht beim präferentierten Programmieren, aber sehr

31:53.550 --> 31:55.970
wohl eben beim sogenannten imperativen Programmieren.

31:56.750 --> 31:59.150
Da muss man erst mal sagen, was ist das eigentlich?

32:00.010 --> 32:02.510
Und wie unterscheidet sich denn das von dem funktionalen

32:02.510 --> 32:04.370
Programmieren, das Sie bisher kennengelernt haben?

32:06.070 --> 32:12.450
Dann werden wir uns damit beschäftigen müssen, wie das imperative

32:12.450 --> 32:15.470
Programmieren, das kann ich jetzt schon vorneweg sagen, das befasst

32:15.470 --> 32:19.230
sich ja sehr wesentlich mit Zuständen und den Zustandsübergängen in

32:19.230 --> 32:19.890
unserem Rechner.

32:20.470 --> 32:23.190
Wie man also überhaupt erst mal über Zustände sprechen kann, wie man

32:23.190 --> 32:27.070
insbesondere auch sagen kann, welche Zustände will ich bezahlen und

32:27.070 --> 32:28.450
welche Zustände will ich verbieten.

32:29.650 --> 32:33.290
Dann werden wir uns also angehen, wie steuere ich denn jetzt eine

32:33.290 --> 32:38.430
ganze Folge von Zustandsübergängen ab und wie sich das gewünschte

32:38.430 --> 32:41.450
Ziel, nämlich einen bestimmten Endzustand, zu erreichen.

32:43.350 --> 32:46.530
Dann werden wir noch einige Dinge, die uns das Leben erleichtern,

32:46.610 --> 32:50.510
einführen, zum Beispiel in sogenannten Methoden, mit denen man einfach

32:50.510 --> 32:56.570
häufig wiederkehrende Abläufe einfacher erfassen kann, sozusagen auch

32:56.570 --> 32:57.950
Vorrat anlegen kann.

32:58.830 --> 33:01.550
Dann werden wir auch noch ansehen, gibt es sowas wie die Rekursion,

33:01.610 --> 33:04.390
die Sie ja aus der funktionalen Programmierung kennen, gibt es die

33:04.390 --> 33:06.690
auch bei der imperativen Programmierung.

33:07.170 --> 33:11.730
Und am Ende werde ich auch noch zeigen, dass auch das, was Sie an

33:11.730 --> 33:15.730
Zündungsbeschreibung gelernt haben, in der Informatik, das ist sehr

33:15.730 --> 33:18.750
wohl, das ist auch solche praktische Fälle, die etwa eine kleine

33:18.750 --> 33:21.150
Programmiersprache Java anwenden kann.

33:24.610 --> 33:29.290
So, also mit anderen Worten, was wir augenblicklich tun, ist, wir

33:29.290 --> 33:32.130
betrachten zunächst mal das, was so grün markiert ist.

33:35.310 --> 33:38.410
So, funktionales Programmieren, das war für Sie ja folgendermaßen.

33:41.330 --> 33:44.710
Sie haben hier ein funktionales Programm, in einer funktionalen

33:44.710 --> 33:47.650
Sprache, und hinten kommt ein Ergebnis raus.

33:48.530 --> 33:51.670
Und immerhin müssen wir uns ja eine gewisse Vorstellung verschaffen,

33:51.810 --> 33:55.210
wie denn aus diesem Programm ein Ergebnis entsteht.

33:55.530 --> 33:58.390
Und dazu müssen wir uns vorstellen, dass umfassend Programm und

33:58.390 --> 34:01.430
gewisse Eingangstaten, die haben wir hier nicht ausgeführt, die müssen

34:01.430 --> 34:05.930
natürlich noch eingebracht werden, wie das funktionale Programm aus

34:05.930 --> 34:08.970
Eingabedaten ein Ergebnis produziert.

34:09.990 --> 34:14.550
Und wir können sagen, und das ist sehr typisch für die Vorgehensweise

34:14.550 --> 34:17.530
auch bei komplizierten Systemen, wir nehmen uns einfach die

34:17.530 --> 34:21.650
Sprachbeschreibung vor, dahinter steckt eine gewisse Semantik, und wir

34:21.650 --> 34:26.530
stellen uns einfach vor, dass es einen Rechner gibt, der genau so

34:26.530 --> 34:29.910
funktioniert, wie wir das für unsere Programmiersprache festgelegt

34:29.910 --> 34:30.210
haben.

34:30.310 --> 34:33.430
Das ist ein Fall der funktionalen Sprachen, an dem ich lese, die

34:33.430 --> 34:34.150
Substitution.

34:35.370 --> 34:38.850
Und ob ein solcher Rechner auch in Wirklichkeit existiert, ist uns

34:38.850 --> 34:39.450
eigentlich egal.

34:40.210 --> 34:44.490
Wir sagen nur, wir stellen uns einen solchen Rechner vor, denn immer

34:44.490 --> 34:48.030
wenn wir eine Sprache, eine Programmiersprache einführen, oder Sie

34:48.030 --> 34:50.130
werden es später sehen, das gilt auch für Datenbanksprachen

34:50.130 --> 34:54.250
beispielsweise, dann ist es eine Vorstellung, wie die Abarbeitung

34:54.250 --> 34:55.890
eines solchen Programmes zu geschehen hat.

34:56.010 --> 34:59.370
Und wir sagen uns, es muss in Folge dessen auch eine irgendwie

34:59.370 --> 35:02.430
geartete Maschine geben, die immer wieder zustande kommt, durch

35:02.430 --> 35:06.230
Hardware oder auch durch Software erstellen, die genau so

35:06.230 --> 35:09.010
funktioniert, wie wir das für unsere Programmiersprache unterstellen.

35:10.370 --> 35:13.650
Also unterstellen wir hier, wenn wir eine funktionale Sprache haben,

35:13.650 --> 35:18.290
wenn wir eine spezielle Herstellung nehmen, dann haben wir einfach an

35:18.290 --> 35:21.670
dieser Stelle, stellen wir uns eine Maschine vor, die im Wesentlichen

35:21.670 --> 35:23.470
auf Substitution basiert.

35:25.610 --> 35:28.630
Hier ist einmal so ein Beispiel gegeben, ich hoffe, dass das heftig

35:28.630 --> 35:29.030
ist.

35:30.830 --> 35:32.070
Ich glaube, da muss ich aber nicht beschwören.

35:32.950 --> 35:38.930
Aber eigentlich geht man schon daran, dass wir nämlich hier

35:38.930 --> 35:40.470
tatsächlich substituieren.

35:40.470 --> 35:42.970
Wir haben also hier eine Definition eines Programms.

35:43.070 --> 35:45.470
Und dieses Programm, wie wir vorhin schon unterstellt haben, dahinter

35:45.470 --> 35:48.030
steckt eine Maschine, die arbeitet per Substitution.

35:49.030 --> 35:54.210
Und sie arbeitet nach gewissen Voranregeln, mit der Substitution.

35:54.790 --> 35:58.610
Beispielsweise, wenn wir uns vorstellen, dass wir für das x an dieser

35:58.610 --> 36:03.910
Stelle das 4,5 eintragen, dann müssen wir x zunächst mal 4,5

36:03.910 --> 36:04.570
substituieren.

36:04.850 --> 36:06.550
Das ist, wie wir hier sehen, an dieser Stelle.

36:06.550 --> 36:11.530
Und infolgedessen haben wir hier eine Substitution 4,5.

36:14.170 --> 36:18.650
Und wenn wir das jetzt anwenden auf den nächsten Ausdruck, dann wird

36:18.650 --> 36:21.810
damit deutlich, dass zunächst einmal hier ein solcher Ausdruck

36:21.810 --> 36:22.270
entsteht.

36:22.410 --> 36:24.950
Dann wird er noch weiter, die Substitution reduziert.

36:25.370 --> 36:27.450
Und das gibt schließlich 10,0.

36:28.410 --> 36:31.690
Dann tragen wir, dann wird das an dieser Stelle, wird dann für Klammer

36:31.690 --> 36:33.970
selbst 10,0 substituiert.

36:36.050 --> 36:40.070
Und wenn wir das fortführen, dann kommt am Ende eben dieses Ergebnis

36:40.070 --> 36:40.470
heraus.

36:41.470 --> 36:46.710
So, weshalb ich da großzügig bin, was die Sprache angeht, hat damit zu

36:46.710 --> 36:50.150
tun, dass wir zunächst einmal darauf ankommen zu sagen, wir stellen

36:50.150 --> 36:53.190
uns an dieser Stelle eine Maschine vor, die mit Substitutionen

36:53.190 --> 36:53.710
umzugehen kann.

36:53.990 --> 36:56.310
Wir entwickeln eine Programmiersprache oder verwenden eine

36:56.310 --> 37:01.610
Programmiersprache, deren Bedeutung ist unter anderem erklärt durch

37:01.610 --> 37:06.950
das Funktionieren, das Abarbeiten mittels Substitution.

37:08.290 --> 37:13.450
So, jetzt werden wir uns fragen, wenn ich also über iterative Sprachen

37:13.450 --> 37:18.110
spreche, dann habe ich vermutlich schon mal irgendwie eine ganz andere

37:18.110 --> 37:19.270
Maschine im Hinterkopf.

37:20.250 --> 37:23.330
Also werden wir uns überlegen müssen, wie sieht denn diese Maschine

37:23.330 --> 37:23.750
aus.

37:26.230 --> 37:29.470
So, wir könnten ja mal folgendes sagen, wir wissen alle, wie ein

37:29.470 --> 37:30.430
Rechner funktioniert.

37:31.350 --> 37:35.290
Da ist zum Beispiel ein klassischer Verneumann-Rechner, der ist immer

37:35.290 --> 37:38.970
noch die Grundlage unserer Rechner auf unseren Laptops.

37:40.050 --> 37:45.830
Der funktioniert im Wesentlichen so, dass er ein Steuerwerk hat, das

37:45.830 --> 37:49.390
steuert jetzt so die ganzen Abläufe und es hat aber im Wesentlichen

37:49.390 --> 37:54.710
etwas, nämlich einen Speicher und ein Rechenwerk.

37:55.450 --> 37:59.110
Und die werden beide über die Steuerwerke in ihrem Aufbau gesteuert.

37:59.710 --> 38:02.070
So, jetzt werden wir uns fragen, wie eine Maschine, die

38:02.070 --> 38:04.390
charakteristisch ist, vor uns zu reisen.

38:07.130 --> 38:10.210
Wir sehen also ein Rechner-Rechner-Rechner-Rechner-Rechner-Rechner

38:10.210 --> 38:10.490
-Rechner.

38:16.420 --> 38:21.020
Der hat die Scheibe, die hat den Rahmen, den Boden, den Himmel.

38:29.860 --> 38:34.060
Wir sehen also über den Rahmen eine Maschine, die mit dem Fahrrad oder

38:34.060 --> 38:35.020
mit dem Fahrrad zu fahren ist.

38:35.100 --> 38:37.760
Wir sehen also ein Rechner-Rechner-Rechner-Rechner-Rechner-Rechner

38:39.230 --> 38:39.690
-Rechner.

38:39.830 --> 38:42.490
Natürlich war es so, dass man ein Rechner-Rechner-Rechner-Rechner

38:42.490 --> 38:42.690
-Rechner -Rechner war.

38:48.180 --> 38:50.840
Aber so nebenbei haben wir eine Rechner-Maschine, die auch in der

38:50.840 --> 38:51.220
Rechner -Rechner-Rechner

39:06.700 --> 39:07.020
-Rechner -Rechner-Rechner-Rechner-Rechner-Rechner.

39:51.960 --> 39:52.600
So,

39:56.820 --> 39:58.200
und jetzt werden wir

41:16.660 --> 41:18.920
uns fragen,

41:37.100 --> 41:40.640
ob wir den Fahrrad sehen, ob

42:09.660 --> 42:13.220
da wir

45:00.190 --> 45:01.510
alle zusammen sind.

45:50.560 --> 45:53.580
Wir sehen dann ja auch, dass wir in dieser Station

48:06.080 --> 48:08.160
ausgebildet sind, ...

48:11.000 --> 48:12.400
...

48:29.320 --> 48:29.920
...

52:15.100 --> 52:18.740
Also werden wir sicherlich jetzt ein bisschen mehr hinzufügen müssen,

52:19.140 --> 52:22.900
um mit solchen Namen systematisch umzugehen und um unsere weiteren

52:22.900 --> 52:27.260
Forderungen, Menge von Zuständen und insbesondere auch frühzeitliche

52:27.260 --> 52:31.200
Überprüfung, ob eine Operation wirklich zulässig ist, ob wir es

52:31.200 --> 52:31.940
wahrnehmen können.

52:34.500 --> 52:37.620
So, das erste, was man an der Stelle schon entscheiden könnte, ist,

52:38.340 --> 52:45.680
wollen wir eigentlich nur Lesen zugreifen oder wollen wir nur Lesen

52:45.680 --> 52:46.920
den Zugriff zulassen?

52:48.180 --> 52:48.740
Wer dürfte?

52:48.920 --> 52:49.920
Ich kann lesen und schreiben.

52:51.960 --> 52:57.340
Wir wissen ja zu uns selbst, wenn wir die Programme verwenden oder in

52:57.340 --> 53:00.460
das Netz irgendwo hingehen, dass wir gelegentlich nur Lesen dürfen und

53:00.460 --> 53:02.500
keine Schrift oder Schreiben eingreifen dürfen.

53:03.160 --> 53:04.560
Und den Unterschied wollen wir gleich machen.

53:05.100 --> 53:10.340
Wir werden also von vornherein in unserem Programm festlegen, entweder

53:10.340 --> 53:14.300
ich darf nur Lesen zugreifen, kann aber den Inhalt nicht ändern,

53:14.740 --> 53:18.200
versus ich darf beides tun, ich darf lesen, ich darf aber auch ändern.

53:18.200 --> 53:22.300
Nicht ein Lesendes, ein Element, das ich nur lesen darf, das hat

53:22.300 --> 53:26.480
sozusagen einen festen Zustand, das ändert sich im Laufe der Zeit

53:26.480 --> 53:30.440
nicht, kann natürlich Teil von weiteren Elementen sein, aber die

53:30.440 --> 53:32.580
selbst geändert werden können.

53:34.340 --> 53:38.540
Also beim Lesendenzugriff geschieht eben folgendes, beim Nurlesenden

53:38.540 --> 53:45.000
sprechen wir davon, dass es Konstanten sind, und wenn wir sowohl Lesen

53:45.000 --> 53:49.340
als auch Ändern dürfen, dann sprechen wir davon, dass es sich um

53:49.340 --> 53:50.360
Variablen handelt.

53:51.220 --> 53:54.720
So, und der Lesendzugriff sieht folgendermaßen aus, wir geben hier den

53:54.720 --> 53:59.240
Namen vor, dann bringen wir die Referenz zurück, dann greifen wir auf

53:59.240 --> 54:03.280
den Behälter über diese Referenz zu und dann erhalten wir als Ergebnis

54:03.280 --> 54:05.120
den Wert zurück in die Schrift.

54:05.840 --> 54:08.860
Und wenn wir schreiben, dann geht es genauso los, wir geben den Namen

54:08.860 --> 54:13.400
vor, die Referenz wird geschafft, wir greifen auf den Behälter zu,

54:13.520 --> 54:15.320
aber ich lege mal was an, den Behälter.

54:17.500 --> 54:22.400
Und da sieht man schon, Ablegen in einem Behälter heißt, wir setzen

54:22.400 --> 54:23.220
den alten Inhalt.

54:23.600 --> 54:26.960
Jedenfalls wenn es eine einfache Zelle ist, dann gibt es ein Ablegen,

54:27.020 --> 54:29.360
der nur eine Methode ist, in dem der alte Wert überschrieben wird.

54:30.840 --> 54:34.800
Also vergessen viele, dass man, wenn man überschreibt, der alte Wert

54:34.800 --> 54:38.360
weg ist, das stört die meisten nicht in dem Programm, wenn wir aber

54:38.360 --> 54:42.380
mal später plötzlich mit großen Datenbanken zu tun haben, da kann man

54:42.380 --> 54:46.140
das gleiche hier auch tun, und dann ist es sehr peinlich, wenn Ihre

54:46.140 --> 54:49.020
Rentenzahlung, die vor 30 Jahren erfolgen worden ist, mal

54:49.020 --> 54:49.980
überschrieben worden ist.

54:51.640 --> 54:55.060
Also wir müssen schon sehr darauf achten, meinen wir wirklich an der

54:55.060 --> 54:57.960
Stelle nur Lesendzugriffs oder auch Schreibenden.

54:58.920 --> 55:01.720
Wir sprechen davon, wenn geschrieben wird, dass ein sogenannter

55:01.720 --> 55:03.020
Zeiteneffekt auftritt.

55:03.020 --> 55:08.720
Zeiteneffekt heißt nichts anderes als, dass für uns nur indirekt

55:08.720 --> 55:13.300
erkennbar, später werden wir lesen, der Zustand verändert wird.

55:17.950 --> 55:22.350
So jetzt können wir schon langsam losgehen und sagen, was passiert

55:22.350 --> 55:28.910
denn jetzt, wenn wir Änderungen vornehmen, oder wenn wir eine

55:28.910 --> 55:33.730
bestimmte Verwendung von Werten vorsehen, ist das möglich, ist das

55:33.730 --> 55:34.630
zulässig oder nicht.

55:34.630 --> 55:39.610
Zulässig heißt jetzt für uns folgendes, ich hole mir so einen Wert

55:39.610 --> 55:44.110
raus, oder auch mehrere Werte, versuche die zu verknüpfen, und ich

55:44.110 --> 55:48.150
kläre vorneweg, ob diese Verknüpfung überhaupt legitim ist oder nicht.

55:49.750 --> 55:52.810
Wenn Sie sich ansehen unten auf der Maschine, haben Sie nur ein

55:52.810 --> 55:53.290
bisschen beides.

55:54.210 --> 55:57.530
Und wenn Sie sagen, modifiziere die beiden Werte, dann werden die

55:57.530 --> 55:59.450
modifiziert, ob das sinnvoll ist oder nicht.

56:00.670 --> 56:05.110
Wenn wir oben auf unserer Ebene sind, auf der wir abstrahieren wollen,

56:05.250 --> 56:08.450
und wo wir viel problemnäher sind, dann wollen wir eigentlich

56:08.450 --> 56:14.330
verhindern, dass wir versehentlich beispielsweise zwei Zeichenketten

56:14.330 --> 56:16.330
oder zwei Zeichen miteinander modifizieren.

56:16.910 --> 56:21.130
Das mag zwar magische Regeln dafür angeben können, wie das geschehen

56:21.130 --> 56:23.130
soll, aber es ist eigentlich nicht sinnvoll.

56:23.610 --> 56:27.550
Und noch schlimmer ist eine Zahl mit einer Zeichenkette zu

56:27.550 --> 56:28.150
modifizieren.

56:28.910 --> 56:31.530
Nun, Sie wissen ja schon, wie das vorgegangen wird.

56:31.710 --> 56:33.790
Das kennen Sie auch aus Informatik 1 schon.

56:34.350 --> 56:36.170
Nämlich, wir typisieren.

56:37.710 --> 56:44.350
Wir sagen zunächst einmal, eine Variable besitzt einen Typ.

56:48.300 --> 56:51.300
Und auch jeder Wert besitzt einen Typ.

56:52.460 --> 56:54.760
So, jetzt müssen wir folgendes sicherstellen.

56:55.220 --> 56:58.320
Wir haben also unsere Variable, das ist also ein Zugriff zu einem

56:58.320 --> 56:58.680
Namen.

56:59.740 --> 57:02.020
Und wir sagen beispielsweise vom Typ Integer.

57:02.900 --> 57:09.700
Dann werden wir fordern, dass wenn wir jetzt auf diese Variable

57:09.700 --> 57:14.520
schreitend zugreifen, also neuen Wert ablegen, dass an dieser Stelle

57:14.520 --> 57:16.900
auch wirklich nur ein Integer abgelegt wird.

57:16.900 --> 57:21.100
Wir werden also versuchen zu unterbinden, dass fälschlicherweise da

57:21.100 --> 57:24.040
eine Zeichenkette abgelegt wird, und später wieder zugreifen und

57:24.040 --> 57:30.180
versuchen, diese Variable mit einer anderen Variable zu modifizieren,

57:30.500 --> 57:34.680
dass dann plötzlich gesehenlich eine Zeichenkette hinzukommt, als

57:34.680 --> 57:35.800
einer der Bekannten.

57:38.540 --> 57:40.820
Typsicherheit heißt jetzt dann folgendes.

57:40.820 --> 57:47.520
Wenn wir den Typ des Elementes kennen, das einer Operation eingeht,

57:48.520 --> 57:54.080
dann stellen wir sicher, dass diese Operation auch auf diesen

57:54.080 --> 57:58.620
Komponenten, auf diesen Elementen wohl definiert ist.

57:58.700 --> 58:02.340
Dass sie tatsächlich anwendbar ist und ein sinnvolles Ergebnis

58:02.340 --> 58:02.820
liefert.

58:05.340 --> 58:09.700
Und jetzt können wir schon sagen, eigentlich ist das etwas, das kennen

58:09.700 --> 58:10.260
Sie schon lange.

58:11.820 --> 58:14.200
Wir haben ja abstrakte Datentypen kennengelernt.

58:14.380 --> 58:18.640
Wir können also sagen, auch wenn wir über Zustände sprechen, und diese

58:18.640 --> 58:23.480
Zustände, also unsere Variablen, unsere Komponenten mit Namen zu

58:23.480 --> 58:27.440
sehen, dann gehen wir in einem Typ mit auf den Weg, und der Typ ist im

58:27.440 --> 58:31.220
Sinne eines abstrakten Datentyps zu verstehen, der sagt also etwas

58:31.220 --> 58:37.880
darüber aus, welche Operationen, welche wohl definierte Wirkung auch

58:37.880 --> 58:44.420
diese Elemente besitzen, und im Umkehrschluss, welchen Folgen es nicht

58:44.420 --> 58:45.340
drauf definiert sind.

58:46.620 --> 58:48.980
Also wir können uns einen Integer nehmen, definieren abstrakten

58:48.980 --> 58:52.580
Datentypen, Integers, in dem aufgeführt ist, welche Operationen

58:52.580 --> 58:53.720
ausgeführt werden können.

58:53.860 --> 58:57.800
Da kriegen wir die Signatur, wie wir im Einzelnen die Rechnung zu

58:57.800 --> 59:00.880
formulieren haben, und außerdem kriegen wir noch die Semantik anhand

59:00.880 --> 59:03.860
der Aktionen erklärt, die besagt, was dann die Wirkung ist, die wir

59:03.860 --> 59:04.620
erwarten können.

59:06.000 --> 59:10.480
Also Typisierung in interaktiven Sprachen können wir uns genau so

59:10.480 --> 59:15.360
vorstellen, wie das, was wir über einen abstrakten Datentyp kennen,

59:15.720 --> 59:19.980
also einfach nicht so spezifiziert wie ein abstrakter Datentyp.

59:21.180 --> 59:26.220
So, und jetzt sehen Sie eben, warum wir das tun, nämlich um möglichst

59:26.220 --> 59:30.160
früh, nämlich zur Übersetzungszeit, der Reichtumssatz, das macht Sinn,

59:30.300 --> 59:34.540
oder das macht keinen Sinn, da ist die Operation wohl definiert, und

59:34.540 --> 59:36.360
wenn das nicht der Fall ist, dann kommt die Übersetzung zurück und

59:36.360 --> 59:38.280
sagt, Leute, da ist oben nur ein Fehler.

59:39.440 --> 59:42.380
Und wir warten nicht, bis wir das Programm ausführen, und dann

59:42.380 --> 59:49.080
irgendwo plötzlich das Programm ausflitzt, und Ihnen nur noch eine

59:49.080 --> 59:50.000
Fehlermeldung zurückgibt.

59:53.990 --> 59:58.790
So, jetzt können wir mal sagen, was haben wir denn eigentlich in Java?

01:00:00.050 --> 01:00:03.590
Was haben wir denn in Java an Möglichkeiten?

01:00:05.830 --> 01:00:13.250
Nun, das erste, was wir haben, ist, wir brauchen nicht unbedingt einen

01:00:13.250 --> 01:00:18.230
neuen Namen zu geben, wir können auch bestimmte Standardformen als

01:00:18.230 --> 01:00:20.190
Namen nehmen, z.B.

01:00:20.250 --> 01:00:25.210
die Zahl 10, geschrieben aus den beiden Pfeffern 1, 0, interpretieren

01:00:25.210 --> 01:00:29.530
wir erdenklicherweise als 10, und Java sagt auch 1 und 0 auseinander

01:00:29.530 --> 01:00:32.770
folgen, dann betrachtet das als die Zahl 10.

01:00:34.610 --> 01:00:38.750
Das ist, wenn man will, auch eine Zukunftsfunktion, die eben jetzt in

01:00:38.750 --> 01:00:43.470
dieser üblichen Schreibweise erfolgt, und ist eine Konstante, weil wir

01:00:43.470 --> 01:00:47.510
sagen, man kann, wenn ich über 10 spreche, da nicht eine Änderung

01:00:47.510 --> 01:00:47.830
vornehmen.

01:00:47.830 --> 01:00:50.630
Aus einer 10 kann ich eine 9 oder 12 machen.

01:00:50.950 --> 01:00:52.490
Sondern das ist und bleibt eine 10.

01:00:53.350 --> 01:00:57.450
Also das ist eine nicht weiter genannte Konstante, die durch ihre

01:00:57.450 --> 01:01:03.910
eigene Formulierung eben als ein sogenanntes Literalien, wenn man das

01:01:03.910 --> 01:01:05.650
dann benannt ist.

01:01:06.410 --> 01:01:11.050
Hier sehen Sie also etwa, dass wir 1, ein Integer, 2, wenn es sich um

01:01:11.050 --> 01:01:18.290
die Buche-Variable handelt, oder das Zeichen C, wenn es sich um ein

01:01:18.290 --> 01:01:19.070
Zeichen handelt.

01:01:21.830 --> 01:01:24.710
Die Variablenvereinbarung, die müssen wir jetzt auch einführen, ich

01:01:24.710 --> 01:01:30.450
würde ja sagen, wenn wir jetzt über Zustände sprechen und solche Namen

01:01:30.450 --> 01:01:34.290
beschaffen, dann müssen wir diese Namen einführen, das erfolgt

01:01:34.290 --> 01:01:40.610
folgendermaßen, wir geben von vornherein den Typ dieser Variablen an

01:01:40.610 --> 01:01:42.290
und dann geben wir die Namen an.

01:01:42.550 --> 01:01:43.670
Verfolgt von einem Semikolon.

01:01:44.410 --> 01:01:48.370
Sie sehen beispielsweise an dieser Stelle, sagen wir einfach, wir

01:01:48.370 --> 01:01:56.310
definieren uns eine Variable A, und damit eine Namensfunktion A, und

01:01:56.310 --> 01:02:00.170
wenn wir dort hingehen und den Behälter erwischen, dann ist

01:02:00.170 --> 01:02:04.490
sicherzustellen, dann schreiben wir vor, dass dort indische Werte

01:02:04.490 --> 01:02:05.150
geführt werden.

01:02:06.550 --> 01:02:09.070
Damit haben wir noch nicht durchgesetzt, dass das tatsächlich indische

01:02:09.070 --> 01:02:10.890
Werte nur hinkommen, da müssen wir noch mehr tun.

01:02:11.190 --> 01:02:14.250
Aber wir tun einen ersten Schritt, indem wir sagen, also ich will

01:02:14.250 --> 01:02:18.070
unter A, wenn ich da zum Behälter gehe, nur indische Werte vorfügen.

01:02:20.410 --> 01:02:24.590
So, wenn ich lesen will, dann ist das ganz einfach, dann nehme ich

01:02:24.590 --> 01:02:31.470
nämlich nur den Namen selbst, wenn da A steht und sonst nichts dazu,

01:02:31.930 --> 01:02:35.970
dann heißt das nichts anderes als, mache hier doch die Funktion aus,

01:02:37.030 --> 01:02:42.090
Zugriffsfunktion, und liefe dann den Wert, der unter A gefunden wird,

01:02:42.310 --> 01:02:42.630
zurück.

01:02:42.870 --> 01:02:46.010
In dem Fall hier wird noch mehr getan, da wird nämlich zunächst einmal

01:02:46.010 --> 01:02:49.890
der Wert für A beschafft aus dem Speicher, und dann wird gleich noch

01:02:49.890 --> 01:02:50.890
noch eins dazu addiert.

01:02:52.990 --> 01:02:56.030
Aber der Teil hier ist also derjenige, bei dem gelesen wird.

01:02:56.550 --> 01:03:01.210
Wenn wir schreiben, einfach, wir geben den Namen an, wir geben den

01:03:01.210 --> 01:03:06.130
Wert an, wir sagen, setze diesen Namen zu diesem Wert, also bei hier,

01:03:06.550 --> 01:03:07.810
wir sagen, setze A gleich ein.

01:03:11.400 --> 01:03:12.440
So, stimmt das?

01:03:13.000 --> 01:03:14.080
Ich weiß nicht, was meinen Sie denn?

01:03:14.800 --> 01:03:15.760
Funktioniert das so?

01:03:16.080 --> 01:03:20.960
Oben haben wir gesagt int A, und hier steht int A gleich ein, also

01:03:20.960 --> 01:03:27.080
dann machen wir gleich folgendes, wir vereinbaren eine Variable A als

01:03:27.080 --> 01:03:29.760
Integer, und dann setzen wir sie gleich zum Wert ein.

01:03:30.720 --> 01:03:31.560
Richtig oder nicht?

01:03:33.580 --> 01:03:34.740
Hier sagt jemand, richtig.

01:03:38.040 --> 01:03:42.700
Ja, und zwar, also hier ist doch die Einschränkung, wenn wir es so

01:03:42.700 --> 01:03:46.200
festlegen, die Festlegung, die an der Stelle gelten muss, ist, dass

01:03:46.200 --> 01:03:48.640
die 1 tatsächlich ein Integer ist.

01:03:50.520 --> 01:03:53.660
Das haben wir jetzt mal angenommen, also dürfte wohl funktionieren,

01:03:54.160 --> 01:03:56.780
aber wenn wir da etwas hinschreiben, müssen wir sicher sein, dass der

01:03:56.780 --> 01:04:01.460
Wert, den wir hinschreiben, dass der irgendwie als ein Typ, der ein

01:04:01.460 --> 01:04:04.560
Typ -Integer in diesem Fall auch interpretiert werden kann.

01:04:05.640 --> 01:04:12.160
So, also haben wir hier sowohl die Vereinbarung einer Variable A, als

01:04:12.160 --> 01:04:15.300
auch gleich Digitalisierung zu einem Integer Wert 1.

01:04:17.860 --> 01:04:21.860
Und hier haben wir eine Konstante, der geben wir auch einen Namen, Pi,

01:04:22.640 --> 01:04:25.360
den haben wir ja vorhin schon kennengelernt, jetzt wollen wir Pi mal

01:04:25.360 --> 01:04:25.980
einführen.

01:04:26.880 --> 01:04:30.360
Und wir sagen, Pi ist vom Typ Float,

01:04:33.840 --> 01:04:39.600
und dann geben wir hier hinten auch einen Wert ein, der für alle

01:04:39.600 --> 01:04:41.740
erkennbar irgendwo in der Nähe von dem Pi liegt.

01:04:43.180 --> 01:04:45.660
Und da ein Punkt da ist, können wir auch unterstellen, dass das

01:04:45.660 --> 01:04:47.540
tatsächlich die gleiche Kommazahl ist.

01:04:49.120 --> 01:04:52.340
Was wäre passiert, wenn ich hingeschrieben habe, Float Pi gleich 3?

01:04:56.750 --> 01:04:59.510
Was hätten Sie gemacht als Übersetzer?

01:05:05.250 --> 01:05:08.550
Also hier werden zwei Varianten geboten.

01:05:08.790 --> 01:05:10.290
Meckern, erste Möglichkeit.

01:05:10.930 --> 01:05:15.350
Zweite Möglichkeit, ich sage, das kann ich ja umgleichen, in eine

01:05:15.350 --> 01:05:16.230
gleiche Kommazahl.

01:05:17.190 --> 01:05:21.490
Das heißt, ich führe den ursprünglichen Typ-Integer, den ja meine 3

01:05:21.490 --> 01:05:23.270
hätte, einfach in einen Float über.

01:05:23.490 --> 01:05:24.310
Können Sie auch machen.

01:05:25.270 --> 01:05:26.510
Jetzt geht es schon los.

01:05:26.510 --> 01:05:29.090
Jetzt müssen wir uns anschauen, wie verschiedene Programmiersprachen

01:05:29.090 --> 01:05:30.730
agieren, das ist unterschiedlich.

01:05:31.110 --> 01:05:34.350
Wir müssen nachlesen, was macht die Programmiersprache in einem

01:05:34.350 --> 01:05:34.850
solchen Fall.

01:05:36.330 --> 01:05:41.410
So, hier macht der Sympathie, führt sie über in ein Float.

01:05:42.790 --> 01:05:45.590
So, da steht dann noch Final, und das Final heißt Konstante.

01:05:46.210 --> 01:05:49.150
Wenn ich mal initialisiert habe von da ab, wird es nicht mehr

01:05:49.150 --> 01:05:49.450
geändert.

01:05:50.190 --> 01:05:54.370
Das heißt, einmal legen wir tatsächlich einen Wert ab, nur dann sagen

01:05:54.370 --> 01:05:56.310
wir, anschließend darf nicht mehr geändert werden.

01:06:02.640 --> 01:06:08.540
So, naja, das habe ich jetzt nicht mehr erläutert.

01:06:10.720 --> 01:06:14.120
So, jetzt können wir uns mal ansehen, wie sich so ein Zustand

01:06:14.120 --> 01:06:14.600
entwickelt.

01:06:16.160 --> 01:06:17.440
Das hier ist ein kleines Programm.

01:06:18.360 --> 01:06:21.860
Dieses Programm initialisiert, wie wir das ja vorhin schon

01:06:21.860 --> 01:06:27.360
kennengelernt haben, zunächst einmal führt es die Variable a ein, und

01:06:27.360 --> 01:06:30.700
damit, als Zugriffsfunktion, eine Speicherzone, die wir näher kennen.

01:06:32.660 --> 01:06:35.440
Und wir sagen, initialisiere das zu 1.

01:06:36.500 --> 01:06:42.720
Am Ende steht also in der Tat, für sie lediglich in einer Speicherzone

01:06:42.720 --> 01:06:44.820
namens a, der Wert 1.

01:06:46.260 --> 01:06:49.240
So, jetzt führen wir a gleich a plus 1 aus.

01:06:50.260 --> 01:06:52.060
Das sieht folgendermaßen aus.

01:06:52.720 --> 01:06:55.620
Wir nehmen uns zunächst einmal die linke, die rechte Seite vor,

01:06:55.620 --> 01:06:59.940
stellen fest, hier steht das a, führen das als lesende Zugriff aus,

01:07:00.460 --> 01:07:06.080
erhalten also die 1, addiere 1 dazu, und jetzt stellen wir fest,

01:07:06.160 --> 01:07:09.400
anschließend soll das Schreiben, das ist unser Gleichheitsteil hier,

01:07:09.780 --> 01:07:15.020
wieder nach a geschafft werden, also wird der neue Wert 2 jetzt in a

01:07:15.020 --> 01:07:15.480
abgelegt.

01:07:15.580 --> 01:07:19.640
Jetzt haben wir einen Zusatzübergang in unser Speicher, und zwar unter

01:07:19.640 --> 01:07:21.140
a von 1 nach 2 erreicht.

01:07:24.300 --> 01:07:30.080
Dann haben wir hier eine nicht erlöse Anweisung.

01:07:30.140 --> 01:07:34.720
Diese Anweisung sagt nichts anderes als zu sagen, ist das gleiche wie

01:07:34.720 --> 01:07:37.440
die vorherigen in der Anweisung in Kurzschreibweise.

01:07:37.820 --> 01:07:40.660
Da sehen wir schon, jetzt können wir nicht anfangen, unsere

01:07:40.660 --> 01:07:44.260
Programmiersprache irgendwie mit eleganten Möglichkeiten zu versehen,

01:07:44.340 --> 01:07:47.240
sodass wir nicht immer so langweilige Anweisungen und Zuweisungen

01:07:47.240 --> 01:07:47.900
schreiben müssen.

01:07:47.900 --> 01:07:54.400
Hier steht also hinter a, lesen, um 1 erhöhen und wieder abschreiben.

01:07:54.960 --> 01:07:56.020
Also ist es 3.

01:07:57.380 --> 01:08:02.720
Und hier haben wir auch eine rein lesende Operation, die ändert

01:08:02.720 --> 01:08:04.180
natürlich den Zustand überhaupt nicht.

01:08:04.320 --> 01:08:06.100
Wenn wir lesen, bleibt der Zustand ja dasselbe.

01:08:08.180 --> 01:08:11.760
Also hier sehen Sie, impressive Sprachen fangen einfach an, sozusagen

01:08:11.760 --> 01:08:13.940
den Zustand schrittweise fortzuentwickeln.

01:08:18.200 --> 01:08:23.360
So, was erlauben wir denn eigentlich jetzt an Operationen?

01:08:23.480 --> 01:08:28.160
Nicht, wenn Sie sagen, Typ-Sicherheit, ich lasse nur bestimmte

01:08:28.160 --> 01:08:32.200
Operationen auf Elementen, die zu einem bestimmten Typ gehören, zu.

01:08:33.000 --> 01:08:35.660
Da muss ich euch irgendwann mal sagen, was sind denn diese

01:08:35.660 --> 01:08:36.440
Operationen?

01:08:37.100 --> 01:08:39.600
Jetzt könnte ich lauter ADTs hinschreiben, ich habe das Leben ein

01:08:39.600 --> 01:08:43.300
bisschen einfacher und schreibe jetzt ein paar Liste an von

01:08:43.300 --> 01:08:44.780
Operationen.

01:08:47.020 --> 01:08:49.240
Da schauen wir uns zum Beispiel, es gibt den Typ Goliath.

01:08:50.400 --> 01:08:51.660
Den kennen Sie ja auch schon.

01:08:52.980 --> 01:08:55.680
Und immerhin kann man mit dem Typ Goliath schon einiges machen.

01:08:57.980 --> 01:09:00.240
Beispielsweise kann man jetzt mal Vergleiche anstellen.

01:09:01.220 --> 01:09:04.300
Die zwei Gleichheitszeichen heißen, ich vergleiche zwei Erde auf

01:09:04.300 --> 01:09:07.760
Gleichheit und das Ausführungszeichen gleich heißt Not.

01:09:09.840 --> 01:09:12.800
Und heißt, ich prüfe darauf, ob Ungleichheit.

01:09:13.780 --> 01:09:18.480
Dann können wir natürlich gute Werte negieren.

01:09:19.640 --> 01:09:24.340
Wir können zwar gute Werte schneiden, bei der Konjunktion.

01:09:24.820 --> 01:09:31.900
Wir können bei der Disjunktion unterscheiden, mit dem inklusiven oder

01:09:31.900 --> 01:09:33.500
das exklusive oder.

01:09:34.000 --> 01:09:37.620
Das inklusive oder ist das Eins von beiden, mindestens zu sein.

01:09:38.080 --> 01:09:47.100
Beim exklusiven oder müssen genau Eins von beiden wahr sein.

01:09:49.220 --> 01:09:56.840
Und dann gibt es das And und das Inclusive Or auch noch in einer

01:09:56.840 --> 01:09:58.560
schaulen Variante.

01:10:00.460 --> 01:10:05.400
Sie erinnern sich auch schon an die Informatik 1, an die gierige

01:10:05.400 --> 01:10:09.440
Auswertung, an die strikte Auswertung und die faule Auswertung.

01:10:09.940 --> 01:10:17.120
Die faule Auswertung besagt, wenn ich zum Beispiel eine Konjunktion

01:10:17.120 --> 01:10:22.960
bilde und ich stelle fest, dass der erste Parameter, die erste Größe

01:10:22.960 --> 01:10:25.920
schon vorliegt, dann brauche ich gar nicht mehr weiterzurechnen, das

01:10:25.920 --> 01:10:27.260
Ergebnis bleibt vor.

01:10:29.700 --> 01:10:36.520
Und bei der strikten, da werde ich mich erst um das Endergebnis

01:10:36.520 --> 01:10:39.960
kümmern, nachdem ich beide Teile ermittelt habe.

01:10:41.020 --> 01:10:44.080
Jetzt wird man sich fragen, was der Unterschied ist.

01:10:44.520 --> 01:10:49.100
Und der Unterschied liegt am folgenden, wir werden natürlich, wenn wir

01:10:49.100 --> 01:10:54.260
zum Beispiel so eine Konjunktion nehmen, dann wird im Allgemeinen

01:10:54.260 --> 01:10:59.000
links und rechts, der Infinitiv Operator, wird durch einen Ausdruck

01:10:59.000 --> 01:11:01.020
stehen, den man auch evaluieren müsste.

01:11:01.380 --> 01:11:03.600
Und dann ist es natürlich schon schön, wenn wir eine faule Auswertung

01:11:03.600 --> 01:11:06.200
haben, wenn nämlich der linke Ausdruck, für den ich schon einen

01:11:06.200 --> 01:11:09.260
gewissen Aufwand betrieben habe, sich als Falsch herausstellt, also

01:11:09.260 --> 01:11:09.800
ich jetzt gar nicht.

01:11:12.440 --> 01:11:16.880
Also wir haben hier, da sind wir mit der Auswertung.

01:11:20.270 --> 01:11:23.590
So, dann haben wir natürlich hier, weil,

01:11:40.960 --> 01:11:46.940
so auf dem Ende ist es mir, hier muss es natürlich, die Ungelegenheit

01:11:46.940 --> 01:12:03.920
sein, dann haben wir hier die Infinitiv Operatorin, wenn ich

01:12:03.920 --> 01:12:08.500
flussbedingt bin, da wird es natürlich auch

01:12:18.310 --> 01:12:21.850
leichter stehen, da wird es leichter stehen,

01:18:56.680 --> 01:19:00.600
und dann müssen wir auf dem Ende, weil, das ist ja so ein bisschen,

01:19:08.050 --> 01:19:13.950
hier der Ausdruck, und wir sehen hier, hier der Einsiedler,

01:19:17.160 --> 01:19:19.320
und dann nehmen wir den ersten Ausdruck,

01:19:23.180 --> 01:19:25.600
und dann sehen wir hier, da ist der Einsiedler,

01:19:58.090 --> 01:20:00.410
und dann haben wir hier, das ist natürlich,

01:21:12.460 --> 01:21:58.070
aber, so, dann haben wir hier,

01:22:15.950 --> 01:22:40.460
hier, aber, ins

01:23:07.260 --> 01:23:13.600
A gleich, und dann wird ein langer Ausdruck.

01:23:15.420 --> 01:23:18.300
Und natürlich wollen wir Folgendes erreichen, wenn dieser Ausdruck

01:23:18.300 --> 01:23:22.680
ausgewertet ist, dann haben wir ja gesagt, bei A dürfen aber nur

01:23:22.680 --> 01:23:24.100
Integer -Werte abgelegt werden.

01:23:26.580 --> 01:23:32.280
Das wäre natürlich dann garantiert, wenn das Ergebnis des Ausdrucks

01:23:32.780 --> 01:23:33.560
Integer ist.

01:23:35.440 --> 01:23:38.300
Jetzt können wir nicht warten, bis zur Ausführung, und wenn es dann

01:23:38.300 --> 01:23:41.520
Integer ist, dann bringen wir wieder ein Fehlermeldungsprogramm ab.

01:23:42.520 --> 01:23:45.340
Viel lieber wäre es natürlich, wenn wir schon bei Typ-Sicherheit sind,

01:23:45.860 --> 01:23:50.240
dass wir zur Übersetzungszeit schon rauskriegen, ob der Ausdruck, der

01:23:50.240 --> 01:23:53.080
da auf der rechten Seite steht, Integer liefert oder nicht.

01:23:55.740 --> 01:24:01.620
Das ist also, wir suchen nach einer sogenannten statischen Typ

01:24:01.620 --> 01:24:06.060
-Sicherheit, wir wollen also herauskriegen, ist dann, können wir schon

01:24:06.060 --> 01:24:12.420
zur Übersetzungszeit herausbekommen, welcher Typ, das Ergebnis eines

01:24:12.420 --> 01:24:13.220
Ausdrucks hat.

01:24:15.240 --> 01:24:24.380
Also, unser Ziel ist es, zur Übersetzungszeit zu bestimmen, naja, das

01:24:24.380 --> 01:24:27.320
habe ich ja schon gesagt, damit die Kinder keine Probleme haben, aber

01:24:27.320 --> 01:24:29.540
gegen Ende der Vorlesungszeit werde ich das bestimmt haben.

01:24:34.550 --> 01:24:38.390
Und, wie kriegen wir das jetzt raus?

01:24:41.790 --> 01:24:44.030
Jetzt machen wir folgendes, hier unten haben wir Beispiele.

01:24:45.650 --> 01:24:53.670
Da haben wir A, B und C definiert und A ist Integer, den weisen wir

01:24:53.670 --> 01:24:58.950
auch gleich den Wert 0 zu, B ist eine Gleichkomma-Variable, A-Variable

01:24:58.950 --> 01:25:04.130
kriegt den Wert 2.0 sowieso, 2.0 zugewiesen, und dann gibt es noch ein

01:25:04.130 --> 01:25:05.950
C, das ist eine Bool'sche Variable.

01:25:08.490 --> 01:25:10.330
Jetzt nehmen wir mal das hier her, das ist ein Ausdruck.

01:25:10.470 --> 01:25:12.090
C bei A gleich B ist ein Ausdruck.

01:25:14.730 --> 01:25:17.130
Jetzt müssen wir also fragen, funktioniert das wirklich?

01:25:17.330 --> 01:25:22.510
Ist das ein Ausdruck, dessen Typ korrekt ist oder nicht?

01:25:24.010 --> 01:25:29.450
Nun, zunächst mal passiert folgendes, A, also das ist eine doppelte

01:25:29.450 --> 01:25:31.850
Gleichheit hier, A gleich B.

01:25:34.850 --> 01:25:39.850
Uns interessiert nicht, welche Werte A und B mal irgendwann später

01:25:39.850 --> 01:25:40.390
haben werden.

01:25:40.710 --> 01:25:43.450
Hier wissen wir zwar zufällig, können wir ja rauskriegen, dass es 0

01:25:43.450 --> 01:25:46.090
und 2 ist, aber es könnte ja sein, dass hinterher diese Werte

01:25:46.090 --> 01:25:47.050
verschwunden worden sind.

01:25:47.670 --> 01:25:51.810
Aber was wir wissen ist, dass A und B talend sind.

01:25:51.950 --> 01:25:53.950
Das eine ist Integer, das andere ist ein Close.

01:25:56.170 --> 01:25:57.750
So, wir könnten,

01:26:02.200 --> 01:26:08.120
wenn wir jetzt mal annehmen, dass das hier legitim ist, dass ich einen

01:26:08.120 --> 01:26:11.580
Integer -Tal und einen Gleichkommen-Tal miteinander vergleichen kann,

01:26:12.220 --> 01:26:14.960
müssen wir noch mal sehen, ob das tatsächlich ist, dann wissen wir auf

01:26:14.960 --> 01:26:23.500
jeden Fall, das Ergebnis ist hier Boolean, das ist der Wahrheitswert,

01:26:24.740 --> 01:26:29.300
und C, sehen wir auch, ist Boolean, also weisen wir tatsächlich einen

01:26:29.300 --> 01:26:32.560
Wert vom richtigen Typ, den Travariablen, C, zu.

01:26:33.460 --> 01:26:35.160
So, können wir ja noch weitermachen.

01:26:35.860 --> 01:26:37.600
Hier haben wir A mal B.

01:26:38.300 --> 01:26:42.520
Schauen wir mal nach, A und B sind wieder Tal-Werte, zwar nicht vom

01:26:42.520 --> 01:26:47.000
gleichen Typ, aber vermutlich werden wir schon irgendeine Regel

01:26:47.000 --> 01:26:50.700
finden, die besagt, dass es durchaus möglich ist, ein Integer-Wert und

01:26:50.700 --> 01:26:53.660
einen Gleichkommen-Tal miteinander zu modifizieren.

01:26:53.660 --> 01:26:59.060
Und wenn das der Fall ist, dann erhebt sich die Frage, was kommt denn

01:26:59.060 --> 01:26:59.600
da raus?

01:27:00.960 --> 01:27:03.540
Naja, da wird wahrscheinlich dann wieder ein Gleitkomma-Wert

01:27:03.540 --> 01:27:08.280
rauskommen, also haben wir hier ein Ergebnis, das ist float.

01:27:09.120 --> 01:27:15.360
Und C ist aber ein Boolean-Wert, also erwartet auf der rechten Seite

01:27:15.360 --> 01:27:18.060
ein Boolean-Wert, kommt aber float, als abgelehnt.

01:27:19.180 --> 01:27:21.920
Festgestellt kommen wir fester, ohne dass wir die ganzen Programme

01:27:21.920 --> 01:27:22.780
hier ausgeführt haben.

01:27:23.980 --> 01:27:25.860
Naja, das Letzte ist C war C.

01:27:28.040 --> 01:27:32.240
Da entdecken wir dann schon viel früher, nämlich, dass die

01:27:32.240 --> 01:27:37.580
Modifikation nicht auf boolische Werte anwendbar ist, haben wir ja

01:27:37.580 --> 01:27:38.480
vorher mit der Bälle gesehen.

01:27:39.180 --> 01:27:43.500
Da auf der rechten Seite ist überhaupt kein definiertes Ergebnis

01:27:43.500 --> 01:27:47.620
zustande, entdeckt auch unser Übersetzer, erklärt auch, dieser

01:27:47.620 --> 01:27:49.640
Ausdruck ist nicht zulässig.

01:27:50.500 --> 01:27:52.200
So, das ist ein ganz einfaches Beispiel.

01:27:52.680 --> 01:27:54.800
Wir stellen dir vor, ich schreibe dir einen Satz mit komplizierten,

01:27:54.900 --> 01:27:55.900
langen Ausdrücken an.

01:27:56.240 --> 01:27:59.160
Ich will immer noch erreichen, dass der Übersetzer sich das anzieht

01:27:59.160 --> 01:28:03.360
und sagt, jawohl, da kommt ein richtiger Typ heraus, oder nein, da

01:28:03.360 --> 01:28:04.260
kommt ein falscher Typ heraus.

01:28:05.020 --> 01:28:06.500
Und lehnt das an dieser Stelle schlapp.

01:28:06.600 --> 01:28:09.020
Also wir kriegen eine Sündsatzmeldung zurück, Sündsatzfehler,

01:28:09.120 --> 01:28:12.560
vielleicht wird noch nicht genau erklärt, um welche Art von Fehler es

01:28:12.560 --> 01:28:13.760
sich vermutlich handelt.

01:28:14.480 --> 01:28:17.360
Und dann können wir gleichgezielt Korrekturen vornehmen.

01:28:21.630 --> 01:28:24.870
So, jetzt ist natürlich das erste, ich schreibe einfach so einen

01:28:24.870 --> 01:28:25.490
Ausdruck hin.

01:28:27.630 --> 01:28:30.810
Eine Regel, die wir von allen Programmiersprachen verlangen, da müssen

01:28:30.810 --> 01:28:34.270
wir uns die Programmiersprachen auch genauer angrehen, es wäre also

01:28:34.270 --> 01:28:38.370
Sache eines ADT, es dort genauer zu beschreiben, ist, in welcher

01:28:38.370 --> 01:28:41.590
Reihenfolge werden denn die Operatoren ausgeführt.

01:28:42.890 --> 01:28:46.050
Und das ist genauso wie in der Funktionalprogrammierung schon

01:28:46.050 --> 01:28:50.130
herkennen, da gibt es wieder Präzedenzregeln, wir sagen einfach, was

01:28:50.130 --> 01:28:56.170
kommt vor, was in der Auswertung und wenn mir die Präzedenzregelung

01:28:56.170 --> 01:28:58.550
nicht passt, dann führe ich einfach Klammerregeln ein.

01:29:00.510 --> 01:29:04.770
Also, wir haben Präzedenzregeln, innerhalb der Präzedenz gehen wir von

01:29:04.770 --> 01:29:13.550
links nach rechts vor, wir durch Klammern können wir schon gehen, und

01:29:14.670 --> 01:29:20.870
wir führen für alle Operatoren eine dritte Evaluierung aus, außer für

01:29:20.870 --> 01:29:25.510
diejenigen, für die eine paule Auswertung zugelassen ist, und das sind

01:29:25.510 --> 01:29:29.630
nur drei, nämlich die beiden, die wir schon kennen hier, und dann gibt

01:29:29.630 --> 01:29:31.990
es noch hier eine dritte, die wir noch nicht kennengelernt haben.

01:29:39.100 --> 01:29:42.100
So, jetzt hatte ich schon die Möglichkeit von Ingrid von Pflauz.

01:29:43.200 --> 01:29:47.320
Und jetzt wird vermutlich die Frage, warum warten wir zulässig und wie

01:29:47.320 --> 01:29:48.420
sieht denn das Ergebnis aus?

01:29:50.000 --> 01:29:52.880
Und es gibt eigentlich eine Menge solcher Regeln, zum Beispiel

01:29:52.880 --> 01:29:54.140
passiert folgendes.

01:29:56.560 --> 01:30:03.400
Wenn wir uns eine Zuweisung A gleich B ansehen, dann sagen wir,

01:30:04.640 --> 01:30:13.560
welcher Typ hat B und welchen Typ kann dann A haben?

01:30:16.340 --> 01:30:20.860
Der Grund ist der folgende, wenn A nicht den richtigen Typ hat, dann

01:30:20.860 --> 01:30:26.660
können wir ja mal versuchen, ob wir nicht den Wert, den B uns

01:30:26.660 --> 01:30:30.360
geliefert hat, so umwandeln, dass es zum Typ von A passt.

01:30:31.920 --> 01:30:35.840
Wenn wir eine Gleichkommazahl nehmen, dann können wir ja runden, nach

01:30:35.840 --> 01:30:39.140
unten oder nach oben, und wir erhalten auf die Art ein Indikator.

01:30:40.000 --> 01:30:42.200
Also was soll ich denn zulässig nehmen?

01:30:43.620 --> 01:30:46.540
Nehmen wir an, wir haben B ist für den Typ weit.

01:30:47.700 --> 01:30:54.020
Dann darf das A sein ein Indiker, ein kurzer, ein normaler oder ein

01:30:54.020 --> 01:30:54.440
langer.

01:30:55.100 --> 01:31:00.940
Es darf sogar eine Fließkommazahl sein und die darf sogar doppelter

01:31:00.940 --> 01:31:01.560
Länge sein.

01:31:02.140 --> 01:31:06.100
Das heißt, wir können weit nehmen und sagen, das kann ich beliebig

01:31:06.100 --> 01:31:06.760
interpretieren.

01:31:09.940 --> 01:31:14.020
Das ist eine Frage, ob wir das wollen, aber Java sieht jedenfalls vor,

01:31:14.100 --> 01:31:17.680
dass wir uns ein weit nehmen und es tatsächlich unterschiedlich

01:31:17.680 --> 01:31:18.620
interpretieren können.

01:31:20.200 --> 01:31:23.520
Ich kann mir das mal vorstellen, dass man irgendwo weit aus dem Netz

01:31:23.520 --> 01:31:27.460
rauszieht, und man weiß aber sehr wohl, was die bedeuten und kann sie

01:31:27.460 --> 01:31:31.020
dann einfach im Programm umwandeln in ein entsprechendes Tag.

01:31:33.220 --> 01:31:39.260
Wenn das B short oder character ist, short ist also eine kurze

01:31:39.260 --> 01:31:48.400
integerzahl, character ist dann k, dann ist zulässig daraus einen

01:31:48.400 --> 01:31:55.840
integer normaler 32-Bit-Länge zu machen oder einen 64-Bit-Länge oder

01:31:55.840 --> 01:32:01.140
einen mit float, also mit einer Fließkommazahl oder sogar mit

01:32:01.140 --> 01:32:01.900
Fließkommazahl.

01:32:02.820 --> 01:32:07.060
Wir dürfen also ein Zeichen nehmen und das umwandeln in eigentliche

01:32:07.060 --> 01:32:07.420
Zahlen.

01:32:10.610 --> 01:32:11.150
Komisch, nicht?

01:32:11.350 --> 01:32:11.970
Wie macht man das?

01:32:14.350 --> 01:32:18.010
Ja, welche Bedeutung das hat und was beim Einzelnen geschieht, da

01:32:18.010 --> 01:32:19.630
müssen wir in der Sprachbescheinigung nachgehen.

01:32:20.970 --> 01:32:25.550
Mich heißt das zum Beispiel, dass ich eine Ziffer nehme als Zeichen

01:32:25.550 --> 01:32:28.010
und dass die einfach umgewandelt wird in ein entsprechendes Tag.

01:32:28.850 --> 01:32:33.070
Ich häufig denke ich ja, so Zahlen einfach in Ziffern formen, also als

01:32:33.070 --> 01:32:33.970
Zeichenkette überreicht.

01:32:34.630 --> 01:32:36.810
Oder ist da noch was anderes an Umwandlung drin?

01:32:37.190 --> 01:32:40.910
Also was hier nicht steht, ist wie die Umwandlung erfolgt.

01:32:42.190 --> 01:32:46.130
So kann ich das genauso mit integer machen, integer kann ich eben auch

01:32:46.130 --> 01:32:50.450
noch in andere Zahlwerte überführen, long kann ich immer noch in

01:32:50.450 --> 01:32:53.910
Fließkommazahlen überführen und float kann ich immer noch dort mit in

01:32:53.910 --> 01:32:54.330
Genauigkeit.

01:32:55.510 --> 01:33:01.930
Man sieht übrigens dabei als folgendes, das Ganze funktioniert, wenn

01:33:01.930 --> 01:33:08.990
ich das D nehme und in einen Wertbereich transportiere, der

01:33:08.990 --> 01:33:10.590
umfangreich ist, der weiter ist.

01:33:11.390 --> 01:33:14.650
Also können wir das als Voraussetzung nehmen, wenn es einen weiteren

01:33:14.650 --> 01:33:20.550
Bereich gibt, in den ich den Wert noch runterbringen kann, dann ist im

01:33:20.550 --> 01:33:25.630
Prinzip diese Zuweisung zulässig, die mit einer Zyklumwandlung

01:33:25.630 --> 01:33:26.550
verbunden ist.

01:33:31.350 --> 01:33:37.190
Ja, dann gibt es es auch noch bei Operatoren, bei Operatoren kann ich

01:33:37.190 --> 01:33:38.590
also folgen, das würde man tun,

01:33:41.670 --> 01:33:52.350
wenn ich das Plus anwende, beispielsweise auf Beiz, dann wird der Wert

01:33:54.050 --> 01:33:56.810
umgewandelt in ein Integer, zumindest wie wir es vorhin ja gerade

01:33:56.810 --> 01:33:57.510
gesehen haben.

01:33:58.990 --> 01:34:04.850
Und anschließend wird der, wird dann auf diesen so umgewandten Wert,

01:34:04.990 --> 01:34:07.190
wird dann dieser Plus-Plus-Operator angewendet.

01:34:09.750 --> 01:34:12.130
Und schließlich können wir auch noch, das ist ja alles so unheimlich,

01:34:12.470 --> 01:34:15.830
weil wir keine Kontrolle in der Sprachbeschreibung nachsehen, was

01:34:15.830 --> 01:34:20.910
passiert denn jetzt, wenn ich derartige unpassende, aber halbpassende

01:34:21.970 --> 01:34:26.130
Zuweisungen vornehme, dann kann ich das auch noch bewusst machen, zum

01:34:26.130 --> 01:34:32.290
Beispiel angenommen, ich habe hier ein A als ein Integer großer Länge,

01:34:32.390 --> 01:34:39.790
64 Bit, definiert hat man anfangs Wert 35, dann sieht man deutlich,

01:34:40.270 --> 01:34:47.930
dass an dieser Stelle das 35 einfach umgewandelt wird im Prinzip in

01:34:47.930 --> 01:34:51.030
ein Langinteger, aber ich kann auch folgendes machen, ich habe B

01:34:54.320 --> 01:35:00.320
und ich will jetzt hier das A verwenden und jetzt kann ich hier

01:35:00.320 --> 01:35:05.240
verlangen, dass das A, das hier lang definiert worden ist, B aber

01:35:05.240 --> 01:35:09.580
zugewiesen wird als ein Integer von 32 Bit Länge.

01:35:09.820 --> 01:35:13.400
Ich habe ja gesehen, das ist nicht zulässig, nach den Regeln, die wir

01:35:13.400 --> 01:35:16.100
vorher gehabt haben, aber wir können einen Zwang ausüben, wenn wir

01:35:16.100 --> 01:35:21.640
sagen, was Sprachbeschreibung sagt, das wird wieder in einen 32 Bit

01:35:21.640 --> 01:35:22.600
Integer überführt.

01:35:33.440 --> 01:35:36.160
Aber bei 35, haben wir Glück, da geht es gut.

01:35:41.720 --> 01:35:44.840
So, also wir können hier im Wesentlichen die Sprachbeschreibung

01:35:44.840 --> 01:35:48.980
nachfinden, wir können schon wandeln, aber wir versuchen immer so zu

01:35:48.980 --> 01:35:52.100
wandeln, dass die staatliche Schützlichkeit gewährleistet wird.

01:35:54.860 --> 01:35:57.180
So, nun ist die Welt ja einfach komplizierter.

01:35:57.920 --> 01:36:07.220
Stellen Sie sich vor, Sie haben tausend Elemente in ihrem Zustand, und

01:36:07.220 --> 01:36:09.420
wir müssen jetzt tausend Namen verdienen.

01:36:10.200 --> 01:36:11.480
Das ist natürlich unpraktisch.

01:36:12.140 --> 01:36:16.460
Wir müssen also jetzt Wege finden, wie wir mit Zuständen, die

01:36:16.460 --> 01:36:19.940
allmählich immer größer werden, wie wir mit denen systematisch umgehen

01:36:19.940 --> 01:36:20.260
können.

01:36:21.620 --> 01:36:24.960
Und wir machen das, indem wir einfach jetzt Elemente zusammensetzen,

01:36:24.960 --> 01:36:28.240
zu größeren Einheiten, und versuchen mit diesen größeren Einheiten

01:36:28.240 --> 01:36:28.860
umzugehen.

01:36:29.180 --> 01:36:31.920
Und das kann man nicht nur tun, indem diese größeren Einheiten selbst

01:36:31.920 --> 01:36:34.020
einer gewissen Systematik unterworfen werden.

01:36:37.340 --> 01:36:42.820
So, in Java, aus Gründen, die ich mir irgendwie noch offen lasse,

01:36:43.880 --> 01:36:47.480
werden, nennt man solche zusammengesetzten Typen, Klassen.

01:36:48.940 --> 01:36:54.900
Und schauen wir mal an, eine Klasse ist etwa die folgende, dass wir

01:36:54.900 --> 01:36:56.300
mit Zeichenketten umgehen können.

01:36:56.540 --> 01:37:00.680
Wir haben ja schon gesehen, Einzelzeichen sind reichlich unbrauchbar,

01:37:00.760 --> 01:37:02.220
und mit denen können wir überhaupt nichts anfangen.

01:37:02.380 --> 01:37:03.140
Da gibt es keine Operation.

01:37:04.940 --> 01:37:07.820
Was wir jetzt tun können, wir können Einzelzeichen zu einer

01:37:07.820 --> 01:37:10.420
Zeichenkette machen, oder auch Zeichenketten.

01:37:10.840 --> 01:37:13.260
Da sind sehr wohl Operationen definiert.

01:37:14.800 --> 01:37:20.360
Nämlich das Plus als das Konkatenieren oder Zusammenführen von

01:37:20.360 --> 01:37:21.440
verschiedenen Zeichenketten.

01:37:21.440 --> 01:37:25.880
Hier sehen Sie also, wir haben mehrere Zeichenketten als ein

01:37:25.880 --> 01:37:26.820
Standardfall.

01:37:27.620 --> 01:37:32.160
Hier haben wir einfach Hello und Boys, wir können sie zu Hello Boys

01:37:32.160 --> 01:37:36.240
zusammenführen, indem wir einfach mit dem Pluszeichen eine

01:37:36.240 --> 01:37:37.480
Konkatenation vordenken.

01:37:38.900 --> 01:37:41.480
So, jetzt haben wir Operationen auf Zeichenketten.

01:37:43.240 --> 01:37:45.920
Und das ist auch sinnvoller, als mit dem Einzelzeichen umzugehen.

01:37:48.500 --> 01:37:51.480
Interessanter ist der Array.

01:37:51.640 --> 01:37:54.720
Den kennen Sie auch schon, aus der Informatik 1.

01:37:55.880 --> 01:38:00.280
Und der ist natürlich sehr praktisch, weil der sozusagen mit einem

01:38:00.280 --> 01:38:05.980
einzigen Namen uns erlaubt, eine ganze Menge von Datenelementen, zum

01:38:05.980 --> 01:38:08.520
Beispiel Speicherzellen, gleichzeitig anzusprechen.

01:38:10.060 --> 01:38:14.140
Und wenn wir jetzt einzelne Elemente herausgreifen wollen, dann machen

01:38:14.140 --> 01:38:16.020
wir einfach das Durchnummerieren.

01:38:16.260 --> 01:38:21.500
Das heißt, wir nummerieren einfach von 1 bis n, also die Größe unserer

01:38:22.900 --> 01:38:23.640
Reihung ist.

01:38:23.920 --> 01:38:24.480
Das ist ein Array.

01:38:26.660 --> 01:38:33.140
So, wir sehen nur folgendes, alle Elemente dieser Reihung müssen vom

01:38:33.140 --> 01:38:34.500
gleichen Typ sein.

01:38:35.740 --> 01:38:37.540
Also die Reihung ist etwas sehr homogenes.

01:38:37.660 --> 01:38:39.700
Wir werden später auch die Frage stellen, ob es auch Dinge sind, die

01:38:39.700 --> 01:38:40.940
immerhin eben sind.

01:38:41.340 --> 01:38:43.420
Und mit denen wir auch systematisch umgehen können wollen.

01:38:43.820 --> 01:38:48.800
Aber hier gehen wir zunächst mal um mit einer geordneten Anordnung,

01:38:48.960 --> 01:38:51.500
sehr homogen von typgleichen Variablen.

01:38:52.260 --> 01:38:55.100
Und die Nennung erfolgt jetzt in zwei Stufen.

01:38:55.240 --> 01:38:58.300
Wir geben erstmal den Namen Arrays vor.

01:39:00.300 --> 01:39:04.480
Und dann gehen wir noch einen Index an, der dann jeweils das Element

01:39:04.480 --> 01:39:08.120
gemäß der Ordnung aus dieser Reihung aufgreift.

01:39:08.760 --> 01:39:12.360
So, um jetzt eine solche Reihung zu vereinbaren, führen wir einfach

01:39:12.360 --> 01:39:13.180
erstmal einen Typ ein.

01:39:13.180 --> 01:39:15.100
Wir sagen also, was ist denn das?

01:39:15.660 --> 01:39:17.760
Von welchem Typ sind denn alle Elemente?

01:39:18.760 --> 01:39:21.740
Dann kommt so eine Klammer auf, Klammer zu, so eine eckige Klammer,

01:39:22.060 --> 01:39:23.800
die sagt einfach, pass auf, das ist eine Reihung.

01:39:25.800 --> 01:39:30.600
Und dann wird der Name angegeben, unter dem wir diese Reihung

01:39:30.600 --> 01:39:31.320
ansprechen können.

01:39:31.440 --> 01:39:35.420
Also hier das Beispiel sagt, alle Elemente unserer Reihung, die wir

01:39:35.420 --> 01:39:39.420
mit AI bezeichnen, die sind vom Typ Integer.

01:39:40.640 --> 01:39:44.680
Und dass es eine Reihung ist, das sieht man an dieser Klammer, an der

01:39:45.640 --> 01:39:46.680
eckigen Klammerpaar.

01:39:49.260 --> 01:39:49.560
So.

01:39:51.140 --> 01:39:55.060
Über die Größe sagen wir hier nichts.

01:39:57.920 --> 01:40:01.860
Das heißt, aus Übersetzungszeiten wissen wir gar nicht, wie groß die

01:40:01.860 --> 01:40:02.460
Reihung ist.

01:40:02.540 --> 01:40:05.060
Wir können also einen beliebigen Index angeben, ohne dass wir

01:40:05.060 --> 01:40:07.120
irgendwie feststellen können, dass wir aus dem Indexbereich

01:40:07.120 --> 01:40:07.700
rausfallen.

01:40:09.240 --> 01:40:16.020
Sondern wir sagen erst etwas über die Größe der Reihung, wenn wir

01:40:17.960 --> 01:40:22.300
tatsächlich jetzt eine, wenn wir jetzt hier ein Objekt erzeugen.

01:40:23.700 --> 01:40:27.120
So und jetzt sehen wir, aha, da ist irgendwas Kompliziertes passiert

01:40:27.120 --> 01:40:27.560
dahinter.

01:40:28.480 --> 01:40:36.000
Ganz offensichtlich steht das AI gar nicht unmittelbar für eine Menge

01:40:36.000 --> 01:40:40.920
von Behältern, die die Elemente aufnehmen, sondern nur für etwas, das

01:40:40.920 --> 01:40:44.020
dorthin zeigt, wo sich später unsere Reihung befinden wird.

01:40:45.260 --> 01:40:46.960
Wir sehen also das dann zweistichig vor.

01:40:47.640 --> 01:40:54.100
Also wir müssen in einem zweiten Schritt dann erzeugen, und zwar

01:40:54.100 --> 01:41:00.700
erzeugen wir irgendwann mal jetzt einen Integer und sagen, der hat

01:41:00.700 --> 01:41:02.540
insgesamt 10 Elemente.

01:41:03.080 --> 01:41:05.200
Und das erfolgt über einen solchen U-Operator.

01:41:05.920 --> 01:41:09.040
Das müssen wir direkt mal einfach hinnehmen, wo ist das halt?

01:41:10.000 --> 01:41:12.360
Später werde ich euch genauer erklären müssen, was steckt denn

01:41:12.360 --> 01:41:13.200
eigentlich da dahinter.

01:41:14.200 --> 01:41:17.720
Im Augenblick halten wir einfach mal fest, dass wir eine

01:41:18.600 --> 01:41:21.060
Reihungsvariable vereinbaren, ohne dass schon eine Reihung dahinter

01:41:21.060 --> 01:41:27.840
steht, und dann später zur Ausführungszeit sagen, wie groß sollte die

01:41:27.840 --> 01:41:30.520
Reihung werden, und dann überhaupt erst die Elemente einführen.

01:41:30.840 --> 01:41:33.980
Und das erfolgt hier, wir sagen also AI, wird etwas zugewiesen,

01:41:34.380 --> 01:41:36.720
nämlich eine solche Reihung mit 10 Elementen.

01:41:39.700 --> 01:41:44.180
Natürlich hätten wir auch gleich bei der Vereinbarung das tun können,

01:41:45.100 --> 01:41:47.320
und wir können natürlich auch vereinbaren, haben wir schon gesehen,

01:41:47.420 --> 01:41:50.260
wir können eine Initialzuweisung vornehmen, das hätten wir natürlich

01:41:50.260 --> 01:41:51.440
an dieser Stelle auch tun können.

01:41:52.540 --> 01:41:56.680
Aber auf jeden Fall halten wir fest, wir müssen unterscheiden zwischen

01:41:56.680 --> 01:42:00.220
einem Namen, der zunächst mal nur an die Stelle verweist, wo die

01:42:00.220 --> 01:42:04.460
Reihung sich befinden wird, aber die Reihung selbst wird erst später

01:42:04.460 --> 01:42:05.120
erzeugt werden.

01:42:05.640 --> 01:42:07.620
Nämlich durch einen Bio-Operator.

01:42:11.460 --> 01:42:14.740
Jetzt können wir natürlich einige Fragen stellen über eine Reihung.

01:42:15.520 --> 01:42:19.080
Zum Beispiel können wir fragen, ich habe hier eine Reihung AI

01:42:19.080 --> 01:42:21.400
gekriegt, wie lang ist die?

01:42:23.320 --> 01:42:28.920
Wenn wir jetzt also zum Beispiel das hier durchführen, das ist AI,

01:42:30.460 --> 01:42:33.220
Punktlängst, sehen wir schon, jetzt haben wir eine Punktnotation,

01:42:33.680 --> 01:42:39.160
verwenden wir die Längenfunktion auf die Reihung, die wir mit der

01:42:39.160 --> 01:42:43.300
Variable AI erreichen, an und stellen fest, aha, die hat 10 Elemente.

01:42:43.780 --> 01:42:48.160
Das heißt, hier prüfen wir 10 Elemente, und wenn eben hier der Wert zu

01:42:49.020 --> 01:42:51.580
sich ergibt, dann wissen wir, das sind 10 Elemente.

01:42:52.880 --> 01:42:55.220
Das ist doch manchmal schon ganz nützlich, denn wenn ich Ihnen jetzt

01:42:55.220 --> 01:42:59.360
das AI übergebe, und sage, da ist schon eine Reihung da, und ich hole

01:42:59.360 --> 01:43:02.740
mal die Elemente raus, dann muss ich erst mal nachsehen, wie groß denn

01:43:02.740 --> 01:43:03.520
die Reihung ist.

01:43:03.680 --> 01:43:06.300
Auf die Art können wir zum Beispiel fragen, wenn es eine Variable

01:43:06.300 --> 01:43:08.000
übergeben wird, wie groß ist denn die Reihung.

01:43:11.970 --> 01:43:19.850
Um zu erzeugen, sehen wir also jetzt folgendes, die Zugriffsfunktion

01:43:19.850 --> 01:43:24.270
besteht jetzt aus dem Namen der Reihung und der Angabe des Indexes.

01:43:24.370 --> 01:43:29.930
Also AI heißt jetzt AI, an der Stelle I heißt nichts anderes, als dass

01:43:29.930 --> 01:43:36.290
wir jetzt zugreifen auf das I, der Element in der Reihung gemäß der

01:43:36.290 --> 01:43:41.810
Ordnung, und wir können als Beispiel folgendes tun, hier wir greifen

01:43:41.810 --> 01:43:47.630
auf das dritte Element rein, auf das Element, wir können sogar einen

01:43:47.630 --> 01:43:51.950
Ausdruck hier hinschreiben, 3 plus 1, das wird das vierte Element der

01:43:51.950 --> 01:43:58.370
Reihung, holen dort das Element heraus und weisen den Element an der

01:43:58.370 --> 01:44:00.050
Stelle I der Reihung zu.

01:44:01.850 --> 01:44:04.030
So, jetzt sehen wir schon, was wir alles rausdrücken, ja, ich halte

01:44:04.030 --> 01:44:04.810
mal die Uhr da oben.

01:44:09.360 --> 01:44:11.740
Und jetzt sehen wir auch, dass wir noch einen Schritt weiter gehen

01:44:11.740 --> 01:44:16.040
können, nämlich wir können also jetzt auch mehr Dimensionen nehmen,

01:44:16.440 --> 01:44:23.420
zum Beispiel an dieser Stelle sagen wir folgendes, hier gibt es eine

01:44:24.580 --> 01:44:30.940
Reihung AAI, das ist eine Reihung, das besagt mir hier dieses

01:44:30.940 --> 01:44:31.560
Klammerpaar.

01:44:32.020 --> 01:44:35.480
Das besteht aus einem Typ, der wie der Reihung ist.

01:44:36.260 --> 01:44:41.100
Und damit haben wir eine Reihung, deren Elemente Reihungen sind.

01:44:43.560 --> 01:44:47.840
Und wir sehen sie beispielsweise hier, könnten wir folgendes sagen,

01:44:47.920 --> 01:44:51.600
hier haben wir eine Array der Speicher-Strings, das heißt wir haben

01:44:51.600 --> 01:44:55.680
hier zunächst mal eine Reihungsdefinition und dann kommt hier noch

01:44:55.680 --> 01:44:57.260
dazu, dass sie uns bringen kann.

01:44:59.180 --> 01:45:08.620
Hier erzeugen wir, wie wir sehen, eine Reihung, die ihrerseits zwei

01:45:09.400 --> 01:45:11.080
Integer -Arrays speichert.

01:45:11.500 --> 01:45:15.220
Das ist nämlich der Typ, und dann wird hier nochmal der Array

01:45:15.220 --> 01:45:16.380
definiert.

01:45:17.680 --> 01:45:22.400
Und hier wird beispielsweise den ersten, also den Nulls, wir nennen es

01:45:22.400 --> 01:45:27.300
an dieser Stelle unsere Array, wird jetzt ein Array zugewiesen.

01:45:27.480 --> 01:45:30.060
Also das ist etwas gewöhnungsbedürftig, denn wir können uns schnell

01:45:30.060 --> 01:45:33.060
vorstellen, ein Array, damit kann man sehr gut mal Flüchten

01:45:33.060 --> 01:45:33.580
darstellen.

01:45:34.480 --> 01:45:37.980
Wir müssen immer daran denken, dass wir eigentlich nicht

01:45:37.980 --> 01:45:42.180
zweidimensionale Arrays haben, sondern immer nur eindimensionale

01:45:42.180 --> 01:45:47.060
Arrays und dass wir lediglich sagen können, aber die Elemente des

01:45:47.060 --> 01:45:49.660
Arrays können jederseits wieder Arrays sein.

01:45:50.360 --> 01:45:53.400
Und das können wir auf drei, vier, fünf Dimensionen, was immer uns

01:45:53.400 --> 01:45:56.120
gefällt, können wir das noch erweitern.

01:45:58.780 --> 01:46:03.440
So, hier kann man noch ein bisschen was sehen, nämlich Zuweisungen und

01:46:03.440 --> 01:46:07.200
insbesondere können wir auch direkt solche Arrays initialisieren.

01:46:08.480 --> 01:46:11.180
Und dann gibt es auch noch Standardwerte, mit denen wir hier

01:46:11.180 --> 01:46:12.440
Vorgesetzungen vornehmen.

01:46:12.880 --> 01:46:14.140
Und jetzt sind wir richtig näher.

01:46:15.740 --> 01:46:19.900
Das hier geben wir uns direkt in die Vorhaut.

01:46:20.600 --> 01:46:25.140
Also dann,

01:46:48.050 --> 01:46:49.290
Herr Stolper, ich stelle dich rüber.

01:46:49.770 --> 01:46:51.230
Ja, ich hoffe nächste Woche.

01:47:55.150 --> 01:47:55.970
Ein Moment.

01:48:11.330 --> 01:48:13.470
Das einzige, was ich gerade im Klartext glaube ich, von dem Leben ist

01:48:13.470 --> 01:48:14.670
die Vertretung.

01:48:14.850 --> 01:48:16.310
Ich habe es aber selbst noch nicht gesehen.

01:48:18.230 --> 01:48:19.490
Wie machen wir das?

01:48:20.710 --> 01:48:23.350
Ich schreibe eine E-Mail auf die Youtube-Seite.

01:48:24.150 --> 01:48:25.390
Oder eine Nachricht.

01:48:27.390 --> 01:48:31.370
Also, ich habe erstmal hier mal ...

01:48:31.370 --> 01:48:31.390
...

01:49:17.370 --> 01:49:19.010
Es passt nur, weil Sie sich aufwenden.

01:49:26.840 --> 01:49:28.300
Macht es gut, oder was?

01:49:28.680 --> 01:49:30.100
Ja, es ist alles prima, cool.

01:49:34.120 --> 01:49:35.080
Müssen wir...

01:49:43.800 --> 01:49:46.060
Jetzt springt am Start der Rekorder auf Stop.

01:49:47.120 --> 01:49:48.700
Nicht die Pause tasten, bitte.