《Java 100 天进阶之路》第7篇：Java面向对象简介

原创已于 2026-05-24 20:58:12 修改 · 335 阅读

10 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

标签

#java #开发语言 #后端 #面试 #求职招聘

于 2026-05-08 19:04:45 首次发布

Java 100 天进阶之路 | 从入门到上岗就业专栏收录该内容

67 篇文章

订阅专栏

第7篇：Java面向对象简介

📌 系列导航：《Java 100 天进阶之路》完整目录 |
⬅️ 上一篇：第6篇：Java异常有哪几种 |
➡️ 下一篇：第8篇：Java基本数据类型

一、核心知识点

面向对象（OOP）的核心思想：对象、类、继承、封装、多态
类与对象的关系（蓝图与实例）
封装的意义：隐藏实现细节，暴露公共方法
继承：代码复用，extends关键字
多态：父类引用指向子类对象，方法重写
面向过程（POP）与面向对象（OOP）的对比

二、通俗讲解（1分钟开心学）

1. 面向过程 vs 面向对象

面向过程：以“函数”为核心，数据和方法分开。就像一份菜谱：先洗菜，再切菜，再炒菜。优点是简单直接，缺点是代码难扩展。
面向对象：以“对象”为核心，把数据和操作打包在一起。就像你有一个“厨师”对象，他有菜刀、锅、食材属性，也有“做菜”方法。你只管跟厨师说“做菜”，不用管内部细节。

生活类比：
面向过程就像去修理店，你跟老板说：“先拿螺丝刀，拆后盖，换电池，装后盖。”（每一步都要你指挥）
面向对象就像你直接把手机给维修机器人，说：“帮我换电池。”机器人自己会拿工具、拆机、更换。你只关心结果，不关心过程。

2. 四大特征

封装：把数据（属性）和行为（方法）包在一起，对外隐藏内部细节。比如汽车的油门踏板，你踩它就加速，但你不需要知道发动机怎么喷油。
继承：子类继承父类的属性和方法，实现代码复用。比如“电动汽车”继承“汽车”，拥有汽车的所有功能，还可以增加充电功能。
多态：同一个行为，不同对象表现出不同形态。比如“动物”都有“叫”的方法，猫叫“喵”，狗叫“汪”。
抽象（常作为第四特征）：只定义规范，不实现具体细节。比如“形状”有“计算面积”的方法，但不知道具体怎么算。

3. 类与对象

类：图纸。定义了一类事物共有的属性和行为。
对象：根据图纸造出来的实物。每个对象都有自己的状态（属性值）。

三、实操代码案例 + 场景说明

场景：你要开发一个学生管理系统，需要描述学生的基本信息（姓名、年龄、成绩），并能打印自我介绍。

1. 封装示例

public class Student {
    // 私有属性（隐藏内部数据）
    private String name;
    private int age;
    private double score;
    
    // 构造方法（创建对象时初始化）
    public Student(String name, int age, double score) {
        this.name = name;
        setAge(age);      // 调用setter做校验
        this.score = score;
    }
    
    // 公共 getter/setter（提供访问入口）
    public String getName() { return name; }
    public int getAge() { return age; }
    public double getScore() { return score; }
    
    public void setAge(int age) {
        if (age >= 0 && age <= 120) {
            this.age = age;
        } else {
            throw new IllegalArgumentException("年龄非法");
        }
    }
    
    // 行为方法
    public void introduce() {
        System.out.println("我是" + name + "，今年" + age + "岁，成绩" + score);
    }
}

2. 继承示例

// 父类
class Person {
    protected String name;
    public Person(String name) { this.name = name; }
    public void eat() { System.out.println(name + "在吃饭"); }
}
// 子类
class Teacher extends Person {
    private String subject;
    public Teacher(String name, String subject) {
        super(name);
        this.subject = subject;
    }
    public void teach() { System.out.println(name + "教" + subject); }
    // 重写父类方法
    @Override
    public void eat() { System.out.println(name + "老师在食堂吃饭"); }
}

3. 多态示例

Person p = new Teacher("张老师", "Java");
p.eat();                    // 输出：张老师在食堂吃饭（子类重写的方法）
// p.teach(); // 编译错误，父类引用无法调用子类特有方法

if (p instanceof Teacher) {
    Teacher t = (Teacher) p;
    t.teach();              // 向下转型后可以调用
}

四、避坑要点

错误/误区	后果	正确做法
把所有属性都写成`public`	数据不安全，难以维护	用`private` + `getter/setter`
继承时重写方法忘了写`@Override`	容易写错成重载，导致意外不执行	始终加上`@Override`注解
多态时滥用`instanceof`和向下转型	代码冗长，违反开闭原则	优先在父类中定义足够的方法
构造方法中调用可被子类重写的方法	子类未完全初始化，可能空指针	构造方法中只调用`private/final`方法

五、面试高频考点

Q1：面向对象和面向过程的区别？

面向过程以函数为中心，数据与函数分离，适合简单、固定流程的任务。面向对象以对象为中心，封装、继承、多态使代码更易维护和扩展。

Q2：继承和组合如何选择？

继承是“is-a”关系（狗是动物），组合是“has-a”关系（汽车有引擎）。组合更灵活，避免继承的紧耦合，优先使用组合。

Q3：多态的实现原理（JVM层面）？

通过方法表（vtable）实现。子类重写方法会替换父类方法在方法表中的条目，运行时根据实际对象类型查找调用。

六、练习题

设计题：定义一个BankAccount类，包含账号、余额、存款、取款方法，要求余额不能为负，取款不能超过余额。

代码阅读：给出以下代码输出，并解释原因。

class A { void print() { System.out.print("A"); } }
class B extends A { void print() { System.out.print("B"); } }
public class Test {
    public static void main(String[] args) {
        A a = new B();
        a.print();
    }
}