🏗️ 类与对象

面向对象编程概述

面向对象编程（OOP）是一种编程范式，它使用"对象"来表示现实世界中的实体。

核心概念

类（Class）：对象的模板或蓝图
对象（Object）：类的实例
封装（Encapsulation）：隐藏实现细节
继承（Inheritance）：代码复用
多态（Polymorphism）：同一接口的不同实现

类（Class）

类的定义

java

// 访问修饰符 class 类名 {
//     成员变量
//     构造方法
//     成员方法
// }

public class Student {
    // 成员变量（属性）
    private String name;
    private int age;
    
    // 构造方法
    public Student() {
        // 无参构造
    }
    
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    // 成员方法
    public void displayInfo() {
        System.out.println("姓名: " + name + ", 年龄: " + age);
    }
    
    // Getter 和 Setter 方法
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public int getAge() {
        return age;
    }
    
    public void setAge(int age) {
        this.age = age;
    }
}

类的组成部分

成员变量（Field）：类的属性
构造方法（Constructor）：用于初始化对象
成员方法（Method）：类的行为

对象（Object）

对象的创建

java

// 使用 new 关键字创建对象
Student student1 = new Student();
Student student2 = new Student("张三", 20);

// 对象引用
Student student3 = student2;  // student3 和 student2 指向同一个对象

对象的使用

java

// 调用方法
student1.setName("李四");
student1.setAge(25);
student1.displayInfo();

// 访问属性（通过方法）
String name = student1.getName();
int age = student1.getAge();

成员变量

实例变量

每个对象都有独立的副本：

java

public class Person {
    private String name;  // 实例变量
    private int age;      // 实例变量
    
    // ...
}

类变量（静态变量）

所有对象共享同一个变量：

java

public class Counter {
    private static int count = 0;  // 类变量
    
    public Counter() {
        count++;
    }
    
    public static int getCount() {
        return count;
    }
}

构造方法

构造方法的特点

方法名与类名相同
没有返回类型（连 void 都没有）
用于初始化对象
可以重载

构造方法示例

java

public class Student {
    private String name;
    private int age;
    
    // 无参构造方法
    public Student() {
        this.name = "未知";
        this.age = 0;
    }
    
    // 有参构造方法
    public Student(String name) {
        this.name = name;
        this.age = 0;
    }
    
    // 完整构造方法
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

this 关键字

java

public class Student {
    private String name;
    private int age;
    
    public Student(String name, int age) {
        this.name = name;  // this 指向当前对象
        this.age = age;
    }
    
    public void setName(String name) {
        this.name = name;  // 区分参数和成员变量
    }
}

成员方法

方法定义

java

// 访问修饰符 返回类型 方法名(参数列表) {
//     方法体
//     return 返回值; // 如果有返回值
// }

public class Calculator {
    // 无返回值方法
    public void printResult(int result) {
        System.out.println("结果: " + result);
    }
    
    // 有返回值方法
    public int add(int a, int b) {
        return a + b;
    }
    
    // 无参数方法
    public String getInfo() {
        return "这是一个计算器";
    }
}

方法重载

同一个类中可以定义多个同名方法，但参数列表必须不同：

java

public class MathUtil {
    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;
    }
    
    // 方法重载：参数类型或数量不同
}

访问修饰符

访问修饰符类型

修饰符	类内	包内	子类	包外
`private`	✅	❌	❌	❌
`default`（无修饰符）	✅	✅	❌	❌
`protected`	✅	✅	✅	❌
`public`	✅	✅	✅	✅

访问修饰符示例

java

public class AccessExample {
    private int privateVar;        // 只有本类可访问
    int defaultVar;                // 包内可访问
    protected int protectedVar;    // 包内和子类可访问
    public int publicVar;          // 所有地方可访问
    
    private void privateMethod() {}
    void defaultMethod() {}
    protected void protectedMethod() {}
    public void publicMethod() {}
}

Getter 和 Setter 方法

用于访问和修改私有成员变量：

java

public class Person {
    private String name;
    private int age;
    
    // 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) {
        if (age >= 0 && age <= 150) {  // 可以添加验证
            this.age = age;
        }
    }
}

静态成员

静态变量

java

public class Counter {
    private static int count = 0;  // 静态变量
    
    public Counter() {
        count++;
    }
    
    public static int getCount() {  // 静态方法
        return count;
    }
}

// 使用
Counter c1 = new Counter();
Counter c2 = new Counter();
System.out.println(Counter.getCount());  // 2（所有对象共享）

静态方法

java

public class MathUtil {
    public static int add(int a, int b) {
        return a + b;
    }
    
    public static double calculateArea(double radius) {
        return Math.PI * radius * radius;
    }
}

// 使用（不需要创建对象）
int sum = MathUtil.add(5, 3);
double area = MathUtil.calculateArea(5.0);

静态代码块

java

public class StaticBlock {
    static {
        // 类加载时执行，只执行一次
        System.out.println("静态代码块执行");
    }
    
    public StaticBlock() {
        System.out.println("构造方法执行");
    }
}

对象生命周期

对象创建

java

// 声明引用变量
Student student;

// 创建对象
student = new Student("张三", 20);

// 或者合并
Student student = new Student("张三", 20);

对象使用

java

student.setName("李四");
student.displayInfo();

对象销毁

Java 使用垃圾回收机制自动回收不再使用的对象：

java

Student student = new Student();
student = null;  // 对象变为可回收状态
// 垃圾回收器会在适当的时候回收对象

完整示例

java

// Student.java
public class Student {
    // 成员变量
    private String name;
    private int age;
    private static int studentCount = 0;  // 静态变量
    
    // 构造方法
    public Student() {
        studentCount++;
    }
    
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        studentCount++;
    }
    
    // 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;
    }
    
    // 成员方法
    public void displayInfo() {
        System.out.println("姓名: " + name + ", 年龄: " + age);
    }
    
    // 静态方法
    public static int getStudentCount() {
        return studentCount;
    }
}

// Main.java
public class Main {
    public static void main(String[] args) {
        // 创建对象
        Student student1 = new Student("张三", 20);
        Student student2 = new Student("李四", 22);
        
        // 使用对象
        student1.displayInfo();
        student2.displayInfo();
        
        // 调用静态方法
        System.out.println("学生总数: " + Student.getStudentCount());
    }
}

最佳实践

1. 封装原则

java

// ✅ 好的做法：使用 private 修饰，提供 getter/setter
public class Person {
    private String name;
    
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
}

// ❌ 不好的做法：公开所有字段
public class Person {
    public String name;  // 不推荐
}

2. 构造方法

java

// ✅ 提供多个构造方法重载
public class Student {
    private String name;
    private int age;
    
    public Student() {
        this("未知", 0);
    }
    
    public Student(String name) {
        this(name, 0);
    }
    
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

3. 方法命名

java

// ✅ 使用动词命名方法
public void displayInfo() {}
public int calculateTotal() {}
public boolean isValid() {}

// ❌ 不要使用名词
public void info() {}  // 不推荐

常见错误

1. 忘记使用 new

java

// ❌ 错误
Student student;
student.setName("张三");  // NullPointerException

// ✅ 正确
Student student = new Student();
student.setName("张三");

2. 混淆对象和引用

java

Student s1 = new Student("张三", 20);
Student s2 = s1;  // s2 和 s1 指向同一个对象
s2.setName("李四");
System.out.println(s1.getName());  // "李四"（因为指向同一个对象）

3. 静态方法访问非静态成员

java

public class Example {
    private int instanceVar = 10;
    
    // ❌ 错误：静态方法不能访问实例变量
    public static void method() {
        System.out.println(instanceVar);  // 编译错误
    }
    
    // ✅ 正确：需要创建对象或使用实例方法
    public static void method() {
        Example e = new Example();
        System.out.println(e.instanceVar);
    }
}

下一步

掌握了类与对象后，可以继续学习：

封装 - 深入学习封装概念
继承 - 学习类的继承关系
多态 - 理解多态的实现

💡 提示：面向对象编程的核心是理解类和对象的关系，多实践，多思考如何用对象来建模现实世界

🏗️ 类与对象 ​

面向对象编程概述 ​

核心概念 ​

类（Class） ​

类的定义 ​

类的组成部分 ​

对象（Object） ​

对象的创建 ​

对象的使用 ​

成员变量 ​

实例变量 ​

类变量（静态变量） ​

构造方法 ​

构造方法的特点 ​

构造方法示例 ​

this 关键字 ​

成员方法 ​

方法定义 ​

方法重载 ​

访问修饰符 ​

访问修饰符类型 ​

访问修饰符示例 ​

Getter 和 Setter 方法 ​

静态成员 ​

静态变量 ​

静态方法 ​

静态代码块 ​

对象生命周期 ​

对象创建 ​

对象使用 ​

对象销毁 ​

完整示例 ​

最佳实践 ​

1. 封装原则 ​

2. 构造方法 ​

3. 方法命名 ​

常见错误 ​

1. 忘记使用 new ​

2. 混淆对象和引用 ​

3. 静态方法访问非静态成员 ​

下一步 ​

🏗️ 类与对象

面向对象编程概述

核心概念

类（Class）

类的定义

类的组成部分

对象（Object）

对象的创建

对象的使用

成员变量

实例变量

类变量（静态变量）

构造方法

构造方法的特点

构造方法示例

this 关键字

成员方法

方法定义

方法重载

访问修饰符

访问修饰符类型

访问修饰符示例

Getter 和 Setter 方法

静态成员

静态变量

静态方法

静态代码块

对象生命周期

对象创建

对象使用

对象销毁

完整示例

最佳实践

1. 封装原则

2. 构造方法

3. 方法命名

常见错误

1. 忘记使用 new

2. 混淆对象和引用

3. 静态方法访问非静态成员

下一步