Java接口详细教程，零基础小白到精通，收藏这篇就够了

概述

我们已经学完了抽象类，抽象类中可以用抽象方法，也可以有普通方法，构造方法，成员变量等。那么什么是接口呢？接口是更加彻底的抽象，JDK7之前，包括JDK7，接口中全部是抽象方法。接口同样是不能创建对象的。

把特有的方法(行为)写成接口,要用的时候调用接口就行了,除了狗和青蛙要用到游泳这个行为,当我们需要给多个类同时定义规则的时候,就需要用到接口

接口就是规则

定义格式

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

// 接口的声明：interface
// 接口名称：首字母大写，满足“驼峰模式”

接口与抽象类的异同

抽象类作为父类的,他是表示动物这一类事物,接口侧重于行为,是对行为的抽象

练习

测试类

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

        Frog f = new Frog("小青",18);
        f.eat();
        f.swim();
        System.out.println(f.getAge()+" "+f.getName());
        System.out.println("------------------");
        Dog d = new Dog("小黑",5);
        d.eat();
        d.swim();
        System.out.println(d.getAge()+" "+d.getName());
        System.out.println("------------------");
        Rabbit r = new Rabbit("小白",6);
        r.eat();
        System.out.println(r.getAge()+" "+r.getName());
    }
}

接口

package jiekou.demo01;
//定义一个接口
public interface Swim {
    //定义一个规则
    public abstract void swim();
}

父类Animal

package jiekou.demo01;

public abstract class Animal {
    private String name;
    private int age;

    public Animal() {
    }

    public Animal(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 abstract void eat();
}

子类Dog

public class Dog   extends Animal implements Swim{

    @Override
    public void eat() {
        System.out.println("狗在吃骨头");
    }

    @Override
    public void swim() {
        System.out.println("狗刨");
    }

    public Dog() {
    }

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

子类Frog

public class Frog  extends Animal implements Swim{
    @Override
    public void eat() {
        System.out.println("青蛙在吃虫子");
    }

    @Override
    public void swim() {
        System.out.println("青蛙在蛙泳");
    }

    public Frog() {
    }

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

子类兔子

public class Rabbit extends Animal {
    @Override
    public void eat() {
        System.out.println("兔子在吃胡萝卜");
    }

    public Rabbit() {
    }

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

接口成分的特点

在JDK7，包括JDK7之前，接口中的只有包含：抽象方法和常量

抽象方法

注意：接口中的抽象方法默认会自动加上public abstract修饰程序员无需自己手写！！ ​ 按照规范：以后接口中的抽象方法建议不要写上public abstract。因为没有必要啊，默认会加上。

常量

在接口中定义的成员变量默认会加上： public static final修饰。也就是说在接口中定义的成员变量实际上是一个常量。这里是使用public static final修饰后，变量值就不可被修改，并且是静态化的变量可以直接用接口名访问，所以也叫常量。常量必须要给初始值。常量命名规范建议字母全部大写，多个单词用下划线连接。

案例演示

public interface InterF {
    // 抽象方法！
    //    public abstract void run();
    void run();

    //    public abstract String getName();
    String getName();

    //    public abstract int add(int a , int b);
    int add(int a , int b);


    // 它的最终写法是：
    // public static final int AGE = 12 ;
    int AGE  = 12; //常量
    String SCHOOL_NAME = "黑马程序员";

}

实现接口的概述

类与接口的关系为实现关系，即类实现接口，该类可以称为接口的实现类，也可以称为接口的子类。实现的动作类似继承，格式相仿，只是关键字不同，实现使用 implements关键字。

实现接口的格式

/**接口的实现：
在Java中接口是被实现的，实现接口的类称为实现类。
实现类的格式:*/
class 类名 implements 接口1,接口2,接口3…{

}

类与接口基本实现案例

假如我们定义一个运动员的接口（规范），代码如下：

/**
接口：接口体现的是规范。
* */
public interface SportMan {
void run(); // 抽象方法，跑步。
void law(); // 抽象方法，遵守法律。
String compittion(String project); // 抽象方法，比赛。
}

接下来定义一个乒乓球运动员类，实现接口，实现接口的实现类代码如下：

package com.itheima._03接口的实现;
/**
 * 接口的实现：
 *    在Java中接口是被实现的，实现接口的类称为实现类。
 *    实现类的格式:
 *      class 类名 implements 接口1,接口2,接口3...{
 *
 *
 *      }
 * */
public class PingPongMan  implements SportMan {
    @Override
    public void run() {
        System.out.println("乒乓球运动员稍微跑一下！！");
    }

    @Override
    public void law() {
        System.out.println("乒乓球运动员守法！");
    }

    @Override
    public String compittion(String project) {
        return "参加"+project+"得金牌！";
    }
}

测试代码：

public class TestMain {
    public static void main(String[] args) {
        // 创建实现类对象。
        PingPongMan zjk = new PingPongMan();
        zjk.run();
        zjk.law();
        System.out.println(zjk.compittion("全球乒乓球比赛"));

    }
}

**//类和接口之间的关系
//实现类,可以单实现,也可以多实现,还可以在继承一个类的同时实现多个接口**

import jiekou.demo02.Inter;

//类和接口之间的关系
//实现类,可以单实现,也可以多实现,还可以在继承一个类的同时实现多个接口
public class Interlmpl implements Inter1, Inter2 {
    @Override
    public void method1() {

    }

    @Override
    public void method2() {

    }

    @Override
    public void method3() {

    }

    @Override
    public void method4() {

    }
}

**//接口和接口之间的是继承关系,可以单继承,也可以多继承
//细节:如果实现类实现了最下面的子接口,那么就就需要重写所有的抽象方法**

package jiekou.demo04;

public class Interlmpl  implements  Inter3{
    @Override
    public void method1() {

    }

    @Override
    public void method2() {

    }
}

练习

测试类

public class Test {
    public static void main(String[] args) {
        PingPangSproter p = new PingPangSproter("张三",18);
        p.study();
        p.SpeakEnglish();
        System.out.println(p.getName()+" "+p.getAge());
        System.out.println("-------------------");
        BasketballSproter b = new BasketballSproter("李四",20);
        b.study();
        System.out.println(b.getName()+" "+b.getAge());
        System.out.println("-------------------");
        PingPangCoath a = new PingPangCoath("王五",18);
        a.teach();
        a.SpeakEnglish();
        System.out.println(a.getName()+" "+a.getAge());
        System.out.println("-------------------");
        BasketballSporterCoath h = new BasketballSporterCoath("赵六",20);
        h.teach();
        System.out.println(h.getName()+" "+h.getAge());
    }
}

子类运动员

public abstract class Sporter extends Person {
    public Sporter() {
    }

    public Sporter(String name, int age) {
        super(name, age);
    }
    public abstract void study();
}

子类教练

public abstract class Coath  extends Person{
    public Coath() {
    }

    public Coath(String name, int age) {
        super(name, age);
    }
    public abstract void teach();
}

子子类乒乓球运动员

public class PingPangSproter extends Sporter implements English {
    @Override
    public void SpeakEnglish() {
        System.out.println("乒乓球运动员在说英语");
    }

    @Override
    public void study() {
        System.out.println("乒乓球运动员在学打乒乓球");
    }

    public PingPangSproter() {
    }

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

子子类篮球运动员

public class BasketballSproter extends Sporter {
    @Override
    public void study() {
        System.out.println("篮球运动员在学打篮球");
    }

    public BasketballSproter() {
    }

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

子子类乒乓球教练

public class PingPangCoath  extends Coath implements  English{
    @Override
    public void teach() {
        System.out.println("乒乓球教练在教打乒乓球");
    }

    @Override
    public void SpeakEnglish() {
        System.out.println("乒乓球教练在说英语");
    }

    public PingPangCoath() {
    }

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

子子类篮球教练

public class BasketballSporterCoath extends Coath {
    @Override
    public void teach() {
        System.out.println("篮球教练在教打篮球");
    }

    public BasketballSporterCoath() {
    }

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

说英语接口

public interface English  {
    void SpeakEnglish();
}

结果

扩展：接口的细节

public interface Inter {
    /*
    接口中的默认方法的定义格式
    格式: public default 返回值类型 方法名(参数列表){ }
     */
    /*
    接口中的默认的注意事项:
    1.默认方法不是抽象方法,所以不强制被重写,但是如果被重写,重写的时候去掉default关键字
    2.public可以省略,default不能被省略
    3.如果实现了多个接口,多个接口中存在相同的名字的默认方法,子类就必须对该方法进行重写
     */
    public  abstract  void method();
    public default void show() {
        System.out.println("接口的默认方法-------show");
    }
}

public class Interlmpl  implements  Inter {
    @Override
    public void method() {
        System.out.println("实现类重写的抽象方法");
    }

    @Override
    public void show() {
        System.out.println("接口的默认方法-被重写------show");
    }
}

public class Test {
    public static void main(String[] args) {
        Interlmpl i=new Interlmpl();
        i.method();
        i.show();
    }
}

静态方法不能被重写

package jiekou.demo7;

public class Test {
    public static void main(String[] args) {
        //调用接口静态方法
        Inter.show();
        //调用实现类中的静态方法
        InterImpl.show();
    }
}

public class InterImpl  implements  Inter{

    @Override
    public void method() {
        System.out.println("InterImpl重写的抽象方法");
    }
    public  static void show(){
        System.out.println("InterImpl实现类里的静态方法-----show");
    }
}

public interface Inter {
    public static  void show(){
        System.out.println("Inter里的静态方法-----show");
    }
    public abstract void method();
}

子类把从父类继承下来的虚方法表里面的方法进行覆盖了,这才叫重写

第一个是默认的方法

第二个静态方法

接口可以理解为各种行为的规则,你想要某个javabean类拥有对应的行为,那就实现对应的接口

接口的多态

适配器原理

就是在实现类里面重写自己指定的方法

package jiekou.demo8;


public class Interlmpl  extends Temp{
    //我需要用到那个方法,就用哪个方法

    @Override
    public void method5() {
        System.out.println("主要用第五个");
    }
}

package jiekou.demo8;

public interface Inter {
    public abstract  void method1();
    public abstract  void method2();
    public abstract  void method3();
    public abstract  void method4();
    public abstract  void method5();
    public abstract  void method6();
    public abstract  void method7();
    public abstract  void method8();
    public abstract  void method18();
}

package jiekou.demo8;

public abstract class Temp  implements Inter {


    @Override
    public void method1() {

    }

    @Override
    public void method2() {

    }

    @Override
    public void method3() {

    }

    @Override
    public void method4() {

    }

    @Override
    public void method5() {

    }

    @Override
    public void method6() {

    }

    @Override
    public void method7() {

    }

    @Override
    public void method8() {

    }

    @Override
    public void method18() {

    }
}

Java程序员的退路到底在哪里？

说真的，这两年看着身边一个个搞Java、C++、前端、数据、架构的开始卷大模型，挺唏嘘的。大家最开始都是写接口、搞Spring Boot、连数据库、配Redis，稳稳当当过日子。

结果GPT、DeepSeek火了之后，整条线上的人都开始有点慌了，大家都在想：“我是不是要学大模型，不然这饭碗还能保多久？”

先给出最直接的答案：一定要把现有的技术和大模型结合起来，而不是抛弃你们现有技术！掌握AI能力的Java工程师比纯Java岗要吃香的多。

即使现在裁员、降薪、团队解散的比比皆是……但后续的趋势一定是AI应用落地！大模型方向才是实现职业升级、提升薪资待遇的绝佳机遇！

如何学习AGI大模型？

作为一名热心肠的互联网老兵，我决定把宝贵的AI知识分享给大家。 至于能学习到多少就看你的学习毅力和能力了 。我已将重要的AI大模型资料包括AI大模型入门学习思维导图、精品AI大模型学习书籍手册、视频教程、实战学习等录播视频免费分享出来。

因篇幅有限，仅展示部分资料，需要点击下方链接即可前往获取

2025最新版优快云大礼包：《AGI大模型学习资源包》免费分享**

一、2025最新大模型学习路线

一个明确的学习路线可以帮助新人了解从哪里开始，按照什么顺序学习，以及需要掌握哪些知识点。大模型领域涉及的知识点非常广泛，没有明确的学习路线可能会导致新人感到迷茫，不知道应该专注于哪些内容。

我们把学习路线分成L1到L4四个阶段，一步步带你从入门到进阶，从理论到实战。

L1级别:AI大模型时代的华丽登场

L1阶段：我们会去了解大模型的基础知识，以及大模型在各个行业的应用和分析；学习理解大模型的核心原理，关键技术，以及大模型应用场景；通过理论原理结合多个项目实战，从提示工程基础到提示工程进阶，掌握Prompt提示工程。

L2级别：AI大模型RAG应用开发工程

L2阶段是我们的AI大模型RAG应用开发工程，我们会去学习RAG检索增强生成：包括Naive RAG、Advanced-RAG以及RAG性能评估，还有GraphRAG在内的多个RAG热门项目的分析。

L3级别：大模型Agent应用架构进阶实践

L3阶段：大模型Agent应用架构进阶实现，我们会去学习LangChain、 LIamaIndex框架，也会学习到AutoGPT、 MetaGPT等多Agent系统，打造我们自己的Agent智能体；同时还可以学习到包括Coze、Dify在内的可视化工具的使用。

L4级别：大模型微调与私有化部署

L4阶段：大模型的微调和私有化部署，我们会更加深入的探讨Transformer架构，学习大模型的微调技术，利用DeepSpeed、Lamam Factory等工具快速进行模型微调；并通过Ollama、vLLM等推理部署框架，实现模型的快速部署。

整个大模型学习路线L1主要是对大模型的理论基础、生态以及提示词他的一个学习掌握；而L3 L4更多的是通过项目实战来掌握大模型的应用开发，针对以上大模型的学习路线我们也整理了对应的学习视频教程，和配套的学习资料。

二、大模型经典PDF书籍

书籍和学习文档资料是学习大模型过程中必不可少的，我们精选了一系列深入探讨大模型技术的书籍和学习文档，它们由领域内的顶尖专家撰写，内容全面、深入、详尽，为你学习大模型提供坚实的理论基础。（书籍含电子版PDF）

三、大模型视频教程

对于很多自学或者没有基础的同学来说，书籍这些纯文字类的学习教材会觉得比较晦涩难以理解，因此，我们提供了丰富的大模型视频教程，以动态、形象的方式展示技术概念，帮助你更快、更轻松地掌握核心知识。

四、大模型项目实战

学以致用 ，当你的理论知识积累到一定程度，就需要通过项目实战，在实际操作中检验和巩固你所学到的知识，同时为你找工作和职业发展打下坚实的基础。

五、大模型面试题

面试不仅是技术的较量，更需要充分的准备。

在你已经掌握了大模型技术之后，就需要开始准备面试，我们将提供精心整理的大模型面试题库，涵盖当前面试中可能遇到的各种技术问题，让你在面试中游刃有余。

因篇幅有限，仅展示部分资料，需要点击下方链接即可前往获取

2025最新版优快云大礼包：《AGI大模型学习资源包》免费分享