穿越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的
子类/派生类，继承之后，子类可以复用父类中成员，子类在实现时只需关心自己新增加的成员即可。
从继承概念中可以看出继承最大的作用就是：实现代码复用，还有就是来实现多态。
继承又分单继承、多层继承、不同类继承同一个类。

单继承：

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，则优先访问子类的a
   b=2;//父类和子类都有b，则优先访问子类的b
   c=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.在使用继承时，要注意成员变量的隐藏和方法的重写，以避免出现意外的行为。