interface INTERFACE1 {dtype method1();}

Week 6: Methods of OO Programming/05A. Interfaces+++

@@ -0,0 +1,199 @@
+It is common that there is a PROPERTY we would like to declare for MULTIPLE CLASSES. 
+For example, we could have several classes that have a price. 
+However, since a price can be attached to very different classes (for example a car, a banana, an airplane, and a house), 
+it would be difficult to come up with a common superclass.
+
+
+For this, we have INTERFACES. 
+The idea of an interface is that it DEFINES a PROPERTY THAT the CLASSES CAN then IMPLEMENT. 
+In practice, the interface (which is a sort of CLASS ITSELF) TYPICALLY DEFINES a METHOD or METHODS WITHOUT actual IMPLEMENTATION. 
+The classes that implement the interface then implement the method(s) as well.
+
+This enables the grouping of objects based on a single property, 
+even if the objects themselves are very different (for example a banana and an airplane). 
+This way we can for example calculate the total price of different objects with price by using a simple loop.
+
+
+
+========================================
+
+
+
+Interfaces in Java
+In Java, an interface is defined with the keyword 'interface'. 
+Inside the interface, ALL DECLARED MEMBERS are PUBLIC, because the implementing classes need to PROVIDE the MEMBERS TO their CLIENTS.
+
+For example, see the interface 'Priced':
+interface Priced {
+    int getPrice();
+}
+
+
+Note that getPrice() is a 'method declaration'. 
+VISIBILITY MODIFIERS are NOT NEEDED, since ALL the MEMBERS defined in the interface are PUBLIC.
+
+As seen in the example, 'no implementations for the methods are given' in the interface. 
+The interface is implemented with keyword 'implements' (different from 'extends', which is used when we extend a class).
+
+class Car implements Priced {
+    private String manufacturer;
+    private String model;
+    private int price;
+
+    public Car(String manufacturer, String model, int price) {
+        this.manufacturer = manufacturer;
+        this.model = model;
+        this.price = price;
+    }
+
+    // update method
+    @Override
+    public int getPrice() {
+        return price;
+    } 
+}
+ 
+
+
+
+
+As a second example, let's look at class Banana. 
+This time the price is fixed at 5. 
+This does not make a difference, the interface just defines that the class needs to return an integer from the method getPrice().
+
+class Banana implements Priced {
+    double length;
+    
+    public Banana(double length) {
+        this.length = length;
+    }
+
+    @Override
+    public int getPrice() {
+        return 5;
+    }
+}
+ 
+
+
+
+
+The implementing classes can have a very different basic idea. 
+However, they need to implement the method getPrice() which is defined in the interface.
+
+public class Test {
+    public static void main(String[] args) {
+        Car car = new Car("Volvo", "345", 1500);
+        Banana banana = new Banana(15.25);
+        
+        System.out.println(car.getPrice());
+        System.out.println(banana.getPrice());
+    }
+}
+
+Program outputs:
+1500
+5
+ 
+ 
+
+
+========================================
+
+
+
+In the newer versions of Java, interface methods can have default implementations. 
+This helps for example when you need to make changes in the interface. 
+The feature is not discussed in detail in this course, more information can be found e.g. at:
+https://docs.oracle.com/javase/tutorial/java/IandI/defaultmethods.html
+
+ 
+
+========================================
+
+Let's see a second example, an interface called Measurable which defines methods getWidth and getHeight.
+
+interface Measurable {
+    double getWidth();
+    double getHeight();
+}
+
+
+
+Now the implementing classes MUST IMPLEMENT BOTH METHODS:
+class Block implements Measurable {
+    private String material;
+    private double width;
+    private double height;
+    
+    public Block(String material, double width, double height) {
+        this.material = material;
+        this.width = width;
+        this.height = height;
+    }
+
+
+    ////////////////////
+    // HERE
+    ////////////////////
+    @Override
+    public double getWidth() {
+        return width;
+    }
+
+    @Override
+    public double getHeight() {
+        return height;
+    }
+    ////////////////////
+    
+    public String getMaterial() {
+        return material;
+    }
+}
+
+
+
+
+
+
+ 
+
+A class can implement more than one interface:
+class Block implements Measurable, Priced {
+    private String material;
+    private double width;
+    private double height;
+    
+    public Block(String material, double width, double height) {
+        this.material = material;
+        this.width = width;
+        this.height = height;
+    }
+
+    ////////////////////
+    // HERE
+    ////////////////////
+    @Override
+    public double getWidth() {
+        return width;
+    }
+
+    @Override
+    public double getHeight() {
+        return height;
+    }
+
+    @Override
+    public int getPrice() {
+        return 25;
+    }
+    ////////////////////
+    
+    public String getMaterial() {
+        return material;
+    }
+}
+
+
+