前言：想象一下，你正在搭建一座乐高城堡。你不需要从头开始制作每一个砖块，而是利用现成的砖块，按照说明书进行组装。面向对象编程 (OOP) 也是类似的理念，它将复杂的程序分解成一个个独立的“砖块”——对象，然后通过组合这些对象来构建整个程序。
1. 封装：保护数据，控制访问就像乐高城堡的每个部分都有自己的功能，OOP 中的对象也包含数据和操作。
数据： 对象的属性，例如城堡的高度、颜色、窗户的数量等。
操作： 对象的方法，例如打开城堡的大门、升起旗帜等。
封装就是将这些数据和操作捆绑在一起，形成一个独立的实体。
数据隐藏： 将对象的内部数据隐藏起来，外部代码无法直接访问和修改，就像城堡的内部结构是隐藏的，只有通过门才能进入。
接口控制： 提供公共的方法，允许外部代码通过这些方法访问和修改对象的数据，就像城堡的大门允许人们进入和离开。
示例：
代码语言：java复制public class Car {
private String color; // 私有数据成员，表示汽车颜色
private int speed; // 私有数据成员，表示汽车速度
// 公共方法，设置汽车颜色
public void setColor(String color) {
this.color = color;
}
// 公共方法，获取汽车颜色
public String getColor() {
return color;
}
// 公共方法，加速汽车
public void accelerate() {
speed += 10;
System.out.println("Car is accelerating. Current speed: " + speed);
}
}
在这个例子中，Car 类封装了汽车的颜色和速度数据，并提供了 setColor, getColor 和 accelerate 方法来控制对这些数据的访问。外部代码只能通过这些方法来操作汽车，保证了数据安全性和一致性。
2. 继承：代码复用，层次结构就像乐高城堡可以由不同的模块组合而成，OOP 中的对象也可以通过继承建立层次关系。
父类： 提供基础的属性和方法，例如所有汽车都具有颜色和速度。
子类： 继承父类的属性和方法，并可以添加新的属性和方法，例如跑车可以继承汽车的属性，并添加加速功能。
示例：
代码语言：java复制public class Vehicle { // 父类
private String color;
public void move() {
System.out.println("Vehicle is moving.");
}
}
public class Car extends Vehicle { // 子类继承 Vehicle 类
private int speed;
public void accelerate() {
speed += 10;
System.out.println("Car is accelerating. Current speed: " + speed);
}
}
public class Motorcycle extends Vehicle { // 子类继承 Vehicle 类
public void wheelie() {
System.out.println("Motorcycle is doing a wheelie!");
}
}
在这个例子中，Car 和 Motorcycle 类都继承了 Vehicle 类的 color 属性和 move() 方法，同时它们分别添加了 accelerate() 和 wheelie() 方法，体现了它们各自的特性。
3. 多态：多种形态，同一接口就像同一个乐高积木可以被用来构建不同的结构，OOP 中的对象也可以表现出不同的行为。
方法重写： 子类可以重写父类的方法，提供不同的实现。
动态绑定： 运行时根据对象的实际类型确定调用哪个方法。
示例：
代码语言：java复制public class Animal {
public void makeSound() {
System.out.println("Animal sound");
}
}
public class Dog extends Animal {
@Override
public void makeSound() {
System.out.println("Woof!");
}
}
public class Cat extends Animal {
@Override
public void makeSound() {
System.out.println("Meow!");
}
}
public class Main {
public static void main(String[] args) {
Animal animal1 = new Dog();
Animal animal2 = new Cat();
animal1.makeSound(); // 输出 "Woof!"
animal2.makeSound(); // 输出 "Meow!"
}
}
在这个例子中，Dog 和 Cat 类都重写了 Animal 类的 makeSound() 方法，提供了不同的声音。当调用 animal1.makeSound() 和 animal2.makeSound() 时，程序会根据 animal1 和 animal2 实际指向的对象类型 (Dog 或 Cat) 动态地调用相应的 makeSound() 方法。
4 JavaBean：OOP 的实用应用我们已经了解了面向对象编程 (OOP) 的三个核心原则：封装、继承和多态。现在，让我们来学习一个非常实用的 OOP 概念——JavaBean。
JavaBean 是符合特定规范的 Java 类，它可以被用于构建可复用的组件，方便地在应用程序之间传递数据。
4.1 JavaBean 与 OOP 的关系
JavaBean 紧密地与 OOP 原理结合，它将数据和操作封装在一个类中，并通过 getter 和 setter 方法控制对数据的访问。
封装： JavaBean 的数据成员是私有的，只能通过 getter 和 setter 方法访问，保证了数据安全性和一致性。
继承： JavaBean 可以继承其他 JavaBean 类，扩展其功能。
多态： JavaBean 可以通过重写方法实现多态性。
4.2 JavaBean 的规范
一个类要成为 JavaBean，必须满足以下规范：
公共的无参构造函数： 允许创建 JavaBean 对象。
私有的数据成员： 保护数据安全性和一致性。
公共的 getter 和 setter 方法： 提供访问和修改数据成员的接口。
序列化： 允许将 JavaBean 对象保存到文件中或数据库中。
示例：
代码语言：java复制public class PersonBean {
private String name;
private int age;
// 无参构造函数
public PersonBean() {}
// getter 方法
public String getName() {
return name;
}
public int getAge() {
return age;
}
// setter 方法
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
}
在这个例子中，PersonBean 类是一个符合 JavaBean 规范的类。它包含私有的 name 和 age 数据成员，以及相应的 getter 和 setter 方法。
4.3 JavaBean 的应用
JavaBean 被广泛应用于各种应用程序中，例如：
GUI 应用程序： JavaBean 可以作为 GUI 组件，例如按钮、文本框等。
Web 应用程序： JavaBean 可以用于存储和传递 Web 应用程序中的数据。
企业应用程序： JavaBean 可以用于构建企业应用程序中的业务逻辑。
结语
面向对象编程通过封装、继承和多态三个核心原则，将复杂问题分解成独立的对象，提高代码的可读性、可维护性和可扩展性。 掌握 OOP 原理，可以帮助你编写更优雅、更强大的程序。同时，JavaBean 是一个非常实用的 OOP 概念，它将数据和操作封装在一个类中，并通过 getter 和 setter 方法控制对数据的访问。JavaBean 符合特定的规范，可以被用于构建可复用的组件，方便地在应用程序之间传递数据。