|
|
| (2 dazwischenliegende Versionen desselben Benutzers werden nicht angezeigt) |
| Zeile 1: |
Zeile 1: |
| == Klassen und Objekte ==
| |
|
| |
| * Man kann sich eine Klasse als Fabrik vorstellen, die Objekte produziert
| |
| * Hier wird festgelegt, welche Eigenschaften und welches Verhalten ein Objekt hat
| |
| * Eine Klasse kann beliebig viele Objekte erzeugen
| |
| * Ein Objekt gehört jedoch immer zu genau einer Klasse
| |
|
| |
| Wenn man sich die Klasse als Fabrik vorstellt, so ist das daraus erzeugte Objekt etwas ganz Konkretes. Man nennt Objekte auch Instanzen.<br>
| |
| Nehmen wir beispielsweise die Klasse Auto.<br>
| |
| Konkrete Auto-Objekte sind: ein bestimmter Mercedes, ein bestimmter BMW.
| |
|
| |
| * Alle diese Objekte haben gewisse gemeinsame Merkmale, z. B. eine Marke, ein Baujahr etc.
| |
| * Diese Merkmale nennt man Attribute (Eigenschaften) eines Objekts.
| |
| * Ein Attribut besteht aus einem Namen und einem Wert.
| |
| * Objekte können außerdem Operationen ausführen. Man nennt diese Operationen Methoden.
| |
| * Methoden sind nichts anderes als Funktionen, die innerhalb einer Klasse definiert sind.
| |
|
| |
| Eine Klasse ist eine Vorlage (Bauplan) für Objekte. Ein Objekt ist eine Instanz dieser Klasse.
| |
|
| |
| <syntaxhighlight lang="java">
| |
| public class Auto {
| |
| String marke;
| |
| int baujahr;
| |
|
| |
| ```
| |
| public void starten() {
| |
| System.out.println("Motor startet");
| |
| }
| |
| ```
| |
|
| |
| } </syntaxhighlight>
| |
|
| |
| Objekterzeugung:
| |
|
| |
| <syntaxhighlight lang="java">
| |
| Auto meinAuto = new Auto();
| |
| meinAuto.marke = "VW";
| |
| meinAuto.baujahr = 2022;
| |
| meinAuto.starten();
| |
| </syntaxhighlight>
| |
|
| |
| [[Kategorie:Programmieren]]
| |
| [[Kategorie:Semester2]]
| |
|
| |
|
| |
| == Objektorientierte Programmierung (OOP) in Java == | | == Objektorientierte Programmierung (OOP) in Java == |
|
| |
|
| Die objektorientierte Programmierung ist ein Paradigma, das Programme auf Basis von '''Objekten''' strukturiert. Java ist eine vollständig objektorientierte Sprache (mit Ausnahme der primitiven Datentypen). | | Die objektorientierte Programmierung ist ein Paradigma, das Programme auf Basis von '''Objekten''' strukturiert. Java ist eine vollständig objektorientierte Sprache (mit Ausnahme der primitiven Datentypen). |
| Ein objektorientiertes Programm ist ein System von Objekten, die miteinander kommunizieren können. Wir haben schon mit Objekten gearbeitet, z. B. Scanner oder ArrayList. | | Ein objektorientiertes Programm ist ein System von Objekten, die miteinander kommunizieren können. Wir haben schon mit Objekten gearbeitet, z. B. Scanner oder ArrayList. |
|
| |
| Jetzt geht es darum, ''' eigene Klassen ''' zu definieren.
| |
|
| |
| === Klassen und Objekte ===
| |
|
| |
| * Man kann sich eine Klasse als Fabrik vorstellen, die Objekte produziert
| |
| *
| |
| * Hier wird festgelegt, welche Eigenschaften und welches Verhalten ein Objekt hat
| |
| *
| |
| * Eine Klasse kann beliebig viele Objekte erzeugen
| |
| *
| |
| * Ein Objekt gehört jedoch immer zu genau einer Klasse
| |
|
| |
| Wenn man sich die Klasse als Fabrik vorstellt, so ist das daraus erzeugte Objekt etwas ganz Konkretes. Man nennt Objekte auch
| |
| Instanzen.<br>
| |
| Nehmen wir beispielsweise die Klasse Auto. <br>
| |
| Konkrete Auto-Objekte sind: ein bestimmter Mercedes, ein bestimmter BMW.
| |
| * Alle diese Objekte haben gewisse gemeinsame Merkmale, z. B. eine Marke, ein Baujahr etc.
| |
| *
| |
| * Diese Merkmale nennt man Attribute (Eigenschaften) eines Objekts.
| |
| *
| |
| * Ein Attribut besteht aus einem Namen und einem Wert.
| |
| *
| |
| * Objekte können außerdem Operationen ausführen. Man nennt diese Operationen Methoden.
| |
| *
| |
| * Methoden sind nichts anderes als Funktionen, die innerhalb einer Klasse definiert sind.
| |
| *
| |
|
| |
| Eine Klasse ist eine Vorlage (Bauplan) für Objekte. Ein Objekt ist eine Instanz dieser Klasse.
| |
|
| |
| <syntaxhighlight lang="java">
| |
| public class Auto {
| |
| String marke;
| |
| int baujahr;
| |
|
| |
|
| |
| public void starten() {
| |
| System.out.println("Motor startet");
| |
| }
| |
|
| |
| } </syntaxhighlight>
| |
|
| |
| Objekterzeugung:
| |
|
| |
| <syntaxhighlight lang="java">
| |
| Auto meinAuto = new Auto();
| |
| meinAuto.marke = "VW";
| |
| meinAuto.baujahr = 2022;
| |
| meinAuto.starten();
| |
| </syntaxhighlight>
| |
|
| |
| === Attribute und Methoden ===
| |
|
| |
| * '''Attribute''' (Eigenschaften, Instanzvariablen): Eigenschaften eines Objekts
| |
| * '''Methoden''': Verhalten eines Objekts
| |
|
| |
| === Konstruktoren ===
| |
|
| |
| Ein Konstruktor initialisiert ein Objekt beim Erzeugen.
| |
| Wird ein neues Objekt mit '''new''' erzeugt und kein eigener Konstruktor programmiert, stellt Java Speicherplatz für die Instanzvariablen bereit und initialisiert diese mit 0, false oder null (je nach Datentyp).<br>
| |
|
| |
| * Die Initialisierung der Instanzvariablen übernimmt eine spezielle Methode, nämlich der Konstruktor.
| |
| *
| |
| * Programmieren Sie keinen eigenen Konstruktor erzeugt der Java-Compiler einen Defaultkonstruktor.
| |
| *
| |
| * Oft ist es aber besser einen eigenen Konstruktor zu programmieren, um die Initialisierung in der "eigenen Hand" zu haben.
| |
| *
| |
| * Der Name des Konstruktors muss mit dem Namen der Klasse übereinstimmen
| |
| *
| |
| * Der Konstruktor liefert nie ein Ergebnis zurück. Er darf '''nicht''' mit '''void''' gekennzeichnet werden
| |
| *
| |
|
| |
|
| |
| <syntaxhighlight lang="java">
| |
| public class Auto {
| |
| String marke;
| |
|
| |
| public Auto(String marke) {
| |
| this.marke = marke;
| |
| }
| |
|
| |
| } </syntaxhighlight>
| |
|
| |
| Aufruf:
| |
|
| |
| <syntaxhighlight lang="java">
| |
| Auto a = new Auto("BMW");
| |
| </syntaxhighlight>
| |
|
| |
| === this-Referenz ===
| |
|
| |
| '''this''' verweist auf das aktuelle Objekt und stellt die Unterscheidung zwischen der Instanzvariable und des Methodenparameters sicher:
| |
|
| |
| <syntaxhighlight lang="java">
| |
| this.marke = marke;
| |
| </syntaxhighlight>
| |
|
| |
| === Sichtbarkeiten (Access Modifiers) in Java ===
| |
|
| |
| {| class="wikitable"
| |
| ! Modifizierer
| |
| ! Zugriff innerhalb der Klasse
| |
| ! Zugriff im selben Paket
| |
| ! Zugriff in Unterklassen
| |
| ! Zugriff außerhalb (global)
| |
|
| |
| |-
| |
| | '''private'''
| |
| | Ja
| |
| | Nein
| |
| | Nein
| |
| | Nein
| |
|
| |
| |-
| |
| | '''package'''<br />(kein Modifizierer)
| |
| | Ja
| |
| | Ja
| |
| | Nein
| |
| | Nein
| |
|
| |
| |-
| |
| | '''protected'''
| |
| | Ja
| |
| | Ja
| |
| | Ja
| |
| | Nein
| |
|
| |
| |-
| |
| | '''public'''
| |
| | Ja
| |
| | Ja
| |
| | Ja
| |
| | Ja
| |
| |}
| |
|
| |
| ''' Hinweise '''
| |
|
| |
| * Der '''default'''-Zugriff gilt, wenn ''kein'' Modifizierer angegeben ist.
| |
| * '''protected''' erlaubt zusätzlich Zugriff in ''Unterklassen'', auch wenn diese in ''anderen Paketen'' liegen.
| |
| * Die Kombination von '''private''' Attributen mit '''public''' Getter/Setter ist Teil der '''Kapselung'''.
| |
|
| |
| === Kapselung (Encapsulation) ===
| |
|
| |
| Die Kapselung ist eines der zentralen Prinzipien der objektorientierten Programmierung. Dabei werden Daten (Attribute) innerhalb einer Klasse versteckt und der Zugriff nur über Methoden (Getter/Setter) erlaubt.
| |
|
| |
| ''' Ziel der Kapselung '''
| |
|
| |
| * Schutz der Daten vor unkontrolliertem Zugriff von außen
| |
| *
| |
| * Verbesserung der Wartbarkeit und Erweiterbarkeit des Codes
| |
| *
| |
| * Klare Trennung zwischen internem Zustand und externer Schnittstelle
| |
| *
| |
| * Attribute werden privat gemacht und über Getter/Setter kontrolliert.
| |
|
| |
| <syntaxhighlight lang="java">
| |
| public class Kunde {
| |
| private String name;
| |
|
| |
| public String getName() {
| |
| return name;
| |
| }
| |
|
| |
| public void setName(String n) {
| |
| name = n;
| |
| }
| |
|
| |
| } </syntaxhighlight>
| |
|
| |
| === Vererbung (Inheritance) ===
| |
|
| |
| Eine Klasse kann von einer anderen erben:
| |
|
| |
| <syntaxhighlight lang="java">
| |
| public class Fahrzeug {
| |
| int geschwindigkeit;
| |
| }
| |
|
| |
| public class Auto extends Fahrzeug {
| |
| int tueranzahl;
| |
| } </syntaxhighlight>
| |
|
| |
| === Polymorphie ===
| |
|
| |
| [[Polymorphie]] bedeutet, dass ein Objekt mehrere Formen annehmen kann – z. B. durch Überschreiben (Overriding) von Methoden:
| |
|
| |
| <syntaxhighlight lang="java">
| |
| class Tier {
| |
| public void geraeusch() {
| |
| System.out.println("Ein Tier macht ein Geräusch");
| |
| }
| |
| }
| |
|
| |
| class Hund extends Tier {
| |
| public void geraeusch() {
| |
| System.out.println("Wuff!");
| |
| }
| |
| } </syntaxhighlight>
| |
|
| |
| === Abstrakte Klassen ===
| |
|
| |
| Dienen als Basisklassen mit nicht vollständiger Implementierung:
| |
|
| |
| <syntaxhighlight lang="java">
| |
| abstract class Figur {
| |
| abstract double berechneFlaeche();
| |
| }
| |
| </syntaxhighlight>
| |
|
| |
| === Interfaces ===
| |
|
| |
| Definieren nur die Methode, aber keine Implementierung:
| |
|
| |
| <syntaxhighlight lang="java">
| |
| interface Bewegbar {
| |
| void bewege();
| |
| }
| |
| </syntaxhighlight>
| |
|
| |
|
| |
|
| |
|
| === Wichtige OOP-Prinzipien === | | === Wichtige OOP-Prinzipien === |
|
| |
|
| * '''Kapselung''' – Daten verbergen | | * '''[[Kapselung]]''' – Daten verbergen |
| * '''Vererbung''' – Wiederverwendbarkeit | | * '''[[Vererbung]]''' – Wiederverwendbarkeit |
| * '''Polymorphie''' – Einheitliches Ansprechen unterschiedlicher Objekte | | * '''[[Polymorphie]]''' – Einheitliches Ansprechen unterschiedlicher Objekte |
| * '''Abstraktion''' – Komplexität reduzieren | | * '''[[Abstraktion]]''' – Komplexität reduzieren |
| | |
|
| |
|
| [[Kategorie:Programmieren]] | | [[Kategorie:Programmieren]] |
| [[Kategorie:Semester2]] | | [[Kategorie:Semester2]] |
