欢迎光临
我们一直在努力

接口/interface的简单理解

一、基本介绍

接口是什么?

接口就是给出一些没有实现的方法,封装到一起,到某个类要实现的时候,再根据具体情况把这些方法写出来。

语法:

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 继承类

接口和继承解决的是不同的问题:

特性继承(extends)接口(implements)
数量 单继承(只能一个父类) 多实现(可以多个接口)
方法实现 可以有具体实现 默认都是抽象
属性 实例变量 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常量


总结

概念一句话总结
接口 定义规范,只说不做
实现接口 类去实现规范,具体怎么做自己决定
继承+接口 继承得基础,接口得扩展
接口多态 同一个接口类型,指向不同对象,表现不同行为
编译看左边 左边类型决定能调什么方法
运行看右边 右边类型决定方法怎么执行
赞(0)
未经允许不得转载:171主机测评 » 接口/interface的简单理解
分享到: 更多 (0)

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址