Java带返回值案例怎么开发

本文目录导读：

1. 基础概念
2. 基础案例
3. 对象返回
4. 实战案例：计算器系统
5. 最佳实践
6. 测试案例

我来给你详细讲解Java带返回值方法的开发案例,从基础到实战。

基础概念

带返回值的方法使用return关键字返回数据,方法声明中需要指定返回值类型。

public 返回值类型 方法名(参数列表) {
    // 方法体
    return 返回值;  // 必须与声明类型一致
}

基础案例

基本数据类型返回

public class ReturnDemo {
    // 返回整数
    public int add(int a, int b) {
        return a + b;
    }
    // 返回布尔值
    public boolean isEven(int num) {
        return num % 2 == 0;
    }
    // 返回字符串
    public String greet(String name) {
        return "Hello, " + name + "!";
    }
    public static void main(String[] args) {
        ReturnDemo demo = new ReturnDemo();
        int sum = demo.add(10, 20);
        System.out.println("和: " + sum);  // 30
        boolean result = demo.isEven(7);
        System.out.println("是否为偶数: " + result);  // false
        String message = demo.greet("张三");
        System.out.println(message);  // Hello, 张三!
    }
}

数组返回

public class ArrayReturnDemo {
    // 返回数组
    public int[] getEvenNumbers(int limit) {
        int[] result = new int[limit/2 + 1];
        int index = 0;
        for (int i = 1; i <= limit; i++) {
            if (i % 2 == 0) {
                result[index++] = i;
            }
        }
        return result;
    }
    // 返回二维数组
    public int[][] createMultiplicationTable(int size) {
        int[][] table = new int[size][size];
        for (int i = 0; i < size; i++) {
            for (int j = 0; j < size; j++) {
                table[i][j] = (i + 1) * (j + 1);
            }
        }
        return table;
    }
    public static void main(String[] args) {
        ArrayReturnDemo demo = new ArrayReturnDemo();
        int[] evens = demo.getEvenNumbers(10);
        System.out.println("偶数: " + Arrays.toString(evens));
        int[][] table = demo.createMultiplicationTable(5);
        for (int[] row : table) {
            System.out.println(Arrays.toString(row));
        }
    }
}

对象返回

自定义对象返回

// 学生类
class Student {
    private String name;
    private int age;
    private double score;
    public Student(String name, int age, double score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }
    @Override
    public String toString() {
        return "Student{name='" + name + "', age=" + age + ", score=" + score + "}";
    }
    // Getter方法
    public String getName() { return name; }
    public int getAge() { return age; }
    public double getScore() { return score; }
}
// 学生管理类
class StudentManager {
    // 返回单个对象
    public Student findTopStudent(List<Student> students) {
        Student top = null;
        double maxScore = 0;
        for (Student s : students) {
            if (s.getScore() > maxScore) {
                maxScore = s.getScore();
                top = s;
            }
        }
        return top;
    }
    // 返回对象集合
    public List<Student> findPassStudents(List<Student> students) {
        List<Student> passList = new ArrayList<>();
        for (Student s : students) {
            if (s.getScore() >= 60) {
                passList.add(s);
            }
        }
        return passList;
    }
}
public class ObjectReturnDemo {
    public static void main(String[] args) {
        List<Student> students = new ArrayList<>();
        students.add(new Student("张三", 20, 85));
        students.add(new Student("李四", 21, 45));
        students.add(new Student("王五", 19, 92));
        StudentManager manager = new StudentManager();
        // 获取最高分学生
        Student top = manager.findTopStudent(students);
        System.out.println("最高分学生: " + top);
        // 获取及格学生列表
        List<Student> passList = manager.findPassStudents(students);
        System.out.println("及格学生: " + passList);
    }
}

实战案例：计算器系统

import java.util.*;
// 表达式结果类
class ExpressionResult {
    private double value;
    private String expression;
    private boolean success;
    private String errorMessage;
    public ExpressionResult(double value, String expression) {
        this.value = value;
        this.expression = expression;
        this.success = true;
    }
    public ExpressionResult(String errorMessage) {
        this.success = false;
        this.errorMessage = errorMessage;
    }
    // Getter方法
    public double getValue() { return value; }
    public String getExpression() { return expression; }
    public boolean isSuccess() { return success; }
    public String getErrorMessage() { return errorMessage; }
    @Override
    public String toString() {
        if (success) {
            return expression + " = " + value;
        }
        return "错误: " + errorMessage;
    }
}
// 计算器类
class Calculator {
    // 基本运算
    public double add(double a, double b) {
        return a + b;
    }
    public double subtract(double a, double b) {
        return a - b;
    }
    public double multiply(double a, double b) {
        return a * b;
    }
    // 带异常处理的除法
    public ExpressionResult divide(double a, double b) {
        if (b == 0) {
            return new ExpressionResult("除数不能为0");
        }
        double result = a / b;
        return new ExpressionResult(result, a + " / " + b);
    }
    // 计算数组平均值
    public double calculateAverage(double[] numbers) {
        if (numbers == null || numbers.length == 0) {
            return 0;
        }
        double sum = 0;
        for (double num : numbers) {
            sum += num;
        }
        return sum / numbers.length;
    }
    // 计算标准差
    public double calculateStandardDeviation(double[] numbers) {
        double avg = calculateAverage(numbers);
        double sumSquaredDiff = 0;
        for (double num : numbers) {
            double diff = num - avg;
            sumSquaredDiff += diff * diff;
        }
        return Math.sqrt(sumSquaredDiff / numbers.length);
    }
    // 科学计算
    public double power(double base, double exponent) {
        return Math.pow(base, exponent);
    }
    public double factorial(int n) {
        if (n < 0) {
            throw new IllegalArgumentException("不能计算负数的阶乘");
        }
        double result = 1;
        for (int i = 2; i <= n; i++) {
            result *= i;
        }
        return result;
    }
    // 解一元二次方程: ax² + bx + c = 0
    public double[] solveQuadraticEquation(double a, double b, double c) {
        double discriminant = b * b - 4 * a * c;
        if (discriminant < 0) {
            return new double[0];  // 无实数解
        }
        double sqrtDiscriminant = Math.sqrt(discriminant);
        if (discriminant == 0) {
            return new double[]{-b / (2 * a)};  // 一个解
        }
        double x1 = (-b + sqrtDiscriminant) / (2 * a);
        double x2 = (-b - sqrtDiscriminant) / (2 * a);
        return new double[]{x1, x2};
    }
}
// 主程序
public class CalculatorDemo {
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        Scanner scanner = new Scanner(System.in);
        // 基本运算
        System.out.println("=== 基本运算 ===");
        System.out.println("10 + 5 = " + calc.add(10, 5));
        System.out.println("10 - 5 = " + calc.subtract(10, 5));
        System.out.println("10 * 5 = " + calc.multiply(10, 5));
        // 带异常处理的除法
        ExpressionResult result1 = calc.divide(10, 2);
        System.out.println(result1);
        ExpressionResult result2 = calc.divide(10, 0);
        System.out.println(result2);
        // 统计计算
        System.out.println("\n=== 统计计算 ===");
        double[] numbers = {85, 90, 78, 92, 88};
        System.out.println("成绩: " + Arrays.toString(numbers));
        System.out.println("平均分: " + calc.calculateAverage(numbers));
        System.out.println("标准差: " + String.format("%.2f", calc.calculateStandardDeviation(numbers)));
        // 科学计算
        System.out.println("\n=== 科学计算 ===");
        System.out.println("2的10次方: " + calc.power(2, 10));
        System.out.println("5的阶乘: " + calc.factorial(5));
        // 解方程
        System.out.println("\n=== 解一元二次方程 ===");
        System.out.println("x² + 2x + 1 = 0 的解: " + 
                         Arrays.toString(calc.solveQuadraticEquation(1, 2, 1)));
        System.out.println("x² - 5x + 6 = 0 的解: " + 
                         Arrays.toString(calc.solveQuadraticEquation(1, -5, 6)));
        // 交互式计算
        System.out.println("\n=== 交互式计算 ===");
        try {
            System.out.print("请输入第一个数字: ");
            double num1 = scanner.nextDouble();
            System.out.print("请输入运算符(+-*/): ");
            String operator = scanner.next();
            System.out.print("请输入第二个数字: ");
            double num2 = scanner.nextDouble();
            double result;
            switch (operator) {
                case "+":
                    result = calc.add(num1, num2);
                    System.out.println(num1 + " + " + num2 + " = " + result);
                    break;
                case "-":
                    result = calc.subtract(num1, num2);
                    System.out.println(num1 + " - " + num2 + " = " + result);
                    break;
                case "*":
                    result = calc.multiply(num1, num2);
                    System.out.println(num1 + " * " + num2 + " = " + result);
                    break;
                case "/":
                    ExpressionResult divResult = calc.divide(num1, num2);
                    System.out.println(divResult);
                    break;
                default:
                    System.out.println("错误的运算符");
            }
        } catch (Exception e) {
            System.out.println("输入错误: " + e.getMessage());
        }
        scanner.close();
    }
}

最佳实践

方法设计原则

public class MethodDesignDemo {
    // 好的设计：方法单一职责
    public double calculateCircleArea(double radius) {
        return Math.PI * radius * radius;
    }
    // 不好的设计：做太多事情
    public void badMethod(double radius) {
        double area = Math.PI * radius * radius;
        System.out.println("面积: " + area);
        saveToDatabase(area);  // 不应该在这里做
        sendEmail(area);       // 不应该在这里做
    }
    // 使用Optional处理可能为null的返回值
    public Optional<Student> findStudentById(int id) {
        if (id <= 0) {
            return Optional.empty();
        }
        return Optional.of(new Student("张三", 20, 85));
    }
    // 返回不可变集合
    public List<String> getNames() {
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        return Collections.unmodifiableList(names);
    }
}

异常处理

public class ExceptionHandlingDemo {
    // 抛出异常
    public int parseInt(String str) {
        if (str == null || str.isEmpty()) {
            throw new IllegalArgumentException("字符串不能为空");
        }
        try {
            return Integer.parseInt(str);
        } catch (NumberFormatException e) {
            throw new IllegalArgumentException("无法解析数字: " + str, e);
        }
    }
    // 返回默认值
    public int parseIntWithDefault(String str, int defaultValue) {
        try {
            return Integer.parseInt(str);
        } catch (NumberFormatException e) {
            return defaultValue;
        }
    }
}

测试案例

import org.junit.Test;
import static org.junit.Assert.*;
public class CalculatorTest {
    @Test
    public void testAdd() {
        Calculator calc = new Calculator();
        assertEquals(15, calc.add(10, 5), 0.001);
    }
    @Test
    public void testDivide() {
        Calculator calc = new Calculator();
        ExpressionResult result = calc.divide(10, 2);
        assertTrue(result.isSuccess());
        assertEquals(5.0, result.getValue(), 0.001);
    }
    @Test
    public void testDivideByZero() {
        Calculator calc = new Calculator();
        ExpressionResult result = calc.divide(10, 0);
        assertFalse(result.isSuccess());
        assertEquals("除数不能为0", result.getErrorMessage());
    }
}

带返回值方法的开发要点：

1. 明确返回值类型：与return语句保持一致
2. 考虑所有路径：确保方法都有返回语句
3. 处理异常情况：使用Optional、抛出异常或返回默认值
4. 保持方法单一职责：一个方法只做一件事
5. 合理使用返回值：返回有意义的数据，避免返回null
6. 文档注释：说明返回值含义和可能的异常

通过以上案例,你应该能够掌握Java中带返回值方法的开发技巧。