IT技术社区_专业开发者平台_最新编程教程与解决方案 -沐辰社区

Java方法案例如何基础定义

wen java案例 26

本文目录导读：

Java方法案例如何基础定义

  1. 方法定义的基本语法
  2. 完整的基础方法案例
  3. 方法重载示例
  4. 静态方法示例
  5. 递归方法示例
  6. 实际应用案例：银行账户管理系统
  7. 注意事项和最佳实践

我来全面介绍Java方法的基础定义和案例,从最基础到实际应用。

方法定义的基本语法

方法定义格式

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

最基础的方法示例

public class MethodBasicDemo {
    // 1. 无参数无返回值
    public void sayHello() {
        System.out.println("Hello, Java!");
    }
    // 2. 有参数无返回值
    public void greet(String name) {
        System.out.println("Hello, " + name);
    }
    // 3. 无参数有返回值
    public int getNumber() {
        return 100;
    }
    // 4. 有参数有返回值
    public int add(int a, int b) {
        return a + b;
    }
}

完整的基础方法案例

案例1：简单计算器

public class CalculatorDemo {
    // 加法
    public int add(int a, int b) {
        return a + b;
    }
    // 减法
    public int subtract(int a, int b) {
        return a - b;
    }
    // 乘法
    public int multiply(int a, int b) {
        return a * b;
    }
    // 除法
    public double divide(int a, int b) {
        if (b == 0) {
            System.out.println("除数不能为0！");
            return 0;
        }
        return (double) a / b;
    }
    // 测试方法
    public static void main(String[] args) {
        CalculatorDemo calc = new CalculatorDemo();
        // 调用方法
        int sum = calc.add(10, 20);
        System.out.println("10 + 20 = " + sum);
        double result = calc.divide(10, 3);
        System.out.println("10 / 3 = " + result);
    }
}

输出结果：

10 + 20 = 30
10 / 3 = 3.3333333333333335

案例2：学生信息管理

public class StudentManager {
    // 定义学生信息
    private String name;
    private int age;
    private String grade;
    // 1. 设置学生信息方法
    public void setStudentInfo(String name, int age, String grade) {
        this.name = name;
        this.age = age;
        this.grade = grade;
    }
    // 2. 获取学生姓名
    public String getName() {
        return name;
    }
    // 3. 获取学生年龄
    public int getAge() {
        return age;
    }
    // 4. 判断学生是否成年
    public boolean isAdult() {
        return age >= 18;
    }
    // 5. 打印学生信息
    public void printStudentInfo() {
        System.out.println("=== 学生信息 ===");
        System.out.println("姓名: " + name);
        System.out.println("年龄: " + age);
        System.out.println("年级: " + grade);
        System.out.println("是否成年: " + (isAdult() ? "是" : "否"));
    }
}
// 测试类
class TestStudent {
    public static void main(String[] args) {
        StudentManager student = new StudentManager();
        // 调用方法设置信息
        student.setStudentInfo("张三", 20, "大二");
        // 调用方法获取信息
        String name = student.getName();
        System.out.println("学生姓名: " + name);
        // 调用方法打印全部信息
        student.printStudentInfo();
    }
}

方法重载示例

public class MethodOverloadDemo {
    // 1. 加法方法重载
    public int add(int a, int b) {
        System.out.println("两个整数相加");
        return a + b;
    }
    public double add(double a, double b) {
        System.out.println("两个小数相加");
        return a + b;
    }
    public int add(int a, int b, int c) {
        System.out.println("三个整数相加");
        return a + b + c;
    }
    // 2. 打印方法重载
    public void print(String str) {
        System.out.println("字符串: " + str);
    }
    public void print(int num) {
        System.out.println("数字: " + num);
    }
    public void print(String str, int num) {
        System.out.println("字符串: " + str + ", 数字: " + num);
    }
    public static void main(String[] args) {
        MethodOverloadDemo demo = new MethodOverloadDemo();
        // 测试方法重载
        System.out.println("=== 方法重载测试 ===");
        System.out.println(demo.add(1, 2));           // 调用int版本
        System.out.println(demo.add(1.5, 2.5));      // 调用double版本
        System.out.println(demo.add(1, 2, 3));       // 调用三个参数版本
        demo.print("Hello");                          // 调用String版本
        demo.print(100);                              // 调用int版本
        demo.print("Hello", 100);                     // 调用两个参数版本
    }
}

静态方法示例

public class StaticMethodDemo {
    // 1. 静态变量
    private static int count = 0;
    // 2. 静态方法
    public static void showMessage() {
        System.out.println("这是一个静态方法");
    }
    // 3. 静态方法返回计数器
    public static int getCount() {
        return count;
    }
    // 4. 静态方法增加计数
    public static void incrementCount() {
        count++;
    }
    // 5. 静态工具方法 - 计算数组平均值
    public static double calculateAverage(int[] numbers) {
        if (numbers == null || numbers.length == 0) {
            return 0;
        }
        int sum = 0;
        for (int num : numbers) {
            sum += num;
        }
        return (double) sum / numbers.length;
    }
}
// 测试类
class TestStaticMethod {
    public static void main(String[] args) {
        // 直接通过类名调用静态方法
        StaticMethodDemo.showMessage();
        // 多次调用增加计数
        StaticMethodDemo.incrementCount();
        StaticMethodDemo.incrementCount();
        StaticMethodDemo.incrementCount();
        System.out.println("当前计数: " + StaticMethodDemo.getCount());
        // 调用工具方法
        int[] scores = {85, 90, 78, 92, 88};
        double avg = StaticMethodDemo.calculateAverage(scores);
        System.out.println("平均分: " + avg);
    }
}

递归方法示例

public class RecursionDemo {
    // 1. 计算阶乘
    public int factorial(int n) {
        // 递归终止条件
        if (n <= 1) {
            return 1;
        }
        // 递归调用
        return n * factorial(n - 1);
    }
    // 2. 斐波那契数列
    public int fibonacci(int n) {
        // 终止条件
        if (n <= 1) {
            return n;
        }
        // 递归调用
        return fibonacci(n - 1) + fibonacci(n - 2);
    }
    // 3. 打印倒序数字
    public void printReverse(int n) {
        if (n > 0) {
            System.out.print(n + " ");
            printReverse(n - 1);  // 递归调用
        }
    }
    public static void main(String[] args) {
        RecursionDemo recursion = new RecursionDemo();
        System.out.println("=== 递归方法测试 ===");
        // 测试阶乘
        int num = 5;
        System.out.println(num + "的阶乘: " + recursion.factorial(num));
        // 测试斐波那契
        System.out.println("斐波那契第6项: " + recursion.fibonacci(6));
        // 测试倒序打印
        System.out.print("倒序打印5到1: ");
        recursion.printReverse(5);
        System.out.println();
    }
}

实际应用案例：银行账户管理系统

public class BankAccount {
    // 账户属性
    private String accountNumber;
    private String accountName;
    private double balance;
    // 构造函数
    public BankAccount(String accountNumber, String accountName) {
        this.accountNumber = accountNumber;
        this.accountName = accountName;
        this.balance = 0.0;
    }
    // 1. 存款方法
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
            System.out.println("存款成功：¥" + amount);
        } else {
            System.out.println("存款金额必须大于0");
        }
    }
    // 2. 取款方法
    public boolean withdraw(double amount) {
        if (amount <= 0) {
            System.out.println("取款金额必须大于0");
            return false;
        }
        if (amount > balance) {
            System.out.println("余额不足！当前余额: ¥" + balance);
            return false;
        }
        balance -= amount;
        System.out.println("取款成功：¥" + amount);
        return true;
    }
    // 3. 查询余额
    public double getBalance() {
        return balance;
    }
    // 4. 转账方法
    public boolean transfer(BankAccount target, double amount) {
        // 先取款
        if (this.withdraw(amount)) {
            // 再存款到目标账户
            target.deposit(amount);
            System.out.println("转账成功：¥" + amount + 
                             " 从 " + this.accountName + 
                             " 到 " + target.accountName);
            return true;
        }
        return false;
    }
    // 5. 显示账户信息
    public void displayInfo() {
        System.out.println("=== 账户信息 ===");
        System.out.println("账号: " + accountNumber);
        System.out.println("户名: " + accountName);
        System.out.println("余额: ¥" + balance);
    }
    // 测试方法
    public static void main(String[] args) {
        // 创建两个账户
        BankAccount account1 = new BankAccount("1001", "张三");
        BankAccount account2 = new BankAccount("1002", "李四");
        // 初始存款
        account1.deposit(1000);
        account2.deposit(500);
        System.out.println("\n=== 初始状态 ===");
        account1.displayInfo();
        account2.displayInfo();
        // 转账操作
        System.out.println("\n=== 转账操作 ===");
        account1.transfer(account2, 300);
        System.out.println("\n=== 转账后状态 ===");
        account1.displayInfo();
        account2.displayInfo();
        // 测试取款
        System.out.println("\n=== 取款测试 ===");
        account1.withdraw(2000);  // 余额不足
        account1.withdraw(500);   // 成功取款
        account1.displayInfo();
    }
}

注意事项和最佳实践

  1. 方法命名：使用驼峰命名法，动词开头

    // 好的命名
public void getUserInfo() {}
public int calculateTotal() {}
// 避免的命名
public void a() {}
public int abc() {}

  2. 单一职责：一个方法只做一件事

    // 好的做法
public void validateUser() {}
public void saveUser() {}
// 避免的做法
public void validateAndSaveUser() {}

  3. 参数数量：尽量不超过3-4个参数

    // 参数过多时使用对象
public void createUser(String name, int age, String email, String phone) {}
// 改进为
public void createUser(User user) {}

  4. 返回值设计：

    • 明确返回值类型
    • 考虑null值处理
    • 使用Optional处理可能为null的情况

这就是Java方法的基础定义和案例，从简单到复杂,覆盖了日常开发中最常用的场景。

上一篇Java无参方法案例怎么编写

下一篇Java有参方法案例如何实现

相关文章

抱歉，评论功能暂时关闭!