sebastian/oca8-lernen
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Page: Exam Watch
Pages
Überladen und Überschreiben von Methoden 99 Lernnotizen Aufpassen! Calendar API Enums Exam Watch Garbage Collection Initialisieurngsreihenfolge Interfaces Label, break, continue Lambda Ausdrücke (Predicate) Operator Rangfolge Primitive Datentypen Switch Anweisung ZZZ: 00 Allgemeines ZZZ: 01 Kapitel 1 ZZZ: 02 Kapitel 2
Clone
15
Exam Watch
Sebastian Eidecker edited this page 2019-11-04 22:38:34 +00:00
Table of Contents

Kurzzusammenfassung der "Exam-Watch"-Boxen aus dem Buch

Antworten nur bei triftigen Gründen ändern (S. xxx)

Nervosität führt ansonsten eher zu mehr Fehlern

Notizzettel nutzen (S. xxxi)

Unsichere Antworten und anschaulichere Darstellung ("Wenn man nicht mehr weiter kann fertigt man eine Skizze an!")

Grenzen Wildcard-Import (S. 16)

Nicht rekursiv, import static A.* nur für statische Member der Klasse, import java.util.* für das Package, nicht tiefer.

Konstanten in Interfaces (S. 27)

Modifier implizit, müssen nicht angegeben werden. Vorsicht, sie gelten aber, auf Compilefehler achten!

Array-Deklaration nie mit Größe (S. 59)

Größe eines Arrays kann nie direkt bei der Deklaration angegeben werden -> Compilefehler

Auf Encapsulation achten (S. 91)

public-deklarierte Felder können von außen zugegriffen werden. Verhalten dann gerne bewusst irreführend.

Interfaces - default (S. 102)

Interfaces können konkrete Implementierungen haben (default)

Polymorphie, Late Binding und Exceptions (S. 110)

Oberklasse deklariert Checked Exceptions, Unterklasse nicht mehr. Wenn Oberklasse als Typ deklariert muss die Exception behandelt werden, auch wenn zur Laufzeit Unterklasse vorhanden ist. Compilefehler, da Compiler Exceptions prüft.

Überladen vs. Überschreiben (S. 112, S. 116, S. 130)

  • Aufpassen, Methoden können auch solche aus Oberklassen überladen.
  • Dadurch ggf. Fehler oder nicht.
  • Überladen: Rückgabe kann sich ändern. Überschreiben: Nur covariant (Subklassen)
  • Methodenauswahl Überladen Compilezeit, Überschreiben Laufzeit.

main() kan überladen werden (S. 115)

Aber nur die public static void main (String [] args) kann von der JVM als Startmethode verwendet werden.

static und default aus Interfaces müssen nicht implementiert werden (S. 123)

Illegale Verwendung extends und implements (S. 127)

  • Klassen implementieren Interfaces (auch mehrere)
  • Klassen extenden Klassen (nicht mehrere)
  • Interfaces extenden Interfaces (auch mehrere)
  • Klassen: erst extends, dann implements

Kovariante Rückgabe (S. 132)

Methoden können Unterklassen des definierten Rückgabewertes liefern.

Initialisierungsblöcke (S. 147)

Initialisierungsblöcke können an beliebiger Stelle (auf Root-Ebene) einer Klasse stehen, nicht nur zu Beginn.

Zugriff auf nichtstatische Objekte aus statischem Kontext (S. 150)

Aufpassen auf versteckte Zugriffe auf Felder/Methoden aus statischem Kontext heraus.

Variablen-Deklaration und -Zuweisung (S. 185)

Erlaubt:

  • int a, b, c
  • int j, k=1, l, m=3
  • int i; int j;
  • int j, k=1, m=k+3; // Reihenfolge wichtig!

Sichtbarkeit (S. 195)

Aufpassen auf nicht sichtbare Variablen, insbesondere in Schleichen, catch, etc.

Lokale Variablen müssen initialisiert werden (S. 199)

Anders als Felder keine Standardwerte. Compilefehler bei Versuch der Verwendung!

Boolesche Ausdrücke - = vs. == (S. 239, 277)

Aufpassen, = vergleicht nicht, kann aber kompilierbar sein, wenn boolescher Ausdruck zugewiesen wird. Auf Compilefehler und trickreiches Verhalten achten!

Instanceof und indirekte Implementierung (S. 243)

Auch true, wenn eine Oberklasse das Interface implementiert.

Arrays sind Objekte (S. 244)

Arrrays sind Objekte, auch solche von Primitiven. (instanceof Object == true)

String-Konkatenation (S. 248)

ints werden addiert. Ab erstem String werden Strings konkateniert. System.out.println(4 + 3 + "" + 3 + 5); ergibt 735

final und Inkrement/Dekrement (S. 250)

Verboten, da Variablen geändert würden. Gerne versteckt!

&& und || nur auf Booleschen Feldern (S. 254)

&& und || dürfen nicht auf Zahlen angewandt werden. Compilefehler.

Syntax switch (S. 280)

Auf korrekte Sytax achten, bspw. : hinter case oder fehlendes case.

Switch und default (S. 284)

default muss nicht am Ende stehen. Wenn kein passendes case wird es ausgewählt, ohne break auch die folgenden.

if, while, do, for (S. 287)

Auf korrekte Boolesche Bedingung achten. Von Zuweisung unterscheiden.

Sichtbarkeit for (S. 291)

Im for-Block initialisierte Variablen sind nur in der Schleife sichtbar.

Continue und break (S. 294, S. 297)

  • continue immer in einer Shleife.
  • break in Schleife oder switch.
  • Labeled continue/break immer in der Schleife, die gelabelt ist

try ohne catch/finally (S. 303)

  • try ohne catch oder finally -> Compilefehler
  • catch direkt nach try
  • finally nach letztem catch oder try, wenn kein catch

Exceptions in main (S. 305)

  • main kann Exceptions werfen, dann Abbruch JVM
  • CheckedExceptions müssen auch in main deklariert werden

Exceptions (S. 313, 315)

  • Checked exceptions müssen deklariert und gefangen werden.
  • Unterklasse von Exception -> Checked Exception

Array-length (S. 350)

  • Arrays haben ein Attribut length
  • Strings eine Methode .length()
  • Listen haben Methode .size()

StringBuilder (S. 353, 355)

  • Diverse Methoden, können mit Initialwert, leer oder Länge konstruiert werden
  • Nicht wie Strings immutable, Methoden ändern Inhalt.

Chained methods (S. 356)

Aufpassen, wenn keine Rückgabe. Ggf. neue Objekte erzeugt, die von GC aufgegriffen werden können.

Calendar (S. 359)

Keine Konstruktoren, immer Factory-Methoden!

Objekte auf Heap (S. 366)

  • Nachdenken
  • Strings je nach Erzeugungsart

ArrayIndex (S. 369. 374)

  • Auf OutOfBounds achten. Initialisierung 1-based, Zugriff 0-based
  • Bei anonymer Initialisierung darf nie die Größe angegeben werden

Array-Zuweisung und Hierarchie (S. 377)

  • Illegal: Zuweisung von Car[] zu Honda[]

Listen und Primitive (S. 382)

List.add(5) weist Integer 5 zu.

Wrapper-Konstruktoren (S. 386)

Bis auf Character immer Variante String und primitiver Typ. Character nur char.

Wrapper und null (S. 388)

NullPointer bei Primitiven möglich, wenn Wrapper im Spiel sind. (Im Moment des Unboxing)