Abstrakte klasser og interfaces i Java

Indhold Hvad er en abstrakt metode og en abstrakt klasse? Hvad er et interface? Hvorfor bruge interface? Interface som en type Interface vs. Class Oprette et interface Implementere et interface Implementere flere interface's Arv med interface's Interface og polymorfi Overskriv et interface

Abstrakte Metoder public abstract void someMethod(); Metoder, der ikke er implementeret (har en body) For at oprette en abstrakt metode tilføjes abstract og {…} udelades. Der afsluttes med ; public abstract void someMethod();

Abstrakt klasse En abstract klasse er en klasse har en eller flere abstrakte metoder. Den erklæres med abstract modifier En abstrakt klasse kan ikke instanseres Man kan altså ikke bruge new på en abstrakt klasse En anden klasse er nødt til at arve fra den abstrakte klasse og implementere metoden

Sample Abstract Class public abstract class LivingThing { public void breath(){ System.out.println("Living Thing breathing..."); } public void eat(){ System.out.println("Living Thing eating..."); public abstract void walk(); public class Human extends LivingThing { public void walk(){ System.out.println("Human walks..."); }

When to use Abstract Methods & Abstract Class? Abstrakte metoder bruges når det ikke giver mening at implementere den i superklassen. F.eks area i shape. Samtidigt er det stadig muligt at genbruge en del af koden

Hvad er et Interface? Det er standardliseret og public måde at beskrive en klasses adfærd, dvs. klassens public medlemmer, altså klassens interface Interface definerer en kontrakt Alle metoder i et interface er abstrakte metoder En konkret klasse skal implementere interfacet, dvs. alle de abstrakte metoder. Interface giver klasser mulighed for at implementere fælles adfærd uanset placering i klasse hierakiet. Og synliggør det for andre klasser.

Eksempel: Interface Relation public interface Relation { public boolean isGreater( Object a, Object b); public boolean isLess( Object a, Object b); public boolean isEqual( Object a, Object b); }

Eksempel 2: OperatorCar Interface public interface OperateCar { // constant declarations, if any // method signatures int turn(Direction direction, double radius, double startSpeed, double endSpeed); int changeLanes(Direction direction, double startSpeed, double endSpeed); int signalTurn(Direction direction, boolean signalOn); int getRadarFront(double distanceToCar, double speedOfCar); int getRadarRear(double distanceToCar, double speedOfCar); ...... // more method signatures }

Hvorfor bruge interfaces? At synliggøre (en del af) en klasses interface uden at gøreimplementation synlig. Dvs. det understøtter indkabsling Implementationen kan ændres uden at involvere den der kalder interfacets metoder Brugeren behøver ikke at den implementerende klasse på kompileringstidspunktet Den behøver kun at kende interfacet på kompileringstidspunktet Det er først på runtime at den aktuelle objekt instans bliver knyttet sammen med interfacet

Hvorfor bruge interfaces? Klasser, der ikke hører sammen kan have samme adfærd / metoder uden at den ene arver fra den anden Eksempel: Klassen Line og klassen MyInteger De er ikke relatereret gennem arv Men de kan implementere samme interface checkIsGreater(Object x, Object y) checkIsLess(Object x, Object y) checkIsEqual(Object x, Object y) Derved kan det f.eks være muligt at sortere dem

Hvorfor bruge interfaces? Modellere mutibel arv. En klasse kan implementere flere interfaces, men kun arve fra en klasse

Interface vs. abstrakt klasse Alle metoder i et interface er abstrakte, men at ikke alle metoder i en abstrakt klasse behøver at være abstrakte. Et interface kan kun definere konstanter, men en abstrakt klasse kan have attributter. Interfaces er ikke arv. De er uafhængige Men interfaces kan indbyrdes arve fra hinanden

Instance som en type Når et interface defineres, defineres en ny reference type, på samme måde som med en klasse Interface navne kan bruges på samme måde som klasse navne Hvis en variabel er erklæret som en instans af et interface, skal den sættes til et objekt af en klasse, der implementerer interfacet Hvis Person implementerer PersonInterface: Person p1 = new Person(); PersonInterface pi1 = p1; PersonInterface pi2 = new Person();

Defining Interfaces public interface [InterfaceName] { //some methods without the body }

Implementere Interfaces For at oprette en klasse der implementerer et interface, bruges implements keyword. public class Line implements Relation { private double x1; private double x2; private double y1; private double y2; public Line(double x1, double x2, double y1, double y2){ this.x1 = x1; this.x2 = x2; this.y1 = y1; this.y2 = y2; } // More code follows

public double getLength(){ double length = Math.sqrt((x2-x1)*(x2-x1) + (y2-y1)* (y2-y1)); return length; } public boolean isGreater( Object a, Object b){ double aLen = ((Line)a).getLength(); double bLen = ((Line)b).getLength(); return (aLen > bLen); public boolean isLess( Object a, Object b){ return (aLen < bLen); public boolean isEqual( Object a, Object b){ return (aLen == bLen);

Implementering af interfaces Følgende opstår hvis ikke alle interface metoder er implementeret Line.java:4: Line is not abstract and does not override abstract method isGreater(java.lang.Object,java.lang.Object) in Relation public class Line implements Relation ^ 1 error

Eksempel: Implementere multiple interfaces En konkret klasse extends een super klasse, men kan implementere flere Interfaces: public class ComputerScienceStudent extends Student implements PersonInterface, AnotherInterface, Third interface { // All abstract methods of all interfaces // need to be implemented. }

Interface arv Interfaces er ikke en del af klasse hierarkiet Men de kan alligevel arve fra andre interfaces public interface PersonInterface { void doSomething(); } public interface StudentInterface extends PersonInterface { void doExtraSomething();

Interface og polymorfi Interfaces understøtter polymorfi på den måde at når programmet kalder en interface metode, vil den rigtige metode afhængigt af typen blive kaldt

Omskrivning af et eksisterende interface Her er et interface: public interface DoIt { void doSomething(int i, double x); int doSomethingElse(String s); } I en senere version skal interfacet udvides boolean didItWork(int i, double x, String s); Hvis man gør det kan de gamle klasser, der bruger interfacet ikke længere bruges

Løsning public interface DoItPlus extends DoIt { boolean didItWork(int i, double x, String s); } Nu kan de gamle klasser stadig bruge det gamle interface, mens de nye klasser implementerer både det nye og det gamle