Java接口：定义行为的"契约"

吃西红柿长大的番茄
59 阅读12分钟

引言：现实世界中的"标准接口"

想象一下各种电子设备：

  • 所有手机都用USB-C接口充电
  • 所有家电都用220V插座供电
  • 所有汽车都用汽油或电力作为能源 这些就是"标准接口"！在Java中，接口就像这些标准，它定义了一组行为规范，让不同的类可以遵循相同的"标准"。

一、什么是接口？

接口（Interface）是一种完全抽象的类，它只包含方法的声明，不包含方法的实现。可以把接口看作是：

  1. 契约/合同 → 规定类必须实现哪些方法
  2. 能力/角色 → 表示类具备什么能力
  3. 标准/规范 → 统一的操作方式

接口 vs 类：

特性类接口
方法可以有具体实现只有声明（Java 8前）
字段可以有各种字段只能是常量
继承只能继承一个类可以实现多个接口
实例化可以创建对象不能创建对象

二、接口的基本使用

2.1 声明和实现接口

// 1. 声明接口
interface Animal {
    // 接口中的方法默认是 public abstract
    void makeSound();  // 抽象方法
    void eat();        // 抽象方法
}

// 2. 实现接口（使用implements关键字）
class Dog implements Animal {
    // 必须实现接口中的所有方法
    @Override
    public void makeSound() {
        System.out.println("狗狗汪汪叫！");
    }
    
    @Override
    public void eat() {
        System.out.println("狗狗吃骨头");
    }
    
    // 可以有自己的方法
    void fetch() {
        System.out.println("狗狗捡球");
    }
}

class Cat implements Animal {
    @Override
    public void makeSound() {
        System.out.println("猫咪喵喵叫！");
    }
    
    @Override
    public void eat() {
        System.out.println("猫咪吃鱼");
    }
    
    void climbTree() {
        System.out.println("猫咪爬树");
    }
}

public class BasicInterface {
    public static void main(String[] args) {
        System.out.println("=== 接口基本使用 ===");
        
        // 通过接口类型引用对象
        Animal dog = new Dog();
        Animal cat = new Cat();
        
        // 调用接口方法
        dog.makeSound();
        dog.eat();
        
        cat.makeSound();
        cat.eat();
        
        // 如果要调用特有方法，需要向下转型
        if (dog instanceof Dog) {
            Dog realDog = (Dog) dog;
            realDog.fetch();
        }
        
        // 数组统一处理
        System.out.println("\n=== 所有动物 ===");
        Animal[] animals = {new Dog(), new Cat()};
        for (Animal animal : animals) {
            animal.makeSound();
            animal.eat();
            System.out.println();
        }
    }
}

2.2 接口中的常量

public class InterfaceConstants {
    public static void main(String[] args) {
        System.out.println("=== 接口中的常量 ===");
        
        // 访问接口常量
        System.out.println("圆周率: " + MathConstants.PI);
        System.out.println("自然常数: " + MathConstants.E);
        System.out.println("重力加速度: " + PhysicsConstants.GRAVITY);
        
        // 计算圆的面积
        double radius = 5.0;
        double area = MathConstants.PI * radius * radius;
        System.out.println("半径为5的圆面积: " + area);
        
        // 配置常量
        System.out.println("\n=== 配置信息 ===");
        System.out.println("最大连接数: " + DatabaseConfig.MAX_CONNECTIONS);
        System.out.println("默认端口: " + DatabaseConfig.DEFAULT_PORT);
        System.out.println("连接超时: " + DatabaseConfig.TIMEOUT + "秒");
    }
}

// 数学常量接口
interface MathConstants {
    // 接口中的字段默认是 public static final
    double PI = 3.141592653589793;
    double E = 2.718281828459045;
    
    // 也可以显式声明
    public static final double SQRT2 = 1.414213562373095;
}

// 物理常量接口
interface PhysicsConstants {
    double GRAVITY = 9.8;           // 重力加速度
    double LIGHT_SPEED = 299792458; // 光速
    double AVOGADRO = 6.022e23;     // 阿伏伽德罗常数
}

// 数据库配置接口
interface DatabaseConfig {
    int MAX_CONNECTIONS = 100;
    int DEFAULT_PORT = 3306;
    int TIMEOUT = 30;
    String DEFAULT_HOST = "localhost";
}

三、接口的高级特性

3.1 默认方法（Java 8+）

public class DefaultMethods {
    public static void main(String[] args) {
        System.out.println("=== 默认方法（Java 8+）===");
        
        Vehicle car = new Car();
        Vehicle bike = new Bike();
        
        car.start();
        car.honk();      // 调用默认方法
        car.stop();
        
        System.out.println();
        
        bike.start();
        bike.honk();     // 调用默认方法
        bike.stop();
        
        // 测试电子设备
        ElectronicDevice phone = new Smartphone();
        phone.powerOn();
        phone.connectToWifi();  // 调用默认方法
        phone.powerOff();
    }
}

// 交通工具接口
interface Vehicle {
    // 抽象方法
    void start();
    void stop();
    
    // 默认方法（Java 8新增）
    default void honk() {
        System.out.println("按喇叭！");
    }
    
    // 另一个默认方法
    default void turnOnLights() {
        System.out.println("打开车灯");
    }
}

class Car implements Vehicle {
    @Override
    public void start() {
        System.out.println("汽车启动");
    }
    
    @Override
    public void stop() {
        System.out.println("汽车停止");
    }
    
    // 可以重写默认方法
    @Override
    public void honk() {
        System.out.println("汽车鸣笛：嘀嘀！");
    }
}

class Bike implements Vehicle {
    @Override
    public void start() {
        System.out.println("自行车开始骑行");
    }
    
    @Override
    public void stop() {
        System.out.println("自行车停车");
    }
    // 不重写honk()，使用默认实现
}

// 电子设备接口
interface ElectronicDevice {
    void powerOn();
    void powerOff();
    
    // 默认方法
    default void connectToWifi() {
        System.out.println("设备连接到WiFi");
    }
    
    default void updateSoftware() {
        System.out.println("检查软件更新...");
        System.out.println("软件已是最新版本");
    }
}

class Smartphone implements ElectronicDevice {
    @Override
    public void powerOn() {
        System.out.println("手机开机");
    }
    
    @Override
    public void powerOff() {
        System.out.println("手机关机");
    }
    
    @Override
    public void connectToWifi() {
        System.out.println("手机扫描WiFi信号...");
        System.out.println("连接到家庭WiFi");
    }
}

class Laptop implements ElectronicDevice {
    @Override
    public void powerOn() {
        System.out.println("笔记本电脑启动");
    }
    
    @Override
    public void powerOff() {
        System.out.println("笔记本电脑关机");
    }
    // 使用默认的connectToWifi方法
}

3.2 静态方法（Java 8+）

public class StaticMethods {
    public static void main(String[] args) {
        System.out.println("=== 静态方法（Java 8+）===");
        
        // 调用接口的静态方法
        MathOperations.showInfo();
        double max = MathOperations.max(10, 20, 15);
        double min = MathOperations.min(10, 20, 15);
        
        System.out.println("最大值: " + max);
        System.out.println("最小值: " + min);
        System.out.println("平方根5: " + MathOperations.sqrt(5));
        
        // 字符串工具
        System.out.println("\n=== 字符串工具 ===");
        System.out.println("反转abc: " + StringUtils.reverse("abc"));
        System.out.println("大写ABC: " + StringUtils.toUpperCase("abc"));
        System.out.println("'hello'是字母吗? " + StringUtils.isAlpha("hello"));
    }
}

// 数学操作接口
interface MathOperations {
    // 静态方法
    static void showInfo() {
        System.out.println("数学运算工具");
    }
    
    static double max(double a, double b, double c) {
        return Math.max(Math.max(a, b), c);
    }
    
    static double min(double a, double b, double c) {
        return Math.min(Math.min(a, b), c);
    }
    
    static double sqrt(double x) {
        return Math.sqrt(x);
    }
    
    static double power(double base, double exponent) {
        return Math.pow(base, exponent);
    }
}

// 字符串工具接口
interface StringUtils {
    static String reverse(String str) {
        return new StringBuilder(str).reverse().toString();
    }
    
    static String toUpperCase(String str) {
        return str.toUpperCase();
    }
    
    static String toLowerCase(String str) {
        return str.toLowerCase();
    }
    
    static boolean isAlpha(String str) {
        return str.matches("[a-zA-Z]+");
    }
    
    static boolean isNumeric(String str) {
        return str.matches("\d+");
    }
}

3.3 私有方法（Java 9+）

public class PrivateMethods {
    public static void main(String[] args) {
        System.out.println("=== 私有方法（Java 9+）===");
        
        BankAccount account = new SavingsAccount();
        account.deposit(1000);
        account.withdraw(500);
        account.withdraw(600);  // 余额不足
        
        System.out.println("\n=== 日志系统 ===");
        Logger fileLogger = new FileLogger();
        fileLogger.logInfo("程序启动");
        fileLogger.logError("文件未找到");
        fileLogger.logDebug("调试信息");
    }
}

// 银行账户接口
interface BankAccount {
    void deposit(double amount);
    void withdraw(double amount);
    
    // 默认方法
    default void checkBalance() {
        double balance = getBalance();  // 调用私有方法
        System.out.println("当前余额: " + balance);
    }
    
    // 私有方法（Java 9+） - 只能在接口内部使用
    private double getBalance() {
        // 模拟获取余额的逻辑
        return Math.random() * 10000;
    }
    
    // 私有静态方法
    private static boolean isValidAmount(double amount) {
        return amount > 0;
    }
    
    // 另一个默认方法
    default void validateAmount(double amount) {
        if (!isValidAmount(amount)) {
            System.out.println("金额无效: " + amount);
        }
    }
}

class SavingsAccount implements BankAccount {
    @Override
    public void deposit(double amount) {
        validateAmount(amount);  // 调用接口的默认方法
        System.out.println("存款: " + amount);
        checkBalance();  // 调用接口的默认方法
    }
    
    @Override
    public void withdraw(double amount) {
        validateAmount(amount);
        System.out.println("取款: " + amount);
        checkBalance();
    }
}

// 日志接口
interface Logger {
    void logInfo(String message);
    void logError(String message);
    void logDebug(String message);
    
    // 私有方法：格式化日志
    private String formatLog(String level, String message) {
        return "[" + level + "] " + new java.util.Date() + " - " + message;
    }
    
    // 默认方法
    default void log(String level, String message) {
        String formatted = formatLog(level, message);
        writeToLog(formatted);
    }
    
    // 抽象方法：具体写入方式由实现类决定
    void writeToLog(String message);
}

class FileLogger implements Logger {
    @Override
    public void logInfo(String message) {
        log("INFO", message);
    }
    
    @Override
    public void logError(String message) {
        log("ERROR", message);
    }
    
    @Override
    public void logDebug(String message) {
        log("DEBUG", message);
    }
    
    @Override
    public void writeToLog(String message) {
        // 模拟写入文件
        System.out.println("写入文件: " + message);
    }
}

四、接口的多重实现

public class MultipleInterfaces {
    public static void main(String[] args) {
        System.out.println("=== 多重接口实现 ===");
        
        // 创建智能设备
        SmartDevice smartTV = new SmartTV();
        SmartDevice smartphone = new Smartphone2();
        
        // 测试功能
        System.out.println("=== 智能电视 ===");
        smartTV.powerOn();
        smartTV.connectToWifi();
        smartTV.playVideo();
        smartTV.adjustVolume(20);
        smartTV.powerOff();
        
        System.out.println("\n=== 智能手机 ===");
        smartphone.powerOn();
        smartphone.connectToWifi();
        smartphone.playVideo();
        smartphone.adjustVolume(15);
        smartphone.makeCall("123456789");
        smartphone.powerOff();
        
        // 测试可飞行的动物
        System.out.println("\n=== 可飞行的动物 ===");
        Flyable bird = new Bird();
        Flyable bat = new Bat();
        
        bird.fly();
        bird.land();
        
        bat.fly();
        bat.land();
        
        // 测试同时实现多个接口
        System.out.println("\n=== 超级动物 ===");
        SuperAnimal eagle = new Eagle();
        eagle.fly();
        eagle.swim();
        eagle.run();
        eagle.hunt();
    }
}

// 接口1：电子设备
interface ElectronicDevice2 {
    void powerOn();
    void powerOff();
    default void connectToWifi() {
        System.out.println("连接到WiFi网络");
    }
}

// 接口2：多媒体设备
interface MultimediaDevice {
    void playVideo();
    void playAudio();
    default void adjustVolume(int level) {
        System.out.println("调整音量到: " + level);
    }
}

// 接口3：通信设备
interface CommunicationDevice {
    void makeCall(String number);
    void sendMessage(String number, String message);
}

// 智能设备接口（继承多个接口）
interface SmartDevice extends ElectronicDevice2, MultimediaDevice, CommunicationDevice {
    void updateSoftware();
}

// 实现类1：智能电视
class SmartTV implements SmartDevice {
    @Override
    public void powerOn() {
        System.out.println("智能电视开机");
    }
    
    @Override
    public void powerOff() {
        System.out.println("智能电视关机");
    }
    
    @Override
    public void playVideo() {
        System.out.println("电视播放视频");
    }
    
    @Override
    public void playAudio() {
        System.out.println("电视播放音频");
    }
    
    @Override
    public void makeCall(String number) {
        System.out.println("电视不支持打电话");
    }
    
    @Override
    public void sendMessage(String number, String message) {
        System.out.println("电视不支持发短信");
    }
    
    @Override
    public void updateSoftware() {
        System.out.println("电视软件更新");
    }
}

// 实现类2：智能手机
class Smartphone2 implements SmartDevice {
    @Override
    public void powerOn() {
        System.out.println("手机开机");
    }
    
    @Override
    public void powerOff() {
        System.out.println("手机关机");
    }
    
    @Override
    public void playVideo() {
        System.out.println("手机播放视频");
    }
    
    @Override
    public void playAudio() {
        System.out.println("手机播放音乐");
    }
    
    @Override
    public void makeCall(String number) {
        System.out.println("手机拨打电话: " + number);
    }
    
    @Override
    public void sendMessage(String number, String message) {
        System.out.println("手机发送短信到" + number + ": " + message);
    }
    
    @Override
    public void updateSoftware() {
        System.out.println("手机系统更新");
    }
}

// 更多接口示例
interface Flyable {
    void fly();
    default void land() {
        System.out.println("降落");
    }
}

interface Swimmable {
    void swim();
}

interface Runnable {
    void run();
}

// 鸟：只能飞
class Bird implements Flyable {
    @Override
    public void fly() {
        System.out.println("鸟儿在天空飞翔");
    }
    
    @Override
    public void land() {
        System.out.println("鸟儿停在树枝上");
    }
}

// 蝙蝠：能飞，但不是鸟
class Bat implements Flyable {
    @Override
    public void fly() {
        System.out.println("蝙蝠在夜间飞行");
    }
}

// 超级动物：能飞、能游、能跑
class SuperAnimal implements Flyable, Swimmable, Runnable {
    private String name;
    
    public SuperAnimal() {
        this.name = "超级动物";
    }
    
    @Override
    public void fly() {
        System.out.println(name + "在天空翱翔");
    }
    
    @Override
    public void swim() {
        System.out.println(name + "在水中游泳");
    }
    
    @Override
    public void run() {
        System.out.println(name + "在陆地奔跑");
    }
    
    // 特有方法
    public void hunt() {
        System.out.println(name + "在捕猎");
    }
}

// 鹰：继承超级动物
class Eagle extends SuperAnimal {
    public Eagle() {
        // 可以设置不同的名字
    }
}

五、接口继承接口

public class InterfaceInheritance {
    public static void main(String[] args) {
        System.out.println("=== 接口继承接口 ===");
        
        // 使用高级打印机
        AdvancedPrinter printer = new OfficePrinter();
        printer.powerOn();
        printer.print("测试文档");
        printer.scan();
        printer.fax("传真内容");
        printer.copy();
        printer.powerOff();
        
        // 测试网络功能
        NetworkDevice router = new WiFiRouter();
        router.connect();
        router.disconnect();
        router.getIPAddress();
        
        // 车辆测试
        Vehicle2 car = new ModernCar();
        car.start();
        car.drive();
        car.playMusic();
        car.navigateTo("北京");
        car.stop();
    }
}

// 基础接口
interface Printer {
    void powerOn();
    void powerOff();
    void print(String document);
}

// 继承基础接口
interface Scanner extends Printer {
    void scan();
}

// 再次继承
interface FaxMachine extends Scanner {
    void fax(String document);
}

// 再次继承
interface Copier extends FaxMachine {
    void copy();
}

// 最终接口：高级打印机
interface AdvancedPrinter extends Copier {
    void showStatus();
}

// 实现最终接口
class OfficePrinter implements AdvancedPrinter {
    @Override
    public void powerOn() {
        System.out.println("打印机开机");
    }
    
    @Override
    public void powerOff() {
        System.out.println("打印机关机");
    }
    
    @Override
    public void print(String document) {
        System.out.println("打印: " + document);
    }
    
    @Override
    public void scan() {
        System.out.println("扫描文档");
    }
    
    @Override
    public void fax(String document) {
        System.out.println("传真: " + document);
    }
    
    @Override
    public void copy() {
        System.out.println("复印文档");
    }
    
    @Override
    public void showStatus() {
        System.out.println("打印机状态: 正常");
    }
}

// 另一个例子：网络设备
interface NetworkDevice {
    void connect();
    void disconnect();
    String getIPAddress();
}

interface WirelessDevice extends NetworkDevice {
    void connectToWifi(String ssid, String password);
    int getSignalStrength();
}

interface Router extends WirelessDevice {
    void setSSID(String ssid);
    void setPassword(String password);
    void restart();
}

class WiFiRouter implements Router {
    private String ssid = "MyWiFi";
    private String password = "password123";
    
    @Override
    public void connect() {
        System.out.println("路由器连接网络");
    }
    
    @Override
    public void disconnect() {
        System.out.println("路由器断开网络");
    }
    
    @Override
    public String getIPAddress() {
        return "192.168.1.1";
    }
    
    @Override
    public void connectToWifi(String ssid, String password) {
        System.out.println("连接到WiFi: " + ssid);
    }
    
    @Override
    public int getSignalStrength() {
        return 90; // 信号强度百分比
    }
    
    @Override
    public void setSSID(String ssid) {
        this.ssid = ssid;
        System.out.println("设置SSID为: " + ssid);
    }
    
    @Override
    public void setPassword(String password) {
        this.password = password;
        System.out.println("设置密码");
    }
    
    @Override
    public void restart() {
        System.out.println("重启路由器");
    }
}

// 汽车接口继承链
interface BasicVehicle {
    void start();
    void stop();
}

interface Drivable extends BasicVehicle {
    void drive();
    void brake();
}

interface EntertainmentSystem {
    void playMusic();
    void playRadio();
}

interface NavigationSystem {
    void navigateTo(String destination);
    String getCurrentLocation();
}

// 组合多个接口
interface ModernCar extends Drivable, EntertainmentSystem, NavigationSystem {
    void enableAutopilot();
}

class ModernCarImpl implements ModernCar {
    @Override
    public void start() {
        System.out.println("汽车启动");
    }
    
    @Override
    public void stop() {
        System.out.println("汽车停止");
    }
    
    @Override
    public void drive() {
        System.out.println("汽车行驶");
    }
    
    @Override
    public void brake() {
        System.out.println("刹车");
    }
    
    @Override
    public void playMusic() {
        System.out.println("播放音乐");
    }
    
    @Override
    public void playRadio() {
        System.out.println("播放广播");
    }
    
    @Override
    public void navigateTo(String destination) {
        System.out.println("导航到: " + destination);
    }
    
    @Override
    public String getCurrentLocation() {
        return "当前位置: 北京市朝阳区";
    }
    
    @Override
    public void enableAutopilot() {
        System.out.println("启用自动驾驶");
    }
}

六、接口在实际项目中的应用

import java.util.ArrayList;
import java.util.List;

public class RealWorldInterface {
    public static void main(String[] args) {
        System.out.println("=== 真实世界接口应用 ===");
        
        // 创建数据存储服务
        DataStorageService storageService = new DataStorageService();
        
        // 使用不同的存储方式
        Storage database = new DatabaseStorage();
        Storage fileSystem = new FileSystemStorage();
        Storage cloud = new CloudStorage();
        
        // 存储数据
        storageService.storeData(database, "用户数据");
        storageService.storeData(fileSystem, "日志文件");
        storageService.storeData(cloud, "备份数据");
        
        // 检索数据
        storageService.retrieveData(database, "用户数据");
        storageService.retrieveData(cloud, "备份数据");
        
        // 测试所有存储方式
        System.out.println("\n=== 测试所有存储方式 ===");
        Storage[] storages = {database, fileSystem, cloud};
        for (Storage storage : storages) {
            storage.testConnection();
            storage.showInfo();
            System.out.println();
        }
        
        // 支付处理
        System.out.println("=== 支付处理系统 ===");
        PaymentProcessor processor = new PaymentProcessor();
        
        Payment alipay = new AlipayPayment();
        Payment wechat = new WechatPayment();
        Payment bank = new BankTransferPayment();
        
        processor.processPayment(alipay, 100.0);
        processor.processPayment(wechat, 200.0);
        processor.processPayment(bank, 300.0);
        
        // 验证所有支付方式
        Payment[] payments = {alipay, wechat, bank};
        for (Payment payment : payments) {
            if (payment.isValid()) {
                System.out.println(payment.getName() + " 是有效的支付方式");
            }
        }
    }
}

// 存储接口
interface Storage {
    void store(String data);
    String retrieve(String key);
    void delete(String key);
    
    // 默认方法
    default void testConnection() {
        System.out.println("测试存储连接...");
    }
    
    default void showInfo() {
        System.out.println("存储系统信息");
    }
    
    // 静态方法
    static Storage getDefaultStorage() {
        return new FileSystemStorage();
    }
}

// 数据库存储实现
class DatabaseStorage implements Storage {
    @Override
    public void store(String data) {
        System.out.println("将数据存储到数据库: " + data);
    }
    
    @Override
    public String retrieve(String key) {
        System.out.println("从数据库检索数据: " + key);
        return "数据库数据";
    }
    
    @Override
    public void delete(String key) {
        System.out.println("从数据库删除数据: " + key);
    }
    
    @Override
    public void showInfo() {
        System.out.println("数据库存储系统");
        System.out.println("类型: MySQL");
        System.out.println("版本: 8.0");
    }
}

// 文件系统存储实现
class FileSystemStorage implements Storage {
    @Override
    public void store(String data) {
        System.out.println("将数据存储到文件系统: " + data);
    }
    
    @Override
    public String retrieve(String key) {
        System.out.println("从文件系统检索文件: " + key);
        return "文件数据";
    }
    
    @Override
    public void delete(String key) {
        System.out.println("从文件系统删除文件: " + key);
    }
    
    @Override
    public void showInfo() {
        System.out.println("文件系统存储");
        System.out.println("类型: NTFS");
        System.out.println("容量: 1TB");
    }
}

// 云存储实现
class CloudStorage implements Storage {
    @Override
    public void store(String data) {
        System.out.println("将数据上传到云存储: " + data);
    }
    
    @Override
    public String retrieve(String key) {
        System.out.println("从云存储下载数据: " + key);
        return "云存储数据";
    }
    
    @Override
    public void delete(String key) {
        System.out.println("从云存储删除数据: " + key);
    }
    
    @Override
    public void showInfo() {
        System.out.println("云存储系统");
        System.out.println("提供商: AWS S3");
        System.out.println("区域: us-east-1");
    }
    
    @Override
    public void testConnection() {
        System.out.println("测试云存储连接...");
        System.out.println("连接成功！延迟: 50ms");
    }
}

// 数据存储服务
class DataStorageService {
    public void storeData(Storage storage, String data) {
        System.out.println("\n=== 存储数据 ===");
        storage.store(data);
        System.out.println("=== 存储完成 ===");
    }
    
    public void retrieveData(Storage storage, String key) {
        System.out.println("\n=== 检索数据 ===");
        String data = storage.retrieve(key);
        System.out.println("获取到数据: " + data);
        System.out.println("=== 检索完成 ===");
    }
}

// 支付接口
interface Payment {
    boolean process(double amount);
    String getName();
    boolean isValid();
    
    // 默认方法
    default void refund(double amount) {
        System.out.println("退款: " + amount + "元");
    }
}

// 支付宝支付
class AlipayPayment implements Payment {
    @Override
    public boolean process(double amount) {
        System.out.println("支付宝支付: " + amount + "元");
        System.out.println("跳转到支付宝页面...");
        System.out.println("支付成功！");
        return true;
    }
    
    @Override
    public String getName() {
        return "支付宝";
    }
    
    @Override
    public boolean isValid() {
        return true;
    }
    
    @Override
    public void refund(double amount) {
        System.out.println("支付宝退款: " + amount + "元");
        System.out.println("退款将在3个工作日内到账");
    }
}

// 微信支付
class WechatPayment implements Payment {
    @Override
    public boolean process(double amount) {
        System.out.println("微信支付: " + amount + "元");
        System.out.println("跳转到微信支付...");
        System.out.println("支付成功！");
        return true;
    }
    
    @Override
    public String getName() {
        return "微信支付";
    }
    
    @Override
    public boolean isValid() {
        return true;
    }
}

// 银行转账
class BankTransferPayment implements Payment {
    @Override
    public boolean process(double amount) {
        System.out.println("银行转账: " + amount + "元");
        System.out.println("请使用网银或手机银行完成转账");
        System.out.println("转账成功！");
        return true;
    }
    
    @Override
    public String getName() {
        return "银行转账";
    }
    
    @Override
    public boolean isValid() {
        return true;
    }
}

// 支付处理器
class PaymentProcessor {
    public void processPayment(Payment payment, double amount) {
        System.out.println("\n=== 开始支付 ===");
        boolean success = payment.process(amount);
        if (success) {
            System.out.println("支付处理完成");
        } else {
            System.out.println("支付失败");
        }
        System.out.println("=== 支付结束 ===");
    }
}

七、总结

7.1 接口的核心概念

  1. 契约性：规定类必须实现的方法
  2. 抽象性：只声明方法，不提供实现（Java 8前）
  3. 多实现：一个类可以实现多个接口
  4. 解耦合：分离定义和实现

7.2 接口的发展历程

Java版本接口新特性
Java 7及之前只有抽象方法和常量
Java 8默认方法、静态方法
Java 9私有方法、私有静态方法

7.3 什么时候使用接口？

  1. 定义行为规范 → 需要多个类遵循相同的规范
  2. 实现多重继承 → 一个类需要多种能力
  3. 解耦合 → 分离接口和实现
  4. 定义回调 → 事件处理、监听器
  5. 策略模式 → 多种算法或策略

7.4 接口 vs 抽象类

特性接口抽象类
方法实现可以有默认实现可以有具体实现
字段只能是常量可以有各种字段
构造方法不能有可以有
多继承支持多实现只能单继承
设计目的定义行为契约提供部分实现

7.5 快速记忆口诀

  1. 接口定义行为，类来实现行为
  2. 一个类多接口，弥补单继承
  3. 默认方法防破坏，静态方法工具类
  4. 私有方法内共享，代码复用接口内
avatar
文章
阅读
粉丝