Java接口与final详解-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_40280217/article/details/96284093

这篇博客详细介绍了Java中的接口，包括接口的概述、定义、成员特点、多实现、多继承，以及接口中的默认方法、静态方法和私有方法。此外，还讲解了final关键字的用途，包括final修饰类、方法和变量，以及单例设计模式和枚举的使用。通过实例和代码，帮助读者理解接口和final在实际开发中的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

01接口的概述

目标:学习接口的概念

讲解:
Java中引用数据类型有3种: 数组,类,接口

class 类名 {
    成员变量
    成员方法/抽象方法
}

插座国标规范.每个厂家生成的插座都需要符合国标规范
国标规范就是接口,厂家生成的插座就是接口的实现类

1.1 接口概述

接口也是一种数据类型,接口是比抽象类还抽象的类,接口中全是抽象方法.接口体现的是规范

1.2定义格式(重点)

//接口的定义格式：
修饰符 interface 接口名称{
    // 抽象方法
}

// 修饰符：public|缺省
// 接口的声明：interface
// 接口名称：首字母大写，满足“驼峰模式”

1.3 接口成分的特点

在JDK8之前，接口中的成分包含：

抽象方法和常量

小结:

接口的定义格式(重点):
interface 接口名 {
抽象方法;
}

将接口看做一个特殊的类

02接口的定义和使用

目标:学习定义和使用接口

讲解:
类和类的关系: 继承

class 子类 extends 父类 {
        }

类和接口的关系:

implements 实现关系,和继承关系类似

HeiMaStudent

// 1.定义类实现接口
//           类               实现    接口
//          实现类
public class HeimaStudent implements HeiMaXiaoGui {
    // 2.重写抽象方法
    @Override
    public void daKa() {
        System.out.println("准时打卡");
    }

    @Override
    public void daiXiaoPai() {
        System.out.println("一定要挂在脖子上");
    }
}
//接口
public interface HeiMaXiaoGui {
    public abstract void daKa();

    public abstract void daiXiaoPai();
}


public class Demo02 {
    public static void main(String[] args) {
        // 3.创建实现类对象
        HeimaStudent hs = new HeimaStudent();
        hs.daKa();
        hs.daiXiaoPai();
    }
}

类实现接口的格式(重点):

class 类名 implements 接口名 {
	重写方法;
}

接口的使用:

小结:

类和接口的关系:
实现关系:implements

类实现接口的格式:

class 类名 implements 接口名 {
重写方法;
}

接口的使用:
1.定义类实现接口
2.重写抽象方法
3.创建实现类对象

03接口中的成员的特点

目标:学习掌握接口的成员特点

讲解:

小结:

接口的成员特点:

1.接口中的成员方法默认会添加:public abstract
2.接口中的成员变量默认会添加:public static final(常量)

课堂代码

public abstract class Demo03 {
    int a;
    public abstract void test01();
}

interface Abc {
    // 2.接口中的成员变量会自动添加public static final(常量),常量命名规范:每个单词都大写,多个单词之间使用_连接
    // ctrl + shift + u: 切换大小写
    int a = 10;
    public static final int STUDENT_COUNT = 10;

    // 1.接口中的方法默认会添加public abstract
    void test01();
    public abstract void test02();
}

04接口多实现

目标:学习接口的多实现

讲解:

Java中类只能单继承,一个类只有一个父类

class 子类 extends 父类 {
}

Java中的类可以同时实现多个接口

class 类名 implements 接口1, 接口2 {
	重写方法
}

小结:

类实现多个接口格式:

 class 类名 implements 接口1, 接口2 {
     重写方法
 }

课堂代码

public class Demo04 {
    public static void main(String[] args) {
        Student s = new Student();
        s.swimming();
        s.smoking();
    }
}

// 抽烟接口
public interface Smokeable {
    public abstract void smoking();
}

// 游泳接口
public interface Swimmable {
    public abstract void swimming();
}

public class Student implements Swimmable, Smokeable {
    @Override
    public void smoking() {
        System.out.println("学生在厕所瑟瑟发抖的抽烟");
    }

    @Override
    public void swimming() {
        System.out.println("学生狗刨式游泳");
    }
}

05接口多继承

了解
目标:学习接口多继承格式

讲解:

Java中类只能单继承

class 子类 extends 父类 {}

Java类可以实现多个接口

class 类名 implements 接口1, 接口2 {}

什么是接口多继承:

一个接口同时继承多个接口

接口多继承格式:

interface 接口名 extends 接口1, 接口2 {
}

小结:

接口多继承格式:
interface 接口名 extends 接口1, 接口2 {
}

Java中有多继承吗?
1.类只能单继承
2.接口可以多继承

课堂的代码


interface Father {
    public abstract void makeMoney();
}
interface Mother {
    public abstract void shopping();
}

// 一个接口继承多个接口
interface Child extends Father, Mother {
    public abstract void lol();
}

class Son implements Child {
    @Override
    public void makeMoney() {
    }

    @Override
    public void shopping() {
    }

    @Override
    public void lol() {

    }
}

public class Demo05 {
    public static void main(String[] args) {

    }
}

06接口_默认方法

目标:学习接口默认方法的使用

讲解:
JDK1.8以前
interface 接口名 {
抽象方法;
}

在JDK1.8以后接口新增了其他方法(了解)
    interface 接口 {
        默认方法; (JDK1.8)
        静态方法; (JDK1.8)
        私有方法; (JDK1.9)
    }

默认方法的格式:

修饰符 default 返回值类型方法名(参数列表) {
}

和普通方法相比: 在返回值类型前面添加default

接口_默认方法的使用:

1.实现类直接使用
2.实现类可以重写默认方法

小结:

接口_默认方法的使用:
1.实现类直接使用
2.实现类可以重写默认方法

课堂代码

public interface Swimmable {
    // 默认方法
    public default void swimming() {
        System.out.println("我是接口默认的游泳方法");
    }
}

// 1.实现类直接使用
public class Teacher implements Swimmable {
    // 2.实现类可以重写默认方法
    @Override
    public void swimming() {
        System.out.println("我是实现类重写的方法");
    }
}

public class Demo06 {
    public static void main(String[] args) {
        Teacher t = new Teacher();
        t.swimming();
    }
}

07接口_静态方法

目标:学习接口静态方法的使用

讲解:

静态方法的格式:

修饰符 static 返回值类型方法名(参数列表) {

}

接口_静态方法的使用:

接口的静态方法只能使用接口名调用

小结:

接口_静态方法的使用:
接口的静态方法只能使用接口名调用

课堂代码

public interface Swimmable {
    // 静态方法
    public static void show() {
        System.out.println("接口静态方法");
    }
}

public class Student implements Swimmable {
}

public class Demo07 {
    public static void main(String[] args) {
        // 接口的静态方法不能使用,实现类对象来调用
        /*Student s = new Student();
        s.show();*/

        // 接口的静态方法只能使用接口名调用
        Swimmable.show();
    }
}

08接口_私有方法

目标：学习接口私有方法的使用

讲解：

私有方法格式：

private 返回值类型  方法名（）{

}

接口_私有方法的使用

私有方法只有本类/接口使用

小结：

接口_私有方法的使用

1.给本接口的默认方法使用

2.给本接口的静态方法使用

课堂代码

public interface Swimmable {
    // 私有方法
    private static void test01() {
        System.out.println("我是接口私有方法");
    }

    // 1.私有方法给本接口的默认方法使用
    public default void show1() {
        test01();
    }

    // 2.私有方法给本接口的静态方法使用
    public static void show2() {
        test01();
    }
}

public class Student implements Swimmable {
}

public class Demo08 {
    public static void main(String[] args) {
        // 接口私有方法,在实现类中不能使用
        // Student s = new Student();
        // s.test01();
    }
}

09接口多实现_静态方法

目标：能够了解接口的多实现_静态方法的使用

讲解:
接口静态方法,使用接口名调用

小结:
接口多实现_静态方法:

课堂代码

public interface Smokeable {
    public static void test() {
        System.out.println("Smokeable接口的test方法");
    }
}

public interface Swimmable {
    public static void test() {
        System.out.println("Swimmable接口的test方法");
    }
}

public class Student implements Smokeable, Swimmable {
}

public class Demo09 {
    public static void main(String[] args) {
        // 类实现多个接口,多个接口中出现同名的静态方法没关系,
        // 因为,接口的静态方法使用接口名调用,不会冲突
        Swimmable.test();
        Smokeable.test();
    }
}

10方法优先级

目标:研究父类中的方法和接口中的默认方法重名问题

讲解:
一个类可以继承父类,同时实现接口,父类中的方法和接口中的默认方法重名时会使用谁的方法?

小结:

父类中的方法和接口中的默认方法重名
使用的是父类的

课堂代码

// 人活着的接口
public interface Liveable {
    public default void eat() {
        System.out.println("我是接口默认方法吃饭");
    }
}

public class Person {
    public void eat() {
        System.out.println("我是父类方法吃饭");
    }
}

// 就近原则,使用父类中的方法
// java中的类一定是先继承父类,后实现接口.接口相当于师傅
public class Student extends Person implements Liveable {
}

public class Demo10 {
    public static void main(String[] args) {
        Student s = new Student();
        s.eat();
    }
}

11接口练习

学生:
属性:姓名,年龄
行为:学习,抽烟,吃饭

老师:
属性:姓名,年龄
行为:上课,游泳,吃饭

工人:
属性:姓名,年龄
行为:搬砖,抽烟,吃饭

司机:
属性:姓名,年龄
行为:开车,游泳,吃饭

// 人类/父类
public class Person {
    private String name;
    private int age;

    public void eat() {
        System.out.println(name + "在吃饭");
    }

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

// 抽烟接口
public interface Smokeable {
    // 抽象的抽烟方法
    public abstract void smoking();
}

// 游泳接口
public interface Swimmable {
    // 抽象的游泳方法
    public abstract void swimming();
}

// 司机继承人类实现游泳接口
public class Driver extends Person implements Swimmable {
    public Driver() {
    }

    public Driver(String name, int age) {
        super(name, age);
    }

    @Override
    public void swimming() {
        System.out.println(getName() + "司机, 一边游泳一遍开车");
    }

    public void driving() {
        System.out.println(getName() + "司机, 单手五连发卡弯");
    }
}

// 学生继承人类,实现抽烟接口
public class Student extends Person implements Smokeable {
    public Student() {
    }

    public Student(String name, int age) {
        super(name, age);
    }

    @Override
    public void smoking() {
        System.out.println(getName() + "学生,色色发抖的在厕所抽赣州桥");
    }

    public void study() {
        System.out.println(getName() + "学生,努力学习");
    }
}

//老师继承人类，实现游泳接口
public class Teacher extends Person implements Swimmable {
    public Teacher() {
    }

    public Teacher(String name, int age) {
        super(name, age);
    }

    @Override
    public void swimming() {
        System.out.println(getName() + "老师, 裸泳");
    }

    public void teach() {
        System.out.println(getName() + "老师, 瑟瑟发抖的上课");
    }
}

// 工人继承人类,实现抽烟接口
public class Worker extends Person implements Smokeable {
    public Worker() {
    }

    public Worker(String name, int age) {
        super(name, age);
    }

    @Override
    public void smoking() {
        System.out.println(getName() + "工人, 寂寞的抽烟");
    }

    public void banZhuan() {
        System.out.println(getName() + "工人, 头顶200块砖");
    }
}

public class Demo11 {
    public static void main(String[] args) {
        // 创建学生
        Student s = new Student("二狗", 18);
        s.eat();
        s.study();
        s.smoking();
        System.out.println("-------------");

        // 创建老师
        Teacher t = new Teacher("苍", 18);
        t.eat();
        t.teach();
        t.swimming();
        System.out.println("--------------");

        // 创建工人
        Worker w = new Worker("张全蛋", 28);
        w.eat();
        w.banZhuan();
        w.smoking();
        System.out.println("--------------");

        // 创建司机
        Driver d = new Driver("藤原拓海", 15);
        d.eat();
        d.driving();
        d.swimming();
    }
}

12final修饰符和方法

学习了继承后，我们知道，子类可以在父类的基础上改写父类内容。

目标:学习final修饰类和方法

讲解:

final关键字的含义:

最终的,不可变的

final可以修饰:

1.类
2.方法
3.变量

小结:

1.final修饰类,这个类不能被继承(太监)
2.final修饰方法,这个方法不能被重写

课堂代码

// 1.final修饰类,这个类不能被继承(太监)
final class Fu {}
// class Zi extends Fu {}

// 2.final修饰方法,这个方法不能被重写
class Fu2 {
    public final void show() {
        System.out.println("aaa");
    }
}

class Zi2 extends Fu2 {
    // @Override
    // public void show() {
    //     System.out.println("我是重写方法");
    // }
}

public class Demo12 {
    public static void main(String[] args) {
        Zi2 z2 = new Zi2();
        // final修饰的方法子类可以使用
        z2.show();
    }
}

13final修饰变量

目标:学习final修饰变量

讲解:

final修饰变量

这个变量只能使用一次=赋值, 常量

小结:

final修饰变量:
不管是局部变量还是成员变量都只能使用一次=赋值

课堂代码

public class Demo08 {
    public static void main(String[] args) {
        // 1.final修饰局部变量:这个变量只能使用一次=赋值
        final int a = 10;
        // a = 20;

        final Person p = new Person();
        // p = new Person();
        p.age = 18;
        p.age = 19;
        p.age = 20;
        // 替换快捷键: ctrl + r

        // c是在for循环外部定义的加了final修饰.这个变量c只能使用一次=赋值,二for循环了10次,赋值了10次不合格
        /*final int c = 0;
        for (int i = 0; i < 10; i++) {
            c = i;
            System.out.println(c);
        }*/

        // 变量c是定义在for循环的循环体中, 循环体中的变量,每次循环都会重新生成,每次循环结束循环体中的变量会被销毁
        for (int i = 0; i < 10; i++) {
            final int c = i;
            System.out.println(c);
        }
    }
}
class Person {
    int age;
}

public class Student {
    // 2.final修饰成员变量,这个变量只能使用一次=赋值
    // 2.1 方案一:立马赋值
    final int num = 10;
    final int num2;

// 方案二:在每个构造方法中赋值一次
    public Student() {
        num2 = 20;
        // num2 = 40;
    }

    public Student(String x) {
        num2 = 30;
    }
}

14单例设计模式

正常情况下一个类可以创建多个对象，有时候我们想在整个程序运行过程中，让一个类只产生一个对象。怎么办呢？

目标:学习单例设计模式

单例设计模式的概念/作用：

单例设计模式让整个应用程序某个类只能产生一个对象

单例设计模式的分类：

1.饿汉式单例
2.懒汉式单例

单例设计模式实现步骤：

1.将构造方法私有
2.本类自己创建一个对象,使用静态的成员变量来保存
3.提供一个方法,返回这个唯一的对象给别人使用

小结:

1.单例模式的作用:
让某个类在整个程序中只有唯一一个对象.

2.实现饿汉式单例的步骤:
1.将构造方法私有
2.创建本类的对象,使用static的成员变量保存
3.提供一个static的方法,返回这个对象唯一的对象给别人使用

课堂代码

// 定义音乐播放器单例(饿汉式)
public class AudioPlayer {
    // 1.将构造方法私有
    private AudioPlayer() {
    }

    // static的成员变量是在类加载的时候就会创建好(早)

    // 2.本类自己创建一个对象,使用静态的成员变量来保存
    private static AudioPlayer player = new AudioPlayer();

    // 3.提供一个方法,返回这个唯一的对象给别人使用
    public static AudioPlayer getInstance() {
        return player;
    }
}

// 视频播放器(懒汉式)
public class VideoPlayer {
    // 1.将构造方法私有
    private VideoPlayer() {
    }
    // 2.本类自己创建一个对象,使用静态的成员变量来保存
    private static VideoPlayer player;

    // 3.提供一个方法,返回这个唯一的对象给别人使用
    public static VideoPlayer getInstance() {
        // 如果对象还没有值
        if (player == null) {
            // 就创建一个对象
            player = new VideoPlayer();
        }
        // 懒汉式存在线程安全问题.后面会学多线程,会解决线程安全问题
        return player;
    }
}

public class Demo14 {
    public static void main(String[] args) {
        AudioPlayer a1 = AudioPlayer.getInstance();
        AudioPlayer a2 = AudioPlayer.getInstance();
        AudioPlayer a3 = AudioPlayer.getInstance();

        System.out.println("a1 = " + a1);
        System.out.println("a2 = " + a2);
        System.out.println("a3 = " + a3);

        // 视频播放器(懒汉式)
        VideoPlayer vp1 = VideoPlayer.getInstance();
        VideoPlayer vp2 = VideoPlayer.getInstance();
        VideoPlayer vp3 = VideoPlayer.getInstance();
        System.out.println("vp1 = " + vp1);
        System.out.println("vp2 = " + vp2);
        System.out.println("vp3 = " + vp3);

        Runtime.getRuntime();
    }
}

15枚举_不使用枚举存在的问题

不使用枚举存在的问题：

可以给性别传入任意的字符串，导致性别是非法的数据，不安全。

课堂代码

public class Demo15 {
    public static void main(String[] args) {
        String ss = "男";

        // 创建Person对象
        // 不使用枚举存在的问题,因为性别是String,
        // 我们随便传什么字符串都可以.其实不符合性别的要求
        Person p1 = new Person("凤姐", "摩托车");
        p1.show();
    }
}

public class Person {
    private String name;
    private String sex;

    public Person() {
    }

    public Person(String name, String sex) {
        this.name = name;
        this.sex = sex;
    }

    public void show() {
        System.out.println(name + "," + sex);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
}

16枚举介绍

目标:学习枚举的定义和使用

枚举的概念:

枚举可以认为是特殊的类,枚举表示几个固定的值

枚举的格式:

enum 枚举名 {
变量名1,变量名2;
}

枚举的使用:

枚举名.成员变量名;

枚举的应用场景:

只有几个固定值的场景

星期
月份
四季
方向

小结:

枚举的格式:
enum 枚举名 {
变量名1, 变量名2;
}

枚举的使用:
枚举名.变量名;

课堂代码

public enum Sex {
    // 男性  女性
    MALE, FEMALE, YAO;
}

public class Person {
    private String name;
    private Sex sex;

    public Person() {
    }

    public Person(String name, Sex sex) {
        this.name = name;
        this.sex = sex;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Sex getSex() {
        return sex;
    }

    public void setSex(Sex sex) {
        this.sex = sex;
    }
}


public class Demo16 {
    public static void main(String[] args) {
        // String s = "a";

        // 定义一个枚举变量
        Sex s1 = Sex.MALE;

        // 创建人类
        Person p = new Person("凤姐", Sex.FEMALE);
    }
}

17枚举的深入

目标:研究枚举的底层

反编译工具

.java源代码 -> 编译javac -> .class字节码文件 -> java运行

.class字节码文件 -> 反编译工具 -> .java源代码

枚举的本质是一个类. 是一个多例
我们在枚举中定义的变量,最终会创建对象并赋值

枚举本质是一个类,可以添加成员变量,成员方法

小结:

枚举的本质是一个类,这个类只创建几个对象.(多例)
枚举可以添加成员变量,构造方法,成员方法

课堂代码

// 星期的枚举
public enum WeekDay {
    // 星期一,星期五,星期天
    MON(1), FRIDAY(5), SUN(7);

    // 枚举本质是一个类,可以添加成员变量,成员方法
    private int num;
    WeekDay(int num) {
        this.num = num;
    }

    public int getNum() {
        return num;
    }
}

// 枚举的本质是一个类. 是一个多例
/*
public final class WeekDay extends Enum {
	public static final WeekDay MON = new WeekDay("MON", 0);
	public static final WeekDay FRIDAY = new WeekDay("FRIDAY", 1);
	public static final WeekDay SUN = new WeekDay("SUN", 2);

	private WeekDay(String s, int i)
	{
		super(s, i);
	}
}
 */
 
 public class Demo17 {
    public static void main(String[] args) {
        WeekDay w = WeekDay.SUN;
        System.out.println(w.getNum());
    }
}

18总结

写出定义接口的格式

interface 接口名 {
抽象方法
}

写出类实现接口的格式

class 类名 implements 接口名1, 接口名2 {
重写抽象方法;
}

说出接口中成员的特点

接口中的成员方法默认添加:public abstract
接口中的成员变量默认添加:public static fianl

描述final修饰的类的特点

这个类不能被继承(太监)

描述final修饰的方法的特点

这个方法不能被子类重写

能够说出单例设计模式的好处

使用单例能够保证这个类在整个程序中只有一个对象

能够定义枚举

enum 枚举名 {
成员变量, 成员变量;
}

多例)
枚举可以添加成员变量,构造方法,成员方法

课堂代码

// 星期的枚举
public enum WeekDay {
    // 星期一,星期五,星期天
    MON(1), FRIDAY(5), SUN(7);

    // 枚举本质是一个类,可以添加成员变量,成员方法
    private int num;
    WeekDay(int num) {
        this.num = num;
    }

    public int getNum() {
        return num;
    }
}

// 枚举的本质是一个类. 是一个多例
/*
public final class WeekDay extends Enum {
	public static final WeekDay MON = new WeekDay("MON", 0);
	public static final WeekDay FRIDAY = new WeekDay("FRIDAY", 1);
	public static final WeekDay SUN = new WeekDay("SUN", 2);

	private WeekDay(String s, int i)
	{
		super(s, i);
	}
}
 */
 
 public class Demo17 {
    public static void main(String[] args) {
        WeekDay w = WeekDay.SUN;
        System.out.println(w.getNum());
    }
}