JavaSE 16 Extends 继承

第二十一章 Extends 继承

21.1 继承的概述

• 继承是多态的前提，如果没有继承，就没有多态。
• 继承主要解决的问题是：共性抽取。

父类也叫基类、超类
子类也可以叫派生类

• 继承关系当中的特点：

1. 子类可以拥有父类的“内容”。
2. 子类还可以拥有自己专有的内容。

21.2 继承的格式

• 在继承的关系中，“子类就是一个父类”。也就是说子类可以当做父类看待。

  • 例如：父类是员工，子类是讲师，那么“讲师就是员工”关系：is-a。

• 定义父类的格式：

public class 父类名称 {
    
    
	...
}

• 定义子类的格式：

public class 父类名称 extends 父类名称 {
    
    
	...
}

• 示例：

//定义父类
public class Fu {
    
    

    public void method() {
    
    
        System.out.println("父类已经执行！");
    }
}

//定义了一个子类
public class Zi extends Fu {
    
    
    
}

public class DemoExtends {
    
    

    public static void main(String[] args) {
    
    
        Zi zi = new Zi();
        zi.method();//Teacher中虽然什么都没写但是会继承父类中的方法。
    }

}

21.3 继承中成员变量的访问特点

• 在父子类的继承关系当中，如果成员变量重名，则创建子类对象时访问有两种方式：

1. 直接通过子类对象访问成员变量
   等号左边是谁，就优先用谁，没有则向上找。
2. 间接通过成员方法访问成员变量
   该方法属于，就优先用谁，没有则向上找。

• 示例：

public class Fu {
    
    
    int fuNum = 10;

    int num = 888;

    public void methodFu() {
    
    
        System.out.println(num);
    }

}

public class Zi extends Fu {
    
    

    int ziNum = 20;

    int num = 999;

    public void methodZi() {
    
    
        System.out.println(num);
    }

}

public class DemoExtends {
    
    

    public static void main(String[] args) {
    
    
        Fu fu = new Fu();
        System.out.println(fu.fuNum);

        Zi zi = new Zi();
        System.out.println(zi.ziNum);
        System.out.println(zi.fuNum);

        //直接通过子类对象访问成员变量
        System.out.println(zi.num);//999 /*"Zi zi = new Zi();" 等号左边是谁('zi')，就优先用谁('zi') */

        //间接通过成员方法访问成员变量
        zi.methodFu();//888 因为Fu类当中有num，所以用Fu类的
        zi.methodZi();//999 因为Zi类当中有num，所以用Zi类的
    }

}

21.4 区分子类方法中的重名的三种变量

局部变量：直接写成员变量名
本类的成员变量：this.成员变量名
父类的成员变量：super.成员变量名

public class Fu {
    
    
    int num = 10;
}

public class Zi extends Fu {
    
    

    int num = 20;

    public void method() {
    
    
        int num = 30;
        System.out.println(num);//30，局部变量
        System.out.println(this.num);//20，本类成员变量
        System.out.println(super.num);//10，父类成员变量
    }

}

public class DemoExtends {
    
    

    public static void main(String[] args) {
    
    
        Zi zi = new Zi();
        zi.method();
    }

}

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

• 创建的对象是谁，就优先用谁，如果没有则向上找。
• 注意：无论是成员方法还是成员变量，如果没有都是向上找父类，绝对不会向下找子类的。

public class Fu {
    
    

    public void methodFu() {
    
    
        System.out.println("父类方法执行！");
    }

    public void method() {
    
    
        System.out.println("父类的重名方法执行！");
    }

}

public class Zi extends Fu {
    
    

    public void methodZi() {
    
    
        System.out.println("子类方法执行!");
    }

    public void method() {
    
    
        System.out.println("子类重名方法执行!");
    }
    
}

public class DemoExtendsMethod {
    
    

    public static void main(String[] args) {
    
    
        Zi zi = new Zi();

        zi.methodFu();//父类方法执行！
        zi.methodZi();//子类方法执行!

        zi.method();//子类重名方法执行!
    }

}

21.6 继承中方法的覆盖重写 Override

21.6.1 概述

• 在继承关系当中，方法的名称一样，参数列表也一样。

• 重写Override与重载Overload的区别

  • 重写：方法的名称一样，参数列表也一样。（也叫覆盖、覆写）
  • 重载：方法的名称一样，参数列表不一样。

• 特点：创建的是子类对象，则优先用子类方法。

21.6.2 覆盖重写的注意事项

1. 必须保证父子类之间方法的名称相同，参数列表也相同。
   @Override:写在方法前面，用来检测是不是有效的正确覆盖重写。（@ 注解 annotation）
   这个注解要是不写，只要满足条件也算覆盖重写。(2、 3点只做了解，因为在重写中大部分情况的子类方法返回值和权限修饰符都是和父类一样的)

2. 子类方法的返回值必须小于等于父类方法的返回值范围。
   java.lang.Object类是所有类的公共最高父类（祖宗类）,java.lang.String就是它的子类。

public class Fu {
    
    

    public Object method() {
    
    
        return null;
    }


}

public class Zi extends Fu {
    
    

    @Override
    public String method() {
    
     //这里的String小于Object
        return null;
    }

}

3. 子类方法的权限必须大于等于父类方法的权限修饰符。
   public > protected > (default) > private
   备注：(default)不是关键字default,而是什么都不写。

public class Fu {
    
    

      String method() {
    
    
        return null;
    }


}

public class Zi extends Fu {
    
    

    @Override
    public String method() {
    
    
        return null;
    }

}

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

1. 子类构造方法当中有一个默认隐含super()调用，所以一定是先调用父类构造，后执行子类构造。
2. 子类构造可以通过super关键字来调用父类重载构造。
3. super的父类构造调用，必须是子类构造方法的第一个语句。不能一个子类构造调用多次super构造。
   总结： 子类必须调用父类构造方法，不写则赠送super();写了则用写的指定的super调用，super只能有一个，还必须是第一个。

public class Fu {
    
    

    public Fu() {
    
    
        System.out.println("父类构造方法！");
    }

}

public class Zi extends Fu {
    
    

    public Zi() {
    
       /*如果父类有方法，但是却没有写空参方法Zi类会报错；因为父类写了方法后不再赠送隐藏的空参方法，(在没有有参调用`super(参数);`时)子类默认的`super();`在父类没有了调用对象。*/
//        super();  /*隐藏赠送的调用父类无参数构造*/
//        super(20);    /*也可以调用有参的*/
        /*但是super();构造方法必须在最前且有且仅有一个*/
        System.out.println("子类构造方法！");
    }

}

public class DemoConstrution {
    
    

    public static void main(String[] args) {
    
    
        Zi zi = new Zi();
    }

}

21.7 super 关键字的三种用法

1. 在子类的成员方法中，访问父类的成员变量。
2. 在子类的成员方法中，访问父类的成员方法。
3. 在子类的构造方法中，访问父类的构造方法。

public class Fu {
    
    

    int num = 10;

    public Fu() {
    
    
    }

    public void method() {
    
    
        System.out.println("父类成员方法！");
    }

}

public class Zi extends Fu {
    
    

    int num = 20;

    public Zi() {
    
    
        super();//调用父类构造方法
    }

    public void method() {
    
    
        System.out.println(super.num);//调用父类的变量
        super.method();//调用父类的成员方法；
    }

}

21.8 this 关键字的三种用法

this关键字用来访问本类内容。

1. 在本类的成员方法中，访问本类的成员变量。
2. 在本类的成员方法中，访问本类的另一个成员方法。（起到强调的作用，不用写this.其实也是一样）
3. 在本类的构造方法中，访问本类的另一个构造方法。
   在第三种用法当中注意！！！
   A. this(...)必须是构造方法的第一个语句，且是唯一一个。
   B. super和this两种构造调用，不能同时使用。

public class DemoAbThis {
    
    

    int num = 20;

    public DemoAbThis() {
    
     //构造方法必须和方法名一致
        this(10);//调用本类构造方法
    }

    public DemoAbThis(int n) {
    
    
    }

    public void method() {
    
    
        int num = 10;
        System.out.println(num);//局部变量
        System.out.println(this.num);//本类中的成员变量
    }

    public void method1() {
    
    
    }

    public void method2() {
    
    
        this.method1();//在方法中调用本类方法
    }

}

21.9 继承的三个特点

1. Java语言是单继承的。一个类的直接父类只能有唯一一个。
2. Java语言可以多级继承。
3. 一个子类的直接父类是唯一的，但是一个父类可以拥有很多个子类。