Java继承和多态（1）

🐵本主题将分为篇文章，本篇文章将主要对继承进行讲解

---

一、介绍继承

1.1 什么是继承

假如有两个类：A类和B类，A类在保持原有成员变量和方法的基础上可以使用B类的成员变量和方法，此时就称A类继承了B类，A类为子类，B类为父类；

继承是通过extends关键字来实现的：

class 父类 {
}

class 子类 extends 父类 {
}

举一个实例：

class Base {
    public int a = 10;
}

//Derived为子类，Base为父类
class Derived extends Base {
    public void method() {
        System.out.println(a);
    }
}
public class Test1{
    public static void main(String[] args) {
        Derived derived = new Derived();
        derived.method();
    }
}

1.2 为什么要有继承

假如有A、B两个类，这两个类中的成员变量和成员方法相似，这时可以再创建一个C类，C类的内容就是A类和B类相同的成员变量和方法，让A和B去继承C类，这样就可以避免代码的冗杂，从而实现代码的复用

二、子类访问父类成员

2.1 访问父类成员变量

当子类成员变量与父类成员变量相同时，优先访问子类成员变量

class Base {
    public int a = 10;
}
class Derived extends Base {
    public int a = 20;

    public void method() {
        System.out.println(a);
    }
}

2.2 访问父类成员方法

当子类成员方法名和父类成员方法名且参数列表相同时，优先访问子类成员方法；当方法名相同但参数列表不同时，访问合适的方法

class Base {
    public int a = 10;    
    public void method() {
        System.out.println("父类成员方法");
    }
    public void A() {
        System.out.println("父类A");
    }
}
class Derived extends Base {
    public int a = 20;
    public void method() {
        System.out.println("子类成员方法");
    }
    public void A (int a){
        this.a = a;
        System.out.println(a);
    }

}
public class Test1{
    public static void main(String[] args) {
        Derived derived = new Derived();
        derived.method(); //打印出 子类成员方法
        derived.A(30); //打印出30
        derived.A(); //打印出 父类A
    }
}

那么当子类成员和父类成员名字相同而我们想要访问父类成员时该如何做，下面介绍super关键字

三、super关键字

super实际上就是从父类继承过来数据的引用，其主要作用就是在子类方法中访问父类成员，super不能出现在静态方法中，以下时super的用法：

1. super.父类成员变量--->访问父类成员变量

2.super.父类成员方法--->访问父类成员方法

3.super() --->访问父类构造方法 （下面介绍）

3.1 super访问父类成员变量

class Parent {
    public int a = 10;
}
class Child extends Parent{
    public int a = 20;
    public void method() {
        System.out.println(super.a);//子类与父类成员变量名字都为a，使用super关键字后就会访问父类的a
    }
}
public class Test2 {
    public static void main(String[] args) {
        Child child = new Child();
        child.method();
    }
}

3.2 super访问父类成员方法

class Parent {
    public void method() {
        System.out.println("父类成员方法");
    }
}
class Child extends Parent{
    public void method() {
        System.out.println("子类成员方法");
    }
    public void func() {
        super.method();
    }
}
public class Test2 {
    public static void main(String[] args) {
        Child child = new Child();
        child.func();
    }
}

四、子类和父类构造方法

在创建对象时，会调用构造方法，如果没有写构造方法，就调用默认的构造方法，在子类和父类的构造方法如下

class Parent {
    public Parent() {

    }
}

class Child extends Parent {
    public Child() {
        super(); //该语句必须出现在子类构造方法的第一行
                //创建对象时先调用父类构造方法再调用子类构造方法
    }
}

以下是错误写法：

class Parent {
    public int a;
    public Parent(int a) { 
        this.a = a;
    }
}
class Child extends Parent { 
    
    public void method() {
        System.out.println(a);
    }
}
public class Test2 {
    public static void main(String[] args) {
        Child child = new Child();
        child.method();
    }
}

上述代码写了只写了父类构造方法，且有一个参数，而没有写子类的构造方法，那么创建对象时就会调用子类的默认构造方法，默认方法中super()中没有参数，所以会报错。那么应该自己去写子类的构造方法，并在super()中写上对应的参数，切记super()要写在子类构造方法的第一行

注意：如果子类和父类的构造方法都写了，但在子类的构造方法中没有写super()，编译器也会自动加上（自动加上的super()没有参数）

五、继承关系下的执行顺序

下面来看继承关系下，静态代码块、构造代码块和构造方法的执行顺序

class Parent {
    static {
        System.out.println("父类静态代码块");
    }

    {
        System.out.println("父类构造代码块");
    }

    public Parent() {
        System.out.println("父类构造方法");
    }

}
class Child extends Parent{
    static {
        System.out.println("子类静态代码块");
    }

    {
        System.out.println("子类构造代码块");
    }

    public Child() {
        super();
        System.out.println("子类构造方法");
    }
}
public class Test {
   
    Child child = new Child();
}

结论：在继承关系下，也是静态代码块先执行，只不过要先执行父类在执行子类，之后也是先执行父类的构造代码块和构造方法，在执行子类的构造代码块和构造方法

六、protected关键字

访问范围	public	private	没有修饰符	protected
同一包中的同一类	✔️	✔️	✔️	✔️
同一包中的不同类	✔️		✔️	✔️
不同包中的子类	✔️			✔️
不同包中的非子类	✔️

着重讲解protected的第三项

package demo1; //demo1包
public class Code {
    protected int x = 10; //x被protected修饰
}


package demo2; //demo2包
import demo1.Code;

public class Derived extends Code {
    public void func() {
        System.out.println(super.x); //编译通过
        Code code = new Code();
        //System.out.println(code.x); //编译报错，在不同包的子类中，不能通过对象的引用访问，而是通过super引用访问
    }
    public static void main(String[] args) {
        Derived derived = new Derived();
        derived.func();
    }
}

七、继承的方式

下面来介绍几种继承的方式:

1.单继承：

2.多层继承：

3. 多继承一：

Java不支持多继承，如下图：

在多层继承中最好不要出现三层继承，为了限制继承的层次，引入final关键字

7.1 final关键字

7.1.1 final修饰变量

当一个变量被final修饰时，它就变成了常量，即不能改变它的值

7.1.2 final修饰类

当一个类被final修饰时，就被称为密封类，该类不能被其它类继承

public final class Test {...}
class Child extends Test {...} //编译报错

7.1.2 final修饰成员方法

当一个方法被final修饰时，该方法不能被重写

八、组合

组合简单来说，就是将一个类的实例作为另一个类的字段

class A { }
class B { }
class C { }

public class Test {
    private A a;
    private B b;
    private C c;
}

组合和继承一样都可以实现代码的复用

---

🙉本篇文章到此结束，下篇文章将会对多态相关知识进行讲解