Java根本---继承

一、什么是继承

1.1、为什么要继承

在java的类的创建的时间，我们不可制止的要创建许多的对象，而某些对象之间又会存在某些接洽，
在这个时间，我们就可以把这些共性的特点抽取出来，单独设置为一个类，以此来实现代码的复用。

图中可以看出，玫瑰花和西红柿都有名字和颜色，还都可以举行生长，这个时间我们就可以把这些相同的地方抽取出来形成一个类。
面向对象思想中提出了继承的概念，专门用来举行共性抽取，实现代码复用
1.2、继承的概念

继承就是在保存原有机制的根本上，实现扩展，形成新的派生类，是实现代码复用的紧张手段，体现了由简朴到复杂的过程，继承主要解决的问题就是：共性的抽取，代码的复用。
由上图可以发现，玫瑰花和西红柿都是植物，都有本身的名字和颜色，还有相同的方法。以是我们可以单独创建一个植物类来存储这些特点。

上图即为继承的过程，其中Plant类被称为父类、超类、基类，Rose和Tomato类被称为子类或派生类。
1.3、继承的语法

在Java中要表现类之间的继承关系，需extends关键字，如下：

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

复制代码

对上面例子的继承：

1. class Plant {
2.     public String name;
3.     public String color;
5.     public Plant(String name, String color) {
6.         this.name = name;
7.         this.color = color;
8.     }
9.     public void togrow() {
10.         System.out.println("种" + this.name);
11.     }
12. }
14. class Rose extends Plant{
15.     public Rose(String name, String color) {
16.         super(name,color);
17.     }
18.    
19.     public void tolove() {
20.         System.out.println("给你爱的人");
21.     }
22. }
23. class Tomato extends Plant{
24.     public Tomato(String name, String color) {
25.         super(name,color);
26.     }
27.    
28.     public void toeat() {
29.         System.out.println("给你爱的人吃");
30.     }
31. }

复制代码

留意：
1.子类会将父类的成员变量和成员方法继承过来
2.子类继承父类后，要添加本身的成员方法或成员变量，否则就没必要继承了
二、父类的访问

在继承体系中，子类将父类中的成员变量和方法继承下来了，那在子类中可否直接访问父类中继承下来的成员呢？
2.1、子类中访问父类的成员变量

2.2.1、子类和父类不存在同名变量

1. class Father {
2.     public int a = 10;
3.     public int b = 20;
4. }
6. class Son extends Father {
7.     public int c = 30;
8.     public void main(String[] args) {
9.         a = 1;//访问父类的a
10.         b = 2;//访问父类的b
11.         c = 3;//访问子类自己的c
12.     }
13. }

复制代码

2.2.2、子类和父类成员变量同名

1. class Father {
2.     public int a = 10;
3.     public int b = 20;
4.     public int c = 30;
5. }
7. class Son extends Father {
8.     public int a;//同名，类型相同
9.     public char b;//同名，类型不同
10.     public void show() {
11.         a = 1;//访问父类继承的a？还是子类的a？
12.         b = 2;//访问父类继承的b？还是子类的b？
13.         c = 3;//子类没有c，访问的是父类继承的c
14.         //d = 4;//编译失败，父类和子类中都没有d
15.     }
16. }

复制代码

在子类方法或通过子类对象访问父类成员时：
1.假如访问的成员变量子类中没有，而父类有，访问的是父类中继承下来的
2.假如访问的成员变量子类中有，优先访问本身的
3.假如访问的成员变量在父类和子类中都没有，编译报错
4.假如访问的成员变量与父类的同名，优先访问子类本身的。
2.2、子类中访问父类的成员方法

1. class Father {
2.     public void showA() {
3.         System.out.println("访问的是父类的showA");
4.     }
5.     public void showB() {
6.         System.out.println("访问的是父类的showB");
7.     }
8. }
10. class Son extends Father {
11.     public void showA(int n) {
12.         System.out.println("访问的是子类的showA");
13.     }
14.     public void showB() {
15.         System.out.println("访问的是子类的showB");
16.     }
18.     public void test() {
19.         showA();//没有参数，访问的是父类showA
20.         showA(1);//有参数，访问的是子类showA
21.         showB();//直接访问的是子类的showB
22.     }
24. }

复制代码

总结：
1.通过子类对象访问不同名的成员方法时，假如子类中有就访问本身的，否则在父类中找，找到就访问，否则编译报错## 标题
2.通过子类对象访问同名的成员方法时，假如父类和子类的方法构成了重载，就按照传递的参数举行访问
假如子类中存在与父类中相同的成员时，那怎样在子类中访问父类相同名称的成员呢？
这个时间就需要我们的super关键字了
三、关键字

3.1、super关键字

由于设计或场景需要，子类和父类可能存在同名变量，这个时间，假如我们需要在子类中访问父类的成员变量，我们应该怎么做呢。
直接访问是无法做到的，Java提供了super关键字，该关键字的作用就是在子类中访问父类的成员。

1. class Super {
2.     public int a = 1;
3.     public int b = 2;
5.     public Super(int a, int b) {
6.         this.a = a;
7.         this.b = b;
8.     }
9.     public void func() {
10.         System.out.println("调用的是父类中的func");
11.     }
12. }
14. class Base extends Super {
15.     public int a = 10;//同名同类型
16.     public char b = 'b';//同名不同类型
18.     public Base(int a, int b, int a1, char b1) {
19.         super(a, b);
20.         this.a = a1;
21.         this.b = b1;
22.     }
23.     public void func() {
24.         System.out.println("调用的是子类中的func");
25.     }
26.     public void test() {
28.         //对于同名变量，直接访问都是访问子类的变量
29.         System.out.println(a);//结果会是10,不能直接访问到父类的a
30.         System.out.println(super.a);//结果会是1
32.         //对于重写的方法，也要通过super关键字
33.         func();//子类的
34.         super.func();//父类的
35.     }
36. }
37. public class Test1 {
38.     public static void main(String[] args) {
39.         Base bs = new Base(1,2,10,'B');
40.         bs.test();
41.     }
42. }
44. //运行结果：
45. 10
46. 1
47. 调用的是子类中的func
48. 调用的是父类中的func

复制代码

留意：
1.super只能非静态方法中利用
2.在子类方法中访问父类的成员变量和方法
3.2、super和this

super和this都可以在成员方法中用来访问成员变量和调用其他成员方法，都可以作为构造语句的第一条语句，那他们之间有什么区别呢？
相同点：
1.都是Java的关键字
2.在构造方法中都要放在第一条语句
3.都只能在非静态的成员方法中利用，用来访问非静态的成员变量和字段
不同点：
1.this是当前对象的引用，当前对象指代调用该实例方法的对象，super是子类从父类继承下来的部分成员的引用
2.在非静态方法中，this用来访问本类的成员方法和变量，super用来访问从父类继承下来的方法和变量
3.在构造方法中，this(…)用来调用本类的构造方法，super(…)用来调用父类的构造方法，两者不能同时在构造方法中出现
4.在子类的构造方法中，肯定会存在super(…)的调用，就算不写，编译器也会默认天生，但是this(…)不写则没有
3.3、final关键字

final关键字可以用来修饰变量，成员方法以及类
1.修饰变量或字段表现常量，既不能被修改
2.修饰成员方法，表现该成员方法不能被重写
3.修饰类，表现该类不能被继承
四、再谈初始化

4.1、子类父类构造方法的关系

在给子类举行初始化前，必须先给父类举行初始化
如上文代码块中的：

1. public Base(int a, int b, int a1, char b1) {
2.         super(a, b);//给父类进行初始化
3.         this.a = a1;
4.         this.b = b1;
5.     }

复制代码

4.2、执行顺序

1. public class Test2 {
2.     public static void main(String[] args) {
3.         Students p2 = new Students("李四",7);
4.     }
5. }
7. class Person {
8.     public String name;
9.     public int age;
11.     public Person(String name, int age) {
12.         this.name = name;
13.         this.age = age;
14.         System.out.println("父类的构造方法被执行了");
15.     }
17.     public static void fj() {
18.         System.out.println("父类的静态方法被执行了");
19.     }
21.     static {
22.         System.out.println("父类的静态代码块被执行了");
23.     }
25.     {
26.         System.out.println("父类的实例代码块被执行了");
27.     }
28. }
30. class Students extends Person{
31.     public Students(String name, int age) {
32.         super(name, age);
33.         System.out.println("子类的构造方法被执行了");
34.     }
36.     public static void zj() {
37.         System.out.println("子类的静态方法被执行了");
38.     }
40.     static {
41.         System.out.println("子类的静态代码块被执行了");
42.     }
44.     {
45.         System.out.println("子类的实例代码块被执行了");
46.     }
47. }
49. //执行结果：
50. 父类的静态代码块被执行了
51. 子类的静态代码块被执行了
52. 父类的实例代码块被执行了
53. 父类的构造方法被执行了
54. 子类的实例代码块被执行了
55. 子类的构造方法被执行了

复制代码

通过以上的执行结果，可以有以下结论：
1.静态代码块先执行，父类的静态代码块优先于子类
2.父类的实例代码块和构造方法紧接着执行
3.子类的实例代码块和构造方法紧接着这些
留意：
1.子类和父类的静态代码块只执行一次，第二次创建对象时不在执行
2.当有对象创建时，会执行实例代码块，再然后才是构造方法

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。