java4：方法

Java方法

（一）方法解释

方法命名规则：首字母小写，后面遵循驼峰原则，如：addTest

//调用System类里面的标准输出对象out中的println方法
System.out.println();
/*
System：是一个类
out：System中的一个对象
println()：一个方法
*/

（二）方法的定义及调用

1. 通过方法实现加法

public class Method {
    public static void main(String[] args) {
        int sum = add(3, 4);
        System.out.println(sum);
    }

    public static int add(int a, int b) {
        int sum = a + b;
        return sum;
    }
}

7

2. 通过方法实现比较大小

public class Method {
    public static void main(String[] args) {
        int max = maxMin(5, 15);
        System.out.println(max);
    }

    public static int maxMin(int a, int b) {
        int result = 0;
        if (a == b) {
            System.out.println(a + "=" + b);
            return 0; //return可以结束方法
        } else if (a > b) {
            result = a;
        } else if (a < b) {
            result = b;
        }
        return result;
    }
}

15

（三）方法重载

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

加法重载（参数类型不同）：

public class Method {
    public static void main(String[] args) {
        float max = maxMin(5, 15); //根据不同输出类型，找到同类型的方法进行执行
        System.out.println(max);
    }

    public static int maxMin(int a, int b) {
        int result = 0; 
        if (a == b) {
            System.out.println(a + "=" + b);
            return 0; //return可以结束方法
        } else if (a > b) {
            result = a;
        } else if (a < b) {
            result = b;
        }
        return result;
    }

    public static float maxMin(float a, float b) {
        float result = 0;
        if (a == b) {
            System.out.println(a + "=" + b);
            return 0; //return可以结束方法
        } else if (a > b) {
            result = a;
        } else if (a < b) {
            result = b;
        }
        return result;
    }
}

15.0

（四）命令行传参

public class MethodTest {
    // main方法中的args其实也是一个参数
    public static void main(String[] args) {
        for (int i = 0; i < args.length; i++) {
            System.out.println("args[" + i + "]：" + args[i]);
        }
    }
}

• 进入 .java 文件的目录，在该目录打开cmd
• 对 .java 文件进行编译（注意中文编码）
• 运行编译好的 .class 文件，并传入参数（需要退回包的根目录，并指定文件的绝对路径）

（五）可变参数

若涉及到很多参数，每种可能进行方法重载显然不是明智的选择，使用引入了可变参数

• jdk1.5开始，java支持传递同类型的可变参数给一个方法
• 在方法声明中，在指定参数类型后加一个省略号（…）
• 一个方法中只能指定一个可变参数，它必须是方法的最后一个参数，任何普通参数必须在它之前声明

示例1：

public class MethodTest {
    public static void main(String[] args) {
        MethodTest methodTest = new MethodTest();
        methodTest.test(1, 2, 3, 4, 5);
    }

    public void test(float j, int... i) {
        System.out.println(j);
        System.out.println(i[0]);
        System.out.println(i[1]);
    }
}

1.0
2
3

示例2：输出最大值

public class MethodTest {
    public static void main(String[] args) {
        printMax(12, 43, 1, 2, 4.4);
        printMax(new double[]{1, 2, 3, 4}); // 新建一个double数组，{数据}
    }

    public static void printMax(double... numbers) {
        if (numbers.length == 0) {
            System.out.println("没有参数！");
            return;
        }
        // 排序
        double result = numbers[0];
        for (int i = 1; i < numbers.length; i++) {
            if (numbers[i] > result) {
                result = numbers[i];
            }
        }
        System.out.println("max number is：" + result);
    }
}

max number is：43.0
max number is：4.0

（六）递归

递归：A方法调用A方法（自己调用自己）

• 递归可以用简单的程序来解决一些复杂的问题。它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可以描述出解题过程所需要的多次重复计算，大大的减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。
• 递归结构包含两个部分：
  • 递归头：什么时候不调用自身方法。如果没有头，将陷入死循环。
  • 递归体：什么时候需要调用自身方法。

1. 例1：求阶乘

public class MethodTest {
    public static void main(String[] args) {
        System.out.println(func(3));
    }

    public static int func(int i){
        /*
        i*func(i-1)
        实际上相当于 i*(i-1)，并再执行func，实现循环到i=1结束
        */
        if (i==1){
            return 1;
        }else {
            return i*func(i-1);
        }
    }
}