方法

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

方法是解决一类问题的步骤组合
方法包含于类或者对象中
方法在程序中被创建，在其他地方被引用

设计方法的原则：方法的本意是功能块，就是实现某个功能的语句块的集合。我们设计方法的时候，最好保持方法的原子性，就是是一个方法只完成一个功能，这样利于后期拓展

方法定义：

修饰符：修饰符是可选的，告诉编译器如何调用该方法，定义了该方法的访问类型
返回值类型：方法可能会返回值。有些方法执行操作的那无返回值，这种情况下关键字就不是数据类型，而是void
方法名：方法的实际名称遵循驼峰原则。方法名和参数共同构成方法签名
参数类型:参数像是一个占位符，参数可选的，方法可以不包含任何参数。

形式参数：在方法被调用时用于接收外界输入的数据
实参数：调用方法时实际传给方法的数据

值传递和应用传递，Java都是值传递
方法体：方法体包含具体的语句，定义该方法的功能

修饰符 返回值类型 方法名（参数类型 参数名){
    ···
     方法体   
    ···
        return 返回值;
}

方法调用

调用方法：对象名.方法名(实参)
Java 支持2种调用方法的方式，根据方法是否返回值来选择。
当方法返回一个值的时候，方法调用通常被当作一个值。例如

int lag=max(30,40)

如果方法返回值是void，方法调用一定是一条语句。

System.out.println("hello，world")

eg1:

public static void main(String[] args) {

      int c=maxs(55,55);
      System.out.println(c);
    }
    //比大小的方法，输入参数返回大的只
   
    public static int maxs(int a,int b){
        int sum=-1;
        if(a==b){
            System.out.println("输入值相等");
            return  sum;//终止方法，不再执行后续
        }
        if(a>b){
            sum=a;
        }else{
            sum=b;
        }
        return sum;
    }
}
 /*
    * 输出结果
    * 输入值相等
        -1
    * */

方法重载

重载就是在一个类中，有相同的函数名称，但形参不同的函数
方法的重载规则：
- 方法名称必须相同
- 参数列表必须不同（个数不同，或类型不同，参数排列顺序不同等）
- 方法的返回类型可以相同也可以不相同
- 仅仅返回类型不同不足以成为方法的重载
实现理论
- 方法名相同时，编译器会根据调用方法的参数个数；参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错

 public static  void main(String args[]){

   double v=maxs(33,22);
   System.out.println(v);
    }
    public static int maxs(int a,int b){
        int sum=-1;
        if(a==b){
            System.out.println("输入值相等");
            return  sum;//终止方法，不再执行后续
        }
        if(a>b){
            sum=a;
        }else{
            sum=b;
        }
        return sum;
    }
    public static double maxs(double a,double b){
        double sum=-1;
        if(a==b){
            System.out.println("输入值相等");
            return  sum;//终止方法，不再执行后续
        }
        if(a>b){
            sum=a;
        }else{
            sum=b;
        }
        return sum;
    }
    public static double maxs(int  a,int b,int c){
        double sum=-1;
        if(a==b){
            System.out.println("输入值相等");
            return  sum;//终止方法，不再执行后续
        }
        if(a>b){
            sum=a;
        }else{
            sum=b;
        }
        return sum;
    }

可变参数

也叫不定参数，jdk1.5开始。Java支持传递同类型的可变参数

在方法声明中，指定参数类型后加省略号(...)

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

eg1：排序

 public static void main(String[] args) {

       int b[]=maxPrin( 1,3,4,5,11,34,56);
       for(int v:b){
           System.out.print(v+"\t");
       }
    }
    public void maxPrin(int a,int b){};
   // public void maxPrin(int b,int ...a){};
    public static  int [] maxPrin(int...a){
        int v[]=a;
        for(int i=0;i<v.length;i++){
            int q=0;
          for (int j=i;j<v.length;j++){
               if(a[i]<a[j]){
                   q=a[i];
                   a[i]=a[j];
                   a[j]=q;
               }
          }
        }
        return v;
    }
}

递归

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

利用递归可以用简单的程序来解决一些复杂问题

它通常把一个大型问题转化位一个原问题相似的小规模问题来求解，递归策略只需少量程序就可描述出解题过程所需要的多次重复计算，大大的减少了程序代码量。递归的能力在于用有限的语句来定义对象的无限集合

递归结构包括2部分：

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

eg1:

  public static void main(String[] args) {

   //   test();
    }


   /* public static  void test(){
        test();
    }
    Exception in thread "main" java.lang.StackOverflowError
    at method.Demo6.test(Demo6.java:15)
    at method.Demo6.test(Demo6.java:15)
     栈溢出
    */

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

eg1:

public static void main(String[] args) {
        System.out.println("阶乘算法_____");
        int v =0;
        v=test1(3);
        System.out.println("总的值为"+v);
    }

    public static int test1(int a ){
        System.out.print(a+"\t");
       if(a==1)
       {
        return  1;
       }else {
       return a*test1(a-1);
       }

    }
/*
阶乘算法_____
3   2   1   总的值为6

*/