¡GoConqr estrena diseño! Cuéntanos qué te parece.

Regístrate gratis

Fichas

Programmierung

So Li Informatik Alemán 174 fichas

Fichas del conjunto (174)

  1. 1CompilerÜbersetzt Befehle in Maschinenbefehle
  2. 2COMPILER VORTEILE- Hohe Ausführungsgeschwindigkeit der Programme,
    - Optimale Nutzung der Prozessoreigenschaften,
    - Quellcode gut geschützt
  3. 3Compiler Nachteile• Langwieriger Übersetzungsvorgang
    • Programme auf Zielrechner spezialisiert
    • Zusätzlicher Aufwand für Anpassungen
    • Verschiedene Compiler notwendig (Mac, Windows)
  4. 4Interpreter Vorteile• KEIN LANGWIERIGER ÜBERSETZUNGSVORGANG
    • QUELLCODE DIREKT AUSFÜHRBAR, WENN INTERPRETER VERFÜGBAR
  5. 5Interpreter Nachteile• Langsame Ausführung
    • Quellcode lesbar
    • Verschiedene Interpreter notwendig
  6. 6InterpreterSchritt für Schritt unmittelbare Ausführung
  7. 7Java: Mischung Compiler Interpreter Vorteile• Nur ein Compiler
    • Sprache ist Plattformunabhängig
    • Quellcode teilweise geschützt
  8. 8Java: Mischung Compiler Interpreter Nachteile• Langsame Ausführung
    • Verschiedene Interpreter notwendig
  9. 9Variable- Platzhalter für Wert eines bestimmten Typs
    - Mit Adresse im Hauptspeicher assoziiert
    z.B. x
  10. 10Deklaration- Erwähnen der Variable
    - Typfestlegung der Variable
    dadurch wird festgelegt:
    - Art der Operationen
    - Speicherplatzbedarf
    - Werte des Speicherinhalts
    z.B. double x;
  11. 11Zuweisung- Weist einer Variable einen Wert zu: mit Zuweisungsoperator "="
    - x = Wert einer Zahl
    int i = 10; i%10 ; i = 0;
    Bedingungen verändern auch die Variable
  12. 12DatentypBauplan für Werte von Variablen oder Konstanten, der festlegt:
    • Wie die Darstellung der Werte im Speicher erfolgt
    • Welche Operationen erlaubt sind
    • Welche Standardwerte (Default-Werte) festgelegt sind
  13. 13AusdruckKombination von Operanden und Operatoren als Vorschrift zur Berechnung eines Wertes
    - Liefert immer Ergebnis
  14. 14OperandKonstante: 1
    Variable: x
  15. 15Operator=
    /
    *
  16. 16Anweisung- Kombination von Ausdrücken und Methoden zur Ausführung einer Aktion
    - x = 5: Wertzuweisung
    - Print(x): Ausgabeanweisung: Methodenaufruf „Drucke x“
    () Argumentklammer
  17. 17Anweisungs-Sequenz:mehrere Anweisungen, die nacheinander ausgeführt werden
  18. 18Anweisungs-Block:logisch zusammengefasste Anweisungen oder Programmteile, die als eine Anweisung aufgefasst werden können
  19. 19Bedingte Anweisung / Entscheidungsanweisung:Anweisung mit mehreren Alternativen
  20. 20Wiederholungsanweisung / Schleife:mehrfach ausgeführter Anweisungsteil
  21. 21Java-Programm ausführen1. Editieren:
    Programmtext erstellen;
    in einer Datei speichern: notepad Kehrwert.java
    2. Übersetzen in Java-Bytecode: Compiler
    javac Kehrwert.java -> dabei entsteht gleichnamige Datei mit Endung .class
    3. Bytecode Ausführen mit Interpreter:
    Java Kehrwert
  22. 22C-Programm ausführen1. Editieren:
    Programmtext erstellen;
    in einer Datei speichern: nano kehrwert.c
    2. Übersetzen in Maschinencode:
    Programmtext mit Compiler in Maschinencode übersetzen
    gcc –o kehrwert kehrwert.c //ausführbare Datei kehrwert entsteht
    3. Ausführen:
    ./kehrwert
  23. 23GrammatikDer Compiler übersetzt nur korrekte Java-Programme
    Die Korrektheit wird anhand der Grammatik überprüft
  24. 24Grammatik, festgelegt durch:1. Alphabet:
    erlaubter Zeichenvorrat
    2. Syntax:
    zulässige Zeichenfolgen
    3. Semantik:
    Bedeutung & Bezeichnung zwischen Sprachelementen, die die Bedeutung des Programms festlegen
  25. 25Der Compiler...1. Scannt zunächst die Zeichenfolge
    2. Sucht Gruppen von Zeichen, indem nach Trennern gesucht wird
    3. Zeichen zwischen zwei Trennern sind lexikalische Elemente (Token)  Wort der Sprache
    Trenner: Whitespace, Kommentare, Satzzeichen, Operatoren
  26. 26Bezeichner: Lexikalische Elemente (Tokens)beliebig lange Zeichenfolge, beginnend mit Buchstaben
  27. 27Keywords: Lexikalische Elemente (Tokens)reservierte Wörter mit vordefinierter Bedeutung
    -> können kein Bezeichner sein
    Abstract, new, return, if, static, this, long
  28. 28Literale: Lexikalische Elemente (Tokens)repräsentieren konstante Werte von Datentypen
    Int, float, true, false, ‚char‘, „String“, Nullreferenz
  29. 29Satzzeichen: Lexikalische Elemente (Tokens). , ; )( }{][
  30. 30Operatoren: Lexikalische Elemente (Tokens)(Trenner und Token)
    + && >>>
  31. 318 Goldene Regeln:1. 1 Anweisung pro Zeile
    2. Blöcke einrücken
    3. } stehen alleine in ihrer Zeile & in der gleichen Spalte
    4. switch-Blöcke gut formatiert
    5. Klassennamen beginnen groß
    6. Variablen und Methoden klein am Anfang
    7. Konstanten komplett GROSS_GESCHRIEBEN public static final int GROSS = 10;
    8. eine Return-Anweisung pro Funktion (Methode mit Rückgabetyp)
  32. 32Einfache (elementare) Datentypen = Primitive Datentypen:o Boolean, nummerische ganzzahlige Typen (byte, short, int, long), Gleitkommatypen, char
  33. 33Referenztypen:o Klassen, Interfaces, Felder
  34. 34bytebyte 8 Bit -128 127 0
  35. 35shortshort 16 Bit -32768 32767 0
  36. 36intint 32 Bit
    -2147483648 2147483647
    0
  37. 37longlong 64 Bit -9223372036854775808 9223372036854775807
    L 0L
  38. 38floatfloat 32 Bit
    1.4E-45 3.40282347E38
    f 0.0F
  39. 39doubledouble 64 Bit 1.7976931348623157E308 4.9E-324
    1.3E7d 0.0D
  40. 40booleanboolean 8 Bit
    false true
    false
  41. 41charchar 16 Bit
    0 6553
    \u0000
  42. 42Typumwandlung Problemevon unten nach oben immer Datenverlust
    int = long
    int = float
    long = double
    float = double
  43. 43Einstellige Operatorenmonadische, unäre
    ++
    beziehen sich auf einen einzelnen Operanden
  44. 44Zweistellige Operatorendyadische, binäre Operatoren
    *, &&,<
  45. 45Dreistellige Operatorentriadische, ternäre Operatoren
    ?:
  46. 46Präfix-Notation:-a
  47. 47Postfix-Notation:n++
  48. 48Infix-Notation:a+b
    oder
    max = (a>b) ?a : b;
  49. 49int i = 0; feld[++i + i++] = i++ + ++i;feld[2] = 2+4;
  50. 50true & truetrue
  51. 51false & truefalse
  52. 52true && falsefalse
  53. 53false && truefalse && egal
    false
  54. 54true | true= true
  55. 55false | true= true
  56. 56true || falsetrue || egal = true
  57. 57false || true= true
  58. 58true ^ false= true
  59. 59true ^ true= false
  60. 60false ^ true= true
  61. 61false ^ false= false
  62. 62a=-55; ~a; a=?a = -55;
    ~a = 54
  63. 63a << b:Schiebt die Bits in a um b Stellen nach links
    i = 2<<3 ; 2*23= 16
  64. 64a>>b:Schiebt die Bits in a um b Stellen nach rechts
    füllt mit dem höchsten Bit von a auf
  65. 65a>>>b:o Schiebt die Bits in a um b Stellen nach rechts
    o füllt mit 0-Bits auf
  66. 66Auswertungsreihenfolge in AusdrückenEinstellig ++ vor multiplikativ * vor additiv + vor vergleichend < vor logisch & vor zuweisend =
    ++ * + > < &| =
  67. 67Switch-Ausdruck verbotene Datentypenlong, float, double, boolean
  68. 68Switch- Werte sind konstant
    - break & default (nur wenn Wert davor nicht vordefiniert) nicht vergessen
  69. 69Switch Codeswitch (){
    case : break;
    case : break;
    default: break; //optional
    }
  70. 70while-Schleife:o der Schleifenkörper wird solange ausgeführt, wie die Bedingung wahr ist
    o ist die Bedingung falsch, wird die Schleife verlassen
    o wenn man eine while-Schleife unterbrechen möchte, z.B. if(x==10) break;
  71. 71do-while-Schleife:o Der Schleifenkörper wird einmal abgearbeitet, erst danach wird die Bedingung geprüft.
    o Bei positivem Test, wird die Schleife durchlaufen, bei negativem beendet
  72. 72Syntax Bestandteile der for schleife:for-Schleife
    Syntax Bestandteile der for schleife:
    for (Initialisierungsliste; Logischer Ausdruck; Update-Liste) {
    Anweisung bzw. Block mit Anweisungsfolge
    }
  73. 73break- break: Wenn man einer Schleife raus möchte, z.B. if(x==10) break;
  74. 74continue:- continue: beendet den aktuellen Durchlauf der Schleife und man gelangt wieder in den Schleifenkopf (bei for wird dadurch iteriert )
  75. 75int [ ] iv; was wird hier gespeichert?dort wird die Adresse abgespeichert, in der der Inhalt vom Feld gespeichert wird.
    Hier steht noch null drinnen
  76. 76int [ ] iv = new int [3]; was wird hier gespeichert?- Im Speicher wird Platz für 3 Variablen gesucht
    - Die Speicheradresse der 3 Variablen wird als Referenz im Array gespeichert
  77. 77Gleichheit zwei einfacher Datentypenwenn gilt (b == a)
  78. 78Gleichheit zweier Referenzdatentypenwenn sie auf die gleiche Referenz zeigen (r==s)
  79. 79Dynamische Array Allokationdouble[ ] x = new double[3];
  80. 80Fachwörter dafür: double[] x = new double[3];[] = new [];
    = Typ oder Klasse
    = Feldlänge; Feldelemente von 0 bis -1
  81. 81Statische Array Allokationdouble[ ] y = {3.0, 6.0,9.0};
  82. 82Was passiert, wenn man die Array-Größe verändert?- die Referenz wird auf ein neues Array gelegt
    - die Informationen des alten Arrays sind nicht mehr zugreifbar -> Garbage-Collector
  83. 83Array Fehler• fehlende Initialisierung durch new oder Werte
    • System.out.println (feldname); -> hier bekommt man die Speicheradresse
    • Bei Schleifen immer feld.length -1
    • Länge kann nur ganzzahlig sein
    • Beim Initialisieren müssen immer die gleiche Anzahl von Klammern rechts und links stehen
    • Bei mehrdimensionalen Feldern, müssen immer zuerst die ersten Dimensionen initialisiert werden
    o int [] [] [] big = new int [] [] [2];
  84. 84Was passiert? int[ ] f1 = new int[2]; int[ ] f2 = new int[5]; f2 = f1;Referenzkopie:
    - f2 hat nun die gleiche Referenz wie f1
    - f2.length = 2
    - Eine Veränderung von f2 bewirkt eine Veränderung von f1
  85. 85Flache Kopie:o Die erste Ebene einer Struktur wird dupliziert
    o Die hinteren Referenzen werden kopiert
    o Änderung der ersten Ebene von f2 wirkt sich nicht auf f1 aus
    o f2 = f1.clone();
  86. 86Tiefe KopieTiefe Kopie = Clonen
    o Die komplette Struktur wird dupliziert
    o f2 ist völlig unabhängig von f1
  87. 87Klassen:- selbstdefinierte Baupläne für einen Datentyp
    - zum Erzeugen von Objekten,
    die aus mehreren Komponenten unterschiedlicher Typen entstehen
    - sind Referenzdatentypen
  88. 88Klassen SyntaxModifizierer-Folge class Bezeichner {
    public class Datum {
    Modifizierer-Folge kann entfallen
    }
  89. 89Wo können Klassen deklariert werden?- Innerhalb einer Klasse geschachtelt
    o inner classes: non static
    o nested classes: static
    - Außerhalb einer Klasse, in eigenständiger Datei (bevorzugt)
    - Außerhalb der Klasse, in gleicher Datei
  90. 90Nachteile geschachtelter Klasseno unübersichtliche Dateistruktur
    o größerer Programmtext
    o Schwere Korrektur
    -> lieber als Elementklasse/Top-Level-Klasse auslagern
  91. 91Zugriffs-Modifizierer:+ public: Zugriff für alle Klassen
    - private: Zugriff nur innerhalb der Klasse
    # protected: Zugriff für vererbte Klassen + Paket
    ~ package: default „package-private“ Zugriff für alle Klassen des Pakets
  92. 92Wie kann man private Variablen erfragen?public String getName() {
    return this.name;
    }
    System.out.println(charly.getName());
  93. 93Instanzvariablen• stehen nicht in einer Methode, nur in einer Klasse
    • beim Erzeugen eines Objekts dieser Klasse werden
    • diese Variablen automatisch miterzeugt und können individuell belegt werden
    Zugriff: .
  94. 94Klassenvariablen:static: Kennzeichnung von Komponenten, die genau einmal erzeugt werden (Beim Laden der Klasse)
    - Diese Komponenten haben für jedes Objekt der Klasse den selben Wert
    Beispiel: Wechselkurs Euro in Dollar
    Zugriff: . (auch über Objektreferenz möglich)
  95. 95Konstruktor Aufgabeo Objekterzeugung mit Startwerten
    • statt drei nur ein Befehl
    o Initialisierungsarbeiten
    o Das Bilden von Objekten
    z.B. Belegen von Instanzvariablen mit den Werten vom Benutzer
  96. 96Konstruktor Codepublic class Sudent {
    String name;
    Student (String name) {
    this.name = name;
    }}
    Student charly = new Student("Charly");
  97. 97Instanzmethode:• Methode ohne static, die zu einem Objekt gehört (einer Klasseninstanz)
    public String toString() {
    return "Student " + this.name; }
    System.out.println(charly.toString());
  98. 98Klassenmethoden:- statische Methoden haben nur Zugriff auf statische Variablen
    (Instanzvariablen brauchen ein Objekt objekt.variablenname)
    - Klassenvariablen brauchen kein Objekt
  99. 99Prozeduren & FunktionenProzeduren: liefern keinen Rückgabewert
    Funktionen liefern einen Rückgabewert
  100. 100Methodeneigenschaften4 Eigenschaften
    1. Unterprogramm
    2. Über Methodenaufruf ausführbar
    3. Können Parameter/Argumente übergeben bekommen
    4. Können Rückgabewert zurückliefern
  101. 101Bedeutung von Methoden3 Bedeutungen
    1. Strukturieren das Programm
    2. Reduzieren den Programmieraufwand
    3. Leichtere Anpassbarkeit von Programmen
  102. 102Vorteile von Methoden8 Vorteile von Methoden
    1. Wiederverwendung von Code
    2. Erleichtern das Testen des Programms
    3. Jede Methode kann / sollte vor Gebrauch getestet werden
    4. Können leichter geändert werden
    5. Definierter Zugriff auf gekapselte Daten ist durch Methoden möglich (getter,setter)
    6. Methoden unterstützen: Generalisierung, Vererbung, Kapselung, Polymorphie
    7. Erleichtern Rekursion und damit Divide&Conquer und das Top-Down-Prinzip
    (schrittweise Verfeinerung)
    8. Unterstützung des Paradigmas der modularen Programmierung
  103. 103Zusammenfassungen von Methoden6 Zusammenfassungen von Methoden
    1. Zusammenfassung von Code unter einem Namen
    2. Kann unter Verwendung von Parametern formuliert sein
    3. Übergabe der Parameter ist Pass/Call-by-Value
    4. Methoden -> Modularisierung: eigenständige Einheiten mit Teilaufgaben
    5. Wiederverwendbarkeit: sollte nur eine einzelne, wohldefinierte Aufgabe haben
    6. Wenn 5 nicht funktioniert, sollte man Methode in kleinere Stücke zerlegen
  104. 104Divide & Conquer – VerfahrenDivide: Problem in möglichst viel gleichgroße Teilprobleme derselben Art wie das
    Originalproblem aufspalten, die dann unabhängig gelöst werden
    Conquer: Die Lösung der Teilprobleme werden zu einer Lösung des Gesamtproblems zusammengefügt
  105. 105Top-Down-Prinzipin der modularen Programmierung Gang und Gäbe
    - Bei jedem Entwurfsschritt wird festgelegt, was die Untermodule leisten sollen, nicht aber WIE sie es leisten sollen
  106. 106Modulare ProgrammierungModul in der Praxis wird als ein in sich zusammenhängender Baustein aufgefasst, der folgende Eigenschaften besitzen sollte:
    - Logisch oder funktional abgeschlossen
    - Information hiding: wie er arbeitet oder implementiert ist, braucht außen nicht bekannt zu sein
    - Klar definierte Schnittstellen nach außen
    - Überschaubar und leicht testbar
    - Sollte möglichst wenig andere Module verwenden
  107. 107Softwaremodulabgeschlossene Programmeinheit aus
    - Konstanten, Variablen, Datentypen, Operationen
    die genau definierten Funktionen ausführen und bestimmte Eigenschaften besitzen
  108. 108System ist modular, wennEs aus abgrenzbaren Einheiten zusammengesetzt ist
    o Diese Einheiten einzeln ausgetauscht verändert oder hinzugefügt werden können
    o Ohne, dass andere Teile des Systems beeinflusst werden
  109. 109Call-by-Value / Pass-by-Value- Die Parameter werden nicht verändert
    - Außer es ist eine Referenz  Veränderungen möglich
  110. 110MethodensyntaxModifizierer Ergebnistyp Bezeichner (Formale Parameter){
    Methoden-Rumpf
    Ausführungsende/Rückgabe des Wertes
    }
  111. 111Sichtbarkeit und Verdecken von VariablenInnerhalb von Methoden verdecken lokale Variablen und formale
    Variablen (übergebene) die Klassenvariablen
  112. 112Klassenmethode- static
    main:
    MeineKlasse.derenMethode(x);
  113. 113Instanzmethodekein static
    main:
    MeineKlasse objName= new MeineKlasse();
    objName.zuveränderndevariable=7;
  114. 114Überladen- Variablen dürfen nicht denselben Namen haben
    - Methoden dürfen gleichen Namen haben, aber brauchen unterschiedliche Signatur
    - Unterscheidung der überladenen Methoden anhand der Signatur:
    o Name der Methode
    o Anzahl der Parameter
    o Datentyp der Parameter
    o Reihenfolge der Parameter
    - Es wird immer die spezifischste aufgerufen
  115. 115Iteration- Problem wird durch die wiederholte Anwendung desgleichen Verfahrensschritt gelöst
    - Jeder Iterationsschritt liefert Ergebnisse, die im nächsten Schritt wiederverwendet werden
    - Abbruch, wenn die Abbruchbedingung erfüllt wird
  116. 116Rekursion- Problem wird durch Zurückführen auf einfacheres Problem gelöst
    - greift auf sich selbst zurück
    - Wichtig:
    o Rekursionen müssen abbrechen
    o ein oder mehrere Fälle müssen gesondert behandelt werden
    - direkt: Im Rumpf der Methode m steht der Aufruf für Methode m
    - indirekt: Im Rumpf der Methode m steht der Aufruf für Methode a, in Methode a steht der Aufruf für Methode b; in Methode b steht der Aufruf für Methode m
    - Vorteil: elegant und kurz für viele Problemstellungen
    - Nachteil: Manchmal ineffizient (Fibonacci)
  117. 117Fakultätsberechnung iterativstatic long fak(long n){
    long fa = 1;
    for (long i = 1; i<=n; i++){
    fa = fa * i;
    return fa;
    }
  118. 118Fakultätsberechnung rekursivstatic long fak (long n){
    if (n==0)
    return 1;
    else
    return n * fak(n-1);
    }
  119. 1193 Motivationsgründe für OOP1. Grafische Benutzeroberflächen: Bedarf vervielfacht sicht
    2. Kosten für Wartung sind zu hoch; dauert zu lange -> 70% der Gesamtkosten entstehen durch die Softwarewartung
    3. Softwarekrise: Imageschaden
  120. 120Paradigmen= Denkmuster/Philosophie, wie ein Programm auf dem Rechner verfasst werden sollte
    • Funktionales Programmieren
    o Gofer, Lisp
    • Imperatives Programmieren
    o C, Pascal, Basic
    • Prozedurales Programmieren
    o Funktionalität realisieren
    o m(a)
  121. 121Objektorientiertes Programmiereno a.m()
    o Java, C++
    o Modell des Systems realisieren
    o Grundsatz: Spiegelt ein Teil der Welt wider; Objekte sollten daher abgebildet werden können
    o Klasse dient als Bauplan (abstrakter Datentyp) und repräsentiert Eigenschaften eines Objekts
    o Objekt einer Klasse erzeugen -> Instanziierung
  122. 1224 Grundprinzipien1. Abstraktion
    2. Kapselung
    3. Vererbung
    4. Polymorphismus
    -> Entwicklungszeit sparen
    -> Fehlerquellen reduzieren
  123. 123Abstraktion/Generalisierung:• Zusammenfassung von Klassen mit gleichen Merkmalen zu Oberklasse
    • ist-ein Säugetier
    Ziele:
    1. Hierarchie mit verschiedenen Beziehungen, wie in der Realität
    -> Superklasse und Subklasse
    2. Gemeinsame Eigenschaften einheitlich modellieren
  124. 124Kapselung:• Daten und Methoden fest an ihr Objekt binden
    • Leichtere Umstrukturierung der Klasse
    • Trennung von Schnittstelle (nach außen sichtbare Methode) und interne Realisierung:
     information hiding: Daten werden vor direkten Zugriffen geschützt
    o private, public, protected…
    o dennoch getter und setter
  125. 125Vererbung• Weiterreichen von Eigenschaften an Subklassen (extends)
    • Ziele:
    1. gemeinsame Eigenschaften einheitlich modellieren
    2. viel Programmcode wiederverwenden
    • Wenn man nicht weiß, welchen Rückgabewert eine Oberklasse hat z.B. die Klasse Währung kann kein Geld zurückgeben und sie ist nicht konkretisiert wie € oder $
    Übergang zum Polymorphismus
    -> abstrakt:
  126. 126abstrakte Klasseno Definition einer Schnittstelle:
    Array eines Objekts der abstrakten Klasse ist füllbar mit den verschiedenen Subklassen
    o es werden keine Methoden ausformuliert { } ; -> Objekte daraus zu bilden ist daher nicht möglich
    erst in Subklasse wird durch Override die Methode mit Methodenrumpf überschrieben {};
  127. 127Polymorphismus:• Individualisieren -> Override ->
    • Individuelle Ausprägung verschiedener Objektklassen unter der einheitlichen Schnittstelle der Superklasse
    • Mutterklasse: Währung; Kindklasse: USDollar
    • geht: Waehrung quarter = new USDollar(0.25);
    • Ziele:
    1. Besonderheiten bei Subklassen berücksichtigen
    2. einheitliche Schnittstellen erzeugen
  128. 128Typumwandlung:wenn es sich bei einem übergegebenen Objekt um einen bestimmten Typ handelt, dann soll etwas gemacht werden
    public static void klaeff(Hund obj){
    if(obj instanceof Bernhardiner){
    Bernhardiner berni = (Bernhardiner) obj;
    berni.jaul();
    Variablenname = (Klasse) Objektname;
  129. 129Warum Typecast• Elementtyp einer Collection kann nicht spezifiziert werden
    • daher beim Zugriff immer Typecast zur Klasse
    • Dadurch überprüft Compiler, ob mit den Typen alles in Ordnung ist
  130. 130Variablen überschreibenPolymorphismus gilt nicht für Variablen (Verdeckung ist möglich)
    Superklasse gewandelt = (Superklasse) sub;
    gewandelt = Objekt sub + Instanz Superklasse
    sout(gewandelt) = sub weil toString Methodenaufruf
    sout(gewandelt.name) = Super weil Variablenname
  131. 131Klasse ObjectObject – Mutter aller Klassen
    • java.lang.Object
    • steht über allen Klassen  jede Klasse erbt automatisch z.B. toString-Methode, Hashtabelle
  132. 132Interfaces implements• Warum? In Java kann nur von einer Klasse geerbt werden
    • Beispiel: Firmenvermögen = Bargeld + Immobilien + Aktien: Wertgegenstände haben unterschiedliche Eigenschaften daher schwer in einer allgemeinen Klasse zu definieren -> Alle Objekte, die das Interface implementieren können als Wertgegenstände aufgefasst werden
    • Unterschied zu abstrakten Klassen: Die Methoden im Interface müssen alle abstrakt sein ();
    • Mehrfachvererbung erlaubt
  133. 133Hilfs-/Hüllklasse String1. Alle Zeichenketten-Literale z.B. „abc“ sind Instanzen der Klasse String
    2. Werte eines Strings sind konstant und können nicht mehr verändert werden
    3. -> Änderung = neues Objekt
  134. 134Verschiedene Möglichkeiten ein String zu erzeugenString s1 = "abc";
    String s2 = new String("abc");
    char[] a = {'a', 'b', 'c');
    String s3 = new String(a);
    byte[ ] b= {97,98,99);
    String s4 = new String(b);
    String s5 = new String (s4);
  135. 1355. Methoden der Klasse String:o Zugriff auf einzelne Zeichen der Zeichenkette
    indexOf(„n“); charAt(4);
    o Vergleich von Zeichenketten compareTo; equals
    o Suchen von Teil-Zeichenketten
    substring(3); (ab dem 3. Buchstaben)
    o Herausgreifen von Teil-Zeichenketten
    replace(‚e‘,‘E‘);
    o Wandeln von Groß- in Kleinbuchstaben und umgekehrt
    toLowerCase(); toUpperCase();
    o Aneinanderhängen mehrerer Strings +
  136. 136StringBuffer (veränderbare Zeichenketten)• StringBuffer x = new StringBuffer();
    • x = new StringBuffer(“start“).append(“s“).insert(4,“le“);
    o start + s = starts
    o 4. Stelle le einfügen star__ts
    • x = „starlets“
  137. 137Hüllklassen(wrapper classes)• Listen sind z.B. nicht für primitive Datentypen erlaubt, daher verwende ich die Klasse davon: Integer, Float … und muss davon ein neues Objekt erstellen
    o Integer x = new Integer(10); // Einpacken
    o x.intValue();  10 (int) // Auspacken
  138. 138Hüllklassen(wrapper classes) Methoden• Double valueOf(String s){…}: String -> Double-Objekt
    • double doubleValue() {…}: Double-Objekt-> double-Wert
    • double parseDouble (String s) {…}: String -> double-Wert
    • double x = Double.valueOf(„12.345“).doubleValue(); entspricht
    • double x =Double.parseDouble(„12.345“);
  139. 139C++ KlassenKlassen:
    • können verwendet werden
    • Methoden können auch außerhalb einer Klasse auftreten
  140. 140C++ Vorwärtsdeklaration:• man kann keine Variable aufrufen, die zuvor nicht deklariert worden ist  zyklische Aufrufe sind unmöglich
    -> Methodenordnung ist schwierig
    • Lösung: Header-Datei pro Klasse zum Deklarieren der Variablen
  141. 141C++ Header-DateienHeader-Dateien (.h)
    enthalten:
    • Deklarationen von Funktion, Datenstrukturen und Klassen
    • Attributen und Methoden
    • private / public Modifizierer können für ganze Blöcke verwendet werden
  142. 142C++ Source-DateienSource-Dateien (.cpp)
    • Implementierung der Methoden
    • Können auf Variablen des Headers zugreifen
    • :: zeigt Zugehörigkeit zur Klasse
  143. 143C++ Objekte:Objekte:
    • können direkt deklariert und angesprochen werden
    • Objekte werden wie einfache Datentypen behandelt
    • Variablen von Objekten sind keine Referenzen oder Pointer, sondern wirklich das Objekt selbst
    • Ansprechen durch Punktnotation
    • -> Wenn man einen Pointer auf ein Objekt oder struct hat
    • ptr -> y == (*ptr).y;
  144. 144C++ Speicherverwaltung• Stack:
    o Objekt-Deklaration
    o Objekte sind nur für Code-Block instanziiert
    • Heap:
    o Allokation mit malloc() und free()
    • new:
    o Allokiert Speicher
    o führt Konstruktor aus
    o liefert Pointer zurück
    • delete:
    o Deallokiert Speicher des Objekts
    o führt Destruktor aus
    o räumt Speicher im Heap auf
  145. 145Enumeration• gewisse Menge an aufgelisteten KONSTANTEN Werten
    • Klassentyp
    • Jeder deklarierte Wert ist eine eigene Instanz der enum-Klasse
    o public, static, final
    • Vergleich durch equals und ==
    • Enums sind sortierbar
  146. 146Enum Vorteile1. Liefert Typsicherheit zur Compile-Zeit
    2. Lesbare Namen für ihre Zustände
    3. Robust (hinzufügen etc. von Konstanten erfordert Rekompilierung)
    4. Können zu Collections hinzugefügt werden, weil es Objekte sind
    5. Können auch Attribute und Methoden enthalten, weil es Klassen sind
  147. 147Enum Methoden• String toString()
    o gibt Name des Enum-Objektes als Konstante zurück
    • boolean equals (Object other)
    o vergleicht die enum-Konstanten
    • int compareTo (E o)
    o Ordnung zum sortieren -1, 0, 1
    • static enum-type valueOf (String s)
    o gibt das Enum Objekt mit dem Namen s zurück
    • static enum-type[] values()
    o gibt ein Array der Enum-Objekte zurück
  148. 148Array Eigenschafteno Eigenschaften:
    • Lineare Folge fester Größe
    • length-Attribut
    • enthält primitive Datentypen oder Referenzen auf Objekte
    • Nur Objekte eines Typs
  149. 149Array Vorteile• sehr effizient
    • Typüberprüfung zur Compile-Zeit
  150. 150Array Nachteile• Feste Größe
    • Nur ein Typ
    • Wenig Methoden
    Wegen der Nachteile gibt es Container
  151. 151Was sind Container?= Objekt, das eine Sammlung von Referenzen auf andere Objekte enthält
  152. 152Zwei Konzepte von Containern• Collection Interface
    o Enthält einzelne Objekte
    o ( Set, ArrayList, LinkedList)
    o Die Verwendung generischer Interfaces erleichtert den Austausch von z.B. ArrayList zu LinkedList
    • Map: Interface
    o Schlüssel-Wert Paare
    o Ein Schlüssel darf nur einmal vorkommen
    o HashMap, HashTable
  153. 153Container Eigenschaften1. Können Verschiedene Typen beinhalten
    2. Keine feste Größe -> automatische Größenanpassung
    3. Enthalten nur Referenzen auf Objekte
    4. Keine primitiven Typen
  154. 154Container Methoden• add (Object o)
    • remove (int index)
    • size()
    • get(int index)
    • put(Object key, Object value) //Map
  155. 155Iteratoren:• besser als get, da eine get Iteration immer von vorne anfängt
    • boolean hasNext()
    • Object next()
    Iterator e = songs.iterator();
    return ((Song) e.next()),toString();
  156. 156Iteratoren Nachteile• Weniger effizient als Arrays
    • manuelle Typumwandlung notwendig, da keine Typüberprüfung
  157. 157GenericsGenerische Programmierung
    = Programmierung von Klassen und Methoden mit parametrisierten Typen
    • Werkzeug zur Erstellung wiederverwendbarer objektorientierter Typen und Bibliotheken
    • Generische Methoden können in normalen und generischen Klassen definiert werden
    • beim Aufruf kann der Typ spezifiziert werden
  158. 158Vorteile Generics• Mehr Sicherheit und Lesbarkeit
    • Keine sichtbaren Typecasts
    • für allgemeine Datenstrukturen nützlich
    • Frühe Compile-Zeit Erkennung von Typverletzung
    (Kein String einfügen in ArrayList)
  159. 159Dokumentation• Code ist für den Menschen geschrieben, daher sollte man ihn auch nach längerer Zeit noch verstehen
    • javadoc: Code und Dokumentation in einer Datei
    • @param, @return erzeugt HTML Dokumentation
  160. 160Compilerfehler:o z.B. System.outprint Punkt vergessen  Fehlermeldung + Interpretieren nicht möglich
    o ausführen ist nicht möglich, man merkt aber schnell, wenn etwas falsch ist
  161. 161Exceptions• Exception = Ausnahmesituation
    • hilft beim Verstehen von Problemen, statt es nur abstürzen zu lassen
    • Abfangen (catching) einer Exception durch try and catch
    • Beim Abfangen auf Hierarchie achten
  162. 162Exceptions Hierarchie1. Throwable
    2. Exception + Error
    3. RuntimeException
    4. NullPointerException
  163. 163Skriptsprachen• Python
    • Keine Kompilierung
    • Nur Zeile für Zeile interpretieren
    • Sobald ein Fehler auftaucht, wird an dieser Stelle abgebrochen
  164. 164Iterator – Erweiterung• kann auch durch Doppelpunktnotation ersetzt werden
    • for each: Für jeden String song aus songs
    for (String song:songs)
  165. 165Programmierparadigmen- Imperativ
    - Deklarativ
    - Prozedural
    - Objektorientiert
    - Ereignisorientiert
    - Logisch
    - Funktional
  166. 166Imperativ1. Abfolge von Befehlen, die Computer in Reihenfolge auszuführen hat
    2. Compiler übersetzt Befehle in Maschinenbefehle
    o vergleichbar mit Möbelbau-Anleitung
    o Sprachen: Java, C, Assembler
  167. 167Deklarativ1. Nicht der Weg zum Ziel, sondern WAS? ist das Ziel
    2. Menge von Definitionen, Relationen und Regeln
    3. Befehle sind aus Relationen und Regeln extrahierbar
    o Vergleichbar mit mathematischen
  168. 168Prozedurale ProgrammierungImperative Programmiersprachen beinhalten prozeduralen Ansatz
    1. Anweisungsfolgen in Teilfolgen (Prozeduren) zerlegen
    2. Prozeduren sind nach Außen durch Schnittstellen definiert
    3. Prozeduren können sich untereinander aufrufen
    o z.B.: Fortan, C, COBOL
  169. 169Objektorientierte Programmierung1. Objekte instanziieren Objekt-Templates (Klassen)
    2. Objekte haben Eigenschaften (Attribute) und können Aktionen (Methoden) ausführen
    3. Objekte zur Modularisierung vom Code
    4. Methoden oft nach prozeduralen Paradigmen definiert
    o Java, C#, C++
  170. 170Ereignisorientierte Programmierung1. kein linearer Vorgang (parallel)
    2. Ereignisbehandlungsroutinen werden ausgeführt, wenn ein bestimmtes Ereignis auftritt
    3. Routinen können andere Ereignisse auslösen
    o gut mit objektorientierten Sprachen vereinbar
    o Typische Anwendung bei GUI-Programmierung
    o Sprachen: Visual Basic, Pascal
  171. 171Logische Programmierung1. beruht auf mathematischer Logik
    2. Statt Anweisungsfolgen, Menge von Axiomen
    3. Lösung wird aus Fakten und Regeln hergeleitet
    o deklarative Programmiersprache
    o Was gilt, nicht wie
    o Sprache: Prolog
  172. 172Funktionale Programmierung1. deklarativ: ausschließlich mathematische Funktionen
    2. besteht aus Funktionsaufrufen
    3. Verbietet: Variablen, Schleifen, Objekte, Anweisungsfolgen
    4. Rekursion ist wichtig
    o Künstliche Intelligenz
    o Sprachen: Haskell, Erlang, Scala
  173. 173C Ein Student mit id Und name (vor- + nachname)struct student{
    int id;
    struct{char vorname [20];
    char nachname[20];
    } name;
    };
  174. 174C Stundent mit id oder name (vor- + nachname)union student {
    int id;
    struct{
    char vorname [20];
    char nachname [20];
    } name;
    };

Información

Descripción
Einführung in die Programmierung
Creado por
So Li
Visitas
81
Valoración

Escríbenos

¿Sobre qué es tu mensaje?

¿Qué te parece el nuevo diseño?

¿Te gusta?