面向对象—继承

目录

1.继承

1.1继承概述

1.2继承的好处和弊端

1.3继承中变量的访问特点

1.3小结

1.4super关键字

1.4小结

1.5继承中构造方法的访问特点

1.6继承中成员方法的访问特点

1.7super内存图

1.8方法重写

练习演示（手机类和新手机类）

1.9方法重写注意事项

1.9小结

1.10Java中继承的注意事项

---

1.继承

1.1继承概述

看这里我有一个学生类

学生类里面有两个成员变量，name和age

这两个成员变量含有对应的get和set方法，

还有一个方法study。

我们再来看一个类：

老师类

老师类里面也有两个成员方法，name和age。

name和age分别都有对应的get和set方法

还有一个teach方法。

看完这两个类之后，我们来说一下他们相同的内容：

首先这两个成员变量是相同的（成员变量我们也可以称为属性），所以我们也可以说他们拥有相同的属性。

我们再来说一下get/set方法，他们是相同的，所以我们说他们具有相同的方法

那么这些相同的内容我们统称为相同特征，假如把相同特征给提取出来，再整理一下我们的原始类就会变成这个样子：

那么这个相同特征里面就是放的相同的内容，我们把这个相同的内容也用一个类来表示：

只不过这个类目前还没给他名字而已：

来看一下这个不知道名字的类里面，有两个成员变量：name和age还有他们对应的get/set方法。

然后在学生类和老师类里面各有一个成员方法，但是它们和它们以前的效果肯定是不同的，因为它们里面少东西了。而这些东西都在这个不知道名字的类里面。

而现在有没有方式或者机制可以让学生类和老师类知道这个不知道名字类里面的内容呢？

那么，肯定是有这个机制的，这个机制就是让它们直接产生一个关系就可以了，而这个关系就是我们要讲解的继承。

继承概述：

继承是面向对象三大特征之一。可以使得子类具有父类的属性和方法，还可以在子类中重新定义，追加属性和方法。

继承的格式：

格式：

public class 子类名 extends 父类名{ }

（这里面有两个类的名字中间用关键字extends连接起来，表示前面这个类继承后面这个类）。

范例：

public class Zi extends Fu{ }

(在这里就是这个Zi继承了这个Fu)

Fu：是父类，也是被称为基类，超类。

Zi：是子类，也被称为派生类。

特点：

     子类可以有父类的内容

     子类还可以有自己特有的内容

代码演示：

public class Fu {
    //写一个方法
    public void show(){
        System.out.println("show方法被调用");
    }
}
class Zi extends Fu{
    //再写一个方法
    public void method(){
        System.out.println("method方法被调用");
    }
}
class Demo {
    public static void main(String[] args) {
        //创建对象调用方法
        Fu f =new Fu();
        f.show();//运行得到show方法被调用     没有问题

        //Zi方法同理
        Zi z = new Zi();
        z.method();//运行得到method方法被调用

        /*按道理说z对象可以调用show方法，但是现在不可以，
        因为现在只是我们自己理解父类和子类，所以要想它们具备
        这个继承关系，我们得使用extend关键字，去到Zi类修改这样才表示
        Zi类继承了Fu类，它继承了Fu类后就可以调用Fu类中的show方法
         */
        z.show();//运行得到show方法被调用
    }
}

1.2继承的好处和弊端

继承的好处：

• 好了代码的复用性（多个类相同的成员可以放到同一个类中）
• 调高了代码的维护性（如果方法的代码需要修改，修改一处即可）

继承的弊端：

     继承让类于类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性。

什么时候使用继承？

• 继承体现的关系：是is和a的关系。
• 用假设法来判断：我有两个类A和B，如果它们满足A是B的一种，或者B是A的一种，就说明它们是存在继承关系，这个时候就可以考虑使用继承来体现，否则就不能滥用继承。
• 举例：苹果和水果（苹果是水果的一种，所以我们可以把水果设为苹果的父类，苹果设定为子类）。

猫和动物（猫是动物的一种，所以我们可以把动物设为猫的父类，猫设定为子类）

猫和够不能使用继承

1.3继承中变量的访问特点

先代码演示再总结：

先准备三个类（父类，子类，测试类）

public class Fu {
    //1.父类里面有一个成员变量 年龄,为了访问方便，我们用public修饰
    public int age = 48;
}
//2.我们先通过extends关键字让Zi类继承Fu类
class Zi extends Fu{
    //3.在子类中有一个变量身高
    public int height = 175;

    //13.接下来我们把父类age复制到子类中来，并把值改为20
    public int age = 20;
    //4.还有一个成员方法
    public void show(){
        //16.更改age的值为30，再到测试类里面执行
        int age = 30;
        /*5.这个年龄呢，虽然子类没有，但是通过子类继承了父类，
        父类里面有，所以子类也是可以直接访问的
         */
        System.out.println(age);//11.这个年龄48来自于父亲的age的值
        //15.这一次年龄的这个值使用的是子类里面的20.由此可见如果子类中有就不会去使用父类中的了
        //18.这一次的年龄使用的是方法内部中的变量
        /*
          19所以就可以说，在方法中使用一个变量的时候，他首先会在方法的内部中寻找，如果没有
        就会到本类的成员变量中去寻早，如果本类的成员变量也没有就会去到父类的成员变量中寻找
         */


        //6.这个身高是子类自己的，可以之间访问
        System.out.println(height);//12.身高来自于本类的值

        //20.这次我们来输出一个不存在的变量体重：weight
        //System.out.println(weight); 21.所以它报错了

    }
}
/*
    测试类

    7.现在我们来看这个测试类
 */
class Demo {
    //8.在这个测试类里面有一个main方法
    public static void main(String[] args) {
        //9.接下来我们要创建对象，调用方法
        Zi z = new Zi();
        z.show();//10.执行得到 48和175，然会回到Zi类的show方法
                 //14.右键输出得到20和175
                 //17.这次得到30.175
    }
}

1.3小结

在子类方法中访问一个变量：

• 首先会在子类局部范围查找。
• 如果子类局部范围没有就会到子类成员范围找
• 子类成员范围没有，就会到父类成员范围找
• 如果父类方法还没有，就报错（不考虑父亲的父亲）

1.4super关键字

先到代码演示然后再总结：

先创建三个类（父、子、测试类）

/*
*   1.先来看父类里面有一个成员变量*/
public class Fu {
    public int age = 40;
}
/*
* 2.再来看子类*/
class Zi extends Fu {
    //3.有一个成员变量age
    public int age = 20;

    //4.有一个成员发方法show
    public void show(){
        //5.在成员方法里面有一个局部变量age，值为30.
        int age = 30;
        //6.在方法里面输出age的值
        System.out.println(age);
        //11.使用this关键字访问本类成员变量
        System.out.println(this.age);
        //13.此处执行得到20所以this.age访问的是本类的成员变量

        /*14.我要访问父类的成员变量age，怎么办呢？
        使用super关键字，可以访问父类的成员变量
         */
        System.out.println(super.age);
        //16.说明这个方法的确是访问父类的成员变量
    }

}
/*
* 测试类*/
class Demo {
    //7.在测试类里面有一个main方法
    public static void main(String[] args) {
        //8.在main方法里面创建对象，并调用方法
        Zi z = new Zi();
        z.show();//9.执行得到30
        /*10.我要访问本类的成员变量age怎么半呢？
        我们现在调用方法访问的是show方法里面的局部变量
        要怎么才能访问它呢：可以使用关键字this
        所以回到子类
         */
        //12.再次调用方法得到30和20，
        //15.再次调用方法得到30、20、40
    }
}

1.4小结

super关键字的用法和this关键字的用法相似

• this：代表本类对象的引用

（this关键字指向调用该方法的对象，一般我们是在当前类中使用this关键字，所以我们常说this代表本类对象的引用）

• super：代表父类存储空间的表示（可以理解为服气对象引用）所以super可以访问父类的成员变量

关于super和this的三种用法：

它们也可以访问方法，括号里的是可以带有参数的，这里省略了。

1.5继承中构造方法的访问特点

先到代码演示然后再小结：

先创建3个类：

 

public class Fu {
    //1.在父类中定义两个构造方法
    public Fu(){
        System.out.println("Fu中无参构造法被调用");
    }
    public Fu(int age){
        System.out.println("Fu中带参构造法被调用");
    }
class Zi extends Fu {
    //2.在子类中我们也定义了两个构造方法
    public Zi(){
        System.out.println("Zi中无参构造方法被调用");
    }
    public Zi(int age){
        System.out.println("Zi中带参构造方法被调用");
    }
}
/*
    测试类
 */
class Demo {
    public static void main(String[] args) {
        //3.在测试类中首先要做的是创建对象,这里是通过无参构造方法来创建的对象
        Zi z = new Zi();
        /*4.右键执行得到
            Fu中无参构造方法被调用
            Zi中无参构造方法被调用
         */

        //5.通过带参构造方法来创建对象
        Zi z2 = new Zi(20);
        /* 6. 执行得到
            Fu中无参构造法被调用
            Zi中带参构造方法被调用    
          */     
    }
}

代码中出现的问题：

子类中所有的构造方法默认都会访问父类中无参的构造方法。为什么呢？

• 因为子类会继承父类中的数据，可能还会使用父类的数。所以，子类初始化 之前，一定要先完成父类数据的初始化

（我们访问父类的构造方法，就是为了完成父类数据的初始化，所以我们所有子类构造方法在创建对象之前都会去访问父类的构造方法，完成父类数据的初始化）

• 每一个子类构造方法的第一条语句默认都是：super()

（super后面直接跟小括号表示调用的是父类的构造方法，而且这里没有参数，就代表调用的是父类的无参构造方法，所以我们刚才使用两个子类构造方法创建对象的时候，它默认访问的都是父类的无参构造方法）

继续代码演示：

public class Fu {
    //1.在父类中定义两个构造方法
    /*9.注释掉无参构造方法
    public Fu(){
        System.out.println("Fu中无参构造法被调用");
    }     */

    //14.在父类中写一个无参构造方法就可以解决13的问题
    public Fu(){
        System.out.println("Fu中无参构造法被调用");
    }
    public Fu(int age){
        System.out.println("Fu中带参构造法被调用");
    }
}
/*10.注释掉父类的无参构造方法，子类会报错，
因为子的构造方法中默认访问的是父类的无参构造方法
而这个无参构造方法被9那里注释掉了，他就只有带参构造方法了，这时怎么办呢？
 */
class Zi extends Fu {
    //2.在子类中我们也定义了两个构造方法
    public Zi(){
        //7.刚才说了在这里会有默认有的东西叫super
        //super();

        //11.可以通过super带参构造方法解决10提出的问题
        //13.还有一种方法，我不喜欢去使用带参构造方法，就把带参super注释掉,他就报错了，怎么办呢？
        //super(20);
        System.out.println("Zi中无参构造方法被调用");
    }
    public Zi(int age){
        //8.写了super后执行得到的结果是一样的，如果我们写了默认的就不会有了，所以一般来说我们不写
        //super();

        //11.这里也给一个参数，这样同样可以通过父类的带参构造方法对父类的数据进行初始化
        //super(10);
        System.out.println("Zi中带参构造方法被调用");
    }
}
/*
    测试类
 */
class Demo {
    public static void main(String[] args) {
        //3.在测试类中首先要做的是创建对象,这里是通过无参构造方法来创建的对象
        Zi z = new Zi();
        /*4.右键执行得到
            Fu中无参构造方法被调用
            Zi中无参构造方法被调用
         */

        /*12.
        * Fu中带参构造法被调用
          Zi中无参构造方法被调用*/

        //5.通过带参构造方法来创建对象
        Zi z2 = new Zi(20);
        /* 6. 执行得到
            Fu中无参构造法被调用
            Zi中带参构造方法被调用         */

        /*
        * 12.Fu中带参构造法被调用
             Zi中带参构造方法被调用*/
    }
}

问题：

如果父类中没有无参构造方法，只有带参构造方法，该怎么办呢？

• 通过使用super关键字去显示的调用父类的带构造方法
• 在父类中自己提供一个无参构造方法

推荐：自己给出无参构造方法

1.6继承中成员方法的访问特点

先到代码中演示

先创建三个包:

public class Fu{
    //1.父类中有一个show方法
    public void show(){
        System.out.println("Fu中show()方法被调用");
    }
}
class Zi extends Fu {
    //2.在Zi类中有一个method方法
    public void method() {
        System.out.println("Zi中method()方法被调用");
    }
    //5.在Zi类中也写一个show方法
        public void show() {
            //6.我们在Zi中show方法里面写个super.show();方法

            super.show();
            System.out.println("Zi中show()方法被调用");

    }
}
class Demo {
    public static void main(String[] args) {
        //3.创建对象,调用方法
        Zi z = new Zi();
        //4.因为子类继承了父类所以这个对象z也可以调用父类的show方法
        z.show();//4. Fu中show()方法被调用
        z.method();//4. Zi中method()方法被调用
        /*5.1这样得到 Zi中show()方法被调用
                        Zi中method()方法被调用
         所以我们通过Zi类对象去调方法的时候，
         它首先是在Zi中里面找，如果Zi里面没有就去Fu类里面找
        * */
        /*6.1 执行就会得到
        Fu中show()方法被调用
        Zi中show()方法被调用
        Zi中method()方法被调用
        因为它首先会通过super.show();方法调用Fu类中的show方法然后再执行Zi类中的show方法
        * */

        //7.我们来调用test方法会报错，因为在Zi类和Fu类中都没有test方法
        //z.test();
    }
}

小结：

通过子类对象访问一个方法：

1. 首先会到子类成员范围找，如果找不到
2. 就会到父类成员范围找
3. 如果都没有就报错（这里同样不考虑父亲的父亲…）

1.7super内存图

首先看这里有一个测试类，这个测试类里面有一个main方法，在main方法里面我们创建了Zi类对象z，并使用对象z调用了show方法和method方法，在这个图里面还有一个栈内存和堆内存。

我们来讲一下这个代码块在整个内存中的执行流程，

首先程序冲main方法开始执行，main方法进入到栈内存里面，然后再main方法里面

通过代码Zi z = new Zi();左边这个动作创建了Zi类对象z，这个Zi类对象z就会加载到main方法里面

然后右边的内容 new Zi，我们就要先看一下Zi类，这个Zi类它继承了Fu类，Zi类里面有一个成员变量age，age的值是20，在这个子类中有一个无参构造方法Zi在控制台输出了一句话，和一个成员方法show在show方法里面定义了age的值为30，并输出了age的值，和在Zi类中的成员变量age的值（也就是通过this访问的变量），还有在Fu类中的成员变量age的值（也就是通过super访问的变量），

然后就会在堆内存中出现一个地址，因为new就会去申请地址而且会进行Zi类数据的初始化，所以age等于20也就存在了，这个地址值最终是要赋值给Zi类对象z的

那么接下来我们调用这个Zi的构造方法

构造方法就会被加载到栈内存中

进来后执行的时候不要着急，因为在Zi的构造方法中，第一行默认的是访问Fu类的无参构造方法（也就是默认有一个super();）

所以这一次我们要找到这个Fu类里面去

然后我们来看一下Fu类里面的内容

首先我们可以看到Fu类里面有一个成员变量，它的值是20，和一个无参构造方法Fu()，和一个成员方法method()。接着Fu里面的内容就要进行初始化，那么这个初始化的内容就会有一个地方来存储，所以在堆内存里面有了一个super空间用来存储Fu类初始化的数据

那么Fu类中的age等于40也就会出现了

再接着会去访问Fu类的构造方法，那么Fu类的构造方法就会加载到栈内存中

然后接着在控制台输出Fu类无参构造方法被调用

接着往下执行，Fu类的无参构造方法就执行完毕，就会从栈内存消失

接着回到Zi类里面，访问Fu类的super无参构造方法结束之后接着往下执行在控制台输出Zi类无参构造方法被调用。

接着往下执行，Zi类的无参构造方法调用也就执行完毕，然后从栈内存消失

然后回到main方法中再通过Zi类创建的z对象调用show方法

然后我们又会进到Zi类的内容

继续调用show方法，这个show方法就会加载到栈内存中

show方法的调用者是z，因为调用者是z那么地址值是001，这个时候的this它的地址值也是001

接着进来之后，show方法里面定义了一个int变量age，它的值是30，这个变量就会在show方法中存在

接着往下执行，在show方法中直接输出age的值，那么输出的值是30

接着往下执行，通过this访问age的值，this它的地址值是001，所以它访问的是001下面的age值20.所以这样一次在控制台输出的值是20.

接着往下来super.age那么这一次要找到调用者通过调用者找到super，再通过super访问下面age的值，这一次在控制台输出的值是40.

接着往下执行，show方法就执行完毕，并从栈内存消失

然后回到main方法中，调用方法z.method（）；

然后再Zi类中并没有method方法，所以它调用不了

但是不要担心，因为它还有Fu类：

 

所以我到父类中去找

发现Fu类中有method这个方法

所以这个时候调用的是Fu类中的method方法，z.method首先会进入到Zi类中，发现Zi类里面没有method方法，就通过关键字extends找到了Fu类，在Fu类里面找到了method方法，执行method方法在控制台输出了Fu类method方法被调用。（这里理解不够到位，后面继续补充）

接着回到main方法中，main方法执行完毕，然后main方法从栈内存消失。

1.8方法重写

方法重写概述

• 子类中出现了和父类一模一样的方法声明

方法重写的应用

• 当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样即沿袭了父类的功能，又定义了子类特有的内容

练习演示（手机类和新手机类）

/*
    1.老款手机类
 */
public class Phone {
    //2.给手机类写一个方法（类似于给手机添加一个功能）
    public void call(String name) {
        //2.让他可以给某某打电话
        System.out.println("给" + name + "打电话");
    }
}
/*
    6.新式手机
    因为新手机除了新功能，老功能跟老款手机一样
    所以我们让新手机继承老款手机
 */
class NewPhone extends Phone {
    //7.我们先什么都不写，只是继承了老款手机的方法，然后去执行试试看


    //10.因为老款手机的方法，只有打电话的功能，但是我们新款手机支持视频功能，所以我们要给新手机添加功能
    //11.直接把老手机的方法，拿过来，并在里面添加功能，这个也叫方法重写
//    public void call(String name) {
    //12.添加功能
//        System.out.print("开启视频功能");
    //2.让他可以给某某打电话
    //System.out.println("给" + name + "打电话");

        /*14.但是上面2.下面的功能是一个打电话的功能，
        我们老款手机类本身就具备，因为我们继承了老款手机所以我们不需要2.下面这一句话
       这个动作我们应该像15.这样操作，先注释掉心事手机类方法里面2.的功能
         */

    //15.通过super去访问父类的打电话功能，把参数传递过去
//        super.call(name);
    //17.这样我们新手机的它重写了打电话的这个功能后，他就能够加入自己特有的内容，并且还能够沿袭父类的功能



        /*18.先把上面的方法重写注释掉,
        我们一开始是从父类里面复制方法声明过来的，
        这次我们自己来写，假如一不小心写错了
         */
//    public void calll(String name){
//        System.out.print("开启视频功能");
//        super.call(name);}


    /*21.注释掉上面的代码使用 @Override 这是个注解，
    这个注解就表明下面的方法声明是重写父类的，要是跟父类的方法声明不一样，它就会报错
     */
    @Override
    public void call(String name){
        System.out.print("开启视频");
        super.call(name);
    }


}
*
    2.手机测试类
 */
class PhoneDemo {
    public static void main(String[] args) {
        //3.创建对象,调用方法
        //4.使用老款手机使用打电话的功能
        Phone p = new Phone();
        p.call("林青霞");//5.执行得到给林青霞打电话
        System.out.println("----------");
        NewPhone np = new NewPhone();

        //8.执行，发现也是可以打电话的
        np.call("张曼玉");//9.执行得到给张曼玉打电话
        //13.添加新功能后，新手机执行得到 开启视频功能给张曼玉打电话
        /*16.通过super访问父类的打电话功能，
        执行得到的是新手机的视频功能+老手机的打电话功能：开启视频功能给张曼玉打电话
         */
        /*19.执行的结果却是给张曼玉打电话，没有视频功能是为什么呢？
        是因为我们把18.那里的方法写名字的时候把名字写错了，所以是个新的方法，
        所以np.call只调用了call方法，并没有调用写错的方法。
         */
        //21.再次执行就会得到：开启视频给张曼玉打电话



        //20.这样才会调用我们写错名字的方法，但是有一个东西可以帮助我们判断是否写错名字，减少犯错
        //20.1.np.calll("林青霞");
    }
}

演示完毕学到一个新知识：注解

@Override

• 是一个注解（注解后面会学习到）
• 可以帮助我们检查方法的方法声明的正确性

1.9方法重写注意事项

先到代码演示再回来总结：

先创建两个类

public class Fu {
    /*1.在Fu类中定义了两个方法，一个show方法一个method方法
    只不过这个show方法是用private修饰的，method方法是用public修饰的
    它们都叫访问权限修饰符，public肯定比private访问权限要高
     */
    private void show(){
        System.out.println("Fu中show()方法被调用");
    }
    void method(){
        System.out.println("Fu中method()方法被调用");
    }
}
//2.这个Zi类继承了Fu类
class Zi extends Fu{
    /*3.然后在Zi类里面去重写父类中的show方法，为了方便直接cv show方法过来
    并修改了show方法里面的东西，这样就是重写了Fu类的show方法
    为了表明我这个方法是重写父类的，使用注解 @Override
    结果发现报错了，为什么会报错呢，看一下报错原因：这个方法不是父类的show方法
    为什么会报这个错呢？
    因为父类中的私有内容，子类是不能继承到的，所以子类根本就不可能去重写父类中的私有方法
    这就是要说的方法重写的第一个注意事项：父类私有方法子类不可能重写。
     */

    /*4.@Override
    private void show(){
        System.out.println("Zi中show()方法被调用");
    }
     */

    /*5.直接cv父类的method方法并修改一下，
    并来一个注解，没有报错，说明这个方法就是重写父类的方法
     */
    /*
    @Override
    public void method(){
        System.out.println("Zi中method()方法被调用");
    }
     */

    /*6.注释掉上面的代码，并重新cv父类的method方法，并把它的修饰符public删除掉
    其实删除掉它还是有一个默认的修饰符的，而默认的访问修饰符它肯定是不如public访问权限大的
    如果只是这样写会报错的
    void method(){
        System.out.println("Fu中method()方法被调用");
    }
    它说，这里必须是public的，不要着急，我们只需要把父类的访问修饰符改成的默认的就不会报错了
    那就说明这是重写父类的方法
    也就是说子类重写父类的方法的时候，它的访问权限不能比父类低。
    但是，父类的访问修饰符可以是默认的，我们子类这里的访问修饰可以写成更高的public，也不会报错
    所以，子类重写父类方法时，你的访问权限只要不比父类的低就可以了
     */
    @Override
    public void method(){
        System.out.println("Zi中method()方法被调用");
    }

}

1.9小结

①私有方法不能被重写（父类私有成员子类是不能继承的）

②子类方法访问权限不能比父类的方法权限低（public>默认>私有）

1.10Java中继承的注意事项

先到代码中演示再来小结：

public class Granddad {
    //1.在爷爷类里面有一个方法
    public void drink(){
        System.out.println("爷爷爱喝酒");
    }
}
/*
6.这个Father本应该继承着Granddad
现在来看 Son继承了Father，Father继承了Granddad
这样就形成了一个继承体系，也就是Son继承Father他就可以拥有Father里面的内容
而Father继承了Granddad，Father就可以用于Granddad里面的内容
这样Son就同时具备了Granddad和Father里面的内容
这就是Java中的多重继承
 */
class Father {
    //2.在父亲类里面有一个方法
    public void smoke(){
        System.out.println("爸爸爱抽烟");
    }
}
class Mother {
    //3.在妈妈类里面有一个方法
    public void dance(){
        System.out.println("妈妈爱跳舞");
    }
}

/*
5.在现实生活中son应该可以继承father，所以我写Son extends Father是没有问题的
而son也应该可以继承mother的，所以也写上 son extends Father,Mother，
这样写会报错，显示类不可以继承多个类。
也就是说在java中类不可以同时继承多个类的，它只能继承单个类：单个继承Mother或者Father
 */
//public class Son extends Father,Mother{}
    //4.目前在儿子类里面说明都没有
    public class Son extends Father{
}

小结：

• Java中类只支持单继承，不支持多继承
• Java中类支持多层继承