1
00:00:04,000 --> 00:00:05,640
 Das war's für heute.

2
00:00:05,640 --> 00:00:08,460
 Bis zum nächsten Mal.

3
00:00:10,142 --> 00:00:16,182
 So, schönen guten Tag, Praxistipps-Referentariat, typische Programmierfehler.

4
00:00:18,602 --> 00:00:24,622
 Die Einführung in die Programmierung ist geprägt von möglichst vielen Übungen,
 wenn man wird

5
00:00:24,622 --> 00:00:29,862
 gut, indem man Dinge einfach mal macht und dabei möglichst viele Fehler begeht.

6
00:00:30,062 --> 00:00:37,362
 Das wissen Sie vielleicht noch aus eigener Erfahrung, die Programmierung ist
 voll mit

7
00:00:37,442 --> 00:00:38,322
 Stolpersteinen.

8
00:00:38,832 --> 00:00:42,992
 Und der Anfänger wird jeden Stolperstein mitnehmen.

9
00:00:43,752 --> 00:00:46,852
 Für Sie als Lehrkraft ist es wichtig, dass Sie

10
00:00:46,852 --> 00:00:51,332
 vorhersehbare Anfängerfehler, die es gibt, schnell entdecken können und schnell

11
00:00:51,332 --> 00:00:52,272
 korrigieren können.

12
00:00:53,612 --> 00:00:57,212
 Und auch in der Lage sind, wenn Sie wissen, welche Fehler typisch sind,

13
00:00:57,392 --> 00:01:00,212
 diese direkt in den Unterricht einzubauen,

14
00:01:00,952 --> 00:01:03,712
 so dass zumindest einige

15
00:01:03,712 --> 00:01:04,592
 Fehler

16
00:01:04,592 --> 00:01:05,932
 vermieden werden können.

17
00:01:06,704 --> 00:01:13,044
 Das Gute ist, dass es eine ganze Reihe von klassischen Anfänger-Fehlern gibt
 und wenn

18
00:01:13,044 --> 00:01:20,744
 sie die kennen, dann können sie sie auch zügig beheben, denn sie müssen sich
 das in der Praxis

19
00:01:20,744 --> 00:01:29,524
 immer vorstellen. Sie haben eine Lerngruppe von 20+ Leuten und alle sind zu
 Gange mit

20
00:01:29,524 --> 00:01:35,104
 der Programmierung und kommen erstmal nicht weiter.

21
00:01:35,312 --> 00:01:39,492
 Da haben sie ganz schnell sehr viel zu tun, wenn sie jeden Fehler wirklich

22
00:01:39,492 --> 00:01:42,752
 suchen müssen, anstatt mit dem geschulten Auge

23
00:01:42,752 --> 00:01:47,172
 das die Erfahrung bringt, einmal drauf zu schauen und dann sofort zu sehen

24
00:01:47,172 --> 00:01:48,932
 was falsch ist.

25
00:01:49,772 --> 00:01:53,712
 Natürlich werden sich diese Fähigkeiten bei Ihnen nach und nach ausbilden, aber

26
00:01:53,712 --> 00:01:57,752
 je mehr man vorher schon weiß, desto entspannter

27
00:01:57,752 --> 00:01:58,952
 ist dann

28
00:01:58,952 --> 00:02:00,592
 die Praxis für Sie.

29
00:02:01,754 --> 00:02:11,814
 Ohne Anspruch auf Vollständigkeit sind hier 7 typische Anfängerfehler
 aufgeführt und die werden es nach und nach vorgestellt.

30
00:02:14,074 --> 00:02:27,254
 Zunächst die Java-spezifische Konvention, dass der Klassenname, hier TestUplet,
 immer gleich dem Dateinamen sein muss, in dem die jeweilige Klasse gespeichert
 ist.

31
00:02:27,254 --> 00:02:30,354
 Das heißt, achten Sie darauf, dass ...

32
00:02:30,384 --> 00:02:35,704
 ... im Beispiel "Test-Uplet" auch in der Datei "Test-Uplet" gespeichert ist.

33
00:02:38,104 --> 00:02:40,684
 Das ist noch eine relativ leicht zu behebende Sache.

34
00:02:42,464 --> 00:02:47,944
 Schwieriger ist dieses Fehlerbild hier, wenn Sie das zum ersten Mal sehen, das
 ist gar nicht so leicht zu finden.

35
00:02:49,044 --> 00:02:57,244
 Und zwar, wenn Sie die Grundstrukturen, also Sequenz, Entscheidung,
 Wiederholung einführen, kommen Sie dann zur Vorschleife.

36
00:02:58,204 --> 00:02:59,644
 Und mit ...

37
00:02:59,664 --> 00:03:06,204
 sind mit dem Problem der Zeichensetzung konfrontiert, also Klammern und
 Semikolons insbesondere.

38
00:03:07,284 --> 00:03:11,624
 Und da wird der ein oder andere schonmal auf die Idee kommen, an diese Stelle,

39
00:03:12,744 --> 00:03:20,764
 nach den runden Klammern der Vorschleife in Semikolons zu setzen und dann den
 Rumpf der Schleife zu formulieren.

40
00:03:23,344 --> 00:03:26,084
 Es ist syntaktisch korrekt, das ist das Problem dabei.

41
00:03:26,084 --> 00:03:29,364
 Allerdings verhält sich das Programm dann nicht so wie ...

42
00:03:30,016 --> 00:03:39,696
 ... der Schüler das gerne möchte. Und hier ist nochmal aufgefüllt, warum das so
 ist.

43
00:03:40,836 --> 00:03:46,556
 Das Simikolon nach den runden Klammern der Vorschleife entspricht einem leeren
 Rumpf.

44
00:03:46,636 --> 00:03:53,316
 Das heißt, sie könnten das auch in dieser Form schreiben. Das heißt, der Block,
 der Rumpf ...

45
00:03:53,520 --> 00:04:04,900
 ... der eigentlich hier in Mengenklammern zur Vorschleife gehörig zählen soll,
 von der Intention her, wird aufgrund des Semikolons nicht mehr dazugezählt.

46
00:04:05,020 --> 00:04:09,860
 Da die Klammerung syntaktisch korrekt ist, gibt es auch keinen Syntaxfehler.

47
00:04:11,020 --> 00:04:13,760
 Das heißt, sie haben eigentlich sowas hier geschrieben.

48
00:04:14,100 --> 00:04:21,140
 Vorschleife und dann einen leeren Rumpf gefolgt von einem weiteren Rumpf, der
 hier unnötige Klammern hat, aber die sind ja nicht falsch.

49
00:04:21,140 --> 00:04:23,300
 Ganz fieser Fehler.

50
00:04:25,144 --> 00:04:29,084
 Das ist günstig, wenn man den vorher mal gesehen hat.

51
00:04:32,484 --> 00:04:41,284
 Ein weiterer Klassiker, historisch gewachsen oder historisch zu erklären, ist
 der Vergleich auf Gleichheit und die Zuweisung.

52
00:04:41,864 --> 00:04:48,444
 Sie wissen, dass obiges Konstrukt, also if a = b, eine Zuweisung ist.

53
00:04:48,444 --> 00:04:52,484
 Also a und b werden gleich gesetzt.

54
00:04:54,028 --> 00:04:57,848
 Intendiert aus der Sicht des Anfängers, und da kommen halt die Probleme her.

55
00:04:58,468 --> 00:05:02,748
 Man ist nur einmal Anfänger und dann vergisst man ganz schnell seine Anfänger
-Probleme.

56
00:05:02,768 --> 00:05:06,248
 Aus der Sicht des Anfängers, der noch nicht in diese

57
00:05:06,968 --> 00:05:07,528
 Routinen

58
00:05:07,528 --> 00:05:09,988
 der Programmierung

59
00:05:10,908 --> 00:05:12,628
 sich hinein entwickelt hat.

60
00:05:13,228 --> 00:05:18,388
 Ist das hier zunächst mal die intuitivere Variante eines Vergleichs

61
00:05:18,388 --> 00:05:20,488
 auf Gleichheit? Wenn a = b.

62
00:05:21,562 --> 00:05:27,882
 Jetzt muss er sich erstmal daran gewöhnen, dass in vielen Programmiersprachen,
 so auch

63
00:05:27,882 --> 00:05:34,162
 in Java, der momentan Unterrichtssprache, beispielsweise in Nordrhein
-Westfalen, nun

64
00:05:34,162 --> 00:05:41,442
 mal an einzelnes Gleich eine Zuweisung darstellt, während der Vergleich auf
 Gleichheit per

65
00:05:41,442 --> 00:05:43,182
 Doppelgleich erfolgt.

66
00:05:44,462 --> 00:05:49,602
 Intuitiv ist das nicht, das werden Sie dann auch sehen, wenn Sie Anfänger in

67
00:05:49,602 --> 00:05:50,962
 der Programmierung unterrichten.

68
00:05:51,872 --> 00:05:57,912
 Warum wurde das so gemacht? Sie müssen da immer die Historie im Hinterkopf
 halten.

69
00:05:58,272 --> 00:06:05,152
 Als Java entwickelt wurde, war es wichtig, dass gewisse Übergänge von anderen
 Programmier sprachen,

70
00:06:05,332 --> 00:06:09,052
 seitens der Programmierer dann auch möglich waren, möglichst leicht,

71
00:06:09,112 --> 00:06:12,172
 und dass eine gewisse Abwärtskompatibilität erhalten bleibt.

72
00:06:13,232 --> 00:06:19,332
 Und einer der Vorläufer von Java war C und C++ und da wurde das genauso
 gemacht.

73
00:06:19,872 --> 00:06:24,652
 Nur weil das so gemacht wurde, seit Jahr und Tag, heißt das nicht, dass es
 sinnvoll ist.

74
00:06:24,692 --> 00:06:26,772
 Es ist auf jeden Fall nicht intuitiv.

75
00:06:27,132 --> 00:06:36,612
 Das ist einer der Gründe, warum beispielsweise in Pascal, die Niklas Wirt als
 Lehrsprache ursprünglich entwickelt hat,

76
00:06:37,152 --> 00:06:45,092
 genau dieses Problem auch anders gelöst wurde, nämlich das einzelne
 Gleicherzeichen ist tatsächlich Vergleich auf Gleichheit,

77
00:06:45,092 --> 00:06:49,672
 also wie das intuitiv ist für den nicht geschulten Lernenden.

78
00:06:50,064 --> 00:06:58,264
 Und Doppelpunktgleich oder das per Definition gleich aus der Mathematik wurde
 für die Zuweisung verwendet.

79
00:06:58,844 --> 00:07:13,244
 Ja, aber gut, es ist so, wie die Sprache das vorgibt. Das heißt, das klassische
 Fehlerbild Zuweisung und Testaufgleichheit wird gerne auch später immer mal
 wieder verwechselt.

80
00:07:13,424 --> 00:07:18,524
 Und da das syntaktisch in der Regel immer korrekt ist, gibt es dann halt auch
 keinen Fehler.

81
00:07:18,880 --> 00:07:27,880
 Fehlermeldung vom Compiler. Das Programm verhält sich nur nicht so, wie es
 soll, was ja sehr viel unangenehmer ist, als gibt es direkt einen Syntax
-Fehler.

82
00:07:29,580 --> 00:07:35,960
 Gut, ein Fehlerbild, das schon etwas fortgeschrittener ist, ist das Problem der
 Sichtbarkeit.

83
00:07:36,920 --> 00:07:43,760
 Wenn Sie sich den Quellcode-Ausschnitt anschauen, dann gibt es manchmal, dass
 es weniger verbreitet, als man meinen könnte,

84
00:07:43,760 --> 00:07:44,580
 dass es weniger verbreitet ist.

85
00:07:45,968 --> 00:07:56,348
 Es gibt Probleme, die gleich benannten Variablen von Ihrem Gültigkeitsbereich
 her einzuschätzen.

86
00:07:56,588 --> 00:08:02,948
 Wenn Sie ein "i" haben außerhalb des Rumpfes einer Methode, innerhalb der
 Klasse, beispielsweise als Attribut,

87
00:08:03,548 --> 00:08:13,088
 und das gleichlautende "i" innerhalb einer Methode, dann kommen manchmal
 Verständnisprobleme auf,

88
00:08:13,088 --> 00:08:14,568
 welches "i" ...

89
00:08:14,592 --> 00:08:28,572
 nun verwendet wird. Das ist aber erstaunlicherweise weniger häufig zu
 beobachten, als man das vielleicht von der rein theoretischen Sicht her
 vermuten könnte.

90
00:08:28,672 --> 00:08:43,752
 Denn meisten Lernenden ist das auch irgendwie intuitiv klar, dass wenn
 innerhalb einer Methode eine Variable verwendet wird, die auch außerhalb der
 Methode vorrätig ist, dann wird die innerhalb der Methode verwendet.

91
00:08:44,384 --> 00:08:49,144
 Sollte das mal ein Problem sein, haben Sie jetzt schon ein geschultes Auge
 dafür.

92
00:08:51,284 --> 00:08:56,544
 Ja, diesen Fehler, den werden Sie wahrscheinlich lieben gelernt haben, aus der
 eigenen Erfahrung.

93
00:08:57,124 --> 00:09:07,784
 Wenn es nach einer gewissen Zeit in der Programmierausbildung um Datenreihen,
 Datenreiungen geht in Form von arrays,

94
00:09:08,584 --> 00:09:11,104
 meistens mit Zahlen drin zunächst, dann

95
00:09:11,664 --> 00:09:15,164
 müssen sie da auch durchlaufen mit einer Vorschleife in der Regel

96
00:09:15,164 --> 00:09:18,364
 und da gibt es dann verschiedene Fehlerbilder.

97
00:09:18,644 --> 00:09:19,784
 Eines davon

98
00:09:20,784 --> 00:09:21,504
 ist

99
00:09:23,444 --> 00:09:24,884
 die Problematik

100
00:09:24,884 --> 00:09:27,564
 der Genauigkeit im Denken

101
00:09:27,564 --> 00:09:28,884
 was das Gleich

102
00:09:29,964 --> 00:09:33,284
 kleiner, größer, kleiner gleich, größer gleich

103
00:09:33,284 --> 00:09:34,644
 angeht.

104
00:09:35,064 --> 00:09:36,384
 Da müssen sie

105
00:09:36,384 --> 00:09:38,024
 direkt von Anfang an

106
00:09:38,720 --> 00:10:07,160
 einen besonderen Wert darauf legen, dass das alle korrekt lernen soll heißen,
 in der Einführung mit absoluten Zahlen, aber dann ganz schnell sauber
 programmieren und allgemeine Attribute verwenden, wie zum Beispiel das Attribut
 length des arrays. Dann haben sie ja diese Probleme gar nicht erst.

107
00:10:09,464 --> 00:10:17,984
 Es wird so oder so passieren, dass Leute über die array-Grenzen hinaus wandern
 und dann einen

108
00:10:17,984 --> 00:10:19,904
 array-index out of bounds bekommen.

109
00:10:22,684 --> 00:10:34,104
 Je sauberer sie programmieren und die Unterschiede zwischen den
 Relationszeichen verdeutlichen,

110
00:10:34,104 --> 00:10:37,224
 die man einfordern und ziemlich zügig zu den

111
00:10:37,712 --> 00:10:43,652
 allgemeinen Programmieransätzen überlängst gehen, desto weniger Probleme wird
 es da geben.

112
00:10:44,332 --> 00:10:48,772
 Und weisen Sie auf diese klassischen Fehler auch immer wieder hin.

113
00:10:50,392 --> 00:10:56,852
 "Finde den Fehler"-Übungsaufgaben haben sich in der Praxis als hilfreich
 erwiesen,

114
00:10:57,072 --> 00:11:02,752
 dass sozusagen Sie Quellcode-Ausschnitte als Übungsaufgabe formulieren,

115
00:11:02,752 --> 00:11:07,872
 die irgendwelche fiesen Fehler enthalten und die lernen sollen, die dann
 finden.

116
00:11:08,432 --> 00:11:16,592
 Wenn Sie in der Einführung von arrays noch nicht mit dem Length-Attribut
 arbeiten, sondern tatsächlich mit absoluten Zahlen,

117
00:11:17,312 --> 00:11:25,792
 dann müssen Sie bedenken, dass der Novize noch nicht dran gewöhnt ist, dass in
 der Informatik von 0 an begonnen wird zu zählen.

118
00:11:26,432 --> 00:11:31,692
 Wenn man also 10 Elemente in einem Feld hat, da geht man ja von 0 bis 9 durch.

119
00:11:33,092 --> 00:11:35,952
 Also von 0 bis 9 ergibt 10 Elemente als Merkhilfe.

120
00:11:36,608 --> 00:11:44,428
 Und es hat sich, wie in allen anderen Inhalten auch bewährt, sinnvolle Routinen
 dabei aufzubauen.

121
00:11:45,188 --> 00:11:51,208
 In dem Fall soll das heißen, dass Sie typisch für eine Vorschleife immer bei 0
 anfangen.

122
00:11:51,468 --> 00:11:56,248
 Und dann die auf kleiner als gewünschte Anzahl prüfen.

123
00:11:56,976 --> 00:12:08,776
 Soll heißen, wenn man 10 Elemente abklappern möchte und man fängt bei 0 an und
 geht bis kleiner als 10, dann hat man ja 0 bis 9 durchlaufen und genau die 10
 Elemente erwischt.

124
00:12:09,696 --> 00:12:19,096
 Das ist der Standardfall, deckt fast alle Szenarien ab und bietet sich deswegen
 an als Routine etabliert zu werden.

125
00:12:22,682 --> 00:12:37,702
 Was in der fortgeschrittenen Anfängerausbildung ein Problem darstellt, ist,
 wenn man zu Strukturen

126
00:12:37,702 --> 00:12:41,582
 übergeht, die eine Struktur in sich tragen.

127
00:12:43,942 --> 00:12:45,862
 Schauen wir uns dazu folgendes Beispiel an.

128
00:12:45,862 --> 00:12:51,062
 Wir haben hier ein 2D-Feld, deren Elemente

129
00:12:51,088 --> 00:12:56,208
 Felder sind, also Objekte der Klasse Feld hier abgebildet.

130
00:12:57,408 --> 00:13:02,628
 Wenn man sich jetzt den Quellcode-Ausschnitt auf der rechten Seite anschaut,
 dann wird hier ein 2D-Feld

131
00:13:03,328 --> 00:13:08,308
 formuliert und über eine doppelt verschachtelte Vorschleife durchlaufen.

132
00:13:08,848 --> 00:13:10,008
 Und die interessante

133
00:13:10,808 --> 00:13:19,568
 Zeile, die sie sorgfältig und mehrfach in verschiedenen Szenarien dann

134
00:13:19,600 --> 00:13:28,240
 steht im Rumpf der zweiten Vorschleife. Testfeld an der Stelle XY gleich
 Newfeld. Das heißt, an jeder Stelle,

135
00:13:28,820 --> 00:13:34,860
 an jedem Kästchen wird ein Objekt gesetzt, vom Datentyp Feld.

136
00:13:36,900 --> 00:13:37,440
 Okay.

137
00:13:39,800 --> 00:13:43,400
 Was heißt das jetzt von der Denkweise? Und da kommen die Probleme her.

138
00:13:44,080 --> 00:13:48,240
 Testfeld an der Stelle 3-4. Was liefert das für einen Datentyp?

139
00:13:48,736 --> 00:13:54,836
 Diese Dinge müssen sie dann sehr viel wert legen, sonst sind Fehler nicht mehr

140
00:13:54,836 --> 00:14:00,256
 behebbar, weil die Leute nicht wissen, was sie da eigentlich machen. Also
 dieses

141
00:14:00,256 --> 00:14:06,376
 Testfeld an der Stelle 3-4 liefert ein Objekt vom Datentyp Feld und davon die

142
00:14:06,596 --> 00:14:13,856
 Methode in dem Fall neuer Status. Das heißt, die

143
00:14:14,608 --> 00:14:21,188
 Struktur 2D-Feld hat eine innere Struktur, nämlich die einzelnen Objekte vom

144
00:14:21,188 --> 00:14:25,528
 Datentyp "Feld", die wiederum eine innere Struktur haben, nämlich hier ihre

145
00:14:25,528 --> 00:14:32,328
 Attribute und Methoden. Da sind sie dann aber schon im fortgeschrittenen
 Bereich

146
00:14:32,328 --> 00:14:36,368
 in der Kursphase, nicht mehr in der Einführungsphase.

147
00:14:38,588 --> 00:14:40,788
 Gut, die

148
00:14:42,746 --> 00:14:48,186
 Der letzte typische Programmierfehler, der auch schon in den vorgeschrittenen
 Bereich

149
00:14:48,186 --> 00:14:59,006
 fällt, ist der, ist das Konstrukt, wenn Objekt 1 doppelgleich Objekt 2, da
 vergleicht man

150
00:14:59,006 --> 00:15:00,006
 auf Gleichheit.

151
00:15:01,346 --> 00:15:06,846
 Das ist so der intuitive Ansatz, wenn das eine Objekt gleich dem anderen ist,
 dann

152
00:15:06,846 --> 00:15:10,766
 erinnert sich der Lernende, ja, Vergleich auf Gleichheit ist ja hier per
 doppelgleich,

153
00:15:10,766 --> 00:15:11,486
 das ist super.

154
00:15:12,080 --> 00:15:18,400
 Und erwartet dann, dass da Ja oder Nein als Antwort, also bullshit Antwort
 herauskommt.

155
00:15:18,440 --> 00:15:24,660
 Das funktioniert so nicht, wie Sie wissen, weil damit nicht Objekte verglichen
 werden,

156
00:15:24,860 --> 00:15:25,720
 sondern Adressen.

157
00:15:27,100 --> 00:15:32,640
 Da steckt natürlich jetzt eine ganze Menge an notwendiger Theorie dahinter, wie
 Objekte

158
00:15:32,640 --> 00:15:35,200
 eigentlich im Speicher verwaltet werden.

159
00:15:36,740 --> 00:15:41,260
 Deswegen ist es auch ein vorschrittener Fehler, der wird Ihnen aber häufig
 unterkommen.

160
00:15:41,648 --> 00:15:46,448
 Und so sind Sie schon mal darauf vorbereitet.

161
00:15:47,748 --> 00:15:53,308
 Gut, viel Spaß in der Ausbildung Ihrer Programmierer.