Tutorien
/
Programmieren_2
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add termin3

This commit is contained in:
Burau, Henri 2021-05-18 18:17:49 +02:00
parent a698803b82
commit 667e7fabda
4 changed files with 311 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
03-termin.md Normal file
View File

@ -0,0 +1,34 @@
<!--
title: Termin 3
description: Folien für den ersten Termin in Programmieren 2
url: https://git.haw-hamburg.de/pm2-tutorium/slides
header: Programmieren 2 **Tutorium**
footer: Henri Burau
-->
# Termin 3
---
# Fragen
---
# Links
[https://git.haw-hamburg.de/pm2-tutorium](https://git.haw-hamburg.de/pm2-tutorium)
- Aufgaben
- Tutoriumsfolien
---
# Plan für heute
Level 5 Themen:
- Testen und Asserts
- Polymorphie und Vererbung
- Generizität
- Reflections
- **Implementationsvererbung**
- **Exceptions**
- **Module**

99
abstract.md Normal file
View File

@ -0,0 +1,99 @@
<!--
title: Abstrakte Klasse
description: Folien für abstrakte Klassen in Programmieren 2
url: https://git.haw-hamburg.de/pm2-tutorium/slides
header: Programmieren 2 **Tutorium**
footer: Henri Burau
-->
# Abstrakte Klassen
---
# Abstrakte Klassen
In abstrakten Klassen können Operationen **ohne** eine Implementation deklariert werden.
```java
abstract double gibFlaeche();
```
---
# Abstrakte Klassen
Eine Klasse mit mindestens einer abstrakten Methode muss abstrakt sein.
Es können keine Instanzen einer abstrakten Klasse erzeugt werden.
```java
abstract class Form
{
abstract double gibFlaeche();
String toString()
{
return "Form";
}
}
```
---
# Benutzung
Es können keine Instanzen einer abstrakten Klasse erzeugt werden. Trotzdem definieren die abstrakten Klassen einen Typ.
```java
// Deklaration
class Kreis extends Form {
private double _radius;
Circle(double rad) {radius = rad;}
double gibFlaeche(){
return 3.14 * radius * radius;
}
}
// Benutzung
Form form1 = new Kreis(4.5);
```
---
# Verwendung
Abstrakte Klassen werden immer benutzt wenn Code wiederverwendet werden soll, aber nicht alle Details bekannt sind. Dabei wird häufig das Prinzip der Schablonen- und Einschubmethoden genutzt.
```java
abstract class DreidimensionaleForm {
private double _hoehe;
abstract double gibFlaeche();
double gibVolumen() {
return gibFlaeche() * _hoehe;
}
}
```
* Welche Methode ist die Einschubmethode und welche die Schablonenmethode?
---
# Übung
1) Müssen alle abstrakten Methoden eine abstrakten Klasse in einer Subklasse implementiert werden?
* Ja, denn ansonsten fehlt für manche Operationen die Implementation.
2) Sind alle Felder der abstrakten Klasse auch in der Subklasse enthalten?
* Ja
3) Darf auf alle Felder der Superklasse aus der Subklasse zugegriffen werden?
* Nur solange die Modifier `private`, `protected` oder `package private` sind.
---
4) Ändere die Klasse `Animal` zu einer abstrakten Klasse. Alle Methoden die bei `Sheep` und `Cow` gleich sind müssen nicht abstrakt sein. Füge aber eine abstrakte Methode `String makeNoise()` ein. Ändere den Code and den richtigen Stellen ab.

87
exceptions.md Normal file
View File

@ -0,0 +1,87 @@
<!--
title: Assertions
description: Folien für Assertions in Programmieren 2
url: https://git.haw-hamburg.de/pm2-tutorium/slides
header: Programmieren 2 **Tutorium**
footer: Henri Burau
-->
# Exceptions
Erlauben es mit Fehlersituationen in einem Programm umzugehen. Es gibt zwei mögliche Fehlerarten:
1) **Entwicklungsfehler**
Vermeidbare Fehler die während der Entwicklung auftreten. Können gut durch Tests aufgedeckt werden und brauchen keine explizite Fehlerbehandlung.
*Beispiel*: Ungültiger Arrayindex, Teilen durch 0
2) **Umgebungsfehler**
Unvermeidbare Fehler die durch die Programmumgebung ausgelöst werden. Diese Fehlerart benötigt eine Fehlerbehandlung.
*Beispiel*: Keine Internetverbindung, Zu wenig Festplattenspeicher
---
# Hierarchie
Exceptions sind Objekte die von `Exception` oder `RuntimeException` erben.
[![width:300px](https://mermaid.ink/img/eyJjb2RlIjoiY2xhc3NEaWFncmFtXG4gICAgVGhyb3dhYmxlIDx8LS0gRXhjZXB0aW9uXG4gICAgVGhyb3dhYmxlIDx8LS0gRXJyb3JcbiAgICBFeGNlcHRpb24gPHwtLSBSdW50aW1lRXhjZXB0aW9uIiwibWVybWFpZCI6eyJ0aGVtZSI6ImRlZmF1bHQifSwidXBkYXRlRWRpdG9yIjpmYWxzZX0)](https://mermaid-js.github.io/mermaid-live-editor/#/edit/eyJjb2RlIjoiY2xhc3NEaWFncmFtXG4gICAgVGhyb3dhYmxlIDx8LS0gRXhjZXB0aW9uXG4gICAgVGhyb3dhYmxlIDx8LS0gRXJyb3JcbiAgICBFeGNlcHRpb24gPHwtLSBSdW50aW1lRXhjZXB0aW9uIiwibWVybWFpZCI6eyJ0aGVtZSI6ImRlZmF1bHQifSwidXBkYXRlRWRpdG9yIjpmYWxzZX0)
---
# Ungeprüfte Exceptions
Erben von `RuntimeException` und müssen nicht explizit behandelt werden.
```java
Dreieck dreieck = null;
double flaeche = dreieck.gibFlaeche();
// Programm wird beendet mit NullPointerException
```
---
# Geprüfte Exceptions
Erben von `Exception` und müssen explizit behandelt werden.
```java
public static void main(String[] args) {
System.out.print("Bitte Alter eingeben: ");
try {
Scanner sc = new Scanner(System.in);
String name = sc.nextLine();
int alter = Integer.parseInt(name); // Wirft ggf. NumberFormatException
}
catch(NumberFormatException e) {
System.out.println("Das war kein gültiges Alter!");
}
finally {
sc.close()
}
}
```
---
# Exceptions werfen
Exceptions werden mit dem Schlüsselwort `throw` geworfen. Wird in einer Methode eine geprüfte Exception nicht behandelt, muss dies in dem Methodenkopf mithilfe von `throws` deklariert werden.
```java
public void pingServer(String serverUrl) throws ConnectException
{
Server server = connectToServer(serverUrl);
if(server == null)
{
throw new ConnectException("Can't connect to server");
}
}
```
---
# Übung
1) Wann werden geprüfte Exceptions eingesetzt und wann ungeprüfte?
* Geprüfte Exceptions bei Umgebungsfehlern, Ungeprüfte Exceptions bei Entwicklungsfehlern
2) Wie kann eine geprüfte Exception beim Auftreten an den Klienten weitergeleitet werden?
* In den Methodenkopf `throws` reinschreiben

91
packages.md Normal file
View File

@ -0,0 +1,91 @@
<!--
title: Termin 3
description: Folien für den ersten Termin in Programmieren 2
url: https://git.haw-hamburg.de/pm2-tutorium/slides
header: Programmieren 2 **Tutorium**
footer: Henri Burau
-->
# Module
Grundlegendes Konzept in der Programmierung zur Organisation von Programmcode.
Module kapseln Implementationen und exportieren eine Schnittstelle mit Operationen, Typen und Konstanten. Dies kann explizit durch die Java 9 Modules geschehen oder implizit durch Zugriffsmodifikatoren.
---
# Geschachtelte Klassen
Erlaubt das Verstecken von Hilfsklassen.
```java
class Dreieck {
private Koordinate _a;
private Koordinate _b;
private Koordinate _c;
private class Koordinate
{
...
}
}
```
---
# Pakete
Ermöglichen Namensräume von zusammengehörigen Klassen. Klassen und Interfaces sind nur sichtbar wenn sie mit dem Schlüsselwort `public` deklariert wurden.
```java
// Dreieck.java
package formen;
public class Dreieck {
private Koordinate _a;
private Koordinate _b;
private Koordinate _c;
//...
}
// Koordinate.java
package formen;
class Koordinate
{
//...
}
```
---
# Imports
Möchte man Klassen und Interfaces aus einem anderen Paket nutzen dann müssen diese importiert werden. Um eine Grundfunktionalität von Java zu gewährleisten wird das Paket [`java.lang`](https://docs.oracle.com/javase/8/docs/api/java/lang/package-summary.html) immer importiert.
```java
import java.util.List; // Nur List
import java.util.*; // Alle Klassen und Interfaces aus java.util
import static org.junit.Assert.*; // Statischer Import der Asserts
import java.lang.*; // Default Import der immer gemacht wird
```
---
# Sichtbarkeiten
Sichtbarkeiten von Methoden, Konstruktoren und Feldern:
* **public**: Sichtbar innerhalb und außerhalb des eigenen Pakets
* **protected**: Sichtbar innerhalb des Pakets und für erbende Klassen
* **package-private**: Sichtbar innerhalb des Pakets
* **private**: Nur sichtbar innerhalb der Klasse
---
# Übung
1) Durch welches Schlüsselwort wird der Modifikator `package-private` genutzt?
* Durch die Verwendung von keinem Schlüsselwort als Modifikator
2) Wie sollten Pakete benannt werden?
* Umgedrehte Domain: `de.henriburau.meineKlassen`