OOP Uebungen

Im folgenden sollen diese Begriffe verstanden und angewandt werden. Diese sind nicht chronologisch geordnet.

Tip: Für weitere Informationen: Objektorientierte Programmierung

• Klasse
  • Instanz- vs. Klassenmethode
  • Instanz- vs. Klassenattribut
  • Innere Klassen (statisch vs. nicht statisch)
• Enumeration (enum)
• Collections (Liste, Set, Map)
• Vererbung
• Abstrakte Klasse
• Interface
• Polymorphismus
• Beziehungen
  • Has-A vs. Is-A
  • Implementierung von Interfaces
• Generics
• Designpatterns

Aufgabe: Datenklasse

Es soll eine Methode erstellt werden, welche das kleinste und das größte Element sowie den Durchschnitt eines int[] ermittelt und zurückgibt. Alle ermittelten Werten sollen in einem Datenobjekt zurückgegeben werden. Erstelle dazu eine Datenklasse welche die entsprechenden Werte enthält. Teste diese Methode ausgiebig mit verschiedenen int[], verwende auch ein zufallsgeneriertes int[] mit negativen und positiven Werten.

• Erstelle die Datenklasse mit einem Sinnvollen Klassennamen und entsprechenden Attributen. Achte hierbei auch auf die Korrekte Sichtbarkeit
• Erstelle in in der Datenklasse einen Konstruktor welcher alle Werte entgegennimmt und erstelle getter für alle Werte
• Überschreibe die toString() Methode und erstelle einen schönen String mit den gegebenen Werten.

Lösung: 2021_11_03_aufgabe_dataclass

Aufgabe: Person

Erstelle eine Klasse welche die typischen Werte eines Menschen speichern kann.

• Größe
• Alter
• Name
• Gewicht

Erstelle weiters eine Methode welche eine List von Personen erhält und bezüglich Größe, Alter, Gewicht, das kleinste und das größte Element sowie den Durchschnitt berechnet und wie in der vorhergehenden Aufgabe in einer eigenen Klasse zurückgibt.

Aufgabe: Person Sortiert

Verwende die erstellte Klasse aus dem vorhergehenden Beispiel und erstelle eine Methode welche eine List von Personen nach entweder nach Größe, Alter, Gewicht, oder Name sortiert. Hierfür kann ein enum verwendet werden, oder auch einfach ein int.

Aufgabe: Fotoapparat

Erstelle eine Fotoapparat Klasse.

• Mit zumindest folgenden Attributen (es dürfen auch gerne mehr sein), Brennweite min/max, Model, Hersteller und Megapixel.
• Erstelle für die Attribute getter und setter
• Erstelle weiters die Methode takePhoto(), die ein Foto schießt (Mach einfach eine nette Ausgabe)
• Überschreibe die toString() Methode und gib die relevanten Daten als String zurück

Erstelle verschiedene Instanzen der Fotoapparat Klasse und Teste diese ausgiebig.

Aufgabe: Fotoapparat & Objektiv & Speicherkarte

Erweitere das vorhergehende Beispiel um die Klassen Objektiv und Speicherkarte. Die Brennweite der Kamera fällt demnach weg. Das Objektiv und die Speicherkarte sollen getauscht werden können. Erstelle Methoden um zu erfragen wieviele Fotos bereits aufgenommen wurden und wieviel Speicher noch frei ist. Für die Berechnung speicherplatz pro bild, kann ein wert von 0.3mb pro Megapixel angenommen werden.[1]

Aufgabe: Carsimulation

Erstelle eine Car Klasse. Diese enthält alle gängigen Attribute die für ein Auto benötigt werden. Zumindest sollte die Klasse folgende Attribute enthalten:

• Hersteller
• Modell
• kW (Leistung)
• Tankinhalt
• Antriebsart (erstelle dafür eine Enumeration Benzin, Diesel, Gas, Strom)
• Gewicht

Überlege welche Attribute du im Konstruktor als Parameter erhalten willst. Ohne welche kann eine Auto Instanz nicht existieren? Erstelle nun die Methode drive(int kilometer) welche einen int zurückgibt. Diese Methode soll, wenn es der Tankinhalt zulässt, die gegebene Strecke zurücklegen. Wenn der Tank leer ist, soll nur die Strecke zurückgegeben werden, die zurückgelegt werden konnte. Um den Verbrauch zu berechnen und den Tankinhalt zu reduzieren verwende das Gewicht und die kW (Leistung) des Autos.

Wenn der Tank leer ist, soll der Tank über eine Methode mit einer gewissen Menge an Kraftstoff aufgefüllt werden. Erstelle dazu eine entsprechende Methode und fahr weiter.

Erstelle nun eine Carsimulation welche eine gewisse Anzahl von Autoinstanzen erstellt und diese fahren lässt und wenn nötig wieder betankt.

Wunsch: Die Methoden sollen zu ihrer eigentlichen Funktion auch eine schöne Ausgabe erstellen

Aufgabe: Carsimulation Extended

Erweitere das vorhergende Beispiel um die Klassen

• Engine (Motor)
• Tank
• GasStation
• RepairStation

Sowohl Tank und Motor sollen in Car als Attribute existieren und durch die RepairStation austauschbar sein.

Eine Engine soll nach einer zufälligen Wahrscheinlichkeit einen Defekt haben und in der RepairStation getauscht werden. Je mehr Kilometer gefahren wurden, desto höher ist die Wahrscheinlichkeit, dass die Engine kaputt geht.

Wenn die Car nicht die gewünschten Kilometer fährt, so ist entweder der Tank leer, oder der Motor kaputt. Erstelle Methoden der Car Klasse die den Tankinhalt und den Zustand des Motors (defekt oder ganz) zurückgeben.

Wird die drive(int kilometers) Methode ausgeführt, so soll nun eine Methode im Motor aufgerufen werden, die diesen startet, und nach den gefahrenen Kilomtern wieder stoppt. Auch der Treibstoffverbrauch soll mit dem Motor zusammenhängen. Vielleicht ist es eine gute Idee beim Starten den Tank an den Motor zu übergeben?

Erstelle folgende Subklassen von Tank

• Battery
• FuelTank

Überlege welche Methoden in der Superklasse Tank Sinn machen.

Erstelle folgende Subklassen von Car

• SelfRepairingCar (hat der Motor einen Schaden, so soll dieser automatisch repariert und weitergefahren werden)
• AeroDynamicCar (reduziert den Treibstoffverbrauch um 50%)
• CrapCar (erhöht die Wahrscheinlichkeit dass der Motor kaputt geht um 50%)

Überlege welche Methoden in der Superklasse Car sinn machen. Eine eigene Methode in der Superklasse welche den Treibstoffverbrauch pro Kilometer ausrechnet, macht wahrscheinlich sinn. Diese kann dann in den Subklassen überschrieben werden.

Teste deine Autosimulation ausgiebig.

Aufgabe: Filesystem traversal

Das wurde schonmal gemacht, einfach nochmal machen, das schadet nicht :-)

Erstelle eine Methode welche durch das Dateisystem ab einem gegebenen Pfad navigiert (Ob der Pfad als String oder File übergeben wird ist egal). Wird der Pfad nicht gefunden, so soll eine FileNotFoundException geworfen werden. Die Navigation soll dabei Rekursiv erfolgen. Gib den Pfad mit entsprechender Einrückung aus.

Tip zur Rekursion: Iteriere in einer Methode durch alle Kinder einer Datei. Handelt es sich um einen Ordner so rufe für jedes Kind dieses Ordners die Methode wieder auf und erhöhe die Einrückung.

Ausgabe (muss nicht genau so aussehen):

├── otherPackageInvocationTest
│   └── Test.java
├── week1
│   ├── tag3
│   │   ├── Aufgabe1.java
│   │   ├── Aufgabe2.java
│   │   └── Loops.java
│   ├── tag4
│   │   ├── Christbaum2.java
│   │   ├── Christbaum.java
│   │   ├── Loops.java
│   │   ├── Traingle2.java
│   │   └── Triangle.java
│   ├── tag5
│   │   ├── Circle2.java
│   │   ├── Circle3.java
│   │   ├── Circle.java
│   │   └── Methods.java
│   └── tag5a
│       └── UseMethods.java
├── week2
│   ├── day3
│   │   ├── Calendar.java
│   │   ├── LogicPuzzle.java
│   │   ├── Recursion2.java
│   │   └── Recursion.java
│   └── day4
│       ├── Menu.java
│       └── UserInput.java

Aufgabe: Filesystem traversal usefull

Erstelle eine Methode welche durch das Dateisystem ab einem gegebenen Pfad navigiert. Die Methode erhält weiters eine Klasse FileReceiver. Diese Klasse hat eine Methode onFileReceived(int depth, File file) welche zur Verarbeitung jeder einzelnen Datei, bzw. jedes einzelnen Ordners aufgerufen wird. Erstelle verschiedene weitere Klassen die von FileReceiver erben und onFileReceived(int depth, File file) überschreiben und folgende Aufgaben erfüllen sollen:

• Größe aller Dateien berechnen
• Anzahl der Dateien mit einer bestimmten Endung zählen
• Alle Dateiendungen Zählen. Tip.: HashMap
• Die größe jedes Ordners ermitteln. Tip.: Hier wird die depth und ein Stapel benötigt (List, oder Stack).

Aufgabe: Filesystem traversal usefull & extended

Wie in der vorhergehenden Aufgabe, jedoch soll nicht nur ein FileReceiver übergeben werden können, sondern eine List von FileReceiver.

Aufgabe: JUnit

Wähle drei Beispiele aus deiner Sammlung und teste diese mit JUnit.

Aufgabe: Geometry

Erstelle eine Abstrakte Klasse Geometry. Diese enthält folgende Methoden:

• getCircumference() und gibt einen double zurück
• getArea() und gibt einen double zurück

Erstelle nun einige Klassen die von Geometry erben (Circle, Square, Rectangle, Triangle,...). Jede Klasse soll in ihrem Konstruktor die entsprechenden Werte erhalten.

Erstelle nun verschiedene Instanzen von Geometry, speichere diese in einer List. Erstelle eine Methode die den Gesamtumfang und die Gesamtfläche aller Geometry Objekte in der List ausgibt.

Teste deine Implementierung ausgibig

Aufgabe: Verhalten

Wie in Protokoll 19.11 gezeigt, soll nun das Schwimmverhalten implementiert werden. Erstelle endweder die Bestehende Klassenhierarchie als Übung in deinem eigenen Paket, oder kopiere diese.

Aufgabe: Graph

Ein Graph ist eine Datenstruktur die aus mehreren Knoten (Nodes besteht). Eine Node kann mehrere Nodes als Nachbarn haben, das heißt, sie hat eine Verbindung zu diesen Nachbarn.

Ein einfacher Graph

• Erstelle eine Datenstruktur für die Node mit (X/Y Koordinaten), verwende für die Nachbarn eine List in der jeweiligen Node
• Erstelle weiters eine Datenstruktur für den Graphen, welche eine List von Nodes enthält
• Erstelle aus den schwarzen Pixeln des folgenden Labyrinths einen Graphen

Ein Labyrinth

Aufgabe: Dijkstra

Zeige deinen Graphen in einem JPanel an. Es soll nun der Start und das Ziel angeklickt werden können. Finde mittels Dijkstra Algorithmus[2] den kürzesten Weg vom Start zum Ziel. Illustriere dabei alle durchwanderten Knoten.