方法

什么是方法

方法的定义和调用

package method;

public class Demo1 {
    public static void main(String[] args) {
        String s = sayHello();
        System.out.println(s);
        int t1 = 3;
        int t2 = 56;
        Demo1 t = new Demo1();
        System.out.println(t.max(t1,t2));
    }
    public static String  sayHello(){
        return "Hello";
    }

    public void hello(){
        return;
    }

    public int max(int a,int b){
        return a > b ? a : b;//三元运算符
    }
}

方法的重载

1. 方法存在于类中,二方法的重载就是在同一个类中,有着相同函数名称的几个函数但他们的形参(个数、类型、排列顺序)各不相同
2. 仅仅返回值类型不同不能称为方法的重载
3. 实现理论:方法名称相同时,编译器会genus调用方法的参数个数、参数类型等逐个匹配,以选择对应的方法,若匹配失败,则编译器会报错

public class Freight {
    public static void main(String[] args) {
        Freight f = new Freight();
        System.out.println(f.max(1,2));
        System.out.println(f.max(4.3,9.1));

    }
    public int max(int a, int b){
        return Math.max(a, b);
    }
    public double max(double a, double b){
        return Math.max(a, b);
    }
}

可变参数

1. 在形参的类型和形参的值之间插入...
2. 一个方法只能有一个可变参数,且必须是最后一个参数
3. 可变参数相当于定义一个不定义长度的关于某参数类型的数组

package method;

public class Varargs {
    public static void main(String[] args) {
        intMax(1.3,2.0,3.4,4.9,3.2);
    }
    //可变参数示例
    public static void intMax(double...numbers){
        double result = numbers[0];
        if(numbers.length == 0){
            System.out.println("No argument passed");
            return;
        }else {
            for (int i = 1; i < numbers.length; i++) {
                if(numbers[i]>result){
                    result = numbers[i];
                }
            }
            System.out.println("The max value is:    "+result);
          	return;
        }
    }
}

递归

递归就是A方法调用A方法

递归的两个部分:

1. 递归头:规定什么时候不调用自身方法.如果没有头,将陷入死循环
2. 递归体:什么时候调用自身方法

package method;

public class Recursion {
    public static void main(String[] args) {
        System.out.println(f(3));
    }
    public static int f(int n){
        if(n == 1){
            return 1;
        }else {
            return n*f(n-1);
        }
    }
}

递归原理

Java使用的是栈机制,递归深度越大,占用内存越大,容易造成内存崩溃