面向对象编程三大特征之一 继承

继承

概述

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。

语句定义格式

class 子类名 extends 父类名{…}

要实现一个继承关系至少需要2个类
class Fu{}
class Zi extends Fu{}
这里的Zi我们称之为子类，派生类，
这里的Fu我们称之为父类，超类，基类

因此继承就是把多个类相同的内容提取到另外一个类中，然后使用关键字extends来实现继承。

继承的好处：

1、提高了代码的复用性 看一看父类
2、提高了代码的维护性 只需要修改父类的内容
3、让类与类之间产生了继承关系，为了后面多态做铺垫（要有继承才能有多态）

继承的坏处：

类的耦合性增强了

开发的原则：低耦合，高内聚
耦合：类与类之间的关系
内聚：类自己本身可以完成的事情

继承的特点

1、Java中的类class只支持单个继承，不允许多个继承
2、Java中的类支持多层继承（形成了一个继承体系）
例如：

class Son extends Father4,Mother4{}

错误，不允许这么做

代码示例：

class GrandFather{
    public void show(){
        System.out.println("我是爷爷");
    }
}

class Father4 extends GrandFather{
    public void show1(){
        System.out.println("我是老子");
    }
}

class Son4 extends Father4{
    public void show2(){
        System.out.println("我是儿子");
    }
}

public class ExtendsDemo3 {
    public static void main(String[] args) {
        Son4 son4 = new Son4();
        son4.show2(); //可以使用自己的方法
        son4.show1(); //也可以使用父亲的方法
        son4.show();  //也可以使用爷爷的方法
    }
}

注意事项

1、要想初始化子类，必须先初始化父类
举例：现有父亲，才能有儿子
2、子类只能继承父类的非私有的成员（成员变量和成员方法）
3、子类不能继承父类的构造方法，但是可以通过super关键字去访问父类的构造方法（因为要想初始化子类，必须先初始化父类，是通过构造方法进行初始化的）
4、不要为了部分的功能而去使用继承，当两个类满足语法什么是什么的时候，就可以使用继承了
比如：学生是人，老师是人；可乐是液体，水是液体…

继承与成员变量之间的关系

1、当子类中的成员变量与父类中的成员变量名字一样的时候
查找：（就近原则）
1）先在方法的局部范围内进行查找，如果找到就返回
2）如果在方法局部范围找不到，去本类中成员位置上查找，如果找到就返回
3）如果在中成员位置上找不到，去父类中成员位置上查找，如果找到就返回
4）如果在父类中成员位置上找不到，报错。
2、当子类中的成员变量与父类中的成员变量名字不一样的时候，使用什么变量名，就访问谁

this关键字与super关键字的使用区别

this代表的是调用该类的当前对象
super代表的是父类存储空间的标识（父类的引用，可以操作父类的成员）

1、访问成员变量
this.成员变量 访问的是本类中的成员变量
super.成员变量 访问的是父类中的成员变量
2、访问构造方法
this(…)
super(…)
3、访问成员方法
this.成员方法()
super.成员方法()
System.out.println(this.num); // 访问的是本类中的成员变量
System.out.println(super.num);// 访问的是父类中的成员变量

代码示例：

class Father7{
    int num = 10;
    public void show2(){
        System.out.println("这是父类中的show2方法");
    }
}
class Son7 extends Father7{
    int num = 20;
    public void show(){
        int num = 30;
        System.out.println(num);
        System.out.println(this.num); // 访问的是本类中的成员变量
        //如何访问到父类中的同名成员变量呢？
        System.out.println(super.num);// 访问的是父类中的成员变量
        show2();//public可以直接引用
        super.show2();//但是如果是private，都不可以用

        show3();
        this.show3();
    }

    public void show3(){
        System.out.println("这是Son7类中的show3方法");
    }
}

public class ExtendsDemo6 {
    public static void main(String[] args) {
        Son7 son7 = new Son7();
        son7.show();
    }
}

继承与构造方法的关系

1、要想初始化子类，必选先初始化父类
2、为什么？
因为子类会继承父类的数据，甚至可能会使用父类的数据
注意：每个子类的构造方法的第一句话默认是super().

当父类中没有无参构造方法的时候，怎么办？

1、使用super关键字带参数的形式访问父类的带参数构造方法
2、子类通过this关键字调用本类的其他构造方法，
注意，本类其他构造方法也必须可以访问父类拥有的构造方法，使用this关键字间接的调用父类的构造方法，无论在哪里调用父类的构造方法，只要最后保证在子类构造方法内容执行之前完成了父类的初始化就可以了
3、super(…)或者this(…)必须出现在第一条语句上
2、否则就会出现父类的数据进行了多次初始化
（重点）每个类只能初始化一次

继承与成员方法的关系

1、当子类的成员方法名与父类成员方法名不一样的时候，该调用谁就调用谁的
2、当子类的成员方法名与父类成员方法名一样的时候，怎么办呢？（就近原则）
1)先在本类中查找，如果有就调用，如果没有去父类中查找，
2)如果父类中有方法，就调用父类的
3)如果连父类中都没有要调用的方法名，报错，提示找不到方法。

子类的方法名能不能和父类方法的声明一样？
如果子类的方法声明与父类的方法声明一样，这样的现象叫做方法的重写。
重写现象是发生在继承的关系中。

重写与重载的区别

重写是发生在继承的关系的关系中，重载是发生在本类中。
重载overload是方法名一致，参数列表不一致就是重载。
重写override是方法名，参数列表，返回值都一样，实现不一样，叫方法的重写。

生活中重写的案例有：水杯–保温杯

方法重写的注意事项

1、父类中私有的方法不能被重写
2、子类重写父类的方法时候，访问权限不能更低
要么子类重写的方法访问权限比父类的访问权限要高或者一样
建议：以后子类重写父类的方法的时候，权限修饰符写一样就不会发生这样的问题。
3、父类中静态的方法不能被重写，也就是说不能被Override修饰，因为静态的是属于类本身的东西。

final关键字

有些时候，不想让子类覆盖重写父类中的方法或者功能，只能让子类去使用，java提供了一个关键字：
final:最终的意思。可以修饰类，成员变量，成员方法。

final的特点

final修饰局部变量
1、在方法内部，修饰基本数据类型的变量，变量值只能赋值一次，不能发生改变
2、final修饰引用数据类型的变量呢？
引用的地址值不可以发生改变，但是该对象的堆内存中的值是可以发生改变的。

代码示例：

class Student {
    int age = 10;
}
public class FinalDemo2 {
    public static void main(String[] args) {
        int x=100;
        x=300;
        System.out.println(x);

        final int y = 200;
//        y = 400; //无法为最终变量y分配值
        System.out.println(y);
        Student student = new Student();
        System.out.println(student.age);

        final Student s2 = new Student();
        System.out.println(s2.age);

        s2.age = 1000;//可以改值，但是地址值不可改变
        System.out.println(s2.age);
        System.out.println("==========================");
//        s2 = new Student(); //无法为最终变量s2分配值
    }
}