10-方法

方法的定义及调用

1. 方法是语句的集合，它们在一起执行一个功能，类似于函数
2. 设计方法时保存方法的原子性，一个方法只完成一个功能
3. 方法命名规则：首字母小写+驼峰
4. 方法包含于类或对象中
5. 方法在程序中被创建，在其他地方被引用

• Java都是值传递

修饰符 返回值类型 方法名（参数类型 参数名）{
    ...方法体
    return 返回值;
}
//修饰符可选
//return 0; 终止方法

    //main方法
    public static void main(String[] args) {
        int sum = add(1, 2);
        System.out.println(sum);
        test();
        System.out.println(add(1, 2, 3));
    }
    //加法
    //修饰符+static(使之成为类方法，以在主函数里调用) 返回值类型 方法名 （形参）
    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;
    }

    public static void test(){
        for (int i = 1; i < 1000; i++) {
            if(i%5==0){
                System.out.print(i + "\t");//转义字符\t
            }
            if(i%(5*3)==0){//当i能被三个5整除的时候，即第三个数被输出，需换行
                System.out.println();//空串代表换行
                //System.out.print("\n");
            }
        }
    }

方法重载

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

规则：

1. 方法名称必须相同
2. 参数列表必须不同（个数或类型或顺序）
3. 返回类型可以相同可以不同

        
        System.out.println(max(2, 3));//自动调用参数为int类型的max
        System.out.println(max(2.1, 3.2));//自动调用参数为double类型的max
    }
    //比大小
    public static int max(int a,int b ){
        return a>b? a:b;
    }
    //方法重载  函数名一样 参数不同 ，调用时用什么样的参数就用什么样的方法
    public static double max(double a,double b ){
        return a>b? a:b;
    }

命令行传参

• 传递命令行参数给main()函数实现

可变参数

不定项参数

• 在方法声明中，在指定参数类型后加一个省略号（...）
• 一个方法只能指定一个可变参数，它必须是方法的最后一个参数。

public class Demo04 {
    public static void main(String[] args) {
        //不用static声明类方法  用对象调用方法
        Demo04 demo04 = new Demo04();//创建Demo04这个类的对象demo04
        //调用可变参数的方法
        demo04.test(1,2,3,4,5);
        demo04.test(new int[]{1,2,3});//用数组丢进去也可以
    }
    //可变长参数  本质是数组
    public void test(int ... i){
        System.out.println(i[0]);
        System.out.println(i[1]);
        System.out.println(i[2]);
        System.out.println(i[3]);
        System.out.println(i[4]);
    }
}

递归

递归就是A方法调用A方法，自己调用自己

递归结构包括两个部分：

• 递归头：什么时候不调用自身方法。若没有头，将陷入死循环
• 递归体：什么时候需要调用自身方法。

java使用是栈机制，对于一些嵌套层次比较深的算法，递归就会带来大量函数调用，产生很多格外时间开销，甚至崩溃。（能不用递归就不用递归）

    //阶乘
    public static int fun(int n){
        if(n==1){
            return 1;
        }else {
            return n*fun(n-1);
        }
    }