目录

一、前言

二、什么是面向对象？

1. 核心概念

2. 面向对象 vs 面向过程

三、Java 面向对象三大核心特征

1. 封装（Encapsulation）

概念

作用

使用

2. 继承（Inheritance）

概念

特点

生活例子

使用

3. 多态（Polymorphism）

概念

前提条件

作用

使用（多态核心）

四、面向对象必备知识点

1. 构造方法

2. this 关键字

3. super 关键字

4. 方法重写（Override）

5. 权限修饰符

五、面向对象开发小案例

六、总结

---

一、前言

在 Java 开发的世界里，面向对象（Object-Oriented Programming，简称 OOP） 是基石，也是我们必须掌握的核心思想。

不同于传统面向过程编程（一步一步写流程），面向对象把现实世界抽象成「对象」，让代码更贴近生活、更易复用、更易维护。不管是做后端开发、安卓开发，还是框架源码学习，OOP 都是绕不开的核心。

今天这篇文章，我会用最通俗的语言，带你从零到一掌握 Java 面向对象的核心知识。

二、什么是面向对象？

1. 核心概念

• 类（Class）：对象的模板/蓝图，描述一类事物的属性和行为。

• 对象（Object）：类的实例，是具体存在的个体。

举个生活中的例子：

• 类：「手机」（抽象概念，定义了手机有颜色、品牌，能打电话、拍照）

• 对象：你手里的这台黑色华为手机（具体的个体）

2. 面向对象 vs 面向过程

特性	面向过程	面向对象
核心	以功能/步骤为中心	以对象为中心
代码设计	一步一步执行流程	把数据和行为封装在一起
复用性	差，代码重复多	高，可继承、可复用
维护性	难，改一处牵一发而动全身	易，模块化设计

简单说：面向过程是「做什么」，面向对象是「谁来做」。

三、Java 面向对象三大核心特征

这是面试、开发中必考、必用的知识点，必须吃透！

1. 封装（Encapsulation）

概念

把属性私有化，对外提供公共的访问方法（get/set），隐藏内部实现细节，只暴露必要接口。

作用

• 保护数据安全，防止外部随意修改

• 简化调用，调用者无需关心内部逻辑

• 提高代码安全性和可维护性

// 人类：封装属性和行为
public class Person {
    // 1. 私有属性（外部不能直接访问）
    private String name;
    private int age;

    // 2. 公共get/set方法（外部通过这里访问/修改）
    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    // 可以加逻辑校验，保证数据安全
    public void setAge(int age) {
        if (age < 0 || age > 150) {
            System.out.println("年龄不合法！");
            return;
        }
        this.age = age;
    }

    // 行为
    public void sayHello() {
        System.out.println("大家好，我是" + name + "，今年" + age + "岁");
    }
}

使用

public class Test {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("张三");
        person.setAge(20); // 合法
        person.setAge(200); // 不合法，会提示错误
        
        person.sayHello();
    }
}

2. 继承（Inheritance）

概念

子类继承父类的属性和方法，实现代码复用，还能扩展新功能。

关键字：extends

特点

• Java 只支持单继承（一个子类只能有一个直接父类）

• 子类可以重写（override）父类方法

• 所有类默认继承 Object 类

生活例子

父类：动物（有名字、会叫）

子类：狗、猫（继承动物，又有自己的特性）

// 父类：动物
class Animal {
    String name;

    public void eat() {
        System.out.println(name + "在吃东西");
    }
}

// 子类：狗 继承 动物
class Dog extends Animal {
    // 子类特有方法
    public void bark() {
        System.out.println(name + "在汪汪叫");
    }
}

使用

public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.name = "旺财";
        
        // 继承自父类
        dog.eat();
        
        // 子类自己的
        dog.bark();
    }
}

3. 多态（Polymorphism）

概念

同一个行为，在不同子类中表现出不同的形态。

前提条件

1. 继承关系

2. 方法重写

3. 父类引用指向子类对象

作用

统一调用标准，提高代码扩展性，适配多种子类。

// 父类
class Animal {
    public void shout() {
        System.out.println("动物在叫");
    }
}

// 子类1
class Cat extends Animal {
    // 重写
    @Override
    public void shout() {
        System.out.println("喵喵喵");
    }
}

// 子类2
class Dog extends Animal {
    @Override
    public void shout() {
        System.out.println("汪汪汪");
    }
}

使用（多态核心）

public class Test {
    public static void main(String[] args) {
        // 父类引用 指向 子类对象
        Animal animal1 = new Dog();
        Animal animal2 = new Cat();

        // 同一个方法，不同表现
        animal1.shout(); // 汪汪汪
        animal2.shout(); // 喵喵喵
    }
}

四、面向对象必备知识点

1. 构造方法

• 作用：创建对象 + 初始化属性

• 方法名与类名完全一致，没有返回值

• 每个类默认有一个无参构造

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

    // 无参构造
    public Student() {}

    // 有参构造
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

2. this 关键字

• 代表当前对象

• 区分成员变量和局部变量

• 调用本类的其他构造方法：this()

3. super 关键字

• 代表父类对象

• 调用父类的属性、方法、构造方法：super()

4. 方法重写（Override）

子类重写父类的方法，方法名、参数列表、返回值都要一致。

使用 @Override 注解标记。

5. 权限修饰符

控制属性/方法的访问范围：

修饰符	本类	同包	子类	任意位置
private	✅	❌	❌	❌
default	✅	✅	❌	❌
protected	✅	✅	✅	❌
public	✅	✅	✅	✅

日常开发最常用：private（私有） + public（公开）

五、面向对象开发小案例

需求：设计一个学生系统，包含学生基本信息、学习行为，使用 OOP 思想实现

// 父类：人类
class Person {
    private String name;
    private int age;

    public Person() {}

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

    public void showInfo() {
        System.out.println("姓名：" + name + "，年龄：" + age);
    }

    // getter/setter 省略
}

// 子类：学生
class Student extends Person {
    private String studentId;

    public Student() {}

    public Student(String name, int age, String studentId) {
        super(name, age); // 调用父类构造
        this.studentId = studentId;
    }

    // 学习行为
    public void study() {
        System.out.println("学号" + studentId + "的学生正在学习Java");
    }
}

测试：

public class StudentTest {
    public static void main(String[] args) {
        Student student = new Student("李四", 18, "S1001");
        student.showInfo(); // 继承父类
        student.study(); // 子类特有
    }
}

输出：

姓名：李四，年龄：18
学号S1001的学生正在学习Java

六、总结

Java 面向对象，核心就三点：封装、继承、多态。

1. 封装：把属性藏起来，安全又简洁

2. 继承：复用代码，减少重复

3. 多态：统一标准，灵活扩展

学习面向对象，不要死记硬背语法，多结合生活场景理解「类和对象」，多写小案例，很快就能熟练掌握。