Java类和对象超详细讲解(看这一篇就够了!)
作者：星子yu
这篇文章主要介绍了Java类和对象超详细讲解的相关资料,包括类的定义、创建及使用,对象的创建和使用,成员变量与局部变量的区别,以及成员方法与普通方法的区别,文中通过代码介绍的非常详细,需要的朋友可以参考下
📌 类和对象是 Java 面向对象编程的核心概念
理解了类和对象，就理解了 Java 的灵魂
前言
本文将系统讲解 Java 面向对象编程的基础：类 和 对象 的概念、定义、使用，以及构造方法、this 关键字、封装等核心知识点。适合 Java 初学者阅读
什么是面向对象
1.1 面向对象 vs 面向过程
| 特点 | 面向过程 | 面向对象 |
|---|---|---|
| 关注点 | 过程、步骤 | 对象、实体 |
| 思维方式 | 「怎么做」 | 「谁来做」 |
| 代码组织 | 函数为单位 | 类为单位 |
| 典型语言 | C | Java、C++、Python |
举个栗子：洗衣服
- 面向过程：拿衣服 → 放盆里 → 加水 → 加洗衣粉 → 搓洗 → 晾干
- 面向对象：找洗衣机 → 放衣服 → 按按钮 → 等待 → 晾干
💡 面向对象把复杂的问题拆分成多个对象，每个对象负责自己的事情，降低耦合，提高复用
类和对象的基本概念
2.1 什么是类？
类（Class） 是对一类事物的抽象描述，是创建对象的模板
比如：「学生」是一个类，它有属性（姓名、年龄）和行为（学习、吃饭）
// 定义一个学生类
public class Student {
// 属性（成员变量）
String name; // 姓名
int age; // 年龄
// 行为（成员方法）
public void study() {
System.out.println(name + "正在学习");
}
public void eat() {
System.out.println(name + "正在吃饭");
}
}
2.2 什么是对象？
对象（Object） 是类的具体实例，是类的具体化/实例化
比如：「张三」是学生类的一个对象，「李四」是另一个对象
public class Test {
public static void main(String[] args) {
// 创建对象
Student s1 = new Student();
s1.name = "张三";
s1.age = 18;
s1.study(); // 张三正在学习
Student s2 = new Student();
s2.name = "李四";
s2.age = 20;
s2.study(); // 李四正在学习
}
}
2.3 类与对象的关系
类的定义
3.1 类的完整结构
[访问修饰符] class 类名 {
// 1. 成员变量（属性）
数据类型 变量名;
// 2. 构造方法
[访问修饰符] 类名(参数列表) {
// 初始化代码
}
// 3. 成员方法（行为）
[访问修饰符] 返回值类型 方法名(参数列表) {
// 方法体
}
}
3.2 实例：定义一个 Person 类
public class Person {
// 成员变量
String name; // 姓名
int age; // 年龄
String gender; // 性别
// 无参构造方法
public Person() {
System.out.println("创建了一个Person对象");
}
// 有参构造方法
public Person(String name, int age, String gender) {
this.name = name;
this.age = age;
this.gender = gender;
}
// 成员方法
public void introduce() {
System.out.println("我是" + name + "，今年" + age + "岁，性别" + gender);
}
public void eat(String food) {
System.out.println(name + "正在吃" + food);
}
}
对象的创建和使用
4.1 创建对象的语法
类名 对象名 = new 类名(参数);
public class Test {
public static void main(String[] args) {
// 使用无参构造创建对象
Person p1 = new Person();
p1.name = "张三";
p1.age = 18;
p1.gender = "男";
p1.introduce(); // 我是张三，今年18岁，性别男
// 使用有参构造创建对象
Person p2 = new Person("李四", 20, "女");
p2.introduce(); // 我是李四，今年20岁，性别女
p2.eat("火锅"); // 李四正在吃火锅
}
}
4.2 对象内存分析
Person p = new Person();
内存结构：
💡 内存要点：
p存储在栈中，保存对象的地址new Person()创建的对象在堆中- 成员变量有默认值：
int→ 0，boolean→ false，引用类型 → null
成员变量 vs 局部变量
5.1 区别对比
| 对比项 | 成员变量 | 局部变量 |
|---|---|---|
| 定义位置 | 类中，方法外 | 方法内、参数、代码块 |
| 默认值 | 有默认值 | 无默认值，必须先赋值 |
| 作用范围 | 整个类 | 定义它的代码块 |
| 生命周期 | 对象创建到销毁 | 方法调用到结束 |
| 存储位置 | 堆内存 | 栈内存 |
5.2 示例说明
public class Demo {
// 成员变量：有默认值
int a; // 默认 0
String name; // 默认 null
boolean flag; // 默认 false
public void test() {
// 局部变量：必须初始化
int b; // 编译错误！使用前必须赋值
b = 10; // 初始化后才能使用
// 同名情况：就近原则
int a = 100; // 局部变量 a
System.out.println(a); // 100（局部变量）
System.out.println(this.a); // 0（成员变量）
}
}
构造方法
6.1 什么是构造方法？
构造方法（Constructor） 用于创建对象并初始化成员变量。
[访问修饰符] 类名(参数列表) {
// 初始化代码
}
6.2 构造方法的特点
| 特点 | 说明 |
|---|---|
| 方法名与类名相同 | 必须完全一致 |
| 没有返回值类型 | 连 void 都没有 |
| 自动调用 | 创建对象时自动执行 |
| 可以重载 | 可以定义多个构造方法 |
6.3 默认构造方法
🔑 如果没有定义任何构造方法，编译器会自动生成一个无参构造方法。
如果已定义构造方法，编译器不再提供默认构造。
public class Dog {
String name;
// 手动定义了有参构造，无参构造不再自动生成
public Dog(String name) {
this.name = name;
}
}
public class Test {
public static void main(String[] args) {
Dog d1 = new Dog("旺财"); // 正确
Dog d2 = new Dog(); // 编译错误！没有无参构造
}
}
6.4 构造方法重载
public class Book {
String name;
String author;
double price;
// 无参构造
public Book() {
System.out.println("创建了一本书");
}
// 一个参数
public Book(String name) {
this.name = name;
}
// 两个参数
public Book(String name, String author) {
this.name = name;
this.author = author;
}
// 三个参数
public Book(String name, String author, double price) {
this.name = name;
this.author = author;
this.price = price;
}
}
this 关键字
7.1 this 的作用
this 代表当前对象的引用，用于区分成员变量和局部变量。
public class Student {
String name;
int age;
public Student(String name, int age) {
this.name = name; // this.name 是成员变量，name 是参数
this.age = age;
}
public void introduce() {
System.out.println("我是" + this.name + "，今年" + this.age + "岁");
}
}
7.2 this 的三种用法
| 用法 | 示例 | 说明 |
|---|---|---|
| 访问成员变量 | this.name | 区分同名变量 |
| 调用成员方法 | this.introduce() | 调用本类的方法 |
| 调用其他构造 | this(参数) | 必须在构造方法第一行 |
7.3 this 调用其他构造方法
public class Employee {
String name;
int age;
double salary;
// 无参构造 → 调用三参构造
public Employee() {
this("未知", 0, 0.0); // 必须在第一行
}
// 两参构造 → 调用三参构造
public Employee(String name, int age) {
this(name, age, 3000.0); // 默认工资
}
// 三参构造（最终初始化）
public Employee(String name, int age, double salary) {
this.name = name;
this.age = age;
this.salary = salary;
}
}
⚠️
this()调用必须放在构造方法的第一行，否则编译错误。
封装
8.1 什么是封装？
封装：隐藏对象的属性和实现细节，只提供公共访问方式。
好处：
- 提高安全性（防止非法赋值）
- 提高复用性
- 降低耦合度
8.2 封装的实现步骤
1. 属性私有化（private） 2. 提供公共的 getter 方法（取值） 3. 提供公共的 setter 方法（赋值）
8.3 封装示例
public class BankAccount {
// 1. 私有化属性
private String owner;
private double balance;
// 2. 无参构造
public BankAccount() {}
// 3. 有参构造
public BankAccount(String owner, double balance) {
this.owner = owner;
this.balance = balance;
}
// 4. getter 方法
public String getOwner() {
return owner;
}
public double getBalance() {
return balance;
}
// 5. setter 方法（带验证逻辑）
public void setOwner(String owner) {
this.owner = owner;
}
public void setBalance(double balance) {
if (balance >= 0) {
this.balance = balance;
} else {
System.out.println("余额不能为负数！");
}
}
// 6. 业务方法
public void deposit(double amount) {
if (amount > 0) {
balance += amount;
System.out.println("存款成功，当前余额：" + balance);
}
}
public void withdraw(double amount) {
if (amount > 0 && amount <= balance) {
balance -= amount;
System.out.println("取款成功，当前余额：" + balance);
} else {
System.out.println("取款失败，余额不足！");
}
}
}
访问修饰符
9.1 四种访问权限
| 修饰符 | 本类 | 同包 | 子类（不同包） | 其他 |
|---|---|---|---|---|
public | ✅ | ✅ | ✅ | ✅ |
protected | ✅ | ✅ | ✅ | ❌ |
| 默认（无修饰符） | ✅ | ✅ | ❌ | ❌ |
private | ✅ | ❌ | ❌ | ❌ |
9.2 使用建议
[!TIP]
💡 设计原则：
- 属性：一般用
private（封装）- 方法：一般用
public（对外提供服务）- 构造方法：一般用
public- 常量：用
public static final
public class Student {
// 私有属性
private String name;
private int age;
// 公共常量
public static final String SCHOOL = "清华大学";
// 公共方法
public void study() { }
// 私有方法：辅助方法
private void helper() { }
}
static 关键字
10.1 什么是 static？
static（静态）：属于类本身，不属于任何对象，被所有对象共享。
public class Student {
// 实例变量：每个对象独有
String name;
int age;
// 静态变量：所有对象共享
static String school = "清华大学";
static int count = 0; // 统计创建了多少学生
public Student(String name, int age) {
this.name = name;
this.age = age;
count++; // 每创建一个对象，count+1
}
}
10.2 static 的特点
| 特点 | 说明 |
|---|---|
| 属于类 | 随类加载而加载，早于对象创建 |
| 共享 | 被所有对象共享 |
| 访问方式 | 类名.静态成员（推荐）或 对象名.静态成员 |
10.3 static 的使用场景
public class Demo {
// 1. 静态变量：共享数据
static int count = 0;
// 2. 静态方法：工具方法，不依赖对象
public static int add(int a, int b) {
return a + b;
}
// 3. 静态代码块：类加载时执行一次
static {
System.out.println("类加载了");
}
}
// 使用
public class Test {
public static void main(String[] args) {
// 静态成员通过类名访问
System.out.println(Demo.count);
System.out.println(Demo.add(1, 2));
}
}
10.4 static 注意事项
⚠️ 静态方法只能访问静态成员，不能直接访问实例成员。
因为静态方法属于类，不依赖对象，而实例成员属于对象。
public class Demo {
int a = 10; // 实例变量
static int b = 20; // 静态变量
public static void test() {
// System.out.println(a); // 编译错误！
System.out.println(b); // 正确
// 如果要访问实例变量，需要创建对象
Demo d = new Demo();
System.out.println(d.a); // 正确
}
}
代码块
11.1 代码块的分类
| 类型 | 位置 | 执行时机 | 作用 |
|---|---|---|---|
| 普通代码块 | 方法中 | 方法调用时执行 | 控制变量作用域 |
| 实例代码块 | 类中，方法外 | 每次创建对象时执行 | 初始化实例成员 |
| 静态代码块 | 类中，方法外，加 static | 类加载时执行一次 | 初始化静态成员 |
| 同步代码块 | 方法中，加 synchronized | 方法调用时执行 | 线程同步（多线程部分讲） |
11.2 普通代码块
public class Demo {
public void test() {
// 普通代码块：控制变量作用域
{
int x = 10;
System.out.println("普通代码块：" + x);
}
// System.out.println(x); // 编译错误，x 已超出作用域
}
}
11.3 实例代码块（构造代码块）
public class Student {
String name;
int age;
// 实例代码块：每次创建对象时执行，先于构造方法
{
System.out.println("实例代码块执行");
age = 18; // 默认年龄
}
public Student(String name) {
this.name = name;
System.out.println("构造方法执行");
}
}
// 测试
public class Test {
public static void main(String[] args) {
Student s1 = new Student("张三");
/* 输出：
实例代码块执行
构造方法执行
*/
Student s2 = new Student("李四");
/* 输出：
实例代码块执行
构造方法执行
*/
}
}
11.4 静态代码块
public class Student {
String name;
static String school;
// 静态代码块：类加载时执行一次，只执行一次
static {
System.out.println("静态代码块执行");
school = "清华大学";
}
// 实例代码块
{
System.out.println("实例代码块执行");
}
public Student(String name) {
this.name = name;
System.out.println("构造方法执行");
}
}
// 测试
public class Test {
public static void main(String[] args) {
Student s1 = new Student("张三");
/* 输出：
静态代码块执行
实例代码块执行
构造方法执行
*/
Student s2 = new Student("李四");
/* 输出：
实例代码块执行
构造方法执行
*/
}
}
11.5 执行顺序总结
🔑 执行顺序：
静态代码块 → 实例代码块 → 构造方法
静态代码块只执行一次，实例代码块和构造方法每次创建对象时都执行。
public class Demo {
static { System.out.println("1. 静态代码块"); }
{ System.out.println("2. 实例代码块"); }
public Demo() { System.out.println("3. 构造方法"); }
public static void main(String[] args) {
new Demo();
System.out.println("---");
new Demo();
}
}
/* 输出：
1. 静态代码块
2. 实例代码块
3. 构造方法
---
2. 实例代码块
3. 构造方法
*/
11.6 同步代码块
📌 同步代码块用于多线程编程，确保线程安全。
将在 多线程 部分详细讲解。
// 预览（多线程部分再讲）
synchronized (对象锁) {
// 需要同步的代码
}
toString 方法
10.1 默认的 toString
所有类都继承自 Object 类，Object 类有 toString() 方法。
public class Test {
public static void main(String[] args) {
Student s = new Student();
s.name = "张三";
s.age = 18;
System.out.println(s); // Student@15db9742（默认：类名@地址）
System.out.println(s.toString()); // 同上
}
}
10.2 重写 toString
public class Student {
private String name;
private int age;
// 构造方法省略...
@Override
public String toString() {
return "Student{name='" + name + "', age=" + age + "}";
}
}
// 使用
Student s = new Student("张三", 18);
System.out.println(s); // Student{name='张三', age=18}
💡 在 IDEA 中，可以使用快捷键
Alt + Insert→toString()自动生成。
对象数组
11.1 什么是对象数组？
数组存储的是对象引用，而不是对象本身。
public class Test {
public static void main(String[] args) {
// 声明对象数组
Student[] students = new Student[3];
// 创建对象并赋值
students[0] = new Student("张三", 18);
students[1] = new Student("李四", 19);
students[2] = new Student("王五", 20);
// 遍历对象数组
for (Student s : students) {
System.out.println(s);
}
}
}
11.2 内存图解
小结
| 知识点 | 核心内容 |
|---|---|
| 类与对象 | 类是模板，对象是实例 |
| 构造方法 | 初始化对象，可重载，可互相调用 |
| this 关键字 | 当前对象引用，区分变量，调用构造 |
| 成员 vs 局部变量 | 作用范围、默认值、存储位置不同 |
| 封装 | private + getter/setter，提高安全性 |
| 访问修饰符 | public > protected > 默认 > private |
| static 关键字 | 属于类，被所有对象共享 |
| 代码块 | 普通/实例/静态/同步（多线程） |
| toString | 重写以返回有意义的字符串表示 |
写在最后
类和对象是 Java 面向对象编程的基石。下一篇我们将讲解 继承 —— 如何复用代码、建立类之间的关系！
到此这篇关于Java类和对象超详细讲解的文章就介绍到这了,更多相关Java类和对象内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！