方法

什么是方法？

Java方法是语句的集合，它们在一起执行一个功能。
方法是解决一类问题的步骤的有序组合；
方法包含于类或对象中；
方法在程序中被创建，在其他地方被引用；

从较为通俗的方式讲解方法的话，“方法”就是我们从一个“解”之下到“答”之上的计算过程，只不过我们是利用了计算机汇编语言将这种计算过程表达出来而已。

而利用一个“方法”，我们可以向其中投入不同的数据以达到相同的数据的处理效果和不同的数据处理结果。

设计方法的原则:方法的本意是功能块，就是实现某个功能的语句块的集合。

我们设计方法的时候，最好保持方法的原子性，就是一个方法只完成1个功能，这样利于我们后期的扩展。

说到这里时，你是不是感觉方法的定义似曾相识？

没错！Java的方法类似于其它语言的函数，是一段用来完成特定功能的代码片段。

方法详解

例如：

public class Demo02 {

public static void main( String[] args) {

​ int max=max(x,y);//实参

​ System.out.println(max);

}//比大小

public static int max ( int num1,int num2){//形式参数

​ int result = 0;

​ if (num1==num2){

​ System. out.println( “ num1==num2”);

​ return 0; //终止方法

}

​ if ( num1>num2){

​ result = num1;

}

​ else {

​ result =num2 ;

}

​ return result;

}
}

如此看来是不是就很清晰了呢？它的本质与C语言基本相同。

如果还有一点不太懂的话，我们再来模块化讲解一遍。

1.public class Demo02 {…}

public class Demo02 {…}

指代的是现有的Java类这个整个类，我们所有针对于这个类和其他外部类的方法都会卸载这个花括号中；

2.public static void main( String[] args) {…}

public static void main( String[] args) {…}

main函数象征着函数的输入端以及输出端，一个Java类中有且只有一个main函数，我们所有的IO流全部从其中经过，它的花括号中可以包含其他的方法，也可以直接调用其他的方法，但这里建议还是将方法写在main函数的外部，甚至可以专门建立一个不含main函数的类去储存需要用到的函数，在之后的学习生活中，我们会了解到在一个单独包中只需要有一个具有main函数的Java类就可以了，包中的其他类就负责承载相关的数据与方法。

3. int max=max(x,y);

建立一个max变量来承载我们需要获取的数值，后面的max是方法的引用，而max(x,y)则是向名为max的方法中投入一个叫x，一个叫y的相关变量，这个x和y是我们定义的变量，在main中改变它们会引起程序结果的改变。

4.public static int max ( int num1,int num2){…}

建立一个名字叫做max的static固定方法，后面的小括号中的int num1,int num2是形式参数，形式参数中的num1和num2只能是int属性的，这里的num1和num2在{}中如果发生了改变，是不会影响到main函数中输入的x和y；

5.return 0

​ return 0不但代表着返回“0”这个数字，还代表着直接结束整个方法流程；

6. return result

return result代表着当result已经被确认时，返回result值到主函数中的相应变量中，也就是我们上文提到的main函数中的max变量

方法的重载

我们直接来看一个程序吧

package studyBase.method;

import java.util.Scanner;

public class chongzai1 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入两个或者三个数进行大小比较");
        int a=scanner.nextInt();
        int b=scanner.nextInt();
        int c=scanner.nextInt();

        max(a,b);
        max((double)a,(double)b);
        max((double)a,(double)b,(double)c);
    }
    public static int max(int a,int b){
       if (a==b){
           System.out.println("a和b一样大，程序结束");
           return 0;
       }
       if (a<b){
           System.out.println("b更大");
           return b;
       }
       else {
           System.out.println("a更大");
           return a;
       }

    }
    /////////////////////////////////////////////////
    public static double max(double a,double b){
       if (a==b){
           System.out.println("a和b一样大，程序结束");
           return 0;
       }
       if (a<b){
           System.out.println("b更大");
           return b;
       }
       else {
           System.out.println("a更大");
           return a;
       }

    }
    ///////////////////////////////////////////////////////
    public static double max(double a,double b,double c){
       if (a==b&&b==c){
           System.out.println("a和b,c一样大，程序结束");
           return 0;
       }
       if (a<b){
           if (b>c)
           {
               if (c>a)
                   System.out.println("b>c>a");
               else {
                   System.out.println("b>a>c");
               }
           }
           if (c>b)
           {
               System.out.println("c>b>a");
           }
       }
       else {
           if (b<c)
           {
               if (c>a)
                   System.out.println("c>a>b");
               else {
                   System.out.println("a>c>b");
               }
           }
           if (b>c)
           {
               System.out.println("a>b>c");
           }
       }
    return 0;
    }
}

这里我们相当于直接重载了三个方法名完全相同的方法：

其中一个是max(a,b)，这意味着只有两个数字时会导入这种方法中，同时按照这种方法进行数据的处理与计算，同时这a与b两个数字都应该是原始输入数字的数据类型，因为这个方法加入的实参并没有进行相关的强制转换，所以会以本身的数据类型进行输入，并进入相同数据类型的形参方法中；

其中有一个是 max((double)a,(double)b)，相当于将a和b的数据类型进行了强制转换变为了double，从而其接受了数据之后只能进入a与b均为double的形式参数的方法中，这里我们就遇见了我们将要学习的第一种重载方法——参数类型不同的重载，它的分辨方式就如同我们所说的一样，根据输入的参数类型的不同进行相关的重载，从而可以使一个输入的数据可以以不同的参数类型进入不同的方法中实现不同的运算；

还有一个是 max((double)a,(double)b,(double)c)，这里额外引入了一个double的c变量，从而使得我们的形式参数从两个变为了三个，从而使其与其余两个方法区分开来，这里只会在遇到(double)a,(double)b,(double)c三个变量同时出现时才会进行使用，这就是我们的第二种重载方式——参数个数不同构成的重载；

可变参数（不定项参数）

从JDK 1.5开始，Java支持传递同类型的可变参数给一个方法。

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

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

package studyBase.method;

public class Demo02 {
    public static void main(String[] args) {
        Demo02 demo02 = new Demo02();//这里不需要知道是怎么回事，只需要记住在引用该方法的情况下要先自己引用自己即可
        demo02.Test(1,3,4,5);//在形式参数已经是可变参数的情况下，这里可以直接输入数值

    }
    public void Test(int...i){//利用形式参数构造可变参数
        System.out.println(i[0]);

    }
}

方法重载

package studyBase.method;

import java.util.Scanner;

import static java.lang.System.in;

public class Demo03 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(in);
        int n=scanner.nextInt();
        int sum=f(n);
        System.out.println(sum);
    }
    public static int f(int n){
        if (n==1){
            return 1;
        }
        else {
            return n*f(n-1);
        }
    }
}

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

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

它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。

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

递归结构包括两个部分:

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

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