【JAVASE】继承

迷南。 2024-04-23 20:26 2阅读 0赞

> ⭐ 作者：小胡\_不糊涂  
> 🌱 作者主页：[小胡\_不糊涂的个人主页][Link 1]  
> 📀 收录专栏：[浅谈Java][Java]  
> 💖 持续更文，关注博主少走弯路，谢谢大家支持 💖

#### 继承 ####

*  1. 为什么要继承
 *  2. 继承概念
 *  3. 继承的语法
 *  4. 父类成员访问
 *   *  4.1 子类中访问父类的成员变量
     *  4.2 子类中访问父类的成员方法
 *  5. super 关键字
 *  6. 子类构造方法
 *  7. super 和 this
 *  8. 再谈初始化
 *  9. protected 关键字
 *  10. 继承方式
 *  11. final 关键字
 *  12. 继承与组合

![在这里插入图片描述][b572dc771c554f919331d858ce47c5bb.gif_pic_center]

## 1. 为什么要继承 ##

> Java中使用类对现实世界中实体来进行描述，类经过实例化之后的产物对象，则可以用来表示现实中的实体，但是现实世界错综复杂，事物之间可能会存在一些关联，那在设计程序是就需要考虑。

比如：**狗和猫，它们都是一个动物。**

![在这里插入图片描述][977f968f1b74416ca30cf7bce7e9940f.png]

使用Java语言来进行描述，就会设计出：

//Dog.java
    public class Dog {
        
        String name;
        int age;
        float weight;
        public void eat(){
        
            System.out.println(name + "正在吃饭");
        }
        public void sleep(){
        
            System.out.println(name + "正在睡觉");
        }
        void Bark(){
        
            System.out.println(name + "汪汪汪~~~");
        }
    }

//Cat.java
    public class Cat {
        
        String name;
        int age;
        float weight;
        public void eat(){
        
            System.out.println(name + "正在吃饭");
        }
        public void sleep()
        {
        
            System.out.println(name + "正在睡觉");
        }
        void mew(){
        
            System.out.println(name + "喵喵喵~~~");
        }
    }

通过观察上述代码会发现，猫和狗的类中存在大量重复，如下所示：

![在这里插入图片描述][b901b6542c264c51885f6f54e7199da1.png]  
那能否将这些共性抽取呢？  
**面向对象思想中提出了继承的概念，专门用来进行共性抽取，实现代码复用。**

## 2. 继承概念 ##

**继承(inheritance)机制**：是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上**进行扩展**，增加新功能，这样产生新的类，称**派生类**。

> 继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。

**继承主要解决的问题是：共性的抽取，实现代码复用。**

例如：狗和猫都是动物，那么我们就可以将共性的内容进行抽取，然后采用继承的思想来达到共用。

![在这里插入图片描述][9ff89f5b90eb4ee6b821da576d25cd5f.png]

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

从继承概念中可以看出继承最大的作用就是：**实现代码复用，还有就是来实现多态。**

## 3. 继承的语法 ##

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

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

对上述 2 中场景使用继承方式重新设计：

//Animal.java
    public class Animal {
        
            String name;
            int age;
    
            public void eat(){
        
                System.out.println(this.name + "正在吃饭");
            }
    
            public void sleep(){
        
                System.out.println(this.name + "正在睡觉");
            }
        }

//Dog.java
    public class Dog extends Animal{
        
        void bark(){
        
            System.out.println(this.name + "汪汪汪~~~");
        }
    }

//Cat.java
    public class Cat extends Animal{
        
        void mew(){
        
            System.out.println(this.name + "喵喵喵~~~");
        }
    }

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

🍤 *运行结果：*

![在这里插入图片描述][dc48f71e9b514c0f9f38396e5e224181.png]

注：

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

## 4. 父类成员访问 ##

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

### 4.1 子类中访问父类的成员变量 ###

1.  子类和父类不存在同名成员变量

public class Base {
        
    	int a;
    	int b;
    }
    
    public class Derived extends Base{
        
    	int c;
    	public void method(){
        
    		a = 10; // 访问从父类中继承下来的a
    		b = 20; // 访问从父类中继承下来的b
    		c = 30; // 访问子类自己的c
    	}
    }

1.  子类和父类成员变量同名

//代码一：
    public class Base {
        
    	int a;
    	int b;
    	int c;
    }

//代码二：
    public class Derived extends Base{
        
    	int a; // 与父类中成员a同名，且类型相同
    	char b; // 与父类中成员b同名，但类型不同
    	public void method(){
        
    		a = 100; // 访问父类继承的a，还是子类自己新增的a？
    		b = 101; // 访问父类继承的b，还是子类自己新增的b?
    		c = 102; // 子类没有c，访问的肯定是从父类继承下来的c
    		// d = 103; // 编译失败，因为父类和子类都没有定义成员变量d
    	}
    }

> **在子类方法中 或者 通过子类对象访问成员时：**  
> 如果访问的成员变量子类中有，优先访问自己的成员变量。  
> 如果访问的成员变量子类中无，则访问父类继承下来的，如果父类也没有定义，则编译报错。  
> 如果访问的成员变量与父类中成员变量同名，则优先访问自己的。

**成员变量访问遵循就近原则，自己有优先自己的，如果没有则向父类中找。**

### 4.2 子类中访问父类的成员方法 ###

1.  成员方法名字不同

//Base.java
    public class Base {
        
    	public void methodA(){
        
    		System.out.println("Base中的methodA()");
    	}
    }
    
    //Derived.java
    public class Derived extends Base{
        
    	public void methodB(){
        
    		System.out.println("Derived中的methodB()方法");
    	}
    	public void methodC(){
        
    		methodB(); // 访问子类自己的methodB()
    		methodA(); // 访问父类继承的methodA()
    		// methodD(); // 编译失败，在整个继承体系中没有发现方法methodD()
    	}
    }
    
    //Main.java
    public class Main{
        
        public static void main(String[] args) {
        
            Derived derived=new Derived();
            derived.methodC();
        }
    }

🍤 *运行结果：*

![在这里插入图片描述][9078f104949344b49ff89d53f1b7baca.png]  
🍤 *没有 method() 时会报错：*

![在这里插入图片描述][1cf6d19c2c7844eea381e92fe9ed1fb2.png]

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

1.  成员方法名字相同

//Base.java
    public class Base {
        
    	public void methodA(){
        
    	System.out.println("Base中的methodA()");
    	}
    	public void methodB(){
        
    	System.out.println("Base中的methodB()");
    	}
    }

//Derived.java
    public class Derived extends Base{
        
    	public void methodA(int a) {
        
    		System.out.println("Derived中的method(int)方法");
    	}
    	
    	public void methodB(){
        
    		System.out.println("Derived中的methodB()方法");
    	}
    	
    	public void methodC(){
        
    		methodA(); // 没有传参，访问父类中的methodA()
    		methodA(20); // 传递int参数，访问子类中的methodA(int)
    		methodB(); // 直接访问，则永远访问到的都是子类中的methodB()，基类的无法访问到
    	}
    }

//Main.java
    public class Main{
        
        public static void main(String[] args) {
        
            Derived derived=new Derived();
            derived.methodC();
        }
    }

🍤 *运行结果：*

![在这里插入图片描述][997a8d32c75d4adf9e2a0e662a84e570.png]

说明：

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

**问题：** 如果子类中存在与父类中相同的成员时，那如何在子类中访问父类相同名称的成员呢？

## 5. super 关键字 ##

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

//Base.java
    public class Base {
        
        int a;
        int b;
        public void methodA(){
        
            System.out.println("Base中的methodA()");
        }
        public void methodB(){
        
            System.out.println("Base中的methodB()");
        }
    }

//Derived.java
    public class Derived extends Base{
        
        int a; // 与父类中成员变量同名且类型相同
        char b; // 与父类中成员变量同名但类型不同
    
        // 与父类中methodA()构成重载
        public void methodA(int a) {
        
            System.out.println("Derived中的method()方法");
        }
    
        // 与基类中methodB()构成重写
        public void methodB(){
        
            System.out.println("Derived中的methodB()方法");
        }
    
        public void methodC(){
        
            // 对于同名的成员变量，直接访问时，访问的都是子类的
            a = 100; // 等价于： this.a = 100;
            b = 101; // 等价于： this.b = 101;
            // 注意：this是当前对象的引用
    
            // 访问父类的成员变量时，需要借助super关键字
            // super是获取到子类对象中从基类继承下来的部分
            super.a = 200;
            super.b = 201;
    
            // 父类和子类中构成重载的方法，直接可以通过参数列表区分清访问父类还是子类方法
            methodA(); // 没有传参，访问父类中的methodA()
            methodA(20); // 传递int参数，访问子类中的methodA(int)
            // 如果在子类中要访问重写的基类方法，则需要借助super关键字
            methodB(); // 直接访问，则永远访问到的都是子类中的methodA()，基类的无法访问到
            super.methodB(); // 访问基类的methodB()
        }
    }

//Main.java
    public class Main{
        
        public static void main(String[] args) {
        
            Derived derived=new Derived();
            derived.methodC();//调用子类的methodC()
        }
    }

🍤 *运行结果：*

![在这里插入图片描述][513f2cdb474c40e09ee8bb009fbd4f9a.png]  
`🍩在子类方法中，如果想要明确访问父类中成员时，借助super关键字即可。`

注：

*  只能在非静态方法中使用
 *  在子类方法中，访问父类的成员变量和方法。

## 6. 子类构造方法 ##

> 父子父子，先有父再有子，即：子类对象构造时，需要先调用基类构造方法，然后执行子类的构造方法。

//Base.java
    public class Base {
        
    	public Base(){
        
    		System.out.println("Base()");
    	}
    }

//Derived.java
    public class Derived extends Base{
        
    	public Derived(){
        
    		// super(); // 注意子类构造方法中默认会调用基类的无参构造方法：super()
    		// 用户没有写时,编译器会自动添加，而且super()必须是子类构造方法中第一条语句
    		// 并且只能出现一次
    		System.out.println("Derived()");
    	}
    }

//Main.java
    public class Main {
        
    	public static void main(String[] args) {
        
    		Derived d = new Derived();
    	}
    }
    
    //打印结果：
    Base()
    Derived()

> 在子类构造方法中，并没有写任何关于基类构造的代码，但是在构造子类对象时，先执行基类的构造方法，然后执行子类的构造方法，因为：**子类对象中成员是有两部分组成的，基类继承下来的以及子类新增加的部分。**

> 父子父子，肯定是先有父再有子，所以**在构造子类对象时候，先要调用基类的构造方法，将从基类继承下来的成员构造完整，然后再调用子类自己的构造方法，将子类自己新增加的成员初始化完整。**

注：

*  若父类显式定义无参或者默认的构造方法，在子类构造方法第一行默认有隐含的super()调用，即调用基类构造方法
 *  如果父类构造方法是带有参数的，此时需要用户为子类显式定义构造方法，并在子类构造方法中选择合适的父类构造方法调用，否则编译失败。
 *  在子类构造方法中，super(…)调用父类构造时，必须是子类构造函数中第一条语句。
 *  super(…)只能在子类构造方法中出现一次，并且不能和this同时出现

## 7. super 和 this ##

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

相同点：

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

不同点：

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

![在这里插入图片描述][35dfb314150b41dd9f62f9f79a56315e.png]

## 8. 再谈初始化 ##

上一篇文章有讲过代码块，我们简单回顾一下几个重要的代码块：实例代码块和静态代码块。

我们看这段代码：

//Dog_.java
    class Dog_ {
        
        public String name;
        public int age;
        public Dog_(String name, int age) {
        
            this.name = name;
            this.age = age;
            System.out.println("构造方法执行");
        }
    
        {
        
            System.out.println("实例代码块执行");
        }
    
         static {
        
            System.out.println("静态代码块执行");
         }
    }

//Test.java
    public class Test {
        
        public static void main(String[] args) {
        
            Dog_ dog1 = new Dog_("Peter",3);
            System.out.println("============================");
            Dog_ dog2 = new Dog_("Jack",1);
        }
    }

🍤 *运行结果：*

![在这里插入图片描述][31c82a3e624f47c683a5d649519a3e85.png]

说明：

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

**继承关系上的执行顺序：**

//Person.java
    class Person {
        
        public String name;
        public int age;
        public Person(String name, int age) {
        
            this.name = name;
            this.age = age;
            System.out.println("Person：构造方法执行");
        }
        {
        
            System.out.println("Person：实例代码块执行");
        }
        static {
        
            System.out.println("Person：静态代码块执行");
        }
    }

//Student.java
    class Student extends Person{
        
        public Student(String name,int age) {
        
            super(name,age);
            System.out.println("Student：构造方法执行");
        }
        {
        
            System.out.println("Student：实例代码块执行");
        }
        static {
        
            System.out.println("Student：静态代码块执行");
        }
    }

//Test1.java
    public class Test1 {
        
        public static void main(String[] args) {
        
            Student student1 = new Student("张三",19);
            System.out.println("===========================");
            Student student2 = new Student("李四",20);
        }
    }

🍤 *运行结果：*

![在这里插入图片描述][f1ecc614a8a94857a92cfe2d4a659410.png]

> 通过分析执行结果，得出以下结论：
> 
> 1.  父类静态代码块优先于子类静态代码块执行，且是最早执行
> 2.  父类实例代码块和父类构造方法紧接着执行
> 3.  子类的实例代码块和子类构造方法紧接着再执行
> 4.  第二次实例化子类对象时，父类和子类的静态代码块都将不会再执行

## 9. protected 关键字 ##

在类和对象章节中，为了实现封装特性，Java中引入了访问限定符，主要限定：**类或者类中成员能否在类外或者其他包中被访问。**

<table> 
 <thead> 
  <tr> 
   <th>范围</th> 
   <th>private</th> 
   <th>default</th> 
   <th>protected</th> 
   <th>public</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>同一包的同一类</td> 
   <td>√</td> 
   <td>√</td> 
   <td>√</td> 
   <td>√</td> 
  </tr> 
  <tr> 
   <td>同一包的不同类</td> 
   <td></td> 
   <td>√</td> 
   <td>√</td> 
   <td>√</td> 
  </tr> 
  <tr> 
   <td>不同包中的子类</td> 
   <td></td> 
   <td></td> 
   <td>√</td> 
   <td>√</td> 
  </tr> 
  <tr> 
   <td>不同包中的非子类</td> 
   <td></td> 
   <td></td> 
   <td></td> 
   <td>√</td> 
  </tr> 
 </tbody> 
</table>

## 10. 继承方式 ##

Java中的几种继承方式：

![在这里插入图片描述][2efd209614d04ddeac7b33173ee3b6e3.png]  
![在这里插入图片描述][62a9e41c33514c14b957cdc909350a6d.png]

Java中不支持多继承

> 一般不要出现超过三层的继承关系。如果继承层次太多，就需要考虑对代码进行重构。  
> 如果想从语法上进行限制继承，就可以使用 final 关键字。

## 11. final 关键字 ##

final关键可以用来修饰变量、成员方法以及类。

1.  **修饰变量或字段，表示常量(即不能修改)**

final int a = 10;
    a = 20; // 编译出错

1.  **修饰类：表示此类不能被继承**

final public class Animal {
        
    	...
    }
    public class Bird extends Animal {
        
    	...
    }
    
    // 编译出错
    Error: 无法从最终com.bit.Animal进行继

`平时是用的 String 字符串类，就是用 final 修饰的，不能被继承`

1.  **修饰方法：表示该方法不能被重写**

## 12. 继承与组合 ##

> 和继承类似，组合也是一种表达类之间关系的方式，也是能够达到代码重用的效果。组合并没有涉及到特殊的语法(诸如 extends 这样的关键字)，仅仅是将一个类的实例作为另外一个类的字段。

**继承表示对象之间是is-a的关系**，比如：狗是动物，猫是动物。  
**组合表示对象之间是has-a的关系**，比如：汽车。

汽车和其轮胎、发动机、方向盘、车载系统等的关系就应该是**组合**，因为汽车是有这些部件组成的。

// 轮胎类
    class Tire{
        
    	// ...
    }
    
    // 发动机类
    class Engine{
        
    	// ...
    }
    
    // 车载系统类
    class VehicleSystem{
        
    	// ...
    }
    
    class Car{
        
    	private Tire tire; // 可以复用轮胎中的属性和方法
    	private Engine engine; // 可以复用发动机中的属性和方法
    	private VehicleSystem vs; // 可以复用车载系统中的属性和方法
    	// ...
    }
    
    // 奔驰是汽车
    class Benz extend Car{
        
    	// 将汽车中包含的：轮胎、发送机、车载系统全部继承下来
    }

`组合和继承都可以实现代码复用，应该使用继承还是组合，需要根据应用场景来选择，一般建议：能用组合尽量用 组合。`

--------------------

![在这里插入图片描述][069b705805bf4c58b9a536accb65b576.png]

[Link 1]: https://blog.csdn.net/iLoyo_
[Java]: http://t.csdn.cn/P9HTz
[b572dc771c554f919331d858ce47c5bb.gif_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/c8d0aa60a3774f2684740590a8aacf2c.gif
[977f968f1b74416ca30cf7bce7e9940f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/e0c3e3fa50294caa9617645a4f3c6dfc.png
[b901b6542c264c51885f6f54e7199da1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/5662597886a74c74b777730929ebd28b.png
[9ff89f5b90eb4ee6b821da576d25cd5f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/62c92e8035db47e58f70d9af05929f69.png
[dc48f71e9b514c0f9f38396e5e224181.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/d889de0fc1b84dcba8c8fb53f4800457.png
[9078f104949344b49ff89d53f1b7baca.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/fd16e6b64e94474cb8eef5d14de72b7a.png
[1cf6d19c2c7844eea381e92fe9ed1fb2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/46c4f104531f405f910e2359554e3744.png
[997a8d32c75d4adf9e2a0e662a84e570.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/e80f3a3a49a946f486e67f22bac8610d.png
[513f2cdb474c40e09ee8bb009fbd4f9a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/263ddf1975c3469ebdb39b907c98b945.png
[35dfb314150b41dd9f62f9f79a56315e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/25fae9f22863472f8ad7e81bfea4883a.png
[31c82a3e624f47c683a5d649519a3e85.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/1d7efe4a69c94a86931e16a2914ebdb9.png
[f1ecc614a8a94857a92cfe2d4a659410.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/0293b3084d0149b9a3c113d96e3e68b8.png
[2efd209614d04ddeac7b33173ee3b6e3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/b24a4b93d72b4d4b85cc4a3ec8b78915.png
[62a9e41c33514c14b957cdc909350a6d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/17edd61f6b164270afec9eac6db11e4d.png
[069b705805bf4c58b9a536accb65b576.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/9ad4e68e3bf745a3a72f4700a714d84d.png