Java-继承和组合
目录
1. 为什么需要继承
2 .继承概念
3. 继承语法
4. 父类成员访问
5. super关键字
6.子类构造方法
7.super和this
8.再看初始化
9. protected关键字
10. 继承方式
11. final关键字
12.继承和组合
1. 为什么需要继承
Java中使用类对现实世界中实体来进行描述，类经过实例化之后的产物对象，则可以用来表示现实中的实体，但是现实世界错综复杂，事物之间可能会存在一些关联。例如：动物狗和猫。
对他们进行描述，可有以下代码
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+"喵喵喵~~~"); } }
对于他们共有的代码块，我们是否能提取这些共性呢？面向对象思想中提出了继承的概念，专门用来进行共性抽取，实现代码复用。
2 .继承概念
继承(inheritance)机制：是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特 性的基础上进行扩展，增加新功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构， 体现了由简单到复杂的认知过程。继承主要解决的问题是：共性的抽取，实现代码复用。
如上文中的猫和狗我们就可以将他们的共性提取，用继承的思想实现。
上述图示中，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(); } }
注意：子类会将父类中的成员变量或者成员方法继承到子类中；子类继承父类之后，必须要新添加自己特有的成员，体现出与基类的不同，否则就没有必要继承。
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(); } }
总结：成员方法不同名时，在子类方法中或者通过子类对象访问方法时，则优先访问自己的，自己没有时再到父类中找，如果父类中也没有则报错。
（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();
}
}
总结：
- 通过子类对象访问父类与子类中不同名方法时，优先在子类中找，找到则访问，否则在父类中找，找到则访问，否则编译报错。
- 通过字类对象访问父类与子类同名方法时，如果父类和子类同名方法的参数列表不同(重载)，根据调用方法适传递的参数选择合适的方法访问，如果没有则报错。
如果子类中存在与父类中相同的成员时，那如何在子类中访问父类相同名称的成员呢？
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(); } }
在子类方法中，如果要访问父类中同名成员变量或与子类方法构成重写时，需借助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(); } }
在子类构造方法中，并没有写任何关于父类构造的代码，但是在构造子类对象时，先执行父类的构造方法，然后执行子类的构造方法，因为：子类对象中成员是有两部分组成的，父类继承下来的以及子类新增加的部分 。父子父子肯定是先有父再有子，所以在构造子类对象时候 ，先要调用父类的构造方法，将从父类继承下来的成员构造完整，然后再调用子类自己的构造方法，将子类自己新增加的成员初始化完整。
注意：
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);
}
}
执行顺序：执行静态代码块（只执行一次，在类加载阶段执行）--->执行实例代码块(有对象创建)--->构造方法。
继承关系上的执行顺序
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);
}
}
执行顺序：父类静态代码块--->子类静态代码块--->父类实例代码块--->父类构造方法--->子类实例代码块--->子类构造方法。
9. protected关键字
在类和对象章节中，为了实现封装特性，Java中引入了访问限定符，主要限定：类或者类中成员能否在类外或者其他包中被访问。
那父类中不同访问权限的成员，在子类中的可见性又是什么样子的呢？
//包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. 继承方式
在现实生活中，事物之间的关系是非常复杂，灵活多样，比如：
但在Java中支支持以下几种继承方式：
我们并不希望类之间的继承层次太复杂. 一般我们不希望出现超过三层的继承关系. 如果继承层次太多, 就需要考虑对代码进行重构了。如果想从语法上进行限制继承, 就可以使用 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的关系，比如：汽车。
汽车和其轮胎、发动机、方向盘、车载系统等的关系就应该是组合，因为汽车是有这些部件组成的。
// 轮胎类
class Tire{
// ...
}// 发动机类
class Engine{
// ...
}// 车载系统类
class VehicleSystem{
// ...
}
class Car{private Tire tire; // 可以复用轮胎中的属性和方法
private Engine engine; // 可以复用发动机中的属性和方法
private VehicleSystem vs; // 可以复用车载系统中的属性和方法//...
}
//奔驰是汽车
class Benz extend Car{
// 将汽车中包含的：轮胎、发送机、车载系统全部继承下来
}
组合和继承都可以实现代码复用，应该使用继承还是组合，需要根据应用场景来选择，一般建议能用组合尽量用组合。