分享一些Java面向对象的实际案例

// 1. 父类：封装共性属性和方法
class Person {
    private String name; // 封装姓名（私有属性）
    private int age;

    // 构造器初始化
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // getter/setter暴露接口（封装的体现）
    public String getName() { return name; }
    public int getAge() { return age; }

    // 共性方法：展示基本信息
    public void showInfo() {
        System.out.println("姓名：" + name + "，年龄：" + age);
    }
}

// 2. 子类1：学生（继承+扩展）
class Student extends Person {
    private String studentId; // 学生专属属性

    public Student(String name, int age, String studentId) {
        super(name, age); // 继承父类构造器
        this.studentId = studentId;
    }

    // 重写父类方法（多态基础）
    @Override
    public void showInfo() {
        super.showInfo(); // 复用父类逻辑
        System.out.println("身份：学生，学号：" + studentId);
    }

    // 学生专属方法
    public void study() {
        System.out.println(getName() + "正在学习");
    }
}

// 3. 子类2：老师（继承+扩展）
class Teacher extends Person {
    private String teacherId; // 老师专属属性

    public Teacher(String name, int age, String teacherId) {
        super(name, age);
        this.teacherId = teacherId;
    }

    // 重写父类方法（多态基础）
    @Override
    public void showInfo() {
        super.showInfo();
        System.out.println("身份：老师，工号：" + teacherId);
    }

    // 老师专属方法
    public void teach() {
        System.out.println(getName() + "正在讲课");
    }
}

// 4. 测试类（多态的实际应用）
public class SchoolSystem {
    public static void main(String[] args) {
        // 父类引用指向子类对象（多态）
        Person s = new Student("张三", 18, "2023001");
        Person t = new Teacher("李四", 35, "T001");

        // 调用同一方法，表现不同行为（多态特性）
        s.showInfo(); 
        // 输出：姓名：张三，年龄：18；身份：学生，学号：2023001
        t.showInfo(); 
        // 输出：姓名：李四，年龄：35；身份：老师，工号：T001

        // 子类专属方法需强转调用
        ((Student)s).study(); // 输出：张三正在学习
        ((Teacher)t).teach(); // 输出：李四正在讲课
    }
}

// 1. 接口：定义商品的统一行为
interface Product {
    double getPrice(); // 计算价格
    String getName();  // 获取名称
}

// 2. 实现类1：手机（封装属性和计价逻辑）
class Phone implements Product {
    private String brand;
    private double price;
    private int storage; // 存储容量（影响价格）

    public Phone(String brand, double price, int storage) {
        this.brand = brand;
        this.price = price + (storage * 100); // 存储越大价格越高
    }

    @Override
    public double getPrice() { return price; }

    @Override
    public String getName() { return brand + "手机（" + storage + "G）"; }
}

// 3. 实现类2：图书（封装属性和计价逻辑）
class Book implements Product {
    private String title;
    private double price;
    private double discount; // 折扣（影响价格）

    public Book(String title, double price, double discount) {
        this.title = title;
        this.price = price * discount; // 折扣后价格
    }

    @Override
    public double getPrice() { return price; }

    @Override
    public String getName() { return title; }
}

// 4. 订单类（使用多态统一管理商品）
class Order {
    private Product[] products; // 订单中的商品（父类数组存子类对象）

    public Order(Product[] products) {
        this.products = products;
    }

    // 计算订单总价（多态：无需关心具体商品类型）
    public double calculateTotal() {
        double total = 0;
        for (Product p : products) {
            total += p.getPrice();
        }
        return total;
    }

    // 展示订单商品
    public void showProducts() {
        System.out.println("订单商品：");
        for (Product p : products) {
            System.out.println(p.getName() + "，单价：" + p.getPrice());
        }
    }
}

// 5. 测试类
public class OrderSystem {
    public static void main(String[] args) {
        // 创建不同商品（多态：统一用Product类型）
        Product p1 = new Phone("小米", 2999, 256); // 价格=2999+256*100=28599
        Product p2 = new Book("Java编程思想", 108, 0.8); // 价格=108*0.8=86.4

        // 生成订单
        Order order = new Order(new Product[]{p1, p2});
        order.showProducts();
        System.out.println("订单总价：" + order.calculateTotal()); // 输出：28685.4
    }
}