Java—接口

不懒的懒羊羊.

787人浏览 · 2025-10-28 22:12:37

不懒的懒羊羊. · 2025-10-28 22:12:37 发布

1、接口概述

Java提供了一个关键字interface定义出接口。

接口的格式

public interface 接口名{

// 成员变量（常量）

// 成员方法（抽象方法）

}

A 接口

public interface A {
    //在JDK8之前，接口中只能定义常量和抽象方法
    //1、常量：接口中定义可以省略public static final不写，默认会加上去。
    String SCHOOL_NAME = "清华大学";
    //public static final String SCHOOL_NAME1 = "清华大学";
    
    //2、抽象方法：接口中定义可以省略public abstract不写，默认会加上去。
    //public abstract void show();
    void show();
}

注意：接口不能创建对象

接口是用来被实现(implements)的，实现接口的类称为实现类，一个类可以同时实现多个接口。

实现类的格式：

修饰符 class 实现类列类名 implements 接口1，接口2，接口3， .....{

//实现类实现多个接口，必须重写全部接口的全部抽象方法，

//否则实现类需要定义成抽象类。

}

A类

public interface A {
    //在JDK8之前，接口中只能定义常量和抽象方法
    //1、常量：接口中定义可以省略public static final不写，默认会加上去。
    String SCHOOL_NAME = "清华大学";
    //public static final String SCHOOL_NAME1 = "清华大学";

    //2、抽象方法：接口中定义可以省略public abstract不写，默认会加上去。
    //public abstract void show();
    void show();
}

B类

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

        //接口不能创建对象
        //实现类实现多个接口，必须重写接口中所有抽象方法，否则这个类必须定义成抽象类
        C c = new C();
        c.show();
        c.run();
    }
}

class C implements A,B {
    @Override
    public void show() {
        System.out.println("show()");
    }
    @Override
    public void run() {
        System.out.println("run()");
    }
}
/*
show()
run()
 */

Test类

public class Test {
    public static void main(String[] args) {
        C c = new C();
        c.show();
        c.run();
    }
}

class C implements A,B {
    @Override
    public void show() {
        System.out.println("show()");
    }
    @Override
    public void run() {
        System.out.println("run()");
    }
}
/*
show()
run()
 */

2、接口的好处

弥补了类单继承的不足，一个类同时可以实现多个接口，使类的角色更多，功能更强大。
让程序可以面向接口编程，这样程序员就可以灵活方便的切换各种业务实现（更利于程序解耦合）。

Test类：理解接口的好处

public class Test {
    public static void main(String[] args) {
        //目标：去理解Java设计接口的好处，用处
        //接口弥补了类单继承的不足，可以让类拥有更多角色，类的功能更强大。
        People p = new Student();
        Driver d = new Student();  //多态
        BoyFriend bf = new Student();

        //2、接口可以实现面向接口编程，更有利于解耦合
        Driver d1 = new Teacher();  //右侧可以换成Student有利于解耦合
    }
}
interface Driver{} //司机类
interface BoyFriend{} //BoyFriend类
class People{} //人类

class Student extends People implements Driver,BoyFriend{}

class Teacher  implements Driver,BoyFriend{}

3、接口的综合小案例

Student 类

public class Student {
    private String name;
    private String sex;
    private double Score;

    public Student(String name, String sex, int Score) {
        this.name = name;
        this.sex = sex;
        this.Score = Score;
    }
    private Student() {}

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

    public double getGrade() {
        return Score;
    }

    public void setGrade(int grade) {
        this.Score = grade;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", Score=" + Score +
                '}';
    }
}

ClassDataInter 类

public interface ClassDataInter {
    void printAllStudentInfos();
    void printStudentAvgScore();
}

ClassDataInterImpl1 类

public class ClassDataInterImpl1 implements ClassDataInter {
    Student[] students;
    public ClassDataInterImpl1(Student[] students) {
        this.students = students;
    }

    @Override
    public void printAllStudentInfos() {
        //定义第一套实现类，实现接口：实现打印全部学生信息，打印平均分
        for (int i = 0; i < students.length; i++) {
            System.out.println(students[i]);
        }
    }

    @Override
    public void printStudentAvgScore() {
        double sum = 0;
        for (int i = 0; i < students.length; i++) {
            sum += students[i].getGrade();
        }
        System.out.println("平均分：" + sum / students.length);
    }
}

ClassDataInterImpl2 类

public class ClassDataInterImpl2 implements ClassDataInter {
    //实现接口：实现打印全部学生信息（打印男女人数），打印平均分（去掉最高分和最低分）
    Student[] students;
    public ClassDataInterImpl2(Student[] students) {
        this.students = students;
    }
    @Override
    public void printAllStudentInfos() {
        //实现接口：实现打印全部学生信息（打印男女人数），打印平均分（去掉最高分和最低分）
        int manNum = 0;
        int womanNum = 0;
        for (int i = 0; i < students.length; i++) {
            if(students[i].getSex().equals("男")){
                manNum++;
            }else{
                womanNum++;
            }
            System.out.println(students[i]);
        }
        System.out.println("男性人数是：" + manNum);
        System.out.println("女性人数是：" + womanNum);

    }

    @Override
    public void printStudentAvgScore() {
        //打印平均分（去掉最高分和最低分）
        double max = students[0].getGrade();
        double min = students[0].getGrade();
        for (int i = 0; i < students.length; i++) {
            if (students[i].getGrade() > max) {
                max = students[i].getGrade();
            }
            if (students[i].getGrade() < min) {
                min = students[i].getGrade();
            }
        }
        double sum = 0;
        for (int i = 0; i < students.length; i++) {
            sum += students[i].getGrade();
        }
        System.out.println("平均分是：" + (sum - max - min) / (students.length - 2));

    }
}

Test类

public class Test {
    public static void main(String[] args) {
        //目标：完成接口小案例
        //1、定义学生类，创建学生对象，封装学生数据，才能交给别人处理学生数据
        //2、准备学生数据，目前我们自己造一些数据
        Student [] allstudents = new Student[10];
        allstudents[0] = new Student("张三","男",77);
        allstudents[1] = new Student("李四","男",66);
        allstudents[2] = new Student("王五","女",89);
        allstudents[3] = new Student("赵六","男",88);
        allstudents[4] = new Student("孙七","不",80);
        allstudents[5] = new Student("周八","男",64);
        allstudents[6] = new Student("吴九","男",60);
        allstudents[7] = new Student("郑十","女",95);
        allstudents[8] = new Student("王十一","男",100);
        allstudents[9] = new Student("王十二","女",99);
        //3、提供两套业务实现方案，支持灵活切换（解耦合）：面向接口编程
        //---定义一个接口（规范思想）：必须完成打印全部学生信息，打印平均分
        //---定义第一套实现类，实现接口：实现打印全部学生信息，打印平均分
        //---定义第二套实现类，实现接口：实现打印全部学生信息（打印男女人数），打印平均分（去掉最高分和最低分）

        //创建接口实现类对象
        ClassDataInter cdi1 = new ClassDataInterImpl1(allstudents);
        cdi1.printAllStudentInfos();
        cdi1.printStudentAvgScore();
    }
}

4、接口新增的三种方法

JDK 8开始，接口新增了三种形式的方法。

接口中为什么新增了方法？增强了接口的能力，更便于项目的扩展和维护。

5、接口的几个注意事项

接口与接口可以多继承：一个接口可以同时继承多个接口[重点]。

一个接口继承多个接口，如果多个接口中存在方法冲突，则此时不支持继承，也不支持多实现。

一个类继承了父类，又同时实现了接口，如果父类中和接口中有相同的默认方法，实现类会优先用父类。

一个类实现了多个接口，如果多个接口中存在同名的默认方法，可以不冲突，这重写该方法即可。

public class Test {
    public static void main(String[] args) {
        CC c = new CC();
        c.test1();
        f f1 = new f();
        f1.test1();


    }
}

//4、一个类实现了多个接口，如果多个接口中存在同名的默认方法，可以不冲突，这重写该方法即可。
interface s{
    default void test1(){
        System.out.println("s接口中的Test1方法");
    }
}
interface t{
    default void test1(){
        System.out.println("t接口中的Test1方法");
    }
}
class f implements s,t{
    @Override
    public void test1() {
        System.out.println("实现类中的Test1方法");
    }
}

//3.一个类继承了父类，又同时实现了接口，如果父类中和接口中有相同的默认方法，实现类会优先用父类
interface  AA{
    default void test1(){
        System.out.println("接口中的Test1方法");
    }
}
class BB {
    void test1(){
        System.out.println("父类中的Test1方法");
    }
}
class CC extends BB implements AA{

}

//2、一个接口继承多个接口，如果多个接口中存在方法冲突，则此时不支持继承，也不支持多实现。
interface A1{
    void test1();
}
interface B1{
    int test1();
}
//如果两个方法完全一样，就不会报错，方法合并
//如果名字一样，参数不同或返回类型不同，就会报错
//interface C1 extends A1,B1{  //报错
//    void test3();
//}

//1、接口与接口可以多继承：一个接口可以同时继承多个接口[重点]。
//类和类:单继承一个类只能继承一个父类。
//类与接口：多实现，一个类可与同时实现多个接口。
//接口与接口：多继承，一个接口可以同时继承多个接口。
interface A{
    void test1();
}
interface B{
    void test2();
}
interface C extends A,B{  //多继承，一个接口可以同时继承多个接口。
    void test3();
}
class D implements A,B,C{  //多实现，一个类可与同时实现多个接口。
    @Override
    public void test1() {
    }

    @Override
    public void test2() {
    }

    @Override
    public void test3() {
    }
}

6、抽象类和接口的区别

7、综合小案例

JD 类:家电类

public class JD implements  Switch{

    private String name;
    private boolean status;       //状态，开关

    //构造器
    public JD(){}

    public JD(String name, boolean status) {
        this.name = name;
        this.status = status;
    }



    public String getName() {
        return name;
    }

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

    public boolean isStatus() {
        return status;
    }

    public void setStatus(boolean status) {
        this.status = status;
    }

    @Override
    public void press() {
        //控制当前设备的开关
        status = !status;
    }
}

Lamp 类：吊顶类

public class Lamp extends JD{
    public Lamp(String name, boolean status) {
        super(name, status);
    }

}

WashMachine 类：洗衣机类

public class WashMachine extends JD{
    public WashMachine(String name, boolean status) {
        super(name, status);
    }
}

TV类：电视机类

public class TV extends JD{
    public TV(String name, boolean status ) {
        super(name, status);
    }
}

Air 类：冰箱类

public class Air extends JD{
    public Air(String name, boolean status) {
        super(name, status);
    }

}

Switch 接口：控制电器的开关

public interface Switch {
    void press(); //按压
}

SmartControl 类：单例类，智能控制系统

public class SmartControl {
    private static SmartControl instance = new SmartControl();
    private SmartControl(){}

    public static SmartControl getInstance(){
        return instance;
    }
     public void control(JD jd){
         System.out.println(jd.getName()+"开关状态："+ (jd.isStatus()?"关":"开"));
         jd.press();
         System.out.println(jd.getName()+"开关已经："+ (jd.isStatus()?"关":"开"));
     }

     //打印all 设备状态
    public  void printStatus(JD []jd){
        for (int i = 0; i < jd.length; i++){
            System.out.println((i + 1) +jd[i].getName()+"开关状态："+ (jd[i].isStatus()?"关":"开"));
        }
    }
}

Test类：测试类

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        //目标：面向对象编程实现智能家居控制系统
        //角色:设备（吊灯，电视机，洗衣机，冰箱...）
        //设备功能：开关
        //谁控制：智能控制系统（单例对象）控制调用设备的开关

        //1.定义设备类：创建设备类
        //2.准备这些设备对象，放在对象数组中
        JD[] jds = new JD[4];
        jds[0] = new Lamp("吊灯",false);
        jds[1] = new TV("电视机",false);
        jds[2] = new WashMachine("洗衣机",false);
        jds[3] = new Air("冰箱",false);
        //3、为每个设备创建一个开关对象

        //4、创建智能控制系统类，并创建对象
        SmartControl sC = SmartControl.getInstance();


        Scanner sc = new Scanner(System.in);

        while (true){
            //打印设备状态
            System.out.println("--------------------------");
            sC.printStatus(jds);
            System.out.println("请输入设备编号：");
            int e = sc.nextInt();
            switch ( e){
                case 0:
                    return;
                case 1:
                    sC.control(jds[0]);
                    break;
                case 2:
                    sC.control(jds[1]);
                    break;
                case 3:
                    sC.control(jds[2]);
                    break;
                case 4:
                    sC.control(jds[3]);
                    break;
                default:
                    System.out.println("输入错误");
                    break;
            }
        }
    }
}

AI Agent技术社区

Agent 垂直技术社区，欢迎活跃、内容共建。

更多推荐

SeedVR2终极指南：如何用单步扩散模型实现专业级视频修复

还在为老旧视频的模糊画质而烦恼吗？面对抖动严重的监控录像或褪色的家庭影像，你是否曾希望有一种简单高效的修复方案？SeedVR2正是为解决这些痛点而生的一站式视频修复工具。作为字节跳动推出的先进视频修复模型，它能够在单步推理中实现专业级的视频质量提升，彻底改变了传统视频修复的工作流程。## 核心价值：为什么选择SeedVR2进行视频修复？**传统视频修复的三大瓶颈**：1. **计算成本高

AI Agent技术社区

深度解析Amlogic S9xxx电视盒子Armbian系统：从闲置设备到Linux服务器的终极实战指南

你是否拥有一台闲置的Amlogic S9xxx系列电视盒子？想让它摆脱单一的视频播放功能，变身为功能强大的Linux服务器、开发平台或家庭媒体中心？本指南将为你详细解析如何通过Armbian系统实现这一转变，让你的电视盒子重获新生，成为高性能的Linux设备。Armbian系统基于Debian/Ubuntu构建，专为ARM芯片优化，提供了完整的Linux生态支持。## 🎯 核心价值与独特优势

AI Agent技术社区

CANN/runtime Event管理API

本章节描述 CANN Runtime 的 Event 管理接口，用于事件的创建、记录、同步、计时及 IPC 跨进程共享。- [`aclError aclrtCreateEvent(aclrtEvent *event)`](#aclrtCreateEvent)：创建Event，创建出来的Event可用于统计两个Event之间的耗时、多Stream之间的任务同步等场景。- [`aclError