[Java] Polymorphism

What is polymorphism?

• Achieve different behavior with methods of the same name
• Inherit Shape class in Triangle, Rectangle class and define getArea method with the same name
• Since the object type is different even for variables of the same Shape type, the method of the base / derived class is called according to the object type.
• ** → You can call different functions with the same name! ** **
• merit:
• Excellent maintainability
• Function replacement is only instance replacement
• easy to understand

Shape.java

public class Shape {
  protected double width;
  protected double height;

  public Shape(double width, double height) {
    this.width = width;
    this.height = height;
  }
//Get the area of the shape (override in the derived class)
  public  double getArea() {
    return 0d;
  }
  //public abstract double getArea();
}

Triangle.java

public class Triangle extends Shape {
  public Triangle(double width, double height) {
    super(width, height);
  }
//Get the area of a triangle
  @Override
  public double getArea() {
    return this.width * this.height / 2;
  }
}

Rectangle.java

public class Rectangle extends Shape {
  public Rectangle(double width, double height) {
    super(width, height);
  }
//Get the area of a rectangle
  @Override
  public double getArea() {
    return this.width * this.height;
  }
}

public class PolymorphismBasic {
  public static void main(String[] args) {
    //Assign Triangle type object (upcast)
    Shape tri = new Triangle(10, 50);
    //Substitute Rectangle type object (upcast)
    Shape rec = new Rectangle(10, 50);
    System.out.println(tri.getArea()); //250.0
    System.out.println(rec.getArea()); //500.0
  }
}

Abstract method

• In the above example, the base class Shape expects to override the getArea method, but it is not compulsory.
• ** Abstract method **: No content (function) in itself ** Empty method **
• ** Abstract class **: Class containing abstract methods
• Classes that inherit from abstract classes are obliged to override all abstract methods **
• Abstract methods ** can guarantee that certain methods will be overridden in derived classes **

How to use

• ** Add abstract qualifier to abstract method definition **
• The base class cannot have block contents, it only ends with ;
• ** Add the abstract modifier to the class block for classes containing abstract methods **

Shape.java

public abstract class Shape {
  protected double width;
  protected double height;

  public Shape(double width, double height) {
    this.width = width;
    this.height = height;
  }
 //You can't have content in the base class!
  public abstract double getArea();
}

interface

• Java does not allow multiple inheritance, so only one class can be inherited at a time.
• Unnecessary methods must be overridden for the time being
• → ** Use interface **
• A class in which all subordinate methods are abstract methods
• Multiple inheritance is possible
• Each method is divided into different interfaces in a semantic chunk
• Only necessary methods can be selected on the derived class side

Interface definition

• interface instruction
• ** public **: accessible from all classes
• ** abstract **: Abstract class
• ** strictfp **: Floating point arithmetic in an environment-independent way
• It is obvious that abstract methods are included under it, so it is the same even if abstract is not added (generally omitted)
• Interface name is in Pascal notation

public interface Shape {
  double getArea();
}

Defineable member

• Abstract method
• default method
• Class methods
• Constant field
• Nested static classes / interfaces

Interface implementation

• ** Define a class by inheriting the predefined interface **
• The class that implements the interface is called ** implementation class **
• implements interface name
• When implementing multiple interfaces, implements Shape, Hoge, Bar
• Combined with inheritance extends MyParent implements Shape

//Shape interface implementation class
public class Rectangle implements Shape {
  private double width;
  private double height;

  public Rectangle(double width, double height) {
    this.width = width;
    this.height = height;
  }

  @Override
  public double getArea() {
    return this.width * this.height;
  }
}

Interface member

• Abstract method, constant field, default method, static method (Java8 or later)

Constant field

• ** Interface field cannot be defined because interface cannot be instantiated **
• Fields are unconditionally public static final
• Since it is redundant, write as follows

interface MyApp{
    String TITLE = "Order of the Phoenix";
    double NUMBER = 5;
}

static field (Java 8 or later)

• When you want to summarize some functions related to the existing interface

default method (Java 8 or later)

• Implementation adopted by default when not explicitly implemented on the implementation class side

public interface Loggable {
  default void log(String msg) {
    System.out.println("Log: " + msg);
  }
}

//Do not override the log method
public class LoggableImpl implements Loggable {
}

InterfaceDefault.java

public class InterfaceDefault {

  public static void main(String[] args) {
    var l = new LoggableImpl();
    //The default method of the Loggable class is called
    l.log("Harry Potter"); //Log:Harry Potter
  }
}

• You can also explicitly call the default method from the implementation class with super

//Do not override the log method
public class LoggableImpl implements Loggable {
  @Override
  public void log(String msg) {
    Loggable.super.log(msg);
    System.out.println("LogImpl: " + msg);
  }
}

InterfaceDefault.java

public class InterfaceDefault {

  public static void main(String[] args) {
    var l = new LoggableImpl();
    l.log("Harry Potter"); 
    //Log:Harry Potter
    //LogImpl:Harry Potter
  }
}

Attention to multiple inheritance

Duplicate abstract method

• ** Compile error when the method name and argument type are the same but only the return value is different **
• The return value on the implementation side must be the lowest derived type

public interface IHoge {
  void foo();
  //CharSequence foo(); //OK
}

public interface IHoge2 {
  String foo();
}

public class HogeImpl implements IHoge, IHoge2 {
    @Override
    public String foo() { } //The return type is IHoge.foo()Not compatible with
}

Duplicate constant fields

• ** Reference error ** even if the data types are different or the types / values are the same **

public interface Hoge {
  int DATA = 0;
}

public interface Hoge2 {
  String DATA = "This is an apple.";
}

public class HogeImpl implements Hoge, Hoge2 {
  public void foo() {
    System.out.println(DATA); //error
  }
}

Duplicate default method

• ** Since it has an implementation, an error will occur even if all method names, arguments, and return values match **
• It is OK to explicitly refer to the defalt method in the implementation class with super
• If there is a difference in the hierarchical relationship, you can use the default method with the same name.
• Priority is given to classes with a closer implementation relationship (direct implementation relationship)

public interface DHoge {
  default void log(String msg) {
    System.out.println("DHoge: " + msg);
  }
}

public interface DHoge2 {
  default void log(String msg) {
    System.out.println("DHoge2: " + msg);
  }
}

public class HogeImpl implements DHoge, DHoge2 {
  @Override
  public void log(String msg) {
    DHoge.super.log(msg); //Error (duplicate default method log with String is DHoge2,(Inherited from DHoge)
    //IHoge.super.log(msg); //Explicit reference is OK
  }
}

Which to use, interface or abstract class?

• Interface priority
• The class is ** tree hierarchy ** with Object class as root
• Interface: ** Independent of class tree **
• Abstract class: ** Part of the class tree **
• Type hierarchy is not a representation of all reality
• For interfaces
• Because it is independent of the type hierarchy **, it is possible to interrupt a specific function **
• ** A new interface can be implemented regardless of the base class **
• ** Multiple inheritance possible **
• For abstract classes
• ** Identify related classes and put them in all higher classes ** Required
• Inheritance cannot be refused even if there are unnecessary functions in the middle **
• When adopting, you should look at the implementation rather than which method the class has (class behavior)
• Common processing in derived classes
• Skeleton of implementation process
• ex: The Writer class in the java.io package provides the XWriter framework in the base classes of BufferWriter, OutputStreamWriter, PrintWriter.