类的定义与结构
类是面向对象编程的核心概念。你可以把类理解为蓝图——它描述了一类事物应该有什么样的属性（数据）和行为（方法）。
类的定义
基本语法
java
[访问修饰符] class 类名 [extends 父类] [implements 接口1, 接口2...] {
// 类体
}一个最简的类：
java
public class User {
// 类体可以为空
}类的组成部分
┌─────────────────────────────────────────────────────────────┐
│ 类 │
├─────────────────────────────────────────────────────────────┤
│ 属性（字段/成员变量） │
│ - 实例变量 │
│ - 静态变量 │
├─────────────────────────────────────────────────────────────┤
│ 方法 │
│ - 实例方法 │
│ - 静态方法 │
├─────────────────────────────────────────────────────────────┤
│ 构造方法 │
├─────────────────────────────────────────────────────────────┤
│ 代码块 │
│ - 实例代码块 │
│ - 静态代码块 │
├─────────────────────────────────────────────────────────────┤
│ 内部类 │
└─────────────────────────────────────────────────────────────┘属性（字段）
属性描述对象的状态：
java
public class User {
// 实例变量：每个对象独立一份
private String name;
private int age;
// 静态变量：所有对象共享一份
public static int totalUsers = 0;
// 常量：不可修改
public static final String SYSTEM_NAME = "用户管理系统";
}方法
方法描述对象的行为：
java
public class User {
private String name;
private int age;
// 构造方法
public User(String name, int age) {
this.name = name;
this.age = age;
}
// getter
public String getName() {
return name;
}
// setter
public void setName(String name) {
this.name = name;
}
// 静态方法
public static int getTotalUsers() {
return totalUsers;
}
// 普通方法
public void display() {
System.out.println("姓名：" + name + "，年龄：" + age);
}
}构造方法
构造方法在创建对象时调用，用于初始化对象：
java
public class User {
private String name;
private int age;
// 无参构造
public User() {
this.name = "匿名";
}
// 有参构造
public User(String name) {
this.name = name;
}
// 全参构造
public User(String name, int age) {
this.name = name;
this.age = age;
}
}代码块
静态代码块
类加载时执行一次，用于初始化静态资源：
java
public class DatabaseConfig {
private static String url;
// 静态代码块：类加载时执行一次
static {
url = "jdbc:mysql://localhost:3306/mydb";
System.out.println("数据库配置加载完成");
}
}实例代码块
每次创建对象时执行，在构造方法之前执行：
java
public class User {
private String name;
// 实例代码块：每次 new 都执行
{
System.out.println("创建新用户对象");
this.name = "默认名称";
}
public User() {
}
public User(String name) {
this.name = name;
}
}执行顺序：
java
public class ExecutionOrderDemo {
static {
System.out.println("1. 静态代码块（类加载时）");
}
{
System.out.println("2. 实例代码块（每次 new）");
}
public ExecutionOrderDemo() {
System.out.println("3. 构造方法");
}
public static void main(String[] args) {
System.out.println("--- 第一个对象 ---");
new ExecutionOrderDemo();
System.out.println("--- 第二个对象 ---");
new ExecutionOrderDemo();
}
}输出：
1. 静态代码块（类加载时）
--- 第一个对象 ---
2. 实例代码块（每次 new）
3. 构造方法
--- 第二个对象 ---
2. 实例代码块（每次 new）
3. 构造方法访问修饰符
类的访问修饰符
| 修饰符 | 说明 |
|---|---|
public | 任何地方都可访问 |
| 默认（无修饰符） | 同一包内可访问 |
java
public class PublicClass { } // 任何地方可用
class PackageClass { } // 同一包内可用成员的访问修饰符
| 修饰符 | 同一类 | 同一包 | 子类 | 其他包 |
|---|---|---|---|---|
public | ✅ | ✅ | ✅ | ✅ |
protected | ✅ | ✅ | ✅ | ❌ |
| 默认 | ✅ | ✅ | ❌ | ❌ |
private | ✅ | ❌ | ❌ | ❌ |
java
public class MyClass {
public int publicField; // 任何地方可访问
protected int protectedField; // 同包或子类可访问
int defaultField; // 同包可访问
private int privateField; // 仅本类可访问
}完整示例
java
/**
* 用户类
* 演示类的完整结构
*/
public class User {
// ==================== 属性 ====================
/** 用户ID */
private Long id;
/** 用户名 */
private String username;
/** 密码 */
private String password;
/** 年龄 */
private int age;
// ==================== 静态属性 ====================
/** 用户总数 */
private static long userCount = 0;
/** 系统名称 */
private static final String SYSTEM_NAME = "用户管理系统";
// ==================== 构造方法 ====================
/**
* 无参构造
*/
public User() {
this.userCount++;
}
/**
* 有参构造
*/
public User(String username, String password, int age) {
this();
this.username = username;
this.password = password;
this.age = age;
}
// ==================== 方法 ====================
/**
* 用户登录
*/
public boolean login(String password) {
return this.password.equals(password);
}
/**
* 显示用户信息
*/
public void display() {
System.out.println("用户名：" + username);
System.out.println("年龄：" + age);
}
// ==================== getter/setter ====================
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if (age < 0 || age > 150) {
throw new IllegalArgumentException("年龄不合法");
}
this.age = age;
}
// ==================== 静态方法 ====================
public static long getUserCount() {
return userCount;
}
public static String getSystemName() {
return SYSTEM_NAME;
}
}类的命名规范
- 使用 PascalCase（首字母大写）
- 名词或名词短语
- 避免缩写
- 体现类的职责
java
// ✅ GOOD
public class UserService { }
public class OrderRepository { }
public class PaymentGateway { }
// ❌ BAD
public class Mgr { } // 缩写不清晰
public class doSomething { } // 动词开头总结
类 = 属性 + 方法 + 构造方法 + 代码块 + 内部类类是面向对象编程的基石。理解类的各个组成部分，是掌握 Java 面向对象的第一步。