Java 面向对象基础超详细整理，从入门到精通-171主机测评

面向对象是 Java 核心编程思想，也是后续学习继承、多态、接口等知识点的基础。依次讲解面向对象思想、类与对象、内存结构、成员变量与局部变量、this 关键字、构造方法、封装、JavaBean、static 关键字，搭配语法详解、完整代码案例、核心规则与实战练习，适合零基础学习、课后复习以及面试备考。

一、面向对象思想

1.1 核心概念

面向对象不是某一门具体技术，而是一种编程指导思想，用来指导我们如何组织代码、如何分析并解决业务问题。Java 语言本身就是一门纯面向对象语言，倡导用现实生活的思维方式编写程序，让代码逻辑更贴合日常认知，可读性、可维护性大幅提升。

1.2 学习两大目标

熟练使用 Java 官方已经提供好的对象（例如Scanner键盘录入、Random随机数）；

学会自主设计类、创建自定义对象，解决个性化业务需求。

1.3 简单示例

我们之前使用的猜数字小游戏，就是典型的面向对象用法：

import java.util.Scanner;
import java.util.Random;

public class GuessGame {
public static void main(String[] args) {
// 创建已有对象
Random r = new Random();
Scanner sc = new Scanner(System.in);
// 调用对象方法
int randomNum = r.nextInt(100) + 1;
System.out.println("请输入猜测数字：");
int scNum = sc.nextInt();

if (scNum > randomNum) {
System.out.println("猜大了");
} else if (scNum < randomNum) {
System.out.println("猜小了");
} else {
System.out.println("猜中了");
}
}
}

当 Java 没有提供对应对象时，就需要我们自己定义类、创建对象来实现功能。

小结

面向对象是贴近生活的编程思想；学习重点分为使用已有对象和自定义对象两部分。

二、类和对象

2.1 类与对象的关系

类：可以理解为模板 / 设计图，描述一组事物共同的属性（特征）和行为（动作）；

对象：根据类模板创建出来的具体实例；

规则：Java 中必须先定义类，才能创建对象；一个类可以创建出多个不同对象。

2.2 类的组成

类由成员变量和成员方法两部分构成：

成员变量：描述事物特征，定义在所有方法外部；
成员方法：描述事物行为，格式和之前方法一致，去掉static关键字。

基础学生类示例：

// 定义学生类（模板）
public class Student {
// 成员变量：属性
String name;
int age;

// 成员方法：行为
public void study() {
System.out.println("学习Java");
}
public void eat() {
System.out.println("吃饭");
}
}

2.3 对象创建与使用格式

创建对象：类名对象名 = new 类名();

访问成员变量：对象名.变量名

调用成员方法：对象名.方法名(实参);

测试类代码：

public class TestStudent {
public static void main(String[] args) {
// 1. 创建学生对象
Student stu = new Student();

// 2. 访问、修改成员变量
System.out.println(stu.name);
System.out.println(stu.age);
stu.name = "李四";
stu.age = 24;
System.out.println(stu.name);
System.out.println(stu.age);

// 3. 调用成员方法
stu.study();
stu.eat();
}
}

2.4 实战练习：手机类

需求：定义手机类Phone，包含品牌、颜色、价格属性，打电话、发短信行为；创建两个手机对象并赋值、调用方法。

// 手机类
public class Phone {
// 成员变量
String brand;
String color;
double price;

// 打电话方法
public void call(String name) {
System.out.println("给" + "打电话");
}
// 发短信方法
public void sendMessage() {
System.out.println("群发短信");
}
}

// 测试类
public class PhoneTest {
public static void main(String[] args) {
// 对象1：小米白色 4999
Phone p1 = new Phone();
p1.brand = "小米";
p1.color = "白色";
p1.price = 4999;
System.out.println(p1.brand + " " + p1.color + " " + p1.price);
p1.call("好友");
p1.sendMessage();

// 对象2：华为黑色 6999
Phone p2 = new Phone();
p2.brand = "华为";
p2.color = "黑色";
p2.price = 6999;
System.out.println(p2.brand + " " + p2.color + " " + p2.price);
p2.call("家人");
p2.sendMessage();
}
}

小结

类是模板，对象是实例；成员变量描述属性，成员方法描述行为；牢记对象创建与成员访问格式。

三、类和对象内存图

3.1 Java 内存分区回顾

方法区：存放.class字节码文件，类加载时进入；
栈内存：main等方法运行、局部变量、对象引用地址存放；
堆内存：new出来的对象实体、成员变量全部存放在此。

3.2 单个对象内存流程

程序运行，Student.class、TestStudent.class加载进入方法区；

main方法入栈执行，执行Student stu = new Student();；

new在堆内存开辟空间，创建对象实体，成员变量赋予默认值；

堆内存产生地址，赋值给栈中的引用变量stu；

通过stu.变量/方法访问堆中数据、执行对应行为。

3.3 多个独立对象

Student stu1 = new Student();
Student stu2 = new Student();

两个new会在堆中开辟两块独立空间，两个对象的成员变量互不干扰，修改其中一个不会影响另一个。

3.4 多个引用指向同一个对象

Student stu1 = new Student();
Student stu2 = stu1;

stu2不会新建对象，只是复制stu1的堆内存地址，两个引用指向同一个实体。任意一个引用修改成员变量，另一个访问到的数据都会同步变化。

小结

对象引用存在栈，真实实体与成员变量存在堆；多引用同地址会数据联动，多new则相互独立。

四、成员变量和局部变量的区别

两类变量定义位置、内存、生命周期、默认值均不同，下面完整对比：

对比项成员变量局部变量

定义位置	类中、方法外部	方法内部、代码块内部
默认初始值	有默认值（和数组规则一致）	无默认值，使用前必须手动赋值
内存位置	堆内存	栈内存
生命周期	对象创建时存在，对象销毁时消失	方法调用时存在，方法执行完毕立即销毁
作用域	当前整个类范围内有效	仅当前方法 / 代码块内有效

代码区分演示

public class Student {
// 成员变量（方法外）
String name;

public void method() {
// 局部变量（方法内）
int age = 23;
}
}

小结

核心区分：看定义位置；成员变量随对象存在，局部变量随方法存在。

五、this 关键字

5.1 出现的问题

当局部变量和成员变量重名时，Java 遵循就近原则，优先使用局部变量，无法直接访问成员变量。示例：

public class Student {
String name;
public void sayHello(String name) {
// 就近原则，优先使用方法参数（局部变量）
System.out.println(name);
}
}

5.2 this 作用

this代表当前对象的引用（堆内存地址），格式：this.成员变量名，用来强制访问类中的成员变量，打破就近原则。

改造后代码：

public class Student {
String name;

public void sayHello(String name) {
System.out.println("局部变量：" + name);
// 访问成员变量
System.out.println("成员变量：" + this.name);
}
}

5.3 使用规则

变量不重名时，this.可以省略不写；

调用本类成员方法时，this.也可省略；

this只能代表当前对象引用，不能出现在静态环境中。

小结

this解决局部变量与成员变量重名问题，指代当前对象地址，无命名冲突时可省略。

六、构造方法

6.1 定义与作用

构造方法（构造器）：专门创建对象、并对成员变量完成初始化的特殊方法。执行时机：使用new创建对象时自动调用，无法手动主动调用。

6.2 语法格式

方法名必须和类名完全一致（大小写相同）；

没有返回值类型，连void都不能写；

可以携带参数，支持方法重载。

基础格式示例：

public class Student {
// 无参构造方法
public Student() {

}
// 有参构造方法（重载）
public Student(String name, int age) {
this.name = name;
this.age = age;
}

String name;
int age;
}

6.3 核心注意事项

一个类没有手动编写构造方法，编译器会自动提供一个默认无参构造；

一旦手动定义了有参构造，系统不再提供默认无参构造；

开发规范：建议一个类同时手动编写无参构造 + 有参构造，避免报错。

6.4 执行流程

执行Student stu = new Student("张三",23);时：

new在堆中开辟对象空间，成员变量赋默认值；

自动调用对应有参构造方法；

通过this为成员变量赋值；

构造执行完毕，对象创建完成，引用指向堆地址。

小结

构造方法用于创建对象 + 初始化属性；类中建议手动保留无参、有参两套构造。

七、封装

7.1 面向对象三大特征

面向对象三大核心特征：封装、继承、多态，本节讲解封装。

7.2 封装概念

基础封装：将属性（成员变量）和操作属性的行为（成员方法）封装到同一个类中，形成完整整体；

访问控制：使用权限修饰符private等，合理隐藏内部细节、合理暴露对外功能，实现数据安全与代码解耦。

7.3 权限修饰符

常用权限：private、默认权限、protected、public。

private（私有）：仅本类内部可访问，外部无法直接调用，用于隐藏核心数据 / 内部方法。

7.4 代码示例

未封装（外部可直接篡改成员变量）：

public class Phone {
public void call(String name) {
System.out.println("给" + name + "打电话");
saveLog();
}
// 内部记录日志，不需要对外暴露
public void saveLog() {
System.out.println("保存通话记录");
}
}

封装优化（用 private 隐藏内部方法）：

public class Phone {
public void call(String name) {
System.out.println("给" + name + "打电话");
saveLog();
}
// 私有方法，外部无法访问
private void saveLog() {
System.out.println("保存通话记录");
}
}

7.5 封装优势

保护数据安全，避免外部随意修改；

隐藏内部复杂实现，使用者只需要调用公开方法；

代码结构统一，后期维护更方便。

小结

封装核心：合理隐藏，合理暴露；private是最常用的隐藏修饰符。

八、JavaBean

8.1 标准 JavaBean 规范

JavaBean 是 Java 中标准实体类的开发规范，主要用于封装数据，日常开发、框架中广泛使用，规则如下：

类中所有成员变量使用private私有化；

为每个私有成员变量提供对应的getXxx()（获取值）、setXxx()（设置值）方法；

类中手动提供无参构造方法（可选补充有参构造）。

8.2 标准 JavaBean 示例

// 标准学生实体类（JavaBean）
public class Student {
// 成员变量私有化
private String name;
private int age;

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

// get方法：获取姓名
public String getName() {
return name;
}
// set方法：设置姓名
public void setName(String name) {
this.name = name;
}
// get方法：获取年龄
public int getAge() {
return age;
}
// set方法：设置年龄
public void setAge(int age) {
this.age = age;
}
}

8.3 使用方式

public class Test {
public static void main(String[] args) {
Student stu = new Student();
// 通过set赋值
stu.setName("张三");
stu.setAge(22);
// 通过get取值
System.out.println(stu.getName());
System.out.println(stu.getAge());
}
}

小结

JavaBean 是数据实体标准写法，私有化变量 + get/set + 无参构造是核心三要素。

九、static 关键字

9.1 基础作用

static为静态修饰符，可以修饰成员变量、成员方法。

9.2 静态成员三大特点

共享性：被static修饰的成员，属于整个类，被该类所有对象共享；

优先存在：静态内容随着类加载而加载，优先于对象存在；

调用方式：除了对象调用，还可以直接使用类名.静态成员调用（推荐写法）。

9.3 静态成员变量示例

public class User {
String name;
int age;
// 静态成员变量，所有对象共享
static int onlineNumber;
}

public class StaticTest {
public static void main(String[] args) {
User.onLineNumber++;
User u1 = new User();
u1.name = "张三";
u1.age = 23;
System.out.println(u1.name + " " + u1.age + " " + User.onLineNumber);

User.onLineNumber++;
User u2 = new User();
u2.name = "李四";
u2.age = 24;
System.out.println(u2.name + " " + u2.age + " " + User.onLineNumber);
}
}

9.4 静态成员方法（工具类场景）

静态方法常用来编写工具类，无需创建对象，直接通过类名调用。示例：数组工具类

public class ArrayTools {
// 求数组最大值（静态方法）
public static int getMax(int[] arr) {
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
if(arr[i] > max){
max = arr[i];
}
}
return max;
}
// 求数组最小值
public static int getMin(int[] arr) {
int min = arr[0];
for (int i = 1; i < arr.length; i++) {
if(arr[i] < min){
min = arr[i];
}
}
return min;
}
}

// 测试调用
public class TestTools {
public static void main(String[] args) {
int[] nums = {12,45,7,89,23};
// 类名直接调用，无需new对象
int max = ArrayTools.getMax(nums);
int min = ArrayTools.getMin(nums);
System.out.println("最大值：" + max);
System.out.println("最小值：" + min);
}
}

9.5 static 使用注意事项

静态方法只能直接访问静态成员，不能直接访问非静态成员；

静态环境中不能使用this关键字；

共享数据、通用工具方法优先使用static修饰。

9.6 拓展：重新认识 main 方法

public class HelloWorld {
public static void main(String[] args) {
System.out.println("HelloWorld");
}
}

public：权限最大，保证 JVM 可以访问；
static：JVM 调用时无需创建对象；
void：方法无返回值；
main：JVM 识别的固定方法名；
String[] args：早期用于接收控制台参数。

小结

static修饰内容属于类、全局共享；静态方法适合工具类，静态变量适合共享数据；静态中无this。

十、全文总结

面向对象思想：以现实事物为模型组织代码，分为使用已有对象、自定义对象两大学习方向；

类与对象：类是模板，对象是实例；成员变量存特征，成员方法存行为；

内存结构：引用、局部变量在栈，对象实体、成员变量在堆，class 文件在方法区；

变量区分：成员变量属于对象，局部变量属于方法，默认值、生命周期差异明显；

this 关键字：区分重名变量，指代当前对象引用；

构造方法：创建并初始化对象，建议同时保留无参、有参构造；

封装：三大特征之一，使用private隐藏细节，保证数据安全；

JavaBean：实体类标准规范，私有化变量 + get/set + 无参构造；

static 静态：内容属于类、全局共享，工具类、共享数据首选，静态环境不能使用this。

面向对象是 Java 体系的核心根基，以上知识点贯穿后续所有内容，建议多动手写类、创建对象、练习封装与静态用法，夯实基础。