Java-继承和组合

雨点打透心脏的1/2处 2024-03-22 23:38 114阅读 0赞

**目录**

1. 为什么需要继承

2 .继承概念

3. 继承语法

4. 父类成员访问

5. super关键字

6.子类构造方法

7.super和this

8.再看初始化

9. protected关键字

10. 继承方式

11. final关键字

12.继承和组合

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

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

Java中使用类对现实世界中实体来进行描述，类经过实例化之后的产物对象，则可以用来表示现实中的实体，但是现实世界错综复杂，事物之间可能会存在一些关联。例如：动物狗和猫。  
![cd03e05845ec4fca9b4bf28bc221cf95.png][]![77c43723bb4443aba0d6272f666c28bc.png][]

对他们进行描述，可有以下代码

>     public class Dogs {//狗
>         String name;
>         int age;
>         float weight;
>         public void eat(){
>             System.out.println(this.name+"正在吃饭");
>         }
>         public  void sleep(){
>             System.out.println(this.name+"正在睡觉");
>         }
>         public void bark(){
>             System.out.println(this.name+"汪汪汪~~~");
>         }
>     }
> 
>     public class Cats {//猫
>         String name;
>         int age;
>         float weight;
>         public void eat(){
>             System.out.println(this.name+"正在吃饭");
>         }
>         public  void sleep(){
>             System.out.println(this.name+"正在睡觉");
>         }
>         public void mew(){
>             System.out.println(this.name+"喵喵喵~~~");
>         }
>     }

![a4d33f8cdc5844dc8f7a9d666328ebac.png][]

对于他们共有的代码块，我们是否能提取这些共性呢？**面向对象思想中提出了继承的概念，专门用来进行共性抽取，实现代码复用。**

## **2 .继承概念** ##

**继承(inheritance)机制**：**是面向对象程序设计使代码可以复用的最重要的手段**，它允许程序员**在保持原有类特 性的基础上进行扩展，增加新功能，这样产生新的类，称派生类**。继承呈现了**面向对象程序设计的层次结构**， 体现了由简单到复杂的认知过程。**继承主要解决的问题是：共性的抽取，实现代码复用**。

如上文中的猫和狗我们就可以将他们的共性提取，用继承的思想实现。

![3e21daeea30742ec95eb790eea5838a4.png][]

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

## **3. 继承语法** ##

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

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

对上述代码使用继承方式。

>     public class Animals {
>         String name;
>         int age;
>         float weight;
>         public void eat(){
>             System.out.println(this.name+"正在吃饭");
>         }
>         public  void sleep(){
>             System.out.println(this.name+"正在睡觉");
>         }
>     }
> 
>     public class  Dogs extends Animals{
>          public  void bark(){
>             System.out.println(this.name+"汪汪汪~~~");
>         }
>     }
> 
>     public class Cats extends Animals{
>         public void mew(){
>             System.out.println(this.name+"喵喵喵~~~");
>         }
>     }
> 
>     public class TextJicheng {
>         public static void main(String[] args) {
>             Dogs dog=new Dogs();
>             //Dogs中没有成员变量，继承父类中的
>             System.out.println(dog.name);
>             System.out.println(dog.age);
>             //Dogs中没有eat和sleep函数，继承父类中的
>             dog.eat();
>             dog.sleep();
>             dog.bark();
>         }
>     }

![706409f68e8f4f9ebcc34d81a3981156.png][]

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

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

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

**1.子类中访问父类的成员变量**

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

>     public class  Dogs extends Animals{
>          public  void bark(){
>             System.out.println(this.name+"汪汪汪~~~");
>         }
>         public void mathod(){
>              name="huahua";
>              age=5;
>              weight=5.2f;
>         }
>     }

（2）子类和父类成员变量同名

>     public class Cats extends Animals{
>         String name;
>         String color;
>         public void mew(){
>             System.out.println(this.name+"喵喵喵~~~");
>         }
>         public void mathod(){
>             name="赛虎";//同名
>             age=4;      //父类中有
>             color="黑白";//父类中没有
>         }
>     }

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

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

**2. 子类中访问父类的成员方法**  
（1）成员方法名不同

>     public class  Dogs extends Animals{
>          public  void bark(){
>             System.out.println(this.name+"汪汪汪~~~");
>         }
>         public void method(){
>              bark();    //访问子类的方法
>              eat();     //访问父类的方法
>         }
>          
> 
>         public static void main(String[] args) {
>          Dogs dog=new Dogs();
>          dog.method();
>         }
>     }

![8269c997eb36427b9266e8bb22f51dd4.png][]

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

（2）成员方法名相同

>     public class Cats extends Animals{
>         String name;
>         String color;
>         public void mew(){
>             System.out.println(this.name+"喵喵喵~~~");
>         }
>         
>         public void sleep(){
>             System.out.println(this.name+"睡醒了");
>         }
>         public static void main(String[] args) {
>             Cats cat=new Cats();
>             cat.sleep();
>         }
>     }

![dcfb9f66814548f5b5538c41e58590cd.png][]

总结：

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

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

## **5. super关键字** ##

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

>     public class Animals {
>         String name;
>         int age;
>         float weight;
>     
>         public void eat(){
>             System.out.println(this.name+"正在吃饭");
>         }
>         public  void sleep(){
>             System.out.println(this.name+"正在睡觉");
>         }
>         
>     }
> 
>     public class Cats extends Animals{
>         String name;
>         String color;
>         public void mew(){
>             System.out.println(this.name+"喵喵喵~~~");
>         }
>         public void mathod(){
>             name="赛虎";//同名成员变量，访问子类
>             age=4;      //同名，访问子类
>             color="黑白";//父类中没有
>             
> 
>             super.name="feifei";//访问父类成员变量
>             super.age=3;
>     
>             sleep();//方法重载
>             sleeo(5);
> 
>             System.out.println("=====");
>             eat();
>             super.eat();//通过super访问父类中同名方法
>         }
>             //方法重载，区分参数列表来访问方法
>         public void sleep(int a){
>             System.out.println(this.name+"睡醒了");
>         }
>         
> 
>             //与父类的eat（）构成重写
>          public  void eat(){
>              System.out.println(this.name+"不吃了");
>          }
> 
>     public static void main(String[] args) {
>             Cats cat=new Cats();
>             cat.mathod();
>         }
>     }

![42dc26e57ab44ccd973c09a5d6859ecc.png][]

![d18cc1efd4c64b8385fcf46741f62e3c.png][]

在子类方法中，如果要访问父类中同名成员变量或与子类方法构成重写时，需借助super关键字，super只能在非静态方法中使用。

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

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

>     public class Animals {
>         String name;
>         int age;
>         float weight;
>         public void eat(){
>             System.out.println(this.name+"正在吃饭");
>         }
>         public  void sleep(){
>             System.out.println(this.name+"正在睡觉");
>         }
>         public Animals(){        //构造方法
>             System.out.println("Animals()");
>         }
>     }
> 
>     public class  Dogs extends Animals{
>          public  void bark(){
>             System.out.println(this.name+"汪汪汪~~~");
>         }
>         public void mathod(){
>              name="huahua";
>              age=5;
>              weight=5.2f;
>         }
>         public void method(){
>              bark();    //访问子类的方法
>              eat();     //访问父类的方法
>         }
>         public Dogs(){        //构造方法
>             System.out.println("Dogs()");
>         }
>     
>         public static void main(String[] args) {
>              Dogs dog=new Dogs();
>         }
>     }

![23747ecb78af4d16a8b0a51102945409.png][]

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

注意：

1. 若父类显式定义无参或者默认的构造方法，在子类构造方法第一行默认有隐含的super()调用，即调用基类构造方法。

2. 如果父类构造方法是带有参数的，此时需要用户为子类显式定义构造方法，并在子类构造方法中选择合适的父类构造方法调用，否则编译失败。

3. 在子类构造方法中，super(...)调用父类构造时，必须是子类构造函数中第一条语句。

4. super(...)只能在子类构造方法中出现一次，并且不能和this同时出现。

## **7.super和this** ##

super和this都可以在成员方法中用来访问：成员变量和调用其他成员函数，都可以作为构造方法的第一条语句，那他们之间有什么区别呢？  
相同点：都是Java中的**关键字**；只能在类的非静态方法中使用，用来**访问非静态成员方法和字段**；**在构造方法中调用时，必须是构造方法中的第一条语句，并且不能同时存在**。

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

## **8.再看初始化** ##

还记得之前讲过的代码块吗？简单回顾一下几个重要的代码块：实例代码块和静态代码块。在没有继承关系时的执行顺序。

>     class Persons {
>         public String name;
>         public int age;
>         public Persons(String name, int age) {
>             this.name = name;
>             this.age = age;
>             System.out.println("构造方法执行");
>         }
>         {
>             System.out.println("实例代码块执行");
>         }
>         static {
>             System.out.println("静态代码块执行");
>         }
>     }
>     public class Person {
>             public static void main(String[] args) {
>                 Persons person1 = new Persons("zhangsan",10);
>                 System.out.println("=======");
>                 Persons person2 = new Persons("lisi",15);
>             }
>     }

![4fa09e7a6ea74b509ee9721d263edca8.png][]

![57cfdc6a069d4088aac4598912240016.png][]

执行顺序：执行静态代码块（只执行一次，在类加载阶段执行）--->执行实例代码块(有对象创建)--->构造方法。

继承关系上的执行顺序

>     class Persons {
>         public String name;
>         public int age;
>         public Persons(String name, int age) {
>             this.name = name;
>             this.age = age;
>             System.out.println("执行构造方法");
>         }
>         {
>             System.out.println("执行实例代码块");
>         }
>         static {
>             System.out.println("执行静态代码块");
>         }
>     }
>     class Student extends Persons{
>             public Student(String name,int age){
>                 super(name,age);
>                 System.out.println("执行构造方法");
>             }
>         {
>             System.out.println("执行实例代码块");
>         }
>         static {
>             System.out.println("执行静态代码块");
>         }
>     }
>     public class Person {
>             public static void main(String[] args) {
>                Student person1 = new Student("zhangsan",10);
>                 System.out.println("=======");
>                 Student person2 = new Student("lisi",15);
>             }
>     }

![b369b1ff83a7413597857d029f38ff1e.png][]

![03092cc74cfc42899d548eca7f70669a.png][]

![407ae866a4f24a7cbc058f524c4a5c10.png][]

执行顺序：父类静态代码块--->子类静态代码块--->父类实例代码块--->父类构造方法--->子类实例代码块--->子类构造方法。

## **9. protected关键字** ##

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

那父类中不同访问权限的成员，在子类中的可见性又是什么样子的呢？

> //包1中
> 
>     public class B {
>         private int a;
>         protected int b;
>         public int c;
>         int d;
>     }
> 
> //包1中的子类
> 
>     public class D extends B{
>         public void method(){
>             //super.a=10; //编译报错，父类B中private成员在相同包子类中不可见
>             super.b=20;  //父类B中protected成员在相同包子类中可以访问
>             super.c=10;  //父类B中public成员在相同包子类中可以访问
>             super.d=2;  //父类B中defult成员在相同包子类中可以访问
>         }
>     }
> 
> //包2中的子类
> 
>     public class C extends B {
>         public void  method(){
>             //super.a;      //编译报错，父类B中private修饰的成员在不同包子类中不可见
>             super.b=10;     //父类protected修饰的成员在不同包中可见
>             super.c=50;     //父类public修饰的成员在不同包中可见
>             //super.d=100;  //编译报错，父类defult修饰的成员在不同包中不可见
>         }
>     }
> 
> //包2中的其他类
> 
>     public class TextC {
>        public static void main(String[] args) {
>            C c=new C();
>            c.method();
>         //System.out.println(c.a);//编译报错父类中private修饰的成员在不同包其他类中不可见
>        //System.out.println(c.b);//编译报错父类中protected修饰的成员在不同包其他类中不可见
>           System.out.println(c.c);//父类中public修饰的成员在不同包其他类中可以访问
>         //System.out.println(c.d);// 编译报错，父类中defult修饰的成员在不同包其他类中不可见
>         }
>     }

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

我们希望类要尽量做到 "封装", 即**隐藏内部实现细节, 只暴露出 必要 的信息给类的调用者**，因此我们在使用的时候应该**尽可能的使用 比较严格 的访问权限. 例如如果一个方法能用 private, 就尽量不要用 public**。

## **10. 继承方式** ##

在现实生活中，事物之间的关系是非常复杂，灵活多样，比如：

![9f5b4e821eb545299661ee91ba004586.png][]

但在Java中支支持以下几种继承方式：

![0e64f7e0bcad4b459b0afbf8b061b2fb.png][]

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

## **11. final关键字** ##

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

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

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

（2）**修饰类：表示此类不能被继承**

> final public class Animal \{  
> ...  
> \}  
> public class Bird extends Animal \{  
> ...  
> \} // 编译报错，A不能再被继承

（3）**修饰方法：表示该方法不能被重写(后序介绍)**

## **12.继承和组合** ##

和继承类似, **组合也是一种表达类之间关系的方式**, **也是能够达到代码重用的效果**。组合并没有涉及到特殊的语法(诸如 extends 这样的关键字), **仅仅是将一个类的实例作为另外一个类的字段**。**继承表示对象之间是is-a的关系**，比如：狗是动物，猫是动物，**组合表示对象之间是has-a的关系**，比如：汽车。

![21932ec191e844b79fb92cffdb85368f.png][]![汽车结构图\_宝来论坛\_太平洋汽车网论坛][R-C.8c6e2a45713566b864249032fcfc1155_rik_XTnV6zVBywQd4A_riu_http_3A_2F_2Fimg.pconline.com.cn_2Fimages_2Fbbs4_2F20085_2F5_2F1209957560879.gif_ehk_W2vvbOGoTmfIRwqAYM5eYJJEi5ItKI_2FPxl9eXheo8_2BY_3D_risl_pid_ImgRaw_r_0]  
汽车和其轮胎、发动机、方向盘、车载系统等的关系就应该是组合，因为汽车是有这些部件组成的。

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

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

[cd03e05845ec4fca9b4bf28bc221cf95.png]: https://img-blog.csdnimg.cn/cd03e05845ec4fca9b4bf28bc221cf95.png
[77c43723bb4443aba0d6272f666c28bc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/1ad0ab34a09a4646a7bbccc84df66565.png
[a4d33f8cdc5844dc8f7a9d666328ebac.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/55011cbd6b5f4b2798ae746653d2d80b.png
[3e21daeea30742ec95eb790eea5838a4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/43b99d44b328457088415776a17cc755.png
[706409f68e8f4f9ebcc34d81a3981156.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/a3af7dba10ac4e58a7cec35aae0277b4.png
[8269c997eb36427b9266e8bb22f51dd4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/cee26170d9fb45038c5b805ea5430de2.png
[dcfb9f66814548f5b5538c41e58590cd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/b5229d873b244fde96d2da5da69f5a48.png
[42dc26e57ab44ccd973c09a5d6859ecc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/0b97aff541cd49d7b70dcbcf90da5560.png
[d18cc1efd4c64b8385fcf46741f62e3c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/dbd9249812374745a766b674d27cee0d.png
[23747ecb78af4d16a8b0a51102945409.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/00dc4781430f4438ac8c0806b9d59f06.png
[4fa09e7a6ea74b509ee9721d263edca8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/2434e4cd911f4d578535f87896af1923.png
[57cfdc6a069d4088aac4598912240016.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/7a2848ca00ac4566a517f661c85b9b31.png
[b369b1ff83a7413597857d029f38ff1e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/12f0c48300cd4ba28120973dd0cc48b0.png
[03092cc74cfc42899d548eca7f70669a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/c78d8eaf622a4551bb037d4d584b8602.png
[407ae866a4f24a7cbc058f524c4a5c10.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/cd0d868c92e64cf9890592b384716dcc.png
[a6b59b6e62d144f0bf07e48a20adf9b2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/5f2cc348f79f4417b7e64f374ace6f77.png
[9f5b4e821eb545299661ee91ba004586.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/41d1357fe9f24445a4b9654c89fb83b7.png
[0e64f7e0bcad4b459b0afbf8b061b2fb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/8b77a522d6994b1197cd6adbfc62ac46.png
[21932ec191e844b79fb92cffdb85368f.png]: https://img-blog.csdnimg.cn/21932ec191e844b79fb92cffdb85368f.png
[R-C.8c6e2a45713566b864249032fcfc1155_rik_XTnV6zVBywQd4A_riu_http_3A_2F_2Fimg.pconline.com.cn_2Fimages_2Fbbs4_2F20085_2F5_2F1209957560879.gif_ehk_W2vvbOGoTmfIRwqAYM5eYJJEi5ItKI_2FPxl9eXheo8_2BY_3D_risl_pid_ImgRaw_r_0]: https://ts1.cn.mm.bing.net/th/id/R-C.8c6e2a45713566b864249032fcfc1155?rik=XTnV6zVBywQd4A&riu=http%3A%2F%2Fimg.pconline.com.cn%2Fimages%2Fbbs4%2F20085%2F5%2F1209957560879.gif&ehk=W2vvbOGoTmfIRwqAYM5eYJJEi5ItKI%2FPxl9eXheo8%2BY%3D&risl=&pid=ImgRaw&r=0