面向对象（四）——继承多态

一、继承
1.继承概述：
把多个类中相同的内容给提取出来定义到一个类中
如何实现继承呢？
java提供了一个关键字:extends
格式：
class 子类名 extends 父类名 {}
继承的好处：
A:提高了代码的复用性
B:提高了代码的维护性
C:让类与类之间产生关系,是多态的前提。

    类与类产生了关系，其实也是继承的一个弊端：        类的耦合性增强了。    开发的原则：低耦合，高内聚    耦合：类与类的关系    内聚：就是自己完成某件事情的能力

class Person{        public void eat(){        System.out.println("吃饭");    }    public void sleep(){        System.out.println("睡觉");    }}class Student extends Person{}class Teacher extends Person{}class ExtendsDemo{    public static void main(String[] args){        Student s = new Student();        s.eat();        s.sleep();        System.out.println("-------");        Teacher t = new Teacher();        t.eat();        t.sleep();    }}

2.继承的特点：
A:java只支持单继承，不支持多继承。
有些语言是支持多继承的，格式extends 类1，类2…
B:java支持多层继承（继承体系）

/*class Father{}class Mother{}class Son extends Father,Mother{}//错误的*/class GrandFather{    public void show(){        System.out.println("我是爷爷");    }}class Father extends GrandFather{    public void method(){        System.out.println("我是老子");    }}class Son extends Father{}class ExtendsDemo{    public static void main(String[] args){        Son s = new Son();        s.method();//使用父亲的        s.show();//使用爷爷的    }}

3.继承的注意事项
A:子类只能继承父类所有非私有的成员（成员方法和成员变量）
B:子类不能继承父类的构造方法，但是可以通过super（后面讲）关键字去访问父类的构造方法
C:不要为了部分功能去使用继承

class A{            public void show1(){}            public void show2(){}        }        class B{            public void show2(){}            public void show3(){}        }        我们发现B类中出现了和A类中一样的show2()方法，        所以，我们就用继承来体现。        class B extends A{            public void show3(){}        }        这样其实不好，因为这样你不但有了show2(),还多了show1(),        有可能show1()并不是你想要的。        那么，我们什么时候考虑使用继承呢？            继承其实体现的是一种关系:"is a".                Person                    Student                    Teacher                水果                    苹果                    香蕉                    橘子            采用假设法。                如果有两个类A,B，只要他们符合A是B的一种，或者                B是A的一种，就可以考虑使用继承。

class Father{    private int num = 10;    public int num2 = 20;    //私有方法，子类不能继承    private void method(){        System.out.println(num);        System.out.println(num2);    }    public void show(){        System.out.println(num);        System.out.println(num2);    }}class Son extends Father{    public void function(){        //num可以在Father中访问private        //子类不能继承父类的私有成员变量        //System.out.println(num);        System.out.println(num2);    }}class ExtendsDemo{    public static void main(String[] args){        //创建对象        Son s = new Son();        //s.method();//子类不能继承父亲的私有方法        s.show();    }}

4.继承中成员变量的关系
类的组成：
成员变量
构造方法
成员方法
而现在我们又讲解了继承，所以，我们就应该来考虑一下，类的
组成部分的各自关系。

    继承中成员变量的关系：        A:子类中的成员变量和父类中的成员变量名称不一样，这个太简单。        B:子类中的成员变量和父类中的成员变量名称一样,结果呢？            在子类方法中访问一个变量的查找顺序：                a:在子类方法的局部范围找，有就使用                b:在子类的成员范围找，有就使用                c:在父类的成员范围找，有就使用                d:如果还找不到，就报错            简单记：就近原则

class Father{    public int num = 20;}class Son extends Father{    public int num2 = 10;    public int num = 30;    public void show(){        System.out.println(num);        System.out.println(num2);    }}class ExtendsDemo{    public static void main(String[] args){        //创建对象        Son s = new Son();        s.show();    }}

5.this和super的区别和应用
问题是：我不仅仅要输出局部范围的num,还要输出本类成员范围的num。怎么办？
我还想要输出父类成员范围的num，怎么办呢？
如果有一个东西和this相似，但是可以直接访问父类的数据就好了
这个关键字是：super

this和super的区别：    分别是什么        this：代表本类对象的引用        super：代表父类存储空间的标识（可以理解为父类引用，可以操作父类的成员）    怎么用呢？        A:调用成员变量            this：成员变量  调用本类的成员变量            super：成员变量  调用父类的成员变量        B:调用构造方法            this(..) 调用本类的构造方法            super(..)  调用父类的构造方法        C:调用成员方法        this.成员方法  调用本类的成员方法        super.成员方法 调用父类的成员方法

class Father{    public int num = 10;}class Son extends Father{    public int num = 20;    public void show(){        int num = 30;        System.out.println(num);        System.out.println(this.num);        System.out.println(super.num);    }}class ExtendsDemo{    public static void main(String[] args){        Son s = new Son();        s.show();    }}

6.继承中构造方法的关系
A:子类中所有的构造方法默认都会访问父类中空参数的构造方法
为什么呢？
因为子类会继承父类中的数据，可能还会使用父类的数据
所以，子类初始化之前，一定要先完成父类数据的初始化。

        注意：子类每一个构造方法的第一条语句默认都是：super()（调用父类的无参构造）

class Father{    public Father(){        System.out.println("这是Father的无参构造方法");    }        public Father(String name){        System.out.println("这是Father的带参数构造方法");    }}class Son extends Father{    public Son(){        System.out.println("这是son的无参构造方法");    }    public Son(String name){        System.out.println("这是son的带参数构造方法");    }}class ExtendsDemo{    public static void main(String[] args){        //创建对象        Son s = new Son();        /*            得到的结果是：                这是Father的无参构造方法                这是son的无参构造方法        */        System.out.println("-------");        Son s2 = new Son("林青霞");        /*            得到的结果是：                这是Father的无参构造方法                这是son的带参数构造方法        子类中所有的构造方法默认都会访问父类中空参数的构造方法        */    }}

7.继承中构造方法的注意事项
如果父类没有无参构造方法，那么子类的构造方法会出现什么现象呢？如何解决呢？

    报错。    如何解决呢？    A:在父类中加一个无参构造方法    B:通过使用super关键字去显示的调用父类的带参构造方法super(参数名1，参数名2...)    C：子类通过this去调用本类的其他构造方法        子类中一定要有一个去访问了父类的构造方法，否则父类数据就没有初始化    注意事项：        this(..)或者super(..)必须出现在第一条语句上。        如果不是放在第一条语句上，就可能对父类的数据进行了多次初始化，所以必须放在第一条语句上。

class Father{    public Father(String name){        System.out.println("Father的带参构造方法");    }}class Son extends Father{    public Son(){        System.out.println("Son的无参构造方法");    }    public Son(String name){        System.out.println("Son的带参构造方法");    }}class ExtendsDemo{    public static void main(String[] args){    }}

8.面试题
题1：

/*    看程序写结果：        A:成员变量  就近原则        B:this和super的问题            this访问访问本类的成员            super访问父类的成员        C:子类构造方法执行前默认先执行父类的无参构造方法。        D:一个类的初始化过程            成员变量进行初始化                默认初始化                显示初始化                构造方法初始化*/class Fu{    public int num = 10;    public Fu(){        System.out.println("fu");    }}class Zi extends Fu{    public int num = 20;    public Zi(){        System.out.println("zi");    }    public void show(){        int num = 30;        System.out.println(num);        System.out.println(this.num);        System.out.println(super.num);    }}class ExtendsTest{    public static void main(String[] args){        Zi z = new Zi();        z.show();    }}/*    程序的结果是：    fu    zi    30    20    10*/

题2：

/*    看程序写结果：        A:一个类的静态代码块，构造代码块，构造方法的执行流程            静态代码块>构造代码块>构造方法        B:静态的内容是随着类的加载而加载            静态代码块的内容会优先执行        C:子类初始化之前先会进行父类的初始化        D:*/class Fu{    static {        System.out.println("静态代码块");    }    {        System.out.println("构造代码块Fu");    }    public Fu(){        System.out.println("构造方法Fu");    }}class Zi extends Fu{    static{        System.out.println("静态代码块Zi");    }    {        System.out.println("构造代码块zi");    }    public Zi(){        System.out.println("构造方法zi");    }}class ExtendsTest2{    public static void main(String[] args){        Zi z = new Zi();    }}/*    程序的结果：        静态代码块fu        静态代码块zi        构造代码块fu        构造方法fu        构造代码块zi        构造方法zi*/

题3：

/*    看程序写结果    A:成员变量的问题        int x = 10；//成员变量是基本类型        Student s = new Student();//成员变量是引用类型    B:一个类的初始化过程        成员变量的初始化            默认初始化            显示初始化            构造方法初始化    C:子父类的初始化(分层初始化)        先进行父类初始化，然后进行子类初始化。    问题：        虽然子类中构造方法默认有一个super()        初始化的时候，不是按照那个顺序进行的。        而是按照分层初始化进行的。        它仅仅表示要先初始化父类数据，再初始化子类数据。    */class X{    Y b = new Y();    X(){        System.out.print("x");    }}class Y(){    Y(){        System.out.print("Y");    }}public class Z extends X{    Y y = new Y();    Z(){        //super()             System.out.print("Z");    }    public static void main(String[] args){        new Z();    }}/*    程序的结果;        YxYz        */

9、继承中成员方法的关系
A:子类中的方法和父类中的方法声明不一样
B:子类中的方法和父类中的方法声明一样
通过子类调用方法：
a:先找子类中，看有没有这个方法，有就使用
b：再看父类中，有没有这个方法，有就使用
c:如果没有就报错

class Father{    public void show(){        System.out.println("show father");    }}class Son extends Father{    public void method(){        System.out.println("method son");    }    public void show(){        System.out.println("show son");    }}class ExtendsDemo{    public static void main(String[] args){        //常见对象        Son s = new Son();        s.show();        s.method();    }}

10、方法重写的应用
方法重写：子类中出现了和父类中方法声明一模一样的方法。

方法重载：    本类中出现的方法名一样，参数列表不同的方法。与返回值无关子类对象调用方法时候：    先找子类本身，再找父类。方法重写的应用：    当子类需要父类的功能，而功能主题子类有自己特有内容时，可以重写父类中的方法    这样，即沿袭了父类的功能，又定义了子类特有的内容。案例：    A:定义一个手机类    B:通过研究，发明了一个新手机，这个手机的作用是在打完电话后，可以听天气预报。        按照我们基本设计，我们把代码写出来了        但是呢？我们又发现新手机应该是手机，所以，它应该继承自手机。    其实这个时候的设计，并不是最好的。    因为手机打电话功能，是手机本身就具备的最基本的功能    所以，我的新手机是不用再提供这个功能的    但是，这个时候，打电话功能就没有了，这个不好    最终，还是加上这个功能，由于它继承了手机类，所以，我们就直接使用父类的功能即可    那么，如何使用父类的功能呢？通过super关键字调用。

class Phone{    public void call(String name){        System.out.println("给"+name+"打电话");    }}class NewPhone extends Phone{    public void call(String name){        //System.out.println("给"+name+"打电话");        super.call(name);        System.out.println("可以听天气预报了");    }}class ExtendsDemo{    public static void main(String[] args){        NewPhone np = new NewPhone();        np.call("梅西");    }}

11.方法重写的注意事项

class Father{    //private void show(){}    /*    public void show(){        System.out.println("show father");    }    */    void show(){        System.out.println("show father");    }    /*    //被覆盖的方法为static    public static void  method(){}    */    public void method(){}}class Son extends Father{    //private void show(){}    public  void show(){        System.out.println("show son");    }    //覆盖的方法为 static    public static void method(){}    //public void method(){}}class ExtendsDemo{    public static void main(String[] args){        Son s = new Son();        s.show();    }}

12.面试题

1.方法重写和方法重载的区别？方法重载能改变返回值类型吗？方法重写：        在子类中，出现和父类中一模一样的方法声明的现象。方法重载：        同一个类中，出现的方法名相同，参数列表不同的现象。方法重载能改变返回值类型，因为他和返回值类型无关。override:方法重写overload:方法重载2.this关键字和super关键字分别代表什么？一级他们各自的使用场景和作用    this:代表当前类的对象引用    super:代表父类存储空间的标识。可以理解为父类的引用，通过这个东西可以访问父亲的成员场景：    成员变量：        this.成员变量        super.成员变量    构造方法：        this(...)        super(...)    成员方法：        this.成员方法        super.成员方法