深入理解Java面向对象编程的三大特征-CSDN博客

public class BankAccount {
    // 私有字段 - 外部无法直接访问
    private String accountNumber;
    private double balance;
    private String ownerName;

    // 公有构造方法
    public BankAccount(String accountNumber, String ownerName, double initialBalance) {
        this.accountNumber = accountNumber;
        this.ownerName = ownerName;
        this.balance = initialBalance;
    }

    // 公有方法 - 提供受控的访问方式
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
            System.out.println("存款成功，当前余额: " + balance);
        } else {
            System.out.println("存款金额必须大于0");
        }
    }

    public void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            System.out.println("取款成功，当前余额: " + balance);
        } else {
            System.out.println("取款失败：金额无效或余额不足");
        }
    }

    // Getter方法 - 提供只读访问
    public double getBalance() {
        return balance;
    }

    public String getAccountNumber() {
        return accountNumber;
    }

    public String getOwnerName() {
        return ownerName;
    }

    // Setter方法 - 提供受控的修改方式
    public void setOwnerName(String ownerName) {
        if (ownerName != null && !ownerName.trim().isEmpty()) {
            this.ownerName = ownerName;
        }
    }
}

封装的好处：

提高安全性：防止外部代码直接修改内部数据
降低耦合度：内部实现变化不影响外部代码
易于维护：可以在方法中添加验证逻辑
代码可读性：清晰的接口定义

2. 继承 (Inheritance)

什么是继承？

继承允许一个新类（子类）基于现有类（父类）来构建，获得父类的属性和方法，并可以添加新的功能或重写现有功能。

继承的核心思想：

代码复用：子类可以重用父类的代码
层次结构：建立类之间的"is-a"关系
扩展功能：子类可以扩展或修改父类的行为

继承的实现：

// 父类 - 动物
public class Animal {
    protected String name;
    protected int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void eat() {
        System.out.println(name + "正在吃东西");
    }

    public void sleep() {
        System.out.println(name + "正在睡觉");
    }

    public void makeSound() {
        System.out.println("动物发出声音");
    }
}

// 子类 - 狗
public class Dog extends Animal {
    private String breed;  // 新增属性

    public Dog(String name, int age, String breed) {
        super(name, age);  // 调用父类构造方法
        this.breed = breed;
    }

    // 重写父类方法
    @Override
    public void makeSound() {
        System.out.println(name + "汪汪叫");
    }

    // 新增方法
    public void fetch() {
        System.out.println(name + "正在接飞盘");
    }

    public String getBreed() {
        return breed;
    }
}

// 子类 - 猫
public class Cat extends Animal {
    private int lives = 9;  // 新增属性

    public Cat(String name, int age) {
        super(name, age);
    }

    // 重写父类方法
    @Override
    public void makeSound() {
        System.out.println(name + "喵喵叫");
    }

    // 新增方法
    public void climbTree() {
        System.out.println(name + "正在爬树");
    }
}

继承的类型：

单继承：Java只支持单继承（一个子类只能有一个直接父类）
多层继承：类可以形成继承层次结构
接口实现：通过接口实现多重继承的效果

继承的好处：

代码复用：避免重复代码
易于扩展：方便添加新功能
多态支持：为多态提供基础

3. 多态 (Polymorphism)

什么是多态？

多态是指同一个行为具有多个不同表现形式或形态的能力。在Java中，多态主要体现为：

编译时多态：方法重载
运行时多态：方法重写

多态的核心思想：

同一接口，不同实现：不同的对象对同一消息做出不同的响应
父类引用，子类对象：父类引用可以指向子类对象

多态的实现：

public class PolymorphismExample {
    public static void main(String[] args) {
        // 多态的体现：父类引用指向子类对象
        Animal myDog = new Dog("Buddy", 3, "金毛");
        Animal myCat = new Cat("Whiskers", 2);
        Animal genericAnimal = new Animal("Generic", 1);

        // 同一个方法调用，不同的行为
        myDog.makeSound();    // 输出: Buddy汪汪叫
        myCat.makeSound();    // 输出: Whiskers喵喵叫
        genericAnimal.makeSound(); // 输出: 动物发出声音

        // 多态在集合中的应用
        Animal[] animals = {
            new Dog("Max", 4, "哈士奇"),
            new Cat("Luna", 1),
            new Dog("Rex", 5, "德牧")
        };

        System.out.println("\n所有动物发出声音:");
        for (Animal animal : animals) {
            animal.makeSound();  // 运行时多态
        }

        // 类型检查和转换
        System.out.println("\n类型检查示例:");
        for (Animal animal : animals) {
            animal.eat();  // 所有动物都会吃
            
            if (animal instanceof Dog) {
                Dog dog = (Dog) animal;  // 向下转型
                dog.fetch();  // 只有狗会接飞盘
            } else if (animal instanceof Cat) {
                Cat cat = (Cat) animal;  // 向下转型
                cat.climbTree();  // 只有猫会爬树
            }
        }
    }
}

多态的实现条件：

继承关系：存在父子类关系
方法重写：子类重写父类的方法
向上转型：父类引用指向子类对象

多态的好处：

提高灵活性：代码可以处理多种类型的对象
增强扩展性：容易添加新的子类而不影响现有代码
简化代码：可以用统一的接口处理不同的对象

三大特征的协同作用

这三个特征不是孤立的，而是相互协作的：

封装为基础：提供了数据的保护和隐藏，为继承和多态创造条件
继承为桥梁：建立了类之间的关系，为实现多态提供基础
多态为表现：体现了面向对象编程的灵活性和扩展性

// 综合示例：三大特征的协同
public class OOPDemo {
    public static void main(String[] args) {
        // 封装：通过构造函数创建对象，数据被保护
        BankAccount account = new BankAccount("123456", "张三", 1000);
        
        // 继承和多态：处理不同类型的动物
        Animal[] animals = {
            new Dog("小黑", 2, "泰迪"),
            new Cat("小白", 1),
            new Dog("大黄", 3, "柴犬")
        };
        
        // 多态：统一处理不同类型的动物
        for (Animal animal : animals) {
            animal.eat();      // 继承的方法
            animal.makeSound(); // 多态的方法
        }
    }
}