Java的方法

方法

• java方法是语句的集合，它们在一起执行一个功能
  1. 方法是解决一类问题步骤的有序组合
  2. 方法包含也类或对象中
  3. 方法在程序中被创建，在其他地方被引用
  4. 一个方法只完成一个功能，这样有利于我们以后的拓展
  5. 方法的命名需要遵守命名规范首字母小写，驼峰原则

方法的定义

• java的方法类似于其他语言的函数，是一般用来完成特定功能的代码片段，一般情况下，定义一个方法包含以下语法：
  1. 方法包含一个方法头和一个方法体
  2. 修饰符：修饰符是可选的，告诉编译器如何调用方法，定义该方法的访问类型。
  3. 返回值类型：方法可能会有返回值，return是返回值的数据类型，有些方法执行的操作，若没有返回值，则用关键字void。
  4. 方法名：是方法的实际名称，要注意命名规范
  5. 参数类型：参数类型像一个占位符，当方法被调用时传递值给参数，参数是可选的，方法可以不包含任何参数
     • 参数有形式参数和实际参数
       • 形式参数：在方法中被调用时用于接收外界输入数据
       • 实际参数：调用方法时实际传给方法的数据

​ 6.方法体：方法包含具体的语句，定义该方法的功能

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

public class Demo01 {
    //main方法,main方法为最底层的方法，我们要保持简洁干净，尽量把公共的模块提取到外面，通过方法的形式来调用。
    public static void main(String[] args) {

        //实际参数，实际调用传递给他的参数
        double sun = add(1, 2);


        System.out.println(sun);
       //test();

    }

    //加法运算方法
    //int a,int b 这个为形式参数，用于定义作用
    public static double add(int a,int b){
        return a+b;
    }

方法的调用

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

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

     int max=max(30,40);
     

​ 2.如果方法返回值为void，方法调用一定是一条语句,例如：

         ```java

System out println()；
```

public class Demo02 {
    public static void main(String[] args) {
        double max = num(1.0,2.0);//调用num方法
        System.out.println(max);


    }
    //比大小的方法
    public static double num(double a, double b) {
        double resalt=0;

        if (a > b) {
            resalt=a;
        } else if (a == b) {
            System.out.println("相等");

        } else {
            resalt=b;
        }return resalt;

    }

方法的重载

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

2. 实际理论：方法名称相同时，编译器会根据调用方法的参数个数、参数类型去逐个匹配，以选择对应的方法，如果匹配失败，则编译器会报错

3. 方法重载的规则

   • 方法名称必须相同

   • 参数列表必须不同（个数不同，类型不同。排列顺序不同等）

   • 方法的返回值类型可以相同也可以不相同

   • 仅仅返回值类型不同不足以成为方法的重载

    //比大小的方法
    public static double num(double a, double b) {
        double resalt=0;

        if (a > b) {
            resalt=a;
        } else if (a == b) {
            System.out.println("相等");

        } else {
            resalt=b;
        }return resalt;

    }
    //比大小的方法 方法名相同，参数列表不同，做到方法的重载
    public static int num(int a, int b) {
        int resalt=0;

        if (a > b) {
            resalt=a;
        } else if (a == b) {
            System.out.println("相等");

        } else {
            resalt=b;
        }return resalt;

    }
}

命令行传参

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

  例如

  package com.YouHaoXin.method;
  
  public class Demo05 {
      public static void main(String[] args) {
          //args length:表示数组长度
          //命令行传参
          for (int i = 0; i < args.length; i++) {
              System.out.println("args["+i+"]:"+args[i]);
              
          }
      }
  }
  

1. 写一个如上面的程序
2. 通过Dos命令行编译一个class文件
3. 在包的文件夹，输出java文件，并输出参数
   

可变参数

1. 从JDK 1.5 开始，java支持使用可变参数
2. 在方法声明中，在指定参数类型加一个省略号（…）
3. 一个方法中只能指定一个可变参数，他必须是方法的最后一个参数，任何普通参数必须在它之前声明

package com.YouHaoXin.method;
//示例1
public class Demo06 {
    //可变参数
    public static void main(String[] args) {
        Demo06 test = new Demo06();
        test.test(2,3,4,10);

    }
    public void test(int...a){

        System.out.println(a[3]);//数组的个数需从0开始算，a[3]相当于数组的第4个数，输出为：10。
    }



}

package com.YouHaoXin.method;
//示例2
public class Demo07 {
    public static void main(String[] args) {
        //调用可变参数

        printMax(1,2,50,45,80);
        printMax(new double[]{1,5,8,6,4});//数组与可变参数的使用

    }

    public static void printMax(double...num1){
        if (num1.length==0){
            System.out.println("NO");//num1的长度为0是，输出NO
            return;
        }
        double result=num1[0];
        for (int i =1; i < num1.length; i++) {
            if (num1[i]>result){
                result=num1[i];
            }
        }
        System.out.println("yes"+result);//输出参数中最大的数
    }


}

递归

1. 递归就是A方法调用A方法，就是自己调用自己
2. 利用递归可以用简单的程序来解决一些复杂的问题，它通常把一个大型复杂的问题层层转化为一个与原问题相似规模的问题来求解，可以大大减少程序的代码量。
3. 递归结构包括两部分:
   • 递归头：什么时候不调用方法，如果没有头，将会陷入死循环
   • 递归体：什么时候需要用自身方法。

package com.YouHaoXin.method;

public class Demo08 {
    public static void main(String[] args) {
        //递归
        /*
        递归的运行
        1.边界条件，到这个条件将结束递归
        2.前阶段：当程序没达到边界条件是，程序会自己调用自身
        3.返回阶段：赋予每个阶段出来的值
         */
        //递归只适用于基数比较小的运算，尽量避免使用递归

        System.out.println(f(5));//120

    }

    public static  int f(int n){
        if (n==1){
            return 1;//递归头，到这个阶段结束递归

        }else{return n*f(n-1);}//递归体，在这里调用自身方法
    }
}