# Java 面向对象入门：类、对象、封装到底该怎么理解？

很多人在刚开始学 Java 的时候，会把“类”“对象”“封装”这些概念记成定义题，背的时候好像都会，一写代码就乱。

这篇文章不讲空泛术语，直接用代码把 Java 面向对象最基础的一层讲清楚。

## 一、为什么 Java 要讲面向对象？

如果我们只用过程式思维写代码，通常会把“数据”和“操作数据的方法”拆开处理。

比如要描述一个学生，我们可能会单独定义姓名、年龄、学号，然后再写若干个函数去处理这些变量。

当系统变复杂后，数据和行为分散在不同位置，代码会越来越难维护。

Java 的面向对象思路，就是把**数据**和**行为**组织在一起。

说白了：谁的数据，就让谁的方法去处理。

## 二、类和对象到底是什么？

### 1. 类是什么

类可以理解成一种“模板”或者“图纸”。

它规定了某一类事物应该有哪些属性、有哪些行为。

比如下面这个 `Student` 类：

```java
public class Student {
    String name;
    int age;

    public void study() {
        System.out.println(name + " is studying.");
    }
}
```

这里的 `Student` 不是某一个具体学生，而是“学生”这一类对象的统一描述。

### 2. 对象是什么

对象是根据类创建出来的具体实例。

```java
public class Main {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.name = "Alice";
        s1.age = 20;

        s1.study();
    }
}
```

运行后，`s1` 就是一个真正存在的学生对象。

类是抽象描述，对象是具体实体。

### 3. 一个类可以创建多个对象

```java
public class Main {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.name = "Alice";
        s1.age = 20;

        Student s2 = new Student();
        s2.name = "Bob";
        s2.age = 22;

        s1.study();
        s2.study();
    }
}
```

虽然 `s1` 和 `s2` 都来自 `Student` 类，但它们是两个不同对象，拥有各自独立的数据。

## 三、属性和方法分别是什么？

在类中：

- **属性（field/member variable）** 用来描述对象的状态
- **方法（method）** 用来描述对象的行为

例如：

```java
public class Car {
    String brand;
    int speed;

    public void start() {
        System.out.println(brand + " starts.");
    }

    public void accelerate() {
        speed += 10;
        System.out.println("Current speed: " + speed);
    }
}
```

这里：

- `brand`、`speed` 是属性
- `start()`、`accelerate()` 是方法

属性决定“它是什么状态”，方法决定“它能做什么”。

## 四、什么是封装？为什么一定要学？

封装是 Java 面向对象里最重要的基础概念之一。

它的核心思想不是一句“把属性私有化”就结束了，而是：

**把对象内部实现细节藏起来，只对外暴露安全、可控的操作方式。**

### 1. 不封装会发生什么

假设这样写：

```java
public class Student {
    String name;
    int age;
}
```

外部代码可以直接这样改：

```java
Student s = new Student();
s.name = "Tom";
s.age = -100;
```

语法没问题，但业务上明显不合理。

这就说明：如果属性完全暴露，数据就可能被随意改坏。

### 2. 用 private 实现封装

```java
public class Student {
    private String name;
    private int age;

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setAge(int age) {
        if (age >= 0 && age <= 150) {
            this.age = age;
        } else {
            System.out.println("Invalid age.");
        }
    }

    public int getAge() {
        return age;
    }
}
```

现在外部不能直接改 `age`，只能通过 `setAge()` 间接修改。

这样就能把校验逻辑统一放进类内部。

### 3. 封装的价值

封装至少有三个直接好处：

#### （1）保护数据安全

无效值、非法操作可以被拦截。

#### （2）降低耦合

外部不需要知道内部具体怎么实现，只知道该调用哪个方法。

#### （3）便于维护和扩展

以后你想修改年龄校验规则，只需要改类内部逻辑，不需要全项目到处改代码。

## 五、this 关键字到底有什么用？

在初学阶段，`this` 最常见的作用是区分“成员变量”和“局部变量”。

```java
public class Student {
    private String name;

    public void setName(String name) {
        this.name = name;
    }
}
```

这里：

- `this.name` 表示当前对象的成员变量
- `name` 表示方法参数

如果没有 `this`，就会发生“变量名遮蔽”，看起来像在给自己赋值。

## 六、构造方法是什么？

构造方法用于在创建对象时初始化属性。

它的名字必须和类名相同，并且没有返回值类型。

```java
public class Student {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void show() {
        System.out.println("name=" + name + ", age=" + age);
    }
}
```

使用方式：

```java
public class Main {
    public static void main(String[] args) {
        Student s = new Student("Alice", 20);
        s.show();
    }
}
```

构造方法的意义是：对象一创建出来就处于合理状态。

## 七、一个完整的面向对象基础示例

下面给一个更完整、也更贴近实际开发习惯的例子：

```java
public class BankAccount {
    private String owner;
    private double balance;

    public BankAccount(String owner, double balance) {
        this.owner = owner;
        if (balance >= 0) {
            this.balance = balance;
        } else {
            this.balance = 0;
        }
    }

    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
            System.out.println("Deposit successful, balance=" + balance);
        }
    }

    public void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            System.out.println("Withdraw successful, balance=" + balance);
        } else {
            System.out.println("Withdraw failed.");
        }
    }

    public double getBalance() {
        return balance;
    }

    public String getOwner() {
        return owner;
    }
}
```

主程序测试：

```java
public class Main {
    public static void main(String[] args) {
        BankAccount account = new BankAccount("Tom", 1000);
        account.deposit(300);
        account.withdraw(200);

        System.out.println(account.getOwner());
        System.out.println(account.getBalance());
    }
}
```

这个例子里已经能看到面向对象的基本味道：

- 数据有边界
- 行为有规则
- 外部不能胡乱改内部状态

## 八、初学者最容易踩的坑

### 1. 把类当成对象来用

类只是模板，不能直接代表一个具体实例。

### 2. 成员变量和局部变量分不清

尤其在 setter 和构造方法里，`this` 经常忘记写。

### 3. 所有属性都直接 public

这会让封装失去意义。

### 4. 构造方法名字写错

构造方法必须和类名完全一致。

### 5. 只会背定义，不会从“数据+行为”角度设计类

真正写代码时，类设计能力比死记概念更重要。

## 九、面试和学习中该怎么理解这部分

如果你要用一句更工程化的话总结：

**类是对象的抽象，对象是类的实例，封装是对对象状态和行为的边界控制。**

但只会说这句没意义。

真正要掌握的是：

- 什么属性应该暴露
- 什么属性应该隐藏
- 什么操作应该通过方法控制
- 什么状态必须在创建对象时就初始化

这才是面向对象真正落到代码里的部分。

## 十、小结

这篇文章你需要真正吃透的只有三件事：

1. **类是模板，对象是实例**
2. **属性描述状态，方法描述行为**
3. **封装的本质是控制访问、保护数据、降低耦合**

只要这三层理解顺了，后面再学继承、多态、接口，就不会觉得概念都在空中飘着。

## 推荐下一步

下一篇建议继续写：

**Java 构造方法、this 与对象初始化流程详解**

这样可以把面向对象最基础的一段彻底打牢。