Java方法

方法

• Java方法是语句的集合，它们在一起执行一个功能
  • 方法是解决一类问题的步骤的有序组合
  • 方法包含在类或对象中
  • 方法在程序中程序中被创建，在其他地方被引用
• 设计方法的原则:方法的本意是功能块，就是实现某个功能的语句块的集合，我们设计方法的时候最好保证方法的原子性。就是一个方法只执行一个功能，这样有利于我们后期扩展。
• 方法的命名规则:首字母小写和驼峰规则

【演示】

public class Demo01 {
    /* main方法 */
    public static void main(String[] args) {
        int sum = add(1,2);// 1和2是实参
        System.out.println("sum="+sum);
    }
    /* add方法，x和y是形参 */
    public static int add(int x, int y){
        return x + y;
    }
}

方法的定义及调用

方法的定义

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

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

• 修饰符:可选
• 返回类型:方法可能有返回值。没有返回值的关键字是void
• 方法名:方法的实际名称（首字母小写和驼峰规则）
• 参数类型:参数像是一个占位符
  • 参数类型、顺序和参数个数。参数是可选的，方法可以不包含任何参数
    • 形式参数:在方法被调用时用于接收外界输入的数据
    • 实参:调用方法时实际传给方法的数据
• 方法体:定义该方法的功能

public class Demo02 {
    /* main方法 */
    public static void main(String[] args) {
        int maxNum = maxThree(2,5,8);
        System.out.println("maxNum="+maxNum);
    }
    /* 三个数求最大值 */
    public static int maxThree(int a, int b, int c){
        int result = 0;
        if (a < b){
            result = b;
        }else {
            result = a;
        }
        if (result < c){
            result = c;
        }
        return result;
    }
}

方法调用

• 调用方法:对象名.方法名(实参列表);

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

• 当方法返回一个值的时候，方法调用通常被当做一个值

    int large = max(20,40);
  

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

    System.out.println("");
  

方法重载

重载就是在一个类中，有相同的函数名称，但形参不同的函数

• 方法的重载规则
  • 方法名必须相同
  • 参数列表必须不同(个数不同或类型不同或参数排列顺序不同等)
  • 方法的返回值可以相同也可以不相同(重载与返回值无关)
  • 仅仅返回类型不同不足以成为方法的重载
• 实现理论
  方法名称相同的时候，编译器会根据调用方法的参数个数.参数类型去逐一匹配，以选择对应的方法，如果匹配失败，则编译器报错。

【演示】

public class Demo03 {
    /* main方法 */
    public static void main(String[] args) {
        int maxNum1 = maxThree(2,5,8);
        System.out.println("maxNum1="+maxNum1);
        double maxNum2 = maxThree(2.23,3.14,6.78);
        System.out.println("maxNum2="+maxNum2);
    }
    /* 三个数求最大值 */
    public static int maxThree(int a, int b, int c){
        int result = 0;
        if (a < b){
            result = b;
        }else {
            result = a;
        }
        if (result < c){
            result = c;
        }
        return result;
    }
    /* 三个数求最大值(重载比较浮点型数据) */
    public static double maxThree(double a, double b, double c){
        double result = 0;
        if (a < b){
            result = b;
        }else {
            result = a;
        }
        if (result < c){
            result = c;
        }
        return result;
    }
}

命令行参数

public class Demo04 {
    public static void main(String[] args) {
        for (int i = 0; i < args.length; i++) {
            System.out.println("args["+i+"]="+args[i]);
        }
    }
}

【演示】

可变参数

java中的可变参数

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

可变参数的本质是数组

【演示】

public class Demo05 {
    public static void main(String[] args) {
        printMax(1,2,3,8,5);
        printMax(new int[]{0,2,5,9,4,6});
    }
    public static void printMax(int...nums){
        int max = nums[0];
        for (int i = 1; i < nums.length; i++) {
            if (max < nums[i]){
                max = nums[i];
            }
        }
        System.out.println("max="+max);
    }
}

递归

自己调用自己：求5的阶乘

public class Demo06 {
    public static void main(String[] args) {
        int result = factorial(5);
        System.out.println("result="+result);
    }
    /* 求阶乘 */
    public static int factorial(int x){
        if (x == 1){
            return 1;
        }else {
            return x * factorial(x - 1);// 递归
        }
    }
}

main方法是在栈底,递归是非常消耗内存的,每调用一次就会往栈中压一个方法,时间和空间复杂度为增加

【作业】

实现一个计算器(加减乘除功能)

public class CalculateDemo {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("请输入：");
        int a = input.nextInt();
        System.out.println("请输入运算方式：");
        String b = input.next();
        System.out.println("请输入：");
        int c = input.nextInt();
        double result = 0.0;
        switch (b){
            case "+":
                result = add(a, c);
                System.out.println(result);
                break;
            case "-":
                result = subsract(a, c);
                System.out.println(result);
                break;
            case "*":
                result = multiplication(a, c);
                System.out.println(result);
                break;
            case "/":
                result = division(a, c);
                System.out.println(result);
                break;
            default:
                System.out.println("输入有误");
        }
        input.close();
    }
    /* 加法 */
    public static double add(int x, int y){
        return (double)x + y;
    }
    /* 减法 */
    public static double subsract(int x, int y){
        return  (double)x - y;
    }
    /* 乘法 */
    public static double multiplication(int x, int y){
        return (double)x * y;
    }
    /* 除法 */
    public static double division(int x, int y){
        return (double)x / y;
    }
}