4 Inheritance and Interface

1 Derived classes

Derived class concept

对于已经存在的class，如果要 define 一个 indepedent class 是需要重新写所有完整代码的；但是如果从这个 class derive 出一个 子类 / derived class / subclass只需要完成 derived class 和 base class / superclass 中不同的部分即可。

Inheritance

只需要像如下一样
class DerivedClass extends BaseClass { … }，在 braces 中 define 不同的部分即可。

2 Access by members of derived classes

Member access

Derived class 不能把 base class 的内容和补充的内容当作一个 class,

1. base class 是 derived class 中相对独立的一部分，只有public mebmer可以出现在 derived class的补充代码中；
2. 但是 base class 可以通过 derived class 像之前一样使用；

Protected member access

Protected access specifier

protect 的 class member 在一个 package 中都可以使用，在子类中国也可以使用。

Class definitinos

public class 在整个程序中都可以使用
non specifier 只在同一 package 中可以使用

3 Overriding & Overloading member methods

Override

覆写：在derived class 中 define 一个与 base class 中name， return type，parameter 全相同的method来覆盖原 method

// Business.java
public class Business {
   protected String name;
   protected String address;
   ... 

   public String getDescription() {
      return name + " -- " + address;
   }
}

// Restaurant.java
public class Restaurant extends Business {
   private int rating;
   ...
   
   @Override
   public String getDescription() {
      return name + " -- " + address +
         "\n  Rating: " + rating;
   }
}

但是可以使用 super keyword 来访问原 method

public class Restaurant extends Business{
   ...
   
   @Override
   public String getDescription() {
      return super.getDescription() + "\n  Rating: " + rating;
   }
   
   ...
}

Overload

无 @Override 关键字就是 overload，都能使用不会覆盖；只有 parameter 一定不一样，从而来区分不同的 method

public class Computer {
   public void setComputerStatus(String cpuStatus, String internetStatus) {
      cpuUsage = cpuStatus;
      internet = internetStatus;
   }

   public void printStatus() {
      System.out.println("CPU: " + cpuUsage);
      System.out.println("Internet: " + internet);
   }
   
   protected String cpuUsage;
   protected String internet;
}
///
public class Laptop extends Computer {
   public void setComputerStatus(String cpuStatus, String internetStatus,
                                 String wifiStatus) {
      cpuUsage = cpuStatus;
      internet = internetStatus;
      wifiQuality = wifiStatus;
   }

   @Override
   public void printStatus() {
      super.printStatus();
      System.out.println("WiFi: " + wifiQuality);
   }

   private String wifiQuality;
}

5 Interface & Abstract Class

interface 和 abstract class 是不能实例化的，只能实现（implements）和继承（extends）。

Interface

1. interface 中只有 public abstract method，本身不能 define 方法体，又因所有的 method 都是 abstract的所以 abstract keyword 就可以省略掉；

public interface Drawable {
   public void draw(Graphics2D graphicsObject);
}

2. interface 中不能声明实例变量 / instance variable（变量类型是某种类），但是可以使用常数变量public static final ；
3. interface 需要实现，使用 implements 关键字, 一个 class 可以同时实现多个 interface，注意所有的 abstract method 必须全override。

public class Square implements Drawable, DrawableASCII {
   private int sideLength;

   public Square(int sideLength) {
      this.sideLength = sideLength;
   }

   @Override
   public void draw(Graphics2D graphicsObject) {
      Rectangle shapeObject = new Rectangle(0, 0, this.sideLength, this.sideLength);
      Color colorObject = new Color(255, 0, 0);
      graphicsObject.setColor(colorObject);
      graphicsObject.fill(shapeObject);
   }

   @Override
   public void drawASCII(char drawChar) {
      int rowIndex;
      int columnIndex;

      for (rowIndex = 0; rowIndex < this.sideLength; ++rowIndex) {
         for (columnIndex = 0; columnIndex < this.sideLength; ++columnIndex) {
            System.out.print("*");
         }
         System.out.println();
      }
   }
}

Abstract Class

1. 含有 abstract method 的 class，其他与普通 class 一样，可以有非抽象方法，但是也不能实例化；
2. 还可以用抽象类继承抽象类，不想override的抽象方法再次重新声明一遍即可；
3. abstract class 是 interface 和 class 之间的过渡。

public abstract class ClassA {
   public abstract void doNeatThings(); 
}

public class ClassB extends ClassA {
   @Override
   public void doNeatThings() {
      System.out.println("Does neat things!");
   }
}

public abstract class ClassB extends ClassA {
   public void doNeatThings();
}

混合使用

一个类可以继承 abstract class 的同时实现 interface

public abstract class ClassA {
   public abstract void doNeatThings(); 
}

public interface ClassC {

}

public class ClassB extends ClassA implements ClassC {
   @Override
   public void doNeatThings() {
      System.out.println("Does neat things!");
   }
}