Java--方法

Java–方法

package com.zy.base;

import java.math.BigDecimal;
import java.util.Scanner;

/**
 *description: Java--方法
 *@program: JavaProjectDemo
 *@author: zy
 *@create: 2023-02-13 22:56
 */
public class Method {

    /*
        修饰符 返回值类型 方法名(参数类型 参数名){
            ...
            方法体
            ...
            return 返回值
        }
        修饰符：可选，定义了该方法的访问类型，如：public/private/protected
        返回值类型：当有返回值时，书写对应的返回值数据类型，若无则为void
        方法名：方法的实际名称，与参数共同构成方法签名
        参数类型：参数列表指参数类型、顺序和参数个数。若无参数可空；
            形式参数：写在方法名之后的参数，用于接收调用方传递的实际参数
            实际参数：调用方法时实际传递的数据
        方法体：包含具体的语句，定义该方法的功能
        public int add(int a,int b){
            return a+b;
        }
        Method method = new Method();
        method.add(1,2);
     */

    public static void main(String[] args) {

        // 命令行传参给main()  扩展了解
        for (int i = 0; i < args.length; i++) {
            System.out.println("args["+i+"]"+args[i]);
        }

        // 普通方法调用
        Method method = new Method();
        System.out.println(method.add(1,2));
        System.out.println(max(1,2));

        // 可变参数方法调用
        printMax(1,3,4,2,6,5);
        printMax(new double[]{9,8,76,4,53,94});

        /*
        递归方法调用:main()-->recursive(6)-->recursive(5)-->recursive(4)
        -->recursive(3)-->recursive(2)-->recursive(1)-->结果：6*5*4*3*2*1=720
        由此可结：
            递边界条件：归方法必须设置边界（跳出递归循环判断）；
            前阶段：未满足边界条件时的递归循环体；
            返回阶段：满足边界条件后的返回：n*(n-1)
        注：递归方法会消耗大量内存，当边界条件太深时，尽量不用递归
        */
         
        System.out.println("6的阶乘结果为："+recursive(6));

        // 练习题：一个简单的计算器
        calculator();
    }

    /**
     * @Description add
     * @author zy
     * [a, b]
     * int
     * @date 2023-2-13 23:06
     */
    public int add(int a,int b){
        return a+b;
    }

    /**
     * @Description max
     * @author zy
     * [num1, num2]
     * int
     * @date 2023-2-13 23:11
     */
    public static int max(int num1,int num2){
        return num1>num2?num1:num2;
    }

    /**
     * @Description max：方法的重载：方法名相同，参数列表不同（参数个数或参数类型不同）
     * @author zy
     * [num1, num2]
     * double
     * @date 2023-2-14 21:12
     */
    public static double max(double num1,double num2){
        return num1>num2?num1:num2;
    }

    /**
     * @Description printMax：可变参数
     * 指定参数类型后加一个省略号；
     * 一个方法只能放一个可变参数且必须放在最后一位。
     * @author zy
     * [numbers]
     * void
     * @date 2023-2-14 21:32
     */
    public static void printMax(double... numbers){

        if(numbers.length==0){
            System.out.println("未传参");
            return;
        }

        double max = numbers[0];
        for (int i = 0; i < numbers.length; i++) {
            if(numbers[i]>max){
                max = numbers[i];
            }
        }

        System.out.println("最大的数为："+max);
    }

    /**
     * @Description recursive：递归方法
     * 递归头：何时不调用自身；如果没有头将进入死循环，切记。
     * 递归体：何时调用自身。
     * @author zy
     * [n]
     * int
     * @date 2023-2-14 21:46
     * 阶乘案例：2! 2*1  3! 3*2*1
     */
    public static int recursive(int number){
        if(number == 1){
            return 1;
        }else{
            return number*recursive(--number);
        }
    }

    public static BigDecimal add(BigDecimal...numbers){
        if(numbers.length <=1){
            return null;
        }
        BigDecimal result = new BigDecimal(0);
        for (BigDecimal x:numbers){
            result = result.add(x);
        }
        return result;
    }
    public static BigDecimal subtract(BigDecimal...numbers){
        if(numbers.length <=1){
            return null;
        }
        BigDecimal result = new BigDecimal(0);
        for(int i=0;i<numbers.length;i++){
            if(i==0){
                result = numbers[i].subtract(result);
            }else{
                result = result.subtract(numbers[i]);
            }
        }
        return result;
    }
    public static BigDecimal multiply(BigDecimal...numbers){
        if(numbers.length <=1){
            return null;
        }
        BigDecimal result = new BigDecimal(1);
        for (BigDecimal x:numbers){
            result = result.multiply(x);
        }
        return result;
    }
    public static BigDecimal division(BigDecimal...numbers){
        if(numbers.length <=1){
            return null;
        }
        BigDecimal result = new BigDecimal(1);
        for(int i=0;i<numbers.length;i++){
            if(i==0){
                result = numbers[i].divide(result,2,BigDecimal.ROUND_DOWN);
            }else{
                result = result.divide(numbers[i],2,BigDecimal.ROUND_DOWN);
            }
        }
        return result;
    }
    /**
     * @Description calculator：简单的多位数字计算器（+、-、*、/）
     * @author zy
     * []
     * void
     * @date 2023-2-14 23:48
     */
    public static void calculator(){
        Scanner scanner = new Scanner(System.in);
        BigDecimal[] numbers = {};
        String operator = "";
        boolean flag = false;
        int i=0;
        System.out.println("请键入数字进行计算（+，-，*，/），数字键入完毕后请键入yes进行下一个环节！");
        while(true){
            i++;
            System.out.println("请输入第"+i+"个数：");
            if(scanner.hasNextBigDecimal()){
                if(numbers.length>0){
                    BigDecimal[] tempNumbers = numbers.clone();
                    numbers = new BigDecimal[i];
                    int j=0;
                    for (BigDecimal x:tempNumbers){
                        numbers[j] = tempNumbers[j];
                        j++;
                    }
                }else{
                    numbers = new BigDecimal[i];
                }
                numbers[i-1] = scanner.nextBigDecimal();
                if(numbers[i-1].equals(BigDecimal.ZERO)){
                    System.out.println("输入的数字不能为0，请重新输入：");
                    i--;
                    continue;
                }
                System.out.println("输入的第"+i+"个数字为："+numbers[i-1]);
                continue;
            }else{
                if(scanner.next().equals("yes")){
                    System.out.println("数字输入完毕！");
                    break;
                }
                System.out.println("输入的不是数字，请重新输入：");
                i--;
                continue;
            }
        }

        System.out.println("请输入运算符（+，-，*，/）：");
        while (!flag && scanner.hasNextLine()){
            operator = scanner.nextLine();
            if(!"".equals(operator) && !flag){
                switch (operator){
                    case "+":
                        System.out.println("输入的运算符为："+operator+"，马上进行计算请等待！");
                        System.out.println("计算结果为："+add(numbers));
                        flag=true;
                        break;
                    case "-":
                        System.out.println("输入的运算符为："+operator+"，马上进行计算请等待！");
                        System.out.println("计算结果为："+subtract(numbers));
                        flag=true;
                        break;
                    case "*":
                        System.out.println("输入的运算符为："+operator+"，马上进行计算请等待！");
                        System.out.println("计算结果为："+multiply(numbers));
                        flag=true;
                        break;
                    case "/":
                        System.out.println("输入的运算符为："+operator+"，马上进行计算请等待！");
                        System.out.println("计算结果为："+division(numbers));
                        flag=true;
                        break;
                    default:
                        System.out.println("输入的运算符错误，请重新输入：");
                        break;
                }
            }
        }

        scanner.close();
    }
}