1、继承

面对对象的三大特征：封装性、继承性、多态性

继承是多态的前提，如果没有继承，就没有多态

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

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

定义父类的格式：（一个普通的类定义）

public class 父类名称｛

//…

｝

定义子类的格式：

public class 子类名称 extends 父类名称｛

//…

｝

微信图片_20221009120414.png

代码示例：

//员工类
public class Employee {
    public void method(){
        System.out.println("方法执行");
    }
}

//讲师类（讲师是员工）
public class Teacher extends Employee {
}

public class Demo01Extends {
    public static void main(String[] args) {
        //创建一个子类对象
        Teacher teacher = new Teacher();
        //Teacher类当中虽然什么都没写，但是会继承来自父类的method方法
        teacher.method();
    }
}

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

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

1.直接通过子类对象访问成员变量：

等号左边是谁，就优先用谁，没有则向上找

2.简接通过成员方法访问成文变量：

该方法属于谁，就优先用谁，没有则向上找

1.2 区分子类方法中重名的三种

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

代码示例：

//父类
public class Fu {
    int num = 10;
}
1

//子类
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 Demo02ExtendsField {
        public static void main(String[] args) {
        Zi zi = new Zi();
        zi.method();
        }
}

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

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

1.4 super关键字的三种用法

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

1.5 this关键字的三种用法

在本类的成员方法中，访问本类的成员变量。
在本类的成员方法中，访问本来的另一个成员方法。
在本类的构造方法中，访问本类的另一个构造方法。

注意：super和this关键字不能同时使用

super和this关键字在内存中的图解如下图

微信图片_20221009121257.png

1.6 java继承的三个特点

java语言是单继承的。一个类的直接父类只有一个。

java语言可以多级继承。

一个子类的直接父类是唯一的，但是一个父类可以拥有多个子类。

2、抽象类

2.1 抽象类的概念

抽象方法：就是加上abstract关键字，然后去掉大括号，直接分号结束。

抽象类：抽象方法所在的类，必须是抽象类才行，在class之前写上abstract即可。

2.2抽象方法是抽象类的使用

不能直接创建new抽象类对象。

必须用一个子类来继承抽象父类.

子类必须覆盖重写抽象父类当中所有的抽象方法。

创建子类对象使用。

注：覆盖重写（实现）：子类去掉抽象方法的abstract关键字，然后补上方法体大括号

代码示例：

public class DemoMain {
    public static void main(String[] args) {
        cat cat = new cat();
        cat.eat();
    }
}

//动物父类
public abstract class Animal {
    public abstract void eat();
}

//猫子类
public class cat extends Animal {
    @Override
    public void eat(){
        System.out.println("猫吃鱼");
    }
}

2.3抽象方法和抽象类的注意事项

抽象类不能创建对象，如果创建，编译无法通过而报错，只能创建其抽象子类的对象

抽象类中，可以有构造方法，是提供子类创建对象时，初始化父类成员使用。

抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错，除非子类也是抽象类。

3、接口

3.1 接口的概念

接口，是Java语言中一种引用类型，是方法的集合，如果说类的内部封装了成员变量、构造方法和成员方法，那么

接口的内部主要就是封装了方法，包含抽象方法（JDK 7及以前），默认方法和静态方法（JDK 8），私有方法

（JDK 9）。

接口的定义，它与定义类方式相似，但是使用 interface 关键字。它也会被编译成.class文件，但一定要明确它并

不是类，而是另外一种引用数据类型。

3.2 定义格式：

public interface 接口名称 {

// 抽象方法：使用 abstract 关键字修饰，可以省略，没有方法体。该方法供子类实现使用。

// 默认方法：使用 default 修饰，不可省略，供子类调用或者子类重写。

// 静态方法: 使用 static 修饰，供接口直接调用。

// 私有方法:使用 private 修饰，供接口中的默认方法或者静态方法调用。

}

注意事项：

1、接口当中的抽象方法，修饰必须是两个固定的关键字：public abstract

2、这两个关键字修饰符，可以选择性省略。

3.3 接口的使用步骤

接口不能直接使用，必须有一个“实现类”来“实现”该接口。

接口的实现类必须覆盖重写（实现）接口中所有抽象方法。

实现：去掉abstract关键字，加上方法体大括号。

创建实现类对象，进行使用。

注意事项：如果实现类并没有覆盖重写所有抽象方法，那么这个实现类自己就必须是抽象类。

3.3.1抽象方法

使用 abstract 关键字修饰，可以省略，没有方法体。该方法供子类实现使用。接口中，有多个抽象方法时，实现类必须重写所有抽象方法。如果抽象方法有重名的，只需要重写一次。

代码示例：

//定义接口
public interface MyInterfaceAbstract {
    //这是一个抽象方法
    public abstract void methodAbs1();
    //这也是一个抽象方法
    abstract void  methodAbs2();
    //这也是抽象方法
    public void methodAbs3();
    //这也是抽象方法
    void methodAbs4();
}

//定义实现类
public class MyInterfaceAbstractImpl implements MyInterfaceAbstract{
    @Override
    public void methodAbs1() {
        System.out.println("这是第一个方法");
    }
    @Override
    public void methodAbs2() {
        System.out.println("这是第二个方法");
    }
    @Override
    public void methodAbs3() {
        System.out.println("这是第三个方法");
    }
    @Override
    public void methodAbs4() {
        System.out.println("这是第四个方法");
    }
}

public class Demo01Interface {
    public static void main(String[] args) {
        MyInterfaceAbstractImpl impl = new MyInterfaceAbstractImpl();
        impl.methodAbs1();
        impl.methodAbs2();
    }
}

3.3.2默认方法

使用 default 修饰，不可省略，供子类调用或者子类重写。接口中，有多个默认方法时，实现类都可继承使用。如果默认方法有重名的，必须重写一次。

代码示例：

//定义接口
public interface MyInterfaceDefault {
    //这是一个抽象方法
    public abstract void methodAbs();
    //新添加一个抽象方法
//    public  abstract void methodAbs2();
    //新添加的方法，改成默认方法
    public default void methodDefault(){
        System.out.println("这是新添加的默认方法");
    }
}

//定义实现类
public class MyInterfaceDefaultA implements MyInterfaceDefault {
    @Override
    public void methodAbs() {
        System.out.println("实现抽象方法，AAA");
    }
}

public class MyInterface {
    public static void main(String[] args) {
        //创建实现类对象
        MyInterfaceDefaultA a = new MyInterfaceDefaultA();
        //调用抽象方法，实现运行的是右侧实现类
        a.methodAbs();
        //调用默认方法，如果实现类当中没有，会向上找接口的
        a.methodDefault();
    }
}

3.3.3静态方法

使用 static 修饰，供接口直接调用。接口中，存在同名的静态方法并不会冲突，原因是只能通过各自接口名访问静态方法。

注意事项：不能通过接口实现类的对象来调用接口当中的静态方法。

正确用法：通过接口名称，直接调用其中的静态方法

格式：

接口名称.静态方法名称（参数）;

3.3.4私有方法

使用 private 修饰，供接口中的默认方法或者静态方法调用。

3.4 接口中的常量定义与使用

接口中，无法定义成员变量，但是可以定义常量，其值不可以改变，默认使用public static final修饰。
接口中，没有构造方法，不能创建对象。
接口中，没有静态代码块

格式：

public static final 数据类型常量名称 = 数据值；

注意:

一旦使用final关键字进行修饰，说明不可改变。
接口中的常量，必须进行赋值，不能不赋值。
接口中常量的名称，使用完全大写的字母，用下划线进行分隔。（推荐）

继承与多态(1）

1、继承

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

1.2 区分子类方法中重名的三种

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

1.4 super关键字的三种用法

1.5 this关键字的三种用法

1.6 java继承的三个特点

2、抽象类

2.1 抽象类的概念

2.2抽象方法是抽象类的使用

2.3抽象方法和抽象类的注意事项

3、接口

3.1 接口的概念

3.2 定义格式：

3.3 接口的使用步骤

3.3.1抽象方法

3.3.2默认方法

3.3.3静态方法

3.3.4私有方法

3.4 接口中的常量定义与使用

热门文章

最新文章

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

继承与多态(1）

1、继承

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

1.2 区分子类方法中重名的三种

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

1.4 super关键字的三种用法

1.5 this关键字的三种用法

1.6 java继承的三个特点

2、抽象类

2.1 抽象类的概念

2.2抽象方法是抽象类的使用

2.3抽象方法和抽象类的注意事项

3、接口

3.1 接口的概念

3.2 定义格式：

3.3 接口的使用步骤

3.3.1抽象方法

3.3.2默认方法

3.3.3静态方法

3.3.4私有方法

3.4 接口中的常量定义与使用

热门文章

最新文章

相关电子书

相关实验场景