天天看点
返回

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

一、继承

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 = ;
    public int num2 = ;

    //私有方法，子类不能继承
    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 = ;
}

class Son extends Father{
    public int num2 = ;
    public int num = ;

    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 = ;
}

class Son extends Father{
    public int num = ;

    public void show(){
        int num = ;
        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 = ;
    public Fu(){
        System.out.println("fu");
    }
}

class Zi extends Fu{
    public int num = ;
    public Zi(){
        System.out.println("zi");
    }
    public void show(){
        int num = ;
        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.面试题

方法重写和方法重载的区别？方法重载能改变返回值类型吗？

方法重写：
        在子类中，出现和父类中一模一样的方法声明的现象。

方法重载：
        同一个类中，出现的方法名相同，参数列表不同的现象。

方法重载能改变返回值类型，因为他和返回值类型无关。

override:方法重写
overload:方法重载

this关键字和super关键字分别代表什么？一级他们各自的使用场景和作用
    this:代表当前类的对象引用
    super:代表父类存储空间的标识。可以理解为父类的引用，通过这个东西可以访问父亲的成员

场景：
    成员变量：
        this.成员变量
        super.成员变量
    构造方法：
        this(...)
        super(...)
    成员方法：
        this.成员方法
        super.成员方法
JavaSE 面向对象
上一篇: Java 面向对象——继承（下）
下一篇: java面向对象---继承1.继承2.继承案例演示3.Java中类的继承特点4.继承的注意事项和什么时候使用继承5.继承中成员变量的关系6.this和super的区别和应用7.继承中构造方法的关系8.继承中构造方法的注意事项9.继承中的面试题10.继承中成员方法关系11.方法重写概述及其应用12.方法重写的注意事项13.猫狗案例分析14.代码块15.代码块的面试题

继续阅读