《java练级之路》之继承！！！

🎇🎇🎇作者：
@小鱼不会骑车
🎆🎆🎆专栏：
《java练级之旅》
🎓🎓🎓个人简介：
一名专科大一在读的小比特，努力学习编程是我唯一的出路😎😎😎

🙈🙈🙈作者心里话

小鱼一直都是秉承着“开开心心看博客，快快乐乐学知识的观点，虽然浏览量好低…”

前言

继承是面向对象语法的三大特征之一继承可以降低代码编写的冗余度，提高编程的效率。通过继承，子类获得了父类的成员变量和方法。一个子类如何继承父类的字段和方法，如何修改从父类继承过来的子类的方法呢

第一部分

🍂1.1 为什么要继承

我们来写出两个类，分别是猫类和狗类

class Dog  {//狗类
   public String name;
   public int age;
   public void wangwang() {
    System.out.println(name+" 汪汪叫");
   }
   public void eat() {
    System.out.println(name+" 在吃饭");
   }

}
 class Cat  {//猫类
 
    public String name;
    public int age;
    public void mimi() {
     System.out.println(name+" 咪咪叫");
    }
    public void eat() {
     System.out.println(name+" 在吃饭");
    }
    
}

public class Main {
 public static void main(String[] args) {
    Dog dog=new Dog();
    System.out.println("======");
    Dog dog1=new Dog();
     }
 }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

大家看这两个类在堆上开辟的对象

大家看，相同的部分我都圈起来了，我们的猫类和狗类都是有名字的，那我们可以将这些共性抽取出来吗？

🍂1.2 继承的概念

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。
我们设父类为Base

上述图示中，Dog和Cat都继承了Base类，其中：Base类称为父类/基类或超类，Dog和Cat可以称为Base的子类/派生类，继承之后，子类可以复用父类中成员，子类在实现时只需关心自己新增加的成员即可。

🍂1.3 继承的语法

在Java中如果要表示类之间的继承关系，需要借助extends关键字，具体如下：

修饰符 class 子类 extends 父类 {
// ... 
}
1
2
3

下面使用继承的方式重新设计

class Base {

    String name;
    int age;
    public void eat() {
        System.out.println(name+" 在吃饭");
    }
}

class Dog extends Base {
   public void wangwang() {
    System.out.println(name+" 汪汪叫");
   }

}
 class Cat extends Base {

    public void mimi() {
     System.out.println(name+" 咪咪叫");
    }

}

public class Main {
 public static void main(String[] args) {
 
    Dog dog=new Dog();
    // dog类中并没有定义任何成员变量，name和age属性肯定是从父类Base中继承下来的
    dog.name="小八嘎";
    dog.age=3;
     System.out.println(dog.name);
     System.out.println(dog.age);
    dog.eat();// dog访问的eat()方法也是从Base中继承下来的
    dog.wangwang();//dog自己的方法
    }
 }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

注意

1. 子类会将父类中的成员变量或者成员方法继承到子类中了
2. 子类继承父类之后，必须要新添加自己特有的成员，体现出与基类的不同，否则就没有必要继承了

第二部分

🍂2.1 访问父类成员

在继承体系中，子类将父类中的方法和字段继承下来了，那在子类中能否直接访问父类中继承下来的成员呢？

🍃2.1.1 子类访问父类属性

🍁1.当子类和父类的属性不重名

public class A {
    public int a;
    public int b;

}
class B extends A {

    public int c;
}
class Main {
    public static void main(String[] args) {
        B p1=new B();
        p1.a=10;//访问从父类继承的a
        p1.b=20;//访问从父类继承的b
        p1.c=30;//访问自己的c
        System.out.println(p1.a);
        System.out.println(p1.b);
        System.out.println(p1.c);
        //输出10，20，30

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

🍁2.当子类的属性和父类的属性重名

public class A {
    public int a=10;
    public int b=20;
    public int c=30;

}
class B extends A {

    public int a=30;//同类型同变量名
    public char b=97;//不同类型相同变量名
    public int d=50;
}
class Main {
    public static void main(String[] args) {
        B p1=new B();//实例化一个B类
        //输出30，访问的是子类的a
        System.out.println(p1.a);
        //输出'a'，访问的是子类的b，转换成ascll值就是'a'
        System.out.println(p1.b);
		//输出30访问的是父类的c，子类没有c
        System.out.println(p1.c);
        System.out.println(p1.d);
        //50，只有子类有d，访问的是子类的
        //System.out.println(p1.e);编译失败，子类父类都没有e这个变量

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

在子类方法中 或者 通过子类对象访问成员时：

• 如果访问的成员变量子类中有，优先访问自己的成员变量。
• 如果访问的成员变量子类中无，则访问父类继承下来的，如果父类也没有定义，则编译报错。
• 如果访问的成员变量与父类中成员变量同名，则优先访问自己的。
• 成员变量访问遵循就近原则，自己有优先自己的，如果没有则向父类中找。

🍃2.1.2 子类访问父类方法

🍁1. 当子类的方法和父类的方法不重名

public class A {
  	public void print(){
      System.out.println("我是A类的方法");
    }

}
class B extends A {
    public void print1() {
      System.out.println("我是B类的方法");
    }
}
class Main {

    public static void main(String[] args) {
        B p1=new B();//实例化一个B类的对象
        p1.print();//继承父类的方法，打印我是A类的方法
        p1.print1();//子类自己的方法，打印我是B类的方法
    // print2(); // 编译失败，在整个继承体系中没有发现方法print2()
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

总结
当我们成员方法没有同名时，在子类方法中或者通过子类对象访问方法时，则优先访问自己的，自己没有时
再到父类中找，如果父类中也没有则报错。

🍁2. 当子类的方法和父类的方法重名

public class A {
  public void printA(){
      System.out.println("A类中的printfA");
    }
    public void printB() {
        System.out.println("A类中的printfB");
    }

}
class B extends A {
    public void printA(int a) {
        System.out.println("B类中的printA");
        }
   public void printB() {
       System.out.println("B类中的printB");
   }
    }


class Main {

    public static void main(String[] args) {
        B p1=new B();
       p1.printA(10);//调用子类的printA
       p1.printA();//子类没有，调用父类的printA
       p1.printB();//优先调用子类的printB
    	}
   }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

输出

【说明】

• 通过子类对象访问父类与子类中不同名方法时，优先在子类中找，找到则访问，否则在父类中找，找到
  则访问，否则编译报错。
• 通过派生类对象访问父类与子类同名方法时，如果父类和子类同名方法的参数列表不同(重载)，根据调用
  方法适传递的参数选择合适的方法访问，如果没有则报错；

那如果方法名或变量名相同时，我想调用父类的方法或变量，该怎么去做呢？

🍂2.2 super关键字

由于设计不好，或者因场景需要，子类和父类中可能会存在相同名称的成员，如果要在子类方法中访问父类同名成
员时，该如何操作？直接访问是无法做到的，Java提供了super关键字，该关键字主要作用：在子类方法中访问父类的成员,super暂时理解为(父类的引用)

🍃2.2.1 super关键字

public class A {
    int a=10;
    int b=20;
  public void printA(){
      System.out.println("A类中的printfA");
    }
    public void printB() {
        System.out.println("A类中的printfB");
    }

}
class B extends A {
    int a = 30;
    int b = 40;

    public void printA(int a) {
        System.out.println("B类中的printA");
    }

    public void printB() {
        System.out.println("B类中的printB");
    }

    public void printC() {
        System.out.println("B类中的printC");
    }

    public void printD() {
        // 对于同名的成员变量，直接访问时，访问的都是子类的
        System.out.println(a); // 等价于： this.a = 30;
        System.out.println(b); // 等价于： this.b = 40;
        // 注意：this是当前对象的引用
        // 访问父类的成员变量时，需要借助super关键字
        // super是获取到子类对象中从基类继承下来的部分
        System.out.println(super.a);//访问父类的成员变量a
        System.out.println(super.b);//访问父类的成员变量b
        // 父类和子类中构成重载的方法，直接可以通过参数列表区分清访问父类还是子类方法
        printA(); // 没有传参，访问父类中的printA()
        printA(20); // 传递int参数，访问子类中的printA(int)
        // 直接访问，则永远访问到的都是子类中的printB()，基类的无法访问到
        printB();
        // 如果在子类中要访问重写的基类方法，则需要借助super关键字
        super.printB();
        //先从子类中查找方法，查找不到再去基类，如果还是找不到就报错
        printC();

    }
}
class Main {

    public static void main(String[] args) {
        B p1 = new B();
        p1.printD();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

最后输出

大家不要说小鱼水博客，这样对比大家搭配注释应该很好的理解，

• super.a ，子类中访问父类成员变量
• super.printB ， 子类中访问父类的方法
• 当我的父类方法名和子类方法名一样，如果参数不同就会形成方法重载，如果参数相同就会采用就近原则。
• super只能在静态的方法中使用

super(暂时理解为父类的引用)不对！
正确的理解：super只是一个关键字，最大的作用就是在写代码或读代码时体现更好的可读性
单独解释一下为什么不能在静态方法中使用super
因为被static修饰的成员数据不依赖于对象，又因为super是依赖于对象的，所以如果没有实例化对象，那么在静态方法中使用super就会报错。

🍃2.3.2 子类构造方法

父子父子，先有父再有子，即：子类对象构造时，需要先调用基类构造方法，然后执行子类的构造方法。
在继承关系上，我们在构造子类的构造方法时，一定要先帮助父类进行构造
怎么帮助？
在子类中调用父类的构造方法，用super()
大家看这块代码

class A {

    public A() {//父类的构造方法
        
    }
}
class  B extends A {

    public B() {//子类的构造方法
        super();//调用父类的构造方法
    }

    public static void main(String[] args) {
        B p=new B();
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

其实平时我们如果并没有自己创建构造方法时，我们的编译器就会和上述代码一样，给我们提供一个无参的构造方法，并且会在子类的构造方法中第一个执行super()去调用父类的构造方法。
有这几种可能

• 题一：父类没有参数的构造方法，子类没有参数的构造方法
• 题二：父类没有参数的构造方法，子类有参数的构造方法
• 题三：父类有参数的构造方法，子类没有参数的构造方法
• 题四：父类有参数的构造方法，子类有参数的构造方法

题一题二当然我们完全可以省略不写super(),只要是我们的父类构造方法无参，图二是省略之后的
图一

图二
题三题四这个时候就不可以不写super,如果不写的话编译器就会产生编译错误。相同颜色的框就是我从哪里去调用它的构造方法
图一

如果想在实例化对象的时候就初始化父类的成员方法，可以这样，内个我们学习java就是要习惯这个抽象的图…

最后打印

张三
王五
1
2

在子类构造方法中，并没有写任何关于基类构造的代码，但是在构造子类对象时，先执行基类的构造方法，然后执
行子类的构造方法，因为：子类对象中成员是有两部分组成的，基类继承下来的以及子类新增加的部分 。父子父子肯定是先有父再有子，所以在构造子类对象时候 ，先要调用基类的构造方法，将从基类继承下来的成员构造完整，然后再调用子类自己的构造方法，将子类自己新增加的成员初始化完整
注意事项

1. 若父类显式定义无参或者默认的构造方法，在子类构造方法第一行默认有隐含的super()调用，即调用基类构造方法
2. 如果父类构造方法是带有参数的，此时需要用户为子类显式定义构造方法，并在子类构造方法中选择合适的父类构造方法调用，否则编译失败。
3. 在子类构造方法中，super(…)调用父类构造时，必须是子类构造函数中第一条语句。
4. super(…)只能在子类构造方法中出现一次，并且不能和this同时出现（因为this（）也是需要在第一行调用，当两个放在一起时编译器会报错）

🍃2.3.3 super和this

super和this都可以在成员方法中用来访问：成员变量和调用其他的成员函数，都可以作为构造方法的第一条语
句，那他们之间有什么区别呢？
【相同点】

1. 都是Java中的关键字
2. 只能在类的非静态方法中使用，用来访问非静态成员方法和字段
3. 在构造方法中调用时，必须是构造方法中的第一条语句，并且不能同时存在

【不同点】

1. this是当前对象的引用，当前对象即调用实例方法的对象，super相当于是子类对象中从父类继承下来部分成
   员的引用
2. 在非静态成员方法中，this用来访问本类的方法和属性，super用来访问父类继承下来的方法和属性
3. 在构造方法中：this(…)用于调用本类构造方法，super(…)用于调用父类构造方法，两种调用不能同时在构造
   方法中出现
4. 构造方法中一定会存在super(…)的调用，用户没有写编译器也会增加，但是this(…)用户不写则没有

🍂2.3 再谈初始化

回顾一下之前讲的：

• 静态代码块先执行，并且只执行一次，在类加载阶段执行
• 当有对象创建时，才会执行实例代码块，实例代码块执行完成后，最后构造方法执行

接下来是父类和子类都有实例化代码块和静态代码块时

class A {
    static {
        System.out.println("父类静态的代码块");//1
    }
    {
        System.out.println("父类实例的代码块");//2
    }

    public A() {
        System.out.println("父类的构造方法");//3
    }
}
class B extends A {
    static {
        System.out.println("子类的静态代码块");//4
    }
    {
        System.out.println("子类的实例代码块");//5
    }
    public B() {
        System.out.println("子类的构造方法");//6
    }
}
public class Main {
    public static void main(String[] args) {
        B p =new B();
        System.out.println("=======");
        p=new B();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

小鱼给这些都标上号了，大家可以看一下最后的顺序是多少

通过分析执行结果，得出以下结论：

1、父类静态代码块优先于子类静态代码块执行，且是最早执行
2、父类实例代码块和父类构造方法紧接着执行
3、子类的实例代码块和子类构造方法紧接着再执行
4、第二次实例化子类对象时，父类和子类的静态代码块都将不会再执行

🍂2.4 再谈重载（附加）

因为我们的后面会再学习新的知识重写，防止大家混淆这两个概念，我给大家单独再解释一下什么是重载

我们的继承关系的类也是存在构造方法的，在帮助手册中是这么形容的

名称相同，返回值无关，可以是继承关系，参数一定不同！！！

第三部分

🍂3.1 protected关键字

这个部分知识点其实有些多，后面会单独出一起类访问权限符的博客，在这里就大概介绍一下

验证

注意：父类中private成员变量虽然在子类中不能直接访问，但是也继承到子类中了
什么时候下用哪一种呢?

• 我们希望类要尽量做到 “封装”, 即隐藏内部实现细节, 只暴露出 必要 的信息给类的调用者.
• 因此我们在使用的时候应该尽可能的使用 比较严格 的访问权限. 例如如果一个方法能用 private, 就尽量不要用 public.
• 另外, 还有一种 简单粗暴 的做法: 将所有的字段设为 private, 将所有的方法设为 public. 不过这种方式属于是对访问权限的滥用,

🍂3.2 继承方式

给大家举个例子

我们可以从下面四个小宠物冲提出两个类，猫类和狗类，当然，也可以都统称为动物类。
在java中支持以下几种继承方式

注意！！！
java不支持多继承

• 我们并不希望类之间的继承层次太复杂. 一般我们不希望出现超过三层的继承关系. 如果继承层次太多, 就需要考虑对代码进行重构了.
• 如果想从语法上进行限制继承, 就可以使用 final 关键字

🍂3.3 final关键字

大家学过C语言都知道有一个关键字是const，用来将变量修饰为常量的，在java中也有个类似的，那就是final
关于final这个关键字其实有很多细节知识点，小鱼也会单独出一篇博客来详细讲解！！！