方法

何谓方法？

System.out.println();

调用系统类，里面的输出对象out，中的方法println

---

命名方法：首字母小写，驼峰规则

java方法是语句的集合，他们在一起执行一个功能，是解决一类问题的步骤的有序组合，它包含于类或对象中，再程序中被创建，再其他地方被引用。（函数）

public class Demon1 {
              //main方法↓
    public static void main(String[] args) {
        int sum = add(1,2);//调用方法   
               //实际参数↑
        System.out.println(sum);
    }
         //返回值类型↓int    add方法名      返回
    public static int add(int a,int b){return a+b;}// 创建方法  
}                     //形式参数↑ 

语法：修饰符 返回值类型 方法名（参数类型 参数名，参数类型 参数名...）{...方法体,,,return返回值；}方法体定义了方法的功能；若无返回值则返回类型为void；若存在返回值，则需要使用return返回值。return会终止方法

形式参数：用来定义作用，add(int a,int b)

实际参数：实际调用传递给他的参数，add(1,2)

设计原则：一个方法只完成一个功能，利于后期的扩展

public class CompereTethod1 {
    public static void main(String[] args) {
        int f = max(1,2);
        System.out.println(f);
    }

    public static int max(int a, int b) {
        int result = 0;
        if (a == b) {
            System.out.println("两个数一样");
        } else {
            if (a < b) {
                result = b;
            } else {
                result = a;
            }

        }return result;//注意返回值需要再方法体内，erturn之后后方法结束
    }
}  // ========以上为 创建一个，找出两个数中大的那个数的方法max().并再main方法中调用=======

方法的调用

调用方法：对象名 方法名(实参列表)如

int f = max(1,2)； //f如未定义需要先定义

当方法有返回值时，方法调用通常被当作一个值。如↑

当方法没有返回值时，方法调用一定时一条语句。如↓

System.out.println("芜湖起飞！"); //返回类型为void

//方法的创建与调用。创建了一个比大小的方法，然后再main方法里调用。

public class CompereTethod1 {
    public static void main(String[] args) {
        int f = max(2,15);
        System.out.println(f);
    }

    public static int max(int a, int b) {
        int result = 0;
        if (a == b) {
            System.out.println("两个数一样");
        } else {
            if (a < b) {
                result = b;
            } else {
                result = a;
            }

        }return result;
    }
}

方法的重载

在一个类中有相同的函数(方法)名称，但形参不同的函数（方法）

                          //max方法的重载
public class CompereTethod1 {
    public static void main(String[] args) {
        double f = max(2.1,3.7);
        System.out.println(f);
    }

    public static int max(int a, int b) {
        int result = 0;
        if (a == b) {
            System.out.println("两个数一样");
        } else {
            if (a < b) {
                result = b;
            } else {
                result = a;
            }

        }return result;
    }

    public static double max(double a, double b) {
        double result = 0;
        if (a == b) {
            System.out.println("两个数一样");
        } else {
            if (a < b) {
                result = b;
            } else {
                result = a;
            }

        }return result;
    }
}          

重载规则：方法名字必须相同，参数列表必须不同（数量不同，类型不同，排列和顺序不同），返回类型不同不足以成为方法的重载。

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

public class Demon1 {
              //main方法↓
    public static void main(String[] args) {
        int sum = add(1,2);
        System.out.println(sum);
    }
 //返回值类型↓int    add方法名      返回
    public static int add(int a,int b){return a+b;}
    public static int add(int a,int b,int c){return a+b+c;}
}// add方法的重载↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑

可变参数

若方法参数不确定则需要通过重载，写多个方法，很繁琐。在jdk1.5后，java支持传递同类型的可变（不定项）参数给一个方法。在方法声明中，在指定参数类型后加一个省略号（...）。一个方法只能指定一个可变参数。他必须时最后一个参数，任何普通参数必须在他之前声明。

public class Demon4 {
    public static void main(String[] args) {
        Demon4 demon4 = new Demon4();
        demon4.text(0,2,54,8,88,8);

    }           //可变参数↓
    public void text(int...i){
        System.out.println(i[0]);
        System.out.println(i[1]);
        System.out.println(i[3]);
        System.out.println(i[4]);
        System.out.println(i[5]);
    }
}

递归

递归结构包括两个部分：

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

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

//求一个数的阶乘 递归方法
public class Demon6 {
    public static void main(String[] args) {
     System.out.println(f(10));   
    }
    public static int f(int n){
        if (n==1){
            return 1;//递归头
        }else {
            return n*f(n-1);//递归体
        }
    }
}

理解：递归等于方法自身调用自身，当n=10，进入方法，返回值为10*f(9)，f(9)未知，再调用自身，f9=9乘f8......一直到求f1，f1=1，一步步返回f2=f1乘2，f3等于f2乘3......最终能够求出f10.

小计算可以使用递归，大计算不要使用递归