Java面向对象核心：多态、抽象类与接口实战解析

Aphelios380

已于 2025-04-14 08:35:05 修改

阅读量1.1k

点赞数 44

分类专栏： Java 文章标签： java 开发语言学习前端

于 2025-04-13 17:16:41 首次发布

本文链接：https://blog.youkuaiyun.com/2403_89107873/article/details/147194013

版权

Java 专栏收录该内容

8 篇文章

订阅专栏

本文为Java全栈学习系列笔记，结合企业级开发实践，深度解析OOP核心特性。适合具备基础语法知识的开发者进阶学习，文中包含大量工程化经验总结。

一、多态：面向对象的灵魂

1.1 多态核心机制

多态基于继承体系实现，满足三个必要条件：

继承关系（类继承或接口实现）
方法重写（@Override）
父类引用指向子类对象（向上转型）

// 典型多态示例
Shape shape = new Circle(5);  // 父类引用指向子类对象
System.out.println(shape.getArea()); // 动态绑定执行子类方法

1.2 多态应用场景

1.2.1 多态参数（企业级开发常用）

‌实战案例‌：通用图形处理器开发

// 抽象图形处理器
public class ShapeProcessor {
    // 多态参数：接收所有Shape子类对象
    public void process(Shape shape) {
        double area = shape.getArea();
        System.out.println("图形面积：" + area);
        // 可扩展渲染、存储等通用操作
    }
}

1.2.2 多态集合（集合框架基础）

‌优化版集合实现（引入泛型）：‌

public class PolymorphicList<T extends Shape> {
    private T[] elements = (T[]) new Shape;
    private int size = 0;
    
    public void add(T element) {
        if(size < elements.length) {
            elements[size++] = element;
        }
    }
    
    public void calculateTotalArea() {
        double total = 0;
        for(T element : elements) {
            if(element != null) {
                total += element.getArea();
            }
        }
        System.out.println("总面积：" + total);
    }
}

1.3 多态优势总结

‌扩展性强‌：新增子类不影响现有代码
‌解耦设计‌：调用方只需关注抽象类型
‌代码复用‌：通用逻辑可放在父类中

二、抽象：架构设计的关键

2.1 抽象类：模板模式基石

2.1.1 抽象类特性

用abstract关键字声明
可包含抽象方法和具体方法
不能被实例化
继承链中的通用模板

‌企业应用场景‌：支付系统模板方法

public abstract class PaymentProcessor {
    // 模板方法（final防止子类修改流程）
    public final void processPayment(double amount) {
        validate(amount);
        preProcess();
        executePayment();
        postProcess();
    }
    
    protected abstract void executePayment();
    
    protected void validate(double amount) {
        if(amount <= 0) throw new IllegalArgumentException();
    }
    
    // Hook方法（可选覆盖）
    protected void preProcess() {}
    protected void postProcess() {}
}

2.2 接口：系统扩展的利器

2.2.1 接口进化史

Java 7：纯抽象（public abstract方法）
Java 8：默认方法（default）、静态方法
Java 9：私有方法

‌现代接口示例：‌

public interface CacheService {
    // 抽象方法
    void put(String key, Object value);
    
    // 默认方法
    default void putIfAbsent(String key, Object value) {
        if(!contains(key)) {
            put(key, value);
        }
    }
    
    // 静态工具方法
    static CacheService createDefault() {
        return new MemoryCache();
    }
    
    // 私有方法（Java9+）
    private boolean contains(String key) {
        // 实现逻辑
    }
}

2.2.2 接口VS抽象类

特性	抽象类	接口
方法实现	可有具体方法	Java8+支持默认方法
构造方法	有	无
多继承	单继承	多实现
设计定位	通用模板	能力扩展/功能契约
状态管理	可维护状态	无状态（推荐）

三、全栈视角的OOP实践

3.1 前后端协同设计

‌场景‌：RESTful API的DTO抽象

// 通用响应接口
public interface ApiResponse<T> {
    int getCode();
    String getMessage();
    T getData();
    
    static <T> ApiResponse<T> success(T data) {
        return new SimpleResponse<>(200, "Success", data);
    }
}

// 实现类（可JSON序列化）
@JsonInclude(Include.NON_NULL)
public record SimpleResponse<T>(
    int code, 
    String message, 
    T data
) implements ApiResponse<T> {}

3.2 设计模式应用

人物角色技能设定接口

‌UML中的加号（+）含义‌：

加号（+）在UML类图中表示该属性或方法是public的（公共的）。这意味着该属性或方法可以被任何其他类访问和修改。

‌UML中的减号（-）含义‌：

减号（-）在UML类图中表示该属性或方法是private的（私有的）。这意味着该属性或方法只能被其所属的类内部访问和修改，外部类无法直接访问。

实线——>继承（extends），虚线——>接口（implements）

Role-父类

// Role.java


public abstract class Role {
    private String name;
    private String skill;

    public abstract void treat();

    public abstract void treat(Role role);

    public abstract void attrack(Role role);

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSkill() {
        return skill;
    }

    public void setSkill(String skill) {
        this.skill = skill;
    }
}

Taoist道士角色-子类

// Taoists.java

public class Taoists extends Role implements Treat {
    @Override
    public void treat() {
        System.out.print("给自己加血，");
        System.out.print("给队友加血");
    }

    @Override
    public void treat(Role role) {
        System.out.println("给" + role.getName() + "加血");
    }

    @Override
    public void attrack(Role role) {
        System.out.println("道士攻击" + role.getName());
    }
}

ITreat - 接口

// Treat.java
package src.main.java.org.yjy.RoleGame;

public interface Treat {
    void treat();
    void treat(Role role);

    void attrack(Role role);
}

Test - 测试

// Test.java
package src.main.java.org.yjy.RoleGame;

public class Test {
    public static void main(String[] args) {
        Taoists taoists = new Taoists();
        taoists.setName("小道");
        System.out.print("道士技能：");
        taoists.treat();
        Role otherRole = new Role() {
            @Override
            public void treat() {
                
            }

            @Override
            public void treat(Role role) {

            }

            @Override
            public void attrack(Role role) {
            }
        };
        otherRole.setName("敌人");
        taoists.treat(otherRole);
        taoists.attrack(otherRole);
    }
}

运行结果：