Java方法

# 方法的定义



# 方法的调用



## 方法的调用与形式参数

```javascript
public static void main(String[] args) {
    //形式参数--比大小
    //调用方法
    int result = FunctionDemo01.max(10,10);
    System.out.println(result);
}
//创建一个方法
//修饰符     方法类型  方法名称（形式参数）
public static  int max(int a,int b){
    if(a==b){
        System.out.println("a=b");
        return 0;
    }else if(a>b){
        return a;
    }else{
        return b;
    }
}
```

## 方法的重载---参数类型不同，名字可以相同

规则：

方法名称必须相同

参数列表必须不同（个数不同，类型不同，参数排列顺序不同）

方法的返回值类型可以相同可以不同

仅仅方法的返回值类型不同，不足以构成方法的重载

实现理论：

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

# 命令行传参

```javascript
public class CommandDemo {
    public static void main(String[] args) {
        for(int i=0;i< args.length;i++){
            System.out.println(args[i]);
        }
    }
}
```

必须使用cd../回退到src文件下，再访问全包名路径，才可以执行.class文件

# 可变参数

```javascript
public class VariableDemo {
    public static void main(String[] args) {
        //可变参数,可变参数可以理解为一个数组
        findMax(12,36,25,14,99,84,77);
        //findmax(new double[]{12,23});
    }


    //先定义一个方法,找出最大值
    public static void findMax(double... i){
        if(i.length==0){
            System.out.println("没有数字");
            //return 0;
        }


        double max = 0;
        for(int x=0;x<i.length;x++){
            if(i[x]>max){
                max=i[x];
            }
        }
       // return max;
        System.out.println("最大值是："+max);
    }

```

# 递归---自己调用自己

**缺点：嵌套的比较深的时候可能会造成内存崩溃（由于Java的栈机制决定了这样的性质）**

**小计算使用递归，大量计算（不使用）**

递归结构包含两个部分：

递归头：什么时候不调用自身方法，如果没有头，将陷入死循环

递归体：什么时候需要调用自身方法

``javascript
public class RecursionDemo {
    public static void main(String[] args) {
        //使用递归实现阶乘
        int s = recursion(5);
        System.out.println("使用递归的方法求阶乘："+s);
    }
    //定义一个方法
    public static int recursion(int i){
        if(i==1){
            return 1;
        }else{
            return i*recursion(i-1);
        }


    }
}
```

# 作业---写一个计算器（实现加减乘除）

```javascript
public class HomeWork {
    public static void main(String[] args) {
        //做一个计算器时间加减乘除
        calculate(10,‘-‘,20);


    }
    //定义一个加的方法
    public static double add(double a,double b){
        double sum = 0;
        sum=a+b;
        return sum;
    }
    //定义一个减的方法
    public static double subtract(double a,double b){
        double sum = 0;
        sum=a-b;
        return sum;
    }
    //定义一个乘的方法
    public static double rid(double a,double b){
        double sum = 0;
        sum=a*b;
        return sum;
    }
    //定义一个除的方法
    public static double divide(double a,double b){
        double sum = 0;
        sum=a/b;
        return sum;
    }
    //定义计算机
    public static double calculate(double a, char f, double b){
        switch(f){
            case ‘+‘:


                double resulta = add(a,b);
                System.out.println("a+b="+resulta);
                //return resulta;
                break;
            case ‘-‘:


                double results = subtract(a,b);
                System.out.println("a+b="+results);
               // return results;
                break;
            case ‘*‘:


                double resultr = rid(a,b);
                System.out.println("a+b="+resultr);
               // return resultr;
                break;
            case ‘/‘:


                double resultd = divide(a,b);
                System.out.println("a+b="+resultd);
               // return resultd;
                break;
            default:
                System.out.println("计算错误！");
                //return 0;
        }
        return 0;
   
```