Vorlesung Programmieren - sdqweb.ipd.kit.edu

KIT – Universität des Landes Baden-Württemberg und

nationales Forschungszentrum in der Helmholtz-Gemeinschaft

ARBEITSGRUPPE ARCHITECTURE-DRIVEN REQUIREMENTS ENGINEERING (ARE)

INSTITUT FÜR PROGRAMMSTRUKTUREN UND DATENORGANISATION (IPD), KIT-FAKULTÄT FÜR INFORMATIK

www.kit.edu

are.ipd.kit.edu

Vorlesung Programmieren

12 Java API

21.12.2016 | Jun.-Prof. Dr.-Ing. Anne Koziolek Version 1.1

Jun.-Prof. Dr.-Ing. Anne Koziolek, Arbeitsgruppe Architecture-Driven Requirements

Engineering, Institut für Programmstrukturen und Datenorganisation

4

Literaturhinweis - Weiterlesen

Dietmar Ratz, Jens Scheffler, Detlef Seese und Jan Wiesenberger

„Grundkurs Programmieren in Java“, 7. Auflage, 2014 (mit Java 8),

Hansa-Verlag

Kapitel 12 „Einige wichtige Hilfsklassen“

Anhang C „Umgang mit der API-Spezifikation“

Vorlesung Programmieren: Java API21.12.2016



5

Java API

API: Application Programming Interface

Sammlung von Klassen / Paketen für häufig benötigte Funktionalität

„Das Rad nicht immer wieder neu erfinden.“

Erlaubt Java-Programmierung auf höherer Ebene

Klassen, die Sie bereits kennen:

Object, String, Math, Enum, Comparable, Wrapper-Klassen, ...

Beschreibung / Dokumentation unter

http://docs.oracle.com/javase/8/docs/api/

Wichtige Pakete:

java.lang: Basisfunktionalität (Object, String, Math, Enum, ...)

java.util: Java Collections Framework / Zeit- und Datumsfunktionen, ...

java.io: Ein- und Ausgabe





6

Java API


htt

p://d

ocs.o

racle

.co

m/ja

va

se/8

/docs/



7

Das Java Collections Framework

Collection = Sammlung von Objekten

Java Collection Framework:

Einheitliche Architektur zur Repräsentation und Manipulation von

Collections

Abstraktion von der Implementierung

Verringerung des Programmieraufwands

14 generische Interfaces mit jeweils mehreren Implementierungen

Hauptinterfaces:


Collections

Set

SortedSet

List Queue

Map

SortedMap



8

Das Interface Collection<E>

Alle Collection-Interfaces sind generisch:

public interface Collection<E> { ... }

Collection<E> trifft keine Aussage darüber, ob

die Elemente der Collection geordnet sind

die Collection Duplikate enthält

Collection<E> wird verwendet, wenn möglichst wenig Einschränkungen

gelten sollen bzw. bekannt sind.

Set, List und Queue sind spezifischere Collections




9

Das Interface Collection<E>

Collection<E> definiert unter anderem folgende Methoden:public interface Collection<E> extends Iterable<E> {

int size();

boolean isEmpty();

boolean contains(Object element);

boolean add(E element);

boolean remove(Object element);

Iterator<E> iterator();

boolean containsAll(Collection<?> c);

boolean addAll(Collection<? extends E> c);

boolean removeAll(Collection<?> c);

void clear();

Object[] toArray();

<T> T[] toArray(T[] a);

boolean retainAll(Collection<?> c);

}




10

Exkurs: Wildcards in generischen Typen


In generische Typen kann als Typ-Parameter auch „?“ verwendet werden

Bsp.: Collection<?> c

„unbounded wildcard“

Das „?“ steht für einen beliebigen, aber festen Typ

Über den Typ „?“ dürfen keine Annahmen gemacht werden

Es gibt drei Arten von Wildcards in generischen Typen:

<?>

<? super [T]>

<? extends [T]>

10

class LivingOrganism

is-a is-a

class Catclass Dog

class Mammal class Bird

is-a is-a

class Animal

is-a

class Plant

is-a

class Object

is-a

<?>

<? super Animal>

<? extends Animal>

is-a is-a

is-a is-a

is-a is-a


class Catclass Dog


class Animal class Plant

class Object

is-a

is-a is-a

is-a is-a

is-a is-a


class Catclass Dog



class Object

is-a

is-a is-a

is-a is-a

is-a is-a


class Catclass Dog



class Object

is-a



11

Exkurs: Kovarianz / Invarianz


Kovarianz und Invarianz beschreiben die Vererbungsrichtung z.B. bei Container-

Klassen

Arrays in Java: kovariant

Integer Unterklasse von Number ➜ Integer[] Unterklasse von Number[]

Beispiel:Number[] a = new Integer[1];

a[0] = new Integer(4); // ok

a[0] = new String("Hallo"); // Laufzeitfehler: ArrayStoreException

Generics in Java: invariant

keine Ableitungsbeziehung zwischen z.B. ArrayList<Number> und

ArrayList<Integer>

Beispiel:ArrayList<Number> a = new ArrayList<Integer>(); // Kompilierfehler

Mit „Bounded Wildcards“:List<? extends Number> b = new ArrayList<Integer>();// ok

b.add(new Integer(42)); // Kompilierfehler

b.add(new Double(42.0)); // Kompilierfehler

List<Number> c = new ArrayList<Number>();

c.addAll(b); // ok



12

Exkurs: Wildcards mit generischen Typen

Richtlinien zur Verwendung von Wildcards:

„upper bounded wildcards“ (List<? extends T>) kann man sich grob als

„read only“-Typ vorstellen (keine Modifikationen z.B. mit add möglich)

List<?> vs. List<Object>:

List<?>: homogene Liste von Elementen (gleicher, aber unbekannter

Typ)

List<Object>: heterogene Liste (unterschiedliche Elementtypen

möglich)

Beispiel:

List<Object> ol = new ArrayList<Object>();

ol.add(new Integer(42)); // ok

List<?> wl = new ArrayList<Integer>();

wl.add(new Integer(42)); // Kompilierfehler


vgl. https://docs.oracle.com/javase/tutorial/java/generics/wildcardGuidelines.html

und https://docs.oracle.com/javase/tutorial/java/generics/lowerBounded.html

https://docs.oracle.com/javase/tutorial/java/generics/wildcardGuidelines.html

https://docs.oracle.com/javase/tutorial/java/generics/lowerBounded.html



13

Nochmals: Das Interface Collection<E>

Collection<E> definiert folgende Methoden:

public interface Collection<E> extends Iterable<E> {

int size();

boolean isEmpty();

boolean contains(Object element);

boolean add(E element);

boolean remove(Object element);

Iterator<E> iterator();

boolean containsAll(Collection<?> c);

boolean addAll(Collection<? extends E> c);

boolean removeAll(Collection<?> c);

void clear();

Object[] toArray();

<T> T[] toArray(T[] a);

boolean retainAll(Collection<?> c);

}




14

Sub-Interfaces von Collection<E>

List<E>

geordnete Collection; kann Duplikate enthalten; Zugriff auf Elemente

mittels Index

Implementierungen: ArrayList, LinkedList

Set<E>

keine Duplikate; modelliert mathematische Menge

Implementierungen: HashSet, TreeSet

SortedSet<E>

keine Duplikate; aufsteigend sortiert

Implementierungen: TreeSet




15

Das Interface Map<K,V>

Modelliert eine mathematische Funktion von K nach V

K: Schlüssel, V: Werte

Auf Grund Funktionseigenschaft:

Eine Map enthält keinen Schlüssel mehrmals

Jeder Schlüssel bildet auf höchstens einen Wert ab

public interface Map<K,V> {

V put(K key, V value);

V get(Object key);

V remove(Object key);

boolean containsKey(Object key);

boolean containsValue(Object value);

int size();

boolean isEmpty();

void putAll(Map<? extends K, ? extends V> m);

void clear();

public Set<K> keySet();

public Collection<V> values();

}




16

Map<K,V>: Beispiel

Map<K,V> unter anderem Implementiert von TreeMap<K,V>

Beispiel:Map<String,Integer> mountains = new TreeMap<String,Integer>();

mountains.put("Mount Everest", 8848);

mountains.put("K2", 8611);

mountains.put("Lhotse", 8516);

System.out.println(mountains.containsKey("Lhotse")); // Ausgabe: true

System.out.pritnln(mountains.get("K2")); // Ausgabe: 8611

System.out.println(mountains.get("Zugspitze")); // Ausgabe: null

mountains.remove("K2");

System.out.println(mountains.size()); // Ausgabe: 2

System.out.println(mountains.values()); // Ausgabe: [8848, 8516]




17

Die Klasse Collections

Die Klasse Collections enthält statische Methoden zum Umgang mit einer

Collection:

public static boolean disjoint(Collection<?> c1, Collection<?> c2)

// true, falls kein Element sowohl in c1 als auch in c2 enthalten ist

public static int frequency(Collection<?> c, Object o)

// Anzahl der Elemente in c, die gemäß equals identisch zu o sind

public static void reverse(List<?> l)

// Kehrt die Reihenfolge der Elemente in l um

public static <T> boolean replaceAll(List<T> l, T oldV, T newV)

// Ersetzt jedes zu oldV identische Element in l durch newV

public static <T extends Comparable<? super T>> void sort(List<T> l)

// Sortiert l gemäß der Methode compareTo des Typs T

public static <T> void sort(List<T> list, Comparator<? super T> c)

// Sortiert l gemäß Comparator c




18

Das Paket java.io

java.io enthält Klassen zur Ein- und Ausgabe durch Datenströme und Dateien

Die wichtigsten Klassen zur Ein- und Ausgabe sind:

Byte-basiert (byte streams):

InputStream und OutputStream

FileInputStream und FileOutputStream

Zeichen-basiert (character streams):

Reader und Writer

InputStreamReader und OutputStreamWriter

FileReader und FileWriter

Mit Puffer (Zwischenspeicher):

BufferedInputStream und BufferedOutputStream

BufferedReader und BufferedWriter




19

Ein- und Ausgabe in Java

Beispiel 1: Lesen von Zeichen der Standardeingabe in einen String

String s = new String();

InputStreamReader isr = new InputStreamReader(System.in);

int c = isr.read();

while (c != -1) {

s += (char) c;

c = isr.read();

}

Beispiel 2: Schreiben von Zeichen eines Strings auf die Standardausgabe

OutputStreamWriter osw = new OutputStreamWriter(System.out);

for (int i = 0; i < s.length(); i++) {

osw.write(s.charAt(i));

}

osr.flush();




20

Ein- und Ausgabe in Java

Die Klassen in java.io realisieren das Design Pattern Decorator:

Erlaubt, zusätzliche Funktionalität zur Laufzeit zu einzelnen Objekten

hinzuzufügen

Beispiel:

OutputStream os = new FileOutputStream(„file.txt“);

// Byte-weises schreiben in Datei

OutputStream bos = new BufferedOutputStream(os);

// ...mit Ausgabepuffer

OutputStream dbos = new DeflaterOutputStream(bos);

// ...und mit Kompression der Ausgabe (ZIP)




21

Java Puzzlers

Joshua Bloch, Neal Gafter: Java Puzzlers

Video: Java Puzzlers

URL: https://www.youtube.com/watch?v=V1vQf4qyMXg




22

Zusammenfassung

API: Application Programming Interface

Sammlung von Klassen / Paketen für häufig benötigte Funktionalität

Erlaubt Java-Programmierung auf höherer Ebene

Häufig verwendete und hilfreiche Klassen

Object, String, Math, Enum, Comparable, Wrapper-Klassen, ...

Java Collections

Beschreibung / Dokumentation unter


Wichtige Pakete:

java.lang: Basisfunktionalität (Object, String, Math, Enum, ...)

java.util: Java Collections Framework / Zeit- und Datumsfunktionen, ...

java.io: Ein- und Ausgabe



Vorlesung Programmieren - sdqweb.ipd.kit.edu

Documents

Transcript of Vorlesung Programmieren - sdqweb.ipd.kit.edu