穿越Java天下的继承奇旅：从基类到子类的富丽蜕变

1.为什么要继承

2.什么是继承以及继承的方式

3.继承的一些语法

4.父类成员的访问

5.关键字super

6.关键字protected

7.关键字final

8.继承与组合

一：为什么要继承
①代码重用：继承允许我们重用、扩展或修改父类的属性和方法，而无需重新编写雷同的代码。这有助于淘汰代码冗余，进步代码的可维护性和可扩展性。
②实现多态：多态是面向对象编程的三大特性之一（封装、继承、多态）。通过继承，我们可以界说具有共同接口（即方法）的多个类，这些类可以实行差别的操纵。这增长了步调的机动性和复用性。
③实现框架和库：在开辟大型应用步调时，通常会使用框架和库来提供根本功能。这些框架和库通过继承机制，允许开辟者界说自己的类来扩展或定制现有功能。
④表达类之间的“是一种”关系：继承可以用来表达类之间的“是一种”（is-a）关系。比方，假如有一个Animal类，我们可以创建一个Dog类继承自Animal类，由于狗是一种动物。这种关系使得类的计划更加直观和易于明确。
⑤提供模板和抽象基类：通过继承，我们可以创建模板类（也称为抽象基类或接口类），这些类只界说接口（即方法署名），而不实现它们。如许，子类就必须实现这些接口，从而欺压实现特定的举动。这有助于确保子类遵照划一的编程范式。
⑥促进模块化：继承有助于将步调分解成更小的、可管理的部分（即类）。每个类负责特定的功能，并通过继承与其他类交互。这有助于促进步调的模块化和封装性。
二：什么是继承以及继承的方式
继承是面向对象编程（OOP）中的一个核心概念，它提供了一种机制，允许我们基于已有的类来创建新的类，新创建的类被称为子类（或派生类），而原有的类被称为父类（或基类、超类）。

Dog和Cat都继承了Animal类，此中：Animal类称为父类/基类或超类，Dog和Cat可以称为Animal的
子类/派生类，继承之后，子类可以复用父类中成员，子类在实现时只需关心自己新增长的成员即可。
从继承概念中可以看出继承最大的作用就是：实今世码复用，尚有就是来实现多态。
继承又分单继承、多层继承、差别类继承同一个类。
单继承：

1. public class A{
2. ·······
3. }
4. public class B extends A{
5. ·······
6. }

复制代码

多层继承：

1. public class A{
2. ·······
3. }
4. public class B extends A{
5. ·······
6. }
7. public class C extends B{·······}

复制代码

差别类继承同一个类：

1. public class A{
2. ·······
3. }
4. public class B extends A{
5. ·······
6. }
7. public class C extends A{·······}

复制代码

注意不支持如图所示的多继承

1. public class A{
2. ·······
3. }
4. public class B {
5. ·······
6. }
7. public class C extends B/A{
8. ·······
9. }
10. **//java不支持多继承**

复制代码

三：继承的一些语法

1. class 基类名 {  
2.     // 基类的成员变量和成员函数  
3. }  
5. class 派生类名 extends 基类名 {  
6.     // 派生类的成员变量和成员函数  
7. }

复制代码

四：父类成员的访问
1、子类与父类不存在同名的成员变量

1. public class w{
2.         int a;
3.         int b;
4. }
5. public class m extends w{
6.         int c;
7. public void method(){
8.    a=1;//父类继承下来的
9.    b=2;//父类继承下来的
10.    c=3;//子类自己的
11.   }
12. }

复制代码

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

1. public class w{
2.         int a;
3.         int b;
4. }
5. public class m extends w{
6.         int a;
7.         int b;
8.         int c;
9. public void method(){
10.    a=1;//父类和子类都有a，则优先访问子类的a
11.    b=2;//父类和子类都有b，则优先访问子类的b
12.    c=3;//只有子类有，访问子类的
13.   }
14. }

复制代码

成员变量访问遵照就近原则，自己有优先自己的，假如没有则向父类中找。
3、子类中访问父类的成员方法名字差别

1. public class w {
2.         public void methodA(){
3.                 System.out.println("w中的methodA()");
4.         }
5. }
6. public class m extends w{
7.         public class methodB（）{
8.                         System.out.println("w中的methodB()");
9.                         }
10.                         public class methodC(){
11.                         methodB(); // 访问子类自己的methodB()
12.                         methodA(); // 访问父类继承的methodA()
13.                         // methodD(); // 编译失败，在整个继承体系中没有发现方法methodD()
14.                         }
15.                 }

复制代码

四、子类中访问父类的成员方法名字雷同

1. public class w{
2.         public void methodA(){
3.                 System.out.println("w中的methodA()");
4.         }
5.         public void methodB(){
6.                 System.out.println("w中的methodB()");
7.         }
8. }
9. public class m extends w{
10.         public void methodA(int a) {
11.                 System.out.println("m中的method(int)方法");
12.         }
13.         public void methodB(){
14.                 System.out.println("m中的methodB()方法");
15.         }
16.         public void methodC(){
17.                 methodA(); // 没有传参，访问父类中的methodA()
18.                 methodA(100); // 传递int参数，访问子类中的methodA(int)
19.                 methodB(); // 直接访问，则永远访问到的都是子类中的methodB()，基类的无法访问到
20.         }
21. }

复制代码

五：关键字super
假如子类中存在与父类中雷同的成员时,这是super就起到了作用。

1. public class w {
2.         int a;
3.         int b;
4.                 public void methodA(){
5.                         System.out.println("w中的methodA()");
6. }
7.                 public void methodB(){
8.                         System.out.println("w中的methodB()");
9.                 }
10. }
11. public class m extends w{
12.         int a; // 与父类中成员变量同名且类型相同
13.         char b; // 与父类中成员变量同名但类型不同
14.         // 与父类中methodA()构成重载
15.         public void methodA(int a) {
16.                 System.out.println("m中的method()方法");
17. }
18.         // 与基类中methodB()构成重写(即原型一致，重写后序详细介绍)
19.         public void methodB(){
20.                 System.out.println("m中的methodB()方法");
21.         }
22.         public void methodC(){
23.         // 对于同名的成员变量，直接访问时，访问的都是子类的
24.         a = 100; // 等价于： this.a = 100;
25.         b = 101; // 等价于： this.b = 101;
26.         // 注意：this是当前对象的引用
27.         // 访问父类的成员变量时，需要借助super关键字
28.         // super是获取到子类对象中从基类继承下来的部分
29.         super.a = 200;
30.         super.b = 201;
31.         // 父类和子类中构成重载的方法，直接可以通过参数列表区分清访问父类还是子类方法
32.         methodA(); // 没有传参，访问父类中的methodA()
33.         methodA(20); // 传递int参数，访问子类中的methodA(int)
34.         // 如果在子类中要访问重写的基类方法，则需要借助super关键字
35.         methodB(); // 直接访问，则永远访问到的都是子类中的methodA()，基类的无法访问到
36.         super.methodB(); // 访问基类的methodB()
37.         }
38. }

复制代码

六：关键字protected
protected用于修饰类的成员（包罗成员变量、成员方法和构造方法），它提供了一种比默认访问权限（包访问权限）更严酷的访问控制，但又比private访问权限更宽松。
七：关键字final
修饰变量：final修饰的变量一旦初始化后，其值就不能被改变。这通常用于界说常量。
修饰方法：final修饰的方法不能被子类覆盖（重写）。这有助于防止子类不测地改变父类的举动。
修饰类：final修饰的类不能被继承。这通常用于计划那些不须要被扩展的类，如String、Integer等。
final关键字在Java中的利益包罗确保数据完备性、进步代码安全性以及加强性能。由于final变量和方法在编译时就可以确定其稳固性，以是编译器可以对它们举行优化。
八：继承与组合
比方一辆汽车

汽车和其轮胎、发动机、方向盘、车载体系等的关系就应该是组合

1. // 轮胎类
2. class Tire{
3. // ...
4. }
5. // 发动机类
6. class Engine{
7. // ...
8. }
9. // 车载系统类
10. class VehicleSystem{
11. // ...
12. }
13. class Car{
14. private Tire tire; // 可以复用轮胎中的属性和方法
15. private Engine engine; // 可以复用发动机中的属性和方法
16. private VehicleSystem vs; // 可以复用车载系统中的属性和方法
17. // ...
18. }
19. // 奔驰是汽车
20. class Benz extend Car{
21. // 将汽车中包含的：轮胎、发送机、车载系统全部继承下来
22. }

复制代码

注意：
1.继承是一种“is-a”关系，即派生类是基类的一个特殊化版本。
2.继承不是万能的，过分使用继承会导致代码布局复杂、难以维护。在计划类时，应优先思量组合（composition）而不是继承（inheritance）。
3.在使用继承时，要注意成员变量的隐蔽和方法的重写，以制止出现不测的举动。