Java基础 - Java基础——继承 - 《Java》

extends
super
成员变量
方法
构造器
访问权限
">
抽象类
super
">
重写与重载
接口

extends

在java中使用extends关键字来表示继承关系。
当创建一个类时，总是在继承，如果在类中声明中没有extends关键字，就总是隐式地从java.lang.Object类继承而来的，所以Object是所有类的元类，

class 子类名称 extends 父类名称

例如：

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

（1）只允许单继承不可以多继承
（2）允许多层继承
（3）除了Object外，所有类实际上都会存在一个父类。

super

调用父类的方法或者成员
privite修饰的字段无法被子类访问
protected修饰的字段可以被子类访问

package com.example.java.inheritance;
/**
 * @Description: 矩形
 * @Author: baxiang
 * @Date: 2021/8/13.
 */
public class Rectangle {
    private Integer length;
    private Integer width;
    public Rectangle(Integer length, Integer width) {
        this.length = length;
        this.width = width;
    }
    /**
     * 获取矩形面积
     *
     * @return
     */
    public Integer area() {
        return this.length * this.width;
    }
}

创建正方形

package com.example.java.inheritance;
/**
 * @Description: 正方形
 * @Author: baxiang
 * @Date: 2021/8/13.
 */
public class Square extends Rectangle{
    public Square(Integer length) {
        super(length, length);
    }
}

成员变量

当子类继承了某个类之后，便可以使用父类中的成员变量，但是并不是完全继承父类的所有成员变量。涉及到成员变量的修饰符，具体的原则如下：
(1). 能够继承父类的public和protected成员变量；不能够继承父类的private成员变量；
(2). 对于缺省修饰符的成员变量，如果子类和父类在同一个包下，则子类能够继承；否则，子类不能够继承；
(3). 对于子类可以继承的父类成员变量，如果在子类中出现了同名称的成员变量，则会发生隐藏现象，即子类的成员变量会屏蔽掉父类的同名成员变量。如果要在子类中访问父类中同名成员变量，需要使用super关键字来进行引用。

方法

(1) 能够继承父类的public和protected成员方法；不能够继承父类的private成员方法；
(2) 对于缺省修饰符的成员方法，如果子类和父类在同一个包下，则子类能够继承；否则，子类不能够继承；
(3) 对于子类可以继承的父类成员方法，如果在子类中出现了方法名称相同的成员方法，则称为覆盖，即子类的成员方法会覆盖掉父类的同名成员方法。如果要在子类中访问父类中同名成员方法，需要使用super关键字来进行引用。
(4)子类访问权限必须大于等于父类。
(5)类方法static是隐藏父类的方法。

构造器

（1）子类是不能够继承父类的构造器，但是要注意的是，如果父类的构造器都是带有参数的，则必须在子类的构造器中显示地通过super关键字调用父类的构造器并配以适当的参数列表。
如果父类有无参构造器，则在子类的构造器中用super关键字调用父类构造器不是必须的，如果没有使用super关键字，编译器会自动调用父类的无参构造器。

访问权限

Java 中有三个访问权限修饰符：private、protected 以及 public，如果不加访问修饰符，表示包级可见。
可以对类或类中的成员（字段以及方法）加上访问修饰符。

类可见表示其它类可以用这个类创建实例对象。
成员可见表示其它类可以用这个类的实例对象访问到该成员；

protected 用于修饰成员，表示在继承体系中成员对于子类可见，但是这个访问修饰符对于类没有意义。
设计良好的模块会隐藏所有的实现细节，把它的 API 与它的实现清晰地隔离开来。模块之间只通过它们的 API 进行通信，一个模块不需要知道其他模块的内部工作情况，这个概念被称为信息隐藏或封装。因此访问权限应当尽可能地使每个类或者成员不被外界访问。
如果子类的方法重写了父类的方法，那么子类中该方法的访问级别不允许低于父类的访问级别。这是为了确保可以使用父类实例的地方都可以使用子类实例，也就是确保满足里氏替换原则。
字段决不能是公有的，因为这么做的话就失去了对这个字段修改行为的控制，客户端可以对其随意修改。例如下面的例子中，AccessExample 拥有 id 公有字段，如果在某个时刻，我们想要使用 int 存储 id 字段，那么就需要修改所有的客户端代码。

public class AccessExample {
    public String id;
}

可以使用公有的 getter 和 setter 方法来替换公有字段，这样的话就可以控制对字段的修改行为。

public class AccessExample {
    private int id;
    public String getId() {
        return id + "";
    }
    public void setId(String id) {
        this.id = Integer.valueOf(id);
    }
}

但是也有例外，如果是包级私有的类或者私有的嵌套类，那么直接暴露成员不会有特别大的影响。

public class AccessWithInnerClassExample {
    private class InnerClass {
        int x;
    }
    private InnerClass innerClass;
    public AccessWithInnerClassExample() {
        innerClass = new InnerClass();
    }
    public int getValue() {
        return innerClass.x;  // 直接访问
    }
}

抽象类

1. 抽象类
抽象类和抽象方法都使用 abstract 关键字进行声明。如果一个类中包含抽象方法，那么这个类必须声明为抽象类。
抽象类和普通类最大的区别是，抽象类不能被实例化，需要继承抽象类才能实例化其子类。

public abstract class AbstractClassExample {
    protected int x;
    private int y;
    public abstract void func1();
    public void func2() {
        System.out.println("func2");
    }
}
public class AbstractExtendClassExample extends AbstractClassExample {
    @Override
    public void func1() {
        System.out.println("func1");
    }
}
// AbstractClassExample ac1 = new AbstractClassExample(); // 'AbstractClassExample' is abstract; cannot be instantiated
AbstractClassExample ac2 = new AbstractExtendClassExample();
ac2.func1();

[

](https://github.com/CyC2018/CS-Notes/blob/master/notes/Java%20%E5%9F%BA%E7%A1%80.md#super)

super

访问父类的构造函数：可以使用 super() 函数访问父类的构造函数，从而委托父类完成一些初始化的工作。应该注意到，子类一定会调用父类的构造函数来完成初始化工作，一般是调用父类的默认构造函数，如果子类需要调用父类其它构造函数，那么就可以使用 super 函数。
访问父类的成员：如果子类重写了父类的某个方法，可以通过使用 super 关键字来引用父类的方法实现。

public class SuperExample {
    protected int x;
    protected int y;
    public SuperExample(int x, int y) {
        this.x = x;
        this.y = y;
    }
    public void func() {
        System.out.println("SuperExample.func()");
    }
}
public class SuperExtendExample extends SuperExample {
    private int z;
    public SuperExtendExample(int x, int y, int z) {
        super(x, y);
        this.z = z;
    }
    @Override
    public void func() {
        super.func();
        System.out.println("SuperExtendExample.func()");
    }
}
SuperExample e = new SuperExtendExample(1, 2, 3);
e.func();
SuperExample.func()
SuperExtendExample.func()

[

](https://docs.oracle.com/javase/tutorial/java/IandI/super.html)

重写与重载

1. 重写（Override）
存在于继承体系中，指子类实现了一个与父类在方法声明上完全相同的一个方法。
为了满足里式替换原则，重写有以下三个限制：

子类方法的访问权限必须大于等于父类方法；
子类方法的返回类型必须是父类方法返回类型或为其子类型。
子类方法抛出的异常类型必须是父类抛出异常类型或为其子类型。

使用 @Override 注解，可以让编译器帮忙检查是否满足上面的三个限制条件。
下面的示例中，SubClass 为 SuperClass 的子类，SubClass 重写了 SuperClass 的 func() 方法。其中：

子类方法访问权限为 public，大于父类的 protected。
子类的返回类型为 ArrayList，是父类返回类型 List 的子类。
子类抛出的异常类型为 Exception，是父类抛出异常 Throwable 的子类。
子类重写方法使用 @Override 注解，从而让编译器自动检查是否满足限制条件。

class SuperClass {
    protected List<Integer> func() throws Throwable {
        return new ArrayList<>();
    }
}
class SubClass extends SuperClass {
    @Override
    public ArrayList<Integer> func() throws Exception {
        return new ArrayList<>();
    }
}

在调用一个方法时，先从本类中查找看是否有对应的方法，如果没有查找到再到父类中查看，看是否有继承来的方法。否则就要对参数进行转型，转成父类之后看是否有对应的方法。总的来说，方法调用的优先级为：

this.func(this)
super.func(this)
this.func(super)
super.func(super)

/
A
|
B
|
C
|
D
/

classA {

publicvoidshow(Aobj) {
System.out.println(“A.show(A)”);
}

publicvoidshow(Cobj) {
System.out.println(“A.show(C)”);
}
}

classBextendsA {

@Override
publicvoidshow(Aobj) {
System.out.println(“B.show(A)”);
}
}

classCextendsB {
}

classDextendsC {
}
publicstaticvoid main(String[] args) {

A a =newA();
B b =newB();
C c =newC();
D d =newD();

// 在 A 中存在 show(A obj)，直接调用
a.show(a); // A.show(A)
// 在 A 中不存在 show(B obj)，将 B 转型成其父类 A
a.show(b); // A.show(A)
// 在 B 中存在从 A 继承来的 show(C obj)，直接调用
b.show(c); // A.show(C)
// 在 B 中不存在 show(D obj)，但是存在从 A 继承来的 show(C obj)，将 D 转型成其父类 C
b.show(d); // A.show(C)

// 引用的还是 B 对象，所以 ba 和 b 的调用结果一样
A ba =newB();
ba.show(c); // A.show(C)
ba.show(d); // A.show(C)
}
2. 重载（Overload）
存在于同一个类中，指一个方法与已经存在的方法名称上相同，但是参数类型、个数、顺序至少有一个不同。
应该注意的是，返回值不同，其它都相同不算是重载。

接口

Java只能单继承，无法多继承，但是实际开发中可能存在继承的问题，Java中的接口可以变相实现多重继承。

接口定义

interface接口是抽象类的延伸，在 Java 8 之前，它可以看成是一个完全抽象的类，也就是说它不能有任何的方法实现。
从 Java 8 开始，接口也可以拥有默认的方法实现，这是因为不支持默认方法的接口的维护成本太高了。在 Java 8 之前，如果一个接口想要添加新的方法，那么要修改所有实现了该接口的类。
接口的成员（字段 + 方法）默认都是 public 的，并且不允许定义为 private 或者 protected。
接口的字段默认都是 static 和 final 的。

[修饰符]interface <接口名> [extends 父类接口名称列表]{
   [public][static][final] 变量
  [public][abstract] 方法
}

interface TestOne{
}
interface TestTwo{
}
interface TestThree  extends TestOne,TestTwo{
}

接口的实现

（1）接口只能继承接口不能继承类，而且是单继承，不能继承多个接口

[修饰符] class <类名> [extends 父类类] [implements 接口列表]{

public interface InterfaceExample {
    void func1();
    default void func2(){
        System.out.println("func2");
    }
    int x = 123;
    // int y;               // Variable 'y' might not have been initialized
    public int z = 0;       // Modifier 'public' is redundant for interface fields
    // private int k = 0;   // Modifier 'private' not allowed here
    // protected int l = 0; // Modifier 'protected' not allowed here
    // private void fun3(); // Modifier 'private' not allowed here
}
public class InterfaceImplementExample implements InterfaceExample {
    @Override
    public void func1() {
        System.out.println("func1");
    }
}
// InterfaceExample ie1 = new InterfaceExample(); // 'InterfaceExample' is abstract; cannot be instantiated
InterfaceExample ie2 = new InterfaceImplementExample();
ie2.func1();
System.out.println(InterfaceExample.x);

接口和和抽象类的对比

相同点：
（1）主要都是被其他类继承，不能创建对象不能实例化
（2）都可以定义抽象方法子类都必须覆写抽象方法
不同点：
（1）接口没有构造方法
（2）Java8之前接口只能有抽象方法
（3）子类只能继承一个抽象类但是可以支持多个接口。
t