Java SE部分 学习笔记 使用B站狂神视频学习

个人博客地址：欢迎来访问鸭

java 方法

可变参数

JDK1.5开始 java支持传递同类型的可变参数给一个方法。
在方法声明中，在指定参数类型后加一个省略号。
一个方法中只能制定一个可变参数，他必须是方法的最后一个参数，任何普通的参数必须在它之前声明。

public class variableParmeter {
    public static void main(String[] args) {
        test(1,2,3);

    }
    public static void test(int ... parameter) {
        for (int i = 0; i < parameter.length; i++) {
            System.out.println(parameter[i]);
        }

在调用时编译器会自动的识别可变参数。

递归

递归结构包括两个部分
递归头：什么时候不调用自身方法。如果没有头将陷入死循环。
递归体：什么时候需要调用自身方法

public class recursion {
    public static void main(String[] args) {
        System.out.println(recursion(4));
    }
    public static int recursion(int i){
        if(i==1){
            return i;
        }
        else{
            return i*recursion(i-1);
        }

    }

作业

题目：

完成效果：
使用了非常多的判断和标志位，写的健壮性也几乎等于没有，越写感觉自己越菜…

代码：

import java.util.Scanner;

public class calculator {
    static double operand=0;    //接受初始操作数
    static double operand2=0;   //接受实时操作数
    static double answer = 0;     //接受答案
    static int status=0;    //输入有三种状态，一种是最开始（0） 一种需要输入操作数(1)，一种需要输入符号(2)
    static String symbol;
    public static double add(double... n){
        double sum=0;
        for (int i = 0; i < n.length; i++) {
            sum+=n[i];
        }
        return sum;
    }
    public static double minus(double... n){
        double difference=n[0];
        difference+=n[1];   //之后的调用中n[1]位置是初始操作数
        for (int i = 1; i < n.length; i++) {
            difference-=n[i];
        }
        return difference;
    }
    public static double div(double... n){
        double beDived = n[0];
        double s =0;
        beDived+=n[1];  //初始操作数
        s = beDived/n[2];
        return s;
    }
    public static double mult(double... n){
        return (n[0]+n[1])*n[2];
    }
    public static void receive(){
        Scanner s = new Scanner(System.in);
        if(status==0){
            System.out.println("请输入操作数");
            if(s.hasNext()){
                String receiver = s.next();
                operand = Double.parseDouble(receiver);
                status =2;
            }
        }
        if(status==1){
            System.out.println("请输入操作数");
            if(s.hasNext()){
                String receiver = s.next();
                operand2 = Double.parseDouble(receiver);
                switch (symbol){
                    case "+" : answer=add(operand,operand2,answer);
                        operand=0;    // 工具人，使用完抛弃掉
                        System.out.println(answer);
                        status =2;
                        receive();break;
                    case "-" : answer=minus(answer,operand,operand2);
                        operand=0;    // 工具人，使用完抛弃掉
                        System.out.println(answer);
                        status =2;
                        receive();break;
                    case "/" : answer=div(answer,operand,operand2);
                        operand=0;    // 工具人，使用完抛弃掉
                        System.out.println(answer);
                        status =2;
                        receive();break;
                    case "*" : answer=mult(answer,operand,operand2);
                        operand=0;    // 工具人，使用完抛弃掉
                        System.out.println(answer);
                        status =2;
                        receive();break;
                }
                status =2;
            }

        }
        else{
            System.out.println("请输入+ - * /");
            if(s.hasNext()){
                symbol = s.next();
                status = 1;
            }
            receive();
        }



    }
    public static void main(String[] args) {
    receive();
    }
}