Java之禅案例

wen java案例 2026-07-29 165

本文目录导读：

Java之禅案例

核心哲学案例：万物皆对象
复用的哲学：组合与继承
接口与解耦：策略设计模式
内部类的回调机制
Java之禅的核心思想

核心哲学案例：万物皆对象

案例：简单对象创建与垃圾回收

这个案例体现了Java的核心哲学之一：一切都是对象，并且由JVM管理内存。

// 定义一个简单的对象
class Student {
    String name;
    int age;
    // 构造方法，用于初始化对象
    Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    // 行为（方法）
    void study() {
        System.out.println(name + " 正在学习 Java 之禅...");
    }
}
public class ObjectExample {
    public static void main(String[] args) {
        // 使用new关键字在堆上创建对象
        Student s = new Student("张三", 20);
        // 通过引用操作对象
        s.study();
        System.out.println(s.name + " 的年龄是：" + s.age);
        // 当对象不再被引用时，JVM会自动回收其内存（垃圾回收GC）
        s = null; // 原Student对象变为垃圾
        // 这里体现了Java的“安全”与“轻松”哲学：无需手动释放内存
    }
}

哲学点：

new 是唯一创建对象的方式（反射等除外）。
所有对象都存储在堆上,所有变量都是引用（s 不是对象本身，而是指向对象的遥控器）。
不需要像C++那样手动 delete，JVM的垃圾收集器会处理。

复用的哲学：组合与继承

案例：使用继承复用车辆类

这体现了Java的复用设计哲学，也是面向对象的基石。

// 基类
class Vehicle {
    public void move() {
        System.out.println("交通工具在移动...");
    }
}
// 子类继承自Vehicle，复用了move方法
class Car extends Vehicle {
    // 添加新的特性
    private String brand = "BMW";
    @Override
    public void move() {
        System.out.println(brand + " 汽车在公路上行驶...");
    }
    // 子类独有的方法
    public void honk() {
        System.out.println("滴滴！");
    }
}
public class InheritanceExample {
    public static void main(String[] args) {
        Car myCar = new Car();
        myCar.move();  // 调用的是重写后的方法
        myCar.honk();  // 子类自己的方法
        // 多态：向上转型
        Vehicle v = new Car(); 
        v.move(); // 动态绑定，依然输出汽车行驶
    }
}

哲学点：

继承实现了代码复用，但更重要的哲学是 “is-a” 关系（汽车是一种交通工具）。
多态是通过继承实现的，它让代码更灵活（通过父类引用操作子类对象）。
@Override 注解体现了Java的严谨：明确告知编译器我要重写父类方法。

接口与解耦：策略设计模式

案例：使用接口实现“策略”模式

这是Java中最经典的解耦哲学,强调 “针对接口编程，而不是针对实现编程”。

// 定义飞行行为接口
interface FlyBehavior {
    void fly();
}
// 实现不同的飞行策略
class FlyWithWings implements FlyBehavior {
    public void fly() {
        System.out.println("靠翅膀飞行！");
    }
}
class FlyNoWay implements FlyBehavior {
    public void fly() {
        System.out.println("不会飞行！");
    }
}
// 鸭子类，将飞行行为委托给接口
class Duck {
    private FlyBehavior flyBehavior; // 组合接口
    public Duck(FlyBehavior flyBehavior) {
        this.flyBehavior = flyBehavior;
    }
    public void performFly() {
        flyBehavior.fly(); // 委托给具体的飞行行为
    }
    // 动态改变行为（运行时更换策略）
    public void setFlyBehavior(FlyBehavior fb) {
        this.flyBehavior = fb;
    }
}
public class StrategyPatternExample {
    public static void main(String[] args) {
        Duck mallardDuck = new Duck(new FlyWithWings());
        mallardDuck.performFly(); // 输出：靠翅膀飞行！
        Duck rubberDuck = new Duck(new FlyNoWay());
        rubberDuck.performFly(); // 输出：不会飞行！
        // 运行时改变行为（体现灵活性）
        rubberDuck.setFlyBehavior(new FlyWithWings());
        rubberDuck.performFly(); // 现在变成飞行了！
    }
}

哲学点：

使用接口定义行为，而不是继承具体类。
组合优于继承：将变化的部分封装成接口，通过委托来实现行为。
系统具有极高的弹性：可以轻松扩展新的飞行方式而不修改Duck类。

内部类的回调机制

案例：使用内部类实现GUI回调

内部类是Java特有的机制,常用于实现回调，体现了 闭包与封装 的哲学。

// 定义点击监听器接口
interface ClickListener {
    void onClick();
}
class Button {
    // 持有监听器
    private ClickListener listener;
    public void setOnClickListener(ClickListener listener) {
        this.listener = listener;
    }
    public void click() {
        if(listener != null) {
            listener.onClick(); // 回调
        }
    }
}
public class InnerClassExample {
    public static void main(String[] args) {
        Button btn = new Button();
        // 1. 常见方式：匿名内部类（体现了Java的简洁哲学）
        btn.setOnClickListener(new ClickListener() {
            @Override
            public void onClick() {
                System.out.println("按钮被点击了！（来自匿名内部类）");
            }
        });
        // 2. Lambda表达式（Java8+ 进一步简化，但本质还是函数式接口）
        btn.setOnClickListener(() -> {
            System.out.println("按钮被点击了！（来自Lambda）");
        });
        btn.click();
    }
}

哲学点：