7.JAVASE中方法的定义和参数的使用

方法的定义：

1.方法是语句的集合，他们一起执行一个功能  2.方法是解决一类问题的步骤的有序组合 3.方法在程序中被创建，在其他地方被调用 4.一个方法只完成一个功能。

修饰符    返回值类型  方法名 （参数类型 参数名）{
方法体
return 返回值；
}

例如：下面是再main方法下面构造一个方法，mian方法里面的值相当于实参，定义的方法里面的的变量相当于形参，程序只能实参传递到形参。1和2传递到下面的形参，赋给a和b。输出3.

ackage base3;
public class Demo4Fortyfive {
    //main方法
    public static void main(String[] args) {
 int sum = add(1,2);   //1,2直接出来了。实参
       System.out.println(sum);  //3
        text();
    }
        //方法：加法
        public  static  int add(int a , int b) {
            return a+b;  //形参
        }

方法的重载：
重载就是在一个类中，有相同的函数名称，参数列表必须不用。但形参不同的函数.一个类里面有两个方法，用相同的名字。可有有很多相同的方法，但是参数类型不能相同。

package base3;
public class Demo6 {
    public static void main(String[] args) {
        double max = max(10.0, 20.0);
        System.out.println(max);   //实
    }

    //比大小
    public static double max(double num1, double num2) {
        double result = 0;     //形
        if (num1 == num2) {
            System.out.println("num1==num2");
            return 0;  //return还有终止方法的意思
        }
        if (num1 > num2) {
            result = num1;
        } else {
            result = num2;
        }

        return result;
    }
    //比大小
    public static int max(int num1,int num2) {
        int result = 0;     //形
        if (num1 == num2) {
            System.out.println("num1==num2");
            return 0;  //return还有终止方法的意思
        }
        if (num1 > num2) {
            result = num1;
        } else {
            result = num2;
        }
        return result;
    }
    }

输出：20.0

可变参数：
在方法声明中，指定参数类型后加一个省略号。一个方法中只能指定一个可变参数，他必须是方法的最后一个参数，任何普通参数必须在他之前声明。

package base3;
//可变参数：在方法声明中，指定参数类型后加一个省略号
//一个方法中只能指定一个可变参数，他必须是方法的最后一个参数，任何普通参数必须在他之前声明
public class Demo8 {
    public static void main(String[] args) {
        Demo8 demo8 = new Demo8();  //先写后面然后alt+回车
        demo8.test(1,2,3,4,56,3);   //直接输入1，不用写前面的
    }
        public void test ( int...i){  //(int...i ,int x  为错，因为 只能在最后面
        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]);
            System.out.println(i[5]);

        }

输出:
1
2
3
4
56
3   

package base3;

public class Demo9Imoprtant {
    public static void main(String[] args) {
        //调用可变参数的方法
  printMax(34,4,3,2,23,4);
  printMax(new double[]{1,2,3,8});  //两种写法
    }  //记住这个}不然下面红


        public static  void printMax(double... numbers) {
            if (numbers.length == 0) {
                System.out.println("No argument passed");
                return;
            }
            double result = numbers[0];
            //排序
            for (int i = 1; i < numbers.length; i++) {
                if (numbers[i] > result) {
                    result = numbers[i];
                }
            }
            System.out.println("The max value is " + result);
        }


}

输出：
The max value is 34.0
The max value is 8.0

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

package base3;
public class Demo10Recursion {
    public static void main(String[] args) {
        System.out.println(f(5));
        //小计算递归，大的不能不要10000容易烧
        //5下去进行递归

    }
    //5!
    public static  int f(int n){
if (n==1){
    return 1;
}else{                       //这个里面实现的循环来×
    return n*f(n-1);     //可以在前面加个n=
}
    }

}


输出
120