4方法相关知识

1.1概念

方法存在的意义
①模块化组织代码
②代码被重复使用, 一份代码在多个位置被使用.
③代码更好理解更简单
⑤直接调用现有方法开发

1.2定义语法

基本语法

//定义方法
public static 方法返回值  方法名称([参数类型 形参]){
	方法体代码；
	[return 返回值]；
}
//方法调用
返回值变量 =  方法名称(实参)
①方法名称必须采用小驼峰形式,只有一个单词均小写,如果两个第二个单词的首字母大写依此类推
②public static :因为当前所有 的方法在写完之后都会在main方法中调用,而mian是静态的所有当前定义的方法都是静态的

public class HelloWorld {
    public static void main(String []args) {
       int a = 10;
		int b = 20;//实参输入的值要和形参的类型保持一致
		//调用方法
		int ret = add(a,b);
		System.out.println("ret = " + ret);
    }
	//方法的定义
	public static int add(int x ,int y) {
	return x + y;
	}
}

①定义方法时，可以没有参数，但是要指定参数类型
②定义方法时，可以没有返回值，如果没有返回值，返回值类型写成void,如果有返回值,返回值的类型的返回值一致
③方法的定义必须写在类中，在主函数的上下没有要求
④JAVA中没有“函数声明”

//求最大值
//求两个数之间的最大值
      public static int maxNum(int num1,int num2){
           return num1 > num2 ? num1 : num2;
        }
        public static void main(String[] args){
           Scanner scan = new Scanner(System.in);
           int num1 = scan.nextInt();
            num2 = scan.nextInt();
           int ret = maxNum(num1,num2);
            System.out.println(ret);
        }
//求三个数之间的最大值①
 public static int maxNum(int n1,int n2,int n3){
        if(n1>n2){
            if(n1>n3){
                return n1;
            }else{
                return n3;
            }
        }else{
            if(n2 > n3){
                return n2;
            }else{
                return n3;
            }
        }
    }
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int a1 = scan.nextInt();
        int a2 = scan.nextInt();
        int a3 = scan.nextInt();
        int ret = maxNum(a1,a2,a3);
        System.out.println(ret);
    }
    //求三个数之间的最大值②
    public static int maxNum(int n1,int n2 ){
        return n1 > n2 ? n1: n2;
    }
    public static int threeMax(int n1,int n2,int n3){
        return maxNum(maxNum(n1,n2),n3);//方法的多次调用
    }

    public static void main(String[] args) {
        Scanner scan =new Scanner(System.in);
        int n1 = scan.nextInt();
        int n2 = scan.nextInt();
        int n3 = scan.nextInt();
        int ret = threeMax(n1,n2,n3);
        System.out.println(ret);
    }

1.3调用执行过程

①定义方法的时候不会执行方法的代码，只有在调用的时候才会执行
②方法在调用过程会把实参赋值给形参
③实参传递给形参之后就会执行方法体代码
④方法调用过程中遇到return 语句，方法调用结束
⑤一个方法可以被调用多次

public class HelloWorld {
     public static void main(String[] args) {
            int a = 10;
            int b = 20;
            int ret = sum(a,b);
            System.out.println("ret="+ret);
            int ret2 = sum(40,20);
            System.out.println("ret2="+ret2);
        }
        public static  int sum(int a,int b){
            return a + b;

        }
}

//1！+2！+3！+4！+5！
public class HelloWorld {
     public static void main(String[] args) {
         int sum = 0;
		 for(int i = 1; i <= 5; i++){
		    sum += factor(i);
		 }
		 System.out.println(sum);
        }
	public static int factor(int n){
	    int result = 1;
		for(int i = 1; i <= n;i++){
	    result *= i;
	    }
		return result;
	 }
}
//阶乘2
    public static  int factor(int n){
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            int ret = 1;
            for (int j = 1;j<= i;j++ ) {
               ret =  ret * j;
            }
            sum+=ret;
        }
       return sum;
    }
    public static void main(String[] args) {
        System.out.println(factor(5));
        }
    //阶乘3
       public static int fac (int n ){
        int ret = 1;
        for (int i = 1; i <= n; i++) {
            ret  *= i;
        }
        return ret;
    }
    public static int factor(int n){
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += fac(i);
        }
        return sum;
    }
    public static void main(String[] args) {
        System.out.println(factor(5));
    }
  

  //阶乘2
   public static int factor(int x){
        int sum = 0;
        for (int i = 1; i <= 5; i++) {
       int ret= 1;
            for (int j = 1; j <= i;j++) {
               ret = ret*j;
            }
           sum += ret;
        }
        return sum;
    }
    public static void main(String[] args) {
        int ddd = factor(5);
        System.out.println(ddd);
    }

//阶乘3
   public static int fac (int n ){
        int ret = 1;
        for (int i = 1; i <= n; i++) {
            ret  *= i;
        }
        return ret;
    }
    public static int factor(int n){
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += fac(i);
        }
        return sum;
    }
    public static void main(String[] args) {
        System.out.println(factor(5));
    }

1.4实参和形参的关系

形参相当于实参的复制，即传值调用
形参的改变不会对形参造成影响

public class HelloWorld {
     public static void main(String[] args) {
        int  a = 10;
		 int b = 20;
		 swap(a,b);
		 System.out.println("a = "+a +"b="+b);
	 }
		 public static void swap(int a,int b){
		     int tmp = a;
			 a = b;
			 b = tmp;
		 }
	 }
//a = 10,b =20,未完成a,b数据交换

2方法重载

方法重载：同一个方法名字，提供不同的版本的调用方法

   public static int add(int x ,int y){
        return x + y;
    }
    public static double add(double x,double y){
        return x + y;
    }
    public static int add (int x ,int y,int z){
        return x +y +z;
    }

    public static void main(String[] args) {
        int a = 3;
        int b = 4;
        int sum = add(a,b);
        System.out.println(sum);
        double c = 3.2;
        double d = 4.5;
        double sum1 = add(a,b);
        System.out.println(sum1);
        int x = 3 ;
        int y = 6;
        int z = 9;
        int sum2 = add(x,y,z);
        System.out.println(sum2);
    }

重载的规则
①方法名相同
②方法的参数不同（个数、类型）
③方法的返回值类型不会影响重载
当两个方法的名字、参数相同、返回值类型不同时，不会构成方法的重载

3方法递归

public class HelloWorld {
     public static void main(String[] args) {
        int n = 5;
		 int ret = factor(n);
		 System.out.println("ret="+ret);
	 }
	public static int factor (int n){
	    System.out.println("函数开始, n = " + n);
		if (n == 1){
		 System.out.println("函数结束, n = 1 ret = 1");
	     return 1;
	     }
		int ret = n * factor (n-1);
		System.out.println("函数结束, n = " + n + " ret = " + ret);
		return ret;
	 } 
}
函数开始, n = 5
函数开始, n = 4
函数开始, n = 3
函数开始, n = 2
函数开始, n = 1
函数结束, n = 1 ret = 1
函数结束, n = 2 ret = 2
函数结束, n = 3 ret = 6
函数结束, n = 4 ret = 24
函数结束, n = 5 ret = 120
ret=120

从3开始的递归过程
递归，递过去再归回来

1+2+3+4+5
   public static int factor(int n){
        if(n == 1){
            return 1;
        }else
            return n * factor(n-1);
    }

    public static void main(String[] args) {
        int n = 5;
        System.out.println(factor(n));
    }

 //输入一个非负整数,返回他的数字之和
    public static int fac(int n ){
        if(n < 9){
            return n;
        }
        return n%10 + fac(n/10);
    }

    public static void main(String[] args) {
        int n = 1256;
        int ret = n % 10 +fac(n/10);
        System.out.println(ret);
    }