Java 类和方法详解

Java类和方法详解

🎯 适用读者

• Java初学者：已掌握Java基本语法、数据类型和变量的读者
• 编程转语言者：有其他编程语言基础，想学习Java的开发者
• 知识巩固者：需要复习Java面向对象基础概念的开发者

📚 学习目标

完成本教程后，您将能够：

• ✅ 理解Java类和对象的核心概念
• ✅ 掌握构造函数的定义和使用
• ✅ 熟练使用方法重载技术
• ✅ 理解访问修饰符的作用和应用
• ✅ 能够设计和实现简单的Java类
• ✅ 具备面向对象编程的基础思维

🛠️ 环境准备

开发环境要求

• JDK版本：JDK 8或更高版本（推荐JDK 17）
• IDE推荐：
  • IntelliJ IDEA（推荐）
  • Eclipse
  • Visual Studio Code
  • NetBeans

快速环境检查

# 检查Java版本
java -version

# 检查编译器版本
javac -version

创建第一个Java项目

1. 在IDE中创建新项目
2. 创建包结构：com.example.learning
3. 创建测试类：TestClass.java

📚 目录

• Java类基础概念
• 类的定义和结构
• 构造函数详解
• 方法重载
• 访问修饰符
• 实际应用示例
• 最佳实践
• 常见错误和注意事项

---

🎯 Java类基础概念

什么是类？

类是Java面向对象编程的核心概念，它是一个模板或蓝图，用来创建对象。类定义了对象的属性（成员变量）和行为（方法）。

类与对象的关系

• 类：模板、设计图
• 对象：根据类创建的具体实例

/**
 * Car类：代表汽车这个实体
 * 这个类演示了Java类的基本结构：属性（成员变量）+ 行为（方法）
 * 体现了面向对象编程的封装思想
 */
public class Car {
    // ========== 属性（成员变量）部分 ==========
    // 定义汽车的基本特征，使用private确保数据安全
    
    private String brand;    // 品牌：汽车的制造商品牌，如"丰田"、"本田"
    private String color;     // 颜色：汽车的外观颜色，如"红色"、"蓝色"
    private int speed;       // 速度：当前行驶速度，单位：公里/小时，初始值为0
    
    // ========== 行为（方法）部分 ==========
    // 定义汽车可以执行的操作，体现对象的行为
    
    /**
     * 启动汽车的方法
     * 功能：模拟汽车启动过程
     * 无参数，无返回值
     */
    public void start() {
        // 输出启动信息，让用户知道汽车已经启动
        System.out.println("汽车启动");
        System.out.println("品牌：" + brand + "，颜色：" + color);
    }
    
    /**
     * 加速方法
     * 功能：每次调用将速度增加10公里/小时
     * 无参数，无返回值
     * 注意：这里没有速度上限检查，实际应用中应该添加
     */
    public void accelerate() {
        speed += 10;  // 速度递增10公里/小时
        // 输出当前速度信息，让用户了解加速效果
        System.out.println("加速，当前速度：" + speed + "公里/小时");
    }
    
    /**
     * 获取当前速度的方法
     * 功能：返回当前速度值
     * 返回值：int类型的速度值
     */
    public int getSpeed() {
        return speed;  // 返回当前速度
    }
}

🎯 实践练习

练习1：创建你的第一个类

// 任务：创建一个Student类
// 要求：
// 1. 包含姓名(name)、年龄(age)、学号(studentId)属性
// 2. 包含一个study()方法，输出学习信息
// 3. 包含一个getInfo()方法，返回学生基本信息

// 你的代码写在这里：

练习2：理解类与对象

// 任务：使用Car类创建对象并测试
public class CarTest {
    public static void main(String[] args) {
        // 1. 创建Car对象
        // 2. 调用start()方法
        // 3. 调用accelerate()方法3次
        // 4. 输出最终速度
        
        // 你的代码写在这里：
    }
}

---

🏗️ 类的定义和结构

类的基本结构

[访问修饰符] class 类名 {
    // 成员变量（属性）
    [访问修饰符] 数据类型 变量名;
    
    // 构造函数
    [访问修饰符] 类名(参数列表) {
        // 初始化代码
    }
    
    // 方法
    [访问修饰符] 返回类型 方法名(参数列表) {
        // 方法体
    }
}

成员变量类型

1. 实例变量：每个对象都有自己的一份
2. 类变量（静态变量）：所有对象共享一份

public class Student {
    // 实例变量：每个Student对象都有自己独立的name和age
    private String name;  // 学生姓名
    private int age;      // 学生年龄
    
    // 类变量（静态变量）：所有Student对象共享同一个studentCount
    private static int studentCount = 0;  // 学生总数计数器，初始值为0
    
    // 构造函数：创建Student对象时自动调用
    public Student(String name, int age) {
        this.name = name;        // 使用this关键字区分参数和成员变量
        this.age = age;          // 初始化学生年龄
        studentCount++;          // 每创建一个学生对象，总数加1
    }
    
    // 实例方法：只有创建了Student对象后才能调用
    public void study() {
        System.out.println(name + "正在学习");  // 输出当前学生的学习状态
    }
    
    // 类方法（静态方法）：不需要创建对象，直接用类名调用
    public static int getStudentCount() {
        return studentCount;  // 返回当前学生总数
    }
}

---

🔧 构造函数详解

什么是构造函数？

构造函数是类的特殊方法，用于初始化对象。它具有以下特点：

• 方法名与类名相同
• 没有返回类型（连void都没有）
• 在创建对象时自动调用

构造函数的类型

1. 默认构造函数

public class Person {
    private String name;
    private int age;
    
    // 默认构造函数（无参数）
    public Person() {
        this.name = "未知";
        this.age = 0;
    }
}

2. 带参数的构造函数

public class Person {
    private String name;
    private int age;
    
    // 带参数的构造函数
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

3. 构造函数重载

public class Person {
    private String name;
    private int age;
    private String email;
    
    // 无参构造函数
    public Person() {
        this.name = "未知";
        this.age = 0;
        this.email = "";
    }
    
    // 两个参数的构造函数
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
        this.email = "";
    }
    
    // 三个参数的构造函数
    public Person(String name, int age, String email) {
        this.name = name;
        this.age = age;
        this.email = email;
    }
}

构造函数调用示例

public class Test {
    public static void main(String[] args) {
        // 调用不同的构造函数
        Person p1 = new Person();                    // 调用无参构造函数
        Person p2 = new Person("张三", 25);         // 调用两参构造函数
        Person p3 = new Person("李四", 30, "lisi@email.com"); // 调用三参构造函数
    }
}

🎯 实践练习

练习3：构造函数重载

// 任务：为Student类添加构造函数重载
// 要求：
// 1. 无参构造函数：设置默认值
// 2. 两参构造函数：姓名和年龄
// 3. 三参构造函数：姓名、年龄、学号
// 4. 创建测试类，使用不同构造函数创建对象

// Student类代码：
public class Student {
    private String name;
    private int age;
    private String studentId;
    
    // 你的构造函数代码写在这里：
}

// 测试类代码：
public class StudentTest {
    public static void main(String[] args) {
        // 你的测试代码写在这里：
    }
}

---

🔄 方法重载

什么是方法重载？

方法重载是指在同一个类中定义多个方法名相同但参数列表不同的方法。

重载的条件

1. 方法名必须相同
2. 参数列表必须不同（参数个数、类型、顺序）
3. 返回类型可以不同（但不能仅靠返回类型区分）
4. 必须在同一个类中

方法重载示例

public class Calculator {
    // 方法重载示例1：整数加法
    // 参数：两个int类型的整数
    // 返回：int类型的和
    public int add(int a, int b) {
        return a + b;  // 返回两个整数的和
    }
    
    // 方法重载示例2：浮点数加法
    // 参数：两个double类型的浮点数
    // 返回：double类型的和
    public double add(double a, double b) {
        return a + b;  // 返回两个浮点数的和
    }
    
    // 方法重载示例3：三个整数加法
    // 参数：三个int类型的整数
    // 返回：int类型的和
    public int add(int a, int b, int c) {
        return a + b + c;  // 返回三个整数的和
    }
    
    // 方法重载示例4：字符串连接
    // 参数：两个String类型的字符串
    // 返回：String类型的连接结果
    public String add(String a, String b) {
        return a + b;  // 使用+操作符连接两个字符串
    }
}

重载调用示例

public class Test {
    public static void main(String[] args) {
        // 创建Calculator对象实例
        Calculator calc = new Calculator();
        
        // 测试方法重载：Java会根据参数类型和个数自动选择对应的方法
        System.out.println(calc.add(5, 3));           // 调用 int add(int, int)，输出：8
        System.out.println(calc.add(5.5, 3.2));       // 调用 double add(double, double)，输出：8.7
        System.out.println(calc.add(1, 2, 3));        // 调用 int add(int, int, int)，输出：6
        System.out.println(calc.add("Hello", "World")); // 调用 String add(String, String)，输出：HelloWorld
    }
}

---

🔒 访问修饰符

四种访问修饰符

修饰符	同类	同包	子类	其他包
private	✅	❌	❌	❌
default	✅	✅	❌	❌
protected	✅	✅	✅	❌
public	✅	✅	✅	✅

详细说明

1. private（私有）

public class BankAccount {
    private double balance;  // 私有变量：账户余额，只能在类内部访问，确保数据安全
    
    // 私有方法：验证金额是否有效，只能在类内部调用
    private void validateAmount(double amount) {
        if (amount < 0) {
            // 如果金额为负数，抛出异常
            throw new IllegalArgumentException("金额不能为负数");
        }
    }
    
    // 公共方法：存款操作，外部可以调用
    public void deposit(double amount) {
        validateAmount(amount);  // 先验证金额是否有效
        balance += amount;       // 增加账户余额
        System.out.println("存款成功，当前余额：" + balance);
    }
}

2. default（包访问）

class PackageClass {  // 没有访问修饰符，默认为包访问
    int packageVar = 10;  // 包访问变量
    
    void packageMethod() {  // 包访问方法
        System.out.println("包访问方法");
    }
}

3. protected（受保护）

public class Animal {
    protected String name;  // 受保护变量，子类可以访问
    
    protected void eat() {  // 受保护方法
        System.out.println(name + "在吃东西");
    }
}

public class Dog extends Animal {
    public void bark() {
        eat();  // 可以调用父类的protected方法
        System.out.println(name + "在叫");  // 可以访问父类的protected变量
    }
}

4. public（公共）

public class PublicClass {
    public int publicVar = 100;  // 公共变量，任何地方都可以访问
    
    public void publicMethod() {  // 公共方法
        System.out.println("公共方法");
    }
}

---

💡 实际应用示例

完整的类设计示例

public class Book {
    // 私有成员变量
    private String title;
    private String author;
    private int pages;
    private double price;
    private boolean isAvailable;
    
    // 构造函数重载
    public Book() {
        this.title = "未知";
        this.author = "未知";
        this.pages = 0;
        this.price = 0.0;
        this.isAvailable = true;
    }
    
    public Book(String title, String author) {
        this.title = title;
        this.author = author;
        this.pages = 0;
        this.price = 0.0;
        this.isAvailable = true;
    }
    
    public Book(String title, String author, int pages, double price) {
        this.title = title;
        this.author = author;
        this.pages = pages;
        this.price = price;
        this.isAvailable = true;
    }
    
    // Getter方法（访问器）
    public String getTitle() {
        return title;
    }
    
    public String getAuthor() {
        return author;
    }
    
    public int getPages() {
        return pages;
    }
    
    public double getPrice() {
        return price;
    }
    
    public boolean isAvailable() {
        return isAvailable;
    }
    
    // Setter方法（修改器）
    public void setTitle(String title) {
        this.title = title;
    }
    
    public void setAuthor(String author) {
        this.author = author;
    }
    
    public void setPages(int pages) {
        if (pages > 0) {
            this.pages = pages;
        } else {
            System.out.println("页数必须大于0");
        }
    }
    
    public void setPrice(double price) {
        if (price >= 0) {
            this.price = price;
        } else {
            System.out.println("价格不能为负数");
        }
    }
    
    // 业务方法
    public void borrow() {
        if (isAvailable) {
            isAvailable = false;
            System.out.println("《" + title + "》已被借出");
        } else {
            System.out.println("《" + title + "》已被借出，无法再借");
        }
    }
    
    public void returnBook() {
        if (!isAvailable) {
            isAvailable = true;
            System.out.println("《" + title + "》已归还");
        } else {
            System.out.println("《" + title + "》本来就在图书馆");
        }
    }
    
    // 方法重载示例
    public void displayInfo() {
        System.out.println("书名：" + title);
        System.out.println("作者：" + author);
        System.out.println("页数：" + pages);
        System.out.println("价格：" + price);
        System.out.println("状态：" + (isAvailable ? "可借" : "已借出"));
    }
    
    public void displayInfo(boolean showPrice) {
        System.out.println("书名：" + title);
        System.out.println("作者：" + author);
        System.out.println("页数：" + pages);
        if (showPrice) {
            System.out.println("价格：" + price);
        }
        System.out.println("状态：" + (isAvailable ? "可借" : "已借出"));
    }
    
    // 静态方法
    public static void printLibraryInfo() {
        System.out.println("欢迎来到图书馆！");
        System.out.println("我们提供各种类型的图书借阅服务");
    }
}

使用示例

public class LibraryTest {
    public static void main(String[] args) {
        // 调用静态方法
        Book.printLibraryInfo();
        
        // 创建Book对象
        Book book1 = new Book("Java编程思想", "Bruce Eckel", 880, 99.0);
        Book book2 = new Book("Python基础教程");
        
        // 使用setter方法
        book2.setPages(500);
        book2.setPrice(79.0);
        
        // 显示图书信息
        book1.displayInfo();
        System.out.println("---");
        book2.displayInfo(false);  // 不显示价格
        
        // 借书操作
        book1.borrow();
        book1.borrow();  // 重复借书
        
        // 还书操作
        book1.returnBook();
    }
}

---

✅ 最佳实践

1. 命名规范

• 类名：使用PascalCase（首字母大写的驼峰命名）
• 方法名：使用camelCase（首字母小写的驼峰命名）
• 变量名：使用camelCase
• 常量：使用UPPER_SNAKE_CASE

public class StudentManager {  // 类名：PascalCase
    private static final int MAX_STUDENTS = 100;  // 常量：UPPER_SNAKE_CASE
    
    private String studentName;  // 变量名：camelCase
    
    public void addStudent() {  // 方法名：camelCase
        // 方法实现
    }
}

2. 封装原则

• 成员变量尽量使用private
• 提供getter和setter方法
• 在setter方法中添加验证逻辑

public class BankAccount {
    private double balance;  // 私有变量
    
    public double getBalance() {  // getter方法
        return balance;
    }
    
    public void setBalance(double balance) {  // setter方法
        if (balance >= 0) {  // 添加验证
            this.balance = balance;
        } else {
            System.out.println("余额不能为负数");
        }
    }
}

3. 构造函数设计

• 提供多个构造函数重载
• 使用this()调用其他构造函数
• 初始化所有必要的成员变量

public class Person {
    private String name;
    private int age;
    private String email;
    
    public Person() {
        this("未知", 0, "");  // 调用三参构造函数
    }
    
    public Person(String name, int age) {
        this(name, age, "");  // 调用三参构造函数
    }
    
    public Person(String name, int age, String email) {
        this.name = name;
        this.age = age;
        this.email = email;
    }
}

---

⚠️ 常见错误和注意事项

1. 构造函数常见错误

// ❌ 错误：构造函数有返回类型
public Person() {
    return;  // 构造函数不能有return语句
}

// ❌ 错误：构造函数名与类名不一致
public class Person {
    public PersonConstructor() {  // 错误：应该是Person()
        // ...
    }
}

// ✅ 正确
public class Person {
    public Person() {
        // 正确的构造函数
    }
}

2. 方法重载常见错误

// ❌ 错误：仅靠返回类型无法区分重载
public int calculate(int a, int b) {
    return a + b;
}

public double calculate(int a, int b) {  // 编译错误！
    return a + b;
}

// ✅ 正确：参数类型不同
public int calculate(int a, int b) {
    return a + b;
}

public double calculate(double a, double b) {
    return a + b;
}

3. 访问修饰符注意事项

public class Test {
    public static void main(String[] args) {
        BankAccount account = new BankAccount();
        
        // ❌ 错误：无法访问私有成员
        // account.balance = 1000;  // 编译错误
        
        // ✅ 正确：通过公共方法访问
        account.setBalance(1000);
        System.out.println(account.getBalance());
    }
}

---

📝 总结

Java类和方法是面向对象编程的基础，掌握这些概念对于Java开发至关重要：

1. 类是对象的模板，定义了对象的属性和行为
2. 构造函数用于初始化对象，支持重载
3. 方法重载允许同名方法有不同的参数列表
4. 访问修饰符控制类成员的可见性，实现封装
5. 遵循命名规范和最佳实践，写出高质量的代码

通过不断练习和实践，您将能够熟练运用这些概念来设计和实现复杂的Java程序。

---

🎯 综合测试

自测题

1. 选择题：以下哪个不是构造函数的特点？

   • A. 方法名与类名相同
   • B. 没有返回类型
   • C. 可以重载
   • D. 必须有参数

2. 判断题：方法重载可以仅通过返回类型不同来区分。（对/错）

3. 编程题：创建一个BankAccount类，包含：

   • 账户号、余额、持卡人姓名属性
   • 存款、取款、查询余额方法
   • 构造函数重载
   • 适当的访问修饰符

项目实战

任务：设计一个简单的图书管理系统

// 要求：
// 1. Book类：书名、作者、价格、库存数量
// 2. Library类：管理图书的增删改查
// 3. 使用适当的访问修饰符
// 4. 实现方法重载
// 5. 添加异常处理

// 你的代码实现：

---

📚 推荐学习资源

📖 官方文档

• Oracle Java官方教程 - 权威的Java学习资料
• Java API文档 - 完整的API参考
• Java语言规范 - 深入了解Java语言

🎓 在线课程平台

• Coursera：Java Programming Specialization
• edX：Introduction to Programming with Java
• 慕课网：Java零基础入门课程
• B站：尚硅谷Java基础教程

💻 实践平台

• LeetCode - 算法练习，巩固Java基础
• 牛客网 - Java专项练习
• Codecademy - 交互式Java学习
• HackerRank - 编程挑战

📚 推荐书籍

• 《Java核心技术》 - Cay S. Horstmann著
• 《Java编程思想》 - Bruce Eckel著
• 《Effective Java》 - Joshua Bloch著
• 《Java并发编程实战》 - Brian Goetz著

🌐 社区论坛

• Stack Overflow - 技术问答社区
• CSDN - 中文技术社区
• 掘金 - 开发者技术社区
• GitHub - 开源项目学习

🛠️ 开发工具

• IDE：IntelliJ IDEA、Eclipse
• 构建工具：Maven、Gradle
• 版本控制：Git、GitHub

📱 学习APP

• 编程狮 - 移动端编程学习
• 菜鸟教程 - 在线教程和工具
• W3School - Web技术学习

---

🎉 学习路径建议

第一阶段：基础巩固（1-2周）

1. 完成本教程的所有练习
2. 在LeetCode上完成50道简单题目
3. 阅读《Java核心技术》前5章

第二阶段：进阶学习（2-3周）

1. 学习Java集合框架
2. 掌握异常处理机制
3. 了解Java IO操作

第三阶段：项目实践（3-4周）

1. 完成图书管理系统项目
2. 学习Spring框架基础
3. 参与开源项目贡献

---

厦门工学院人工智能创作坊 --郑恩赐
2025-9-23