一、基本介绍
接口是什么?
接口就是给出一些没有实现的方法,封装到一起,到某个类要实现的时候,再根据具体情况把这些方法写出来。
语法:
interface 接口名 {
// 属性
// 方法
}
代码示例:
package interface_;
public interface inter01 {
String name = "哦哦哦";
// 接口中的属性默认是 public static final,这三个修饰符都可以省略
void say();
// 接口中的方法默认是 public abstract,abstract 和 public 都可以省略
}
实现接口:
class 类名 implements 接口 {
// 自己属性;
// 自己方法;
// 必须实现的接口的抽象方法;
}
完整示例:
package interface_;
public class inter01_1 {
public static void main(String[] args) {
inter_1 inter1 = new inter_1();
inter1.cry();
inter1.say();
}
}
class inter_1 implements inter01 {
// 本类的属性与方法
String name = "呜呜呜";
public void cry() {
System.out.println(name);
}
// 实现接口的抽象方法
@Override
public void say() {
System.out.println(inter01.name);
}
}
二、注意事项和细节
1. 接口不能被实例化
inter01 i = new inter01(); // 错误!不能new
2. 接口中的方法都是public的
void aaa(); // 实际是 public abstract void aaa();
3. 普通类实现接口,必须实现所有方法
💡 快捷键 Alt + Enter 可以快速补全对应接口的所有方法
4. 抽象类实现接口,可以不实现接口的方法
abstract class AbstractClass implements inter01 {
// 抽象类可以不实现接口的方法
}
5. 一个类可以实现多个接口
interface IA { void I2(); }
interface IB { void I3(); }
class interA implements IA, IB {
@Override
public void I2() {}
@Override
public void I3() {}
}
6. 接口中的属性只能是final
int a = 1; // 实际是 public static final int a = 1;
7. 接口中属性的访问形式
接口名.属性名 // 推荐方式
8. 接口可以继承多个别的接口(但不能继承类)
interface IA { void I2(); }
interface IB { void I3(); }
interface IC extends IA, IB {} // 继承两个接口
9. 接口的修饰符
- 只能是 public 和默认(和类一样)
三、继承类 + 实现接口
生活例子
现实中的小猴子:
- 天生就会:爬树、吃饭(从猴妈妈那里继承来的)
- 后天学会:飞翔、游泳(额外获得的技能)
对应到Java:
- 继承:把父类的东西"传"给子类(省得重复写)
- 接口:给类"附加"额外的能力(不破坏原来的继承关系)
代码示例
package interface_;
public class Test {
public static void main(String[] args) {
LittleMonkey littleMonkey = new LittleMonkey("小猴子");
littleMonkey.climb_tree(); // 继承自Monkey
littleMonkey.eat(); // 继承自Monkey
littleMonkey.fly(); // 实现Bird接口
littleMonkey.swim(); // 实现fish接口
}
}
// 猴子父类:提供初始技能
class Monkey {
public void climb_tree() {
System.out.println("会爬树");
}
public void eat() {
System.out.println("会吃饭");
}
}
/**
* 小猴子类
* 继承Monkey类获得基础技能
* 实现Bird和fish接口获得额外技能
*/
class LittleMonkey extends Monkey implements Bird, fish {
private String name;
public LittleMonkey(String name) {
this.name = name;
}
// 重写实现两个接口的方法
@Override
public void fly() {
System.out.println(name + "现在会飞了");
}
@Override
public void swim() {
System.out.println(name + "现在会游泳了");
}
}
interface Bird {
void fly();
}
interface fish {
void swim();
}
什么时候用这个组合?
| 有明确的父子关系(猴子→动物) | 用继承 |
| 想给类加多个技能(会飞、会游、会跑) | 用接口 |
| 既要基础能力,又要额外技能 | 继承 + 接口 |
四、实现接口 VS 继承类
接口和继承解决的是不同的问题:
| 数量 | 单继承(只能一个父类) | 多实现(可以多个接口) |
| 方法实现 | 可以有具体实现 | 默认都是抽象 |
| 属性 | 实例变量 | public static final常量 |
| 使用场景 | is-a关系(是什么) | can-do关系(能做什么) |
小结:
- 当子类继承了父类,就自动拥有父类的功能
- 如果子类需要扩展功能,可以通过实现接口的方式扩展
- 可以理解实现接口是对Java单继承机制的一种补充
💡 继承是"亲爹给的",接口是"自己学的"
五、接口的多态特性
1. 接口多态
接口引用可以指向实现了接口的类的对象。
package interface_;
public class interface_poly01 {
public static void main(String[] args) {
// 编译类型是USB,用usb引用只能调用USB接口的方法
// 原有的phone方法无法使用
USB usb = new Phone();
USB usb1 = new Camera();
}
}
class Phone implements USB {
@Override
public void work() {
System.out.println("手机开机!!!");
}
public void call() {
System.out.println("打电话");
}
}
class Camera implements USB {
@Override
public void work() {
System.out.println("相机开机!!!");
}
}
interface USB {
void work();
}
核心规则:编译看左边,运行看右边
| USB usb | 只有 work() | call() |
| Phone phone | work() 和 call() | 无 |
2. 多态数组
给USB数组中存放Phone和Camera对象,Phone类还有一个特有的方法call()。遍历USB数组,如果是Phone对象,除了调用USB接口定义的方法外,还需要调用Phone特有方法。
package interface_;
public class interface_poly02 {
public static void main(String[] args) {
USB_[] usbs = new USB_[2];
usbs[0] = new Phone_();
usbs[1] = new Camera_();
for (int i = 0; i < usbs.length; i++) {
usbs[i].work(); // 多态调用
if (usbs[i] instanceof Phone_) {
((Phone_) usbs[i]).call(); // 向下转型,调用特有方法
}
}
}
}
class Phone_ implements USB_ {
public void call() {
System.out.println("打电话");
}
@Override
public void work() {
System.out.println("手机开机!!!");
}
}
class Camera_ implements USB_ {
public void crack() {
System.out.println("拍照");
}
@Override
public void work() {
System.out.println("相机开机!!!");
}
}
interface USB_ {
void work();
}
输出:
手机开机!!!
打电话
相机开机!!!
3. 多态传递
// 接口多态传递演示
interface IA {
void hi();
}
interface IB extends IA { // IB继承IA
void hello();
}
class Teacher implements IB {
@Override
public void hi() {
System.out.println("hi~~~");
}
@Override
public void hello() {
System.out.println("hello~~~");
}
}
public class Test {
public static void main(String[] args) {
// 子接口指向实现类对象
IB ib = new Teacher();
ib.hi(); // 可以访问IA的方法
ib.hello(); // 可以访问IB的方法
// 爷爷接口也能指向(多态传递)
IA ia = new Teacher();
ia.hi(); // 可以
// ia.hello(); // IA接口没有hello方法
}
}
六、为什么要用接口?
直接new Phone不好吗?
Phone phone = new Phone(); // 简单直接
答案是:不是为了"更好",而是为了"更灵活"
对比示例
// 不用接口:来一个设备写一个方法
public void usePhone(Phone p) { p.work(); }
public void useCamera(Camera c) { c.work(); }
public void useUDisk(UDisk u) { u.work(); }
// 用接口:一个方法通吃所有USB设备!
public void useDevice(USB d) { d.work(); }
接口的价值
| 灵活 | 同一个方法能处理不同设备 |
| 统一 | 所有USB设备用同一套规则 |
| 易扩展 | 加新设备不改旧代码 |
继承的价值主要在于:解决代码的复用性和可维护性
接口的价值主要在于:设计,设计好各种规范(方法),让其他类去实现这些方法
七、常见错误提醒
// 1. 接口不能new ❌
USB usb = new USB(); // 错误!接口不能实例化
// 2. 实现接口必须重写所有抽象方法 ❌
class Phone implements USB {
// 没写work()方法 → 编译错误
}
// 3. 接口引用不能调用子类特有方法 ❌
USB usb = new Phone();
usb.call(); // 错误!编译看左边
// 4. 接口属性不能修改 ❌
USB.name = "新名字"; // 错误!final常量
总结
| 接口 | 定义规范,只说不做 |
| 实现接口 | 类去实现规范,具体怎么做自己决定 |
| 继承+接口 | 继承得基础,接口得扩展 |
| 接口多态 | 同一个接口类型,指向不同对象,表现不同行为 |
| 编译看左边 | 左边类型决定能调什么方法 |
| 运行看右边 | 右边类型决定方法怎么执行 |





