面向对象 类结构详解 Java编程中，如何定义和使用类的方法与实例

🚀 Java面向对象编程：类结构与方法实例全解析（2025最新版）

📚 一、类与对象基础

1 什么是类？

类（Class） 是对象的模板或蓝图，用于描述具有相同属性和行为的对象集合。
🌰 例子：Person类可以定义所有人的共同特征（姓名、年龄）和行为（问候、学习）。

public class Person {
    // 属性（成员变量）
    String name;
    int age;
    // 构造方法（初始化对象）
    public Person() {
        this.name = "未知";
        this.age = 0;
    }
    // 方法（行为）
    public void sayHello() {
        System.out.println("大家好，我是" + name + "，今年" + age + "岁！");
    }
}

2 什么是对象？

对象（Object） 是类的具体实例，通过new关键字创建。
🌰 例子：Person p1 = new Person(); 创建了一个Person对象。

Person p1 = new Person();
p1.name = "张三";
p1.age = 20;
p1.sayHello(); // 输出：大家好，我是张三，今年20岁！

🔧 二、方法定义与使用

1 方法的基本结构

方法（Method） 是实现特定功能的代码块,由以下部分组成：

• 访问修饰符：public、private等
• 返回类型：void或具体数据类型
• 方法名：遵循小驼峰命名法
• 参数列表：可选，定义输入数据

// 无参无返回值方法
public void greet() {
    System.out.println("你好！");
}
// 有参有返回值方法
public int add(int a, int b) {
    return a + b;
}

2 构造方法

构造方法（Constructor） 用于初始化对象，方法名与类名相同,无返回类型。

public class Person {
    String name;
    int age;
    // 无参构造方法
    public Person() {}
    // 有参构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

3 方法重载（Overloading）

同一类中允许多个同名方法,但参数列表必须不同。

public class MathUtils {
    // 方法1：两个整数相加
    public int add(int a, int b) {
        return a + b;
    }
    // 方法2：三个整数相加
    public int add(int a, int b, int c) {
        return a + b + c;
    }
}

4 this关键字

• 区分成员变量和局部变量：this.name表示成员变量，name表示局部变量。
• 调用同类其他构造方法：this(参数)必须放在构造方法首行。

public class Person {
    String name;
    public Person() {
        this("未知"); // 调用有参构造方法
    }
    public Person(String name) {
        this.name = name;
    }
}

🔄 三、实例的创建与使用

1 创建对象

通过new关键字实例化对象：

// 步骤1：声明对象引用
Person p1;
// 步骤2：创建对象实例
p1 = new Person();
// 合并为一步
Person p2 = new Person("李四", 25);

2 访问属性与方法

通过对象引用访问成员：

p1.name = "王五";
p1.age = 30;
p1.sayHello(); // 调用方法
int sum = mathUtils.add(5, 10); // 调用有返回值方法

🔒 四、封装与访问控制

1 访问修饰符

2 封装实现

通过private隐藏属性，提供public的getter/setter方法：

public class Person {
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        if (name != null && !name.isEmpty()) {
            this.name = name;
        } else {
            throw new IllegalArgumentException("姓名不能为空！");
        }
    }
}

🧬 五、继承与多态

1 继承语法

通过extends关键字实现继承：

public class Student extends Person {
    String school;
    public Student(String name, int age, String school) {
        super(name, age); // 调用父类构造方法
        this.school = school;
    }
    @Override
    public void sayHello() {
        super.sayHello(); // 调用父类方法
        System.out.println("我在" + school + "上学！");
    }
}

2 多态表现

• 编译时多态：方法重载
• 运行时多态：方法重写

Person p = new Student("张三", 20, "清华大学");
p.sayHello(); // 输出：大家好，我是张三，今年20岁！我在清华大学上学！

3 向上转型与向下转型

// 向上转型（自动）
Person person = new Student();
// 向下转型（需强制转换）
if (person instanceof Student) {
    Student student = (Student) person;
}

🧾 六、静态方法与成员

1 静态成员

• 静态变量：属于类,通过类名直接访问。
• 静态方法：不能访问非静态成员。

public class MathUtils {
    public static final double PI = 3.14159;
    public static int add(int a, int b) {
        return a + b;
    }
}
// 使用静态成员
MathUtils.add(5, 10);
System.out.println(MathUtils.PI);

🚀 七、现代Java特性（2025版）

1 JDK 21新特性

• 虚拟线程：轻量级线程,提升并发性能。
• 字符串模板：简化字符串拼接。

// 虚拟线程示例
ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
executor.submit(() -> {
    System.out.println("运行在虚拟线程上");
});
// 字符串模板
String name = "Java开发者";
String message = STR."欢迎, \{name}！今天是\{java.time.LocalDate.now()}";

2 Maven 4与Spring Boot 3.x

• Maven 4：更快构建速度，支持JDK 21。
• Spring Boot 3.x：基于Spring Framework 6,简化开发。

<!-- pom.xml示例 -->
<project>
    <properties>
        <maven.compiler.source>21</maven.compiler.source>
        <maven.compiler.target>21</maven.compiler.target>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>3.2.5</version>
        </dependency>
    </dependencies>
</project>

通过本文,你掌握了Java面向对象编程的核心概念：

1. 类与对象：模板与实例的关系。
2. 方法定义：构造方法、重载、this关键字。
3. 实例操作：创建对象、访问属性与方法。
4. 封装与继承：访问控制、多态实现。
5. 现代特性：JDK 21新特性与工具链升级。

💡 小贴士：多实践是掌握OOP的关键,赶紧写一个自己的类试试吧！