java学习Day6

方法的重载

• 重载即在一个类中，有相同的函数名称，但形参不同的函数

public class Demo02 {
    public static void main(String[] args) {
        int max = max(10, 20);
        System.out.println(max);
        double Max = max(10, 20);//传入的参数是int，所以走的是int方法，但最后进行了自动转换，变成了double
        System.out.println(Max);
        double MAX = max(10.0, 10.0);
        System.out.println(MAX);
    }

    //比大小
    public static double max(double num1,double num2){
        double result=0;

        if (num1==num2){
            System.out.println("num1=num2");
            return 0;//终止方法
        }
        if (num1>num2){
            result=num1;
        }else {
            result=num2;
        }

        return result;
    }
    //比大小
    public static int max(int num1,int num2){
        int result=0;

        if (num1==num2){
            System.out.println("num1=num2");
            return 0;//终止方法
        }
        if (num1>num2){
            result=num1;
        }else {
            result=num2;
        }

        return result;
    }
}

其上两个方法的作用都是比较大小，有着相同的名字，但形式参数不同

输出结果为

方法重载原则

1. 方法名相同

2. 参数列表不同（个数/类型/参数排列顺序不同）

3. 方法的返回类型可以相同可以不同。但仅仅返回类型不同不足以称为方法的重载

public static int max(int num1,int num2)
public static int max(double num1,double num2)
public static int max(int num1,int num2,int num3)
...

• 重载实现理论：方法名称相同时，编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错

命令行传递参数

package com.su.methud;

public class Demo03 {
    public static void main(String[] args) {
        //args.length 数组长度
        for (int i = 0; i < args.length; i++) {
            System.out.println("args["+i+"]:"+args[i]);
        }
    }
}

在cmd中打开

注意点：

1. javac的意思是编译，cd…可以返回上一目录
2. 因为Demo03中含有包package com.su.methud，因而在D:\JavaSE\基础语法\src\com\su\methud>中是打不开的（即自己本身不能打开自己）所以要返回到src目录

可变参数

public class Demo04 {
    public static void main(String[] args) {

        Demo04 demo04 = new Demo04();
        demo04.test(1,3,5,45,12);
    }
    public void test(int... i){
        System.out.println(i[0]);
        System.out.println(i[1]);
        System.out.println(i[2]);
        System.out.println(i[3]);
        System.out.println(i[4]);
    }
}

输出结果为

形式

• 在指定参数类型后加一个省略号
• 一个方法只能指定一个可变参数，且必须是方法的最后一个参数。任何普通的参数必须在它之前声明

常见错误

1. 可变参数没有放在最后的位置上

public void test(int... i,int x)

2. 传输的实参必须类型相同

demo04.test(1,3,5,45.0,12);

public void test(int x,int... i){

public class Demo04 {
    public static void main(String[] args) {
        //调用可变参数的方法
        printMax(34,3,3,2,56.5);
        printMax(new double[]{1,2,3});
    }

    public static void printMax(double...numbers) {
        if (numbers.length==0){
            System.out.println("No argument passed");
            return;//非返回值，而是用作终止方法
        }
        double result=numbers[0];
        
        //比较赋值找出最大值
        for (int i = 1; i <numbers.length ; i++) {
            if (numbers[i]>result){
                result=numbers[i];
            }
        }
        System.out.println("The max value is"+result);
    } 
}

中间的return不是返回值，是起了终止方法的作用

输出结果为

递归

• 递归即自己调用自己，理解为套娃
• 在基数小时使用，大大减少代码量，思想要掌握，但能不用尽量不用

结构

• 递归头：指什么时候不调用自己。可以理解为套娃中最里的一层。如果没有头，将陷入死循环，即无限套娃。
• 递归体：即什么时候需要调用自身方法

public class Demo06 {
    public static void main(String[] args) {
		System.out.println(f(4));
    }

    public static int f(int n){
        //阶乘
        if (n==1){
            return 1;
        }else {
            return n*f(n-1);
        }
    }
}

这个实现阶乘运算，以4！为例：输入4后，因为4!=1，因此返回值为4×f（3），而f（3）相当于输入3，即f（3）=3×f（2），f（2）=2×f（1），f（1）=1。整个算式写下来就是4!=f(4)=4×f(3)=4×3×f(2)=4×3×2×f(1)=4×3×2×1。任何数输入进去都会无限套娃直到最里层为1，从而实现阶乘的运算。

输出结果为

自主练习

• 编写一个计算器

public class Demo05 {//编写一个计算器
    public static void main(String[] args) {
        System.out.println("请输入：");
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextLine()){
            double num1=scanner.nextDouble();
            String operator = scanner.next();
            double num2 = scanner.nextDouble();
            switch (operator){
                case "+":
                    add(num1,num2);
                    break;
                case "-":
                    minus(num1,num2);
                    break;
                case "*":
                    multiply(num1,num2);
                    break;
                case "/":
                    except(num1,num2);
                    break;
                default:
                    System.out.println("输入格式不对");
            }
        }

        while (scanner.hasNext()){

        }
        scanner.close();
    }

    public static double add(double num1,double num2){
        double result=num1+num2;
        System.out.println(result);
        return result;
    }
    public static double minus(double num1,double num2){
        double result=num1-num2;
        System.out.println(result);
        return result;
    }
    public static double multiply(double num1,double num2){
        double result=num1*num2;
        System.out.println(result);
        return result;
    }
    public static double except(double num1,double num2){
        if (num2==0){
            System.out.println("除数不能为0");
            return 0;
        }else {
            double result=num1/num2;
            System.out.println(result);
            return result;
        }
    }
}

可循环输入

输出结果为

public class Demo07 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入计算方式:");
        String jisuantype = scanner.next();
        System.out.println("值1:");
        double next = scanner.nextDouble();
        System.out.println("值2:");
        double next1 = scanner.nextDouble();
        switch (jisuantype) {
            case "+":
                System.out.println(next + next1);
                break;
            case "-":
                System.out.println(next - next1);
                break;
            case "*":
                System.out.println(next * next1);
                break;
            case "/":
                System.out.println(next / next1);
                break;
        }
        scanner.close();
    }
}

不可循环输入

输出结果为

数组概述

定义

• 相同类型数据的有序集合
• 每一个数据称作一个数组元素，每个数组元素可通过一个下标来访问它们