方法 递归,重载

方法(驼峰命名)

方法的定义及调用

• 方法是解决一类问题的步骤的有序组合
• 方法包含于类或者对象中
• 方法在程序中被创建,在其他地方被引用

设计方法的原则:方法的本意是功能块,就是就是实现某个功能的语句块集合.一个方法只完成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 ;
    }

}