一、类的结构组成

在Java中，一个完整的类通常包含以下组成部分：

public class Person {
    // 1. 属性（成员变量/字段）
    private String name;    // 姓名
    private double height;  // 身高
    private int age;        // 年龄
    
    // 2. 方法（成员方法/行为）
    public void speak() {
        System.out.println(name + "正在说话");
    }
    
    public void run() {
        System.out.println(name + "正在跑步");
    }
    
    public int calculate(int a, int b) {
        return a + b;
    }
}

二、方法详解

1. 方法的基本语法

访问修饰符 返回值类型 方法名(参数类型 参数名, 参数类型 参数名, ...) {
    // 方法体
    [return 返回值;]
}

示例代码：

public class Calculator {
    
    // 无返回值方法
    public void printMessage() {
        System.out.println("这是一个计算方法");
    }
    
    // 有返回值方法
    public int sum(int a, int b) {
        return a + b;
    }
    
    // 多个参数的方法
    public double average(double x, double y, double z) {
        return (x + y + z) / 3.0;
    }
}

// 方法调用示例
Calculator calc = new Calculator();
calc.printMessage();            // 调用无返回值方法
int result = calc.sum(5, 3);    // 调用有返回值方法
System.out.println("结果：" + result);

三、构造方法

1. 构造方法的特点

public class Student {
    private String name;
    private int age;
    
    // 1. 无参构造方法（默认提供）
    public Student() {
        System.out.println("无参构造方法被调用");
    }
    
    // 2. 有参构造方法
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("有参构造方法被调用");
    }
    
    // 3. 构造方法重载
    public Student(String name) {
        this(name, 18);  // 默认年龄为18
    }
}

// 使用示例
public class Test {
    public static void main(String[] args) {
        Student s1 = new Student();           // 调用无参构造
        Student s2 = new Student("张三", 20); // 调用有参构造
        Student s3 = new Student("李四");     // 调用重载构造
    }
}

构造方法的注意事项：

1. 构造方法名必须与类名相同

2. 构造方法没有返回值类型，连void都不写

3. 一个类默认有无参构造方法

4. 如果定义了有参构造，则不再自动生成无参构造

5. 构造方法可以重载

四、this关键字

1. this的三种用法

public class Person {
    private String name;
    private int age;
    
    // 1. 区分成员变量和局部变量
    public void setName(String name) {
        this.name = name;  // this.name指成员变量，name指参数
    }
    
    // 2. 调用本类其他方法
    public void display() {
        this.showInfo();  // 调用本类的showInfo方法
    }
    
    public void showInfo() {
        System.out.println("姓名：" + name + "，年龄：" + age);
    }
    
    // 3. 调用本类其他构造方法
    public Person() {
        this("未知", 0);  // 调用另一个构造方法
    }
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

五、方法重载（Overload）

1. 为什么要使用方法重载？

不重载的问题：

class Polygon {
    // 每个图形都有独立的计算方法名
    public double getCircleArea(double radius) {
        return Math.PI * radius * radius;
    }
    
    public double getTriangleArea(double base, double height) {
        return 0.5 * base * height;
    }
    
    public double getRectangleArea(double width, double height) {
        return width * height;
    }
    
    public double getTrapezoidArea(double top, double bottom, double height) {
        return (top + bottom) * height / 2;
    }
}

使用方法重载改进：

class ShapeCalculator {
    // 使用方法重载，统一方法名
    public double getArea(double radius) {
        return Math.PI * radius * radius;  // 计算圆面积
    }
    
    public double getArea(double base, double height) {
        return 0.5 * base * height;  // 计算三角形面积
    }
    
    public double getArea(double width, double height, String shape) {
        if ("rectangle".equals(shape)) {
            return width * height;  // 计算矩形面积
        }
        return 0;
    }
    
    public double getArea(double a, double b, double h) {
        return (a + b) * h / 2;  // 计算梯形面积
    }
}

// 使用方法
ShapeCalculator calculator = new ShapeCalculator();
double circleArea = calculator.getArea(5.0);  // 调用计算圆面积的方法
double triangleArea = calculator.getArea(3.0, 4.0);  // 调用计算三角形面积的方法
double rectangleArea = calculator.getArea(3.0, 4.0, "rectangle");  // 调用计算矩形面积的方法

方法重载的规则：

• 方法名必须相同

• 参数列表必须不同（类型、个数、顺序至少一个不同）

• 返回类型可以相同也可以不同

• 与访问修饰符无关

• 与异常声明无关

六、值传递 vs 引用传递

1. 值传递（基本数据类型）

public class ValuePassingExample {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        
        System.out.println("交换前：a = " + a + ", b = " + b);
        swap(a, b);
        System.out.println("交换后：a = " + a + ", b = " + b);
    }
    
    public static void swap(int x, int y) {
        int temp = x;
        x = y;
        y = temp;
        System.out.println("方法内交换：x = " + x + ", y = " + y);
    }
}

输出结果：

交换前：a = 10, b = 20
方法内交换：x = 20, y = 10
交换后：a = 10, b = 20

2. 引用传递（引用数据类型）

class Student {
    String name;
    
    public Student(String name) {
        this.name = name;
    }
}

public class ReferencePassingExample {
    public static void main(String[] args) {
        Student stu1 = new Student("张三");
        Student stu2 = new Student("李四");
        
        System.out.println("交换前：stu1.name = " + stu1.name);
        System.out.println("交换前：stu2.name = " + stu2.name);
        
        swapReference(stu1, stu2);
        
        System.out.println("交换后：stu1.name = " + stu1.name);
        System.out.println("交换后：stu2.name = " + stu2.name);
        
        modifyObject(stu1);
        
        System.out.println("修改后：stu1.name = " + stu1.name);
    }
    
    public static void swapReference(Student a, Student b) {
        Student temp = a;
        a = b;
        b = temp;
    }
    
    public static void modifyObject(Student student) {
        student.name = "王五";
    }
}

输出结果：

交换前：stu1.name = 张三
交换前：stu2.name = 李四
交换后：stu1.name = 张三
交换后：stu2.name = 李四
修改后：stu1.name = 王五

核心区别总结：

特性	值传递	引用传递
传递内容​	值的副本	地址的副本
数据类型​	基本数据类型	引用数据类型
修改影响​	不影响原始值	可以修改对象内容
交换影响​	无法交换原始变量	无法交换原始引用

七、局部变量 vs 全局变量

1. 变量作用域示例

public class VariableExample {
    // 全局变量（成员变量）
    private String name = "全局变量";
    private static int count = 0;
    
    public void testMethod() {
        // 局部变量
        String localVar = "局部变量";
        int number = 100;
        
        System.out.println("局部变量：" + localVar);
        System.out.println("局部变量：" + number);
        
        // 可以访问全局变量
        System.out.println("全局变量：" + this.name);
        
        // 局部变量与全局变量同名
        String name = "同名的局部变量";
        System.out.println("局部变量name：" + name);
        System.out.println("全局变量name：" + this.name);
        
        // 代码块中的局部变量
        {
            int blockVar = 200;
            System.out.println("代码块变量：" + blockVar);
        }
        // System.out.println(blockVar);  // 错误！无法访问代码块变量
    }
    
    public void anotherMethod() {
        // 无法访问其他方法的局部变量
        // System.out.println(localVar);  // 编译错误！
        
        // 但可以访问全局变量
        System.out.println("访问全局变量：" + name);
    }
}

2. 变量作用域对比

对比项	全局变量（成员变量）	局部变量
声明位置​	类中，方法外	方法、构造方法或代码块内
作用域​	整个类（除静态方法）	所在的方法或代码块
生命周期​	对象创建到销毁	方法调用到结束
内存位置​	堆内存	栈内存
初始值​	有默认值	必须显式初始化
修饰符​	可以加访问修饰符	不能加访问修饰符

八、static关键字详解

1. 静态变量（类变量）

public class School {
    // 实例变量 - 每个对象独立
    private String studentName;
    private int studentId;
    
    // 静态变量 - 所有对象共享
    public static String schoolName = "清华大学";
    public static int studentCount = 0;
    
    public School(String studentName) {
        this.studentName = studentName;
        this.studentId = ++studentCount;  // 每创建一个学生，计数加1
    }
    
    public void showInfo() {
        System.out.println("学号：" + studentId);
        System.out.println("姓名：" + studentName);
        System.out.println("学校：" + schoolName);
        System.out.println("总人数：" + studentCount);
    }
}

// 使用示例
public class TestSchool {
    public static void main(String[] args) {
        School s1 = new School("张三");
        School s2 = new School("李四");
        School s3 = new School("王五");
        
        s1.showInfo();
        System.out.println("----------------");
        s2.showInfo();
        
        // 通过类名访问静态变量（推荐）
        System.out.println("学校名称：" + School.schoolName);
        
        // 通过对象访问静态变量（不推荐）
        System.out.println("总人数：" + s1.studentCount);
    }
}

2. 静态方法

public class MathUtils {
    // 静态变量
    public static final double PI = 3.1415926;
    
    // 静态方法
    public static int add(int a, int b) {
        return a + b;
    }
    
    public static double circleArea(double radius) {
        return PI * radius * radius;
    }
    
    public static int max(int a, int b, int c) {
        return Math.max(a, Math.max(b, c));
    }
    
    // 实例方法
    public void displayPI() {
        System.out.println("PI的值是：" + PI);
    }
}

// 使用示例
public class TestMath {
    public static void main(String[] args) {
        // 直接通过类名调用静态方法
        int sum = MathUtils.add(5, 3);
        double area = MathUtils.circleArea(2.5);
        int maxValue = MathUtils.max(10, 20, 15);
        
        System.out.println("和：" + sum);
        System.out.println("圆面积：" + area);
        System.out.println("最大值：" + maxValue);
        
        // 实例方法需要通过对象调用
        MathUtils utils = new MathUtils();
        utils.displayPI();
    }
}

3. 静态变量 vs 全局变量对比

特性	静态变量	全局变量（实例变量）
声明方式​	使用static修饰	不使用static修饰
内存位置​	方法区（静态区）	堆内存
加载时机​	类加载时创建	对象创建时创建
访问方式​	类名.变量名（推荐） 对象.变量名	对象.变量名
共享性​	所有对象共享一份	每个对象独享一份
生命周期​	与类共存亡	与对象共存亡
默认值​	有默认值	有默认值

九、综合示例

public class BankAccount {
    // 静态变量
    private static double interestRate = 0.03;  // 年利率
    private static int accountCount = 0;        // 账户总数
    
    // 实例变量
    private String accountNumber;
    private String accountHolder;
    private double balance;
    private final int accountId;
    
    // 构造方法
    public BankAccount(String accountHolder, double initialBalance) {
        this.accountHolder = accountHolder;
        this.balance = initialBalance;
        this.accountId = ++accountCount;  // 自动生成账户ID
        this.accountNumber = generateAccountNumber();
    }
    
    // 静态方法
    public static double calculateInterest(double amount, int years) {
        return amount * Math.pow(1 + interestRate, years) - amount;
    }
    
    public static int getAccountCount() {
        return accountCount;
    }
    
    public static void setInterestRate(double newRate) {
        interestRate = newRate;
    }
    
    // 实例方法
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
            System.out.println("存款成功！当前余额：" + balance);
        }
    }
    
    public void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            System.out.println("取款成功！当前余额：" + balance);
        } else {
            System.out.println("取款失败！余额不足。");
        }
    }
    
    public void displayAccountInfo() {
        System.out.println("账户ID：" + accountId);
        System.out.println("账号：" + accountNumber);
        System.out.println("户主：" + accountHolder);
        System.out.println("余额：" + balance);
        System.out.println("年利率：" + (interestRate * 100) + "%");
    }
    
    // 私有方法
    private String generateAccountNumber() {
        return "BANK" + String.format("%08d", accountId);
    }
}

// 测试类
public class TestBank {
    public static void main(String[] args) {
        // 创建账户
        BankAccount account1 = new BankAccount("张三", 1000);
        BankAccount account2 = new BankAccount("李四", 5000);
        
        // 显示账户信息
        account1.displayAccountInfo();
        System.out.println("----------------");
        account2.displayAccountInfo();
        
        // 操作账户
        account1.deposit(500);
        account1.withdraw(200);
        
        // 使用静态方法
        System.out.println("账户总数：" + BankAccount.getAccountCount());
        
        double interest = BankAccount.calculateInterest(10000, 5);
        System.out.println("10000元5年利息：" + interest);
        
        // 修改利率
        BankAccount.setInterestRate(0.035);
        System.out.println("利率已调整");
        
        account1.displayAccountInfo();
    }
}

十、总结与最佳实践

1. 方法设计原则

• 单一职责原则：一个方法只做一件事

• 命名规范：方法名使用动词开头，如getXXX(), setXXX(), calculateXXX()

• 参数数量：尽量保持参数数量在5个以内

• 方法长度：一个方法不要超过50行

2. 变量使用建议

• 优先使用局部变量

• 静态变量用于真正需要共享的数据

• 常量使用static final修饰

• 避免过度使用全局变量

3. 构造方法建议

• 提供有意义的无参构造

• 通过构造方法确保对象完整性

• 使用构造方法重载提高灵活性

4. 代码组织技巧

• 将相关的属性组织在一起

• 将相关的方法组织在一起

• 使用合适的访问修饰符

• 添加必要的注释和文档

通过合理使用方法和变量，可以创建出结构清晰、易于维护的Java程序。掌握这些基础知识是成为优秀Java开发者的第一步。