方法

我们经常使用到System.out.println()，它到底是什么呢？

• System 是系统类
  out 是标准输出对象
• println() 是一个方法
  这句话的用法是调用系统类 System 中的标准输出对象 out 中的方法 println()

Java方法是语句的集合，类似于C语言的函数，它们在一起执行一个功能

• 方法是解决一类问题的步骤的有序组合
• 方法包含于类或对象中
• 方法在程序中被创建，在其他地方被引用
• 设计方法的时候，最好保持方法的原子性，就是一个方法只完成1个功能，有利于后期扩展

public static void main(String[] args) {//void是main方法的返回值，void表示什么值都不返回
       int sum= add(1,2);
        System.out.println(sum);
    }
    public static int add(int x,int y){ //方法要定义在main方法的外面
        //加个static修饰符让add方法成为类变量，才能在main方法中直接被调用
        return x+y;
    }

方法的定义

一般情况下，定义一个方法包含以下语法

修饰符 返回值类型 方法名(参数类型 参数名){ 

... 

方法体 

... 

return 返回值; 

} 

下面是一个方法的所有部分：

• 修饰符：这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。如public、static
• 返回值类型：方法可能会返回值。returnValueType是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，returnValueType关键字void
• 方法名：是方法的实际名称
• 参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。定义方法时设置的参数被称为形参，实际输入的值被称为实参。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。
• 方法体：方法体包含具体的语句，定义该方法的功能。

方法的调用

Java 支持两种调用方法的方式，根据方法是否返回值来选择。

当方法返回一个值的时候，方法调用通常被当做一个值。例如：

int larger = max(30, 40);

如果方法返回值是void，方法调用一定是一条语句。例如，方法println返回void。下面的调用是个语句。

System.out.println("Hello World!");

写一个比较大小的方法

 public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入第一个数字");
        double a = scanner.nextDouble();
        System.out.println("请输入第二个数字");
        double b = scanner.nextDouble();
        double m=max(a,b);
        System.out.println();
        if(m!=0){
            System.out.println(m+"更大");
        }
    }
    public static double max(double x,double y){
        double result=0.0;
        if (x==y){
            System.out.println(x+"="+y);
            return 0;//终止方法
        }else if (x>y){
            result=x;
        }else{
            result=y;
        }
        return result;
    }

方法的重载

一个类中有两个同名但参数列表不同的方法，根据不同的参数列表（如参数类型）去调用方法就是方法的重载。
方法重载的规则：

• 方法的名称必须相同
• 参数列表必须不同（个数不同、类型不同、顺序不同...）
• 方法的返回类型可以相同也可以不同，故仅返回类型不同不足以实现方法重载。

以上面比大小的方法为例：

public class Hello {
    public static void main(String[] args) {

        int m=max(1,2);
        if(m!=0){
            System.out.println(m+"更大");
        }
    }

    public static int max(int x,int y){
        int result=0;
        if (x==y){
            System.out.println(x+"="+y);
            return 0;
        }else if (x>y){
            result=x;
        }else{
            result=y;
        }
        return result;
    }

    public static double max(double x,double y){
        double result=0.0;
        if (x==y){
            System.out.println(x+"="+y);
            return 0;
        }else if (x>y){
            result=x;
        }else{
            result=y;
        }
        return result;
    }
}

有两个同名的方法max，区别在于方法的参数类型不同。
当m的类型为int时，程序所调用的方法是int类型的max方法

当m的类型为double时，程序所调用的方法是double类型的max方法

double m=max(1,2);

命令行传参

有时候你希望运行在程序运行的时候给它传递消息。这要靠传递命令行参数给main()函数实现，仅做了解即可。

package Demo;

public class Hello {

        public static void main(String args[]){

            for(int i=0; i<args.length; i++){
                System.out.println("args[" + i + "]: " + args[i]);
            }

        }
    }

该程序直接运行是没有作用的，需要在命令行中运行。
idea中左下角点击终端terminal按钮可以进入命令行

进入命令行后首先在Hello.java所在目录下执行javac Hello.java命令来编译class文件
然后需要退回到包所在目录的上一级即\src，再执行java Demo.Hello命令来运行class文件
这里在Hello.java所在目录下执行java Hello或者在\src中执行java Hello都是不行的。

可变参数

JDK 1.5 开始，Java支持传递同类型的可变参数给一个方法。如果在写方法的时候不清楚要定义多少个参数，可以用可变参数。
在方法声明中，在指定参数类型后加一个省略号(...)
一个方法中只能指定一个可变参数，它必须是方法的最后一个参数，任何普通的参数必须在它之前声明。

public static void main(String args[]) {
        // 调用可变参数的方法
        printMax(34, 3, 3, 2, 56.5);
        printMax(new double[]{1, 2, 3});
    }
    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);
    }

递归

递归是一种常见的解决问题的方法，即把问题逐渐简单化。
递归的基本思想就是“自己调用自己”，一个使用递归技术的方法将会直接或者间接的调用自己。
递归结构包括两个部分：

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

利用递归计算5的阶乘

public static void main(String[] args) {
        System.out.println(f(5));
    }

    public static int f(int n) {
        if (0 == n){
            return 1;
        } else{
            return n*f(n-1);
        }
    }
/*
f(0)=1
f(1)=1*f(0)=1
f(2)=2*f(1)=2*1
f(3)=3*f(2)=3*2*f(1)=3*2*1
...
*/

图解

此题中，按照递归的三个条件来分析：
(1)边界条件：阶乘，乘到最后一个数，即1的时候，返回1，程序执行到底；
(2)递归前进段：当前的参数不等于1的时候，继续调用自身；→递
(3)递归返回段：从最大的数开始乘，如果当前参数是5，那么就是5 4，即5 (5-1)，即n * (n-1)→归
过程
main方法先调用f(5)，因为f(5)要得出结果需要调用f(4)，而f(4)要得到结果需要向下调用f(3)；
同理，f(3)再继续调用f(2)，f(2)调用f(1)。此时f(1)得到了结果1，并将结果传给f(2)
f(2)也得出了结果，然后再将f(2)的结果传给f(3)，以此类推，f(4)的结果传给f(5)得出最终结果。

递归其实是方便了程序员难为了机器，递归可以通过数学公式很方便的转换为程序。其优点就是易理解，容易编程。
但是java都是使用栈机制的
main方法在最底层，每调用一个方法就会在main方法上压一层（压栈），调用结束就出栈。
如果递归的深度过多，压栈的层数就会过大，造成大量内存被占用，降低程序运行速度甚至卡死。
所以能不用递归就不用递归，递归都可以用迭代来代替。