Übergang zur Schnittstellenvererbung

Größe: px
Ab Seite anzeigen:

Download "Übergang zur Schnittstellenvererbung"

Transkript

1 (68) Übergang zur Schnittstellenvererbung Einfachvererbung versus Mehrfachvererbung Interface = Schnittstellenspezifikation Mehrfachvererbung bei Interfaces Verwendungsregeln Polymorphie / Entkopplung / Design mit Interfaces Annotationen Bis Java 7 blieben Interfaces stabil. Java 8 führt dort (leider) Implementierungsaspekte ein (s.u.)

2 Warum keine Implementierungs-Mehrfachvererbung? (69) Java : Realität : Klassen-Einfachvererbung - jede Unterklasse hat nur eine direkte Oberklasse Auch Mehrfachvererbung Kind (Vater + Mutter) aber Mehrfachklassenvererbung macht logische + technische Strukturen komplexer / schwieriger Erhöhter Speicherbedarf + Verwaltungsaufwand für JVM VMT ( virtual method tables ) Rautenproblem der OO : Basis m() a Mehrfachvererbung für Klasse Unter_2 : Erbt m() und a "zweimal" : Über Klasse Unter_1a und über Unter_1b Welcher Weg ist gültig? Unter_1a m() Unter_1b m() m() in Unter_1a und Unter_1b überschreibbar! Welche Variante bei Aufruf aus Unter_2 verwenden? Lösung : Keine Mehrfachvererbung Unter_2 Interface-Konzept!??

3 Interface = Schnittstellenspezifikation (70) In seiner Idealform enthält ein Interface ausschließlich abstrakte Methoden - basta!! (In Java können jedoch (leider?!) auch weitere Bestandteile aufgenommen werden ) Ein Interface definiert eine Schnittstelle = Typ - nicht seine Implementierung Liefert Spezifikation von Fähigkeiten = Vertrag 1. Interfaces können von mehreren Interfaces erben extends Mehrere Schnittstellenbeschreibungen können in einem Interface zusammengefasst werden 2. Klassen können mehrere Interfaces implementieren : Neues Schlüsselwort implements 3. Jede implementierende Klasse ist typkompatibel zu Interface! Somit können ihre Objekte überall dort eingesetzt werden, wo der IF-Typ gefordert ist!

4 Interface = Schnittstellenspezifikation (71) Inhalt bis incl. Java 7 : Abstrakte Methoden + Statische Konstanten Alle Methoden public abstract Alle Attribute public static final interface Konto { public static final double MIN = 10.0 ; public abstract void einzahlen( double betrag ) ; public abstract void abheben( double betrag ) ; class Sparkonto implements Konto { Schlüsselwörter public, abstract, static final müssen nicht explizit angegeben werden - werden vom Compiler automatisch gesetzt. Konstanten - müssen im IF initialisiert werden! Implementierte Methoden müssen public sein! Eine vom IF erbende Klasse, die nicht alle Interfacemethoden implementiert, enthält abstrakte Methoden + ist somit abstract! private double saldo ; public Sparkonto( ) { /* */ public double getsaldo( ) { return saldo ; public void einzahlen( double betrag ) { saldo = saldo + betrag ; public void abheben( double betrag ) { if( saldo - betrag > MIN ) saldo = saldo - betrag ; else /* */ Nachträgliche Änderungen an Interfaces erzwingen Anpassungen in allen implementierenden Klassen!!

5 IF - Strukturierung + Modellierung Modellierung Mehrfachvererbung durch Interfacehierarchie : extends Fahrzeugantrieb Diesel Elektro (72) Interfaces erlauben Modellierung komplexer Zusammenhänge : Anforderungs-Spezifikation IF-Hierarchie bildet Zusammenhang ab Keine Implementierung von Methoden - aber Modellierung + Strukturierung Klassen, die IF implementieren, übernehmen dadurch Strukturierung des Sachverhalts Reihenfolge - erst Erben / dann Implementieren : class A extends B implements IFC, IFD { /* */ interface Fahrzeugantrieb { int getleistung( ) ; int getgewicht( ) ; interface Diesel extends Fahrzeugantrieb { double gethubraum( ) ; double getverbrauch( ) ; interface Elektro extends Fahrzeugantrieb { double getbatteriekapazität( ) ; interface Hybrid extends Diesel, Elektro { String getkopplungsart( ) ; class HybridAntrieb implements Hybrid { public int getleistung( ) { public double getbatteriekapazität( ) { // Hybrid

6 Interfaces - Strukturierung + Modellierung (73) Schnittstellenvererbung statt Implementierungsvererbung Strukturierung von Software! Interfaces : Spezifikation + Modellierung Abstrakte Vertragsdefinition Klassen : Konkrete Implementierung Interfaces können nicht instanziiert werden Sollen durch implementierende Klasse konkretisiert werden Unterschied Interface - abstrakte Klasse : 1. Abstrakte Klassen können Implementierung enthalten 2. Abstrakte Klassen können private + finale Methoden enthalten 3. Klassen können nur von einer abstrakten Oberklasse erben Aber Klassen können beliebig viele Interfaces implementieren Extreme Form : Marker-Interfaces Ohne jeden Inhalt - Vertrag nur durch ihre Dokumentation festgelegt Es wird kein Verhalten definiert - dh keine Methoden + Konstanten enthalten. Vertrag befindet sich in Dokumentation, die die Erwartungen beschreibt, die implememtierende Klasse erfüllen sollte Bsp : Serializable, Cloneable 4. IFs erlauben Mehrfachvererbung

7 Interfaces - Rautenprobleme Methoden Regeln : (IF X,Y) Gleicher Methodenname, gleicher oder verschiedener Rückgabetyp, X Y Z (74) unterschiedliche Parameterlisten : Klasse Z muss entsprechend viele gleichnamige überladene Methoden implementieren Gleicher Methodenname, gleicher Rückgabetyp, gleiche Parameterlisten : Klasse Z muss nur diese eine Methode implementieren Gleicher Methodenname, gleiche Parameterlisten unterschiedlicher Rückgabetyp : Nicht erlaubt - Compilerfehler! Identische Konstanten-Namen - Regeln : Konflikt durch Qualifikation des Interface-Namens aufgelöst interface Skat { int kartenzahl = 32 ; interface Poker { int kartenzahl = 52 ; class Z implements Skat, Poker { /* */ Skat.kartenZahl /* */ /* */ Poker.kartenZahl /* */ // IF-Konstanten auch in nicht // implementierenden Klassen verwendbar : class A { /* */ Skat.kartenZahl /* */ /* */ Poker.kartenZahl /* */

8 Programmieren mit Interfaces (75) Interfaces legen keine Implementierungsdetails fest : Ihre Methoden können nicht mit native, synchronized oder strictfp modifiziert werden Würde Implementierung vorschreiben dies ist allein Sache der implementierenden Klasse! Interfaces dürfen keine Konstruktoren vorschreiben Methoden können nicht final sein Methoden können nicht static sein denn sie müssen erst noch in einer Klasse implementiert werden denn statische Methoden können nicht abstract sein Methoden dürfen mit throws-klausel Exception-Verhalten beschreiben Interface-Konstanten können Objekte sein wenngleich kein guter Stil, da dadurch IF von konkreter Implementierung abhängig class A { /* */ interface IFEuro { public static final A a = new A( ) ; public abstract double indm( double euros ) throws MyException ;

9 Interfaces nicht als Konstantendeponie! (77) interface PhysicalConstants { public static final double NA = 6.022e23 ; public static final double KB = 1.38e-23 ; public static final double ME = 9.11e-31 ; Interne Verwendung von Konstanten sollte ein Implementierungsdetail der Klasse sein. Bei Implementierung eines entsprechenden "Konstanten-Interfaces" werden die Konstanten jedoch Teil der öffentlichen Schnittstelle der implementierenden Klasse ("implementation details leak into the class's exported API"). Verwirrt Benutzer der Klasse, da er keinen Sinn in Werten sieht, die nur intern benötigt werden. Die Schnittstelle der Klasse und ihrer Unterklassen wird mit den IF-Konstanten verschmutzt. package science ; // Bessere Lösung! public final class PhysicalConstants { // Tool private PhysicalConstants( ) { // no objects! public static final double NA = 6.022e23 ; public static final double KB = 1.38e-23 ; public static final double ME = 9.11e-31 ; import science.physicalconstants ; class Test { public double atoms( double mol ) { // return PhysicalConstants.NA * mol ; Interfaces sollten verwendet werden, um Typen + Schnittstellen zu definieren! Nichtinstanziierbare Tool-Klasse ist bessere Lösung! Sie sollten nicht dem bloßen Export von Konstanten dienen!

10 Programmieren mit IFs interface IFEuroSF { Interface = Typ Auf diesen kann man sich bei Methoden- Implementierung beziehen : Parameter, Rückgabewert, Variablen können von Interface-Typ sein! Interface-Referenz wird Objekt einer implementierenden Klasse zugewiesen *) Darauf nur die im IF definierten Methoden + Konstanten zugreifbar! Erhöhte Typsicherheit & Flexibilität bei Verwendung, leichtere Austauschbarkeit der Implementierung! Programmierung via Interfaces Konkrete Aufrufe aber mit Objekten der implementierenden Klassen public static final double kurs = 1.14 ; public abstract double insf( double eurobetrag ) ; ////////////////////////////////////////////////////////////////////////// class CIFUser { public static double rechne( IFEuroSF ie, double e ) { double s = ie.insf( e ) ; return s ; Kennt Implementierer nicht! /////////////////////////////////////////////////////////////////////////// class CEurorechner implements IFEuroSF { public double insf( double eurobetrag ) { return eurobetrag * IFEuroSF.kurs ; Kennt User nicht! ///////////////////////////////////////////////////////////////////////////// class IFTest { public static void main( String[ ] args ) { IFEuroSF er = new CEurorechner( ) ; // * double d = CIFUser.rechne( er, 200 ) ; (78)

11 Interfaces : Bedeutung als "Abstrakte Server" (79) Entkopplung : durch Interfaces als Mittel der Abstraktion optimal unterstützt Programmteile mit klarer Funktionalität sind isoliert nutzbar + voneinander unabhängig! Interne Implementierungen interessieren nicht nur die Aufruf-Schnittstellen! Interfaces als Mittler zwischen Aufrufer (Client) und Aufgerufenem (Server) : Klasse A ruft implementiert Klasse B Klasse A bildet mit Interface I eine syntaktisch korrekte kompilierbare Einheit unabhängig von konkreter Implementierung der Klasse B Klasse B bildet mit Interface I eine syntaktisch korrekte kompilierbare Einheit unabhängig von konkreten Aufrufen durch Klasse A Durch Interface wurden Klasse A und Klasse B voneinander entkoppelt : Client Interface I Server Implementierung B ist austauschbar Indirekter Zugriff durch A Interfaces definieren Vertrag zwischen Konsumenten und Anbietern von Funktionalität und entkoppeln diese voneinander

12 Interfaces + Design (80) Interface definiert Typ - auf den sich System bezieht Interface beschreibt das Konzept - nicht die konkrete Implementierung. << interface>> Form double flaeche() Klassen implementieren das IF = den Typ. Das aufrufende System ist nur von der Schnittstelle abhängig muss dank Polymorphie die Klassen der beteiligten Objekte nicht kennen. Kreis Viereck Dreieck Prinzip : Entkopplung von Schnittstelle von Implementierung Entkopplung des "Was" vom "Wie" Beliebige konkrete Implementierungen verwendbar Einbau neuer System-Features : Nicht durch Modifikation existierenden Codes, sondern durch Erweiterung des Systems mittels neuer Klassen Verbesserung der Entwurfsqualität durch die Auflösung konkreter Abhängigkeiten : System hängt nicht von Implementierungsdetails ab, sondern nur von grundlegenden Konzepten. Polymorphie - statt bedingtem Verhalten mittels switch-case-konstrukten : Je nach übergebenem Objekttyp zeigt Methode anderes Verhalten ohne dass dies in der Methode durch verschiedene Cases explizit behandelt werden müsste

13 Interfaces + Design // OCP : Stabiles Coding // Auch bei weiteren Implementierungen des // IFs Form ergeben sich hier keine Änderungen! << interface>> Form double flaeche() (81) class Geometrie { private Form[ ] container = new Form[ 100 ] ; private int pos = 0 ; Kreis Viereck Dreieck public void add( Form frm ) { container[ pos ] = frm ; pos++ ; public void ausgabe( ) { for( int i=0; i<container.length; i++ ) { Form frm = container[ i ] ; IO.writeln( "Flaeche = " + frm.flaeche( ) ) ; // Einbau neuer System-Features : Durch modifikationsfreie Erweiterung des Systems mittels neuer Klassen (zb: Raute, Ellipse ) Veränderungen durch Hinzufügen neuen Codes statt durch Änderung bestehenden Codes OpenClosedPrinciple OCP : Systeme sollen offen für Erweiterungen sein - aber abgeschlossen gegenüber Änderungen Stabiles + flexibles Verhalten: Kein Änderungsbedarf am Großteil des existierenden Codings

14 Pattern : Interface Abstrakte Klasse Implementierende Klasse (82) interface IF { m1( ) m2( ) m3( ) m4( ) m5( ) Formuliert Vertrag + Typ = Schnittstelle Framework : Verlangt nach Typ IF abstract class AbstractIF implements IF { abstract public void m1( ) ; abstract public void m2( ) ; public void m3( ) { public void m4( ) { public void m5( ) { class MyVersionOfIF extends AbstractIF { public void m1( ) { public void m2( ) { public void m4( ) { Abstrakte skeletal-implementation-class als Implementierungshilfe : Implementiert Vertrag bereits teilweise eventuell mit leerer Implementierung Grundlegende Methoden bleiben abstrakt, verwendende Methoden vorimplementiert Konkrete Klasse : Muss nur noch Teil der Methoden implementieren bzw. zur individuellen Anpassung überschreiben Weniger mühsam, als direkt mit IF zu beginnen Bsp : Instanzen entsprechen dem vom Framework geforderten Typ! java.util Collection Framework IF Collection AK AbstractCollection AbstractList

15 Pattern : Interface zur Formulierung von Factories (83) interface Konto { /* */ Das Interface als allgemeiner Typ class Giro implements Konto { /* */ class Sparkonto implements Konto { /* */ class Bauspar implements Konto { /* */ // und viele andere mehr Konkrete Klassen, die alle den grundlegenden Interface-Typ spezifisch implementieren abstract class KontoFactory { public static Konto createkonto( String type ) { if( type.equals("g") ) return new Giro( /* */ ) ; if( type.equals("s") ) return new Sparkonto( /* */ ) ; if( type.equals("b") ) return new Bauspar( /* */ ) ; // Eine eventuell abstrakte Factory-Klasse, die passende Objekte liefert, ohne dass Namen und die Existenz der dahinterstehenden Klassen bekannt sein müssten! Vorteil von Factories : Flexibel anpassbares Erzeugen von Instanzen, ohne Details zu exponieren. class Anwendung { public static void main( String[ ] args ) { String type = IO.promptAndReadString( "Kontotyp (S/B/G/ )? ") ; Konto k = KontoFactory.createKonto( type ) ; // Objekt verwenden Anwendung, die sich auf das beschreibende Interface und die Dienste der Factory verlässt, ohne die dahinterstehenden implementierenden Klassen zu kennen!

16 Beispiel: Interfaces java.lang.comparable java.util.comparator (84) Vergleichsmethoden : compareto( ) und compare( ) implementieren eine totale Ordnungsrelation mit gleicher Semantik a.compareto( b ) compare( a, b ) < 0 bedeutet: a < b = 0 a gleichgroß b > 0 a > b Absolutwerte <0 oder >0 egal keine weitere Semantik einbauen! Totale Ordnung : Allerdings unterschiedliche Signatur der Vergleichsmethoden : public interface Comparator { public interface Comparable { public int compare( Object o1, Object o2 ) ; public int compareto( Object o ) ; // weitere Details hier unwichtig Alle Elemente einer Menge können aufgrund einer Größer-Gleich- Relation linear angeordnet werden Implementierung von Comparable bei "natürlicher" Ordnung als Teil der Klassenlogik (zb Bruch, Integer, Complex) Ab Java5 generisch für Referenztyp T : Implementierung von Comparator für weitere Sortierkriterien In Klasse - oder durch separate Comparator-Klassen : Definieren weitere Kriterien - davon kann es beliebig viele geben interface Comparable<T> interface Comparator<T>

17 Beispiel: Interfaces java.lang.comparable java.util.comparator (85) import java.util.* ; class Mitarbeiter implements Comparable { public int persnr ; // eindeutige Ordnung public String name ; public Mitarbeiter( int nr, String n ) { /* */ // public int compareto( Object o ) { Mitarbeiter m = (Mitarbeiter) o ; return this.persnr m.persnr ; // Weiteres Sortierkriterium: name class NameComparator implements Comparator { public int compare( Object p, Object q ) { String s1 = ( (Mitarbeiter) p ).name ; String s2 = ( (Mitarbeiter) q ).name ; return s1.compareto( s2 ) ; import java.util.*; class Sorted { public static void main( String[ ] args ) { Mitarbeiter[ ] m = new Mitarbeiter[4] ; m[0] = new Mitarbeiter( 11, "Anna" ) ; m[1] = new Mitarbeiter( 5, "Ursula" ) ; m[2] = new Mitarbeiter( 7, "Wolf" ) ; m[3] = new Mitarbeiter( 13, "Bert" ) ; // Unsortierte Ausgabe: System.out.println( Arrays.toString( m ) ) ; // Sortieren nach compareto() Arrays.sort( m ) ; System.out.println( Arrays.toString( m ) ) ; // Sortieren nach NameComparator Arrays.sort( m, new NameComparator( ) ) ; System.out.println( Arrays.toString( m ) ) ;

18 Strategy-Pattern Inversion of dependencies (86) Dependeny-Inversion Principle : policy should not depend on details (R.C. Martin) 1. High-level modules should not depend on low-level modules. Both should depend on abstractions. 2. Abstractions should not depend on details. Details should depend on abstractions. High level modules contain the important policy decisions and business models of an application. Prinzip : Abhängigkeit von konkreten (und somit veränderlichen) Klassen minimieren Veränderliche Klassen hinter konstanten Interfaces verbergen Client gibt erforderliches Interface vor dieses ist von tieferen Schichten zu implementieren Prinzip: Entwerfe ein System Top Down (gemäß Vorgaben der höheren Schichten), statt Bottom Up (gemäß Vorgaben der tieferen Schichten) Keine triviale Forderung denn meist ist es historisch gewachsen anders: Quelle: R.C.Martin, Agile Software Development, S.128f Höhere Schichten nutzen "traditionellerweise" direkt die Services niedrigerer Schichten, rufen deren Methoden direkt auf, hängen somit von diesen direkt ab Deshalb die Forderung nach Inversion (Umkehr) der "üblichen" Abhängigkeiten!

19 Beispiel: Schalter & Lampe (87) Schalter (policy) und Lampe (detail) in traditioneller Abhängigkeit : Schalter-Klasse hängt direkt von Klasse Lampe ab Schalter kann nur Lampen-Objekte schalten - keine anderen Geräte. Jede Änderung in Klasse Lampe beeinflusst Klasse Schalter. Die Policy (high level) hängt von den Details (low level implementation) ab. Schalter + schalte() Lampe + schalteein() + schalteaus() Ziel : Inversion der Abhängigkeiten : Schalter-Klasse schreibt den Devices das geforderte Verhalten durch ein Interface vor Die Devices hängen auf diese Weise von den Forderungen des Clients ab! Analogie : Manger in Zentrale bekommt aus vielen Filialen Reports in jeweils anderem Format. Muss sich auf diese einstellen. "Dreht nun den Spieß um", indem er den Filialen ein festes Berichtsformat ("Formular" = IF) vorschreibt, das diese einhalten müssen. Dadurch ist auch die Hinzunahme weiterer Filialen kein Problem mehr, erfordert keine konzeptionelle Zusatzarbeit! class Schalter { private Lampe meinelampe ; public Schalter( Lampe lp ) { meinelampe = lp ; public void schalte( ) { if( /* */ ) meinelampe.schalteein( ) ; else meinelampe.schalteaus( ) ; class Lampe { public void schalteein( ) { /* */ public void schalteaus( ) { /* */

20 Beispiel: Schalter & Lampe Inversion der Abhängigkeiten : Schalter-Klasse fordert Devices-Verhalten durch Interface Devices hängen nun von Forderungen des Clients ab Schalter kann alle Geräte kontrollieren, die das Interface (grundlegende Verhaltensabstraktion) implementieren auch noch gar nicht "Erfundene" Deren Details spielen für Systemstruktur keine Rolle mehr Systemstruktur viel flexibler Änderung in Klasse Lampe beeinflusst Klasse Schalter strukturell nicht. Schalter + schalte( ) Lampe << interface>> Schaltbar + schalteein( ) + schalteaus( ) Filter (88) Motor class Schalter { private Schaltbar meinserver ; public Schalter( Schaltbar s ) { meinserver = s ; public void schalte( ) { if( /* */ ) meinserver.schalteein( ) ; else meinserver.schalteaus( ) ; class Lampe implements Schaltbar { public void schalteein( ) { /* */ public void schalteaus( ) { /* */ class Motor implements Schaltbar { public void schalteein( ) { /* */ public void schalteaus( ) { /* */ Das Interface erlaubt, beliebige weitere nutzende Clients (Trigger, Hebel, Taster ) zu definieren.

21 Vorteile und Probleme von Interfaces (89) lt is, generally speaking, impossible to add a method to a public interface without breaking all existing classes that implement the interface. Classes that previously implemented the interface will be missing the new method and won't compile anymore. You could limit the damage somewhat by adding the new method to the skeletal implementation at the same time as you add it to the interface, but this really wouldn't solve the problem. Any implementation that didn't inherit from the skeletal implementation would still be broken. Public interfaces, therefore, must be designed carefully. Once an interface is released and widely implemented, it is almost impossible to change. You really must get it right the first time. If an interface contains a minor flaw, it will irritate you and its users forever. If an interface is severely deficient, it can doom an API. The best thing to do when releasing a new interface is to have as many programmers as possible implement the interface in as many ways as possible before the interface is frozen. This will allow you to discover flaws while you can still correct them. To summarize, an interface is generally the best way to define a type that permits multiple implementations. If you export a nontrivial interface, you should strongly consider providing a skeletal implementation to go with it. Finally, you should design all of your public interfaces with the utmost care and test them thoroughly by writing multiple implementations. Joshua Bloch, Effective Java S.97

22 Vorteile von Interfaces Denken + Entwickeln via Schnittstellen (90) 1. Interfaces fördern den modularen Aufbau von Systemen Prinzip Separation of Concerns wird unterstützt Reduktion der Abhängigkeiten Wartbarkeit gefördert durch klar definierte funktionale Einheiten 2. Interfaces fördern das Information Hiding schon beim Entwurf von Systemen Kein "Drauflos-Implementieren" - sondern thematische Strukturierung "Rauschen der Implementierung" kommt erst später Konzentration auf Semantik der Schnittstelle Konzentration auf saubere + sinnvolle Signaturen + den Sinn von Schnittstellen Prinzip Kohäsion : Vollständigkeit + funktionaler Zusammenhang 3. Interfaces verbessern spätere Implementierung Implementierung hat klare Basis + eindeutige semantische Zielrichtung Lose Kopplung zwischen Schnittstelle + Implementierung Leichtere Austauschbarkeit der Implementierung (Testen, Warten, Upgrade) Open-Closed-Prinzip: Software soll offen sein für Erweiterungen aber abgeschlossen für Änderungen (Konstanz der Schnittstelle)

23 Grundsätze des OO-Designs Grundeinheit des OO-Programmierens ist die Klasse Aber Grundeinheit des OO-Entwurfs ist der Typ! (91) Abstrahiere von der konkreten Implementierung denn diese ist austauschbar Programmiere gegen Interfaces nicht gegen konkrete Klassen Abhängigkeiten von Abstraktionen herstellen nicht von Konkretisierungen Hohe Abstraktion statt vorschneller Konkretisierung alles Konkrete veraltet schnell Implementierungen müssen austauschbar sein + Erweiterungen leicht möglich sein Denke in Verträgen + Service-Anforderungen nicht in Details von Algorithmen Entkopple Konsumenten und Produzenten durch Interfaces (Service-Verträge) Garantiert werden keine Implementierungsdetails, sondern die Einhaltung von Service-Verträgen, die in Interfaces festgeschrieben sind Die Seele des Ganzen ist die sinnvolle Typisierung nicht die konkrete Implementierung Erfinde das Rad nicht zweimal orientiere dich an Design-Patterns Modellieren ist grundlegender als Implementieren ( nicht mehr oder weniger wichtig)

24 @Annotations : Meta-Informationen zu Klassen + Methoden (92) Annotations do not directly affect program semantics, but they do affect the way programs are treated by tools [ ]. Annotations can be read from source files, class files, or reflectively at run time. Typical application programmers will never have to define an annotation type, but it is not hard to do so. Als spezielle Art von "Interface" Teil von Java Compiler prüft syntaktische Test{ Können Elemente enthalten, die bei Verwendung mit passenden Werten zu füllen sind : Nur primitive Typen, Strings, Arrays Elemente ohne Parameter / Exceptions! Default-Werte können hinterlegt Copyright { String author( ) ; int year( ) author="sap AG", year = 2013 ) public class SomethingNew { Annotierbarkeit : Zulässig nur vor Package, Klasse, Interface, Methode, Attribut, Parameter, lokale void tuwas( ) { /* nur Test */

25 @Annotations : Meta-Informationen zu Klassen + Methoden (93) Marker-Quelltext-Auswertung durch Tools zur Erstellung von Ressourcen Javadoc JUnit Teilweise durch @Deprecated Einkompiliert in Bytecode - zur LZ-Auswertung via Reflection java.lang.annotation Liefert Frameworks + Containern Informationen Parametrisierbar Annotationen können selbst Meta-Annotationen besitzen Auslesbarkeit / Anwendbarkeit / Übernahme in Javadoc / Vererbbarkeit / durch Meta-Annotationen einschränkbar Paket java.lang.annotation Enthält zahlreiche Meta-Annotationen

26 @Annotations : Weitere Techniken Mark{ // keine Elemente, reiner Marker // Alle Annotationen beziehen sich auf Revision { int major( ) default 1 ; // Hinterlegen Defaults int minor( ) default 0 ClassVersionInfo { String created( ) ; String createdby( ) ; String lastmodified( ) ; String lastmodifiedby( ) ; Revision revision( ) // oder auch : Mark( created = " ", createdby = "H.Neuendorf", lastmodified = " ", lastmodifiedby = "H.Neuendorf", revision minor = 2 ) // Defaults bugsid = { "ArrayIndex", "NP", "IO-Exception" ) class TestKlasse BugsFixed { String[ ] bugsid( ) ; Für jede Annotation wird eigenes.class- File angelegt // Durch Annotationen kann man Intentionen ausdrücken, die von Tools / Frameworks berücksichtigt werden Ansätze der Aspekt-Orientierten Programmierung

27 (95) Interface-Erweiterungen in Java 8 Aufnahme von Implementierungen Statische Implementierte Methode Default-Implementierungen Rautenproblem + andere Kollisionen In seiner Idealform enthält ein Interface ausschließlich abstrakte Methoden - basta!! Erweiterung des IF-Konzepts beruht nicht auf vormailger Unvollständigkeit, sondern wurde durch Erweiterungen bei Lambda-Expressions erzwungen!

28 Java 8 Interfaces - Statische Methoden (96) Interfaces können statische implementierte Methoden enthalten (Tool / Utility) Modifizierer static ist explizit anzugeben! Statische Methoden des IFs haben Zugriff auf die Konstanten des IFs Die statischen Methoden sind nur auf dem Namen des Interfaces aufrufbar! Aufruf auf implementierender Klasse und deren Objekten ist nicht zulässig! interface IFPrice { public static final int MAX_PRICE = 1000 ; public static boolean isvalid( double p ) { return p > 0 && p < MAX_PRICE ; public abstract double calcprice( ) ; boolean b ; b = IFPrice.isValid( ) ; // ok! b = Price.isValid( ) ; // Fehler! Price pobj = new Price( ) ; b = pobj.isvalid( ) ; // Fehler! Nun droht Mißbrauch des IF-Konzepts als Tooling-Deponie - besser : class Price implements IFPrice { /* */ Finale Tool-Klasse mit privatem Konstruktor

29 Java 8 Interfaces - Default Implementierungen (97) Interfaces können nicht-statische Methoden mit Standard-Implementierung enthalten Default-Methoden machen gewöhnliche IFs zu Erweiterten Schnittstellen Verhalten sich wie Methoden in abstrakten Klassen hinsichtlich Zugriff auf IF-Elemente Sinn : Hinzufügen weiterer Methoden zu IF ohne Implementierer zu invalidieren Erweiterung von IFs (Retrofitting) jederzeit kompatibel möglich! Implementierende Klassen können Default-Implementierung übernehmen Müssen diese nicht überschreiben - können es aber natürlich! interface IFPrice { // Schlüsselwort / Modifizierer default abstract public double calcprofit( ) ; default public double calcprice( ) { return ; default public void test( ) { // void-methode mit leerer Standard-Implementierung - ok! default public int check( ) { throw new RuntimeException( "not implemented" ) ; // ok! default public boolean hasprofit( ) { return calcprofit( ) > 0 ; // ok - Template-Muster!

30 Default Implementierungen - Mehrdeutigkeiten (98) IF kann von anderem IF geerbte Default-Methoden durch eigene Variante überschreiben Implementierende Klasse kann von Oberklasse erben, die auch solche Methode enthält Regel : Die Oberklasse setzt sich gegen das Interface durch! interface IFYes { default public boolean isok( ) { return true ; interface IFNo extends IFYes { default public boolean isok( ) { return false ; class Checker implements IFNo { /* */ new Checker().isOk( ) ; // liefert eindeutig false class Yes { public boolean isok( ) { return true ; class Checker extends Yes implements IFNo { /* */ new Checker().isOk( ) ; // liefert true!! IF kann von anderem IF geerbte Default-Methode abstrakt überschreiben = Implementierung entfernen Implementierende Klasse erbt dann nur abstrakte Methode! interface IFYes { default public boolean isok( ) { return true ; interface IFNo extends IFYes { abstract public boolean isok( ) ;

31 Default Implementierungen - Mehrdeutigkeiten (99) Klasse kann nicht zwei IFs implementieren, die dieselbe Default-Schnittstelle enthalten! interface IFYes { default public boolean isok( ) { return true ; interface IFNo { default public boolean isok( ) { return false ; class Checker implements IFYes, IFNo { /* */ // Fehler Klasse kann zwei IFs implementieren, die dieselbe Default- Schnittstelle enthalten - wenn in der Klasse die geerbten Default-Implementierungen überschrieben werden! interface IFYes { default public boolean isok( ) { return true ; interface IFNo { default public boolean isok( ) { return false ; class Checker implements IFYes, IFNo { // ok! public boolean isok( ) { return false ;

32 Default Implementierungen - super.-zgriff (100) Klasse kann geerbte Default-Implementierung überschreiben und trotzdem Orginal-Default-Implementierung des IFs nutzen Vorgehen : super.-aufruf gegen IF interface IFYes { default public boolean isok( ) { return true ; class Checker implements IFYes { public boolean isok( ) { return false ; public boolean optimist( ) { return IFYes.super.isOK( ) ; analog zur Klassen-Vererbung

Grundlagen der Programmierung Prof. H. Mössenböck. 15. Pakete

Grundlagen der Programmierung Prof. H. Mössenböck. 15. Pakete Grundlagen der Programmierung Prof. H. Mössenböck 15. Pakete Idee Paket = Sammlung zusammengehöriger Klassen (Bibliothek) Zweck mehr Ordnung in Programme bringen bessere Kontrolle der Zugriffsrechte (wer

Mehr

7. Pakete Grundlagen der Programmierung 1 (Java)

7. Pakete Grundlagen der Programmierung 1 (Java) 7. Pakete Grundlagen der Programmierung 1 (Java) Fachhochschule Darmstadt Haardtring 100 D-64295 Darmstadt Prof. Dr. Bernhard Humm FH Darmstadt, 29. November 2005 Einordnung im Kontext der Vorlesung 1.

Mehr

3 Objektorientierte Konzepte in Java

3 Objektorientierte Konzepte in Java 3 Objektorientierte Konzepte in Java Bisherige Beobachtungen zu Objekten: werden in Klassen zusammengefasst besitzen Eigenschaften und Verhalten verbergen private Informationen werden geboren, leben und

Mehr

Java für C++ Programmierer

Java für C++ Programmierer Java für C++ Programmierer Alexander Bernauer bernauer@inf.ethz.ch Einführung in die Übungen zu Informatik II (D ITET) FS2010 ETH Zürich Ziel Allgemeiner Überblick Kennenlernen der Suchbegriffe Warum Java?

Mehr

Verhindert, dass eine Methode überschrieben wird. public final int holekontostand() {...} public final class Girokonto extends Konto {...

Verhindert, dass eine Methode überschrieben wird. public final int holekontostand() {...} public final class Girokonto extends Konto {... PIWIN I Kap. 8 Objektorientierte Programmierung - Vererbung 31 Schlüsselwort: final Verhindert, dass eine Methode überschrieben wird public final int holekontostand() {... Erben von einer Klasse verbieten:

Mehr

3 Objektorientierte Konzepte in Java

3 Objektorientierte Konzepte in Java 3 Objektorientierte Konzepte in Java 3.1 Klassendeklarationen Fragen an die Klassendeklaration: Wie heißt die Klasse? Wer darf auf die Klasse und ihre Attribute/Methoden zugreifen? Ist die Klasse eine

Mehr

Vererbung & Schnittstellen in C#

Vererbung & Schnittstellen in C# Vererbung & Schnittstellen in C# Inhaltsübersicht - Vorüberlegung - Vererbung - Schnittstellenklassen - Zusammenfassung 1 Vorüberlegung Wozu benötigt man Vererbung überhaubt? 1.Um Zeit zu sparen! Verwendung

Mehr

Einstieg in die Informatik mit Java

Einstieg in die Informatik mit Java Vorlesung vom 18.4.07, Grundlagen Übersicht 1 Kommentare 2 Bezeichner für Klassen, Methoden, Variablen 3 White Space Zeichen 4 Wortsymbole 5 Interpunktionszeichen 6 Operatoren 7 import Anweisungen 8 Form

Mehr

1 Polymorphie (Vielgestaltigkeit)

1 Polymorphie (Vielgestaltigkeit) 1 Polymorphie (Vielgestaltigkeit) Problem: Unsere Datenstrukturen List, Stack und Queue können einzig und allein int-werte aufnehmen. Wollen wir String-Objekte, andere Arten von Zahlen oder andere Objekttypen

Mehr

Programmieren in Java

Programmieren in Java Programmieren in Java objektorientierte Programmierung 2 2 Zusammenhang Klasse-Datei In jeder *.java Datei kann es genau eine public-klasse geben wobei Klassen- und Dateiname übereinstimmen. Es können

Mehr

Kapitel 6. Vererbung

Kapitel 6. Vererbung 1 Kapitel 6 2 Ziele Das sprinzip der objektorientierten Programmierung verstehen Und in Java umsetzen können Insbesondere folgende Begriffe verstehen und anwenden können: Ober/Unterklassen Subtyping Überschreiben

Mehr

Objektorientierte Programmierung. Kapitel 12: Interfaces

Objektorientierte Programmierung. Kapitel 12: Interfaces 12. Interfaces 1/14 Objektorientierte Programmierung Kapitel 12: Interfaces Stefan Brass Martin-Luther-Universität Halle-Wittenberg Wintersemester 2012/13 http://www.informatik.uni-halle.de/ brass/oop12/

Mehr

Javadoc. Programmiermethodik. Eva Zangerle Universität Innsbruck

Javadoc. Programmiermethodik. Eva Zangerle Universität Innsbruck Javadoc Programmiermethodik Eva Zangerle Universität Innsbruck Überblick Einführung Java Ein erster Überblick Objektorientierung Vererbung und Polymorphismus Ausnahmebehandlung Pakete und Javadoc Spezielle

Mehr

Kapitel 6. Vererbung

Kapitel 6. Vererbung 1 Kapitel 6 2 Ziele Das sprinzip der objektorientierten Programmierung verstehen Und in Java umsetzen können Insbesondere folgende Begriffe verstehen und anwenden können: Ober/Unterklassen Subtyping Überschreiben

Mehr

Kapitel 6. Vererbung

Kapitel 6. Vererbung Kapitel 6 Vererbung Vererbung 1 Ziele Das Vererbungsprinzip der objektorientierten Programmierung verstehen Und in Java umsetzen können Insbesondere folgende Begriffe verstehen und anwenden können: Ober/Unterklassen

Mehr

Java für Computerlinguisten

Java für Computerlinguisten Java für Computerlinguisten 2. Objektorientierte Programmierung Christian Scheible Institut für Maschinelle Sprachverarbeitung 28. Juli 2009 Christian Scheible Java für Computerlinguisten 28. Juli 2009

Mehr

Javakurs FSS Lehrstuhl Stuckenschmidt. Tag 3 - Objektorientierung

Javakurs FSS Lehrstuhl Stuckenschmidt. Tag 3 - Objektorientierung Javakurs FSS 2012 Lehrstuhl Stuckenschmidt Tag 3 - Objektorientierung Warum Objektorientierung Daten und Funktionen möglichst eng koppeln und nach außen kapseln Komplexität der Software besser modellieren

Mehr

Java Einführung Methoden in Klassen

Java Einführung Methoden in Klassen Java Einführung Methoden in Klassen Lehrziel der Einheit Methoden Signatur (=Deklaration) einer Methode Zugriff/Sichtbarkeit Rückgabewerte Parameter Aufruf von Methoden (Nachrichten) Information Hiding

Mehr

5.6 Vererbung. Vererbung

5.6 Vererbung. Vererbung 5.6 Vererbung Klassen können zueinander in einer "ist ein"- Beziehung stehen Beispiel: Jeder PKW ist ein Kraftfahrzeug, jedes Kraftfahrzeug ist ein Transportmittel aber: auch jeder LKW ist ein Kraftfahrzeug

Mehr

Einführung in Javadoc

Einführung in Javadoc Einführung in Javadoc Johannes Rinn http://java.sun.com/j2se/javadoc Was ist Javadoc? Javadoc ist ein Werkzeug, dass eine standardisierte Dokumentation für die Programmiersprache Java unterstützt. Vorteil:

Mehr

7. Objektorientierte Softwareentwicklung/3. Informatik II für Verkehrsingenieure

7. Objektorientierte Softwareentwicklung/3. Informatik II für Verkehrsingenieure 7. Objektorientierte Softwareentwicklung/3 Informatik II für Verkehrsingenieure Überblick FOLGENDE BEGRIFFE/PRINZIPIEN SOLLTEN BEKANNT SEIN Objekte Klasse Attribute Fähigkeiten ZIEL DER HEUTIGEN LEHRVERANSTALTUNG

Mehr

1 Abstrakte Klassen, finale Klassen und Interfaces

1 Abstrakte Klassen, finale Klassen und Interfaces 1 Abstrakte Klassen, finale Klassen und Interfaces Eine abstrakte Objekt-Methode ist eine Methode, für die keine Implementierung bereit gestellt wird. Eine Klasse, die abstrakte Objekt-Methoden enthält,

Mehr

Die Bedeutung abstrakter Datentypen in der objektorientierten Programmierung. Klaus Kusche, September 2014

Die Bedeutung abstrakter Datentypen in der objektorientierten Programmierung. Klaus Kusche, September 2014 Die Bedeutung abstrakter Datentypen in der objektorientierten Programmierung Klaus Kusche, September 2014 Inhalt Ziel & Voraussetzungen Was sind abstrakte Datentypen? Was kann man damit grundsätzlich?

Mehr

5.5.8 Öffentliche und private Eigenschaften

5.5.8 Öffentliche und private Eigenschaften 5.5.8 Öffentliche und private Eigenschaften Schnittstellen vs. Implementierungen: Schnittstelle einer Klasse beschreibt, was eine Klasse leistet und wie sie benutzt werden kann, ohne dass ihre Implementierung

Mehr

Silke Trißl, Prof. Ulf Leser Wissensmanagement in der Bioinformatik. Jede Applikation braucht eine Klasse mit einer main-methode

Silke Trißl, Prof. Ulf Leser Wissensmanagement in der Bioinformatik. Jede Applikation braucht eine Klasse mit einer main-methode Methoden und Klassen Silke Trißl, Prof. Ulf Leser Wissensmanagement in der Bioinformatik Wiederholung Jede Applikation braucht eine Klasse mit einer main-methode Eintrittspunkt in das Programm Die main-methode

Mehr

Java-Schulung Grundlagen

Java-Schulung Grundlagen Java-Schulung Grundlagen Java 2 Standard Edition JDK 5 / 6 31.05.2008 Marcel Wieczorek 1 Themenübersicht Basiswissen Objektorientierung Datentypen Fehlerbehandlung Sonstiges Einführung Klassen, Strings

Mehr

Eine Klasse beschreibt Objekte mit gleichen Attributen und Methoden.

Eine Klasse beschreibt Objekte mit gleichen Attributen und Methoden. Grundwissen Informatik Objekt Attribut Methoden Als Objekte bezeichnet man alle Gegenstände, Dinge, Lebewesen, Begriffe oder Strukturen unserer Welt ( Autos, Räume, Bakterien, Lehrer, Schüler, Kunden,

Mehr

Einführung in die Programmierung

Einführung in die Programmierung Technische Universität München WS 2003/2004 Institut für Informatik Prof. Dr. Christoph Zenger Testklausur Einführung in die Programmierung Probeklausur Java (Lösungsvorschlag) 1 Die Klasse ArrayList In

Mehr

Objektorientierte Programmierung. Kapitel 16: Pakete, Zugriffsschutz

Objektorientierte Programmierung. Kapitel 16: Pakete, Zugriffsschutz Stefan Brass: OOP (Java), 16. Pakete, Zugriffsschutz 1/30 Objektorientierte Programmierung Kapitel 16: Pakete, Zugriffsschutz Stefan Brass Martin-Luther-Universität Halle-Wittenberg Wintersemester 2013/14

Mehr

Algorithmen und Datenstrukturen 07

Algorithmen und Datenstrukturen 07 5. Dezember 2011 1 Besprechung Blatt 6 Fragen 2 Vererbung Allgemein abstract Interfaces 3 Unified Modeling Language (UML) Ablaufdiagramme Klassendiagramme Anwendungsfalldiagramme 4 Vorbereitung Blatt 7

Mehr

Einführung in die. objektorientierte Programmierung

Einführung in die. objektorientierte Programmierung Einführung in die objektorientierte Programmierung Teil 3 Vererbung Modul WI111: Objektorientierte Programmierung Fachrichtung Wirtschaftsinformatik Prof. Dr. Gert Faustmann Fachbereich Berufsakademie

Mehr

Prinzipien Objektorientierter Programmierung

Prinzipien Objektorientierter Programmierung Prinzipien Objektorientierter Programmierung Valerian Wintner Inhaltsverzeichnis 1 Vorwort 1 2 Kapselung 1 3 Polymorphie 2 3.1 Dynamische Polymorphie...................... 2 3.2 Statische Polymorphie........................

Mehr

Abschnitt 9: Schnittstellen: Interfaces

Abschnitt 9: Schnittstellen: Interfaces Abschnitt 9: Schnittstellen: Interfaces 9. Schnittstellen: Interfaces 9.1 Die Idee der Schnittstellen 9.2 Schnittstellen in Java 9.3 Marker-Interfaces 9.4 Interfaces und Hilfsklassen 9.5 Zusammenfassung

Mehr

Java Schulung (Java 2 Java Development Kit 5 / 6)

Java Schulung (Java 2 Java Development Kit 5 / 6) 2. Grundlagen der Objektorientierung 2.1 Klassen, Attribute, Methoden Klassen Eine Klasse beschreibt als Bauplan Gemeinsamkeiten einer Menge von Objekten ist also ein Modell, auf dessen Basis Objekte erstellt

Mehr

Javakurs 2013 Objektorientierung

Javakurs 2013 Objektorientierung Javakurs 2013 Objektorientierung Objektorientierte Programmierung I Armelle Vérité 7 März 2013 Technische Universität Berlin This work is licensed under the Creative Commons Attribution-ShareAlike 3.0

Mehr

Java Einführung Packages

Java Einführung Packages Java Einführung Packages Inhalt dieser Einheit Packages (= Klassenbibliotheken) Packages erstellen Packages importieren Packages verwenden Standard Packages 2 Code-Reuse Einbinden von bereits (selbst-/fremd)

Mehr

Klassen in Java. Klassen

Klassen in Java. Klassen Klassen in Java Klassen Klassen beschreiben Objekte, die abstakte oder konkrete Sachverhalte modellieren. Objekte sind durch einen Status gekennzeichnet (State). Der Status eines Objektes ergibt sich aus

Mehr

Javakurs zu Informatik I. Henning Heitkötter

Javakurs zu Informatik I. Henning Heitkötter Javakurs zu Informatik I Arrays vergleichen Implementieren Sie folgende Methode, die prüft, ob die Elemente der beiden Arrays an jeder Position übereinstimmen: public static boolean identisch(int[] a,

Mehr

Objektorientierte Programmierung

Objektorientierte Programmierung Objektorientierte Programmierung 1 Geschichte Dahl, Nygaard: Simula 67 (Algol 60 + Objektorientierung) Kay et al.: Smalltalk (erste rein-objektorientierte Sprache) Object Pascal, Objective C, C++ (wiederum

Mehr

Einführung in die Informatik: Programmierung und Software-Entwicklung, WS 14/15. Kapitel 11. Fehler und Ausnahmen 1

Einführung in die Informatik: Programmierung und Software-Entwicklung, WS 14/15. Kapitel 11. Fehler und Ausnahmen 1 Kapitel 11 Fehler und Ausnahmen Fehler und Ausnahmen 1 Ziele Fehlerquellen in Programmen und bei der Programmausführung verstehen Das Java-Konzept der Ausnahmen als Objekte kennenlernen Ausnahmen auslösen

Mehr

Übersicht. Informatik 2 Teil 3 Anwendungsbeispiel für objektorientierte Programmierung

Übersicht. Informatik 2 Teil 3 Anwendungsbeispiel für objektorientierte Programmierung Übersicht 3.1 Modell Konto 3.2 Modell Konto - Erläuterungen 3.3 Benutzer Ein- und Ausgabe mit Dialogfenster I 3.4 Benutzer Ein- und Ausgabe mit Dialogfenster II 3.5 Klassen- und Objekteigenschaften des

Mehr

Vorkurs C++ Programmierung

Vorkurs C++ Programmierung Vorkurs C++ Programmierung Klassen Letzte Stunde Speicherverwaltung automatische Speicherverwaltung auf dem Stack dynamische Speicherverwaltung auf dem Heap new/new[] und delete/delete[] Speicherklassen:

Mehr

5.4 Klassen und Objekte

5.4 Klassen und Objekte 5.4 Klassen und Objekte Zusammenfassung: Projekt Figuren und Zeichner Figuren stellt Basisklassen für geometrische Figuren zur Verfügung Zeichner bietet eine übergeordnete Klasse Zeichner, welche die Dienstleistungen

Mehr

PIWIN I. Praktische Informatik für Wirtschaftsmathematiker, Ingenieure und Naturwissenschaftler I. Vorlesung 3 SWS WS 2007/2008

PIWIN I. Praktische Informatik für Wirtschaftsmathematiker, Ingenieure und Naturwissenschaftler I. Vorlesung 3 SWS WS 2007/2008 PIWIN I Kap. 7 Objektorientierte Programmierung - Einführung 1 PIWIN I Praktische Informatik für Wirtschaftsmathematiker, Ingenieure und Naturwissenschaftler I Vorlesung 3 SWS WS 2007/2008 FB Informatik

Mehr

Anwendungsentwicklung mit Java. Grundlagen der OOP, Vererbung, Schnittstellen, Polymorphie

Anwendungsentwicklung mit Java. Grundlagen der OOP, Vererbung, Schnittstellen, Polymorphie Anwendungsentwicklung mit Java Grundlagen der OOP, Vererbung, Schnittstellen, Polymorphie Vererbung (1) 2 Problem: Objekte mit gleichen Attributen/Methoden, aber nicht völlig identisch, z.b., LKW, PKW,

Mehr

Geschachtelte Klassen

Geschachtelte Klassen Geschachtelte Klassen Die Programmiersprache Java bietet nicht nur die Möglichkeit innerhalb von Klassen Datenfelder und Methoden zu definieren, sondern auch Klassen. Solche Klassen heißen en geschachtelte

Mehr

Info B VL 8: Abstrakte Klassen & Interfaces

Info B VL 8: Abstrakte Klassen & Interfaces Info B VL 8: Abstrakte Klassen & Interfaces Objektorientiere Programmierung in Java 2003 Ute Schmid (Vorlesung) Elmar Ludwig (Übung) FB Mathematik/Informatik, Universität Osnabrück Info B VL 8: Abstrakte

Mehr

Aufbau einer typischen Java-Datei

Aufbau einer typischen Java-Datei Aufbau einer typischen Java-Datei 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 [package mein.paket;] [import

Mehr

Programmieren I. Dokumentation mit javadoc Heusch 10.4 Ratz Institut für Angewandte Informatik

Programmieren I. Dokumentation mit javadoc Heusch 10.4 Ratz Institut für Angewandte Informatik Programmieren I Dokumentation mit javadoc Heusch 10.4 Ratz 4.1.1 KIT Die Forschungsuniversität in der Helmholtz-Gemeinschaft www.kit.edu Automatische Dokumentation Java bietet standardmäßig das Dokumentationssystem

Mehr

Datenbankanwendungsprogrammierung Crashkurs Java

Datenbankanwendungsprogrammierung Crashkurs Java Datenbankanwendungsprogrammierung Crashkurs Java Denny Priebe Datenbankanwendungsprogrammierung p. Unterschiede zu C, C++ typedefs, Präprozessor Strukturen, Unions globale Funktionen Mehrfachvererbung

Mehr

Abschnitt 12: Strukturierung von Java-Programmen: Packages

Abschnitt 12: Strukturierung von Java-Programmen: Packages Abschnitt 12: Strukturierung von Java-Programmen: Packages 12. Strukturierung von Java-Programmen: Packages 12.1 Strukturierung durch Packages 12.2 Zugriffsspezifikationen 12.3 Zusammenfassung 12 Strukturierung

Mehr

Java Generics & Collections

Java Generics & Collections Java Praktikum Effizientes Programmieren (Sommersemester 2015) Dennis Reuling Agenda 1 2 3 1 / 30 Praktikum Effizientes Programmieren (Sommersemester 2015) Java Subtyping Teil 1 2 / 30 Praktikum Effizientes

Mehr

Probeklausur: Programmierung WS04/05

Probeklausur: Programmierung WS04/05 Probeklausur: Programmierung WS04/05 Name: Hinweise zur Bearbeitung Nimm Dir für diese Klausur ausreichend Zeit, und sorge dafür, dass Du nicht gestört wirst. Die Klausur ist für 90 Minuten angesetzt,

Mehr

Objekt-Orientierte Programmierung

Objekt-Orientierte Programmierung Objekt-Orientierte Programmierung Ein OO-Programm modelliert eine Anwendung als eine Welt von Objekten, die miteinander in Beziehung stehen ( später). Ein Objekt kann andere Objekte erzeugen. Ein Objekt

Mehr

Konstruktoren, Packages und Scopes

Konstruktoren, Packages und Scopes Universität Bayreuth Lehrstuhl für Angewandte Informatik IV Datenbanken und Informationssysteme Prof. Dr.-Ing. Jablonski Konstruktoren, Packages und Scopes Dipl. Inf. Manuel Götz Lehrstuhl für Angewandte

Mehr

Java Kurs für Anfänger Einheit 5 Methoden

Java Kurs für Anfänger Einheit 5 Methoden Java Kurs für Anfänger Einheit 5 Methoden Ludwig-Maximilians-Universität München (Institut für Informatik: Programmierung und Softwaretechnik von Prof.Wirsing) 22. Juni 2009 Inhaltsverzeichnis Methoden

Mehr

Einstieg in die Informatik mit Java

Einstieg in die Informatik mit Java 1 / 16 Einstieg in die Informatik mit Java Innere Klassen Gerd Bohlender Institut für Angewandte und Numerische Mathematik Gliederung 2 / 16 1 Einführung 2 Element-Klassen 3 Lokale Klassen 4 Anonyme Klassen

Mehr

Kapitel 9: Klassen und höhere Datentypen. Klassen und höhere. Objekte, Felder, Methoden. Küchlin/Weber: Einführung in die Informatik

Kapitel 9: Klassen und höhere Datentypen. Klassen und höhere. Objekte, Felder, Methoden. Küchlin/Weber: Einführung in die Informatik Klassen und höhere Datentypen Objekte, Felder, Methoden Küchlin/Weber: Einführung in die Informatik Klassen Klasse (class) stellt einen (i.a. benutzerdefinierten) Verbund-Datentyp dar Objekte sind Instanzen

Mehr

Beispiele für Ausdrücke. Der imperative Kern. Der imperative Kern. Imperativer Kern - Kontrollstrukturen. Deklarationen mit Initialisierung

Beispiele für Ausdrücke. Der imperative Kern. Der imperative Kern. Imperativer Kern - Kontrollstrukturen. Deklarationen mit Initialisierung Beispiele für Ausdrücke Der imperative Kern Deklarationen mit Initialisierung Variablendeklarationen int i = 10; int j = 15; Beispiele für Ausdrücke i+j i++ i & j i j [] [static]

Mehr

Innere Klassen. Gerd Bohlender. Institut für Angewandte und Numerische Mathematik. Vorlesung: Einstieg in die Informatik mit Java

Innere Klassen. Gerd Bohlender. Institut für Angewandte und Numerische Mathematik. Vorlesung: Einstieg in die Informatik mit Java Innere Klassen Gerd Bohlender Institut für Angewandte und Numerische Mathematik Vorlesung: Einstieg in die Informatik mit Java 13.06.07 G. Bohlender (IANM UNI Karlsruhe) Innere Klassen 13.06.07 1 / 11

Mehr

Java Einführung Abstrakte Klassen und Interfaces

Java Einführung Abstrakte Klassen und Interfaces Java Einführung Abstrakte Klassen und Interfaces Interface Interface bieten in Java ist die Möglichkeit, einheitliche Schnittstelle für Klassen zu definieren, die später oder/und durch andere Programmierer

Mehr

1. Grundzüge der Objektorientierung 2. Methoden, Unterprogramme und Parameter 3. Datenabstraktion 4. Konstruktoren 5. Vordefinierte Klassen

1. Grundzüge der Objektorientierung 2. Methoden, Unterprogramme und Parameter 3. Datenabstraktion 4. Konstruktoren 5. Vordefinierte Klassen 1. Grundzüge der Objektorientierung 2. Methoden, Unterprogramme und Parameter 3. Datenabstraktion 4. Konstruktoren 5. Vordefinierte Klassen II.2.3 Datenabstraktion - 1 - public class Rechteck { Selektoren

Mehr

Programmieren in Java

Programmieren in Java Programmieren in Java Dateien lesen und schreiben 2 Übersicht der heutigen Inhalte File Streams try-with-resources Properties csv-dateien 3 Klasse File Die Klasse java.io.file bietet Unterstützung im Umgang

Mehr

FH D. Objektorientierte Programmierung in Java FH D FH D. Prof. Dr. Ing. André Stuhlsatz. Wiederholung: Gerüstbeispiel. Vererbungshierarchie: Typ 0

FH D. Objektorientierte Programmierung in Java FH D FH D. Prof. Dr. Ing. André Stuhlsatz. Wiederholung: Gerüstbeispiel. Vererbungshierarchie: Typ 0 9 Objektorientierte Programmierung in Java Prof. Dr. Ing. André Stuhlsatz Wiederholung: Gerüstbeispiel Ein Duo, Quarto oder Sexto ist ein Gerüst. Die Klassen Duo, Quarto und Sexto sollen durch Vererbung

Mehr

II. Grundlagen der Programmierung. 9. Datenstrukturen. Daten zusammenfassen. In Java (Forts.): In Java:

II. Grundlagen der Programmierung. 9. Datenstrukturen. Daten zusammenfassen. In Java (Forts.): In Java: Technische Informatik für Ingenieure (TIfI) WS 2005/2006, Vorlesung 9 II. Grundlagen der Programmierung Ekkart Kindler Funktionen und Prozeduren Datenstrukturen 9. Datenstrukturen Daten zusammenfassen

Mehr

1. Der Einstieg in Java. Was heißt Programmieren?

1. Der Einstieg in Java. Was heißt Programmieren? 1. Der Einstieg in Java Lernziele: Am Ende dieses Kapitels sollen Sie wissen, aus welchen Bestandteilen ein Java-Programm besteht, Java-Programme übersetzen und ausführen können, Möglichkeiten der Kommentierung

Mehr

Problemstellung. Informatik B - Objektorientierte Programmierung in Java. Vorlesung 24: Reflection 1. IDE und automatische Tests.

Problemstellung. Informatik B - Objektorientierte Programmierung in Java. Vorlesung 24: Reflection 1. IDE und automatische Tests. Universität Osnabrück 1 Problemstellung 3 - Objektorientierte Programmierung in Java Vorlesung 24: Reflection 1 SS 2006 Prof. Dr. Frank M. Thiesing, FH Osnabrück Um ein Objekt anzulegen, eine seiner Methoden

Mehr

Algorithmische Kernsprache. Zuweisung, einfache und bedingte Anweisung, Blöcke, Schleifen, return, debugging.

Algorithmische Kernsprache. Zuweisung, einfache und bedingte Anweisung, Blöcke, Schleifen, return, debugging. Algorithmische Kernsprache Zuweisung, einfache und bedingte Anweisung, Blöcke, Schleifen, return, debugging. Ausdrücke Anweisungen Ausdrücke bezeichnen einen Wert Kontext stellt Werte von Variablen Werte

Mehr

Repetitorium Informatik (Java)

Repetitorium Informatik (Java) Repetitorium Informatik (Java) Tag 6 Lehrstuhl für Informatik 2 (Programmiersysteme) Übersicht 1 Klassen und Objekte Objektorientierung Begrifflichkeiten Deklaration von Klassen Instanzmethoden/-variablen

Mehr

Programmieren II. Innere Klassen. Heusch 10, Ratz 5.2.1, Institut für Angewandte Informatik

Programmieren II. Innere Klassen. Heusch 10, Ratz 5.2.1, Institut für Angewandte Informatik Programmieren II Innere Klassen Heusch 10, 13.10 Ratz 5.2.1, 9.8 KIT Die Forschungsuniversität in der Helmholtz-Gemeinschaft www.kit.edu Innere Klassen Bisher kennen wir nur Klassen, die entweder zusammen

Mehr

Pakete dienen dazu, die Software eines Projektes in größere inhaltlich zusammengehörige Bereiche mit eigenem Namen einzuteilen (siehe Java API).

Pakete dienen dazu, die Software eines Projektes in größere inhaltlich zusammengehörige Bereiche mit eigenem Namen einzuteilen (siehe Java API). Paketdeklaration Paketdeklaration package Bezeichner ; Pakete dienen dazu, die Software eines Projektes in größere inhaltlich zusammengehörige Bereiche mit eigenem Namen einzuteilen (siehe Java API). Ein

Mehr

Übung 1 mit C# 6.0 MATTHIAS RONCORONI

Übung 1 mit C# 6.0 MATTHIAS RONCORONI Übung 1 mit C# 6.0 MATTHIAS RONCORONI Inhalt 2 1. Überblick über C# 2. Lösung der Übung 1 3. Code 4. Demo C# allgemein 3 aktuell: C# 6.0 mit.net-framework 4.6: Multiparadigmatisch (Strukturiert, Objektorientiert,

Mehr

Objektorientierte Programmierung mit Python Polymorphismus und Vererbung. Eltern

Objektorientierte Programmierung mit Python Polymorphismus und Vererbung. Eltern Objektorientierte Programmierung mit Python Polymorphismus und Vererbung Eltern Kind Kind Kind Kind Prinzipien der objektorientierten Programmierung Vererbung Strukturierung von Klassen. Oberbegriffe beschreiben

Mehr

Programmierkurs Java

Programmierkurs Java Programmierkurs Java Konstruktor, Statische Methoden Packages Prof. Dr. Stefan Fischer Institut für Telematik, Universität zu Lübeck http://www.itm.uni-luebeck.de/people/fischer Initialisierung von Datenstrukturen

Mehr

Javakurs für Anfänger

Javakurs für Anfänger Javakurs für Anfänger Einheit 02: Klassen & Objekte Lorenz Schauer Lehrstuhl für Mobile und Verteilte Systeme Heutige Agenda 1. Teil: Klassen Grundstruktur einer Java-Klasse Eigenschaften (Attribute) Variablen

Mehr

Test zu Grundlagen der Programmierung Leitung: Michael Hahsler. 21. November 2003

Test zu Grundlagen der Programmierung Leitung: Michael Hahsler. 21. November 2003 Test zu Grundlagen der Programmierung Leitung: Michael Hahsler 1. November 00 Name Martrikelnummer Unterschrift Bitte kreuzen Sie das Studium an, für das Sie diese Prüfung ablegen: O Bakkalaureat Wirtschaftsinformatik

Mehr

Java-Programmierung. Remote Method Invocation - RMI

Java-Programmierung. Remote Method Invocation - RMI Java-Programmierung Remote Method Invocation - RMI Entwicklungsmethoden Sockets Entwurf verteilter Anwendungen ist relativ aufwändig, da zunächst ein Kommunikationsprotokoll entwickelt werden muss aufwändig

Mehr

Objektorientierung: Klassen und Objekte

Objektorientierung: Klassen und Objekte Objektorientierung: Klassen und Objekte Klasse: Beschreibung für eine Menge von Objekten Schablone, Bauplan abstrakte Form Objekt: Instanz einer Klasse konkreter Inhalt (Werte) Klassen bestehen aus Attributen

Mehr

Interaktionen zwischen Objekten durch Senden von Nachrichten und Reagieren auf empfangene Nachrichten

Interaktionen zwischen Objekten durch Senden von Nachrichten und Reagieren auf empfangene Nachrichten Objekt Objekt kapselt Variablen und Routinen Interaktionen zwischen Objekten durch Senden von Nachrichten und Reagieren auf empfangene Nachrichten Eigenschaften jedes Objekts: Identität (identisch = mehrere

Mehr

4 Vererbung, Polymorphie

4 Vererbung, Polymorphie 4 Vererbung, Polymorphie Jörn Loviscach Versionsstand: 21. März 2014, 22:57 Die nummerierten Felder sind absichtlich leer, zum Ausfüllen beim Ansehen der Videos: http://www.j3l7h.de/videos.html This work

Mehr

Programmieren I. Prinzipieller Ablauf. Eigenschaften von JAVA. Source-Code Javac Bytecode. Java Virtual Machine (Java, Browser, Appletviewer)

Programmieren I. Prinzipieller Ablauf. Eigenschaften von JAVA. Source-Code Javac Bytecode. Java Virtual Machine (Java, Browser, Appletviewer) Programmieren I Grundlagen von JAVA Dr. Klaus Höppner Hello World in JAVA Hochschule Darmstadt WS 2007/2008 Elementare Datentypen 1 / 17 2 / 17 Eigenschaften von JAVA Prinzipieller Ablauf Plattform-und

Mehr

Musterlösung zur Vorlesung Modellbasierte Softwareentwicklung Wintersemester 2014/2015 Übungsblatt 9

Musterlösung zur Vorlesung Modellbasierte Softwareentwicklung Wintersemester 2014/2015 Übungsblatt 9 Prof. Dr. Wilhelm Schäfer Paderborn, 15. Dezember 2014 Christian Brenner Tristan Wittgen Musterlösung zur Vorlesung Modellbasierte Softwareentwicklung Wintersemester 2014/2015 Übungsblatt 9 Aufgabe 1 Codegenerierung

Mehr

Client-Server-Beziehungen

Client-Server-Beziehungen Client-Server-Beziehungen Server bietet Dienste an, Client nutzt Dienste Objekt ist gleichzeitig Client und Server Vertrag zwischen Client und Server: Client erfüllt Vorbedingungen eines Dienstes Server

Mehr

Innere Klassen in Java

Innere Klassen in Java Innere Klassen in Java SS 2012 Prof. Dr. Margarita Esponda Innere Klassen Klassen- oder Interfacedefinitionen können zur besseren Strukturierung von Programmen verschachtelt werden Eine "Inner Class" wird

Mehr

Programmieren I. Kapitel 8. Vererbung

Programmieren I. Kapitel 8. Vererbung Programmieren I Kapitel 8. Vererbung Kapitel 8: Vererbung Ziel: Wesentliches objektorientiertes Konzept kennenlernen Subtypen Idee Probleme und Varianten Vererbung in Java dynamische Bindung abstrakte

Mehr

AuD-Tafelübung T-B5b

AuD-Tafelübung T-B5b 6. Übung Sichtbarkeiten, Rekursion, Javadoc Di, 29.11.2011 1 Blatt 5 2 OOP Klassen Static vs. Instanzen Sichtbarkeit 3 Stack und Heap Stack Heap 4 Blatt 6 1 Blatt 5 2 OOP Klassen Static vs. Instanzen Sichtbarkeit

Mehr

7. Schnittstellen Grundlagen zu Schnittstellen. 7. Schnittstellen

7. Schnittstellen Grundlagen zu Schnittstellen. 7. Schnittstellen 7. Schnittstellen Grundlagen zu Schnittstellen 7. Schnittstellen Eine Schnittstelle (Interface) ist eine Spezifikation eines Typs in Form eines Typnamens und einer Menge von Methoden, die keine Implementierungen

Mehr

Angewandte Mathematik und Programmierung

Angewandte Mathematik und Programmierung Angewandte Mathematik und Programmierung Einführung in das Konzept der objektorientierten Anwendungen zu mathematischen Rechnens WS 2013/14 Die Vererbung ermöglicht es, neue Klassen auf der Basis von schon

Mehr

Repetitorium Informatik (Java)

Repetitorium Informatik (Java) Repetitorium Informatik (Java) Tag 8 Lehrstuhl für Informatik 2 (Programmiersysteme) Übersicht 1 Vererbung Vererbung Statischer Typ Dynamischer Typ 2 Polymorphie Overloading: Methoden überladen Overriding:

Mehr

Liste Programmieren Java Überblick

Liste Programmieren Java Überblick Liste Programmieren Java Überblick 1 Was ist Java? 2 Klassen und Objekte 3 Vererbung 4 Schnittstellen 5 Innere Klassen 6 Exceptions 8 Datenstrukturen und Algorithmen 9 Ein-/Ausgabe 10 Threads 11 GUI-Programmierung

Mehr

PIWIN I. Praktische Informatik für Wirtschaftsmathematiker, Ingenieure und Naturwissenschaftler I. Vorlesung 3 SWS WS 2008/2009

PIWIN I. Praktische Informatik für Wirtschaftsmathematiker, Ingenieure und Naturwissenschaftler I. Vorlesung 3 SWS WS 2008/2009 PIWIN I Kap. 8 Objektorientierte Programmierung - Vererbung 1 PIWIN I Praktische Informatik für Wirtschaftsmathematiker, Ingenieure und Naturwissenschaftler I Vorlesung 3 SWS WS 2008/2009 FB Informatik

Mehr

Einstieg in die Informatik mit Java

Einstieg in die Informatik mit Java 1 / 41 Einstieg in die Informatik mit Java Vererbung Gerd Bohlender Institut für Angewandte und Numerische Mathematik Gliederung 2 / 41 1 Überblick: Vererbung 2 Grundidee Vererbung 3 Verdeckte Variablen

Mehr

Vorlesung Informatik II

Vorlesung Informatik II Vorlesung Informatik II Universität Augsburg Wintersemester 2011/2012 Prof. Dr. Bernhard Bauer Folien von: Prof. Dr. Robert Lorenz Lehrprofessur für Informatik 02. JAVA: Erstes Programm 1 Das erste Java-Programm

Mehr

Teil 1: Grundeigenschaften von Rechnern und Software

Teil 1: Grundeigenschaften von Rechnern und Software Blatt Nummer: 1 Teil 1: Grundeigenschaften von Rechnern und Software Aufgabe 1.1 [2P] Welcher fundamentale Unterschied besteht zwischen dem Zweck eines Computer von dem Zweck anderer Maschinen (etwa einer

Mehr

Willkommen zur Vorlesung. Objektorientierte Programmierung Vertiefung - Java

Willkommen zur Vorlesung. Objektorientierte Programmierung Vertiefung - Java Willkommen zur Vorlesung Objektorientierte Programmierung Vertiefung - Java Zum Dozenten Mein Name: Andreas Berndt Diplom-Informatiker (TU Darmstadt) Derzeit Software-Entwickler für Web- Applikationen

Mehr

Schritt 4: Hallo Enterprise Bean

Schritt 4: Hallo Enterprise Bean Prof. Dr. Th. Letschert FB MNI JEE Schritt 4: Hallo Enterprise Bean Einstieg: EJBs erzeugen und nutzen Meine erstes EJB Projekt Enterprise Beans sind eine Backend Technologie, die mit unterschiedlichen

Mehr

Beispiel: Methode mit einem Fehler. Diese Methode wird problematisch, wenn von außen eine Dauer von 0 Sekunden angegeben wird, etwa im Aufruf

Beispiel: Methode mit einem Fehler. Diese Methode wird problematisch, wenn von außen eine Dauer von 0 Sekunden angegeben wird, etwa im Aufruf 16 Exceptions Zur Behandlung unerwarteter Situationen bietet Java Unterstützung in Form von Exceptions oder Ausnahmen. Den Sinn von Exceptions können wir Ihnen an einem kleinen Beispiel klarmachen. Nehmen

Mehr

Objects First With Java A Practical Introduction Using BlueJ. Mehr über Vererbung. Exploring polymorphism 1.0

Objects First With Java A Practical Introduction Using BlueJ. Mehr über Vererbung. Exploring polymorphism 1.0 Objects First With Java A Practical Introduction Using BlueJ Mehr über Vererbung Exploring polymorphism 1.0 Zentrale Konzepte dieses Kapitels Methoden-Polymorphie statischer und dynamischer Typ Überschreiben

Mehr

Theorie zu Übung 8 Implementierung in Java

Theorie zu Übung 8 Implementierung in Java Universität Stuttgart Institut für Automatisierungstechnik und Softwaresysteme Prof. Dr.-Ing. M. Weyrich Theorie zu Übung 8 Implementierung in Java Klasse in Java Die Klasse wird durch das class-konzept

Mehr

Java: Eine Übersicht. Dennis Giffhorn. Lehrstuhl für Programmierparadigmen Universität Karlsruhe

Java: Eine Übersicht. Dennis Giffhorn. Lehrstuhl für Programmierparadigmen Universität Karlsruhe Java: Eine Übersicht Dennis Giffhorn Lehrstuhl für Programmierparadigmen Universität Karlsruhe Allgemeines Objektorientiert Syntaxfamilie von C/C++ Statisch getypt Entwickelt von Sun Microsystems class

Mehr