概述
我们已经学完了抽象类，抽象类中可以用抽象方法，也可以有普通方法，构造方法，成员变量等。那么什么是接口呢？接口是更加彻底的抽象，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最新版CSDN大礼包：《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最新版CSDN大礼包：《AGI大模型学习资源包》免费分享
