01_类的定义（属性 方法 构造器）

一、类的基本概念

类（Class）是 Java 面向对象编程的核心，是对一类事物的抽象描述，包含这类事物的属性（特征）和方法（行为）。例如，"Person" 类可抽象描述人的姓名、年龄（属性）和吃饭、走路（方法）。

类是创建对象的 "模板"，对象是类的具体实例。通过类，我们可以将数据（属性）和操作数据的逻辑（方法）封装在一起，实现代码的模块化和复用。

二、类的定义语法

Java 类的基本定义语法如下：

[修饰符] class 类名 {
    // 属性（成员变量）
    [修饰符] 数据类型 属性名;
    
    // 构造器
    [修饰符] 类名(参数列表) {
        // 构造器体
    }
    
    // 方法（成员方法）
    [修饰符] 返回值类型 方法名(参数列表) {
        // 方法体
    }
}

• 修饰符：可选，如public、private、final等（控制类的访问权限或特性）。
• 类名：遵循帕斯卡命名法（首字母大写，如Person、UserService），需见名知意。
• 类体中可包含属性、构造器、方法三部分，顺序无严格要求，但通常按 "属性→构造器→方法" 的顺序组织。

三、属性（成员变量）

3.1 定义与作用

属性（Attribute）也称成员变量，用于描述类的静态特征（数据）。例如，"Student" 类的name（姓名）、score（成绩）都是属性。

定义语法：

[修饰符] 数据类型 属性名 [= 初始值];

• 数据类型：可以是基本数据类型（int、double等）或引用数据类型（String、数组、自定义类等）。
• 初始值：可选，若不指定，会有默认值（如int默认 0，String默认null）。

示例：

public class Student {
    // 基本类型属性
    private String name; // 姓名（默认值null）
    private int age = 18; // 年龄（指定初始值18）
    private double score; // 成绩（默认值0.0）
    
    // 引用类型属性
    private String[] hobbies; // 爱好（默认值null）
}

3.2 注意事项

1. 访问修饰符：属性通常使用private修饰（封装思想），通过公共方法（getter/setter）访问或修改，避免直接暴露。

public class Person {
    private String name; // 私有属性
    
    // 公共getter方法：获取属性值
    public String getName() {
        return name;
    }
    
    // 公共setter方法：修改属性值（可添加校验逻辑）
    public void setName(String name) {
        if (name != null && !name.isEmpty()) {
            this.name = name;
        }
    }
}

2. 与局部变量的区别：
   • 属性定义在类中，方法外；局部变量定义在方法内或方法参数中。
   • 属性有默认值；局部变量必须手动初始化后才能使用。
   • 属性的作用域是整个类；局部变量的作用域是其所在的方法或代码块。

四、方法（成员方法）

4.1 定义与作用

方法（Method）用于描述类的动态行为（操作），是封装了特定逻辑的代码块。例如，"Calculator" 类的add()（加法）、subtract()（减法）都是方法。

定义语法：

[修饰符] 返回值类型 方法名(参数列表) {
    // 方法体（实现逻辑）
    [return 返回值;]
}

• 返回值类型：方法执行后返回的结果类型，无返回值时用void。
• 参数列表：方法接收的输入数据，格式为 "数据类型 参数名"，多个参数用逗号分隔（可选）。
• 方法体：包含实现具体功能的代码，可使用属性、局部变量和控制流语句（if、for等）。

示例：

public class Calculator {
    // 无参数、无返回值的方法
    public void showWelcome() {
        System.out.println("欢迎使用计算器！");
    }
    
    // 有参数、有返回值的方法
    public int add(int a, int b) {
        int sum = a + b;
        return sum; // 返回计算结果
    }
    
    // 有参数、无返回值的方法（修改属性）
    private String lastResult; // 私有属性：记录上次计算结果
    
    public void recordResult(int result) {
        lastResult = "上次结果：" + result; // 使用类的属性
    }
}

4.2 方法的调用

方法定义后需通过对象调用（非静态方法），语法：

对象名.方法名(实际参数);

示例：

// 创建对象
Calculator calc = new Calculator();

// 调用无参方法
calc.showWelcome(); // 输出"欢迎使用计算器！"

// 调用有参有返回值方法
int result = calc.add(3, 5); // 调用add()，接收返回值8
System.out.println(result);

// 调用有参无返回值方法
calc.recordResult(result);

4.3 注意事项

1. 方法命名：遵循驼峰命名法（首字母小写，如getAge、calculateTotal），需体现方法的功能。
2. 方法的封装性：一个方法应只实现一个功能，避免 "万能方法"（如同时处理输入、计算、输出）。
3. 参数与返回值：参数和返回值的类型、含义需明确，便于调用者理解和使用。

五、构造器（Constructor）

5.1 定义与作用

构造器是一种特殊的方法，用于创建对象时初始化对象（如给属性赋值）。它与类同名，无返回值（连void都不能写）。

定义语法：

[修饰符] 类名(参数列表) {
    // 构造器体（通常用于初始化属性）
}

示例：

public class Person {
    private String name;
    private int age;
    
    // 无参构造器
    public Person() {
        // 初始化默认值
        name = "未知";
        age = 0;
    }
    
    // 有参构造器
    public Person(String name, int age) {
        // 用参数初始化属性
        this.name = name;
        this.age = age;
    }
}

5.2 构造器的调用

构造器通过new关键字调用，用于创建对象：

// 调用无参构造器创建对象
Person p1 = new Person(); 
System.out.println(p1.getName()); // 输出"未知"（默认值）

// 调用有参构造器创建对象
Person p2 = new Person("张三", 20);
System.out.println(p2.getName()); // 输出"张三"（参数初始化）

5.3 注意事项

1. 默认构造器：若类中未定义任何构造器，编译器会自动生成一个无参构造器（默认构造器）；若已定义构造器，默认构造器不会自动生成（需手动定义）。

public class Car {
    // 未定义构造器，编译器自动生成无参构造器
}

// 可正常调用无参构造器
Car car = new Car();

2. 构造器的作用：主要用于初始化对象属性，避免创建对象后需要手动调用多个setter方法赋值。
3. 不能被static、final等修饰：构造器是创建对象的特殊方法，这些修饰符与其语义冲突。

六、完整类定义示例

综合属性、方法、构造器的定义，以下是一个完整的类示例：

// 定义"Book"类
public class Book {
    // 属性（特征）
    private String title; // 书名
    private String author; // 作者
    private double price; // 价格
    
    // 构造器（初始化）
    // 无参构造器
    public Book() {
        title = "未命名";
        author = "未知";
        price = 0.0;
    }
    
    // 有参构造器
    public Book(String title, String author, double price) {
        this.title = title;
        this.author = author;
        this.price = price;
    }
    
    // 方法（行为）
    // 获取书籍信息
    public String getInfo() {
        return "书名：" + title + "，作者：" + author + "，价格：" + price + "元";
    }
    
    // 修改价格（带校验）
    public void setPrice(double price) {
        if (price >= 0) { // 价格不能为负数
            this.price = price;
        } else {
            System.out.println("价格不能为负数");
        }
    }
    
    // getter方法（获取私有属性）
    public String getTitle() {
        return title;
    }
}

// 使用Book类
public class TestBook {
    public static void main(String[] args) {
        // 创建对象（调用有参构造器）
        Book book = new Book("Java编程", "张三", 59.9);
        
        // 调用方法
        System.out.println(book.getInfo()); // 输出书籍信息
        book.setPrice(-10); // 尝试设置负价格（失败）
        book.setPrice(69.9); // 修改价格为69.9
        System.out.println(book.getInfo()); // 输出更新后的信息
    }
}

七、类定义的最佳实践

1. 单一职责原则：一个类应只描述一类事物（如User类只处理用户相关的属性和方法），避免过大的 "全能类"。
2. 属性私有化：属性用private修饰，通过getter/setter方法访问，实现封装和数据校验。
3. 构造器初始化：提供有参构造器便于快速初始化对象，同时保留无参构造器（避免使用反射或框架时出错）。
4. 方法语义清晰：方法名和参数应准确描述功能，如calculateTotal()比func1()更易理解。
5. 代码格式化：属性、构造器、方法按逻辑分组，使用空行分隔，提高可读性。

八、总结

类是 Java 面向对象编程的基础，其核心组成包括：

• 属性：描述类的特征（数据），封装对象的状态。
• 方法：描述类的行为（操作），封装处理数据的逻辑。
• 构造器：初始化对象，在创建对象时为属性赋值。

通过类的定义，我们可以将数据和操作数据的逻辑封装在一起，实现面向对象的核心特性（封装、继承、多态）。掌握类的定义是编写 Java 程序的基础，合理的类设计能显著提高代码的可维护性和复用性。