在 Java 中，面向对象编程的三大特性——封装性、继承性和多态性是构建复杂软件系统的基础，下面分别对其进行详细解释并给出示例。

封装性

  • 定义：封装是把对象的属性和操作（方法）结合为一个独立的整体，并尽可能隐藏对象的内部实现细节，只对外提供必要的访问接口。通过封装，可以提高代码的安全性和可维护性，防止外部代码随意访问和修改对象的内部状态。
  • 示例：
class BankAccount {
    // 私有属性，外部无法直接访问
    private String accountNumber;
    private double balance;

    // 构造方法，用于初始化对象
    public BankAccount(String accountNumber, double balance) {
        this.accountNumber = accountNumber;
        this.balance = balance;
    }

    // 获取账户余额的公共方法
    public double getBalance() {
        return balance;
    }

    // 存款的公共方法
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
            System.out.println("存款成功，当前余额为：" + balance);
        } else {
            System.out.println("无效的存款金额");
        }
    }

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

public class EncapsulationExample {
    public static void main(String[] args) {
        BankAccount account = new BankAccount("123456", 1000);
        account.deposit(500);
        account.withdraw(200);
    }
}

在上述代码中，BankAccount 类的 accountNumber 和 balance 属性被声明为 private，外部代码无法直接访问。通过提供公共的 getBalance、deposit 和 withdraw 方法，实现了对这些属性的安全访问和操作。

继承性

  • 定义：继承是指一个类（子类）可以继承另一个类（父类）的属性和方法，从而实现代码的复用。子类可以在继承父类的基础上，添加自己特有的属性和方法，或者对父类的方法进行重写。
  • 示例：
// 父类：动物
class Animal {
    protected String name;

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

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

// 子类：狗，继承自 Animal 类
class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

    public void bark() {
        System.out.println(name + " 正在汪汪叫");
    }
}

public class InheritanceExample {
    public static void main(String[] args) {
        Dog dog = new Dog("旺财");
        dog.eat();
        dog.bark();
    }
}

在这个例子中，Dog 类继承了 Animal 类的 name 属性和 eat 方法，同时还添加了自己特有的 bark 方法。通过 super 关键字调用父类的构造方法进行属性初始化。

多态性

  • 定义：多态是指同一个方法调用可以根据对象的实际类型产生不同的行为。在 Java 中，多态主要通过继承和方法重写来实现。通过父类引用指向子类对象，可以在运行时动态地调用子类重写的方法。
  • 示例：
// 父类：图形
abstract class Shape {
    public abstract double area();
}

// 子类：圆形
class Circle extends Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public double area() {
        return Math.PI * radius * radius;
    }
}

// 子类：矩形
class Rectangle extends Shape {
    private double length;
    private double width;

    public Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }

    @Override
    public double area() {
        return length * width;
    }
}

public class PolymorphismExample {
    public static void main(String[] args) {
        Shape circle = new Circle(5);
        Shape rectangle = new Rectangle(4, 6);

        System.out.println("圆形的面积是：" + circle.area());
        System.out.println("矩形的面积是：" + rectangle.area());
    }
}

在上述代码中，Shape 是一个抽象类，包含一个抽象方法 area。Circle 和 Rectangle 类继承自 Shape 类，并对 area 方法进行了重写。在 main 方法中，通过父类引用 Shape 指向子类对象 Circle 和 Rectangle，调用 area 方法时会根据对象的实际类型调用相应子类的 area 方法，从而实现了多态。