What is inheritance?

** Take over the members of the original class and define a new class **
** Base class ** (super class, parent class): Inheritance source
** Derived class ** (subclass, child class): Inherited class
A mechanism to cut out the common part of the function and write only the difference
cf: ** Delegation **: Cut out a specific role as another class and save the instance as a field

How to use inheritance

class Derived class extends Base class {}
If omitted, it means that the Object class is inherited.
Search for the requested member in the current class, ** if it does not exist, call the member defined in the upper class! ** **
Methods in both the base and the derived class preferentially call the derived class
Note:
** Only one base class in Java ** (multiple succession approval not possible)
** Members defined in the base class cannot be deleted in the derived class **
= Derived class ** contains all properties of the base class **

`Person.java`


public class Person {
  public String name;
  public int age;

  public String show() {
    return String.format("%s（%d).", this.name, this.age);
  }
}

`BusinessPerson.java`


//Create BusinessPerson class that inherits Person
public class BusinessPerson extends Person {
  //Work method definition unique to derived class
  public String work() {
    return String.format("%d year old%s works fine today as well.", this.age, this.name);
  }
}

public class InheritBasic {
  public static void main(String[] args) {
    //Call only Business Person
    var bp = new BusinessPerson();
    bp.name = "Ichiro Sato";
    bp.age = 30;
    //The show method can be called like a member of the bp class!
    System.out.println(bp.show()); //I'm Ichiro Sato (30 years old).
    System.out.println(bp.work());  //Ichiro Sato, 30 years old, works well today.
  }
}

Points
Use inheritance if the parent and child classes have a ** is-a relationship ** * is-a：SubClass is a SuperClass * Person⊃BusinessPerson
Relationship in which Business Person is included in Person
Derived classes are ** specialized ** of base classes
The base class is a ** generalization of the derived class **

Field concealment

Inheritance depends on the member
** Override **: Method possible
** Hidden **: Fields, nested classes / interfaces allowed

hiding

** If the field with the same name in the base class is defined in the derived class **, the field in the base class will not be visible.
Even if the data type is different ** If the name is the same, it will be hidden **
Hidden fields can be accessed by using the reserved variable ** super **
Note: Base class fields are inaccessible if private

`Person.java`


import java.time.ZonedDateTime;
public class Person {
  public String name;
  public ZonedDateTime birth = ZonedDateTime.now();
}

`BusinessPerson.java`


import java.time.LocalDateTime;
public class BusinessPerson extends Person {
  //Hide the birth field of the base class
  public LocalDateTime birth = LocalDateTime.now();
  public void show() {
    //Access hidden fields
    System.out.println(super.birth);
  }
}

public class HideBasic {

  public static void main(String[] args) {
    var bp = new BusinessPerson();
    //BusinessPerson.Show birth
    System.out.println(bp.birth); 
    bp.show();
    //Person.Show birth field
    Person p = new BusinessPerson();
    System.out.println(p.birth);
  }
}

Method override

Overwrite (redefine) the method defined in the base class with the derived class
You don't just see the name (unlike concealment)
** Method name **: Exact match
** Formal argument **: Data type / number match
The base (CharSequence s) cannot be overridden by the derived (String s)
** Return value **: Type match / derived type
** Access modifier **: Looser than match / base type
public> protected> unspecified> private
private cannot be overridden
** throw clause (exception) **: Match / derived type
→ ** @Override annotation ** is OK
** Explicitly declare that you are overriding a method in the base class **

public class Person {
  public String name;
  public int age;

  public String show() {
    return String.format("%s（%d).", this.name, this.age);
  }
}

public class BusinessPerson extends Person {
  public BusinessPerson() {}
  //Override the show method with the same name in the base class
  @Override
  public String show() {
    return String.format("Of an office worker%s（%d).", this.name, this.age);
  }

  public String work() {
    return String.format("%d year old%s works fine today as well.", this.age, this.name);
  }
}

Base class reference (super)

Method call by super is ** beginning of method definition of derived class **

//Inherit BusinessPerson class
public class EliteBusinessPerson extends BusinessPerson {
  @Override 
  //Call the work method of the base class and add your own processing

  public String work() {
    //Call the super method at the beginning of the derived class
    var result = super.work();
    return String.format("%s Always smile!", result);
  }
}

public class InheritBaseCall {
  public static void main(String[] args) {
    var ebp = new EliteBusinessPerson();
    ebp.name = "Yamada Taro";
    ebp.age = 35;
    System.out.println(ebp.work()); //35-year-old Taro Yamada works well today. Always smile!
  }
}

Derived class constructor

** Constructors are not inherited like methods **
In the inherited class, ** the constructor is called in order from the upper class, and finally the constructor of the current class is called **
Base class initialization is the base class constructor
Derived class initialization is a derived class constructor
1. Initialize all fields with specified values
1. Base class initialization block execution
1. Base class constructor execution
1. Derived class initialization block execution
1. Constructor execution of derived class

`MyParent.java`


public class MyParent {
  public MyParent() {
    System.out.println("I'm a parent.");
  }
}

`MyChild.java`


public class MyChild extends MyParent {
  public MyChild() {
    System.out.println("I'm a child.");
  }
}

public class InheritConstruct {
  public static void main(String[] args) {
    var c = new MyChild(); //I'm a parent. I'm a child.
  }
}

Only the no-argument constructor is implicitly called in the upper class **
If you explicitly define a constructor (= with arguments), the default constructor is not automatically generated.
→ Call the constructor with arguments with ** super from the constructor of the derived class **
** Be sure to call ** at the ** first sentence of the ** constructor

//Upper class (constructor with arguments)
public class MyParent {
  public MyParent(String name) {
    System.out.printf("%The parent of s.\n", name);
  }
}

public class MyChild extends MyParent {
  public MyChild(String name) {
    //Call the no-argument constructor of the upper class from the constructor of the derived class
    super(name);
    //Constructors are called in the order of base class → derived class
    System.out.printf("Of child%s.\n", name); //I'm Taro Yamada's parent.\n I'm a child of Taro Yamada.
  }
}

public class InheritConstruct {
  public static void main(String[] args) {
    var c = new MyChild("Yamada Taro");
  }
}

Inheritance / override prohibited

Implementation and modification of inheritable classes should also consider the impact on derived classes
For classes / methods that do not assume inheritance / override, ** prohibit with final modifier **

public class Person {
  String name;
  int age;
  public Person() {}
  //Do not override show method
  public final String show() {
    return String.format("%s（%d).", this.name, this.age);
  }
}

//No inheritance of BusinessPerson class
public final class BusinessPerson extends Person {
  public String intro() {
    return "I'm an office worker.";
  }
}

Reference type type conversion

** Types must be inherited / implemented **

Upcast

** Conversion from derived class to base class **
Convert BusinessPerson type to Person type
Derived class contains all members of base class
Derived class instances are available as base class instances
** In this case, the conversion type is Person and the object type is BusinessPerson ** (* Variable type / Object type * Reference described later)

//Upcast
public class CastUp {
  public static void main(String[] args) {
    //Convert by assigning a BusinessPerson object to a variable of base class Person type
    Person bp = new BusinessPerson();
    bp.name = "Yamada Taro";
    bp.age = 20;
    System.out.println(bp.show());
  }
}

Downcast

** Conversion from base class to derived class **
Convert Person type to Business Person type
Base class cannot always behave as a derived class
** Explicit type conversion required in cast syntax **
Person p = new BusinessPerson();
BusinessPerson bp = (BusinessPerson)p;

Variable type / object type

Override show method of Person class in Business Person
However, the following code cannot call the work method of the BusinessPerson class.
Variable p is a Person type variable
Variable p ** cannot call work method **
The object type (entity) of the variable p is BusinessPerson
** BusinessPerson show method is called **

`BusinessPerson.java`


public class BusinessPerson extends Person {
  public BusinessPerson() {}

  @Override
  public String show() {
    return String.format("Of an office worker%s（%d).", this.name, this.age);
  }

  public String work() {
    return String.format("%d year old%s works.", this.age, this.name);
  }
}

public class TypeDifference {

  public static void main(String[] args) {
    Person p = new BusinessPerson();
    p.name = "Yamada Taro";
    p.age = 30;
    // System.out.println(p.work()); //error
    System.out.println(p.show()); //I'm Taro Yamada (30 years old), an office worker.
  }
}

In other words,
Cast replaces ** variable type **
Convert BusinessPerson variable type to Person variable type
** Object type (entity) does not change even if cast **
** The method to be called is determined by the object type **
Person cannot behave as a Business Person

Hiding class methods / fields

Class methods are called with class name.method name (...)
Variable type / object type does not exist
Since the method of the specified class is always called ** There is no override concept **
Field selection depends on variable type

public class HideBasic {
  public static void main(String[] args) {
    var bp = new BusinessPerson();
    System.out.println(bp.birth);
    bp.show();
    //Variable p is of type Person
    Person p = new BusinessPerson();
    //The birth field of the Person class is of type ZonedDateTime
    System.out.println(p.birth); //ZonedDateTime type
  }
}

Type judgment

Object type check required when downcasting **
For example, something like this. .. ..
BusinessPerson / Student is a Person-derived class * Person p = new BusinessPerson(); //OK * BusinessPerson bp = (BusinessPerson)p; //OK * Student st = (Student)p; //NG
The entity (object type) of the variable p is BusinessPerson
At compile time, I only know the inheritance relationship between Person and BusinessPerson / Student, so ** I don't get a compile error, but I get an error at runtime! ** **
→ ** ʻUse the instanceof` operator **
True if the object type stored in the variable can be converted to the specified type

//Type check
if(p instanceof Student){
    Student st = (Student)p;
    //Processing when casting is correct
}

Type acquisition

Get the object type with the getClass method
Get the object type regardless of the variable type

public class Main {
    public static void main(String[] args) {
    Person p1 = new Person();
    System.out.println(p1.getClass()); //class Person
    Person p2 = new BusinessPerson();
    System.out.println(p2.getClass()); //class BusinessPerson
  }
}

transfer

Inheritance is tightly coupled with base / derived classes
When to use inheritance
** Base / derived classes are-a related **
** Liskov Substitution Principle **: Assigning an instance of the derived class to a variable in the base class does not compromise the validity of the code
** Assuming expansion, documenting that fact **
Examples of inappropriate inheritance

import java.util.Random;

public class Roulette extends Random {
//Roulette upper limit
private int bound;

  public Roulette(int bound) {
    this.bound = bound;
  }
  //Get the value to be the upper limit of the bound field and generate a random number
  @Override
  public int nextInt() {
    return nextInt(this.bound);
  }
  //Disables other unnecessary methods (contrary to Liskov Substitution Principle)
  @Override
  public boolean nextBoolean() {
    throw new UnsupportedOperationException();
  }

  @Override
  public long nextLong() {
    throw new UnsupportedOperationException();
  }
}

import java.util.Random;

public class RouletteClient {
  public static void main(String[] args) {
    Random rou = new Roulette(10);
    System.out.println(rou.nextBoolean()); //UnsupportedOperationException
  }
}

** In delegation, an object with the function you want to reuse is imported as a field of the current class **
Delegation is ** a dynamic relationship between instances **
Hold (has) Random object in random field of Roulette class ** Use Random class method as needed **
** has-a relationship **
merit:
** Loose relationships between classes **
Because it uses public members ** It does not depend on internal implementation **
The relationship is not fixed because the instance is held in the field.
** The transferee can be changed later **
** Processing can be delegated to multiple classes **
** The delegation destination can be changed for each instance **

import java.util.Random;

public class Roulette {
  private int bound;
  //Keep the above object in the field
  private Random random = new Random();

  public Roulette(int bound) {
    this.bound = bound;
  }
  //Delegate processing as needed
  public int nextInt() {
    return this.random.nextInt(this.bound);
  }
}

[Java] Inheritance

What is inheritance?

How to use inheritance

Person.java

BusinessPerson.java

Field concealment

hiding

Person.java

BusinessPerson.java

Method override

Base class reference (super)

Derived class constructor

MyParent.java

MyChild.java

Inheritance / override prohibited

Reference type type conversion

Upcast

Downcast

Variable type / object type

BusinessPerson.java

Hiding class methods / fields

Type judgment

Type acquisition

transfer

`Person.java`

`BusinessPerson.java`

`Person.java`

`BusinessPerson.java`

`MyParent.java`

`MyChild.java`

`BusinessPerson.java`