Java面向对象的实际案例能很好体现封装、继承、多态的结合使用，以下是几个贴近生活的场景案例：
案例1：校园人员管理系统（封装+继承+多态）
场景：学校有学生、老师两类人员，需统一管理基本信息，同时区分各自特性（学生有学号、老师有工号）。
// 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(); // 输出：李四正在讲课
}
}
案例2：电商商品订单系统（接口+多态）
场景：订单可包含多种商品（手机、图书），需统一计算总价，每种商品有自己的计价逻辑。
// 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
}
}
这些案例中，封装保证了数据安全（如私有属性通过方法访问），继承减少了代码重复（如学生/老师复用人员信息），多态实现了灵活扩展（如同一订单处理不同商品），完全贴合面向对象的设计思想。
