面向对象编程入门

本文是《Java 后端从小白到大神》修仙系列第零篇，正式进入Java后端世界，本篇文章主要聊Java基础，我们开始吧。

一、为什么要学习面向对象？

不是为了应付考试，也不是为了背概念。
因为现实世界是“一个个事物”组成的，而不是“一步步流程”组成的。

人有姓名、年龄，会吃饭、睡觉、工作
订单有编号、金额，能支付、能取消
手机有品牌、内存，能开机、能打电话

Java 就是用代码模拟现实。
掌握面向对象 = 掌握 Java 世界的底层世界观。

二、面向过程 vs 面向对象

2.1 面向过程

（C 语言风格）：按步骤做事

核心：数据和行为分家，先做什么、再做什么，一步步走。

数据：一堆变量、结构体
行为：一堆独立函数
关系：函数处理数据，谁都能改，谁都能碰

就像：
做饭 = 买菜 → 洗菜 → 切菜 → 炒菜 → 装盘
一步一步线性执行，步骤乱了就全乱。

// 数据
struct Student {
    int id;
    int score;
};

// 独立函数，到处调用
void input(...) {}
void print(...) {}
void calc(...) {}

缺点：

数据不安全，谁都能直接改
函数越写越多，关系混乱
改一步，牵一发而动全身
大型项目根本管不住

2.2 面向对象

（Java）：按事物建模

核心：把“数据 + 行为”打包成一个整体，叫做对象。

事物有什么特征 → 成员变量（状态）
事物能做什么事 → 成员方法（行为）

就像：
一个学生自己管自己的信息，自己打印自己的成绩，自己算自己的排名。

class Student {
    // 特征：数据
    private int id;
    private int score;

    // 行为：方法
    public void printInfo() {}
    public int getScoreLevel() {}
}

优点：

数据安全，外部不能乱改
结构清晰，事物归事物，功能归功能
易扩展、易复用、易维护
适合中大型项目、企业级后端开发

一句话终极对比

面向过程：我一步步指挥数据做事
面向对象：我让对象自己做事

三、面向对象核心概念

3.1 类与对象

类（Class）：同一类事物的模板/图纸
比如：学生、订单、手机、狗
对象（Object）：类造出来的具体一个实例
比如：张三这个学生、你中午的外卖订单、你的手机

现实映射：

类 = “学生”这个概念
对象 = 具体某一个学生

图纸理论：
类、接口本质只是一张设计图纸，不是 new 出来的实物对象。
定义图纸时，不需要提前创建实例，就可以直接把自身类/接口用作方法返回值、成员属性类型；
图纸只负责定规则、定结构，只有执行 new 时，才会用图纸创建出真正的对象实例。

3.2 面向对象三大特性

封装（保护自己）

一句话本质：把数据藏起来，只开放安全方法。

变量私有化（private）
方法公开化（public）
外部不能随便改，只能通过规定方式访问

现实例子：
手机内部电路板你碰不到，只能按屏幕、按按钮。

class Student {
    private int score;  // 藏起来

    public int getScore() { return score; }
    public void setScore(int s) {
        if(s >= 0) score = s; // 安全控制
    }
}

继承（复用父亲）

一句话本质：子类拥有父类的全部功能，并可以扩展自己。

关系：is a（…是一种…）
子类 = 父类 + 自己的新东西
不用重复写代码

现实例子：

父：动物（会吃、会睡）
子：狗（继承吃、睡，新增：会叫）

class Animal {
    void eat() {}
}

class Dog extends Animal {
    void bark() {} // 扩展
}

多态（灵活替换）

一句话本质：同一个行为，不同对象做不一样的事。

父类引用指向子类对象
调用同一个方法，表现不同效果
统一接口，灵活替换

现实模型（最经典）：

都是“叫”
- 狗：汪汪汪
- 猫：喵喵喵
- 牛：哞哞哞

Animal a1 = new Dog();
Animal a2 = new Cat();

a1.shout(); // 汪汪
a2.shout(); // 喵喵

四、现实世界 ↔ 代码世界

4.1 现实事物 → 代码对象

现实世界	代码世界
一类事物	类（Class）
具体一个东西	对象（Object）
长相、特征、信息	成员变量（属性/状态）
能做的动作、能力	成员方法（行为）

4.2 动物体系（现实 → 代码）

现实：

动物：都有名字、年龄，都会叫
狗：是动物，会汪汪叫
猫：是动物，会喵喵叫

代码：

// 父类：动物
abstract class Animal {
    protected String name;
    protected int age;

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

    // 抽象：都会叫，但叫法不同
    public abstract void shout();
}

// 狗
class Dog extends Animal {
    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void shout() {
        System.out.println("汪汪汪");
    }
}

// 猫
class Cat extends Animal {
    public Cat(String name, int age) {
        super(name, age);
    }

    @Override
    public void shout() {
        System.out.println("喵喵喵");
    }
}

// 测试
public class Test {
    public static void main(String[] args) {
        Animal a1 = new Dog("旺财", 2);
        Animal a2 = new Cat("咪咪", 1);

        a1.shout();
        a2.shout();
    }
}

结构一目了然：

现实“动物” → 代码 Animal
现实“狗” → 代码 Dog extends Animal
现实“叫” → 代码 shout()
多态：同样 shout()，不同叫声

五、面向对象的实际应用

5.1 企业级最常用模型：订单体系

现实：

所有订单都有：编号、金额、状态
都能：支付、取消、查询
外卖订单：额外有配送、商家、地址
商城订单：额外有物流、优惠券

代码结构：

class Order {          // 通用订单
    String orderId;
    double money;
    void pay() {}
}

class TakeawayOrder extends Order {  // 外卖订单
    String address;
    void deliver() {}
}

class MallOrder extends Order {       // 商城订单
    String logisticsNo;
    void sendGoods() {}
}

价值一眼看懂：

公共逻辑只写一遍（继承）
新增订单类型只加类，不改老代码（开闭原则）
统一处理支付、退款（多态）

六、总结

1. 面向对象本质

用代码模拟现实世界：一切皆对象，对象 = 状态 + 行为

2. 三大特性一句话记住

封装：数据藏起来，安全可靠
继承：复用父类，扩展自己
多态：同一行为，不同表现

3. 最终心法

面向过程是走流程，面向对象是建世界。

面向对象编程是一种编程思想，它将现实世界中的事物抽象为对象，通过封装、继承和多态等特性，使代码更加清晰、灵活和可维护。

搜索

Java后端-基础-面向对象-0