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

Java带返回值案例怎么开发

wen java案例 160

本文目录导读：

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中带返回值方法的开发技巧。

版权声明：足球直播 足球直播 足球直播 足球直播 足球直播 中超直播 中超直播 中超直播 中超直播 中超直播 英超直播 英超直播 英超直播 英超直播 英超直播 德甲直播 德甲直播 德甲直播 德甲直播 德甲直播 西甲直播 西甲直播 西甲直播 西甲直播 西甲直播 意甲直播 意甲直播 意甲直播 意甲直播 意甲直播 NBA直播 NBA直播 NBA直播 NBA直播 NBA直播 篮球直播 篮球直播 篮球直播 篮球直播 篮球直播 足球直播 足球直播 足球直播 足球直播 足球直播 中超直播 中超直播 中超直播 中超直播 中超直播 英超直播 英超直播 英超直播 英超直播 英超直播 德甲直播 德甲直播 德甲直播 德甲直播 德甲直播 西甲直播 西甲直播 西甲直播 西甲直播 西甲直播 意甲直播 意甲直播 意甲直播 意甲直播 意甲直播 NBA直播 NBA直播 NBA直播 NBA直播 NBA直播 篮球直播 篮球直播 篮球直播 篮球直播 篮球直播 足球直播 足球直播 足球直播 足球直播 足球直播 中超直播 中超直播 中超直播 中超直播 中超直播 英超直播 英超直播 英超直播 英超直播 英超直播 德甲直播 德甲直播 德甲直播 德甲直播 德甲直播 西甲直播 西甲直播 西甲直播 西甲直播 西甲直播 意甲直播 意甲直播 意甲直播 意甲直播 意甲直播 NBA直播 NBA直播 NBA直播 NBA直播 NBA直播 篮球直播 篮球直播 篮球直播 篮球直播 篮球直播

上一篇Java方法重写案例怎么实现

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

相关文章

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

友情链接攻略窝 · 礼包窝 · 配置窝 · 换算窝 · 算法窝 · 查文窝 · 手册窝 · 问答窝 · 全文搜 · 手册库
相关站点礼包窝 · 查文窝