java第九课——继承
目录
一：继承概念
二：继承语法
三：父类成员访问
3.1子类中访问父类的成员变量
1.子类和父类不存在同名成员变量
2.子类和父类成员变量同名
3.2子类中访问父类的成员方法
1. 成员方法名字不同
四：super关键字
五：子类构造方法
六：继承关系上代码块的执行顺序
七：protected关键字
八：继承方式
九：final关键字
9.1final关键字修饰变量
9.2 final关键字修饰类
9.3final关键字修饰方法
十：继承与组合
一：继承概念
继承(inheritance)机制：是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加新功能，这样产生新的类，称派生类。
继承主要解决的问题是：共性的抽取，实现代码复用。
例如创建两个类，类和类，它们有共同的属性，即名字、年龄和体重；各自又有独特的成员方法，即不同的叫声。我们可以抽象出一个动物类，抽取和共同的属性，再让类和类继承动物类。我们把动物类称为父类（或基类、超类），把两个子类称为子类（或派生类）。
二：继承语法
修饰符 class 子类 extends 父类 {
// ...
}
利用继承的语法，实现上述类和类对于动物类的继承，具体实现如下：
package Inheritance;
class Animal {
String name;
int age;
public void eat(){
System.out.println(name+"正在吃饭");
}
public void sleep(){
System.out.println(name+"正在睡觉");
}
}
class Cat extends Animal {
public void mew(){
System.out.println(name+"喵喵喵~~~");
}
}
class Dog extends Animal{
void bark(){
System.out.println(name+"汪汪汪~~~");
}
}
package Inheritance;
public class TestDemo {
public static void main(String[] args) {
Dog dog1 = new Dog();
dog1.name = "小乖";
dog1.sleep();
dog1.bark();
Cat cat1 = new Cat();
cat1.name="结婚";
cat1.sleep();
cat1.mew();
}
}运行结果如下：
注意：
1. 子类会将父类中的成员变量或者成员方法继承到子类中；
2. 子类继承父类之后，建议新添加自己特有的成员，体现出与基类的不同，否则就没有必要继承了。
三：父类成员访问
3.1子类中访问父类的成员变量
1.子类和父类不存在同名成员变量
package Test1;
class Base{
public int a = 1;
public int b = 2;
}
class Derived extends Base{
public int c = 3;
public int d = 4;
public void test(){
System.out.println(a);
System.out.println(b);
System.out.println(c);
System.out.println(d);
}
}
public class TestDemo {
public static void main(String[] args) {
Derived derived = new Derived();
derived.test();
}
}运行结果如下：
图解如下：
2.子类和父类成员变量同名
package Test1;
class Base2{
public int a = 1;
public int b = 2;
}
class Derived2 extends Base2{
public int a = 3;
public int b = 4;
public void test(){
System.out.println(a);//如果重名了，优先访问子类自己的
System.out.println(b);
System.out.println(super.a);
System.out.println(super.b);
}
}
public class Testdemo2 {
public static void main(String[] args) {
Derived2 derived2 = new Derived2();
derived2.test();
}
}
运行结果如下：
当子类和父类成员变量同名时，优先访问子类的成员变量；若要访问父类的成员变量，使用super关键字。图解如下：
总结一下，在子类方法中，或者通过子类对象访问成员时：
- 如果访问的成员变量子类中有，优先访问子类自己的成员变量；
- 如果访问的成员变量子类中无，则访问父类继承下来的，如果父类也没有定义，则编译报错；
- 如果访问的成员变量与父类中成员变量同名，则优先访问自己的，即：子类将父类同名成员隐藏了。
成员变量访问遵循就近原则，自己有优先自己的，如果没有则向父类中找。比如：你和你父亲各自有一款相同的手机，平时使用时你肯定优先用自己的，如果自己手机没电了，你才会考虑使用父亲的。
3.2子类中访问父类的成员方法
1. 成员方法名字不同
package Test1;
class Base2{
public void method(){
System.out.println("Base2::method()");
}
}
class Derived2 extends Base2{
public void son_method(){
System.out.println("Derived2::son_method()");
}
}
public class Testdemo2 {
public static void main(String[] args) {
Derived2 derived2 = new Derived2();
derived2.son_method();
derived2.method();
}
}
运行结果如下：
成员方法没有同名时，在子类方法中或者通过子类对象访问方法时，既可以访问子类自己的方法，也可以访问从父类中继承的方法。
package Test1;
class Base2{
public void methodA(){
System.out.println("Base2::methodA()");
}
public void methodB(){
System.out.println("Base2::methodB()");
}
}
class Derived2 extends Base2{
public void methodA(int a){
System.out.println("Derived2::methodA()");
}
public void methodB(){
System.out.println("Derived2::methodB()");
}
}
public class Testdemo2 {
public static void main(String[] args) {
Derived2 derived2 = new Derived2();
derived2.methodA(); // 没有传参，访问父类中的methodA()
derived2.methodA(20); // 传递int参数，访问子类中的methodA(int)
derived2.methodB(); // 直接访问，则永远访问到的都是子类中的methodB()，基类的无法访问到
}
}
运行结果如下：
【说明】
- 通过子类对象访问父类与子类中不同名方法时，优先在子类中找，找到则访问，否则在父类中找，找到则访问，否则编译报错；
- 通过派生类对象访问父类与子类同名方法时，如果父类和子类同名方法的参数列表不同(重载)，根据调用方法传递的参数选择合适的方法访问，如果没有则报错；
- 如果父类和子类同名方法的原型一致(重写)，则只能访问到子类的，父类的无法通过派生类对象直接访问到。
四：super关键字
因场景需要，子类和父类中可能会存在相同名称的成员，如果要在子类方法中访问父类同名成员时，该如何操作？直接访问是无法做到的，Java提供了super关键字，该关键字主要作用：在子类方法中访问父类的成员。
注意：super关键字只能在非静态方法中使用。
super关键字的三种用法：
- super.data; //访问父类中的成员变量
- super.func(); //访问父类中的成员方法
- super(); //在子类构造方法中显式调用父类的构造方法(具体请看下文)
五：子类构造方法
在继承关系中，当构造子类的时候，一定要先帮助父类进行构造。那么，什么时候创建父类，什么时候创建子类呢？此时就要提到构造方法。
当我们没有自己写构造方法时，编译器会默认提供一个不带参数的构造方法。示例如下：
package TEST;
class Animal2 {
public String name;
public int age;
/*
这是编译器默认提供的构造方法：
public Animal2(){
}
*/
public void eat() {
System.out.println(this.name+" 正在吃饭！");
}
}
class Cat2 extends Animal2 {
public String hair;
/*
这是编译器默认提供的构造方法：
public Cat2(){
super(); 调用父类的构造方法
}
*/
public void mew() {
System.out.println(this.name + " 正在叫！");//是不能访问了 不是没有被继承
}
}
public class TestDemo2 {
public static void main(String[] args) {
Cat2 cat2 = new Cat2();
cat2.name = "大傻春";
cat2.mew();
cat2.eat();
}
}运行结果如下：
图解如下：
编译器默认提供的构造方法
更合理的做法，当然是由程序员自己提供构造方法，具体示例如下：
package TEST;
class Animal {
public String name;
public int age;
public Animal(String name, int age) {
this.name = name;
this.age = age;
}
public void eat() {
System.out.println(this.name+" 正在吃饭！");
}
}
class Cat extends Animal {
public String hair;
public Cat(String name, int age, String hair) {
super(name, age);//显式调用父类的构造方法，来初始化 子类从父类继承过来的东西
this.hair = hair;
}
public void mew() {
System.out.println(this.name + " 正在叫！");
}
}
public class TestDemo {
public static void main(String[] args) {
Cat cat1 = new Cat("花姐",15,"white");
cat1.mew();
cat1.eat();
}
}
运行结果如下：
这就是super关键字的第三种用法，即在子类构造方法中显式调用父类的构造方法。
那么，super和this究竟有哪些区别与联系呢？总结如下：
【相同点】
1. 都是Java中的关键字；
2. 只能在类的非静态方法中使用，用来访问非静态成员方法和字段；
3. 在构造方法中调用时，必须是构造方法中的第一条语句，并且不能同时存在。（因为二者会争夺第一条语句的位置，一山不容二虎啊）。
【不同点】
1. this是当前对象的引用，当前对象即调用实例方法的对象，super相当于是子类对象中从父类继承下来部分成员的引用；
2. 在非静态成员方法中，this用来访问本类的方法和属性，super用来访问父类继承下来的方法和属性；
3. this是非静态成员方法的一个隐藏参数，super不是隐藏的参数；
4. 在构造方法中：this(...)用于调用本类构造方法，super(...)用于调用父类构造方法，两种调用不能同时在构造方法中出现（一山不容二虎）；
5. 子类构造方法中一定会存在super(...)的调用，用户没有写编译器也会增加，但是this(...)用户不写则没有。
6. 成员方法中直接访问本类成员时，编译之后会将this还原，即本类非静态成员都是通过this来访问的；在子类中如果通过super访问父类成员，编译之后在字节码层面super实际是不存在的（仅作了解即可）。
六：继承关系上代码块的执行顺序
package TEST;
class Person{
public String name;
public int age;
public Person(String name,int age){
this.name = name;
this.age = age;
System.out.println("Person：构造方法执行");
}
{
System.out.println("Person：实例代码块执行");
}
static{
System.out.println("Person：静态代码块执行");
}
}
class Student extends Person{
public Student(String name,int age){
super(name,age);
System.out.println("Student：构造方法执行");
}
{
System.out.println("Student：实例代码块执行");
}
static {
System.out.println("Student：静态代码块执行");
}
}
public class TestDemo3 {
public static void main(String[] args) {
Student s1 = new Student("江妹",19);
System.out.println("==============================");
Student s2 = new Student("苏秦",18);
}
}
运行结果如下：
通过分析执行结果，得出以下结论：
1、父类静态代码块优先于子类静态代码块执行，且是最早执行；
2、父类实例代码块和父类构造方法紧接着执行；
3、子类的实例代码块和子类构造方法紧接着再执行；
4、第二次实例化子类对象时，父类和子类的静态代码块都将不会再执行。
注意思考（以不变应万变）
七：protected关键字
在类和对象章节中，为了实现封装特性，Java中引入了访问限定符，主要限定：类或者类中成员能否在类外或者其他包中被访问。
访问限定符
今天我们来讨论，父类中不同访问权限的成员，在子类中的可见性是什么样子的？
在所有这些访问权限中，public的访问权限很大，default又只能在同一个包当中访问，还有一种情况是，我们不在一个包下，但我是你的子类，那么我也可以访问你到的属性，这是就需要用到protected关键字。所以protected也称作“继承权限”。以下是一个简单的实例：
八：继承方式
在现实生活中，事物之间的关系是非常复杂，灵活多样，比如：
在java中，只支持以下几种继承方式：
如果想从语法上限制继承，就要使用final关键字。
那么java怎么弥补无法进行多继承的缺陷呢？敬请期待“接口”部分。
九：final关键字
final关键字可以用来修饰变量、成员方法以及类。
9.1final关键字修饰变量
显然，final关键字修饰变量，表示常量。
9.2 final关键字修饰类
final修饰类，表示此类不能被继承。
9.3final关键字修饰方法
表示该方法不能被重写。
十：继承与组合
和继承类似, 组合也是一种表达类之间关系的方式, 也是能够达到代码重用的效果。组合并没有涉及到特殊的语法(诸如 extends 这样的关键字), 仅仅是将一个类的实例作为另外一个类的字段。
继承表示对象之间是is-a的关系，比如：是动物，是动物，是动物；
组合表示对象之间是has-a的关系，比如：汽车，有方向盘，有轮胎，有后视镜...
实例如下：
package TEST;
// 轮胎类
class Tire{
// ...
}
// 发动机类
class Engine{
// ...
}
// 车载系统类
class VehicleSystem{
// ...
}
class Car{
private Tire tire; // 可以复用轮胎中的属性和方法
private Engine engine; // 可以复用发动机中的属性和方法
private VehicleSystem vs; // 可以复用车载系统中的属性和方法
// ...
}
// 奔驰是汽车
class Benz extends Car{
// 将汽车中包含的：轮胎、发送机、车载系统全部继承下来
}在实际开发中，组合的应用更加广泛，同样更建议使用。
本课内容完！