Java接口实现案例怎么实操

wen java案例 2026-07-01 255

本文目录导读：

Java接口实现案例怎么实操

基础案例：支付系统接口
进阶案例：多种接口实现
综合案例：策略模式应用
实际开发中的接口应用
最佳实践总结

我来通过一个完整的案例,帮你掌握Java接口的实操方法。

基础案例：支付系统接口

定义接口

// 支付接口
public interface Payment {
    // 抽象方法（接口中的方法默认是public abstract）
    void pay(double amount);
    // 默认方法（Java 8+）
    default void showPaymentInfo() {
        System.out.println("执行支付操作");
    }
    // 静态方法（Java 8+）
    static boolean validateAmount(double amount) {
        return amount > 0;
    }
}

实现接口

// 支付宝支付实现
public class AlipayImpl implements Payment {
    @Override
    public void pay(double amount) {
        if (!Payment.validateAmount(amount)) {
            System.out.println("金额无效");
            return;
        }
        System.out.println("支付宝支付：" + amount + "元");
        // 实际的支付宝支付逻辑
    }
}
// 微信支付实现
public class WechatPayImpl implements Payment {
    @Override
    public void pay(double amount) {
        if (!Payment.validateAmount(amount)) {
            System.out.println("金额无效");
            return;
        }
        System.out.println("微信支付：" + amount + "元");
        // 实际的微信支付逻辑
    }
}

使用接口

public class PaymentDemo {
    public static void main(String[] args) {
        // 面向接口编程
        Payment payment1 = new AlipayImpl();
        Payment payment2 = new WechatPayImpl();
        // 调用接口方法
        payment1.pay(100.0);
        payment2.pay(200.0);
        // 调用默认方法
        payment1.showPaymentInfo();
        // 调用接口静态方法
        System.out.println(Payment.validateAmount(50.0)); // true
    }
}

进阶案例：多种接口实现

定义多个接口

// 可支付接口
public interface Payable {
    void pay();
}
// 可退款接口
public interface Refundable {
    void refund();
}
// 可通知接口
public interface Notifiable {
    void sendNotification();
}

一个类实现多个接口

// 订单类实现多个接口
public class Order implements Payable, Refundable, Notifiable {
    private String orderId;
    private double amount;
    private String userEmail;
    public Order(String orderId, double amount, String userEmail) {
        this.orderId = orderId;
        this.amount = amount;
        this.userEmail = userEmail;
    }
    @Override
    public void pay() {
        System.out.println("订单 " + orderId + " 支付 " + amount + "元");
    }
    @Override
    public void refund() {
        System.out.println("订单 " + orderId + " 退款 " + amount + "元");
    }
    @Override
    public void sendNotification() {
        System.out.println("发送通知到邮箱：" + userEmail);
    }
}

使用接口引用

public class OrderService {
    public static void main(String[] args) {
        Order order = new Order("ORD001", 299.0, "user@example.com");
        // 使用不同的接口引用
        Payable payable = order;
        Refundable refundable = order;
        Notifiable notifiable = order;
        // 只能调用各自接口定义的方法
        payable.pay();
        refundable.refund();
        notifiable.sendNotification();
        // 接口类型检查
        if (payable instanceof Order) {
            Order originalOrder = (Order) payable;
            System.out.println("订单ID: " + originalOrder.orderId);
        }
    }
}

综合案例：策略模式应用

定义策略接口

// 计算价格策略接口
public interface PriceStrategy {
    double calculatePrice(double originalPrice);
}
// 会员折扣策略
public class VipPriceStrategy implements PriceStrategy {
    @Override
    public double calculatePrice(double originalPrice) {
        return originalPrice * 0.8; // 8折
    }
}
// 节日促销策略
public class HolidayPriceStrategy implements PriceStrategy {
    @Override
    public double calculatePrice(double originalPrice) {
        return originalPrice * 0.6; // 6折
    }
}
// 满减策略
public class FullReductionStrategy implements PriceStrategy {
    @Override
    public double calculatePrice(double originalPrice) {
        if (originalPrice >= 300) {
            return originalPrice - 50; // 满300减50
        }
        return originalPrice;
    }
}

使用策略模式

public class ShoppingCart {
    private PriceStrategy priceStrategy;
    // 设置策略
    public void setPriceStrategy(PriceStrategy strategy) {
        this.priceStrategy = strategy;
    }
    // 计算最终价格
    public double calculateFinalPrice(double originalPrice) {
        if (priceStrategy == null) {
            return originalPrice;
        }
        return priceStrategy.calculatePrice(originalPrice);
    }
    public static void main(String[] args) {
        ShoppingCart cart = new ShoppingCart();
        double price = 350.0;
        // 使用不同策略
        cart.setPriceStrategy(new VipPriceStrategy());
        System.out.println("VIP价格: " + cart.calculateFinalPrice(price));
        cart.setPriceStrategy(new HolidayPriceStrategy());
        System.out.println("节日价格: " + cart.calculateFinalPrice(price));
        cart.setPriceStrategy(new FullReductionStrategy());
        System.out.println("满减价格: " + cart.calculateFinalPrice(price));
    }
}

实际开发中的接口应用

数据访问层接口

// 数据访问对象接口
public interface UserDao {
    // CRUD操作
    boolean insertUser(User user);
    boolean deleteUser(int id);
    boolean updateUser(User user);
    User findUserById(int id);
    List<User> findAllUsers();
}
// 实现类
public class UserDaoImpl implements UserDao {
    @Override
    public boolean insertUser(User user) {
        // JDBC或MyBatis操作
        System.out.println("插入用户: " + user.getName());
        return true;
    }
    @Override
    public boolean deleteUser(int id) {
        System.out.println("删除用户ID: " + id);
        return true;
    }
    @Override
    public boolean updateUser(User user) {
        System.out.println("更新用户: " + user.getName());
        return true;
    }
    @Override
    public User findUserById(int id) {
        // 模拟查询
        return new User(id, "测试用户", "test@example.com");
    }
    @Override
    public List<User> findAllUsers() {
        return Arrays.asList(
            new User(1, "张三", "zhangsan@example.com"),
            new User(2, "李四", "lisi@example.com")
        );
    }
}

最佳实践总结

接口命名规范

形容词命名：Serializable, Comparable
能力命名：Runnable, Closable
以able表示具有某种能力

设计原则

// 1. 接口隔离原则 - 不要设计臃肿的接口
// ❌ 不好的设计
public interface BadAnimal {
    void fly();
    void swim();
    void run();
}
// ✅ 好的设计
public interface Flyable {
    void fly();
}
public interface Swimmable {
    void swim();
}
public interface Runnable {
    void run();
}