本文目录导读：
我来通过一个完整的案例,帮你掌握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();
}
实际应用场景
- 服务层接口：定义业务逻辑
- DAO层接口：数据访问抽象
- 远程调用接口：RPC服务定义
- 回调接口：事件处理
通过以上案例，你可以看到接口在实际开发中的强大作用：定义规范、实现多态、降低耦合，建议从简单的支付系统案例开始练习,逐步掌握接口的精髓。
