跳到主要内容

面向对象三大特性

介绍

面向对象编程(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)

什么是多态?

多态是指同一个方法在不同对象中有不同的实现方式。多态分为两种:

  1. 编译时多态:通过方法重载实现。
  2. 运行时多态:通过方法重写和父类引用指向子类对象实现。

如何实现多态?

方法重载(编译时多态)

方法重载是指在同一个类中定义多个同名方法,但参数列表不同。

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
警告

运行时多态依赖于方法重写,因此子类必须重写父类的方法才能实现多态。


实际案例

案例:银行账户系统

假设我们正在开发一个银行账户系统,可以使用面向对象的三大特性来实现:

  1. 封装:将账户余额设为私有,并通过公共方法进行存取款操作。
  2. 继承:创建一个 Account 父类,SavingsAccountCurrentAccount 作为子类继承 Account
  3. 多态:通过父类引用调用子类的 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.

总结

面向对象编程的三大特性——封装、继承和多态,是构建健壮、可维护和可扩展代码的基础。通过本文的学习,你应该已经掌握了这些核心概念,并能够通过代码示例和实际案例应用它们。


附加资源与练习

  1. 练习:尝试创建一个 Vehicle 父类和 CarBike 子类,实现多态。
  2. 扩展阅读:深入学习 Java 中的抽象类和接口,了解它们如何增强面向对象编程的能力。
  3. 挑战:设计一个简单的图书馆管理系统,使用封装、继承和多态来管理书籍和用户。

Happy Coding! 🚀