Java中的基础：类

最新推荐文章于 2025-05-12 14:49:54 发布

CANI_PLUS

最新推荐文章于 2025-05-12 14:49:54 发布

阅读量1.3k

点赞数 20

CC 4.0 BY-SA版权

分类专栏： Java 文章标签： java 开发语言

本文链接：https://blog.youkuaiyun.com/qq_52460199/article/details/146126189

Java 专栏收录该内容

8 篇文章

订阅专栏

类（Class）详解

1. 定义

是什么？
类是面向对象编程（OOP）的核心概念，是用于创建对象的模板。它定义了对象的属性（字段）和行为（方法），是封装数据与操作的逻辑单元。

对象是类的实例：类是抽象蓝图，对象是具体的实体（如“汽车设计图”是类，“某辆红色跑车”是对象）。
组成要素：
- 属性（字段）：描述对象的状态（如 String name; int age;）。
- 方法：定义对象的行为（如 eat(), run()）。
- 构造方法：初始化对象属性（如 public Student(String name) { ... }）。

为什么需要类？

抽象现实世界：将实体抽象为代码中的数据结构（如“学生”类对应现实中的学生）。
封装复杂性：隐藏实现细节，暴露可控接口（如银行账户的余额修改必须通过方法）。
代码复用：通过实例化多个对象共享类的逻辑（如创建100个学生对象）。

2. 使用场景与实现方式

适用场景

建模现实实体：如用户、订单、商品等。
模块化开发：将功能拆分为多个类（如登录模块、支付模块）。
定义数据结构：如链表、树等复杂结构的节点类。
封装工具方法：如日期处理工具类（静态方法）。

如何定义类？

[访问修饰符] class 类名 {
    // 1. 属性（字段）
    [访问修饰符] 数据类型 属性名;
    
    // 2. 构造方法
    public 类名(参数列表) { ... }
    
    // 3. 方法
    [访问修饰符] 返回值类型 方法名(参数列表) { ... }
}

注意事项

单一职责原则：一个类只负责一个功能（如“订单类”处理订单数据，不处理支付逻辑）。
避免过度设计：不要为简单的逻辑创建过多冗余类。
合理使用访问修饰符：
- private：保护内部数据，仅允许类内访问。
- public：暴露必要接口供外部调用。
构造方法：
- 默认有无参构造方法，若自定义有参构造方法，需显式定义无参构造方法。
- 初始化对象时确保属性处于合法状态（如年龄不能为负数）。

3. 作用

封装数据与行为：将属性和方法绑定，隐藏实现细节。
代码复用：通过实例化多个对象复用类逻辑。
支持继承与多态：作为父类或子类，构建层次化结构。
提高可维护性：模块化设计便于单独修改和测试。

4. 代码案例与注解

场景1：基础类定义与实例化

/**
 * 学生类：定义属性、构造方法、方法
 */
public class Student {
    // 1. 属性（字段）
    private String name;  // 私有属性，外部不可直接访问
    private int age;

    // 2. 构造方法（初始化对象）
    public Student(String name, int age) {
        this.name = name;
        if (age < 0) {
            throw new IllegalArgumentException("年龄不能为负数");
        }
        this.age = age;
    }

    // 3. 公共方法（暴露访问接口）
    public void study(String subject) {
        System.out.println(name + "正在学习" + subject);
    }

    // Getter/Setter（封装访问）
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }
}

/**
 * 测试类
 */
public class Main {
    public static void main(String[] args) {
        // 4. 实例化对象
        Student student = new Student("张三", 18);
        student.study("Java");  // 输出：张三正在学习Java
        
        // 通过Getter访问属性
        System.out.println(student.getName());  // 输出：张三
    }
}

代码注解

属性定义：
```
private String name;
```
- 使用 private 封装，外部只能通过公共方法访问。
构造方法：
```
public Student(String name, int age) { ... }
```
- 初始化对象时校验年龄合法性。

方法定义：

public void study(String subject) { ... }

定义对象的行为逻辑。

实例化对象：
```
Student student = new Student("张三", 18);
```
- new 关键字调用构造方法创建对象。

场景2：静态成员与工具类

/**
 * 工具类：数学计算（静态方法）
 */
public class MathUtils {
    // 静态属性（类级别共享）
    public static final double PI = 3.1415926;

    // 静态方法（直接通过类名调用）
    public static int max(int a, int b) {
        return a > b ? a : b;
    }
}

public class Main {
    public static void main(String[] args) {
        int max = MathUtils.max(5, 10);  // 调用静态方法
        System.out.println("最大值：" + max);  // 输出：10
        
        System.out.println("PI的值：" + MathUtils.PI);  // 输出：3.1415926
    }
}

注释：

静态成员：属于类而非对象，通过 类名.成员名 直接访问。
适用场景：工具方法（如数学计算）、常量定义。

5. 高级应用

场景1：内部类（封装关联逻辑）

public class Outer {
    private String outerField = "外部类字段";

    // 内部类
    class Inner {
        public void print() {
            System.out.println("访问外部类字段：" + outerField);  // 直接访问外部类属性
        }
    }

    public static void main(String[] args) {
        Outer outer = new Outer();
        Inner inner = outer.new Inner();  // 创建内部类对象
        inner.print();  // 输出：访问外部类字段：外部类字段
    }
}

注释：

内部类：定义在另一个类内部，可直接访问外部类的私有成员。
适用场景：封装紧密关联的逻辑（如链表节点类）。

场景2：单例模式（限制实例化次数）

public class Singleton {
    // 1. 私有静态实例
    private static Singleton instance;

    // 2. 私有构造方法（禁止外部new）
    private Singleton() {}

    // 3. 公共静态方法获取实例
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }

    public void showMessage() {
        System.out.println("单例对象调用");
    }
}

public class Main {
    public static void main(String[] args) {
        Singleton obj1 = Singleton.getInstance();
        Singleton obj2 = Singleton.getInstance();
        System.out.println(obj1 == obj2);  // 输出：true（同一对象）
        obj1.showMessage();  // 输出：单例对象调用
    }
}