Java方法的详解

Java方法注释

• Java方法是语句的集合，他们在一起执行一个功能
• 方法是解决一类问题的步骤的有序组合
• 方法包含类和对象
• 命名规则：首字母小写，驼峰原则，不出现下划线

---

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

Java方法的定义

• Java的方法类似其他语言的函数，是一段用来完成特定功能的代码片段，一般情况下，定义一个方法包含以下说法：
  方法包含一个头和一个方法体
       修饰符：修饰符，这是可选的，告诉编译器如何调用该方法定义了方法的访问类型
       返回值类型：方法可能会返回值，returnValueType是方法返回值的数据类型，有些方法执行所需的操作，但没有返回值（数据类型），在这种情侣下，returnValueType是关键字void
       方法名：是方法的名称，方法名和参数列表共同构成方法签名
       参数类型：参数像是一个占位符，当方法被调用时传递值给参数，这个值被称为实参或变量，参数列表是指方法的参数类型，顺序和参数的个数，参数是可选的，方法可以不包含任何参数
• 形式参数：在方法被调用时用于接收外界输入的数据
• 实参：包含具体的语句，定义该方法的功能
       方法体：包含具体的语句，定义该方法的功能

修饰符 返回值类型 方法名（参数类型 参数名）{
    ...
        方法体
        ...
        return 返回值；
        }

方法的调用

调用方法：对象名.方法名（实参列表）
Java支持两种调用方法，根据方法是否返回值来选择
     当方法返回一个值的时候,方法调用通常被当做一个值
     如果方法返回值是void，方法调用一直是一条语句
什么时候用返回值，什么时候使用无返回值？

• 没有返回值的方法只能进行一个特定的功能
• 有返回值的方法还可以将有用的数据作为返回值供其他地方使用
• 如果只有完成一个功能就直接用无返回值void，反之；

public class MethodDemo02 {
    public static void main(String[] args) {
//        方法调用
        int fin=text(10,32);
        System.out.println(fin);
    }
//    比大小
    public static int text(int a,int b){
        if (a==b){
            System.out.println("a==b");
//            return表示终止并返回一个数值
            return 0;
        }
//        初始值
        int result=0;
        if (a>b){
            result=a;
        }else {
            result=b;
        }
        return result;
    }
}

方法的重载

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

public class MethodDemo03 {
    public static void main(String[] args) {
//方法的重载
        int sum=number(10,58);
        System.out.println("sum = " + sum);
    }
    public static int number(int a,int b){
        return a+b;
    }
    public static double number(double a,double b){
        return a+b;
    }
    public static int number(int a,int b,int c){
        return a+b+c;
    }
}

命令行传参

有时候希望运行一个程序时再传递个它消息，这要靠命令行传参给main()函数实现

public class MethodDemo04 {
    public static void main(String[] args) {
//        main方法命令行传参
        for (int i=0;i<args.length;i++){
            System.out.println("args["+i+"]="+args[i]);
        }
    }
}

可变参数

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

public class MethodDemo05 {
    public static void main(String[] args) {
//            可变参数调用
        MethodDemo05 methodDemo05 = new MethodDemo05();
//        对象.方法名调用
        methodDemo05.printMax(32,35.5,4,44,65);
    }
    //找出最大值
    public void printMax(double...i){
        if (i.length==0){
            System.out.println("没有传递参数");
            return;
        }
        double result=i[0];
        for (int j=0;j<i.length;j++){
            if (result<i[j]){
                result=i[j];
            }
        }
        System.out.println("The max value is "+result);
    }
}

方法递归

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

public class MethodDemo06 {
    public static void main(String[] args) {
//方法的递归10以内的阶乘
        MethodDemo06 methodDemo06 = new MethodDemo06();
        methodDemo06.number(10);
    }
    public int number(int n){
        System.out.println("开始n="+n);
        if (n==1){
            System.out.println("这是递归头");
            return 1;
        }
//        递归自己调用自己
        int fin=n*number(n-1);
        System.out.println("递归结束n:"+n+"返回值"+fin);
        return fin;

    }
}

演示案例

开始n=10
开始n=9
开始n=8
开始n=7
开始n=6
开始n=5
开始n=4
开始n=3
开始n=2
开始n=1
这是递归头
递归结束n:2返回值2
递归结束n:3返回值6
递归结束n:4返回值24
递归结束n:5返回值120
递归结束n:6返回值720
递归结束n:7返回值5040
递归结束n:8返回值40320
递归结束n:9返回值362880
递归结束n:10返回值3628800

练习代码：制作一个计算器

public class JSQ_Demo {
    public static void main(String[] args) {
        while (true){
            Scanner input = new Scanner(System.in);
            System.out.println("请输入第一个数值：");
            double user_FirstNumber = input.nextDouble();
            System.out.println("请输入第二个数值：");
            double user_SecondNumber = input.nextDouble();
            System.out.println("请输入加减乘除的操作（输入符号+-*/）");
            String YSF = input.next();
//            按照用户需求进行调用方法
            switch (YSF){
                case "+":
                    addNumber(user_FirstNumber,user_SecondNumber);
                    break;
                case "-":
                    subNumber(user_FirstNumber,user_SecondNumber);
                    break;
                case "*":
                    mulNumber(user_FirstNumber,user_SecondNumber);
                    break;
                default:
 
                   divNumber(user_FirstNumber,user_SecondNumber);
                               }
            System.out.println("是否继续？（y/n）");
            String con = input.next();
            if (con.equals("y")){
                continue;
            }else {
                break;
            }

        }



    }
//    加法
    public static void addNumber(double fist_number,double second_number){
        double add=fist_number+second_number;
        System.out.println(fist_number+"+"+second_number+"="+add);
    }
//    减法
    public static void  subNumber(double fist_number,double second_number){
        double sub=fist_number-second_number;
        System.out.println(fist_number+"-"+second_number+"="+sub);
    }
//    乘法
    public static void  mulNumber(double fist_number,double second_number){
    double mul=fist_number*second_number;
    System.out.println(fist_number+"*"+second_number+"="+mul);
    }
//    除法
    public static void  divNumber(double fist_number,double second_number){
    double div=fist_number/second_number;
    System.out.println(fist_number+"/"+second_number+"="+div);
    }
}