1.为什么要继承

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

3.继承的一些语法

4.父类成员的访问

5.关键字super

6.关键字protected

7.关键字final

8.继承与组合

一：为什么要继承

①代码重用：继承允许我们重用、扩展或修改父类的属性和方法，而无需重新编写相同的代码。这有助于减少代码冗余，提高代码的可维护性和可扩展性。
②实现多态：多态是面向对象编程的三大特性之一（封装、继承、多态）。通过继承，我们可以定义具有共同接口（即方法）的多个类，这些类可以执行不同的操作。这增加了程序的灵活性和复用性。
③实现框架和库：在开发大型应用程序时，通常会使用框架和库来提供基础功能。这些框架和库通过继承机制，允许开发者定义自己的类来扩展或定制现有功能。
④表达类之间的“是一种”关系：继承可以用来表达类之间的“是一种”（is-a）关系。例如，如果有一个Animal类，我们可以创建一个Dog类继承自Animal类，因为狗是一种动物。这种关系使得类的设计更加直观和易于理解。
⑤提供模板和抽象基类：通过继承，我们可以创建模板类（也称为抽象基类或接口类），这些类只定义接口（即方法签名），而不实现它们。这样，子类就必须实现这些接口，从而强制实现特定的行为。这有助于确保子类遵循一致的编程范式。
⑥促进模块化：继承有助于将程序分解成更小的、可管理的部分（即类）。每个类负责特定的功能，并通过继承与其他类交互。这有助于促进程序的模块化和封装性。

二：什么是继承以及继承的方式

继承是面向对象编程（OOP）中的一个核心概念，它提供了一种机制，允许我们基于已有的类来创建新的类，新创建的类被称为子类（或派生类），而原有的类被称为父类（或基类、超类）。

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

单继承：

public class A{
·······
}
public class B extends A{
·······
}

多层继承：

public class A{
·······
}
public class B extends A{
·······
}
public class C extends B{
·······
}

不同类继承同一个类：

public class A{
·······
}
public class B extends A{
·······
}
public class C extends A{
·······
}

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

public class A{
·······
}
public class B {
·······
}
public class C extends B/A{
·······
}
**//java不支持多继承**

三：继承的一些语法

class 基类名 {  // 基类的成员变量和成员函数  
}  class 派生类名 extends 基类名 {  // 派生类的成员变量和成员函数  
}

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

public class w{int a;int b;
}
public class m extends w{int c;
public void method(){a=1;//父类继承下来的b=2;//父类继承下来的c=3;//子类自己的}
} 

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

public class w{int a;int b;
}
public class m extends w{int a;int b;int c;
public void method(){a=1;//父类和子类都有a，则优先访问子类的ab=2;//父类和子类都有b，则优先访问子类的bc=3;//只有子类有，访问子类的}
} 

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

3、子类中访问父类的成员方法名字不同

public class w {public void methodA(){System.out.println("w中的methodA()");}
}
public class m extends w{public class methodB（）{System.out.println("w中的methodB()");}public class methodC(){methodB(); // 访问子类自己的methodB()methodA(); // 访问父类继承的methodA()// methodD(); // 编译失败，在整个继承体系中没有发现方法methodD()}}

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

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

五：关键字super

如果子类中存在与父类中相同的成员时,这是super就起到了作用。

public class w {int a;int b;public void methodA(){System.out.println("w中的methodA()");
}public void methodB(){System.out.println("w中的methodB()");}
}
public class m extends w{int a; // 与父类中成员变量同名且类型相同char b; // 与父类中成员变量同名但类型不同// 与父类中methodA()构成重载public void methodA(int a) {System.out.println("m中的method()方法");
}// 与基类中methodB()构成重写(即原型一致，重写后序详细介绍)public void methodB(){System.out.println("m中的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()}
}

六：关键字protected
protected用于修饰类的成员（包括成员变量、成员方法和构造方法），它提供了一种比默认访问权限（包访问权限）更严格的访问控制，但又比private访问权限更宽松。
七：关键字final
修饰变量：final修饰的变量一旦初始化后，其值就不能被改变。这通常用于定义常量。
修饰方法：final修饰的方法不能被子类覆盖（重写）。这有助于防止子类意外地改变父类的行为。
修饰类：final修饰的类不能被继承。这通常用于设计那些不需要被扩展的类，如String、Integer等。
final关键字在Java中的好处包括确保数据完整性、提高代码安全性以及增强性能。因为final变量和方法在编译时就可以确定其不变性，所以编译器可以对它们进行优化。
八：继承与组合
例如一辆汽车

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

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

注意：
1.继承是一种“is-a”关系，即派生类是基类的一个特殊化版本。
2.继承不是万能的，过度使用继承会导致代码结构复杂、难以维护。在设计类时，应优先考虑组合（composition）而不是继承（inheritance）。
3.在使用继承时，要注意成员变量的隐藏和方法的重写，以避免出现意外的行为。