JavaDay03-方法、可变参数、递归

Java方法

修饰符 返回值类型 方法名（形参类型 形参名）{方法体}

1、修饰符可以有多个 public static final
2、有返回值:返回值类型处为相应的类型（返回值类型如果为int，方法体内必须要加return 0）；无返回值：返回值类型处为void（通常为打印一句话）
3、方法名命名规则：首字母小写+驼峰原则
4、参数可以有多个，可以一个，可以没有，可以为可变参数（见下文）。参数分为实参和形参。
5、方法重载

• 方法名相同
• 形参不同：类型、数量、顺序
• 返回值可以相同，可以不同

public class Demo01 {
    //主方法中尽量简洁，把公共的东西都放在主方法外面
    public static void main(String[] args) {
        int sum=add(1,2);
        System.out.println(sum);
    }
    //加法-在学习对象之前先用static 可以在主方法中直接使用
    //方法的原子性：一个方法只完成一个功能
    public static int add(int a,int b){
        return a+b;
    }
    //比较大小
    public static int compare(int a,int b){
        int result=0;//接收比较后的结果
        if (a==b){
            return 0;//终止程序，不会继续执行下面的语句
        }
        if (a>b){
            result=a;
        }else{
            result=b;
        }
        return result;//return语句不要写在if语句内部
    }
    //重载比较大小
    public static double compare(double a,double b){
        double res;
        if (a>b){
            res=a;
        }else{
            res=b;
        }
        return res;
    }
}

可变参数

修饰符 返回值类型 方法名（可变参数类型... 可变参数名）{}

1、所有参数都是同一种类型
2、一个方法只能有一个可变参数
3、可变参数只能定义在参数列表最后面

public class VariableParameterDemo01 {
    public static void main(String[] args) {
        //如果方法中没有static，则需要先生成类的对象，通过对象调用方法
        VariableParameterDemo01 varPara = new VariableParameterDemo01();
        varPara.test(1,12,23,44,45);//可变参数，可以接收随意数量的值
    }
    //可变参数（参数类型... 参数名）-所有的参数都必须是同一种类型，一个方法只能有一个可变参数，并且只能定义在形参列表的最后
    public void test(int... i){//i是一个数组
        System.out.println(i[0]);
        System.out.println(i[1]);//复制上一行：ctrl+d
        System.out.println(i[2]);
    }
}

可变参数小练习-数字排序

public class SortDemo {
    public static void main(String[] args) {
        SortDemo sortDemo = new SortDemo();
        sortDemo.sort(4.4,2.1,5.6,99,215);
    }
    //排序
    public void sort(double... numbers){
        double result=0;
        //合法性判断
        if (numbers.length==0){
            System.out.println("啥也没有，比较啥呀？玩呢？");
            //return 0;
        }else{
            for (double number : numbers) {//增强for循环，专门用于数组或集合，把numbers数组中的每一项取出来赋值给double number这个变量
                if (number > result) {
                    result = number;
                }
            }
            System.out.println("排好啦，最大值是："+result);
        }
    }
}

递归

1、递归头
2、递归体
3、递归采用了栈机制，尽量不用递归，当阶数小的时候可以用，阶数太大十分占用内存。

递归小练习-计算阶乘

import java.util.Scanner;
public class Recurrence {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("想要计算几的阶乘呢？");
        if (scanner.hasNextInt()) {
            int i=scanner.nextInt();
            Recurrence recurrence = new Recurrence();
            int result = recurrence.recur(i);
            System.out.println(i+"的阶乘是：" + result);
        }
        scanner.close();
    }
    //递归-求阶乘
    public int recur(int i){
        if (i==1){//边界、递归头
            return 1;
        }else{
            return i*recur(i-1);//返回阶段、递归体
        }
    }
}

小练习-简易计算器：能够循环接收键盘输入，能够判断加减乘除

1、写四个方法，加减乘除
2、循环+switch进行用户交互
3、传递需要操作的两个数
4、输出结果

import java.util.Scanner;
public class PractiseRecurrence {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        PractiseRecurrence praRecur = new PractiseRecurrence();
        System.out.println("+|-|*|%:");
        String ope= scanner.next();
        while(ope.equals("*")|ope.equals("+")|ope.equals("-")|ope.equals("%")){
            switch (ope){
                case "+":
                    System.out.println("加数：");
                    double addOp01=scanner.nextDouble();
                    System.out.println("被加数：");
                    double addOp02=scanner.nextDouble();
                    double resultAdd = praRecur.add(addOp01,addOp02);
                    System.out.println(addOp01+"+"+addOp02+"="+resultAdd);
                    break;
                case "-":
                    System.out.println("减数：");
                    double subOp01=scanner.nextDouble();
                    System.out.println("被减数：");
                    double subOp02=scanner.nextDouble();
                    double resultSub = praRecur.sub(subOp01,subOp02);
                    System.out.println(subOp01+"-"+subOp02+"="+resultSub);
                    break;
                case "*":
                    System.out.println("乘数：");
                    double mulOp01=scanner.nextDouble();
                    System.out.println("被乘数：");
                    double mulOp02=scanner.nextDouble();
                    double resultMul = praRecur.mul(mulOp01,mulOp02);
                    System.out.println(mulOp01+"*"+mulOp02+"="+resultMul);
                    break;
                case "%":
                    System.out.println("除数：");
                    double divOp01=scanner.nextDouble();
                    System.out.println("被除数：");
                    double divOp02=scanner.nextDouble();
                    double resultDiv = praRecur.div(divOp01, divOp02);
                    System.out.println(divOp01+"/"+divOp02+"="+resultDiv);
                    break;
            }
            System.out.println("+|-|*|/:");
        }
        System.out.println("乖哦~要输入正确的运算符才可以哦！");
        scanner.close();
    }
    //加
    public double add(double a,double b){
        return a+b;
    }
    //减
    public double sub(double a,double b){
        return a-b;
    }
    //乘
    public double mul(double a,double b){
        return a*b;
    }
    //除
    public double div(double a,double b){
        return a/b;
    }
}