day07_JAVAOOP（二）

继承

继承概述

• 父类：多个类中存在相同属性和行为时，将这些内容抽取到单独的一个类中，这个类就称为父类、超类(superclass)或者基类
• 子类：上文中那些多个存在相同属性和行为的类称为子类

继承概念

继承就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、行为

• 子类可以直接访问父类中的非私有的属性和行为

继承的特点

1. 子类自动拥有父类中的非私有的成员
2. 子类也可以拥有自己的成员

继承的好处

1. 提高代码的复用性
2. 类与类之间产生了关系，是多态的前提

继承的格式

• 通过extends关键字，可以声明一个子类继承另外一个父类，定义格式如下：

class 父类{...}
class 子类 extends 父类{...}

代码演示

• 父类

package cn.zhuo_01;
/**
 * @Auther: 不学无墅
 * @Date: 2023/7/13 8:40
 * @Desc: 父类
 */
public class Father {
    public void show(){
        System.out.println("这是父类");
    }
}

• 子类

package cn.zhuo_01;

/**
 * @Auther: 不学无墅
 * @Date: 2023/7/13 11:38
 * @Desc: 子类
 */
public class Son extends Father {

    public void showSon() {
        System.out.println("这是子类");
    }
}

• 测试类

package cn.zhuo_01;

/**
 * @Auther: 不学无墅
 * @Date: 2023/7/13 11:42
 * @Desc: 测试类
 */
public class Test {

    public static void main(String[] args) {

        //创建对象
        Son s = new Son();
        s.show();//这是父类
        s.showSon();//这是子类

        //创建对象
        Father f = new Father();
        f.show();//这是父类
    }
}

继承中成员访问的特点

子类访问父类

• 子类不能访问父类中私有的成员变量
• 子类不能访问父类中私有的成员方法

代码演示：

• 父类

package cn.zhuo_02;

/**
 * @Auther: 不学无墅
 * @Date: 2023/7/13 11:52
 * @Desc: 父类
 */
public class Father {

    //私有的成员变量
    private int number;

    //非私有的成员变量
    public int number1;

    //私有的成员方法
    private void method(){
        System.out.println("私有的成员方法");
    }

    //非私有的成员方法
    public void method1(){
        System.out.println("非私有的成员方法");
    }
}

• 子类

package cn.zhuo_02;

/**
 * @Auther: 不学无墅
 * @Date: 2023/7/13 11:53
 * @Desc: 子类
 */
public class Son extends Father {
    //子类自己的成员变量
    int number2;

    //
    public void method2(){
        System.out.println(number1);
        //System.out.println(number);——报错，子类不能访问父类中私有的成员变量
    }
}

• 测试类

package cn.zhuo_02;

/**
 * @Auther: 不学无墅
 * @Date: 2023/7/13 11:53
 * @Desc: 测试类
 */
public class Test {

    public static void main(String[] args) {
        //创建对象
        Son s = new Son();

        //s.number = 200;——报错，子类不能访问父类中私有的成员变量
        s.number1 = 10;

        //s.method();——报错，子类不能访问父类中的私有的成员方法

        s.method2();//输出number1：10

        s.method1();//输出：非私有的成员方法

    }

}

成员变量

• 如果子类父类中出现不重名的成员变量，这时的访问时没有影响的

• 如果子类父类中出现重名的成员变量，这时的访问将会受到影响

  • 若成员变量重名，调用时采用就近原则

  • 若非要指定访问父类中重名的成员变量，需要使用super关键字

    使用格式：super.父类成员变量名;
    

成员方法

1. 成员方法不重名：对调用没有影响
2. 方法重写：若子类父类中出现重名的成员方法，这使得访问是一种特殊情况，叫做方法重写（Override）
   • 子类中出现与父类一模一样的方法时（返回值类型、方法名和参数列表都相同），会出现覆盖效果，也成为重写或复写，声明不变，重新实现
3. 方法重写的应用场景：子类根据需要，沿用父类的功能名称，进行扩展增强，实现特定于自己的行为

代码演示：

• 父类

package cn.zhuo_03;

/**
 * @Auther: 不学无墅
 * @Date: 2023/7/13 13:54
 * @Desc: 父类
 */
public class Fulei {
    //父类成员变量
    int num = 10;

    //父类成员方法
    public void show(){
        System.out.println("这是父类");
    }

    public void method(){
        System.out.println("这也是父类");
    }

}

• 子类

package cn.zhuo_03;

/**
 * @Auther: 不学无墅
 * @Date: 2023/7/13 13:55
 * @Desc: 子类
 */
public class Zilei extends Fulei {

    //子类成员变量
    int num = 20;//和父类成员变量重名

    public void print(){

        //子类成员变量和父类成员变量重名的情况下，采用就近原则，此处访问的是子类成员变量20
        System.out.println(num);//20

        //使用super关键字进行修饰，此处访问的就是父类成员变量10
        System.out.println(super.num);//10

    }

    public void show2(){
        System.out.println("这是子类");
    }

    public void method(){
        System.out.println("这属于方法重写，是对父类的方法进行了扩展增强");
    }

    public void show3(){
        //父类和子类成员变量重名，采用就近原则，此处为子类成员变量num=20
        System.out.println(num);

        //super.父类成员变量名：可以在重名的情况下指定访问到父类的成员变量，此处为父类的成员变量num=10
        System.out.println(super.num);
    }

}

• 测试类

package cn.zhuo_03;

/**
 * @Auther: 不学无墅
 * @Date: 2023/7/13 13:55
 * @Desc: 测试类
 */
public class Ceshi {
    public static void main(String[] args) {
        //创建对象
        Zilei z = new Zilei();

        //调用继承而来的父类方法
        z.show();

        //调用子类方法
        z.show2();
        z.show3();

        //方法重写：子类中出现了与父类中的一模一样的方法
        //子类重写了父类的方法
        z.method();


    }

}

方法重写的注意事项

• 子类方法重写父类方法，必须要保证权限大于等于父类权限，最好修饰权限一样
• 子类方法重写父类方法，返回值类型，方法名和参数列表都要一模一样

构造方法执行特点

描述

1. 构造方法的名字与类名一致，所以子类无法继承父类的构造方法
2. 构造方法的作用是初始化成员变量，所以子类的初始化过程中必须先执行父类的初始化操作
3. 注：在每次创建子类对象时，先初始化父类空间，在创建其子类对象本身

访问构造方法的注意事项

1. 在子类构造方法中的第一行，默认有super();给父类进行初始化
2. 在子类构造方法中可以手动调用父类其他重载的构造方法
   • 格式：super（参数列表）
3. 注：
   • super.父类成员方法//表示调用父类的成员方法
   • super.父类成员变量//表示调用父类的成员变量
   • super（）//表示访问父类中的无参构造
   • super（参数）//表示访问父类中的有参构造

super和this

含义

• super：前提要是继承关系，代表父类的存储空间标识（可以理解为父类的引用）
• this：代表当前对象的引用（this在哪个类中就代表那个类）

用法

访问成员

this.成员变量	本类的成员变量
this.成员方法	本类的成员方法
super.成员变量	父类的成员变量
super.成员方法	父类的成员方法

访问构造

this（...）	本类的构造方法
super	父类的构造方法

注：super（）和this（）都必在构造方法的第一行，所以不能同时出现

继承的特点

1. Java只支持单继承，不支持多继承（一个类最多只有一个父类）

class C extends A{}//对
class C extends A,B...{}//error

2. Java支持多层继承（继承体系）

class A{}
class B extends A{}
class C extends B{}
//没有问题

3. 子类和父类是一种相对概念
4. 一个父类可以有很多个子类

代码演示

• 父类

package cn.zhuo_04;

/**
 * @Auther: 不学无墅
 * @Date: 2023/7/13 15:12
 * @Desc: 父类
 */
public class Father {
    //父类成员变量
    private int num;

    //父类无参构造方法
    public Father() {
        System.out.println("父类的无参构造方法");
    }

    //父类有参构造方法
    public Father(int num) {
        this.num = num;
    }

    //父类成员方法
    public void show1() {
        System.out.println(num);
    }
}

• 子类

package cn.zhuo_04;

/**
 * @Auther: 不学无墅
 * @Date: 2023/7/13 15:13
 * @Desc: 子类
 */
public class Son extends Father{

    //子类成员变量
    int num2;

    //子类无参构造方法
    public Son(){
        // 作用：因为继承必须先调用父类的构造方法，父类成员变量初始化后，才可以给子类使用
        super();//可以省略，因为子类构造方法中的第一行默认有 super() ,给父类进行初始化
        System.out.println("子类的无参构造方法");
    }
    //子类有参构造方法
    public Son(int num2) {

        //手动调用父类其他重载的构造方法
        super(34);//如果不写本局代码，将默认调用父类的无参构造方法
        this.num2 = num2;
    }

    //子类成员方法
    public void show2(){
        super.show1();
        System.out.println(num2);
    }
}

• 测试类

package cn.zhuo_04;

/**
 * @Auther: 不学无墅
 * @Date: 2023/7/13 15:13
 * @Desc: 测试类
 */
public class Test {

    public static void main(String[] args) {

        //创建子类对象，使用无参构造方法初始化子类
        Son s = new Son();

        //创建子类对象，使用有参构造方法初始化子类
        Son s1 = new Son(50);
        s1.show1();//34
        s1.show2();//50

    }
}

抽象类

什么是抽象

1. 抽象方法：只有方法的声明，没有方法体的方法，就是抽象方法
2. 抽象类：Java语法规定，抽象方法所在的类必定是抽象类

抽象类和抽象方法的格式

抽象方法

使用abstract关键字修饰的方法，抽象方法只包含一个方法名，而没有方法体

• 定义格式：

修饰符 abstract 返回值类型 方法名（参数列表）

抽象类

若一个类包含抽象方法，该类必是抽象类

• 定义格式：

public abstract class 类名{}

抽象的使用

1. 具体的子类继承抽象的父类，必须重写父类所有的抽象方法
2. 抽象的子类继承抽象的父类，不用重写父类方法，没有意义
3. 抽象的类中可以有抽象方法，也可以有非抽象方法

使用场景

有共性的功能，定义抽象方法，有抽象方法的类必是抽象类

抽象的注意事项

1. 有抽象方法的类必是抽象类
2. 抽象类可以有抽象方法，也可以有普通方法
3. 抽象类有构造方法
4. 抽象类不能实例化
5. 抽象类中的普通方法通过子类继承过来即可调用

• 抽象类不能创建对象，创建就报错，只能创建其非抽象子类的对象

假设创建了抽象类的对象，调用方法没有方法体，没有意义

• 抽象类中，可以有构造方法

供子类创建对象时，默认的super（）初始化父类成员使用

• 抽象类中不一定包含抽象方法，反之有抽象方法的类必是抽象类

没有抽象方法的抽象类，就是不想让调用者创建该类对象

抽象类关键字使用

abstract不能和以下关键字一起使用：

• private（私有的）
• final（最终的）
• static（静态的）