Ü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

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

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

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

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

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

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

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

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

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 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

Ü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

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

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

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

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

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

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

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

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

2.4.3 Polymorphie (Wiederholung von Alp2)

2.4.3 Polymorphie (Wiederholung von Alp2) 2.4.3 Polymorphie (Wiederholung von Alp2) Sparbuch einsparbuch = new Sparbuch(3.0); Konto einkonto; KontoDrucker = new KontoDrucker(); KontoDrucker.setzeKonto(einSparbuch); einkonto = einsparbuch; Wie

Mehr

VIII: Vererbung. Unterklassen einer Klasse. Vererbung von Methoden und Instanzvariablen. Überschreiben von Methoden

VIII: Vererbung. Unterklassen einer Klasse. Vererbung von Methoden und Instanzvariablen. Überschreiben von Methoden VIII: Vererbung Unterklassen einer Klasse Vererbung von Methoden und Instanzvariablen Überschreiben von Methoden Vererbung als Realisierung einer is-a Beziehung. Informatik I VIII: Vererbung 259 Beispiel:

Mehr

Programmieren - Vererbung & Polymorphie

Programmieren - Vererbung & Polymorphie Programmieren - Vererbung & Polymorphie Reiner Nitsch r.nitsch@fbi.h-da.de Vererbung - Was ist das? Vererbung ist ein wichtiges Konzept zur Unterstützung der Wiederverwendbarkeit, wenn auch nicht das Wichtigste.

Mehr

1. Der Einstieg in Java

1. Der Einstieg in Java 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

Mehr

EINI I. Einführung in die Informatik für Naturwissenschaftler und Ingenieure. Vorlesung 2 SWS WS 10/11

EINI I. Einführung in die Informatik für Naturwissenschaftler und Ingenieure. Vorlesung 2 SWS WS 10/11 EINI I Einführung in die Informatik für Naturwissenschaftler und Ingenieure Vorlesung 2 SWS WS 10/11 Fakultät für Informatik Technische Universität Dortmund lars.hildebrand@udo.edu http://ls1-www.cs.uni-dortmund.de

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

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

Java: Vererbung. Teil 3: super() www.informatikzentrale.de

Java: Vererbung. Teil 3: super() www.informatikzentrale.de Java: Vererbung Teil 3: super() Konstruktor und Vererbung Kindklasse ruft SELBSTSTÄNDIG und IMMER zuerst den Konstruktor der Elternklasse auf! Konstruktor und Vererbung Kindklasse ruft SELBSTSTÄNDIG und

Mehr

Objektorientierte Programmierung. Objektorientierte Programmierung. Klasse. Objekt. Beispiel: Sportfest1. Methode. Eine Einführung mit BlueJ

Objektorientierte Programmierung. Objektorientierte Programmierung. Klasse. Objekt. Beispiel: Sportfest1. Methode. Eine Einführung mit BlueJ Objektorientierte Programmierung Objektorientierte Programmierung Eine Einführung mit BlueJ stellt die Daten, ihre Struktur und ihre Beziehungen zueinander in den Vordergrund. Weniger im Blickpunkt: die

Mehr

Schnittstellen implementieren am Beispiel Suchbaum

Schnittstellen implementieren am Beispiel Suchbaum Motivation Informatik mit Java und BlueJ Schnittstellen implementieren am Beispiel Suchbaum von Bernhard Rosing Schreiben Sie eine Klasse Person, deren Instanzen in ein TreeSet (Suchbaum) eingefügt werden

Mehr

C++ - Einführung in die Programmiersprache Polymorphismus und Vererbung. Eltern

C++ - Einführung in die Programmiersprache Polymorphismus und Vererbung. Eltern C++ - Einführung in die Programmiersprache Polymorphismus und Vererbung Eltern Kind Kind Vererbung Definition von Klassen auf Basis von bestehenden Klassen. Implementierung von ist ein. bildet ein hierarchisches

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

Einführung in Java. PING e.v. Weiterbildung Andreas Rossbacher 24. März 2005

Einführung in Java. PING e.v. Weiterbildung Andreas Rossbacher 24. März 2005 Einführung in Java PING e.v. Weiterbildung Andreas Rossbacher 24. März 2005 Gliederung 1. Was ist Java / Geschichte von Java 2. Prinzip der Plattformunabhängigkeit 3. Wie kommt man vom Quellcode zum Programm

Mehr

Rekursion. Was heißt "rekursiv" Page 1. Eine Methode m() heißt rekursiv, wenn sie sich selbst aufruft. Beispiel: Berechnung der Fakultät (n!

Rekursion. Was heißt rekursiv Page 1. Eine Methode m() heißt rekursiv, wenn sie sich selbst aufruft. Beispiel: Berechnung der Fakultät (n! Rekursion Was heißt "rekursiv" Eine Methode m() heißt rekursiv, wenn sie sich selbst aufruft m() { m(); direkt rekursiv m() { n() { m(); indirekt rekursiv Beispiel: Berechnung der Fakultät (n!) n! = 1

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

Erste Schritte in Java

Erste Schritte in Java Erste Schritte in Java Im einführenden Kapitel haben wir die Grundbegriffe der imperativen Programmierung an einem Beispiel (Algorithmus von Euklid) kennengelernt. In diesem Kapitel sehen wir uns an einem

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

C# im Vergleich zu Java

C# im Vergleich zu Java C# im Vergleich zu Java Serhad Ilgün Seminar Universität Dortmund SS 03 Gliederung Entstehung von C# und Java Überblick von C# und Java Unterschiede und Gemeinsamkeiten Zusammenfassung und Ausblick Entstehung

Mehr

Klassen und Unterklassen

Klassen und Unterklassen Klassen und Unterklassen Klassenfelder, Klassenmethoden, Applikationen,Unterklassen, Benutzung, Vererbung, super, over-riding, Systemklassen, Pakete, Applets Klassenfelder Manche Felder müssen nicht in

Mehr

Programmentwicklung ohne BlueJ

Programmentwicklung ohne BlueJ Objektorientierte Programmierung in - Eine praxisnahe Einführung mit Bluej Programmentwicklung BlueJ 1.0 Ein BlueJ-Projekt Ein BlueJ-Projekt ist der Inhalt eines Verzeichnisses. das Projektname heißt wie

Mehr

Kapitel 14. Systemarchitektur

Kapitel 14. Systemarchitektur 1 Kapitel 14 Ziele 2 Grundprinzipien der verstehen Schichtenarchitekturen kennenlernen Modelle und Programme mit Paketen strukturieren Eine Architektur für eine einfache Bankanwendung konstruieren Grundprinzipien

Mehr

Alexander Niemann. Das Einsteigerseminar Objektorientierte Programmierung in Java. bhv

Alexander Niemann. Das Einsteigerseminar Objektorientierte Programmierung in Java. bhv Alexander Niemann Das Einsteigerseminar Objektorientierte Programmierung in Java G bhv Inhaltsverzeichnis Vorwort 11 Einleitung 13 Lernen - Üben 13 Über dieses Buch 14 Ш11ШШШШ '. ш Ш Java 19 Die Geschichte

Mehr

Programmieren I. Strategie zum Entwurf von Klassen. Beispiele. Design von Klassen. Dr. Klaus Höppner. Beispiel: Bibliothek

Programmieren I. Strategie zum Entwurf von Klassen. Beispiele. Design von Klassen. Dr. Klaus Höppner. Beispiel: Bibliothek Programmieren I Dr. Klaus Höppner Hochschule Darmstadt Wintersemester 2008/2009 1 / 22 2 / 22 Strategie zum Entwurf von Klassen Beispiele Objektorientierte Sichtweise: Mit welchen Objekten habe ich es

Mehr

1. Grundlegende Eigenscha5en 2. Redefini+on 3. Polymophie 4. Mehrfachvererbung

1. Grundlegende Eigenscha5en 2. Redefini+on 3. Polymophie 4. Mehrfachvererbung K05 Vererbung & Polymorphie in C++ 1. Grundlegende Eigenscha5en 2. Redefini+on 3. Polymophie 4. Mehrfachvererbung 2 Vererbung in C++: Grundlagen Analog zu Java unterstützt C++ das Konzept der Vererbung:

Mehr

Java Tipps für Lehrer. Table des matières. Einleitung

Java Tipps für Lehrer. Table des matières. Einleitung Java Tipps für Lehrer Table des matières Einleitung..1 Tipp 1: Gültige Objekte erzeugen.2 Tipp 2: Objekte nicht wiederverwenden.3 Tipp 3: Direkt auf die eigenen Attribute zugreifen4 Tipp 4: Ausgabe-Strings

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

(H ist Entropie) bei Redundanz Information vielleicht mehrfach. Redundanz zur Fehlererkennung und -korrektur nutzbar

(H ist Entropie) bei Redundanz Information vielleicht mehrfach. Redundanz zur Fehlererkennung und -korrektur nutzbar Redundanz Anzahl der Bits H (H ist Entropie) Redundanz = Anzahl der Bits H bei Redundanz Information vielleicht mehrfach Redundanz zur Fehlererkennung und -korrektur nutzbar Redundanz in Programmen kann

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

einkonto.zahle(+100); //Transaktion Einzahlung einkonto.zahle(-20); //Transaktion Auszahlung einkonto.zahle(+30); //Transaktion Einzahlung

einkonto.zahle(+100); //Transaktion Einzahlung einkonto.zahle(-20); //Transaktion Auszahlung einkonto.zahle(+30); //Transaktion Einzahlung PIWIN I Kap. 7 Objektorientierte Programmierung - Einführung 28 Testklasse public class TestGirokonto { public static void main(string[] args) { // erzeuge neues Konto Girokonto einkonto = new Girokonto();

Mehr

Codegeneratoren mit Xtend2. 11.04.2012, A. Arnold

Codegeneratoren mit Xtend2. 11.04.2012, A. Arnold Codegeneratoren mit Xtend2 11.04.2012, A. Arnold Copyright 2012 anderscore GmbH Inhalt 1. Was ist Xtend2? 2. Xtend2 Konzepte 3. Hands On! 3 4 8 20 2 Was ist Xtend2? Funktionale, objektorientierte Sprache

Mehr

Objektorientierte Programmierung

Objektorientierte Programmierung Universität der Bundeswehr Fakultät für Informatik Institut 2 Priv.-Doz. Dr. Lothar Schmitz FT 2006 Zusatzaufgaben Lösungsvorschlag Objektorientierte Programmierung Lösung 22 (Java und UML-Klassendiagramm)

Mehr

Exceptions. Prof. Dr. Margarita Esponda SS 2012. M. Esponda-Argüero

Exceptions. Prof. Dr. Margarita Esponda SS 2012. M. Esponda-Argüero Exceptions Prof. Dr. Margarita Esponda SS 2012 1 Ausnahmen Eine Ausnahme (Exception) ist ein Fehler oder ein nicht geplantes Ereignis, das während der Ausführung eines Programms vorkommt und dessen normalen

Mehr

Von der UML nach C++

Von der UML nach C++ 22 Von der UML nach C++ Dieses Kapitel behandelt die folgenden Themen: Vererbung Interfaces Assoziationen Multiplizität Aggregation Komposition Die Unified Modeling Language (UML) ist eine weit verbreitete

Mehr

Autor: Michael Spahn Version: 1.0 1/10 Vertraulichkeit: öffentlich Status: Final Metaways Infosystems GmbH

Autor: Michael Spahn Version: 1.0 1/10 Vertraulichkeit: öffentlich Status: Final Metaways Infosystems GmbH Java Einleitung - Handout Kurzbeschreibung: Eine kleine Einführung in die Programmierung mit Java. Dokument: Autor: Michael Spahn Version 1.0 Status: Final Datum: 23.10.2012 Vertraulichkeit: öffentlich

Mehr

Grundlagen der Programmierung Prof. H. Mössenböck. 10. Klassen

Grundlagen der Programmierung Prof. H. Mössenböck. 10. Klassen Grundlagen der Programmierung Prof. H. Mössenböck 10. Klassen Motivation Wie würde man ein Datum speichern (z.b. 13. November 2004)? 3 Variablen int da; String month; int ear; Unbequem, wenn man mehrere

Mehr

Java Einführung Programmcode

Java Einführung Programmcode Java Einführung Programmcode Inhalt dieser Einheit Programmelemente Der erste Programmcode Die Entwicklungsumgebung: Sun's Java Software Development Kit (SDK) Vom Code zum Ausführen des Programms 2 Wiederholung:

Mehr

> Vererbung, Die Austauschbarkeit

> Vererbung, Die Austauschbarkeit Objektorientierte Programmierung (OOP) > Vererbung, Die Austauschbarkeit Mark Egloff 2006 1 Lernziel Heute Abend > Sie lernen wie Objekte gezielt kompatibel werden und somit ausgetauscht werden können

Mehr

Prüfungszeuch im Fach Objektorientierte Programmierung WS 2000

Prüfungszeuch im Fach Objektorientierte Programmierung WS 2000 Prüfungszeuch im Fach Objektorientierte Programmierung WS 2000 A. Beschreibung der Projektarbeit. Welche Aufgabe haben Sie im Rahmen der Projektarbeit gelöst? 2. Mit welchen Tools bzw. Programmen (Anwendung,

Mehr

Gliederung Grundlagen Schlüsselworte try-catch Fehlerobjekte Fehlerklassen Schlüsselwort finally Schlüsselwort throws selbst erstellte Exceptions

Gliederung Grundlagen Schlüsselworte try-catch Fehlerobjekte Fehlerklassen Schlüsselwort finally Schlüsselwort throws selbst erstellte Exceptions try-catch Schlüsselworte try-catch e Schlüsselwort Schlüsselwort selbst erstellte ermöglichen die Behandlung von Fehlern, die zur Laufzeit entstehen. try-catch in C: Fehler führt immer zum Abbruch des

Mehr

Übungen Informatik I. JAVA - Eclipse. elga Gabler, Holger Vogelsang, Christian Pape. Übungen Informatik 1 1

Übungen Informatik I. JAVA - Eclipse. elga Gabler, Holger Vogelsang, Christian Pape. Übungen Informatik 1 1 Übungen Informatik I JAVA - Eclipse Übungen Informatik 1 1 Integrierte Entwicklungsumgebungen Integrierte Entwicklungsumgebung (IDE): vereint Editor, Compiler, Debugger und andere Entwicklungswerkzeuge

Mehr

3. Konzepte der objektorientierten Programmierung

3. Konzepte der objektorientierten Programmierung 3. Konzepte der objektorientierten Programmierung 3.1 Basiskonzepte 3.2 Generalisierung / Spezialisierung 3.3 Aggregation 3.4 Assoziation 3.5 Nachrichten 3.6 Polymorphismus 3. Konzepte der Objektorientierung

Mehr

Software Engineering II

Software Engineering II Software Engineering II Codegenerierung für den SmartIO Editor mit der Modeling Workflow Engine Wintersemester 10/111 Fachgebiet Software Engineering Albert Zündorf / Wiederholung Bisher im Laufe des Semesters

Mehr

Enterprise Java Beans Einführung

Enterprise Java Beans Einführung Enterprise Java Beans Einführung Vorlesung 8 Ralf Gitzel ralf_gitzel@hotmail.de 1 Themenübersicht Ralf Gitzel ralf_gitzel@hotmail.de 2 Übersicht EJBs im JEE Umfeld Verschiedene Typen von EJBs Von der Javaklasse

Mehr

JMangler. Frithjof Kurtz. Universität Bonn, Seminar Softw aretechnologie WS 03/04, Jmangler Frithjof Kurtz 1

JMangler. Frithjof Kurtz. Universität Bonn, Seminar Softw aretechnologie WS 03/04, Jmangler Frithjof Kurtz 1 JMangler Frithjof Kurtz Universität Bonn, Seminar Softw aretechnologie WS 03/04, Jmangler Frithjof Kurtz 1 JMangler Vortragsgliederung Motivation Java Grundlagen JMangler Grundlagen Transformationen Algorithmen

Mehr

CORBA. Systemprogrammierung WS 2006-2007

CORBA. Systemprogrammierung WS 2006-2007 CORBA Systemprogrammierung WS 2006-2007 Teilnehmer: Bahareh Akherattalab Babak Akherattalab Inhaltsverzeichnis: Verteilte Systeme Vergleich zwischen lokale und verteilte Systeme Verteilte Anwendungen CORBA

Mehr

Java - Programmierung - Objektorientierte Programmierung 1

Java - Programmierung - Objektorientierte Programmierung 1 Java - Programmierung - Objektorientierte Programmierung 1 // Klassen und Objekte public class KlaObj public static void main(string args []) Klasse1 a; a = new Klasse1("heute", 47); Klasse1 b = new Klasse1

Mehr

Primitive Datentypen

Primitive Datentypen Primitive Datentypen 2 Arten von Datentypen: primitive Datentypen (heute) Objekte (später) Java ist streng typisiert, d.h. für jede Variable muß angegeben werden was für eine Art von Wert sie aufnimmt.

Mehr

Tutorium Java Ein Überblick. Helge Janicke

Tutorium Java Ein Überblick. Helge Janicke Tutorium Java Ein Überblick Helge Janicke 26. Oktober 2000 1 VORRAUSSETZUNGEN ZUM PROGRAMMIEREN MIT JAVA. 1 1 Vorraussetzungen zum Programmieren mit Java. Was braucht man, wenn man mit Java programmieren

Mehr

Klausur zur Einführung in die objektorientierte Programmierung mit Java

Klausur zur Einführung in die objektorientierte Programmierung mit Java Klausur zur Einführung in die objektorientierte Programmierung mit Java im Studiengang Informationswissenschaft Prof. Dr. Christian Wolff Professur für Medieninformatik Institut für Medien-, Informations-

Mehr

Klassenentwurf. Wie schreiben wir Klassen, die leicht zu verstehen, wartbar und wiederverwendbar sind? Objektorientierte Programmierung mit Java

Klassenentwurf. Wie schreiben wir Klassen, die leicht zu verstehen, wartbar und wiederverwendbar sind? Objektorientierte Programmierung mit Java Objektorientierte Programmierung mit Java Eine praxisnahe Einführung mit BlueJ Klassenentwurf Wie schreiben wir Klassen, die leicht zu verstehen, wartbar und wiederverwendbar sind? 1.0 Zentrale Konzepte

Mehr

Vorlesung im Herbstwintersemester 2007. Autorisierte studentisch Lösungen zu Aufgabenblatt 2

Vorlesung im Herbstwintersemester 2007. Autorisierte studentisch Lösungen zu Aufgabenblatt 2 Praktische Informatik I Vorlesung im Herbstwintersemester 2007 Autorisierte studentisch Lösungen zu Aufgabenblatt 2 zusammengestellt von Iva Tsvetkova 9.10.2007 1.Präsenzaufgaben 1.1 Entwurf einer Verwaltung

Mehr

Android in der Industrie

Android in der Industrie Android in der Industrie Jörg Pleumann Head of Android Development Noser Engineering AG Berner Technologie-Impulse 08.09.2011 Agenda Was ist Android? Software Hardware Industrielle Projekte Fazit Einleitung

Mehr

Variablen manipulieren per JDI

Variablen manipulieren per JDI Variablen manipulieren per JDI Zusammenfassung Jede moderne Java IDE verfügt über eine mächtige und dennoch meist einfach zu bedienende Benutzeroberfläche die das finden von Fehlern in lokalen oder entfernt

Mehr

Einführung in die Programmierung mit Java. Hörsaalübung

Einführung in die Programmierung mit Java. Hörsaalübung Einführung in die Programmierung mit Java Hörsaalübung Folie 1 Grundlagen der Objektorientierung Seit Anfang der Neunzigerjahre Standardmethode der Softwareentwicklung. Die OOP Objektorientierte Programmierung

Mehr

Effiziente Java Programmierung

Effiziente Java Programmierung Effiziente Java Programmierung Seminar Implementierung moderner virtueller Maschinen am Beispiel von Java SS 2009 von Reinhard Klaus Losse 20. Mai 2009 Gliederung Definition Effizienz Werkzeuge zum Messen

Mehr

Vorlesung Modellierung und Programmierung I Inhaltsverzeichnis

Vorlesung Modellierung und Programmierung I Inhaltsverzeichnis Vorlesung Modellierung und Programmierung I Inhaltsverzeichnis Teil I Imperative Programmierung 0 Maschinenzahlen... 2 0.1 Additionssysteme...2 0.2 Positionssysteme...2 0.3 Dezimal- und Dualsystem...3

Mehr

J2EE-Praktikum. EJB-Security. Peter Thiemann. J2EE-Praktikum, WS2005/2006. Universität Freiburg

J2EE-Praktikum. EJB-Security. Peter Thiemann. J2EE-Praktikum, WS2005/2006. Universität Freiburg J2EE-Praktikum EJB-Security Peter Thiemann Universität Freiburg J2EE-Praktikum, WS2005/2006 Inhalt 1 EJB Sicherheit 2 Schnittstelle für den Bean Provider 3 Zusammenfassung EJB Security Allgemeines Sicherheitsziele

Mehr

Java Kurs für Anfänger LMU SS09 Einheit 1 Javaumgebung

Java Kurs für Anfänger LMU SS09 Einheit 1 Javaumgebung Java Kurs für Anfänger LMU SS09 Einheit 1 Javaumgebung Ludwig-Maximilians-Universität München Institut für Informatik Programmierung und Softwaretechnik (PST) Prof. Wirsing 6. Mai 2009 1 Der Name Java

Mehr

Grundlagen der Informatik Generische Klassen

Grundlagen der Informatik Generische Klassen Grundlagen der Informatik Generische Klassen Generische Klassen, das Java-Collection-Framework und mehr Generische Programmierung Beobachtung: In vielen Problemstellungen hängt der grundsätzliche Aufbau

Mehr

PIWIN 1 Übung Blatt 5

PIWIN 1 Übung Blatt 5 Fakultät für Informatik Wintersemester 2008 André Gronemeier, LS 2, OH 14 Raum 307, andre.gronemeier@cs.uni-dortmund.de PIWIN 1 Übung Blatt 5 Ausgabedatum: 19.12.2008 Übungen: 12.1.2009-22.1.2009 Abgabe:

Mehr

Meeting C++ C++11 R-Value Referenzen

Meeting C++ C++11 R-Value Referenzen Meeting C++ Detlef Wilkening http://www.wilkening-online.de 09.11.2012 Inhalt Motivation L-Values und R-Values R-Value Referenzen Move Semantik std::move Funktionen mit R-Value-Referenz Parametern Fazit

Mehr

Hochschule Niederrhein Grundlagen der Prof. Dr. Nitsche Fachbereich 03 Java Programmierung Bachelor Informatik SS 2015 Übung 1. Grundlagen von Java

Hochschule Niederrhein Grundlagen der Prof. Dr. Nitsche Fachbereich 03 Java Programmierung Bachelor Informatik SS 2015 Übung 1. Grundlagen von Java Grundlagen von Java Aufgabe 1: Typen und Zuweisungen in Java Welche der folgenden Java-Anweisungen sind fehlerhaft? Handelt es sich um einen Compiler- oder einen Laufzeitfehler? Anmerkung: Folgefehler

Mehr

Übungsaufgabe Transaktion als Middleware

Übungsaufgabe Transaktion als Middleware Übungsaufgabe Transaktion als Middleware und Java Persistence API Client/Server Abstraktes Komponentenmodell Entscheidende Punkte Erweiterung der Invoke-Methode Context-Verwaltung Transaktionsbehandlung

Mehr

Übungen zu Verteilte Systeme : Aufgabe zu Java-RMI (1)

Übungen zu Verteilte Systeme : Aufgabe zu Java-RMI (1) BEREICH DATENTECHNIK U VS 031 01 TH 02 Übungen zu Verteilte Systeme : Aufgabe zu Java-RMI (1) Aufgabenstellung : Es ist ein über RMI aktivierbarer generischer Problemlösungs-Server in Java zu entwickeln.

Mehr

Einführung in die Programmierung mit BlueJ

Einführung in die Programmierung mit BlueJ Einführung in die Programmierung mit BlueJ Thema 1 Grundlagen der Programmierung mit BlueJ Dr. Henry Herper Otto-von-Guericke-Universität Magdeburg - WS 2013/14 Java 1991-92 Java (1995) Anwendungsgebiet:

Mehr

4. Objektorientierte Programmierung

4. Objektorientierte Programmierung 4. Objektorientierte Programmierung In Abschnitt 3 ging es um fundamentale Basiskonzepte von Java, wie es sie in jeder anderen gängigen Programmiersprache so oder so ähnlich auch gibt. In Abschnitt 4 nun

Mehr

MotorBoot. - leistung: int - geschwindigkeit: int - ankeranzahl: int - satellitennavigation: boolean - radar: boolean

MotorBoot. - leistung: int - geschwindigkeit: int - ankeranzahl: int - satellitennavigation: boolean - radar: boolean Inhalt 9 Klassen... 9-2 9.1 Instanzvariablen und Instanzmethoden... 9-2 9.1.1 Vereinbarung... 9-2 9.1.2 this - Selbstreferenz... 9-5 9.1.3 tostring()... 9-5 9.2 Klassenvariablen und Klassenmethoden...

Mehr

-Testen verteilter Anwendungen

-Testen verteilter Anwendungen -Testen verteilter Anwendungen Seminar Simulation und Bildanalyse mit Java im SS04 Konstantin Tjo, Urs Pricking Testen verteilter Anwendungen 1 Übersicht Einführung in verteilte Anwendungen RMI (Remote

Mehr

Programmieren I. Die Programmiersprache Java. www.kit.edu. Institut für Angewandte Informatik

Programmieren I. Die Programmiersprache Java. www.kit.edu. Institut für Angewandte Informatik Programmieren I Die Programmiersprache Java KIT Universität des Landes Baden-Württemberg und nationales Großforschungszentrum in der Helmholtz-Gemeinschaft www.kit.edu Eigenschaften von Java Java ist eine

Mehr

Einführung in die objektorientierte Programmierung mit Java. Klausur am 19. Oktober 2005

Einführung in die objektorientierte Programmierung mit Java. Klausur am 19. Oktober 2005 Einführung in die objektorientierte Programmierung mit Java Klausur am 19. Oktober 2005 Matrikelnummer: Nachname: Vorname: Semesteranzahl: Die Klausur besteht aus drei Frageblöcken zu den Inhalten der

Mehr

p^db=`oj===pìééçêíáåñçêã~íáçå=

p^db=`oj===pìééçêíáåñçêã~íáçå= p^db=`oj===pìééçêíáåñçêã~íáçå= Error: "Could not connect to the SQL Server Instance" or "Failed to open a connection to the database." When you attempt to launch ACT! by Sage or ACT by Sage Premium for

Mehr

5. Abstrakte Klassen. Beispiel (3) Abstrakte Klasse. Beispiel (2) Angenommen, wir wollen die folgende Klassenhierarchie implementieren:

5. Abstrakte Klassen. Beispiel (3) Abstrakte Klasse. Beispiel (2) Angenommen, wir wollen die folgende Klassenhierarchie implementieren: 5. Abstrakte Klassen Beispiel 5. Abstrakte Klassen 5. Abstrakte Klassen Beispiel Beispiel (3) Angenommen, wir wollen die folgende Klassenhierarchie implementieren: Probleme des Implementierungsvorschlags:

Mehr

Vererbung versus Delegation

Vererbung versus Delegation Vererbung versus Delegation class A { public void x() { z(); } protected void z() { /* A-Code */... } } class B extends A { protected void z() { /* B-Code */... } public void y() { delegate.x(); } private

Mehr

Technical Support Information No. 123 Revision 2 June 2008

Technical Support Information No. 123 Revision 2 June 2008 I IA Sensors and Communication - Process Analytics - Karlsruhe, Germany Page 6 of 10 Out Baking Of The MicroSAM Analytical Modules Preparatory Works The pre-adjustments and the following operations are

Mehr

Das Build Tool Ant. Sebastian Mancke, mancke@mancke-software.de

Das Build Tool Ant. Sebastian Mancke, mancke@mancke-software.de Das Build Tool Ant Sebastian Mancke, mancke@mancke-software.de Grundlagen Motivation Bei der Übersetzung und Pflege von Software treten viele, gleich bleibende Arbeitsschritte auf. Übersetzen des Codes

Mehr

Java Batch Der Standard für's Stapeln

Java Batch Der Standard für's Stapeln Java Batch Der Standard für's Stapeln Berlin Expert Days 18.09.2015 Dirk Weil, GEDOPLAN GmbH Dirk Weil GEDOPLAN GmbH, Bielefeld GEDOPLAN IT Consulting Konzeption und Realisierung von IT-Lösungen GEDOPLAN

Mehr

Grundlagen der Informatik Ausnahmebehandlung & Threads

Grundlagen der Informatik Ausnahmebehandlung & Threads Grundlagen der Informatik Ausnahmebehandlung & Threads Prof. Dr. Bernhard Schiefer (basierend auf Unterlagen von Prof. Dr. Duque-Antón) bernhard.schiefer@fh-kl.de http://www.fh-kl.de/~schiefer Inhalt Ausnahmebehandlung

Mehr