面向对象三大特性
介绍
面向对象编程（OOP）是一种编程范式，它将程序组织为对象的集合，每个对象都是类的实例。面向对象编程有三大核心特性：封装、继承和多态。这些特性使得代码更易于维护、扩展和重用。本文将逐一讲解这些特性，并通过代码示例和实际案例帮助你更好地理解。
1. 封装（Encapsulation）
什么是封装？
封装是将数据（属性）和操作数据的方法（行为）捆绑在一起的过程。通过封装，我们可以隐藏对象的内部实现细节，只暴露必要的接口供外部使用。这有助于提高代码的安全性和可维护性。
如何实现封装？
在 Java 中，封装通常通过以下方式实现：
- 使用
private关键字将属性设为私有。 - 提供
public的 getter 和 setter 方法来访问和修改这些属性。
代码示例
java
class Person {
private String name; // 私有属性
private int age;
// Getter 方法
public String getName() {
return name;
}
// Setter 方法
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if (age > 0) { // 数据验证
this.age = age;
}
}
}
public class Main {
public static void main(String[] args) {
Person person = new Person();
person.setName("Alice");
person.setAge(25);
System.out.println("Name: " + person.getName());
System.out.println("Age: " + person.getAge());
}
}
输出
Name: Alice
Age: 25
提示
封装不仅保护了数据，还允许我们在 setter 方法中添加数据验证逻辑，确保数据的有效性。
2. 继承（Inheritance）
什么是继承？
继承是一种机制，允许一个类（子类）基于另一个类（父类）来创建。子类会继承父类的属性和方法，同时可以添加新的属性和方法，或者重写父类的方法。继承的主要目的是实现代码的重用。
如何实现继承？
在 Java 中，使用 extends 关键字来实现继承。
代码示例
java
class Animal {
void eat() {
System.out.println("This animal eats food.");
}
}
class Dog extends Animal { // Dog 继承自 Animal
void bark() {
System.out.println("The dog barks.");
}
}
public class Main {
public static void main(String[] args) {
Dog dog = new Dog();
dog.eat(); // 继承自 Animal 的方法
dog.bark(); // Dog 类自己的方法
}
}
输出
This animal eats food.
The dog barks.
备注
继承使得代码更加模块化，子类可以复用父类的功能，同时可以根据需要扩展或修改父类的行为。
3. 多态（Polymorphism）
什么是多态？
多态是指同一个方法在不同对象中有不同的实现方式。多态分为两种：
- 编译时多态：通过方法重载实现。
- 运行时多态：通过方法重写和父类引用指向子类对象实现。
如何实现多态？
方法重载（编译时多态）
方法重载是指在同一个类中定义多个同名方法，但参数列表不同。
java
class Calculator {
int add(int a, int b) {
return a + b;
}
double add(double a, double b) {
return a + b;
}
}
public class Main {
public static void main(String[] args) {
Calculator calc = new Calculator();
System.out.println("Sum (int): " + calc.add(5, 10));
System.out.println("Sum (double): " + calc.add(5.5, 10.5));
}
}
输出
Sum (int): 15
Sum (double): 16.0
方法重写（运行时多态）
方法重写是指子类重新定义父类的方法。通过父类引用指向子类对象，可以实现运行时多态。
java
class Animal {
void sound() {
System.out.println("Animal makes a sound");
}
}
class Dog extends Animal {
@Override
void sound() {
System.out.println("Dog barks");
}
}
class Cat extends Animal {
@Override
void sound() {
System.out.println("Cat meows");
}
}
public class Main {
public static void main(String[] args) {
Animal myDog = new Dog(); // 父类引用指向子类对象
Animal myCat = new Cat();
myDog.sound(); // 调用 Dog 类的 sound 方法
myCat.sound(); // 调用 Cat 类的 sound 方法
}
}
输出
Dog barks
Cat meows
警告
运行时多态依赖于方法重写，因此子类必须重写父类的方法才能实现多态。
实际案例
案例：银行账户系统
假设我们正在开发一个银行账户系统，可以使用面向对象的三大特性来实现：
- 封装：将账户余额设为私有，并通过公共方法进行存取款操作。
- 继承：创建一个
Account父类，SavingsAccount和CurrentAccount作为子类继承Account。 - 多态：通过父类引用调用子类的
calculateInterest方法，计算不同类型的账户利息。
java
class Account {
private double balance;
public void deposit(double amount) {
if (amount > 0) {
balance += amount;
}
}
public void withdraw(double amount) {
if (amount > 0 && amount <= balance) {
balance -= amount;
}
}
public double getBalance() {
return balance;
}
void calculateInterest() {
System.out.println("Interest calculation not defined for generic account.");
}
}
class SavingsAccount extends Account {
@Override
void calculateInterest() {
double interest = getBalance() * 0.05; // 5% 利息
System.out.println("Savings Account Interest: " + interest);
}
}
class CurrentAccount extends Account {
@Override
void calculateInterest() {
System.out.println("Current Account has no interest.");
}
}
public class Main {
public static void main(String[] args) {
Account savings = new SavingsAccount();
savings.deposit(1000);
savings.calculateInterest();
Account current = new CurrentAccount();
current.deposit(1000);
current.calculateInterest();
}
}
输出
Savings Account Interest: 50.0
Current Account has no interest.
总结
面向对象编程的三大特性——封装、继承和多态，是构建健壮、可维护和可扩展代码的基础。通过本文的学习，你应该已经掌握了这些核心概念，并能够通过代码示例和实际案例应用它们。
附加资源与练习
- 练习：尝试创建一个
Vehicle父类和Car、Bike子类，实现多态。 - 扩展阅读：深入学习 Java 中的抽象类和接口，了解它们如何增强面向对象编程的能力。
- 挑战：设计一个简单的图书馆管理系统，使用封装、继承和多态来管理书籍和用户。
Happy Coding! 🚀