方法 递归,重载

方法是解决一类问题的步骤的有序组合方法包含于类或者对象中方法在程序中被创建,在其他地方被引用 设计方法的原则:方法的本意是功能块,就是就是实现某个功能的语句块集合.一个方法只完成1个功能,这样有利于往年后期的扩展.

public class Demo01 {
    public static void main(String[] args) {
        //调用add方法把方法retuen返回的值赋予i
        //add方法中2和4就是实参:实际调用方法传递给他的参数
        int i=add(2,4);
        System.out.println(i);
    }
    //方法中定义的a,b就是形参
    public static int add(int a,int b){
        return a+b;
    }
}

重载就是在一个类中,有相同的函数名称,但是形参不同的函数.

方法的重载的规则：

方法名称必须相同参数列表必须不同(个数不同,或者类型不同、参数排列顺序不同等)。方法的返回类型可以相同也可以不相同。仅仅返回类型不同不足以成为方法的重载。

实现理论：

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

public class Demo01 {
    public static void main(String[] args) {
        //调用add方法把方法retuen返回的值赋予i
        //add方法中2和4就是实参:实际调用方法传递给他的参数
        int i=add(2,4);
        System.out.println(i);
        //调用的是add的重载方法,实参与形参的数据类型以及个数匹配上
        double u=add(2.0,3.2);
    }
    //方法中定义的a,b就是形参
    public static int add(int a,int b){
        return a+b;
    }
    //add方法的重载
    public static double add(double a,double b){
        return a+b;
    }
}

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

public class Demo04 {
    public static void main(String[] args) {
       //调用可变参数订单方法
        printMax(34,12,56,86,1);
        double[] dc= new double[]{1,2.3,3};
        printMax(new double[]{1,2,3});
    }
    public static void printMax(double... numbers){
        if (numbers.length == 0) {
            System.out.println("无参数密码");
            return;
        }
        double re = numbers[0];

        //排序
        for (int i = 1; i < numbers.length; i++) {
            if (numbers[i]>re){
                re=numbers[i];
            }
        }
        System.out.println(re);
    }
}

A方法调用B方法

递归就是:A方法调用A方法!自己调用自己

递归结构包括两个部分：

递归头：声明时候不调用自身方法。如果没有头，将陷入死循环。递归体：声明时候需要调用自身方法。

public class Demo05 {
    public static void main(String[] args) {
        System.out.println(f(5));
    }
    public static int f(int n){
        //递归头
        if (n == 1) {
            return n;
        }else {  //递归体
            return n*f(n-1);
        }
    }
}

栈有限,当递归调用方法过多,就会奔溃造成内存泄露,只有当递归运行完,栈才会释放方法 ,main方法是在栈的最底层

public class Demo06 {
    public static void main(String[] args) {
    	//循环一直运行,死循环
        while(true){
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入一个数字");
            int a=sc.nextInt();
            System.out.println("请输入一个运算符");
            String str=sc.next();
            System.out.println("请输入一个是数字");
            int b=sc.nextInt();
            //判断调用哪个方法做什么运算
            switch (str){
                case "+":
                    add(a,b);
                    break;
                case "-":
                    delete(a,b);
                    break;
                case "*":
                    ride(a,b);
                    break;
                case "/":
                    except(a,b);
                    break;
                default:
                    System.out.println("你输入的内容有错请重新输入!");
            }
        }



    }
    //加法运算
    public static  void add(int a,int b){
        System.out.println(a+"+"+b+"="+(a+b));
        return ;
    }
	//减法运算
    public static  void delete(int a,int b){
        System.out.println(a+"+"+b+"="+(a+b));
        return ;
    }
	//乘法运算
    public static  void ride(int a,int b){
        System.out.println(a+"+"+b+"="+(a+b));
        return ;
    }
	//除法运算
    public static  void except(int a,int b){
    	//判断被除数不为0
        if (b!=0){
            System.out.println(a+"+"+b+"="+(a+b));
        }
        return ;
    }

}