什么是方法method

java方法是语句的集合，在一起执行一个功能

方法是解决一类问题步骤的有序组合

方法包含于类或对象中

在程序中被创建，在其他地方被引用

方法的本意是功能块，就是实现某个功能的语句块的集合

设计方法的时候最好保持方法的原子性，

一个方法只完成一个功能，这样有利于后期扩展

 package basic.methodL;
 ?
 public class method01 {
     //main方法     返回值，void表示不返回值
     public static void main(String[] args) {
         int sum = add(1,2);//调用方法 add() 选择数字1,2 变成add(1,2)
         System.out.println(sum);
 ?
     }
     //自己的方法写在外面
     //比如加法 返回值是int整数
     public static int add(int a,int b){//a，b都是形式参数
         return a+b;// 1+2 return 3
 ?
     }
 }

 package basic.methodL;
 ?
 public class method02 {
     
     public static void main(String[] args) {
         test();//直接调用
     }
     //将打印1000以内能被5整除的数并且每行打印3个直接做成方法
     public static void test(){
         for (int i = 0; i <= 1000; i++) {
             if (i%5==0){
                 System.out.print(i+"\t");
 ?
             }
             if (i%(5*3)==0){
                 System.out.println();
 ?
 ?
             }
         }
 ?
     }
 ?
 }

方法的定义和调用

Java的方法类似其他语言的函数，是一段用来完成特定功能的代码片段

方法包含一个方法头和一个方法体：

 package basic.methodL;
 ?
 public class method03 {
     public static void main(String[] args) {
         /*
         修饰符 返回值类型 方法名（参数类型，参数名）{
         ...
         方法体
         ...
         return 返回值;
         }
          */
         int number = max(10,20);//调用方法 加上实际参数
         System.out.println(number);
 ?
     }
     public static int max(int num1,int num2){
         int results = 0;
         if (num1==num2){
             System.out.println("num1==num2");
             return 0;//这里用来终止方法
         };
         if (num1>num2){
             results = num1;
         }else {
             results = num2;
         }
         return results;
     }
 }
 ?

方法的重载

方法可以有很多重名的，但是要确保参数类型不同

方法重载的规则：

1. 名称必须相同

2. 参数列表必须不同

3. 返回类型可以相同也可以不相同

4. 仅仅返回类型不同不足以成为方法的重载

5. 方法名称相同时，编译器会根据调用房的参数个数、类型等去逐个匹配，以选择对应的方法，如果匹配失败就会报错

 public class method04 {
     public static void main(String[] args) {
         double number2 = max(10.0,20.0);
         System.out.println(number2);
     }
 ?
     public static double max(double num1, double num2) {
         double results2 = 0.0;
         if (num2 == num1) {
             System.out.println("num1==num2");
             return 0;
         }
         ;
         if (num1 > num2) {
             results2 = num1;
         } else {
             results2 = num2;
         }
         return results2;
     }
     public static double max(double num1, double num2,double num3) {
         double results2 = 0;
         if (num2 == num1) {
             System.out.println("num1==num2");
             return 0;
         }
         ;
         if (num1 > num2) {
             results2 = num1;
         } else {
             results2 = num2;
         }
         return results2;
     }
     public static int max(int num1, int num2,int num3) {
         int results2 = 0;
         if (num2 == num1) {
             System.out.println("num1==num2");
             return 0;
         }
         ;
         if (num1 > num2) {
             results2 = num1;
         } else {
             results2 = num2;
         }
         return results2;
     }

可变参数

在方法声明中，在指定参数类型后加一个省略号: ...

一个方法中只能指定一个可变参数，它必须是方法的最后一个参数，任何普通参数必须在它前面声明。

 package basic.methodL;
 ?
 public class method05 {
     public static void main(String[] args) {
         method05 method05 = new method05();
         method05.test(1,2,3,4,5,6);
 ?
     }
     public void test(int... i){
         System.out.println(i[2]);
 ?
     }
 }

 package basic.methodL;
 ?
 public class method06 {
     public static void main(String[] args) {
         printMax(34,7,9,43.1,9);
         printMax(new double[]{1,2,3});
 ?
 ?
     }
     public static void printMax(double...numbers){
         if (numbers.length == 0){
             System.out.println("nothing here");
             return;
         }
         double result = numbers[0];
         for (int i = 0; i < numbers.length; i++) {
             if (numbers[i] > result){
                 result = numbers[i];
             }
 ?
         }
         System.out.println("the max value is" + result);
     }
 }

递归

1. A方法调用A方法,自己调用自己

2. 利用递归可以用简单的程序来解决一些复杂的问题，它通常把一个大型复杂的问题层层转化为一个与原问题相似、规模较小的问题的求解。

3. 递归策略只需要少量的程序就可描述出截图过程中所需要的多次重复运算，大大的减少了程序的递归码。

4. 递归的能力在于用有限的语句来定义对象的无限集合。

5. 递归结构分为两个部分：

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

   2. 递归体：什么时候调用自身方法。

 package basic.methodL;
 ?
 public class method07 {
     /*
     阶乘案例
     1! 1
     2! 2*1
     3! 3*2*1
     5! 5*4*3*2*1
      */
     public static void main(String[] args) {
         System.out.println(f(3));
 ?
     }
     //2 2*f(1)
     //3 3*f(2)*f(1)
     public static int f(int n){
         if (n==1){//边界条件
             return 1;
         }else {//前阶段
             return n*f(n-1);//返回阶段
         }
 ?
     }
 }

递归在数字大、深度大的时候会调用太多函数，压很多栈，会产生额外的时间开销

深度越大 越别用递归，会占用大量空间内存

能不用就不用。

方法的学习

原文：https://www.cnblogs.com/wzq669492/p/14526120.html