类和对象是Java的绝对地基。不管你后面学集合、学框架、还是去刷面试题，绕来绕去都得回到这两个词上。很多新手看教程时总觉得概念飘忽，什么“类是模板，对象是实例”，听起来像绕口令，真正上手写代码时照样懵。我写这篇文章的目的很简单：把类和对象拆开嚼碎，从定义类到创建对象，从语法细节到内存变化，再到面试最爱挖的坑，一条线捋清楚。不管是刚入门Java的同学，还是准备校招社招的开发者，都能在这里找到可以直接用的干货。
我没有打算堆砌术语，所有概念都会配代码和场景说明。你会看到我是怎么理解一个类的，也会看到new一个对象时JVM里到底发生了什么。建议你打开IDE边看边敲，光看不练是真的记不住。
1. 类和对象的基本理解
1.1 类是什么？对象是什么？
我见过太多人把“类”和“对象”挂在嘴边，但问到本质时却说不出所以然。其实你只要抓住一个类比就行：类是一张产品设计图，对象是根据这张图生产出来的真实产品。
设计图上会标注这个产品有哪些属性（比如颜色、尺寸、重量），有哪些行为（比如开灯、播放音乐）。但设计图本身不能发光，也不能被拿在手里使用。只有按照设计图“生产”出来的实体，才可以真正被操作。在Java里，这张设计图就叫类（Class），生产出来的每一个实体就叫对象（Object）。
另外一个关键点是，Java是面向对象语言，不是面向类语言。类只是代码层面的一种组织方式，真正的运行逻辑都在对象上。我经常看到新人写了一个类，里面塞满了静态方法，然后全程用类名调用，这其实就退化成了面向过程。面向对象的精髓是让对象去负责自己的行为，而不是让一个外部工具类替它做所有事。
1.2 类的实体化：对象是运行时的存在
类在编译期是源代码文件，在运行期也是JVM里的一块“类模板”元数据。但对象不一样，对象是程序运行到new那一刻，在堆内存里实实在在分配出来的一块空间。你可以创建多个对象，它们各自拥有独立的属性存储空间，互不干扰。
// 定义一个类 public class Dog { String name; int age; void bark() { System.out.println(name + " is barking"); } }上面的Dog是一个类，它只是说明书。只有当执行new Dog()时，才会产生一只实际的狗：
public class Main { public static void main(String[] args) { Dog dog1 = new Dog(); dog1.name = "旺财"; dog1.age = 2; dog1.bark(); // 旺财 is barking Dog dog2 = new Dog(); dog2.name = "来福"; dog2.age = 3; dog2.bark(); // 来福 is barking } }dog1和dog2是两个完全独立的对象，你修改dog1的名字不会影响到dog2。这就是对象的独立性。同时，dog1和dog2都指向同一个类模板Dog，所以它们拥有相同的行为定义。
2. 类的定义与对象的创建
2.1 类的完整语法结构：从字段到方法
定义一个类没有你想象的那么玄乎，核心就是“属性 + 方法”的组合。不过，想让一个类显得规范、易维护，你必须在一开始就养成良好的习惯。
一个标准的类通常包含以下几部分：
- 访问修饰符：
public表示这个类可以跨包访问，不写就默认包私有。 - 字段（属性）：用来描述对象的状态。
- 构造器：特殊方法，用于初始化对象。
- 方法：描述行为。
- （可选）内部类、静态变量、常量等。
下面是一个比较完整的例子，注意我加了private修饰字段，并通过方法来访问。这是封装的基本要求，后面我还会细讲。
public class Student { // 字段用private，对外隐藏细节 private String name; private int score; // 构造器：无参构造 public Student() { // 默认值由JVM赋予，name为null，score为0 } // 构造器：带参构造 public Student(String name, int score) { this.name = name; this.score = score; } // 公开的getter和setter public String getName() { return name; } public void setName(String name) { this.name = name; } public int getScore() { return score; } public void setScore(int score) { this.score = score; } // 自定义行为方法 public void showInfo() { System.out.println("姓名：" + name + "，成绩：" + score); } }看到this关键字了吗？当方法参数和字段名冲突时，this.name指向当前对象的字段，防止歧义。这就是this最常见的用法。
2.2 构造器：对象初始化的关键节点
很多人忽视构造器的意义，其实它决定了一个对象“出生”时的状态。如果你只写了带参构造，却没有显式写无参构造，那么new Student()就会直接编译报错。因为Java编译器只在你一个构造器都没写时，才自动给一个默认无参构造。
我强烈建议：在一个类中同时显式定义无参构造和全参构造。无参构造配合setter可以分步赋值，全参构造方便一次性初始化，两种场景在真实开发中都会用到。比如从数据库查询出一个对象，你可能会用全参构造快速组装；如果是前端表单提交，你更可能先用无参构造创建对象，再逐个set值。
另外还有一个“坑”：构造器是可以私有的。把构造器设为private，外部就无法new这个类了。这正是单例模式的基础，面试里经常问。下面是一个最简单的饿汉式单例：
public class Singleton { private static Singleton instance = new Singleton(); private Singleton() {} public static Singleton getInstance() { return instance; } }这里private Singleton() {}阻止了外部创建对象，所有的使用方都必须通过getInstance()获得同一个实例。这就是“私有构造器”背后的实际价值。
2.3 new对象时JVM到底做了什么
每次执行new Student()，JVM并不是简简单单分配一块内存就完事。了解这个过程，对排查空指针异常和内存问题很有帮助。
- 检查类是否已加载，如果没有则先加载类模板。
- 在堆内存中为对象分配空间。
- 将字段初始化：先赋默认值（
null、0、false），再执行构造器里的赋值语句。 - 执行构造器的代码块。
- 通过栈中的引用变量指向这块堆内存。
我打个比方：new Student()就像一个工厂接到订单后，先检查图纸（类加载），接着空出一块场地（分配内存），然后按照图纸上的初始状态摆放设备（默认值初始化），再把订单里的具体要求加上去（构造器赋值），最后把场地地址写进你的通讯录（栈引用）。
这解释了一个经典问题：为什么String是引用类型却可以直接比较值？因为String类的特殊性。而对于普通对象，你用==比较的是引用地址，而不是内容。这一点在面试问答环节我会重点提。
3. 面向对象的核心特性：封装、继承、多态
3.1 封装：用private保护数据，用方法提供入口
封装不是单纯把字段设为private，而是通过访问控制，让外部不能随意篡改对象内部状态。就好比你家里的电器面板，你按下按钮就能使用，但你不能直接去碰里面的高压电路。private字段就是“高压电路”，public方法就是“按钮面板”。
实际开发中，封装的一个典型应用是校验逻辑。比如学生成绩不可能为负数，也几乎不可能超过100分。如果字段是public，外部可以直接给score赋一个1000，后果不可预知。但有了setter，你就能在入口处拦截：
public void setScore(int score) { if (score < 0 || score > 100) { throw new IllegalArgumentException("成绩不合理"); } this.score = score; }这样一来，任何非法赋值都会被挡在门外。我见过很多团队为了图省事，直接把字段设成public，最后查问题查得焦头烂额。封装带来的不仅仅是安全性，更是一种“约束的集中管理”，它让类的设计者掌握了数据的合法性规则。
3.2 继承：抽取共性，代码复用
继承解决的是“多个类之间共享代码”的问题。比如学生、老师、管理员都是人，它们共有的属性和行为（姓名、年龄、自我介绍）就可以放到父类Person里，子类用extends关键字继承，再写自己特有的部分。
public class Person { protected String name; protected int age; public Person(String name, int age) { this.name = name; this.age = age; } public void introduce() { System.out.println("我是" + name + "，今年" + age + "岁"); } } public class Student extends Person { private int score; public Student(String name, int age, int score) { super(name, age); // 调用父类构造器 this.score = score; } public void study() { System.out.println(name + "正在学习"); } }注意我用了protected关键字。它表示子类、同包类可以访问，外部不可随意访问，比private更宽松，比public更安全。这在父类中非常常用，属于一个需要仔细拿捏的访问级别。
继承还有一个重要的“隐藏知识”：子类构造器必须调用父类构造器，要么显式写super(...)，要么隐式调用父类无参构造。如果父类没有无参构造，子类又没有显式调用super(...)，就会编译报错。
3.3 多态：同一个行为，不同表现
多态是我当初学Java时最绕的一个点，理解核心就一句话：父类引用指向子类对象。比如：
Person p = new Student("张三", 18, 90); p.introduce(); // 调用的是子类重写后的逻辑这里p的静态类型是Person，但运行时实际对象是Student。如果Student重写了introduce()方法，调用p.introduce()会走子类的实现，而不是父类的。
这就引出了**重写（Override）和重载（Overload）**的区别：
- 重写：子类对父类方法进行重新定义，方法签名必须一样。
- 重载：同一个类中方法名相同，参数列表不同，跟返回类型无关。
多态大大提升了程序的扩展性。比如你有多种支付方式，只要它们都实现同一个接口，就能用统一的方式处理。这里顺带提一句，接口在Java里也是“类”的延伸，很多面试题都会问“抽象类和普通类的区别”，往往就是围绕接口和抽象类展开的。
4. 内部类与对象的高级操作
4.1 内部类分类与使用场景
内部类不是必须的，但用得恰当会让代码结构很清晰。Java里有四种内部类：
- 成员内部类：定义在类内部，可以访问外部类的所有成员。
- 局部内部类：定义在方法内部，只在方法内有效。
- 匿名内部类：没有类名的内部类，常用于快速实现接口或抽象类。
- 静态内部类：用
static修饰，不持有外部类对象引用。
成员内部类一个典型场景是，外部类的某个逻辑非常依赖一个辅助类，而这个辅助类只服务当前外部类。比如HashMap里就有一个Node内部类，用来存放键值对。你不希望在外部独立看到Node，但它又必须是HashMap的一部分，把它设计成内部类再合适不过。
下面是四种内部类的一个快速示例：
public class Outer { private int num = 10; // 成员内部类 class Inner { void show() { System.out.println(num); // 可以直接访问外部类私有成员 } } // 静态内部类 static class StaticInner { void show() { // 不能直接访问外部类非静态成员 } } void method() { // 局部内部类 class Local { } // 匿名内部类，比如new一个接口 Runnable r = new Runnable() { @Override public void run() { System.out.println("匿名内部类"); } }; } }匿名内部类在Java 8之后大部分被Lambda表达式替代，但很多老代码还是这种写法。至少你要能看懂。
4.2 对象数组与去重
热搜词里有“对象数组去重”，这个在实际开发中非常常见。比如从数据库查出一批用户对象，你需要按某个字段去重。Java 8之后，用Stream可以写得极其优雅：
List<User> users = ...; List<User> distinctUsers = users.stream() .collect(Collectors.toMap(User::getId, Function.identity(), (old, latest) -> old)) .values() .stream() .collect(Collectors.toList());代码逻辑是：toMap时指定主键为id，如果遇到重复id就保留旧值（第三个参数），然后把Map的values转回List。这种做法的好处是内存可控、逻辑清晰，不会像嵌套for循环那样低效又难读。
如果不想用lambda，那就老老实实维护一个Set，遍历时判断是否包含。但注意，普通Set判断的是对象引用，你必须重写equals和hashCode，否则同id不同引用的两个对象会被当成不同元素。很多新人在这里翻车，就是因为没有重写这两个方法。
4.3 匿名对象：临时使用的好帮手
匿名对象就是没有赋给任何变量的对象。比如：
new Student("李四", 20, 85).showInfo();这种写法适合只调用一次方法的场景。优点是不用额外声明变量，代码更简洁。缺点是对象生命周期很短，调用完之后即刻变成垃圾，频繁使用会增加GC压力。在循环里创建匿名对象尤其要小心，能复用就尽量复用。
5. 面试高频考点与疑难排查实录
5.1 类和对象相关的五个高频面试题
我整理了这些年面试别人和被别人面试时，出现频率极高的几个问题，每个都值得你反复琢磨。
1. 类和对象的区别是什么？
类是一类事物的模板，定义属性和方法的集合；对象是类的具体实例，拥有独立的内存空间。类是编译期存在的抽象，对象是运行期具体的值。
2. 为什么Java里main方法必须是static？
因为main是程序入口，JVM启动时还没有任何对象存在，只能通过类名直接调用。所以main必须是static，public要能被JVM访问，返回类型必须是void，参数是String[] args用于接收命令行参数。
3. 构造器能不能被static修饰？
不能。构造器是给new用的，new的过程是在堆上分配对象，这天然是一个实例化的过程。而static成员属于类本身，不依赖对象存在。两者逻辑矛盾，所以编译都不允许。
4.==和equals有什么区别？
==比较的是引用地址，equals是Object类的方法，默认也相当于==，但很多类（比如String、Integer）重写了equals，用来比较内容。因此，比较两个对象的“业务相等性”时，必须重写equals，同时重写hashCode，否则在HashSet、HashMap里会出错。
5. 抽象类和接口有什么区别？
抽象类重在“复用”，可以有字段、构造器，可以定义普通方法，用extends继承；接口重在“能力契约”，字段默认是public static final，方法默认是抽象方法（Java 8后可以有默认方法和静态方法）。在Java 8以后，两者语法边界越来越模糊，但设计意图完全不一样。面试时如果能举一个实际场景说明，非常加分。
5.2 空指针异常的三大来源与排查技巧
空指针（NullPointerException）是所有Java开发者的老朋友。它大多跟对象有关，而且多在你想当然时出现。我总结三个高频来源：
- 调用了一个本应初始化的对象，但对象的初始化被条件判断跳过了。
- 数组或集合中某个位置的元素是
null，直接取出来调用方法。 - 方法返回值可能为
null，没有判空就继续操作。
排查空指针，最快的手段是看异常堆栈，它精确到是哪一行代码抛出的。然后检查那一行调用的对象到底哪个是null。如果是链式调用，比如a.getB().getC().getName()，一旦中间某个环节返回null，整个链路就断了。Java 8之后可以用Optional链式处理，大幅降低空指针风险。
Optional.ofNullable(user) .map(User::getAddress) .map(Address::getCity) .ifPresent(System.out::println);这样的写法优雅且安全，但也要注意别滥用，全部套Optional会让代码变得啰嗦。只在可能为null的传递环节使用。
5.3 重写equals和hashCode的正确姿势
前面我反复提过equals和hashCode，这里展开讲一下。如果你要判断两个Person对象是否“同一个人”，标准是id相同，那么：
@Override public boolean equals(Object o) { if (this == o) return true; if (!(o instanceof Person)) return false; Person person = (Person) o; return id == person.id; } @Override public int hashCode() { return Objects.hash(id); }为什么hashCode也必须重写？因为基于哈希的容器（HashMap、HashSet）先根据hashCode定位桶，再用equals比较桶内元素。如果只重写equals不重写hashCode，那么两个业务相等的对象可能哈希值不同，导致它们被放到不同桶里，容器就会误判它们不相等。IDE一般提供自动生成快捷键，不要再手写样板代码。
6. 实操心得：更好的组织类和对象
6.1 控制类的大小：一个类一个职责
我见过很多一千行以上的“上帝类”，什么功能都往里塞，最后改一处崩三处。设计类的时候，一定要坚持单一职责原则：一个类只干一件事。比如学生类只管学生的数据和行为，学生成绩统计这件事应该交给一个专门的ScoreAnalyzer类，而不是让Student既保存个人信息又负责分析全班成绩。
控制类大小的一个实用标准是：如果你没法在一个屏幕里看完这个类的所有字段和方法，说明它已经太大了。此时就该考虑拆分。拆分的维度通常是“变化的频率”——经常一起变化的成员放一起，互相独立的拆开。
6.2 对象创建时的内存优化技巧
创建对象的开销不可忽视，特别是在循环和并发场景。下面是一些我实际用过的优化手段：
- 使用构建器模式（Builder Pattern）替代大量参数构造器。当构造器参数超过三四个时，代码可读性断崖式下降，用Builder可以清晰看到每个字段的赋值。
- 尽量复用对象。比如字符串拼接，别在循环里用
+，用StringBuilder。 - 频繁创建短生命周期对象会加重GC负担。能用基本类型就用基本类型，别动不动包装成Integer或Long。
- 对象池仅用于创建成本极高的对象，比如数据库连接、线程。普通小对象随便new，反而更省心。
构建器模式虽然会多写一点代码，但换个角度说，它也是为后续扩展留了空间。比如这个类以后要增加一个必填字段，用构造器会直接破坏旧代码，用Builder则只需新增方法，兼容性极好。
6.3 我踩过的一个典型坑：子类重写方法时误用了private
曾经有一次，我在子类继承父类时，想重写父类的某个方法，结果把子类里的方法写成了private。编译不报错，但运行时走的是父类方法，因为子类私有方法对父类引用完全不可见。这种“看似重写实则新写”的问题，是继承体系里最容易埋的坑之一。解决办法很简单：重写方法时权限绝不能低于父类，而且尽量加上@Override注解，让编译器帮你检查。
后来我养成了一个习惯：所有重写方法都强制加@Override。第一呢，可以让编译器确认确实是重写；第二，以后维护代码的人一眼能看出意图。这是一个零成本但收益很大的好习惯。
如果你正在练习类和对象，我建议你手写一个“图书馆管理系统”的小栗子，有Book类、Reader类、BorrowRecord类，用集合存对象，再实现借书、还书、查询。把封装、继承、多态、对象数组去重全部用上。做完这个项目，你对类和对象的理解会完全不同。
我个人在实际操作中的体会是，类和对象的概念不是背出来的，而是写出来的。每多写一个类，你就能多理解一层“为什么要有对象”这个看似天真的问题。等你写多了，自然会在脑海里自动形成“这个行为属于谁”的判断。到那天，你才算真正迈进了面向对象的大门。
