WEBVTT

00:03.330 --> 00:05.150
So, schönen guten Tag.

00:06.590 --> 00:11.990
Wir fangen jetzt mit der Programmieren-Vorlesung an und wir kommen

00:11.990 --> 00:14.610
wirklich mal zum Thema Programmieren.

00:15.430 --> 00:18.070
Und wie sich das natürlich geziemt, bevor wir jetzt den ersten

00:18.070 --> 00:21.510
Programmierbefehl lernen, vielleicht erst mal ganz allgemein, was ist

00:21.510 --> 00:22.730
denn Programmieren?

00:23.410 --> 00:25.790
Und dann lohnt sich es auch durchaus mal in die Geschichte zu schauen.

00:27.450 --> 00:30.970
In dem letzten, vorletzten Jahrhundert, im neunzehnten Jahrhundert,

00:31.630 --> 00:36.490
gab es einen englischen Adligen, einen Erfinder, Charles Babbage.

00:36.790 --> 00:41.770
Der hatte zwei Maschinen, sich überlegt, was wir heute Computer nennen

00:41.770 --> 00:41.950
würden.

00:42.050 --> 00:43.310
Das eine war die Differential Engine.

00:43.950 --> 00:47.330
Die war noch nicht so wirklich computerartig im Sinne, dass sie frei

00:47.330 --> 00:48.150
programmierbar war.

00:48.470 --> 00:50.090
Und aber auch die Analytical Engine.

00:50.770 --> 00:54.610
Hier sieht man ein Nachbau, eine Rekonstruktion.

00:54.670 --> 00:57.470
Das Problem ist, die Maschine hat nie wirklich richtig existiert,

00:57.570 --> 00:58.410
funktionsfähig.

00:58.910 --> 01:00.550
Aber er hat sie sich halt mal ausgedacht.

01:01.510 --> 01:06.770
Und Ada Lovelace hatte tatsächlich dann sich auch Gedanken gemacht

01:06.770 --> 01:09.170
über das, was wir heute Software nennen.

01:09.270 --> 01:11.610
Nämlich, sie hat gesagt, naja, wenn das eine Maschine ist, die

01:11.610 --> 01:15.770
verschiedene Befehle ausführen kann, dann kann man halt durch das

01:15.770 --> 01:18.330
Hintereinanderausführen von vielen Befehlen halt komplexere Probleme

01:18.330 --> 01:18.710
lösen.

01:19.290 --> 01:22.070
Und sie hatte sich eben Gedanken gemacht, wie kann man jetzt ein

01:22.070 --> 01:25.990
komplexeres Problem zerlegen in eine Reihe von den Elementarbefehlen,

01:26.130 --> 01:28.730
die diese Analytical Engine auch ausführen kann.

01:29.270 --> 01:32.230
Und das würden wir natürlich heute mit Fug und Recht sagen, ja, das

01:32.230 --> 01:33.350
ist Programmieren.

01:33.490 --> 01:36.750
Und also Frau Ada Lovelace war also die erste Programmiererin.

01:37.490 --> 01:41.030
Für alle, die immer noch denken, Informatik wäre nichts für Frauen, so

01:41.030 --> 01:41.550
ein Quatsch.

01:41.730 --> 01:43.230
Die erste Programmiererin war eine Frau.

01:45.430 --> 01:46.770
Tja, wie geht es dann weiter?

01:47.070 --> 01:48.450
Im Prinzip großer Zeitsprung.

01:49.310 --> 01:52.230
Die nächste eigentliche Programmiersprache wurde tatsächlich 100 Jahre

01:52.230 --> 01:55.410
dann später sich überlegt von Konrad Zuse.

01:55.930 --> 01:57.510
Ich denke mal, die meisten von Ihnen wissen das.

01:57.590 --> 02:01.790
Konrad Zuse gilt heute international als der Erfinder eines Computers.

02:01.870 --> 02:03.810
Das hängt natürlich immer ein bisschen davon ab, was definiert man als

02:03.810 --> 02:04.250
Computer.

02:05.330 --> 02:06.510
Nur so zur Hintergrundinfo.

02:06.950 --> 02:09.730
Eine Rechenmaschine ist natürlich noch nicht ein Computer.

02:09.730 --> 02:13.050
Das Entscheidende ist dabei, dass es frei programmierbar ist.

02:13.150 --> 02:16.450
Das heißt also nicht nur, dass eine vorgefertigte, festvertratete

02:16.450 --> 02:18.030
Befehlsfolge abgespult wird.

02:18.610 --> 02:20.830
Addiermaschinen, Substraktionsmaschinen gibt es alle schon viel

02:20.830 --> 02:21.030
länger.

02:21.610 --> 02:24.630
Sondern, dass man sagt, ich habe eine Art Befehlssatz von

02:25.130 --> 02:27.530
Elementarbefehlen und die, wie ich die anordne, wie in welcher

02:27.530 --> 02:30.630
Reihenfolge die ausgeführt werden und unter welchen Bedingungen die

02:30.630 --> 02:33.350
ausgeführt wird, das ist eben noch angebbar.

02:33.450 --> 02:35.850
Das ist genau dieses Programmieren, was Ada Lovelace ja auch zumindest

02:35.850 --> 02:37.670
mal sich einen Gedanken gemacht hat.

02:37.810 --> 02:39.510
Und Konrad Zuse hat sogar eine Maschine erfunden.

02:40.130 --> 02:41.410
Das war die Z3.

02:41.610 --> 02:43.610
Im Wohnzimmer seiner Eltern in Berlin hat er das erfunden.

02:44.130 --> 02:45.930
Ob die so begeistert waren, ist nicht überliefert.

02:46.510 --> 02:49.390
Aber auf alle Fälle hat er sich dann auch schon überlegt für diese Z3

02:49.390 --> 02:49.810
-Maschine.

02:50.930 --> 02:52.970
Also Z3 steht für Zuse 3.

02:53.350 --> 02:55.590
Er selber war etwas bescheidener, hat sie immer V genannt.

02:55.710 --> 02:56.530
V wie Versuch.

02:58.550 --> 03:01.550
Aber er hatte sich eine Überlegung gemacht, dass er auch eine

03:01.550 --> 03:02.730
Programmiersprache dafür möchte.

03:02.870 --> 03:05.410
Und das ist der sogenannte Plan-Kalkül.

03:05.970 --> 03:07.730
Das ist dann nachher nicht mehr weiterverfolgt worden.

03:07.790 --> 03:10.190
Das ist eine Tabellenartige Programmiersprache.

03:10.530 --> 03:12.810
Aber wenn man so will, eine der ersten Programmiersprachen der Welt,

03:13.410 --> 03:15.850
die auch mal richtig dann auch eine Maschine hatten, wo sie ausgeführt

03:15.850 --> 03:16.090
wurden.

03:18.550 --> 03:22.290
So, dann geht die Entwicklung rasant weiter.

03:23.190 --> 03:26.910
In England wurden dann auch, wieder auch in Amerika, dann auch danach

03:26.910 --> 03:28.290
Maschinen entwickelt.

03:28.590 --> 03:31.910
Und Alan Turing, den Namen haben vielleicht einige schon mal gehört.

03:32.390 --> 03:34.670
Es gibt ein relativ bekanntes Buch, noch ein Film, Enigma.

03:35.710 --> 03:40.110
Alan Turing, englischer Mathematiker, hatte Vorläufer von Computern

03:40.110 --> 03:43.210
gebaut zur Entschlüsselung deutscher Kryptomaschinen im Zweiten

03:43.210 --> 03:43.770
Weltkrieg.

03:44.630 --> 03:46.550
Das war das sogenannte Pletchley Park-Projekt in England.

03:47.330 --> 03:49.770
Und die waren noch nicht ganz frei programmierbar, aber hatten schon

03:49.770 --> 03:52.810
sonst viele Charakterisierungen von automatischem Rechnen.

03:53.430 --> 03:55.350
Und aber nach dem Krieg hat er dann tatsächlich auch frei

03:55.350 --> 03:57.030
programmierbare Rechner mitentwickelt.

03:57.030 --> 03:59.830
Das war zum Beispiel die Ferranti Mark I.

04:00.850 --> 04:06.950
Und er hatte, hier ist also Alan Turing zu sehen, dann auch letzten

04:06.950 --> 04:08.710
Endes das Handbuch zu dem Computer geschrieben.

04:09.170 --> 04:11.890
Jetzt würden wir sagen, Handbücher sind total langweilig, wer liest

04:11.890 --> 04:13.970
denn schon Docfiles oder so als Informatiker oder so.

04:14.810 --> 04:16.210
Ist aber trotzdem mal interessant zu lesen.

04:16.350 --> 04:22.390
Und zwar hat er da drin geschrieben, hier auf Deutsch übersetzt, das

04:22.390 --> 04:24.750
erst mal erklärt, wozu ist eigentlich diese Maschine da, die vorher

04:24.750 --> 04:25.990
noch keiner so richtig kannte.

04:26.050 --> 04:31.230
Elektronische Computer sind dazu gedacht, jeden präzise festgelegten

04:31.230 --> 04:34.830
Berechnungsprozess auszuführen, der durch einen menschlichen Operator

04:34.830 --> 04:38.130
in einer disziplinen, aber stupiden Weise auch bewerkstelligt werden

04:38.130 --> 04:38.450
könnte.

04:38.970 --> 04:41.490
Und das ist eigentlich schon mit die entscheidende Botschaft, die er

04:41.490 --> 04:46.230
damals formuliert hatte in den 50ern, wichtig ist das, was er nannte

04:46.230 --> 04:48.110
eine stupide Weise.

04:48.230 --> 04:50.410
Stupide, jetzt mal überlegt, was heißt das?

04:50.470 --> 04:54.010
Stupide heißt in dem Falle, dass es keinen Interpretationsspielraum

04:54.010 --> 04:54.370
mehr gibt.

04:54.590 --> 04:57.010
Es ist also nicht ein Befehl, wo man vielleicht noch eine gewisse

04:57.010 --> 05:00.050
Intelligenz aufwenden müsste, um zu überlegen, was könnte denn dieser

05:00.050 --> 05:03.270
Befehl bedeuten, sondern nein, es gibt keinen

05:03.270 --> 05:07.710
Interpretationsspielraum, es ist hochobjektiv und man kann im Prinzip

05:07.710 --> 05:10.970
das mechanisch, ohne nachzudenken, ausführen.

05:12.330 --> 05:16.270
Und das ist in der Tat dann auch Programmieren, dass man sagt, ich

05:16.270 --> 05:19.630
bringe einen Computer dabei, durch einen sehr präzise festgelegten

05:19.630 --> 05:21.250
Berechnungsprozess etwas auszuführen.

05:21.910 --> 05:25.050
Und wenn ihr so wollt, ist letzten Endes Programmieren die Tätigkeit,

05:25.730 --> 05:29.030
ein Problem, in der Regel ja aus der realen Welt oder aus der

05:29.030 --> 05:32.750
Mathematik, so umzuformulieren, dass es ein Computer lösen kann und

05:32.750 --> 05:35.930
damit auch so objektiv die Lösung zu beschreiben, dass es quasi mit

05:35.930 --> 05:37.890
null Intelligenz lösbar ist.

05:37.950 --> 05:40.270
Die Intelligenz müsst ihr als Programmierer reinstecken, aber der

05:40.270 --> 05:43.570
Computer, der nachher das Programm ausführt, der hat keine

05:43.570 --> 05:44.110
Intelligenz.

05:46.890 --> 05:52.350
So, und jetzt machen wir zur Auflockerung eine kleine Übung zum

05:52.350 --> 05:55.710
Programmieren und zwar bräuchte ich dazu fünf Freiwillige.

05:55.830 --> 05:57.650
Achtung, es ist nichts Schlimmes, es ist auch nicht wie bei

05:57.650 --> 06:00.810
Hochzeiten, wo man so bloßgestellt wird oder sowas, sondern einfach

06:00.810 --> 06:02.410
nur fünf Freiwillige, die nach vorne kommen.

06:02.490 --> 06:05.870
Es wird natürlich alles super positiv angerechnet für die Prüfung, das

06:05.870 --> 06:09.610
Gesicht werde ich mir ihr ganzes Studium lang merken, also positiv

06:09.610 --> 06:10.830
merken, anders geht auch.

06:11.370 --> 06:14.090
Und das wäre die Bitte, dass jetzt fünf Leute nach vorne kommen und es

06:14.090 --> 06:15.710
nichts Schlimmes, was mit ihnen passiert.

06:16.130 --> 06:18.350
Es gilt unsere Demonstration von Programmieren.

06:18.970 --> 06:21.770
Das Ganze funktioniert jetzt so, wir haben jetzt hier ihre

06:21.770 --> 06:25.770
Kommilitonen und ich verteile jetzt einfach mal zwei Kärtchen.

06:25.910 --> 06:28.870
Sie bekommen die grüne, dann gebe ich mal die rote.

06:29.810 --> 06:32.070
Und was es damit auf sich hat, erkläre ich jetzt.

06:32.070 --> 06:37.350
Und zwar ist die Überlegung, dass wir jetzt ihre Kommilitonen der

06:37.350 --> 06:39.670
Größe nach sortieren möchten.

06:39.830 --> 06:44.390
Das Problem, also was wir lösen wollen, ist sortieren und die

06:44.390 --> 06:47.970
Elementarbefehle oder Operationen, die wir jetzt haben, die Sie bitte

06:47.970 --> 06:52.390
dann nachher auch aufrufen werden, ist in der Tat, dass man die rote

06:52.390 --> 06:54.670
Karte weitergeben soll.

06:55.350 --> 07:00.290
Dann bewegt man mit zwei Händen die Richtung, wo man sagt, die rote

07:00.290 --> 07:04.870
Karte soll weitergegeben werden oder mit einer Hand, wohin die grüne

07:04.870 --> 07:05.870
Karte wandern soll.

07:06.750 --> 07:10.250
Und dann kann man noch eine Drehbewegung mit der Hand machen, also Sie

07:10.250 --> 07:11.890
sind jetzt quasi der Prozessor, der Computer.

07:12.450 --> 07:15.050
Und die Drehbewegung heißt, dass die Leute dann, die diese Karten in

07:15.050 --> 07:18.490
dem Augenblick in der Hand halten, tauschen, die Position tauschen

07:18.490 --> 07:18.790
sollen.

07:19.090 --> 07:22.150
Und das heißt, letzten Endes läuft es also darauf hinaus, abstrakt

07:22.150 --> 07:25.930
gesprochen, dass wir eben die Sortierung durch das Vertauschen von

07:25.930 --> 07:30.570
Kommilitonen in der Position bewerkstelligen.

07:31.290 --> 07:36.630
Und jetzt wäre also die Frage erstmal, was sollte der erste Befehl

07:36.630 --> 07:40.450
sein, sagen wir jetzt, damit es getaktet abläuft, für die grüne Karte?

07:42.790 --> 07:46.670
Genau, Sie zeigen darüber, also eins weiter bitte geben.

07:50.970 --> 07:55.870
Rote Karte, also Tauschbewegung kommt.

07:55.950 --> 07:58.670
Genau, dann bitte tauschen Sie die Positionen.

07:58.730 --> 07:59.190
Danke schön.

08:00.490 --> 08:01.010
Ja, okay.

08:02.250 --> 08:06.530
So, jetzt, wo soll die rote Karte hin?

08:08.190 --> 08:09.530
Die meisten zeigen darüber.

08:09.890 --> 08:11.630
Okay, einmal bitte rübergeben.

08:13.270 --> 08:16.210
Und Tauschbewegung wieder.

08:17.050 --> 08:17.370
Gut.

08:19.570 --> 08:21.970
Bin mir nicht sicher, ob das konvergiert, aber es sind ja Flash

08:21.970 --> 08:23.710
-Kommilitonen mit relativ ähnlicher Größe.

08:24.210 --> 08:25.830
Genau, zwei Hände rüber.

08:27.570 --> 08:31.030
Zwei Hände bei rote Karte, also rote Karte eins rüber.

08:32.710 --> 08:34.530
So, und tauschen.

08:38.510 --> 08:40.070
Ja, das sieht ja schon besser aus.

08:40.070 --> 08:43.650
Und jetzt grüne Karte, wohin?

08:44.930 --> 08:45.790
Grüne Karte darüber.

08:48.150 --> 08:48.930
Weiter rüber.

08:52.630 --> 08:54.050
Nein, nein, nein, das geht nicht.

08:54.510 --> 08:56.390
Absturz des Systems, Rechner kaputt.

08:56.890 --> 08:58.230
So, wohin die grüne Karte?

08:59.110 --> 09:00.470
Weiter rüber, genau.

09:01.490 --> 09:03.350
Und rote Karte weiter.

09:04.230 --> 09:05.210
Genau, nochmal rüber, genau.

09:06.630 --> 09:11.090
Und jetzt die rote Karte nochmal.

09:12.650 --> 09:13.270
Wohin die rote?

09:13.610 --> 09:14.370
Darüber, genau.

09:16.490 --> 09:18.990
Ja, jetzt nicht tauschen.

09:20.470 --> 09:24.750
Also nochmal die rote Karte rüber und jetzt tauschen.

09:25.530 --> 09:27.170
Und jetzt haben wir es, glaube ich, geschafft.

09:28.270 --> 09:30.290
Ja, das ist sehr knapp alles, gebe ich zu.

09:30.830 --> 09:31.970
So, vielen Dank.

09:32.490 --> 09:33.450
Das war es schon gewesen.

09:33.550 --> 09:34.830
Danke, dass Sie mitgearbeitet haben.

09:35.610 --> 09:40.950
So, jetzt kann man sich in der Tat fragen, war das, was wir jetzt hier

09:40.950 --> 09:45.370
alle gemeinsam gemacht haben, schon Programmieren gewesen?

09:46.230 --> 09:47.670
Zum einen Teil ja.

09:48.010 --> 09:49.910
Wir hatten einen Prozess uns definiert.

09:50.130 --> 09:52.930
Das war in dem Sinne objektiv, was wir gemacht haben.

09:53.010 --> 09:56.350
Es gab auch eindeutig Instruktionen, Karten bewegen, tauschen.

09:56.410 --> 09:58.690
Das war unser Befehlssatz, unser Instruktionssatz gewesen.

09:59.670 --> 10:03.590
Und wir haben tatsächlich eine etwas aufwendigere Aufgabe, nämlich

10:03.590 --> 10:07.930
sortieren der Größe nach, runtergebrochen in eine Abfolge dieser

10:07.930 --> 10:09.870
elementaren Operationen.

10:09.890 --> 10:14.630
Und das ist genau auch ein Charakteristikum von Programmieren.

10:15.770 --> 10:20.650
Aber so ganz auch noch nicht, weil Sie mussten ja schon nachdenken.

10:20.850 --> 10:23.990
Sie mussten ja nachdenken, muss es jetzt nach links, muss es jetzt

10:23.990 --> 10:24.590
nach rechts.

10:24.930 --> 10:26.130
Sie mussten die Kommilitonen anschauen.

10:26.230 --> 10:29.010
Das heißt, so ganz stupide war das eigentlich nicht, was quasi Sie als

10:29.010 --> 10:30.570
Prozessor gemacht haben.

10:32.130 --> 10:36.310
Und es fehlt auch der allgemeine Plan.

10:37.310 --> 10:41.590
Das war ja jetzt speziell für diese Konstellation von Kommilitonen,

10:41.690 --> 10:45.530
auch speziell in der Art, wie sie auch initial standen, hat natürlich

10:45.530 --> 10:49.010
diese Befehlsfolge, wenn man so will, zum Ziel geführt.

10:49.990 --> 10:52.570
Hätten die Kommilitonen anders gestanden, hätten wir eine andere

10:52.570 --> 10:53.970
Befehlsfolge gebraucht.

10:54.470 --> 10:57.070
Das heißt also, diese eine Befehlsfolge löst eigentlich nur ein

10:57.490 --> 11:00.710
spezielles Problem, nämlich diese Kommilitonen mit dieser Größe in

11:00.710 --> 11:03.350
dieser Anfangsaufstellung sortieren.

11:04.370 --> 11:07.010
Für alle anderen Sachen wäre die Befehlsfolge logischerweise nicht gut

11:07.010 --> 11:07.350
gewesen.

11:07.470 --> 11:09.090
Und ich weiß, Sie hätten dann auch eine andere genommen.

11:09.230 --> 11:11.530
Aber die Idee ist natürlich bei einem Programm, dass es möglichst

11:11.530 --> 11:12.130
allgemein ist.

11:12.150 --> 11:13.310
Es ist ein allgemeiner Plan.

11:13.430 --> 11:15.410
Das heißt, es muss genereller sein.

11:15.890 --> 11:18.690
Es muss für zum Beispiel eine beliebige Anzahl von Personen klappen

11:18.690 --> 11:24.370
und auch in beliebigen initialen Konfigurationen, also sprich in

11:24.370 --> 11:26.390
beliebigen Reihenfolgen, wie man da steht.

11:27.430 --> 11:31.050
Und natürlich möchte man auch in dem Sinne abstrakt sein.

11:32.090 --> 11:35.930
Erinnern Sie sich, abstrakt heißt, weglassen von Details, die für die

11:35.930 --> 11:37.270
Problemlösung nicht relevant sind.

11:37.830 --> 11:41.010
Und das heißt, wir möchten ja vielleicht nicht nur Personen sortieren,

11:41.610 --> 11:46.150
sondern eigentlich alles, was aufgrund eines Merkmals in eine

11:46.150 --> 11:47.550
Reihenfolge gebracht werden kann.

11:48.230 --> 11:49.990
Das können Zahlen sein verschiedener Art.

11:50.990 --> 11:53.690
Das können Gegenstände sein, die wir abbilden können auf Zahlen.

11:54.870 --> 11:57.230
Das heißt mit anderen Worten, wir möchten eigentlich einen möglichst

11:57.230 --> 12:01.530
allgemeinen Sortieralgorithmus haben, ein Verfahren, um Gegenstände,

12:01.610 --> 12:03.110
um Dinge, Personen zu sortieren.

12:04.110 --> 12:06.110
Aber wie gesagt, alles, was eigentlich sortierbar ist und nicht eben

12:06.110 --> 12:08.970
nur Personen und eben, wie gesagt, beliebig viele, endlich viele,

12:08.970 --> 12:09.910
klar, aber beliebig viele.

12:10.610 --> 12:15.690
Und auch von unterschiedlichen Anfangskonfigurationen aus.

12:15.790 --> 12:17.650
Das wäre dann wirklich ein Programm gewesen.

12:18.010 --> 12:20.270
Aber wie gesagt, ein paar Elemente von Programmieren haben wir jetzt

12:20.270 --> 12:22.070
schon in diesem einfachen Spiel gelernt.

12:23.810 --> 12:31.110
Jetzt ist es so, wir programmieren den Computer in einer Sprache, die

12:31.110 --> 12:31.990
der Computer versteht.

12:32.070 --> 12:34.810
Das ist die Programmiersprache Java jetzt in diesem Kurs.

12:37.130 --> 12:40.090
Die Idee bei Java dahinter, Sie können fragen, warum jetzt die

12:40.090 --> 12:42.610
Programmiersprache und nicht eine von den 27.000 anderen.

12:43.790 --> 12:47.870
Das ist eine Sprache, die viele aus unserer Sicht didaktisch sinnvolle

12:47.870 --> 12:51.030
Konzepte Ihnen vermittelt und gut ausdrückbar macht.

12:51.950 --> 12:54.310
Das ist das, was wir objektorientiert nennen.

12:54.530 --> 12:57.410
Was das heißt, wird jetzt im Laufe noch später von diesen 90 Minuten

12:57.410 --> 12:58.090
mal deutlicher.

12:58.950 --> 13:00.030
Nehmen Sie das jetzt erstmal so hin.

13:01.650 --> 13:05.310
Sie hat einen großen Vorteil, sie ist plattformunabhängig in dem

13:05.310 --> 13:08.890
Sinne, dass sie nicht an ein bestimmtes Computersystem und ein

13:08.890 --> 13:10.430
bestimmtes Betriebssystem gebunden ist.

13:10.510 --> 13:11.790
Auch dazu nachher mehr.

13:13.330 --> 13:16.910
Jetzt könnte man sagen, warum denn jetzt nicht eine Umgangssprache?

13:19.510 --> 13:21.050
Umgangssprache ist halt oft mehrdeutig.

13:21.930 --> 13:24.590
Also spätestens, wenn man den Satz zweimal gelesen hat, wird einem

13:24.590 --> 13:26.430
deutlich, dass er mehrdeutig ist.

13:26.710 --> 13:29.630
Und da sieht man also, wie schnell das passiert, auch ohne, dass man

13:29.630 --> 13:32.770
darüber selbst offenbar noch gewissen Aufwand reinsteckt, das Ganze zu

13:32.770 --> 13:35.270
drucken und zu stanzen und zu pressen und aufzuhängen.

13:35.950 --> 13:37.690
Dass einem noch nicht auffällt, dass es mehrdeutig ist.

13:37.730 --> 13:39.330
Aber wie gesagt, wenn man darüber nachdenkt, merkt man, dass er

13:39.330 --> 13:40.510
mehrdeutig ist, der Satz.

13:41.230 --> 13:42.670
Und das ist so ein bisschen die Gefahr.

13:42.750 --> 13:46.250
Wir wollen ja einen hochobjektiven Prozess machen, wo eben kein

13:46.250 --> 13:49.530
Interpretationsspielraum mehr da ist, weil der Computer kann nichts

13:49.530 --> 13:50.670
intelligent interpretieren.

13:50.750 --> 13:52.770
Der Computer kann nur stumpfsinnig Befehle abarbeiten.

13:53.410 --> 13:57.450
Und bei diesem Satz ist es halt schon so, dass man halt nachdenken

13:57.450 --> 14:00.970
muss und sagen muss, offenbar ist die Klammerung Straftaten durch die

14:00.970 --> 14:01.390
Polizei.

14:01.590 --> 14:04.370
Diese Klammerung war wohl nicht gemeint, vor allem nicht, wenn es das

14:04.370 --> 14:09.150
Polizeipräsidium selber aufhängt, sondern die Klammerung war natürlich

14:09.150 --> 14:12.650
so Verhütung von Straftaten und dann Klammer, durch die Polizei

14:12.650 --> 14:13.490
Videoüberwacht.

14:13.810 --> 14:16.290
Man hätte das Problem natürlich umgehen können, indem man gesagt

14:16.290 --> 14:19.010
hätte, einfach dieser Bereich wird zur Verhütung von Straftaten

14:19.010 --> 14:20.490
Videoüberwacht durch die Polizei.

14:20.810 --> 14:21.850
Aber man hat halt nicht dran gedacht.

14:23.030 --> 14:26.330
Da sehen Sie also, Umgangssprache ist zum Programmieren wegen dieser

14:26.330 --> 14:29.350
Mehrdeutigkeiten, Unerdeutigkeiten nicht geeignet.

14:31.130 --> 14:38.390
Deswegen nehmen wir eine Programmiersprache, die eben eine, wir sagen

14:38.390 --> 14:42.230
als Informatiker, eine formale Semantik hat, eine formale Bedeutung

14:42.230 --> 14:43.210
einem Programm hinterlegt.

14:43.330 --> 14:44.290
Die ist halt eindeutig.

14:46.130 --> 14:48.670
So und genau das sollen Sie jetzt eigentlich auch lernen.

14:48.790 --> 14:53.690
Sie sollen lernen, wie entwickle ich einfache Algorithmen, das sind

14:53.690 --> 14:56.450
aber zugegebenerweise nur sehr einfache Algorithmen, also allgemeine

14:56.450 --> 15:01.150
Problemlösungen und vor allem, wie baue ich die dann um in eine

15:01.150 --> 15:04.630
Programmiersprache, wie modelliert man das Problem in einer

15:04.630 --> 15:05.950
Programmiersprache.

15:06.190 --> 15:08.830
Dazu braucht man diese Fähigkeit zur Modellbildung, zur Abstraktion,

15:09.330 --> 15:10.510
werden wir uns ein bisschen anschauen.

15:11.130 --> 15:15.150
Aber Sie lernen eben auch, sauber zu programmieren, das heißt auch,

15:15.170 --> 15:18.170
wie kann man so programmieren, dass es nachher für einen selber noch

15:18.170 --> 15:20.770
verständlich ist und auch für andere, die das Ganze lesen.

15:21.370 --> 15:25.790
Die vielleicht wichtigste Botschaft, der man den nächsten Monaten

15:25.790 --> 15:28.330
Ihnen vermitteln will, ist nicht nur, wie man programmiert, sondern

15:28.330 --> 15:31.510
Sie schreiben das Programm nicht für den Computer, sondern für den

15:31.510 --> 15:32.750
nächsten Menschen, der es lesen muss.

15:33.210 --> 15:35.330
Das ist eine ganz tiefe, wichtige Einsicht.

15:37.850 --> 15:40.350
Und natürlich, das Ganze soll nachvollziehbar sein, nachvollziehbar

15:40.350 --> 15:42.350
modelliert sein, soll gut strukturiert sein.

15:43.090 --> 15:46.270
Was das alles bedeutet, das wird Ihnen im Verlauf der nächsten Monate

15:46.270 --> 15:47.510
hoffentlich deutlich.

15:48.270 --> 15:51.210
Wenn man jetzt noch mal das ganze Bild der Softwareentwicklung etwas

15:51.210 --> 15:54.490
größer macht, dann wird man sehen, programmieren ist, wenn man will,

15:54.570 --> 15:58.070
nur eine Sicht auf mein Software-System.

15:58.530 --> 16:01.510
Es ist die Sicht auf das Software-System, die dem Prozessor genau

16:01.510 --> 16:03.730
verklickert, was er tun soll, flapsig gesagt.

16:04.690 --> 16:06.050
Das ist aber nicht alles.

16:07.330 --> 16:12.310
Wenn Sie ein Problem aus der realen Welt umsetzen sollen in Software,

16:12.530 --> 16:16.370
in ein finalerweise auch ein Programm, dann müssen Sie sich erst mal

16:16.370 --> 16:18.210
Gedanken machen, was ist denn das Problem?

16:18.670 --> 16:19.970
Was will man denn eigentlich von mir?

16:20.590 --> 16:23.670
Bei dem Programm, die wir Ihnen hier geben in der Vorlesung, ist das

16:23.670 --> 16:26.710
so offensichtlich klar, dass Sie gar nicht verstehen, dass das

16:26.710 --> 16:27.630
eigentlich ein Problem ist.

16:27.790 --> 16:30.110
Weil wir sagen Ihnen zum Beispiel, bitte schreiben Sie ein Programm,

16:30.230 --> 16:31.430
was ein paar Zahlen aufsummiert.

16:31.490 --> 16:33.650
Dann wissen Sie alle natürlich mit Ihrem mathematischen

16:33.650 --> 16:37.290
Grundverständnis, was die sogenannte Anforderung an das Programm ist,

16:37.730 --> 16:38.530
English Requirement.

16:39.870 --> 16:44.070
Wenn Sie natürlich jetzt als frischgebackener Master-Informatiker dann

16:44.070 --> 16:46.470
mal irgendwo zu einer Bank gehen und jemand sagt Ihnen, oh, ich

16:46.470 --> 16:49.870
brauche ein Anlageprogramm für eine bestimmte Art von Finanzderivaten,

16:49.930 --> 16:52.610
dann würden Sie erst mal sagen, ja gut, was ist das denn eigentlich?

16:53.050 --> 16:55.170
Das heißt natürlich verstehen Sie nicht das Problem auf Anhieb,

16:55.230 --> 16:57.630
sondern Sie müssen erst mal verstehen, was das Problem ist.

16:57.670 --> 17:01.590
Das ist das sogenannte, auf Englisch Requirements Engineering oder auf

17:01.590 --> 17:04.130
Deutsch eben die Anforderungserhebung, die Anforderungsanalyse.

17:04.350 --> 17:07.450
Auch das müssen Sie als Informatiker machen und damit Sie gleich nicht

17:07.450 --> 17:10.610
mit der Fehlkonzeption vieler Generationen von Informatikern ins Leben

17:10.610 --> 17:14.550
starten, dummerweise ist die Welt nicht so, wie die Informatiker sich

17:14.550 --> 17:17.290
das immer wünschen, dass nämlich die blöden Anwender uns die

17:17.290 --> 17:20.250
Anforderungen fertig dokumentiert über die Mauer werfen, wir in Ruhe,

17:20.310 --> 17:22.910
was wir am liebsten tun, am Computer rumcoden und irgendwann werfen

17:22.910 --> 17:24.730
wir das Programm zurück über die Mauer zum Anwender.

17:25.030 --> 17:25.990
So klappt es leider nicht.

17:26.630 --> 17:29.250
Das liegt daran, weil die Anwender so dumm sind, die können auch nicht

17:29.250 --> 17:30.450
mal die Anforderungen aufschreiben.

17:30.910 --> 17:32.290
Die wissen gar nicht, was sie wollen.

17:32.790 --> 17:35.070
Wenn Sie mit fünf Anwendern reden, die werden Ihnen sechs verschiedene

17:35.070 --> 17:37.090
Meinungen erzählen, was Sie haben wollen, wenn Sie Glück haben.

17:38.330 --> 17:43.150
Das heißt also alleine zu verstehen, was wollen die, ist eine

17:43.150 --> 17:44.350
Informatikeraufgabe.

17:44.690 --> 17:45.630
Das machen die nicht für sich.

17:46.810 --> 17:49.890
Es funktioniert also im Wesentlichen so, dass man dann halt mit

17:49.890 --> 17:53.290
bestimmten Techniken, die Sie alle im weiteren Verlauf des Studiums

17:53.290 --> 17:59.590
lernen, wie interviewt man Anwender, wie geht man mit den Konflikten

17:59.590 --> 18:01.210
um, die verschiedene Personengruppen haben.

18:01.290 --> 18:04.850
Sie können sich vorstellen, die Person, die das Programm bezahlt, hat

18:04.850 --> 18:06.970
unter Umständen andere Vorstellungen darüber, wie die Person, die das

18:06.970 --> 18:07.810
Programm benutzen muss.

18:08.850 --> 18:12.030
So lange Rede kurzer Sinn, also diese Anforderungserhebung, das ist

18:12.030 --> 18:14.990
ein Riesenthema, hat aber mit dem Computer an sich jetzt erstmal noch

18:14.990 --> 18:15.590
gar nichts zu tun.

18:15.690 --> 18:18.710
Sie müssen als Informatiker, deswegen ist die Ausbildung ja

18:18.710 --> 18:23.750
Informatiker oder Informationswirt, Wirtschaftsinformatiker, heißt ja

18:23.750 --> 18:26.410
nicht Programmierer, Sie sind tatsächlich Informatiker, das heißt, Sie

18:26.410 --> 18:29.190
lernen mit Informationen umzugehen, das heißt, Sie lernen erstmal

18:29.190 --> 18:32.970
abstrakte Probleme zu formalisieren, zu modellieren und dann kommt der

18:32.970 --> 18:35.830
Schritt, wo man sagt, okay, wie baue ich das jetzt in einem Software

18:35.830 --> 18:36.590
-System um.

18:37.150 --> 18:40.110
Dann machen wir erstmal eine Architektur, genauso wie das auch ist im

18:40.110 --> 18:41.390
Hausbau, im Gebäudebau.

18:41.810 --> 18:44.110
Da fängt ja auch nicht einer an und sagt, ich will zum Beispiel den

18:44.110 --> 18:47.330
Flughafen Berlin, ich lege erstmal ein paar Steine aufeinander und

18:47.330 --> 18:49.050
dann, ups, okay, blödes Beispiel.

18:50.070 --> 18:54.910
Sagen wir mal, ich möchte dieses Hörsaalgebäude, da fangen Sie ja auch

18:54.910 --> 18:58.030
nicht an, lege erstmal ein paar Steine hin und sagen irgendwann, boah,

18:58.230 --> 19:00.750
ich weiß jetzt auch nicht, ob das hält, sondern Sie machen erstmal

19:00.750 --> 19:03.530
eine Architektur und genauso ist das auch bei der Softwareentwicklung.

19:04.030 --> 19:08.010
Es gibt sehr grundlegende Entscheidungen, Entwurfsentscheidungen und

19:08.010 --> 19:12.470
die werden in einer sogenannten Software-Architektur dokumentiert und

19:12.470 --> 19:15.930
wenn die steht und man eine Menge Fragen schon mal beantwortet hat,

19:16.010 --> 19:18.550
wie muss ich das selber programmieren oder gibt es da schon was Altes,

19:18.630 --> 19:20.790
was ich nehmen kann oder kaufe ich mir das nicht einfach ein, weil es

19:20.790 --> 19:23.830
das eh schon lange gibt und all so Sachen, dann erst kommt man zum

19:23.830 --> 19:24.450
Programmieren.

19:25.130 --> 19:27.050
Das waren die drei Sichten, die Sie hier sehen.

19:27.650 --> 19:29.730
Es gibt die Anforderungen, es gibt die Architektur, es gibt den

19:29.730 --> 19:32.590
Programmcode und wenn man ehrlich ist, gibt es noch viel, viel mehr

19:32.590 --> 19:35.010
Sichten, das habe ich jetzt nicht drauf, wegen der Verwirrung.

19:35.090 --> 19:37.250
Es gibt Sichten darüber, wie verteile ich die Software auf

19:37.250 --> 19:39.610
verschiedenen Rechnerknoten, weil die meiste Software läuft irgendwie

19:39.610 --> 19:41.110
vernetzt ab und nicht isoliert.

19:42.330 --> 19:45.190
Wenn Sie sich komplexere Systeme vorstellen, wie zum Beispiel ein

19:45.190 --> 19:48.190
autonomes Fahrzeug, da steckt ja auch hauptsächlich Software drin und

19:48.190 --> 19:51.930
es fährt autonom, weil da Software drin ist, nicht weil ein schlauer

19:51.930 --> 19:55.050
Sensor drin ist, dann können Sie sich vorstellen, da haben Sie noch

19:55.050 --> 19:57.410
mehr Sichten, weil auf einmal haben Sie Sichten auch über die Technik,

19:57.670 --> 19:59.670
über die Sensorik, über die Verkabelung und so weiter.

19:59.770 --> 20:02.110
Das heißt, Sie haben immer mehr Sichten, die irgendwie konsistent

20:02.110 --> 20:05.210
gehalten werden müssen und schlussendlich, wenn Sie sich nicht nur das

20:05.210 --> 20:08.570
Auto anschauen, selbst wenn es autonom fährt, sondern das sogenannte

20:08.570 --> 20:11.690
Mobilitätssystem, das heißt also den Verbund der verschiedenen

20:11.690 --> 20:15.930
Verkehrsmittel vom Car-Sharing zum Bike-Sharing, zum Fußgänger, zum

20:15.930 --> 20:19.530
Auto, eben zur Bahn, öffentlichen Nahverkehr und so weiter, dann

20:19.530 --> 20:21.530
merken Sie, wir haben eine ganze Menge Software-Systeme, die

20:21.530 --> 20:22.670
untereinander vernetzt sind.

20:23.590 --> 20:26.150
Und auch das sind wieder alle Sichten, die wieder miteinander

20:26.150 --> 20:29.050
konsistent gehalten werden und Sie merken, das Programmieren ist eine

20:29.050 --> 20:29.730
Sicht davon.

20:29.870 --> 20:31.270
Aber es ist der Fokus dieser Vorlesung.

20:31.310 --> 20:32.290
Sie müssen also nicht weglaufen.

20:32.850 --> 20:35.230
Im Folgenden reden wir schon über Programmieren.

20:38.550 --> 20:41.270
Mist, hätte ich früher sagen sollen.

20:44.070 --> 20:46.370
Was kann man damit anfangen, wenn man gut programmieren kann?

20:46.470 --> 20:49.290
Man kann eigentlich schon eine ganze Menge machen, nämlich an eine

20:49.290 --> 20:51.070
Sache, die ich durchaus ans Herz legen will.

20:51.210 --> 20:53.210
Sie können in Open-Source-Projekten mitarbeiten.

20:54.530 --> 20:56.690
Unauffällig, macht das schon einer, weil als Schüler das vielleicht

20:56.690 --> 20:56.890
schon?

20:57.410 --> 20:58.730
Super, das ist echt gut.

20:59.510 --> 21:00.410
Warum finde ich das gut?

21:00.810 --> 21:02.810
Weil man lernt selber nochmal gut programmieren.

21:02.910 --> 21:06.770
Indem man sich den Code von anderen anschaut, merkt man auch selber,

21:06.950 --> 21:09.070
wie gute Programme aussehen oder auch vielleicht, wie man es besser

21:09.070 --> 21:11.310
nicht machen sollte, weil man ärgert sich darüber, wie ein anderer das

21:11.310 --> 21:13.290
gemacht hat und man hat es die ganze Zeit nicht verstanden.

21:13.450 --> 21:15.830
Auch das ist dann Lernen durch negative Beispiele.

21:16.450 --> 21:19.370
Aber das ist eine Sache, die zum Beispiel die Architekturstudenten,

21:20.450 --> 21:24.890
die Studierenden, ihre Kommilitoninnen von der Architekturfakultät

21:24.890 --> 21:28.630
durchaus machen, die schauen sich auch bestehende Entwürfe von

21:28.630 --> 21:32.710
historischen oder auch aktuellen Bauwerken an, um damit zu lernen, was

21:32.710 --> 21:34.070
ist ein guter Architekturstil.

21:34.450 --> 21:35.770
Und dasselbe gilt auch beim Programmieren.

21:36.110 --> 21:39.810
Dadurch, dass sie Code von anderen Menschen lesen, lernen sie auch

21:39.810 --> 21:40.670
besser zu programmieren.

21:40.990 --> 21:43.390
Außerdem ist es auf den Lebenslauf immer auch ein Pluspunkt zu sagen,

21:43.790 --> 21:45.870
ich habe auch ein Open-Source-Projekt mitgearbeitet, weil dann seht

21:45.870 --> 21:49.030
natürlich auch ein zukünftiger Arbeitgeber, dass sie sich da schon mal

21:49.030 --> 21:51.070
engagiert haben bei sowas und auch was gelernt haben.

21:52.210 --> 21:55.530
Sie können natürlich auch tatsächlich in Unternehmen auch schon als

21:55.530 --> 21:57.010
Student, Studentin arbeiten.

21:57.110 --> 21:58.730
Man verdient damit natürlich auch nicht schlecht Geld.

21:59.890 --> 22:02.130
Will ich aber nur bedingt empfehlen, weil Sie sollen sich ja aufs

22:02.130 --> 22:02.830
Studium konzentrieren.

22:03.910 --> 22:08.710
Sie können sich nach dem Studium auch selbstständig machen oder ganz

22:08.710 --> 22:11.070
anders, Sie können auch irgendwelche Apps schreiben, sich selber auch

22:11.070 --> 22:12.750
schreiben für das Smartphone, mit Freunden teilen.

22:13.990 --> 22:18.010
Und wie ich ja auch in der allgemeinen Motivation und der

22:18.010 --> 22:21.090
Einführungsveranstaltung in der Erstsemesterbegrüßung letzte Woche

22:21.090 --> 22:25.570
gesagt habe, im Prinzip sind Sie als Informatiker nachher derjenige,

22:25.730 --> 22:28.870
der gesellschaftliche Probleme auch löst, Mobilitätskonzepte,

22:28.930 --> 22:30.050
Energieversorgung und so weiter.

22:30.150 --> 22:33.030
Alles Mögliche wird heute durch Software gemacht und man braucht die

22:33.030 --> 22:34.690
Leute, die diese Software programmieren.

22:36.390 --> 22:38.350
Also wohin geht die Reise?

22:38.590 --> 22:42.850
Im Prinzip hat das schon Alan Turing in den 50ern relativ klar

22:42.850 --> 22:43.450
vorausgesagt.

22:43.530 --> 22:46.230
Er sagt, es gibt eigentlich keine Grenze.

22:46.410 --> 22:50.430
Er sagt, es gibt im Prinzip keinen Grund, warum irgendein Gebiet nicht

22:50.430 --> 22:55.670
durch Computerprogramme mal irgendwann beherrscht werden soll.

22:56.850 --> 23:01.170
Vor ungefähr fünf Jahren hat der Unternehmer aus dem Silicon Valley,

23:01.310 --> 23:03.710
Marc Andreessens, gesagt, Software eats the world.

23:04.370 --> 23:07.970
Und es stimmt natürlich, wenn Sie sich schauen, moderne Apps wie Uber

23:07.970 --> 23:10.850
zum Beispiel, Bed & Breakfast und so weiter, Booking.com und so

23:10.850 --> 23:12.890
weiter, das sind alles erstmal Softwareanwendungen.

23:13.090 --> 23:15.230
Und es gibt wenig, was das Unternehmen hat.

23:15.910 --> 23:18.530
Also Uber hat kein einziges Taxifahrzeug.

23:19.310 --> 23:21.030
B&B hat kein einziges Hotel.

23:21.230 --> 23:23.810
Das sind alles nur Softwareplattformen, worüber dann diese modernen

23:23.810 --> 23:24.770
Geschäftsmodelle aber gehen.

23:25.170 --> 23:28.050
Und natürlich zum Teil essen sie auch klassische Geschäftsmodelle weg.

23:28.690 --> 23:32.230
Und insofern, also das ist eine extrem zentrale Qualifikation, die sie

23:32.230 --> 23:32.790
hier erwerben.

23:34.290 --> 23:39.370
Lernziel ist also, dass Sie ein einfaches Java-Programm schreiben,

23:39.570 --> 23:40.530
kompilieren und ausführen können.

23:40.610 --> 23:42.190
Das wäre sogar das Lernziel schon für heute.

23:42.770 --> 23:45.770
Und dass Sie schon einige der Grundelemente von einem Java-Programm

23:45.770 --> 23:45.990
kennen.

23:46.050 --> 23:48.030
Wir gucken uns nämlich gleich eins mal an.

23:52.010 --> 23:55.610
Das erste Beispielprogramm, was Sie sehen, vielleicht das erste

23:55.610 --> 23:58.830
Programm in Ihrem Leben, ich weiß es nicht, macht was ganz Einfaches.

23:58.970 --> 24:02.490
Es summiert die Zahlen von 1 bis N auf.

24:02.930 --> 24:06.730
Also das hier mal hingeschrieben mit der Summenformel, also im Prinzip

24:06.730 --> 24:08.710
ist das 1 plus 2 plus bis N.

24:10.590 --> 24:13.470
Und jetzt kann man sich überlegen, diese Zahlen nacheinander

24:13.470 --> 24:14.170
aufsummieren.

24:14.930 --> 24:18.410
Wie würde man so etwas hinschreiben, dass ein Computer, der Java

24:18.410 --> 24:21.730
-Programme versteht, was das bedeutet, erkläre ich nachher, auch

24:21.730 --> 24:22.470
machen kann.

24:23.370 --> 24:27.050
So und das Erste, was ich mache, ist, ich deklariere mir sogenannte

24:27.050 --> 24:27.930
Variablen.

24:28.030 --> 24:29.650
Was das ist, kommt in der extra Vorlesung dran.

24:29.730 --> 24:30.550
Das ist hier das N.

24:31.830 --> 24:33.170
Bis wohin soll ich sortieren?

24:33.250 --> 24:35.290
Da nehme ich mal aus naheliegenden Gründen 42.

24:36.490 --> 24:39.010
Und ich will bei 1 anfangen.

24:39.170 --> 24:39.890
Das ist also hier.

24:39.890 --> 24:42.610
Also setze ich erstmal diese Variable i auf den Wert 1.

24:43.510 --> 24:46.150
Die Summe ist am Anfang 0.

24:46.250 --> 24:47.170
Ich habe ja noch nichts addiert.

24:48.530 --> 24:49.290
Das passiert hier.

24:49.670 --> 24:54.270
Und jetzt sage ich, weil, also das englische Wort für während, solange

24:54.270 --> 24:59.030
i noch kleiner gleich diesem N ist, summiere ich das auf, was vorher

24:59.030 --> 25:00.250
da war und noch eins dazu.

25:00.810 --> 25:03.690
Alle Leute, die noch nicht programmieren können, werden jetzt erstmal

25:03.690 --> 25:05.210
sagen, hä, was für ein Quatsch.

25:05.770 --> 25:07.630
Sum ist gleich Sum plus i.

25:07.930 --> 25:09.650
Das stimmt doch nur, wenn i gleich 0 ist.

25:10.070 --> 25:10.290
Stimmt.

25:10.510 --> 25:13.010
Als mathematische Gleichung gelesen wäre das die einzige Logik

25:13.010 --> 25:13.410
dahinter.

25:14.390 --> 25:15.710
Hier, das ist aber keine Gleichung.

25:15.910 --> 25:17.450
Das ist ein Befehl an den Computer.

25:17.610 --> 25:21.710
Und das heißt, der neue Wert, der in dieser Variablen Sum steht, soll

25:21.710 --> 25:24.710
der alte Wert sein und noch das i dazu addiert.

25:25.290 --> 25:27.170
Das ist also keine Gleichung, sondern ein Befehl.

25:28.390 --> 25:31.170
Und das nur zu denjenigen, die noch nicht programmieren können, weil

25:31.170 --> 25:33.430
das als Gleichung zu lesen ist naheliegend, aber ist falsch.

25:33.510 --> 25:34.390
Dasselbe gilt auch hier.

25:35.430 --> 25:36.730
i ist gleich i plus 1.

25:36.790 --> 25:39.970
Das macht so gar keinen Sinn, wenn man das als Gleichung liest.

25:40.110 --> 25:43.290
Auch hier wieder, das heißt, so viel wie i soll um 1 erhöht werden.

25:43.650 --> 25:46.790
Und das mache ich so lange, bis das i auf den Wert n kommt.

25:46.890 --> 25:49.690
Und genau das besagt ja eigentlich unsere Summenformel.

25:50.310 --> 25:53.830
Und nochmal mathematisch hingeschrieben ist das hier der Wert.

25:54.230 --> 25:55.970
So, 903.

25:57.150 --> 26:00.410
Jetzt weise ich einige generbost, weil sie sagen, was für ein Quatsch.

26:00.490 --> 26:01.530
Der hat ja gar keine Ahnung.

26:02.030 --> 26:03.510
Das kann man ja alles viel schneller machen.

26:03.650 --> 26:04.010
Stimmt.

26:04.550 --> 26:07.430
Und es kommt nämlich eine ganz wichtige Botschaft am kleinen Beispiel.

26:08.410 --> 26:10.190
Erstmal über das Problem nachdenken.

26:10.410 --> 26:12.650
Genauso wie der Mauer will, wenn Sie ein Haus bauen, wollen Sie nicht

26:12.650 --> 26:15.890
anfangen, Ziegelsteine aufeinander zu stapeln, sondern Sie denken erst

26:15.890 --> 26:17.570
mal nach, was will ich denn eigentlich erreichen.

26:18.390 --> 26:23.390
Und wenn Sie das tun, werden Sie vielleicht sich erinnern, vielleicht

26:23.390 --> 26:25.930
werden Sie es auch hier in der Uni erst lernen, da gibt es eine

26:25.930 --> 26:26.350
Formel.

26:27.350 --> 26:30.050
Man muss gar nicht mühsam alle Zahlen einzeln hintereinander

26:30.050 --> 26:34.150
aufaddieren, sondern es gibt die Gauss'sche Summenformel, die da

26:34.150 --> 26:37.530
lautet n mal n plus 1 durch 2 ist genau das.

26:37.610 --> 26:39.290
Jetzt kann man sagen, wie kann das sein?

26:39.750 --> 26:42.070
Der Legende nach, ich weiß nicht, ob es stimmt, ich war nicht dabei,

26:42.170 --> 26:45.730
hat Gauss das schon irgendwie als zartes kleines Schulkind entdeckt,

26:45.790 --> 26:48.890
weil der Lehrer wollte nämlich die Schüler damit beschäftigen, dass

26:48.890 --> 26:51.370
sie mal die ersten 100 Zahlen aufaddieren und dachten, da haben die

26:51.370 --> 26:53.930
jetzt so lange mit zu tun, ich kann mal in Ruhe Zeitungen lesen oder

26:53.930 --> 26:55.230
was damals so Lehrer gemacht haben.

26:56.010 --> 26:59.550
Und blöderweise hat der kleine Gauss dann nach 5 Minuten gesagt, ich

26:59.550 --> 27:04.550
weiß es schon, das ist nämlich 50 mal 99, 50 mal 101.

27:05.090 --> 27:06.950
Und dann sagte der Lehrer, warum?

27:07.070 --> 27:09.530
Und die Logik von Gauss war eigentlich relativ einfach, wie gesagt,

27:09.570 --> 27:11.430
schon als kleines Kind angeblich rausbekommen.

27:12.090 --> 27:15.530
Stellen Sie sich das mal grafisch vor, Sie haben 1, dann haben Sie 1,

27:15.670 --> 27:19.330
2, so einfach als Punkte mal vorgestellt, dann haben Sie 1, 2, 3.

27:19.450 --> 27:21.270
Sie merken, das ist so ein Dreieck, was ansteigt.

27:21.870 --> 27:24.790
Und Gauss hat sich halt überlegt, naja, was sind denn die Kantenlängen

27:24.790 --> 27:28.730
und das ist natürlich n mal n plus 1.

27:28.870 --> 27:30.250
Und dann hat er gesagt, naja, das ist aber ein Dreieck, das ist nicht

27:30.250 --> 27:31.550
das ganze Quadrat, also die Hälfte.

27:31.730 --> 27:33.570
Und das ist offenbar die Gesamtsumme.

27:34.370 --> 27:37.250
Man kann das auch beweisen, das werden Sie sicherlich in einer der

27:37.250 --> 27:40.370
Mathematikvorlesungen nochmal als Fingerübung vorgerechnet bekommen

27:40.370 --> 27:40.910
oder sehen.

27:41.350 --> 27:43.950
Das ist relativ leicht auch bewiesen, mit Induktion zum Beispiel.

27:44.570 --> 27:48.330
Aber wie gesagt, der Witz ist der, wenn man über das Problem einmal

27:48.330 --> 27:52.030
nachdenkt, bekommt man natürlich eine viel schlauere Implementierung

27:52.030 --> 27:54.230
hin, die nämlich hier ist, da ist das ganze Programm.

27:54.650 --> 27:58.150
Sie sagen, ich will es für 42 wissen und die Summe ist genau das

27:58.150 --> 28:01.150
hingeschrieben, n mal n plus 1 geteilt durch 2.

28:02.750 --> 28:04.550
Natürlich muss man auf die Klammerungen achten, aber das ist kein

28:04.550 --> 28:05.070
Wunder für Sie.

28:05.890 --> 28:10.210
Und das ist ein ganz einfaches Beispiel, wo man sieht, es lohnt sich

28:10.210 --> 28:13.910
einmal über das Problem nachzudenken, bevor man losprogrammiert.

28:14.030 --> 28:17.410
Weil das Programm ist nicht nur kürzer, leichter verständlich, es ist

28:17.410 --> 28:18.250
sogar schneller auch.

28:20.370 --> 28:24.270
Jetzt könnten Sie sagen, naja, so naiv bin ich aber jetzt gar nicht.

28:25.050 --> 28:27.690
Ich ahne ja schon, dass ich in meinem Berufsleben als Informatiker,

28:28.490 --> 28:32.270
als Informatikerin oder Informationswirt, nicht mein ganzes Leben lang

28:32.270 --> 28:33.970
immer nur mathematische Probleme lösen werde.

28:34.070 --> 28:35.910
Stimmt, das machen die wenigsten von Ihnen nachher.

28:36.410 --> 28:38.450
Diejenigen, die im Bereich wissenschaftlichen Rechnern arbeiten

28:38.450 --> 28:39.910
vielleicht schon, aber die meisten natürlich nicht.

28:40.550 --> 28:43.070
Aber dasselbe gilt im Prinzip eben auch allgemein.

28:43.110 --> 28:45.410
Wenn Sie Probleme aus der realen Welt bekommen, ist es erstmal

28:45.410 --> 28:49.350
wichtiger, das Problem zu verstehen und dann die Informatiklösung zu

28:49.350 --> 28:53.190
basteln, anstatt jetzt erstmal blind drauf losprogrammieren.

28:53.670 --> 28:56.050
Schönes Beispiel auch aus einem Industrieberatungsprojekt bei einer,

28:56.130 --> 28:59.110
wo dann einer angerufen hat, also ich muss ganz große Excel-Tabellen

28:59.110 --> 28:59.470
drucken.

28:59.530 --> 29:01.750
Und das geht halt mit Excel nicht und jetzt brauchen wir Informatiker,

29:01.870 --> 29:04.070
die uns Programme schreiben, um ganz große Excel-Tabellen zu drucken.

29:04.630 --> 29:07.090
Wir sind halt hin zu dem Unternehmen und haben uns das mal angehört,

29:07.150 --> 29:08.030
was ist eigentlich das Problem.

29:08.130 --> 29:11.170
Und dann stellte sich raus, wenn man den Arbeitsablauf nur ein kleines

29:11.170 --> 29:13.750
bisschen anders organisiert, ich hätte möglicherweise auch

29:13.750 --> 29:16.610
peinlicherweise gesagt besser organisiert, braucht man gar keine ganz

29:16.610 --> 29:18.830
großen Excel-Tabellen drucken, die so groß sind, dass Excel sie nicht

29:18.830 --> 29:21.370
drucken kann, sondern man kann ganz normal mit Excel arbeiten.

29:21.810 --> 29:24.590
Das heißt also keine Softwarelösung gefragt, einfach nur den

29:24.590 --> 29:25.730
Geschäftsprozess ein bisschen ändern.

29:26.250 --> 29:28.790
Und das ist halt häufig bei uns Informatikern so, dass wir eben nicht

29:28.790 --> 29:32.910
nur darüber nachdenken, wie kann man das jetzt reinkoden und einem

29:32.910 --> 29:35.750
blöden Computer was beibringen, sondern erstmal über das Problem

29:35.750 --> 29:36.670
nachdenken und das verstehen.

29:36.770 --> 29:38.610
Und das sieht man schon an diesem Trivial-Beispiel hier.

29:39.370 --> 29:41.810
Wenn man eben weiß, hier gibt es eine Summenformel, wie sagt der

29:41.810 --> 29:44.150
kleine Gauss, wusste es angeblich, schreibt man auch so viel

29:44.150 --> 29:44.910
schnellere Programme.

29:46.170 --> 29:49.090
So, hier haben wir das Programm jetzt in seiner ganzen Schönheit vor

29:49.090 --> 29:49.390
uns.

29:49.730 --> 29:55.450
Sie sehen, Java-Programme haben sowas drin wie Public Class, was das

29:55.450 --> 29:57.070
bedeutet, kommt später dran.

29:57.530 --> 29:59.590
Wir nennen es jetzt mal Simple-Programm, weil es ein einfaches

29:59.590 --> 30:00.090
Programm ist.

30:00.830 --> 30:03.450
Dann kommt noch sowas, was Sie auch erstmal noch nicht verstehen

30:03.450 --> 30:06.450
müssen, Public Static Void Main String, eckige Klammer auf, eckige

30:06.450 --> 30:08.390
Klammer zu, Args, geschweifte Klammer auf.

30:08.390 --> 30:10.990
Auch das später nicht irritieren lassen.

30:11.490 --> 30:13.970
Und dann kommt das, was wir eben gesehen haben.

30:14.230 --> 30:18.030
NS hat den Wert 42 und ich berechte die Summe durch diese gaussische

30:18.030 --> 30:20.490
Summenformel und ich drucke diese Summe aus.

30:21.690 --> 30:24.830
Diejenigen, die schon programmieren können, wüssten, das kann man

30:24.830 --> 30:25.990
natürlich alles viel kürzer machen.

30:26.350 --> 30:29.770
Man kann natürlich auch genauso reinschreiben System Out Print Line

30:29.770 --> 30:30.730
903.

30:31.130 --> 30:35.650
Ja, stimmt, das war aber nicht Zweck der Übung, sondern, wie gesagt,

30:35.710 --> 30:37.310
ich wollte Ihnen ein einfaches Programm zeigen.

30:38.350 --> 30:39.670
Und was macht man jetzt damit?

30:40.630 --> 30:45.170
Das schreibt man mit einem Textdatei in eine Datei rein.

30:46.770 --> 30:48.430
Und jetzt hat die spannende Frage, wie starte ich das?

30:49.330 --> 30:53.030
So, und jetzt kommt etwas, was Sie im Prinzip jetzt schon verstehen

30:53.030 --> 30:54.910
müssen, weil sonst können Sie die Übungsblätter demnächst nicht

30:54.910 --> 30:55.470
bearbeiten.

30:58.210 --> 31:02.850
Der Prozessor, der Computer, hardware-mäßig, um die bittere Wahrheit

31:02.850 --> 31:04.870
zu sagen, versteht eigentlich nur so etwas wie 001.

31:05.090 --> 31:09.130
Streng genommen nur verschiedene Spannungszustände von Strom an

31:09.130 --> 31:09.850
irgendwelchen Eingängen.

31:11.230 --> 31:14.870
So, mathematisch gesprochen, er kann einen sogenannten Binärcode

31:14.870 --> 31:15.450
verstehen.

31:15.990 --> 31:17.830
Hoher Strom 1, niedriger Strom 0.

31:18.910 --> 31:21.910
Jetzt ist das für uns Menschen aber ein bisschen mühsam, permanent 001

31:21.910 --> 31:25.830
einzutippen, schon allein deswegen, weil dann auf der Tastatur 001

31:25.830 --> 31:27.190
überproportional verschlissen sind.

31:28.110 --> 31:30.030
Sondern wir schreiben natürlich etwas Schöneres hin.

31:31.210 --> 31:34.810
Und das ist eine Programmiersprache wie Java.

31:34.950 --> 31:39.270
Die muss aber übersetzt oder im Englischen compiled, kompiliert sagt

31:39.270 --> 31:41.250
man da manchmal in Neudeutsch, werden.

31:42.710 --> 31:44.790
Und das Programm, was das macht, heißt Java C.

31:44.930 --> 31:46.430
Java C steht für Java Compiler.

31:46.930 --> 31:48.830
Das ist das Programm, was schon da ist.

31:48.870 --> 31:50.350
Das müssen Sie zum Glück jetzt nicht selber schreiben.

31:51.550 --> 31:53.610
Das nimmt ein Programm, was Sie in Java geschrieben haben und

31:53.610 --> 31:55.790
übersetzt das in einen Code, den der Computer ausführen kann.

31:55.890 --> 31:57.230
Wie das geht, kommt nachher im Detail.

31:59.030 --> 32:04.150
So und dieses Programm, was wir hier Simple Program hatten, also mit

32:04.150 --> 32:06.730
dem Class Simple Program, das muss dann auch tatsächlich in eine Datei

32:06.730 --> 32:09.630
rein, die heißt simpleprogram.java.

32:10.150 --> 32:12.890
Und dieser Dateiname muss auch dem Klassennamen entsprechen.

32:13.610 --> 32:17.310
Und wenn Sie das so machen, also dieses Programm, eintippen in eine

32:17.310 --> 32:24.190
Datei, simpleprogram.java und dann den Java C Compiler aufrufen mit

32:24.190 --> 32:29.070
dem Programm, dann erzeugt dieser Java Compiler hier raus ein

32:29.070 --> 32:31.070
simpleprogram.class Datei.

32:31.170 --> 32:34.750
Da steht noch nicht ganz der Binärcode drin, in erster Näherung aber

32:34.750 --> 32:36.090
ja, erkläre ich nachher im Detail.

32:36.770 --> 32:38.790
Und dann erst können Sie das Programm ausführen.

32:38.870 --> 32:40.710
Und das sieht jetzt auf der Kommandozeile so aus.

32:42.710 --> 32:45.250
Sie haben also, wie gesagt, das eingetippt in eine Datei, die heißt

32:45.250 --> 32:48.530
simpleprogram.java und dann rufen Sie eben auf javac.simpleprogram

32:48.530 --> 32:49.170
.java.

32:49.330 --> 32:55.150
Wenn Sie das gemacht haben, können Sie dann das Programm ausführen.

32:56.170 --> 32:57.150
Und was heißt ausführen?

32:57.330 --> 33:01.090
Ausführen heißt, dass das Programm geladen wird in den Speicher Ihres

33:01.090 --> 33:04.910
Computers und dann dort begonnen wird mit der Ausführung und das heißt

33:04.910 --> 33:08.910
konkret, dass man sich das sucht, was unter Main liegt.

33:09.070 --> 33:13.270
Main ist, wenn man so will, ein reserviertes Wort in der Javasprache,

33:13.390 --> 33:16.550
was dem Nachher der Laufzeitumgebung sagt, bitte hier anfangen.

33:16.630 --> 33:19.030
Das ist die Stelle im Programm, an der du anfangen sollst.

33:19.930 --> 33:22.750
Den Sinn werden Sie dann verstehen, wenn Sie mal selber Java-Programme

33:22.750 --> 33:25.430
geschrieben haben, dann merken Sie nämlich, ganz oben steht alles

33:25.430 --> 33:26.630
Mögliche, aber nicht Main.

33:27.070 --> 33:30.510
Man muss dem schon sagen, wo er anfangen soll und das ist eben da, wo

33:30.510 --> 33:30.990
Main steht.

33:31.970 --> 33:35.010
So und tatsächlich, was passiert dann bei Main in unserem Programm?

33:35.430 --> 33:39.290
Na ja, da sind ja genau diese Befehle drunter, die wir eben ausgeführt

33:39.290 --> 33:39.810
haben wollten.

33:40.450 --> 33:42.690
So und wenn Sie das machen, dann starten Sie also jetzt, nachdem Sie

33:42.690 --> 33:46.190
das kompiliert haben, einfach tippen Sie hin, Java Simple Programme,

33:46.230 --> 33:51.010
was heißt, führe jetzt bitte mal dieses Programm aus und das Ergebnis,

33:51.130 --> 33:55.670
was Sie ausgedrückt bekommen, sind 903, was genau eben diese 42 mal 43

33:55.670 --> 34:00.510
durch 2 ist und dann mit dem Befehl System.out.println klingt

34:00.510 --> 34:03.870
umständlich, das sagt, gib bitte diesen Inhalt dieser Variablesumme,

34:03.930 --> 34:06.270
der eben hier berechnet wurde, das ist die 903.

34:07.290 --> 34:09.570
So, das heißt, Sie müssen also immer erst ein Programm kompilieren und

34:09.570 --> 34:10.690
dann ausführen.

34:11.010 --> 34:13.770
Wie gesagt, ich weiß, für die, die schon programmieren können, ist ein

34:13.770 --> 34:16.590
bisschen langweilig, deswegen habe ich immer hin und wieder diese

34:16.590 --> 34:22.110
Fronie mit so einem Einstein-Piktogramm-Logo eingeführt und diese sind

34:22.110 --> 34:23.870
so ein bisschen für die fortgeschrittenen Themen.

34:24.330 --> 34:28.390
Mit fortgeschritten meine ich, hoffentlich ist es nochmal interessant

34:28.390 --> 34:30.030
für die Leute, die schon ein bisschen programmieren können.

34:30.570 --> 34:32.650
Für die, die noch nicht programmieren können, ist es nicht schlimm,

34:32.730 --> 34:35.670
wenn Sie jetzt das nicht so richtig verstehen und sagen, boah, das ist

34:35.670 --> 34:36.970
aber irgendwie alles ein bisschen schnell gegangen.

34:38.170 --> 34:40.630
Für mich ist es vollkommen okay, wenn Sie es am Ende des ersten

34:40.630 --> 34:41.970
Semesters alle verstanden haben.

34:42.170 --> 34:44.090
Jetzt geht es darum, dass die, die schon so ein bisschen

34:44.090 --> 34:46.230
fortgeschrittener sind, auch was haben.

34:46.530 --> 34:49.550
Jetzt werden Sie sich vielleicht einen Augenblick fragen, warum denn

34:49.550 --> 34:49.910
Einstein?

34:49.990 --> 34:51.270
Das war doch gar kein Informatiker.

34:51.630 --> 34:53.990
Stimmt, der war Physiker, aber raten Sie mal, was die meisten Physiker

34:53.990 --> 34:54.570
nachher machen?

34:54.990 --> 34:55.870
Software entwickeln, genau.

34:56.070 --> 34:58.070
Deswegen SAP, Sammlung Arbeitsloser Physiker.

34:58.950 --> 34:59.790
Daher kommt der Name.

35:04.270 --> 35:07.410
Jetzt ist es so, wir hatten gesagt, die Programmierer müssen mit dem

35:07.410 --> 35:08.470
Rechner sprechen.

35:08.750 --> 35:11.190
Dummerweise spricht der Computer aber von sich heraus so diesen

35:11.190 --> 35:12.010
Binärcode.

35:12.090 --> 35:13.910
Das macht wirklich keinen Spaß einzutippen.

35:14.270 --> 35:18.850
In den Urzeiten, bevor man gerade für neue Computer überhaupt sowas

35:18.850 --> 35:21.790
wie Compiler hatte, musste man tatsächlich immer dann am Anfang auch

35:21.790 --> 35:23.270
mal Sachen eintippen.

35:23.310 --> 35:24.850
Das hat man allerdings nicht binär gemacht, sondern im

35:24.850 --> 35:28.510
Hexadezimalsystem, weil man da dann schon mal 15, beziehungsweise 16

35:28.510 --> 35:29.230
Symbole hatte.

35:29.590 --> 35:30.770
Das war dann schon mal ein bisschen leichter.

35:31.730 --> 35:33.770
Nichtsdestotrotz, das ist natürlich für Menschen alles sehr schwer

35:33.770 --> 35:37.970
verständlich und deswegen war die Idee, sogenannte Exemplarsprachen zu

35:37.970 --> 35:38.210
machen.

35:38.690 --> 35:41.910
Die Exemplarsprachen ist aber nichts anderes als eine sehr, wenn man

35:41.910 --> 35:45.550
so will, 1 zu 1 Abbildung vom Binärcode, nur dass man ein paar Wörter

35:45.550 --> 35:48.390
hat, die so ein bisschen leichter es machen, für einen zu erinnern,

35:48.430 --> 35:51.590
was ist denn gemeint im Vergleich zu einer Abfolge von 001.

35:51.930 --> 35:56.990
Und zum Beispiel sagt man hier Move Register 1 zu Register 5 oder von

35:56.990 --> 35:59.710
mir ist es anders, je nachdem, wie man es liest, Register 5 zu 1 und

35:59.710 --> 36:01.150
addiere zwei Register zusammen.

36:01.370 --> 36:05.330
Das sind Exemplarbefehle, jetzt so ein bisschen beliebig

36:05.330 --> 36:05.870
hingeschrieben.

36:06.390 --> 36:08.150
Das hängt natürlich vom Prozessor ab, den man hat.

36:09.270 --> 36:12.910
Und das sind Befehle, die der Prozessor zwar noch nicht direkt

36:12.910 --> 36:15.670
versteht, weil der Prozessor selber mit Move und Add nichts anfangen

36:15.670 --> 36:18.950
kann, aber die man quasi durch, wenn man so will, nachschlagen auf

36:18.950 --> 36:21.450
einer Tabelle umwandeln könnte in Binärcodes.

36:21.550 --> 36:25.430
Das ist quasi nur eine Gedächtnisstütze für Binärcodes.

36:25.550 --> 36:28.630
Und das ist diese Exemplarsprache, die der Prozessor mehr oder weniger

36:29.730 --> 36:30.950
schnell verstehen kann.

36:33.590 --> 36:36.350
Jetzt kann man fragen, ja schön, dann programmier ich halt so.

36:36.530 --> 36:39.370
Und tatsächlich gab es früher auch Leute, die so programmiert haben.

36:39.950 --> 36:41.410
Das hat aber einen großen Nachteil.

36:45.070 --> 36:49.190
Erstens ist es ja auch dann nur der Algorithmus implementiert für

36:49.190 --> 36:51.070
einen bestimmten Prozessor.

36:52.010 --> 36:55.530
Wenn Sie einen anderen Prozessor nehmen, andere Prozessorfamilie,

36:55.610 --> 36:57.810
anderen Befehlssatz, Pech gehabt, müssen Sie nochmal neu ran.

36:58.630 --> 37:00.490
Und da hat man irgendwann gesagt, naja, der Aufwand von Programmieren

37:00.490 --> 37:03.650
ist so hoch, jetzt möchte ich doch mal Programmiersprachen haben, die

37:03.650 --> 37:06.990
etwas unabhängiger sind von dem konkreten Prozessor, die etwas

37:06.990 --> 37:09.990
unabhängiger sind vom Betriebssystem.

37:10.550 --> 37:13.230
Und dann kam man eben auf diese Idee der Programmiersprachen.

37:13.510 --> 37:16.190
Und dafür braucht man dann aber den Übersetzer, der eine

37:16.190 --> 37:19.390
Programmiersprache, die eben nicht mehr so ganz 1 zu 1 einem Binärcode

37:19.390 --> 37:22.650
entspricht und durch einfaches Tabellennachgucken umgewandelt werden

37:22.650 --> 37:22.990
könnte.

37:23.810 --> 37:25.650
Und das sind die sogenannten Hochsprachen, die höheren

37:25.650 --> 37:26.370
Programmiersprachen.

37:27.450 --> 37:32.850
Und was der Übersetzer oder der Compiler eben macht, das ist, dass man

37:32.850 --> 37:35.670
sagt, ich nehme ein Programm in einer höheren Programmiersprache und

37:35.670 --> 37:37.970
übersetze das entweder in die Maschinensprache oder direkt im

37:37.970 --> 37:42.390
Binärcode oder aber, und das ist der Fall bei Java, in eine

37:42.390 --> 37:43.290
Zwischensprache.

37:45.050 --> 37:48.490
Und um das zu verstehen, warum das so ist mit dieser Zwischensprache,

37:48.890 --> 37:51.290
muss man einen Unterschied verstehen, nämlich den zwischen einem

37:51.290 --> 37:52.570
Compiler und einem Interpreter.

37:53.610 --> 37:56.430
Der Compiler, wie gesagt, übersetzt ein Programm, übersetzt das in

37:56.430 --> 37:57.190
einen Binärcode.

37:58.330 --> 38:02.730
Der Interpreter, sein Name sagt ja auch Interpreter, also der hilft ja

38:02.730 --> 38:03.810
irgendwie auch beim Verständnis.

38:05.110 --> 38:08.770
Der nimmt auch ein Programm, aber nicht das gesamte Programm auf

38:08.770 --> 38:11.530
einmal wie der Compiler, sondern quasi geht der, wenn man so will,

38:12.330 --> 38:16.270
zeilenweise durch das Programm, übersetzt es, führt es aus, nimmt den

38:16.270 --> 38:18.170
nächsten Befehl, übersetzt ihn, führt ihn aus.

38:20.130 --> 38:22.570
Das Ergebnis ist erstmal ähnlich.

38:23.370 --> 38:25.190
Der Compiler erzeugt in einem Binärprogramm.

38:25.310 --> 38:27.690
Sie rufen das Binärprogramm aus, es wird ausgeführt, wie wir das eben

38:27.690 --> 38:28.090
gesehen haben.

38:28.170 --> 38:32.350
Java C, simpleprogramm.java und dann Java simpleprogramm.

38:33.010 --> 38:36.330
Der Interpreter macht das, wenn man so will, in einem.

38:36.690 --> 38:39.590
Er nimmt ein Teil vom Programm, übersetzt ihn, führt ihn aus,

38:40.130 --> 38:41.530
übersetzt den nächsten Teil, führt ihn aus.

38:42.050 --> 38:45.050
Der Haken an der Sache ist beim Interpreter vor allem der, dass es

38:45.050 --> 38:47.770
relativ langsam ist, weil stellen Sie sich vor, wir hatten eben diese

38:47.770 --> 38:49.310
Schleife gehabt, dieses While.

38:50.150 --> 38:54.350
Und nehmen Sie an, Sie wollen jetzt Zahlen addieren bis 10.000.

38:54.810 --> 38:57.130
Das heißt, die Schleife wird 10.000 Mal so schlaufen und tatsächlich

38:57.130 --> 39:02.470
10.000 Mal schnappt sich der Interpreter die Zeile 1, also alles, was

39:02.470 --> 39:04.690
in der Schleife ist, und dann die nächste Zeile in der Schleife und so

39:04.690 --> 39:04.790
weiter.

39:04.890 --> 39:06.130
Und jedes Mal wird es neu übersetzt.

39:06.890 --> 39:08.630
Da würde man sagen, das brauchst du ja nicht, du hast es ja die ganze

39:08.630 --> 39:09.550
Zeit schon vorher übersetzt.

39:10.270 --> 39:10.890
Und das stimmt auch.

39:10.910 --> 39:11.950
Das ist der Vorteil vom Compiler.

39:12.030 --> 39:15.010
Der Compiler nimmt das Programm einmal, ohne es auszuführen, übersetzt

39:15.010 --> 39:17.970
es und dann können Sie eben das Programm im Binärcode ausführen, was

39:17.970 --> 39:18.810
halt deutlich schneller ist.

39:20.110 --> 39:24.290
Aber der Interpreter hat natürlich einen Vorteil, er kapselt die

39:24.290 --> 39:27.090
Details der tatsächlich unterliegenden Hardware und des

39:27.090 --> 39:27.970
Betriebssystems weg.

39:28.890 --> 39:31.450
Und genau das ist der Trick, dass man in Java beides versucht zu

39:31.450 --> 39:38.050
kombinieren, indem man sagt, ich übersetze mit dem Java Compiler in

39:38.050 --> 39:40.970
ein Zielprogramm, aber das Zielprogramm ist eben keine

39:40.970 --> 39:45.090
Maschinensprache, das wäre nämlich Prozessorabhängig, sondern ich

39:45.090 --> 39:47.250
übersetze in einen sogenannten Java Bytecode.

39:47.310 --> 39:50.470
Das ist eine standardisierte Sprache auch, mit der man auch, wenn man

39:50.470 --> 39:51.790
wollte, direkt programmieren könnte.

39:51.850 --> 39:54.730
Das ist aber ein bisschen unangenehm auch, man muss sich einige Knoten

39:54.730 --> 39:55.370
ins Hirn denken.

39:55.650 --> 39:57.730
Das ist schon angenehmer, im richtigen Java zu programmieren.

39:59.610 --> 40:02.410
Aber der Vorteil ist, der Übersetzer erzeugt mir ja auch diesen

40:02.410 --> 40:02.750
Bytecode.

40:02.810 --> 40:04.310
Ich muss auch nicht in diesem Bytecode programmieren.

40:04.390 --> 40:07.950
Und dann wird dieser Bytecode von Interpretern für die jeweilige

40:07.950 --> 40:11.090
Plattform, die Sie haben, also sei es ein Linux-Rechner, ein Windows

40:11.090 --> 40:14.010
-Rechner, die verschiedenen Hardware-Plattformen, die Sie haben,

40:14.010 --> 40:17.010
nochmal da drunter, wird dann dafür speziell ein Interpreter, gibt es,

40:17.110 --> 40:19.430
und der führt Ihnen dann quasi das Programm aus.

40:19.990 --> 40:23.490
Damit verhofft man so ein bisschen natürlich beides zu verknüpfen, die

40:23.490 --> 40:28.110
Vorteile aus beiden Welten, den schnelleren Weg über den Compiler und

40:28.110 --> 40:30.590
die große Plattform-Unabhängigkeit, dass ich also nicht für jede

40:30.590 --> 40:33.770
Plattform einen neuen Compiler brauche, dadurch, dass ich Interpreter

40:33.770 --> 40:35.330
unten drunter habe, die relativ einfach sind.

40:36.210 --> 40:39.050
So sieht das Ganze grafisch letzten Endes aus.

40:39.690 --> 40:42.690
Sie haben Ihr Java-Programm, was Sie getippt haben, dann haben Sie den

40:42.690 --> 40:46.510
Compiler, dieser Java-C-Aufruf, der erzeugt diesen Java-Bytecode, das

40:46.510 --> 40:50.710
ist dann die Datei, die da rausgespuckt wird, simpleprogramm.class zum

40:50.710 --> 40:56.490
Beispiel, und dann rufen Sie Java auf mit dem Namen Ihres Programms

40:56.490 --> 40:59.850
und dann, je nachdem, auf welcher Plattform Sie unterwegs sind,

41:00.010 --> 41:03.630
Windows, Linux, macOS, wird dann der entsprechende Java-Interpreter

41:03.630 --> 41:07.050
aufgerufen und dann wird daraus dann im Prinzip das Programm

41:07.050 --> 41:07.710
ausgeführt.

41:10.150 --> 41:14.110
Jetzt gibt es so was, das heißt Just-in-Time-Compilation.

41:14.810 --> 41:15.530
Wer hat das schon mal gehört?

41:16.750 --> 41:17.830
Doch, ein paar, sehr schön.

41:18.970 --> 41:23.150
Für alle anderen, das ist die Überlegung, dass man sagt, naja, jetzt

41:23.150 --> 41:26.150
habe ich aber immer noch bei dem Interpreter das Problem, dass der ja

41:26.150 --> 41:27.770
in der Schleife Dinge wiederholt.

41:28.250 --> 41:30.450
Und das ist halt sehr langsam, wenn die Schleife so oft durchlaufen

41:30.450 --> 41:30.650
wird.

41:30.930 --> 41:32.750
Und deswegen will ich eigentlich auch ein bisschen Compiler

41:32.750 --> 41:34.770
-Technologie in diesen Interpreter reinschmuggeln.

41:35.530 --> 41:39.310
Und das ist genau das, was diese Just-in-Time-Compilation macht.

41:39.430 --> 41:43.770
Die erkennt, während der Ausführung im Interpreter des Programms, ui,

41:43.970 --> 41:45.810
da werden ja Sachen wiederholt übersetzt, das kann ich mir alles

41:45.810 --> 41:47.290
sparen, ich übersetze jetzt doch mal.

41:47.330 --> 41:50.770
Es scheint sich zu lohnen, jetzt mal noch mal zu kompilieren.

41:50.810 --> 41:53.330
Und dann kompiliert tatsächlich auf den Binärcode der Maschine runter,

41:53.410 --> 41:55.230
der Just-in-Time-Compiler im Interpreter.

41:55.630 --> 41:57.910
Klingt alles ein bisschen abgefahren, ist es auch letzten Endes,

41:57.930 --> 41:59.350
deswegen auch das Einstein-Symbol hier.

42:01.730 --> 42:03.070
Es hat ein paar Vorteile.

42:03.070 --> 42:05.570
Erstens haben Sie den Compiler-Vorteil, Sie müssen nicht immer

42:05.570 --> 42:08.090
dasselbe nochmal neu übersetzen, obwohl Sie es schon gerade eben auch

42:08.090 --> 42:08.830
nochmal übersetzt hatten.

42:09.770 --> 42:12.890
Das andere ist, Sie können natürlich auch sich überlegen, hmm,

42:14.350 --> 42:17.110
letztens hatte, ich weiß ja jetzt auch die Werte der Variablen schon,

42:17.190 --> 42:18.150
Sie sind ja schon am Interpretieren.

42:18.270 --> 42:21.630
Das heißt, Sie können ganz andere Compiler-Optimierungen machen, als

42:21.630 --> 42:24.170
wenn Sie das Programm noch nicht ausführen, weil Sie kennen schon die

42:24.170 --> 42:25.070
Variablen -Belegungen.

42:25.210 --> 42:27.690
Das heißt also, Sie haben durch die Just-in-Time-Compilation

42:28.570 --> 42:31.410
Optimierungsmöglichkeiten, die ein normaler Stand-alone-Compiler, der

42:31.410 --> 42:32.930
nicht in einem Interpreter abläuft, nicht hat.

42:33.230 --> 42:34.430
Und das ist ein großer Vorteil sogar.

42:34.990 --> 42:37.250
Und dadurch kann man wirklich auch sehr performanten Code dann

42:37.250 --> 42:37.650
generieren.

42:38.630 --> 42:40.650
Und Sie können natürlich auch Code, der nie aufgerufen wird, das

42:40.650 --> 42:42.230
wissen Sie an der Stelle jetzt schon, brauchen Sie auch nicht

42:42.230 --> 42:43.610
übersetzen, was auch ein Vorteil ist.

42:44.550 --> 42:46.190
So, jetzt wieder Einstein-Ende.

42:46.410 --> 42:48.390
Jetzt kommen wir wieder zurück zu unserem einfachen Programm.

42:51.090 --> 42:52.750
Also, das ist das, was ich jetzt habe.

42:52.910 --> 42:55.330
Jetzt sagen Sie, naja gut, das habe ich jetzt oft genug gesehen, dass

42:55.330 --> 42:58.370
die Summe der Zahlen von 1 bis 42,903 ist.

42:58.710 --> 43:00.790
Wie ist das denn mit einer anderen Zahl?

43:01.250 --> 43:02.230
Wie ändere ich das jetzt?

43:02.990 --> 43:07.530
Gut, Sie gehen wieder in Ihren Texteditor, ändern das N auf 43 hier

43:07.530 --> 43:14.690
und jetzt rufen Sie wieder Ihr Programm auf und Sie bekommen aber

43:14.690 --> 43:16.210
wieder 903 raus.

43:16.970 --> 43:18.410
Hm, Mist, was ist los?

43:18.810 --> 43:20.450
Naja, Sie haben das Programm nicht neu kompiliert.

43:20.630 --> 43:25.630
Sie haben das Programm geändert und Sie haben aber mit der Zeile Java

43:25.630 --> 43:28.790
-Simple -Programm das alte Programm noch ausgeführt.

43:28.850 --> 43:30.710
Das neue Programm ist noch nicht übersetzt worden.

43:31.530 --> 43:34.770
Ja, Java greift nicht auf Ihren Quelltext zu, Java greift auf die

43:34.770 --> 43:36.250
generierte.class-Datei zu.

43:36.950 --> 43:38.710
Das heißt, Sie müssen es nochmal neu kompilieren.

43:38.830 --> 43:42.090
Das heißt, eigentlich geht es so, Sie haben also das hier auf die 43,

43:42.210 --> 43:46.270
Sie rufen nochmal Java-C auf, den Compiler, der generiert Ihnen den

43:46.270 --> 43:50.630
neuen Bytecode und den rufen Sie mit Java-Simple-Programm auf und

43:50.630 --> 43:53.330
tatsächlich, dann bekommen Sie die Antwort 946.

43:53.810 --> 43:57.290
Also Sie müssen immer nach jeder Änderung das Programm kompilieren.

43:57.810 --> 44:01.090
Also für alle, die noch nicht programmieren konnten, war das eine der

44:01.090 --> 44:03.410
wesentlichen Botschaften dieser Vorlesung.

44:05.910 --> 44:09.830
So, jetzt gucken wir uns mal ein bisschen genauer an, woraus das

44:09.830 --> 44:10.270
besteht.

44:11.550 --> 44:13.810
Also das Ganze, was Sie hier sehen, ist ein Beispiel für eine

44:13.810 --> 44:14.670
sogenannte Klasse.

44:15.870 --> 44:23.470
Eine Klasse ist in Java quasi eine Menge von Dingen, die es auch in

44:23.470 --> 44:24.650
der realen Welt geben könnte.

44:24.770 --> 44:26.830
Wir werden später noch darauf genauer eingehen.

44:28.150 --> 44:30.490
Hier jetzt erstmal für uns das Beispiel für ein einfaches Programm.

44:31.550 --> 44:34.810
Dann haben wir einen Klassennamen, SimpleProgramm.

44:35.830 --> 44:40.210
Wir haben die Main-Methode, wie gesagt, das ist der Einstiegspunkt für

44:40.210 --> 44:41.010
die Ausführung.

44:43.750 --> 44:49.670
Dann haben wir einen Methodennamen, das ist der Name Main hier und Sie

44:49.670 --> 44:51.610
haben einen Variablen-Typ.

44:51.890 --> 44:56.110
n ist nicht irgendwas, sondern eine ganzzahlige Variable, deswegen

44:56.110 --> 44:58.310
Integer, Integer für ganzzahlig.

44:59.770 --> 45:02.130
Sie haben den Variablen-Namen n.

45:02.890 --> 45:06.710
Variablen sind im Prinzip, wenn Sie so wollen, Plätze im Speicher

45:06.710 --> 45:09.030
Ihrer Maschine, wo Werte reingeschrieben werden können.

45:10.170 --> 45:14.070
Und Sie haben das Ganze zusammen, int n ist eine Variablen-Deklaration

45:14.070 --> 45:18.950
und tatsächlich wird auch initial schon auch der Wert 42

45:18.950 --> 45:20.510
reingeschrieben in diese Variable.

45:21.890 --> 45:23.910
Und damit also auch der Wert initialisiert.

45:25.050 --> 45:27.670
Also die Variable initialisiert mit dem Wert 42.

45:29.210 --> 45:31.050
So, jetzt könnten Sie sagen, das ist immer ein bisschen nervig.

45:31.210 --> 45:33.690
Wenn ich immer andere Zahlen addieren will, muss ich jedes Mal rein,

45:33.750 --> 45:36.410
das Programm editieren, das Programm neu übersetzen, neu ausführen,

45:36.490 --> 45:37.390
alles ein bisschen mühsam.

45:37.950 --> 45:39.350
Kann man das nicht anders machen?

45:39.410 --> 45:40.850
Und die Antwort ist ja, das geht.

45:40.850 --> 45:46.790
Und zwar, hier gibt es ja dieses ominöse String args.

45:46.910 --> 45:50.290
Und was das ist, auch nachher mal in Ruhe, jetzt erstmal nur ganz

45:50.290 --> 45:50.550
schnell.

45:51.070 --> 45:53.610
String steht für Zeichenketten.

45:53.890 --> 45:56.470
Das ist auch ein variablen Typ, so wie wir eben Ganzzahl hatten,

45:56.570 --> 46:00.290
Integer, gibt es auch Zeichenketten, also beliebige Dinge quasi, die

46:00.290 --> 46:02.090
man als Kette von Zeichen darstellen kann.

46:02.730 --> 46:04.630
Eckige Klammer heißt, da gibt es mehrere von.

46:05.470 --> 46:07.910
Und das Ganze nenne ich args, wie Argumente.

46:08.730 --> 46:12.470
Und die Argumente ist das, was man einem Programm als Parameter

46:12.470 --> 46:12.930
mitgeben muss.

46:13.950 --> 46:16.370
Das Wort Argument hat im ungarischsprachlichen eine etwas andere

46:16.370 --> 46:18.670
Bedeutung, bei uns in der Informatik heißt es so was oft wie

46:18.670 --> 46:19.570
Funktionsparameter.

46:20.710 --> 46:24.970
So, und jetzt kann man sagen, ich möchte im Prinzip das erste Argument

46:24.970 --> 46:25.370
nehmen.

46:27.070 --> 46:29.330
In der Computerei fängt häufig das erste mit 0 an.

46:29.610 --> 46:30.970
Warum sollte man nämlich diesen Wert verschenken?

46:31.110 --> 46:35.410
Also, args 0 ist das erste Kommando-Zahlenparameter, der ist momentan

46:35.410 --> 46:39.430
noch eine Zeichenkette, String, den möchte ich übersetzen in eine

46:39.430 --> 46:44.390
ganze Zahl und deswegen rufe ich dieses PassInt auf, also für Sie nur

46:44.390 --> 46:46.890
die Übersetzung von irgendeiner Zeichenkette in eine Zahl.

46:48.190 --> 46:51.370
Was genau passiert, kommt alles in späteren Vorlesungen, das ist so

46:51.370 --> 46:52.170
ein bisschen Überblick hier.

46:52.510 --> 46:55.450
Und dann berechne ich das, was mit dem n ich gewohnt habe und gebe es

46:55.450 --> 46:55.710
aus.

46:56.570 --> 46:59.870
So, und jetzt können Sie im Prinzip das so machen, Sie starten Ihr

46:59.870 --> 47:03.370
Programm Java Simple Program und dann als Kommando-Zahlenparameter 42

47:03.370 --> 47:06.190
hier auf der Kommandozeile und dann können Sie das natürlich auch

47:06.190 --> 47:10.410
schreiben Java Simple Program 45 oder so, ohne dass Sie das Programm

47:10.410 --> 47:14.050
jedes Mal neu kompilieren müssen, weil es wird jedes Mal der Wert von

47:14.050 --> 47:18.670
der Kommandozeile, also wo Sie das Programm starten, eingelesen, hier

47:18.670 --> 47:20.970
in dieses n reingeschrieben, Sie haben es eben nicht mehr hart

47:20.970 --> 47:24.530
vertratet als 42 in Ihrem Programmtext drin, sondern wie gesagt, es

47:24.530 --> 47:29.190
wird eingelesen, hier rüber, also diese 42, lange Rede, kurzer Sinn,

47:29.290 --> 47:31.930
wandert über diese Zeile nachher hier rein und Sie führen das Programm

47:31.930 --> 47:34.230
aus und Sie bekommen wieder Ihre, in dem Fall 903.

47:35.130 --> 47:37.010
Vorteil, wie gesagt, jetzt ist, Sie müssen nicht jedes Mal das

47:37.010 --> 47:39.290
Programm neu editieren und neu übersetzen, sondern Sie können das

47:39.290 --> 47:41.390
einfach immer neu starten mit anderen Werten.

47:42.730 --> 47:45.770
So, und das ist nochmal das, was ich eben auch gesagt hatte.

47:47.950 --> 47:52.730
So, das wäre jetzt schon mal der erste Einstieg gewesen, jetzt noch

47:52.730 --> 47:54.930
nicht weglaufen, ich habe noch einen weiteren Foliensatz.

47:56.270 --> 47:58.790
Für diejenigen, die sagen, das war aber alles ein bisschen schnell,

47:59.550 --> 48:01.610
ich kann ja noch gar nicht so richtig programmieren, stimmt, so ist

48:01.610 --> 48:02.590
das halt in der Vorlesung.

48:04.290 --> 48:08.390
Immer in Ruhe nachlesen ist mal so ein Tipp und hier ist es in der Tat

48:08.390 --> 48:12.710
aus dem Buch, was ich ja für die Anfänger empfohlen hatte von Dietmar

48:12.710 --> 48:16.330
Raatz und anderen, der Abschnitt 2.2, was heißt Programmieren und

48:16.330 --> 48:19.170
Abschnitt 3.1, mein erstes Programm, da kann man solche Dinge nochmal

48:19.170 --> 48:20.510
in Ruhe nachlesen.

48:21.330 --> 48:23.110
Was haben wir gemacht bis jetzt?

48:23.490 --> 48:25.390
Wir haben erst mal überlegt, was sind Programme?

48:25.610 --> 48:29.270
Das sind präzise festgelegte Prozesse, die eben von einer dummen

48:29.270 --> 48:32.770
Maschine ohne Interpretationsspielraum abarbeitbar sind.

48:33.410 --> 48:37.330
Es sind allgemeine Pläne, die dem Computer sagen, was er machen soll,

48:37.970 --> 48:39.970
die aber möglichst allgemein gehalten sind.

48:40.190 --> 48:43.770
Also in unserem Beispiel beliebige Dinge, Gegenstände, die man

48:43.770 --> 48:47.370
sortieren kann, für beliebig viele davon, eben möglichst abstrakt.

48:47.370 --> 48:50.350
Und wir haben ein einfaches Java-Programm gesehen.

48:51.090 --> 48:54.510
Wir haben gesehen, dass die Main-Methode angibt, wo wird angefangen

48:54.510 --> 48:55.350
mit der Ausführung.

48:56.350 --> 49:00.110
Wir haben über das Kompilieren gesprochen, also dieses Übersetzen in

49:00.110 --> 49:02.630
einen Binärcode und dann den Aufruf zum Ausführen.

49:03.090 --> 49:06.770
Und wir haben zumal gesehen, dass man mit Variablen rechnen kann und

49:06.770 --> 49:09.650
eine Ausgabe mit System.out.println ausgeben kann.

49:09.810 --> 49:12.230
Das war schon mal das erste einfache Programm für diejenigen, die noch

49:12.230 --> 49:13.090
nie sowas gesehen haben.

49:13.730 --> 49:16.830
Das war schon mal ihr erstes Java-Programm, was also zumindest mal

49:16.830 --> 49:18.430
nicht ganz banale Sache gemacht hat.

49:20.610 --> 49:26.130
So, jetzt würde ich übergehen zum nächsten Thema, was ich in dieser

49:26.130 --> 49:33.470
Vorlesung behandeln wollte, und zwar das Thema Klassen und Objekte.

49:34.510 --> 49:41.150
Hier in diesem Teil sollen Sie jetzt lernen, was verbirgt sich bei der

49:41.150 --> 49:44.270
objektorientierten Programmierung mit dem Wort Objekt und was mit

49:44.270 --> 49:44.650
Klasse.

49:45.210 --> 49:48.850
Beides Wörter, die in der umgangssprachlichen Welt natürlich schon

49:48.850 --> 49:52.690
vorhanden sind, die aber eine sehr spezielle Bedeutung eben jetzt hier

49:52.690 --> 49:53.290
bei uns haben.

49:53.910 --> 49:56.570
Und Sie werden lernen, dass Klassen beschrieben werden durch

49:56.570 --> 49:59.290
sogenannte Attribute und Methoden, auch das wieder Wörter, die in der

49:59.290 --> 50:01.950
realen Welt auch auftauchen, hier aber eine spezielle Bedeutung haben.

50:02.350 --> 50:04.810
Und Sie wissen auch, wie man sowas in Java ausdrückt.

50:05.630 --> 50:07.650
Und dazu gucken wir uns erst mal ein Beispiel an.

50:07.790 --> 50:13.050
Und zwar nehmen wir an, Sie wollen einen Billiardsimulator

50:13.770 --> 50:14.250
programmieren.

50:15.210 --> 50:21.510
Und der erste Teil ist, dass Sie sich überlegen, naja, wie bewegen

50:21.510 --> 50:22.210
sich hier die Kugeln.

50:23.310 --> 50:26.050
Und das haben Sie eben schon gelernt in unserem Kleinstbeispiel mit

50:26.050 --> 50:27.350
dem Aufsummieren von Zahlen.

50:28.510 --> 50:30.690
Erstmal in Ruhe über das Problem nachdenken.

50:30.890 --> 50:34.050
Erstmal versuchen, das Problem zu verstehen und zu modellieren, dann

50:34.050 --> 50:34.970
erst loscoden.

50:35.690 --> 50:38.570
Und dieses sogenannte Modellieren des Problems, also das Beschreiben

50:38.570 --> 50:42.170
erstmal des Problems, hängt erstmal zusammen, welche Daten habe ich

50:42.170 --> 50:46.410
denn, mit was für Daten habe ich zu tun und welche Operationen werden

50:46.410 --> 50:48.070
eigentlich auf diesen Daten ausgeführt.

50:48.650 --> 50:50.710
Und um so die Katze ein bisschen aus dem Sack zu lassen, das

50:50.710 --> 50:54.230
Zusammenbündeln von Daten und Operationen, das heißt dann nachher

50:54.230 --> 50:54.930
Klasse.

50:57.010 --> 50:59.310
So, machen wir das jetzt mal ein Beispiel hier durch.

50:59.490 --> 51:03.830
Also wir wollen simulieren, wie sich im Billiardspiel diese Kugeln auf

51:03.830 --> 51:06.010
den Billiardtisch, das ist quasi von oben auf den Billiardtisch

51:06.010 --> 51:08.170
draufgeguckt, bewegen.

51:08.910 --> 51:10.570
Und jetzt müssen wir überlegen, was müssen wir eigentlich modellieren.

51:10.990 --> 51:13.870
Und die erste triviale Antwort ist natürlich, wir müssen den Tisch

51:13.870 --> 51:14.390
modellieren.

51:15.530 --> 51:16.930
Wodurch wird der Tisch beschrieben?

51:17.310 --> 51:19.950
Im Wesentlichen auch erstmal durch seine Ausmaße, also die Größe.

51:20.390 --> 51:23.830
Wir können uns das, muss man nicht, aber kann man natürlich so als XY

51:23.830 --> 51:27.430
-Koordinatensystem hier vorstellen, dann hat er halt hier drin quasi,

51:27.590 --> 51:29.890
wenn die eine Kante vom Tisch hier immer im Ursprung liegt, das Ganze

51:29.890 --> 51:32.610
eine gewisse Ausdehnung in XY-Koordinaten.

51:34.170 --> 51:36.910
Hört sich einfach an, ist auch ein einfaches Beispiel, aber wie

51:36.910 --> 51:39.610
gesagt, sie würden genauso vorgehen auch bei komplexeren Problemen.

51:40.270 --> 51:43.010
So, dann habe ich natürlich nicht nur in meiner realen Welt den Tisch,

51:43.230 --> 51:44.250
sondern ich habe auch die Kugeln.

51:45.030 --> 51:47.030
Also auch die müssen wir modellieren.

51:47.790 --> 51:48.870
Und was hat eine Kugel?

51:49.150 --> 51:52.110
Sie hat eine Position auf dem Tisch, das heißt also in unserem

51:52.110 --> 51:54.970
Koordinatensystem, man kann das als Vektor quasi, als

51:54.970 --> 51:56.310
zweidimensionalen Vektor darstellen.

51:57.190 --> 52:00.790
Sie hat eine Bewegungsrichtung oder eine Geschwindigkeit.

52:01.450 --> 52:03.730
Sie hat für die Leute, die etwas fortgeschrittener Billiards spielen,

52:03.810 --> 52:06.730
vielleicht noch einen gewissen Effet, also das heißt also ein Trall

52:06.730 --> 52:08.950
drin, die dann nochmal die Bahn etwas beeinflusst.

52:10.510 --> 52:12.190
Und was kann auch passieren?

52:12.310 --> 52:15.270
Naja, als Operationen darauf, Kugeln können aneinanderstoßen und

52:15.270 --> 52:16.550
ändern dann ihre Bewegungsrichtung.

52:16.550 --> 52:18.790
Das ist ja auch der Charme beim Billiardspielen.

52:20.510 --> 52:24.370
So, und das muss man jetzt irgendwie modellieren, beschreiben.

52:25.610 --> 52:29.610
Und das ist jetzt auch so im Prinzip die Hauptidee in der

52:29.610 --> 52:33.110
objektorientierten Programmierung, dass man sagt, also alle Objekte,

52:33.250 --> 52:36.670
die es in der realen Welt gibt, bekommen auch eine Entsprechung im

52:36.670 --> 52:38.010
Computerprogramm.

52:39.090 --> 52:43.210
Und diese Objekte kooperieren dadurch, dass sie Nachrichten

52:43.210 --> 52:43.770
austauschen.

52:43.850 --> 52:47.890
Nachrichten austauschen heißt im Wesentlichen, etwas aufrufen bei

52:47.890 --> 52:49.730
einem anderen Objekt, was dann was damit macht.

52:51.810 --> 52:56.410
Und insofern ist also die Modellierungsfrage, wer macht denn hier

52:56.410 --> 52:57.150
eigentlich was?

52:57.270 --> 52:58.050
Was machen die Kugeln?

52:58.130 --> 52:58.850
Was macht der Tisch?

52:59.610 --> 53:03.710
Und dann sagt man so im Programmiererjargon, zum Beispiel A sendet

53:03.710 --> 53:08.750
eine Nachricht an Objekt B oder A ruft eine Methode von B auf.

53:08.830 --> 53:10.690
Das ist aber nichts anderes, als wenn man so will, Nachrichten

53:10.690 --> 53:12.330
austauschen durch diesen Objekten.

53:13.890 --> 53:17.150
So und hier nochmal grafisch dargestellt, ich habe meine reale Welt,

53:17.290 --> 53:20.150
da habe ich den Tisch und die Kugeln und das entspricht jetzt alles

53:20.150 --> 53:20.750
Objekten.

53:20.870 --> 53:24.110
Zum Beispiel kann ich sagen, ich habe einen Tisch, der heißt T, der

53:24.110 --> 53:26.610
hat eine bestimmte Länge, der hat eine bestimmte Breite, der hat auch

53:26.610 --> 53:30.510
vielleicht einen Namen und es gibt auch sogenannte Operationen, also

53:30.510 --> 53:32.230
Dinge, die man ausführen kann auf ihm.

53:33.290 --> 53:36.470
Methoden heißt es dann, dass man zum Beispiel die Länge ausliest, die

53:36.470 --> 53:39.690
Breite ausliest, den Namen und dass man eine Kugel hinzufügt, quasi

53:39.690 --> 53:41.590
eine Kugel auf den Tisch draufliegt.

53:44.890 --> 53:49.110
Das Obere, diese Angaben, das heißt Attribute, das sind, wenn man so

53:49.110 --> 53:52.710
will, Daten und das sind Dinge, die man machen kann damit, das sind

53:52.710 --> 53:57.270
sogenannte Methoden und einige Methoden sind relativ klar aus der

53:57.270 --> 53:57.790
realen Welt.

53:57.950 --> 54:01.270
Sie können auf einen Tisch eine Kugel drauflegen, das ist das Ad Ball,

54:02.050 --> 54:04.890
dass man Name, Breite und so weiter ausliest, das würden Sie

54:04.890 --> 54:06.990
vielleicht in der realen Welt erstmal nicht erkennen, aber natürlich

54:06.990 --> 54:10.650
könnten Sie auch in der realen Welt nachschauen, was ist die Länge von

54:10.650 --> 54:11.670
dem Tisch oder wie heißt er.

54:13.810 --> 54:18.250
So, jetzt habe ich noch meine Kugeln, davon habe ich jetzt auch drei

54:18.250 --> 54:21.630
Stück hier und genau so habe ich drei Objekte jetzt hier und ich

54:21.630 --> 54:25.290
beschreibe, das ist jetzt die Abstraktion, die Kugel anhand ihres

54:25.290 --> 54:28.670
Durchmessers, ihres Gewichts, ihrer Farbe und natürlich auch anhand

54:28.670 --> 54:32.030
ihrer Position auf dem Tisch.

54:32.130 --> 54:34.470
Und das kann ich sagen, also jetzt möchte ich den nächsten Schritt,

54:34.850 --> 54:37.670
den nächsten Stoß quasi simulieren, was passiert mit dieser Kugel im

54:37.670 --> 54:40.910
nächsten Stoß und das ist die Operation Simulation Step.

54:44.440 --> 54:49.880
So und wie ich sagte, Objekte, das ist die Hauptidee, sind letzten

54:49.880 --> 54:53.300
Endes ein Zusammenschluss von den Daten, die etwas beschreiben und den

54:53.300 --> 54:55.260
Operationen, die man darauf ausführen kann.

54:55.920 --> 54:59.260
Wie wir aber eben gesehen haben, habe ich ja, wenn ich drei Kugeln

54:59.260 --> 55:01.780
habe, logischerweise auch drei Objekte.

55:02.580 --> 55:05.120
Jetzt sind aber diese drei Objekte ja nicht komplett unterschiedlich,

55:05.180 --> 55:06.200
die haben ja schon was gemeinsam.

55:06.760 --> 55:09.500
Sie haben vielleicht natürlich eine andere Farbe hoffentlich.

55:10.380 --> 55:13.280
Sie haben auch andere Positionen logischerweise auf dem Tisch, weil

55:13.280 --> 55:15.060
nicht zwei Kugeln übereinander liegen können irgendwie.

55:16.360 --> 55:20.580
Aber dass sie beschrieben werden über Farbe, dass sie beschrieben

55:20.580 --> 55:24.400
werden mit einem Gewicht, mit einer Position, das haben natürlich alle

55:24.400 --> 55:24.880
gemeinsam.

55:25.500 --> 55:27.420
Jetzt werden Sie sagen, aha, das sind ja auch zwei verschiedene

55:27.420 --> 55:27.760
Sachen.

55:28.680 --> 55:32.160
Sie unterscheiden sich in den konkreten Werten, wie zum Beispiel eben

55:32.160 --> 55:35.280
dem Farbwert hier, rot, andere blau.

55:36.200 --> 55:39.360
Aber dass sie eine Farbe haben, das ist ja, wenn man so will, auf

55:39.360 --> 55:40.580
einer anderen Ebene.

55:40.700 --> 55:45.200
Das ist ja was Allgemeineres, das Farbe haben.

55:46.360 --> 55:48.020
Und genau das ist auch die Idee dahinter.

55:48.120 --> 55:51.500
Man sagt, letzten Endes gibt es eine Art Bauplan, eine Blaupause für

55:51.500 --> 55:55.940
Kugeln, die sagt, mit welchen Attributen wird eigentlich so eine Kugel

55:55.940 --> 55:58.200
beschrieben und welche Operationen gibt es hier eigentlich.

55:58.340 --> 56:00.360
Und das ist die sogenannte Klasse.

56:01.820 --> 56:05.560
Ich weiß wieder, Objekt und Klasse haben im Alltagsdeutschen natürlich

56:05.560 --> 56:06.540
andere Bedeutungen.

56:07.100 --> 56:11.400
Aber für uns jetzt hier, wenn man so will, ist es, die Klasse ist der

56:11.400 --> 56:14.720
Typ und die Kugel, das sind die Instanzen.

56:15.000 --> 56:16.080
Das sind die Ausprägungen.

56:16.180 --> 56:18.700
Das deutsche Wort für Instanz wäre Ausprägung an der Stelle.

56:19.400 --> 56:24.660
Und ich habe also mehrere Ausprägungen der Klasse Ball und das wäre

56:24.660 --> 56:27.720
dann zum Beispiel der Red Ball, der Blue Ball und der White Ball.

56:28.780 --> 56:31.980
Und hier wird festgelegt, welche Attribute hat das, zum Beispiel

56:31.980 --> 56:35.080
Durchmesser, Gewicht, X- und Y-Positionen, welche Methoden.

56:37.080 --> 56:41.560
Und hier haben Sie dann die konkrete Ausprägung, den Durchmesser, das

56:41.560 --> 56:43.360
Gewicht ganz konkret mit Zahlen angegeben.

56:43.560 --> 56:46.800
Das ist genauso, das könnte im Prinzip genauso jetzt auch hier, wenn

56:46.800 --> 56:50.860
Sie ein System bauen zur Hörsaalverwaltung, anfangen zu sagen, ich

56:50.860 --> 56:55.040
habe zum Beispiel eine Klasse Student und Student wird zum Beispiel

56:55.040 --> 56:58.120
beschrieben durch Matrikelnummer und jeder von Ihnen wäre eine

56:58.120 --> 57:01.800
Ausprägung dieser Klasse mit natürlich der eindeutigen Matrikelnummer.

57:02.700 --> 57:06.260
Genauso können Sie sagen, es gibt jetzt die Klasse Professor, davon

57:06.260 --> 57:09.460
gibt es natürlich auch mehrere, wie Sie schon erlebt haben und die

57:09.460 --> 57:11.200
haben natürlich dann auch wieder verschiedene Ausprägungen,

57:11.520 --> 57:15.360
verschiedene Namen, verschiedene Vorlesungen, die Sie erhalten und so

57:15.360 --> 57:15.560
weiter.

57:18.260 --> 57:21.960
Wie gesagt, Sie können aus einer sogenannten Klasse, also mit diesem

57:21.960 --> 57:23.940
Bauplan oder Sie können sich das quasi vorstellen wie so einen

57:23.940 --> 57:26.880
Stempel, der schon mal das Gerüst vorgibt, natürlich beliebig viele

57:26.880 --> 57:29.980
sogenannte Objekte, Instanzen erzeugen und das nennt man dann auch

57:29.980 --> 57:31.040
manchmal Instanziieren.

57:31.600 --> 57:33.560
Also die Objekterzeugung heißt Instanziieren.

57:36.220 --> 57:40.460
Und das war im Prinzip, gab es lange Diskussionen auch in der

57:40.460 --> 57:43.880
Informatik, was ist denn jetzt genau ein Objekt und es gab im Prinzip

57:43.880 --> 57:49.500
drei Eigenschaften, die Crady Butch, das ist einer der großen Software

57:49.500 --> 57:53.560
-Architektur -Software-Entwickler, der bei IBM arbeitet, einer der

57:53.560 --> 57:56.780
meist zitiertesten, der hat mal in den 80ern ein Buch geschrieben,

57:56.880 --> 57:59.720
Object -Oriented Analysis and Design und da hat er das dann eigentlich

57:59.720 --> 58:01.900
mal schon einmal für alle Zeiten festgelegt.

58:02.420 --> 58:06.040
Und zwar sind Objekte charakterisiert durch ihre Entität.

58:06.840 --> 58:09.220
Es gibt also ein Objekt, jedes Objekt hat eine eigene Identität.

58:09.340 --> 58:12.580
Wenn Sie zwei Objekte haben, sind es erstmal zwei verschiedene, auch

58:12.580 --> 58:14.860
wenn die Werte, die Attributwerte genau gleich sind, trotzdem zwei

58:14.860 --> 58:15.600
verschiedene Objekte.

58:17.080 --> 58:20.840
Sie haben einen Zustand, der ist charakterisiert durch die Belegung

58:20.840 --> 58:24.800
der Attributvariablen, also welche Farbe, welches Gewicht, das gehört

58:24.800 --> 58:26.620
alles zum Zustand des Objektes.

58:27.100 --> 58:31.720
Und Sie haben ein Verhalten, das sind nämlich die Methoden, die, wenn

58:31.720 --> 58:34.320
man sie ausführt, den Zustand auch ändern können, indem Sie

58:34.320 --> 58:37.500
Berechnungen durchführen, was in die Variablenwerte reinschreiben und

58:37.500 --> 58:37.820
so weiter.

58:39.440 --> 58:42.520
Das sind Objekte und die Klassen sind, wenn Sie so wollen, der Bauplan

58:42.520 --> 58:44.000
für gleichartige Objekte.

58:44.260 --> 58:46.380
Wenn Sie verschiedene Entitäten, denken Sie daran, Beispiel

58:46.380 --> 58:50.500
Studierende, Student charakterisiert mit der Matrikelnummer.

58:51.380 --> 58:53.580
Das ist natürlich eine starke Abstraktion, das ist mir auch klar.

58:54.360 --> 58:56.500
Aber wie gesagt, jeder Student von Ihnen hat eine eigene

58:56.500 --> 58:59.420
Matrikelnummer, aber der Student als Klasse hat eben das Attribut

58:59.420 --> 58:59.920
Matrikelnummer.

59:03.640 --> 59:07.920
Die objektorientierte Programmierung ist sehr, sehr alt, weil einige

59:07.920 --> 59:09.280
immer sagen, oh, das ist was super Neues.

59:09.560 --> 59:10.220
Stimmt gar nicht.

59:10.300 --> 59:13.980
Das ist im Prinzip eine der Hauptzweige auch der Programmierung, die

59:13.980 --> 59:17.140
parallel zu anderen, die heute als veraltet angesehen wurden, auch

59:17.140 --> 59:20.820
schon begonnen wurde und zwar tatsächlich von einer Sprache Simular.

59:21.880 --> 59:24.440
Und die heißt tatsächlich deswegen Simular, weil man tatsächlich Dinge

59:24.440 --> 59:26.260
aus der realen Welt simulieren wollte.

59:26.380 --> 59:29.420
Und deswegen kommt diese Idee, Objekte sollen immer eine Entsprechung

59:29.420 --> 59:30.560
in der realen Welt haben.

59:32.920 --> 59:35.820
Und Simular ist tatsächlich die erste Sprache, die eben zwischen

59:35.820 --> 59:37.000
Klassen und Objekten unterscheidet.

59:37.640 --> 59:41.300
Und diese Konzepte sind über eine Reihe von anderen Sprachen dann auch

59:41.300 --> 59:42.320
in Java reingewandert.

59:42.400 --> 59:45.700
Und deswegen heißt Java auch objektorientierte Programmiersprache.

59:45.920 --> 59:49.120
Objektorientiert heißt, Sie haben ein Konstrukt wie eine Klasse, haben

59:49.120 --> 59:53.180
wir ja eben schon gesehen, welches Code und Daten zusammenbündeln

59:53.180 --> 59:53.480
kann.

59:55.760 --> 59:59.540
Und wenn wir uns das Beispiel anschauen, da haben wir unsere Klasse

59:59.540 --> 01:00:03.120
Ball und da haben Sie jetzt die Attribute, Durchmesser, Gewicht, x-

01:00:03.120 --> 01:00:06.240
und y-Position und x- und y-Geschwindigkeit.

01:00:06.460 --> 01:00:07.820
Und dann ist noch verschiedene Methoden.

01:00:08.680 --> 01:00:11.680
Und das ganze Schema funktioniert so, Sie schreiben Klasse und dann

01:00:11.680 --> 01:00:13.080
wählen Sie einen Namen dafür aus.

01:00:13.140 --> 01:00:16.600
Das ist der Name, den Sie auch in Ihrem Programm nachher brauchen.

01:00:18.280 --> 01:00:21.300
So jetzt sieht man vielleicht durch ein bisschen draufgucken, das

01:00:21.300 --> 01:00:22.800
sieht ja alles ziemlich ähnlich aus.

01:00:22.920 --> 01:00:26.100
Ich habe hier x-Position, y-Position, x-Velocity, y-Velocity.

01:00:27.400 --> 01:00:30.500
Das ist ja irgendwie komplizierter vielleicht, als es sein muss.

01:00:30.580 --> 01:00:31.960
Kann man das nicht vereinfachen?

01:00:32.060 --> 01:00:32.260
Ja.

01:00:32.480 --> 01:00:33.380
Und die Antwort ist, kann man.

01:00:34.940 --> 01:00:39.840
Und zwar, indem wir sagen, x- und y-Paare von zwei Fließkomma-Werten,

01:00:39.980 --> 01:00:42.700
das heißt das Float, Fließkomma, auch in späteren Vorlesungen genauer

01:00:42.700 --> 01:00:43.480
erklärt, was das ist.

01:00:44.560 --> 01:00:46.420
Also erstmal für Sie jetzt ganz grob Kommazahl.

01:00:48.180 --> 01:00:50.900
Diese Paare von Kommazahlen kann man jetzt in eine neue Klasse

01:00:50.900 --> 01:00:54.200
reinpacken, die wir 2D-Vektor nennen, Vektor 2D.

01:00:55.180 --> 01:00:56.360
Und das kann man machen.

01:00:56.860 --> 01:00:58.100
So sieht dann die Klasse aus.

01:00:59.520 --> 01:01:02.660
Ich habe x- und y-Koordinator, das Ganze heißt Vektor 2D.

01:01:02.880 --> 01:01:10.480
Und jetzt habe ich hier tatsächlich dann Vektor 2D-Position und

01:01:10.480 --> 01:01:11.660
Velocity einfach stehen.

01:01:12.620 --> 01:01:14.180
Und das heißt, so verwenden Sie das.

01:01:14.300 --> 01:01:18.600
Sie deklarieren quasi hier in dieser Klasse zwei Instanzen, Position

01:01:18.600 --> 01:01:20.980
und Velocity von Vektor 2D.

01:01:21.080 --> 01:01:21.700
Das ist die Klasse.

01:01:21.860 --> 01:01:24.080
Hier haben Sie jetzt zwei Objekte definiert.

01:01:24.800 --> 01:01:26.760
Erstmal nur definiert, erzeugten Sie noch nicht.

01:01:28.500 --> 01:01:31.380
Und hat aber die Sache natürlich schon mal deutlich vereinfacht.

01:01:31.500 --> 01:01:35.820
Zum einen, weil Sie ein allgemeines Konzept, nämlich einen 2D-Vektor

01:01:35.820 --> 01:01:39.340
rausgezogen haben und alleine die Tatsache, weil Sie jetzt hier einen

01:01:39.340 --> 01:01:42.440
für Menschen gut lesbaren, nachvollziehbaren Namen gegeben haben,

01:01:42.520 --> 01:01:46.380
Vektor 2D, wird auch ein bisschen klarer schon, was ist hier

01:01:46.380 --> 01:01:47.400
eigentlich gemeint.

01:01:47.540 --> 01:01:49.140
Es ist nämlich ein Vektor jedes Mal mit gemeint.

01:01:50.000 --> 01:01:55.680
Und gutes Programmieren besteht im Großteil auch darin, gute Variablen

01:01:55.680 --> 01:01:58.880
-Namen, gute Klassen-Namen und so weiter zu finden, weil das erhöht

01:01:58.880 --> 01:02:00.440
die Lesbarkeit von Programmen massiv.

01:02:00.640 --> 01:02:03.460
Also der Professor, bei dem ich programmieren gelernt habe, Prof.

01:02:03.620 --> 01:02:06.240
Tichy, sagte schon immer, keine Angst vor langen Variablen-Namen.

01:02:06.800 --> 01:02:08.580
Und ein Stück weit kann ich Ihnen das auch weitergeben.

01:02:08.580 --> 01:02:12.340
Nicht anfangen, Variablen mit T1 zu benennen.

01:02:12.440 --> 01:02:15.280
Das ist keine semantische Information oder X2.

01:02:16.560 --> 01:02:20.040
Abgesehen davon sollten Sie auch nicht das machen, was hier steht.

01:02:20.440 --> 01:02:21.900
Das ist nur ein Beispiel so.

01:02:22.160 --> 01:02:25.060
Und zwar Variablen nur mit einem Buchstaben.

01:02:25.680 --> 01:02:28.000
Wenn Sie sich nämlich hier vertippen, kann es sein, dass es eine

01:02:28.000 --> 01:02:30.340
andere Variable gibt, die auch so heißt.

01:02:30.580 --> 01:02:32.720
Das heißt, der Compiler merkt nicht, dass Sie was falsch gemacht

01:02:32.720 --> 01:02:32.960
haben.

01:02:33.240 --> 01:02:35.500
Der kann den Fehler nicht an Sie melden und Sie wundern sich lange,

01:02:35.820 --> 01:02:36.640
was Sie da gemacht haben.

01:02:36.720 --> 01:02:39.440
Also in der Regel immer versuchen, Variablenbezeichner,

01:02:40.040 --> 01:02:43.120
Klassenbezeichner mit mehr als zwei Buchstaben Unterschied zu wählen.

01:02:44.140 --> 01:02:46.880
Diejenigen, die schon viel programmiert haben, wie ich, wissen das zu

01:02:46.880 --> 01:02:49.080
schätzen und hätten wahrscheinlich einige schlaflose Nächte bei der

01:02:49.080 --> 01:02:50.100
Fehlersuche vermeiden können.

01:02:51.560 --> 01:02:57.780
So, jetzt habe ich erst mal gesagt eben, ich habe da mal zwei Objekte

01:02:57.780 --> 01:02:58.620
deklariert.

01:02:58.780 --> 01:03:00.420
Ich habe die aber noch nicht erzeugt.

01:03:00.480 --> 01:03:02.080
Objekte muss man richtig erzeugen.

01:03:02.400 --> 01:03:04.860
Das heißt, der Speicher muss belegt werden dafür.

01:03:04.940 --> 01:03:06.080
Was das alles heißt, kommt später.

01:03:06.700 --> 01:03:08.340
Und dazu gibt es dieses Wort New.

01:03:08.620 --> 01:03:10.780
Das ist auch fest eingebaut in der Java-Sprache.

01:03:11.640 --> 01:03:17.040
Und Vector2D-Position, also das Objekt-Position, bekommt ein neues

01:03:17.040 --> 01:03:19.360
Objekt, was vom Typ Vector2D ist.

01:03:19.660 --> 01:03:21.120
Sieht ein bisschen länglich aus.

01:03:22.040 --> 01:03:26.780
Wir werden später in der Vorlesung das auch kennenlernen, dass der Typ

01:03:26.780 --> 01:03:29.660
hier, also der Name hier, nicht mehr derselbe ist wie hier.

01:03:29.760 --> 01:03:31.720
Aber für den ersten Augenblick ist es mal dasselbe.

01:03:33.380 --> 01:03:36.700
Und dann erzeuge ich hier Velocity für die Geschwindigkeit auch

01:03:36.700 --> 01:03:39.640
nochmal einen neuen Vektor und dann erzeuge ich den gesamten Ball

01:03:39.640 --> 01:03:39.880
noch.

01:03:40.480 --> 01:03:42.060
So, und jetzt kleine Übung an Sie.

01:03:42.900 --> 01:03:46.560
Jetzt wäre die Idee, dass Sie kurz in kleinen Gruppen, zweier-,

01:03:46.560 --> 01:03:50.420
dreiergruppen in Ihrer Nachbarschaft sich überlegen, wenn ich denn die

01:03:50.420 --> 01:03:55.500
Mensa modellieren will, was habe ich denn da für Objekte der realen

01:03:55.500 --> 01:03:55.860
Welt?

01:03:56.680 --> 01:03:57.760
Also was sind meine Objekte?

01:03:58.180 --> 01:03:59.820
Was davon sind Klassen?

01:04:00.320 --> 01:04:01.520
Und in welcher Beziehung stehen die?

01:04:01.640 --> 01:04:02.720
Welche Attribute haben das?

01:04:03.160 --> 01:04:05.840
Also welche Klassen haben wir, um eine Mensa zu beschreiben?

01:04:06.420 --> 01:04:07.740
Und welche Attribute und Methoden?

01:04:08.880 --> 01:04:11.240
Das können Sie jetzt mal so fünf Minuten machen und dann werde ich

01:04:11.240 --> 01:04:12.440
einen Vorschlag präsentieren.

01:04:13.200 --> 01:04:14.800
Und Sie können überlegen erst mal gemeinsam, was ist.

01:04:16.120 --> 01:04:22.020
So, dann kommen wir mal gemeinsam an die Auflösung.

01:04:23.260 --> 01:04:28.760
Also zuerst einmal, da ich Ihnen ja nicht gesagt habe, wozu wollen wir

01:04:28.760 --> 01:04:32.740
nachher dieses Konstrukt Mensa eigentlich verwenden, was wir hier

01:04:32.740 --> 01:04:33.260
modellieren.

01:04:33.740 --> 01:04:36.960
Geht es darum, nachher Bestelllisten für die Mensa zu machen?

01:04:37.080 --> 01:04:38.860
Geht es darum, Statistikauswertung zu machen?

01:04:39.000 --> 01:04:40.100
Wer welches Essen wählt?

01:04:40.180 --> 01:04:41.520
Habe ich Ihnen ja alles nicht verraten.

01:04:41.840 --> 01:04:44.460
In dem Zufolge gibt es auch gar nicht eine eindeutige Lösung, sondern

01:04:44.460 --> 01:04:47.520
viele Lösungen, die alle gleich gut oder gleich schlecht sind.

01:04:48.160 --> 01:04:51.360
Das heißt also, das, was ich Ihnen jetzt gleich erzähle, ist halt eine

01:04:51.360 --> 01:04:53.100
denkbare Abstraktion.

01:04:53.740 --> 01:04:55.820
Die Abstraktion, wie gesagt, hängt immer ab von der sogenannten

01:04:55.820 --> 01:04:56.600
Pragmatik.

01:04:56.680 --> 01:04:57.840
Was will ich eigentlich damit machen?

01:04:57.920 --> 01:04:58.960
Die habe ich Ihnen aber nicht verraten.

01:04:59.020 --> 01:05:01.720
Insofern gibt es natürlich viele sinnvolle Abstraktionen.

01:05:01.900 --> 01:05:05.260
Und selbst wenn ich Ihnen die Pragmatik verraten hätte, zum Beispiel

01:05:05.260 --> 01:05:09.160
es geht darum, Statistikauswertung zu machen, welche Studenten sich

01:05:09.160 --> 01:05:13.700
wie oft Nachschlag holen, selbst dann gäbe es immer noch viele

01:05:13.700 --> 01:05:15.540
verschiedene Abstraktionen und Modellierungen.

01:05:15.620 --> 01:05:19.700
Das ist nicht in dem Sinne eindeutig, wie jetzt quasi die Auflösung

01:05:19.700 --> 01:05:24.300
von der mathematischen Gleichung oder sowas, sondern das ist im

01:05:24.300 --> 01:05:26.760
Prinzip diese Entscheidung, was abstrahiere ich weg, was lasse ich da,

01:05:27.100 --> 01:05:29.560
ist nicht trivial und kann auf sehr unterschiedliche Art und Weise

01:05:29.560 --> 01:05:30.880
gleich gut gemacht werden.

01:05:31.480 --> 01:05:35.060
So, wer hat denn zum Beispiel sich überlegt, dass es eine Klasse

01:05:35.060 --> 01:05:37.020
Speiseplan geben muss?

01:05:39.420 --> 01:05:40.340
Ein paar schon.

01:05:40.880 --> 01:05:44.020
Wer hat sich überlegt, dass es eine Klasse Bauchweh geben muss?

01:05:44.960 --> 01:05:45.620
Keiner, okay.

01:05:47.100 --> 01:05:48.460
Schon eine schlimme Erfahrung gemacht.

01:05:48.980 --> 01:05:53.560
So, das ist jetzt ein, wie gesagt, ein Beispiel, wie man das machen

01:05:53.560 --> 01:05:53.740
kann.

01:05:53.820 --> 01:05:54.860
Man kann es auch anders machen.

01:05:55.780 --> 01:05:59.680
Es ist erst mal clever, sich zu überlegen bei der Modellierung.

01:06:01.260 --> 01:06:04.240
Ich will eine Mensa modellieren, also mache ich erst mal eine Klasse

01:06:04.240 --> 01:06:05.200
Mensa.

01:06:05.660 --> 01:06:07.960
Die kann ja Bestandteile haben, aber es ist nicht so falsch.

01:06:09.080 --> 01:06:11.080
Fragen mache ich nachher, weil sonst wird es zu lange.

01:06:12.760 --> 01:06:16.020
Und zwar, was zeichnet die Mensa an sich aus?

01:06:16.120 --> 01:06:19.580
Das ist zum Beispiel, dass sie einen Namen hat, zum Beispiel in

01:06:19.580 --> 01:06:22.280
unserem Fall hier von der Mensa, die wir hier haben, Mensa am

01:06:22.280 --> 01:06:22.960
Adenauerring.

01:06:23.840 --> 01:06:26.680
Die erfahreneren Studenten wissen, es gibt in Karlsruhe mehrere Mensen

01:06:26.680 --> 01:06:28.660
noch, zum Beispiel bei der Fachhochschule, die wird auch vom

01:06:28.660 --> 01:06:29.540
Studentenwerk betrieben.

01:06:29.660 --> 01:06:32.340
Also wir brauchen einen Namen und dann gibt es vielleicht noch eine

01:06:32.340 --> 01:06:33.640
Postleitzahl und eine Straße.

01:06:34.020 --> 01:06:34.880
Das kann man auch anders machen.

01:06:34.960 --> 01:06:39.160
Man kann natürlich auch noch die Geodaten im GPS-System reinkodieren.

01:06:39.320 --> 01:06:40.480
Haben wir jetzt alles mal nicht gemacht.

01:06:41.360 --> 01:06:47.180
So, dann gibt es für eine Mensa natürlich den Speiseplan, wo drauf

01:06:47.180 --> 01:06:49.280
steht, welches Gericht gibt es.

01:06:49.320 --> 01:06:52.380
Jetzt können Sie sagen, ja, aber es gibt auch viele Gerichte in der

01:06:52.380 --> 01:06:53.040
Mensa, die können sich auch modellieren.

01:06:54.920 --> 01:06:55.920
Und das ist hier gemacht.

01:06:56.240 --> 01:07:01.400
Ein Gericht hat einen Namen und sagen wir mal einen Preis.

01:07:02.060 --> 01:07:03.780
Wir wissen, das ist ein echt komplizierter.

01:07:03.820 --> 01:07:06.320
Sie haben ja diese Komponenten wieder für die Gerichte, die Sie sich

01:07:06.320 --> 01:07:07.280
hier selber zusammenstellen könnten.

01:07:07.520 --> 01:07:09.120
Aber das könnte man natürlich weiter modellieren.

01:07:09.240 --> 01:07:11.960
Man könnte sagen, ein Gericht besteht wieder aus mehreren

01:07:11.960 --> 01:07:14.860
Einzelkomponenten, Nachtisch, Vorspeise und so weiter.

01:07:15.600 --> 01:07:17.980
Haben wir jetzt mal hier der Einfachheit halber nicht gemacht.

01:07:18.640 --> 01:07:20.500
Und dann gibt es natürlich auch den Mensa-Besucher.

01:07:20.640 --> 01:07:23.080
Jetzt können Sie sagen, ja, aber der Mensa-Besucher ist ja nicht

01:07:23.080 --> 01:07:24.160
Bestandteil der Mensa.

01:07:24.320 --> 01:07:28.480
Stimmt, aber er besteht doch in einer Beziehung zur Mensa.

01:07:28.620 --> 01:07:31.640
Und zwar kann ein Mensa-Besucher in mehrere Mensen gehen, das heißt

01:07:31.640 --> 01:07:32.180
das Sternchen.

01:07:32.320 --> 01:07:35.060
Und eine Mensa hat auch unter anderem mehrere Besucher.

01:07:35.140 --> 01:07:36.300
Das bedeutet das Sternchen da.

01:07:37.180 --> 01:07:41.280
Und der Mensa-Besucher hat Vornamen, Nachnamen.

01:07:41.600 --> 01:07:44.560
Er hat hoffentlich Geld dabei oder eine aufgeleitete Chipkarte.

01:07:45.040 --> 01:07:47.400
Und er hat Hunger oder auch vielleicht nicht Hunger, das heißt dieses

01:07:47.400 --> 01:07:47.880
Bulien.

01:07:49.240 --> 01:07:50.860
Meistens hat er Hunger, wenn er in die Mensa geht.

01:07:51.040 --> 01:07:52.200
Warum sollte man sonst hingehen?

01:07:53.340 --> 01:07:56.260
Und er kann ein Gericht essen und er kann die Mensa besuchen.

01:07:56.380 --> 01:07:58.280
Das sind die Operationen des Mensa-Besuchers.

01:07:59.080 --> 01:08:04.920
Und jetzt sehen Sie hier eine ganz einfache, eine Abstraktion von

01:08:04.920 --> 01:08:07.020
vielen möglichen.

01:08:08.340 --> 01:08:14.720
Und jetzt sagen Sie, na ja, das ist ja schön und gut, dieses

01:08:14.720 --> 01:08:15.320
Modellieren.

01:08:15.380 --> 01:08:17.420
Was hat das denn jetzt mit dem Programmieren zu tun?

01:08:18.320 --> 01:08:20.700
Und im Prinzip ist die Idee von dem Programmieren, dass man sagt, ich

01:08:20.700 --> 01:08:23.820
programmiere erst, wenn ich mal vorher ein Modell gemacht habe.

01:08:24.660 --> 01:08:27.780
Damit Sie jetzt aber nicht so ganz langweilig wird, machen wir noch

01:08:27.780 --> 01:08:31.860
eine kleine Papierrechner-Programmieraufgabe, die Sie gerne auch

01:08:31.860 --> 01:08:33.920
wieder gemeinsam machen können.

01:08:34.860 --> 01:08:40.720
Sie schreiben eine Main-Methode bitte für die Klasse Vector2D, die wir

01:08:40.720 --> 01:08:44.180
eben definiert haben, die die Koordinaten des Vektors ausgibt.

01:08:44.260 --> 01:08:46.640
Sie erinnern sich, ausgeben ist System Printline.

01:08:47.000 --> 01:08:49.580
Fragen mache ich nachher, weil sonst kommen wir zu nichts.

01:08:50.980 --> 01:08:54.700
Und zwar wäre die Sache, also überlegen Sie sich gerade gemeinsam auf

01:08:54.700 --> 01:08:58.060
dem Blatt Papier oder auch im Gespräch, was würde man denn jetzt

01:08:58.060 --> 01:09:02.460
machen, um hier von Vector2D diese beiden Koordinaten auszugeben?

01:09:02.860 --> 01:09:04.400
Wie sähe ein Programm dazu aus?

01:09:04.600 --> 01:09:07.860
So, kommen wir mal gemeinsam zur Lösung.

01:09:08.180 --> 01:09:11.060
Auch hier ist es wieder so, wenn Sie ein bisschen mehr Erfahrung

01:09:11.060 --> 01:09:14.200
haben, werden Sie eigentlich merken, dass der Unterschied zum

01:09:14.200 --> 01:09:17.400
Modellieren, zum Programmieren eigentlich ein bisschen entfließen ist.

01:09:17.460 --> 01:09:18.860
Das ist kein scharfer Übergang.

01:09:19.180 --> 01:09:21.600
Sie können ja auch in Java eben objektorientiert programmieren.

01:09:22.740 --> 01:09:24.980
Insofern gilt dasselbe eigentlich wie auch beim Modellieren.

01:09:25.340 --> 01:09:29.260
Es gibt viele verschiedene Programme, die dasselbe sinnvoll machen.

01:09:29.840 --> 01:09:32.640
Aber insofern, auch wenn es jetzt ein bisschen anders aussieht, was

01:09:32.640 --> 01:09:34.800
Sie hatten, hier das ist jetzt eine Lösung.

01:09:34.920 --> 01:09:37.680
Es ist nicht unbedingt die cleverste Lösung, aber es ist die, auf die

01:09:37.680 --> 01:09:40.040
man hätte kommen können mit dem Kenntnisstand, den ich Ihnen

01:09:40.040 --> 01:09:40.920
beigebracht habe.

01:09:40.920 --> 01:09:45.440
Und zwar haben Sie Ihre Klasse Vector2D.

01:09:46.460 --> 01:09:47.620
Die Attribute hatten Sie schon.

01:09:47.820 --> 01:09:52.500
Und jetzt definiere ich hier drin eine Main-Methode, die tatsächlich

01:09:52.500 --> 01:09:58.460
mir einen neuen Vector2D erzeugt und dann mit System.println mir diese

01:09:58.460 --> 01:09:59.260
Werte ausgibt.

01:09:59.360 --> 01:10:03.440
Und zwar mit v.x und v.y sagt man also, ich greife jetzt hier drauf zu

01:10:03.440 --> 01:10:06.700
auf diesen Vector v und da auf den x-Wert und den y-Wert.

01:10:07.560 --> 01:10:11.000
Das ist jetzt, wie gesagt, ganz einfach gemacht.

01:10:12.960 --> 01:10:16.440
Wir werden in den nächsten Vorlesungen alles im Detail davon

01:10:16.440 --> 01:10:16.820
durchgehen.

01:10:16.920 --> 01:10:18.860
Das war ein Stück weit auch gedacht als Überblick.

01:10:19.480 --> 01:10:22.520
Aber letzten Endes sieht man halt hier wieder die klassischen

01:10:22.520 --> 01:10:22.940
Elemente.

01:10:23.000 --> 01:10:25.720
Sie haben eine Klasse, die Klasse hat einen Namen, sie hat Attribute

01:10:25.720 --> 01:10:29.480
und sie hat eine Main-Methode in dem Falle, wo jetzt hier mit System

01:10:29.480 --> 01:10:32.140
.out.println Dinge ausgegeben werden.

01:10:34.180 --> 01:10:39.100
Es hatten sich eben mindestens zwei Leute gemeldet mit Fragen und da

01:10:39.100 --> 01:10:41.580
wir jetzt in der Tat noch ein bisschen Zeit hatten, wäre die Frage an

01:10:41.580 --> 01:10:46.780
die Frage, wenn Ihre Frage von allgemeinem Interesse ist.

01:10:48.940 --> 01:10:51.060
Achtung, Achtung, wir sind jetzt wieder in dem Modus, wo ich rede und

01:10:51.060 --> 01:10:53.360
Sie ruhig sind, nicht mehr im Gruppendiskussionsmodus.

01:10:55.720 --> 01:10:58.220
Die Leute, die sich gefragt haben, wenn Sie sagen, Ihre Frage ist von

01:10:58.220 --> 01:11:00.480
allgemeinem Interesse für alle, dann haben wir jetzt noch Zeit, diese

01:11:00.480 --> 01:11:01.160
Fragen zu stellen.

01:11:01.300 --> 01:11:03.600
Ansonsten sage ich einfach, kommen Sie nachher zu mir.

01:11:04.680 --> 01:11:06.440
Übungsgruppenleiter sind auch da, dann können wir auch Fragen

01:11:06.440 --> 01:11:06.960
beantworten.

01:11:07.040 --> 01:11:09.720
Aber wenn Sie denken, die Frage ist von allgemeinem Interesse, dann

01:11:09.720 --> 01:11:11.200
könnten wir Sie jetzt fragen.

01:11:11.500 --> 01:11:12.220
Okay, gut.

01:11:12.900 --> 01:11:14.920
Dann kommen wir zur Zusammenfassung.

01:11:15.600 --> 01:11:23.840
Ein bisschen Ruhe noch, nur um das mal klar zu machen.

01:11:24.200 --> 01:11:26.820
Ich toleriere Lautstärke im Hörsaal nicht und ich habe einen

01:11:26.820 --> 01:11:28.520
Laserpointer, der ist mal irgendwo runtergefallen.

01:11:28.600 --> 01:11:30.660
Sie sehen, der Punkt ist relativ groß.

01:11:31.220 --> 01:11:32.820
Genau, kann auch mal ins Auge gehen.

01:11:33.120 --> 01:11:34.380
Ich zeige dann immer auf die Schwätzer.

01:11:34.480 --> 01:11:35.240
Das mache ich immer gerne.

01:11:35.800 --> 01:11:37.800
Ich habe aber noch kein Strafverfahren deswegen bekommen.

01:11:37.900 --> 01:11:39.340
Es scheint also auch juristisch zu gehen.

01:11:40.060 --> 01:11:41.180
Das heißt also, ein bisschen Ruhe schon.

01:11:41.320 --> 01:11:43.580
Sonst kriegen wir einen grünen Punkt und das heißt dann was.

01:11:45.720 --> 01:11:47.060
Also, was haben wir gelernt?

01:11:49.500 --> 01:11:52.240
Objekte modellieren Gegenstände in der realen Welt.

01:11:52.360 --> 01:11:58.680
Das ist extrem hilfreich, weil wenn Sie zwei komplette Welten haben,

01:11:58.760 --> 01:12:03.260
Ihr Problem, was Sie lösen wollen und Ihr Programm, was komplett

01:12:03.260 --> 01:12:08.740
woanders ist, was keine Wörter der realen Weltbegriffe hat, dann ist

01:12:08.740 --> 01:12:10.260
das sehr schwer zu verstehen, das Programm.

01:12:10.380 --> 01:12:13.820
Sie müssen quasi jedes Mal sich sehr mühsam in das Programm eindenken

01:12:13.820 --> 01:12:16.600
und verstehen, warum löst es denn dieses Problem aus der realen Welt

01:12:16.600 --> 01:12:19.120
oder schlimmer noch, welches Problem löst es überhaupt.

01:12:19.700 --> 01:12:24.520
Wenn Sie Begrifflichkeiten aus der realen Welt, aus der Welt, wo Sie

01:12:24.520 --> 01:12:29.260
das Problem lösen, auch übernehmen in der Programm im Sinne von guten

01:12:29.260 --> 01:12:33.040
Bezeichnernamen, guten Namen für Klassen, guten Namen für Objekte,

01:12:33.160 --> 01:12:36.620
gute Namen für Variablen, wird es leichter, Ihr Programm zu verstehen.

01:12:37.100 --> 01:12:40.580
Und das ist der große Vorteil der Objektorientierung gegenüber anderen

01:12:41.900 --> 01:12:44.480
Programmierkonzepten, dass Sie hier die Chance haben, über die

01:12:44.480 --> 01:12:47.940
Objektnamen und Klassennamen Begrifflichkeiten eins zu eins aus der

01:12:47.940 --> 01:12:48.960
realen Welt zu übernehmen.

01:12:49.060 --> 01:12:51.000
Das ist genau die Hauptidee von Objektorientierung.

01:12:51.720 --> 01:12:54.480
Objekte modellieren Gegenstande aus der realen Welt.

01:12:54.560 --> 01:12:55.700
Das ist ein Riesenvorteil.

01:12:57.620 --> 01:13:00.140
Das macht, wie gesagt, Programme leichter verständlich, leichter

01:13:00.140 --> 01:13:00.820
nachvollziehbar.

01:13:01.060 --> 01:13:03.700
Und wenn Sie mal selber programmiert haben, wissen Sie, nach drei,

01:13:03.760 --> 01:13:06.660
vier Monaten den eigenen Code lesen ist quasi wie neuen Code lesen.

01:13:06.720 --> 01:13:09.500
Sie haben nicht mehr die originale Idee im Kopf und Sie sind auf Ihren

01:13:09.500 --> 01:13:10.380
eigenen Code angewiesen.

01:13:11.100 --> 01:13:14.520
Wir haben gelernt, Klassen sind Baupläne für Objekte.

01:13:15.140 --> 01:13:17.780
Das heißt also mit anderen Worten, wenn Sie eine Klasse definieren,

01:13:18.240 --> 01:13:19.180
ist das so wie ein Plan.

01:13:19.560 --> 01:13:21.240
Was sind die Bestandteile von Objekten?

01:13:21.420 --> 01:13:22.380
Welche Attribute hat es?

01:13:22.440 --> 01:13:23.180
Welche Methoden hat es?

01:13:23.200 --> 01:13:25.860
Das haben Sie einmal in der Klasse festgelegt und dann können Sie

01:13:25.860 --> 01:13:29.480
davon mit dem New Operator mehrere Objekte anlegen.

01:13:30.180 --> 01:13:33.560
Und Dinge aufrufen können Sie für den Augenblick zumindest mal erstmal

01:13:33.560 --> 01:13:34.800
immer nur bei Objekten.

01:13:35.780 --> 01:13:42.280
So, in Java gibt es eine ganze Menge fest eingebauter Datentypen und

01:13:42.280 --> 01:13:45.220
über Klassen, die Sie selber definieren, können Sie das im Prinzip

01:13:45.220 --> 01:13:45.780
erweitern.

01:13:46.240 --> 01:13:49.380
Vielen Dank und wie gesagt, für Fragen stehe ich jetzt am Ende mit den

01:13:49.380 --> 01:13:50.360
Gruppenleitern zur Verfügung.