Java面向对象基础
在 Java 中，面向对象编程（OOP）的核心思想是将数据和操作数据的方法封装在 “类” 中，通过 “对象” 实例化类来实现功能。以下从类与对象创建、三大特性（封装、继承、多态）的实现及应用场景展开说明：
一、类与对象的创建
1. 类的定义
类是对象的模板，包含属性（数据）和方法（行为）。语法：
修饰符 class 类名 {
// 属性（成员变量）
数据类型 属性名;
// 方法
修饰符 返回值类型 方法名(参数列表) {
// 方法体
}
}
示例（定义一个 Person 类）：
public class Person {
// 属性（封装数据）
private String name;
private int age;
// 方法（封装行为）
public void sayHello() {
System.out.println("Hello, I'm " + name);
}
// 构造方法（用于创建对象时初始化属性）
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
2. 对象的创建
通过 new 关键字实例化对象，调用构造方法初始化。示例：
public class Main {
public static void main(String[] args) {
// 创建 Person 对象
Person person = new Person("Alice", 20);
// 调用对象的方法
person.sayHello(); // 输出：Hello, I'm Alice
}
}
二、封装
1. 实现方式
- 将类的属性设为
private（私有），限制直接访问。 - 提供
public的 getter/setter 方法，控制属性的读写逻辑（如校验）。
示例（完善 Person 类的封装）：
public class Person {
private String name;
private int age;
// getter 方法：获取属性值
public String getName() {
return name;
}
// setter 方法：设置属性值（带校验）
public void setAge(int age) {
if (age < 0 || age > 150) {
throw new IllegalArgumentException("年龄不合法");
}
this.age = age;
}
public int getAge() {
return age;
}
}
2. 应用场景
- 保护数据安全性（如年龄不能为负数）。
- 隐藏实现细节（用户只需调用方法，无需关心内部逻辑）。
- 便于后续修改（如修改校验规则，不影响外部调用）。
三、继承
1. 实现方式
通过 extends 关键字让子类继承父类，子类可复用父类的属性和方法，并扩展新功能。语法：class 子类名 extends 父类名 { ... }
示例（学生类 Student 继承 Person）：
// 父类
public class Person {
protected String name; // 受保护的属性，子类可访问
public void eat() {
System.out.println(name + " is eating");
}
}
// 子类
public class Student extends Person {
private String school; // 子类新增属性
// 子类扩展方法
public void study() {
System.out.println(name + " is studying at " + school);
}
}
2. 关键特性
- 单继承：Java 中类只能继承一个父类（但可通过接口实现多继承效果）。
super关键字：访问父类的属性、方法或构造方法（如super(name)调用父类构造）。- 方法重写（Override）：子类可重写父类方法，实现个性化逻辑（需满足方法签名相同）。
示例（重写父类方法）：
public class Student extends Person {
@Override // 注解标识重写
public void eat() {
System.out.println(name + " is eating in the cafeteria");
}
}
3. 应用场景
- 代码复用：如多个类（
Student、Teacher）共享Person的属性（姓名、年龄）。 - 层级关系建模：如
Animal作为父类，Dog、Cat作为子类，体现 “is-a” 关系。
四、多态
1. 实现方式
多态核心思想是 “同一行为，不同实现”，有编译时多态和运行时多态之分。通常所说的多态指的是运行时多态。
编译时多态（方法重载）的示例：
// 编译时多态示例：通过方法重载实现
public class Calculator {
// 重载：参数个数不同
public int add(int a, int b) {
return a + b;
}
// 重载：参数个数不同
public int add(int a, int b, int c) {
return a + b + c;
}
// 重载：参数类型不同
public double add(double a, double b) {
return a + b;
}
// 重载：参数顺序不同（需保证类型有差异）
public String add(String a, int b) {
return a + b;
}
public String add(int a, String b) {
return a + b;
}
public static void main(String[] args) {
Calculator calc = new Calculator();
// 编译时就确定调用哪个重载方法
System.out.println(calc.add(1, 2)); // 调用 int add(int, int)
System.out.println(calc.add(1, 2, 3)); // 调用 int add(int, int, int)
System.out.println(calc.add(1.5, 2.5)); // 调用 double add(double, double)
System.out.println(calc.add("年龄：", 20)); // 调用 String add(String, int)
System.out.println(calc.add(20, "岁")); // 调用 String add(int, String)
}
}
运行时多态示例：
public class Main {
public static void main(String[] args) {
Person person1 = new Student(); // 父类引用指向子类对象
Person person2 = new Teacher();
person1.eat(); // 调用 Student 重写的 eat()
person2.eat(); // 调用 Teacher 重写的 eat()
}
}
public class Student extends Person {
@Override // 注解标识重写
public void eat() {
System.out.println(name + " is eating in the cafeteria");
}
}
class Teacher extends Person {
@Override
public void eat() {
System.out.println(name + " is eating in the office");
}
}
2. 关键特性
编译时多态： 编译期确定调用版本，核心是 "同名方法的不同参数形态"，
- 发生在同一个类中（或父子类中，但通常建议在同一类）
- 方法名必须相同，参数列表必须不同（参数类型、个数、顺序至少有一个不同）
- 返回值类型可以不同（但不能仅通过返回值类型区分重载）
运行时多态： 运行期确定调用版本，核心是 "子类对父类方法的重写 + 向上转型"
- 需同时满足：继承关系、方法重写、父类引用指向子类对象。
- 不能用于静态方法和属性：静态方法和类属性属于类本身，不具备多态性。
3. 应用场景
多态在实际开发中应用广泛，其核心价值在于降低代码耦合度、提高扩展性和复用性，常见应用场景如下：
- 统一接口调用（最核心场景）：当需要对一组具有继承关系的类进行统一操作时，通过父类引用调用方法，无需关心具体子类类型，即可触发对应子类的实现。
- 框架与工具类设计：后边学到的 Spring中大量使用多态实现 “通用逻辑” 与 “具体业务” 的分离。
- 策略模式（Strategy Pattern）：通过多态封装不同的算法 / 策略，使算法可动态切换，且不影响使用算法的客户端。
总结
- 类与对象：类是模板，对象是实例，通过
new创建。 - 封装：私有属性 + 公共方法，保护数据并隐藏细节。
- 继承：
extends实现代码复用，子类可扩展或重写父类。 - 多态：父类引用指向子类对象，实现灵活调用，提升扩展性。
这三大特性共同支撑 Java 面向对象编程的灵活性和可维护性，是构建复杂系统的基础。
