Java接口(Interface)的使用和基础知识的讲解

一、接口的基本概念

接口是Java中一种完全抽象的类型，用于定义类必须实现的行为规范（方法签名）。核心特点：

• 纯抽象（Java 8前）：只包含抽象方法和常量
• 行为契约：定义"做什么"，不定义"怎么做"
• 多继承支持：类是单继承，但可多实现接口

二、接口定义语法

1. 基础语法

[访问修饰符] interface 接口名称 {
    // 常量声明 (隐式 public static final)
    // 抽象方法 (隐式 public abstract)
    // 默认方法 (Java 8+)
    // 静态方法 (Java 8+)
    // 私有方法 (Java 9+)
}

示例：

public interface Drawable {
    // 常量（自动为 public static final）
    String COLOR = "Black";

    // 抽象方法（自动为 public abstract）
    void draw(); 
}

2. 核心组成部分

(1) 常量

接口中声明的变量默认是 public static final（公共、静态、不可变）的常量。必须在声明时初始化，且不能被修改。

语法：

type CONSTANT_NAME = value;

特点：

• 隐式修饰符：public static final（即使省略也生效）
• 命名规范：全大写字母 + 下划线
• 必须初始化

示例：

public interface Physics {
    // 常量声明
    double LIGHT_SPEED = 299792458;  // 等同于 public static final double LIGHT_SPEED = ...;
    String UNIT = "m/s";
}

使用：

System.out.println("光速: " + Physics.LIGHT_SPEED + " " + Physics.UNIT);
// 输出: 光速: 2.99792458E8 m/s

(2) 抽象方法

没有方法体的方法声明，要求实现类必须提供具体实现。默认修饰符为 public abstract。

语法：

returnType methodName(parameters);

特点：

• 隐式修饰符：public abstract
• 不能有方法体（没有 {}）
• 实现类必须覆盖所有抽象方法

示例：

public interface Animal {
    // 抽象方法
    void makeSound();
    int getLegCount();
}

实现类：

class Dog implements Animal {
    @Override
    public void makeSound() {
        System.out.println("汪汪!");
    }
    
    @Override
    public int getLegCount() {
        return 4;
    }
}

(3) 默认方法 (Java 8+)

使用 default 关键字声明的方法，包含具体实现。实现类可选择继承或重写。

语法：

default returnType methodName(parameters) {
    // 方法体
}

特点：

• 解决接口升级问题：向已有接口添加新方法而不破坏现有实现
• 可被实现类继承或重写
• 支持多继承（解决默认方法冲突需重写）

示例：

public interface Payment {
    // 抽象方法
    void processPayment(double amount);
    
    // 默认方法
    default void refund(double amount) {
        System.out.println("退款处理中: ¥" + amount);
        logRefund(amount);  // 调用私有方法
    }
    
    private void logRefund(double amount) { /* ... */ }
}

使用：

class CreditCardPayment implements Payment {
    @Override
    public void processPayment(double amount) {
        System.out.println("信用卡支付: ¥" + amount);
    }
    // 继承默认的refund()方法
}

// 调用
Payment p = new CreditCardPayment();
p.refund(100);  // 输出: 退款处理中: ¥100

(4) 静态方法 (Java 8+)

使用 static 关键字声明的方法，属于接口本身，只能通过接口名调用。接口中的静态方法（包括类的静态方法）不能被重写（Override）。这是由静态方法的本质特性决定的。

语法：

static returnType methodName(parameters) {
    // 方法体
}

特点：

• 不能被实现类继承或重写
• 不参与多态行为
• 用于工具方法/工厂方法

示例：

public interface MathUtils {
    // 静态方法
    static int max(int a, int b) {
        return a > b ? a : b;
    }
}

使用：

int maximum = MathUtils.max(7, 12);  // 通过接口名调用
System.out.println("最大值: " + maximum);  // 输出: 12

三、接口核心特性

四、接口的使用方式

在Java中，接口不能直接实例化使用，必须通过实现类（或匿名内部类、Lambda表达式）来间接使用。以下是详细解释和示例：

1. 接口无法直接实例化

interface MyInterface {
    void myMethod();
}

public class Main {
    public static void main(String[] args) {
        // 错误！接口不能直接实例化
        MyInterface obj = new MyInterface(); // 编译报错
    }
}

2.正确使用方式

方式1：通过实现类（implements）

class MyImplementation implements MyInterface {
    @Override
    public void myMethod() {
        System.out.println("方法已实现");
    }
}

public class Main {
    public static void main(String[] args) {
        MyInterface obj = new MyImplementation(); // 通过实现类实例化
        obj.myMethod(); // 输出: "方法已实现"
    }
}

 方式2：匿名内部类（无需显式继承）

public class Main {
    public static void main(String[] args) {
        MyInterface obj = new MyInterface() {
            @Override
            public void myMethod() {
                System.out.println("匿名内部类实现");
            }
        };
        obj.myMethod(); // 输出: "匿名内部类实现"
    }
}

方式3：Lambda表达式（仅适用于函数式接口）

@FunctionalInterface // 确保是单方法接口
interface MyInterface {
    void myMethod();
}

public class Main {
    public static void main(String[] args) {
        MyInterface obj = () -> System.out.println("Lambda实现");
        obj.myMethod(); // 输出: "Lambda实现"
    }
}

3. 关键规则总结

五、接口继承

接口可多继承其他接口：

interface A { void methodA(); }
interface B { void methodB(); }

interface C extends A, B { // 接口多继承
    void methodC();
}

class D implements C {
    // 需实现A、B、C所有方法
}

六、接口 vs 抽象类

七.接口使用的完整示例

// 接口定义
interface Payment {
    double MIN_PAYMENT = 10.0; // 常量
    
    void pay(double amount);   // 抽象方法
    
    default void verify() {    // 默认方法
        System.out.println("支付验证通过");
    }
    
    static String getCurrency() { // 静态方法
        return "CNY";
    }
}

// 实现类
class Alipay implements Payment {
    @Override
    public void pay(double amount) {
        System.out.printf("支付宝支付: %.2f %s\n", 
                         amount, Payment.getCurrency());
    }
}

// 使用
public class Main {
    public static void main(String[] args) {
        Payment p = new Alipay();
        p.verify();
        p.pay(199.99);
        System.out.println("最小支付金额: " + Payment.MIN_PAYMENT);
    }
}