Java方法

一、方法的简介

方法(method)，就是一段具有特定功能的代码。可以通过调用名字在任意的位置上进行重复使用,从而达到代码简化的目的。

特点及优点：

1. java程序中最小的执行单元。
2. 提高了代码的重用性和可维护性。

二、 方法的定义

方法要定义在类体中，方法是类体中的一个成员。

语法：

[访问权限修饰词] [其他修饰词] 返回值类型 方法名(参数列表){
        //方法体
        [return]
}

特点：

1.[]里的内容表示可有可无，需要的时候就写上，不需要的时候该位置就可以不写。

2.方法名是标识符，使用小驼峰命名法。

3.方法之间是平级的，不可以方法嵌套方法。

三、方法的修饰词

3.1 访问权限修饰词

方法并不是在任何位置上都可以被调用，与权限修饰词有关。权限大，使用的地方就多，权限小，使用的地方就少。

权限修饰词	本类中	同包下	子类中	其他位置
public（公有的）	√	√	√	√
protected（被保护的）	√	√	√
默认的（就是什么也不写）	√	√
private（私有的）	√

3.2 其他修饰词

static：静态的方法，  调用的时候使用类名直接调用。也可以在本类中的其他方法中直接写方法名表示调用。

final：最终，最后。final修饰的方法在子类在不能被修改了。因为是最终的。

四、方法的返回值

4.1 返回值类型

方法在定义时，必须规定方法的返回值类型是什么。
方法的返回值类型位置可以书写两大类型：
          第一种类型：void，无类型，表示方法在执行完毕后，不需要返回任何数据。
          第二种类型：Java中除void外的的任一类型，包括程序员自定义的类型。那么在方法结束之前，                    就必须要有一个指定 类型的返回值，作为该方法的执行结果。         

4.2 return关键字

return关键字： 返回，归还的含义。

1.在方法中表示结束方法，因此return后不能有其他代码，无意义，执行不到。在任何方法中都可以使用这个关键字。

2.void类型的方法，return 可加可不加。

3.返回值类型是其他类型的方法，return关键字必须添加，并且return后必须要有一个返回值类型的变量或者表达式。表示方法执行完毕后，最终数据要返回给调用者。

注意：调用者是指调用该方法的所在处。

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

    }
    //定义一个void形式的方法m1
    public static void m1(){
        int a = 1;
        int b = 2;
        int c = a + b;
        return;//return关键字表示方法结束，可加可不加
    }
    //定义一个返回值类型为int的方法m2
    public static int m2(){
        int a = 1;
        int b = 2;
        int c = a + b;
       return c+1;
    }
    public static String m3(){
        int a = 1;
        int b = 2;
        int c = a + b;
        return c+"";
    }
}

 五、方法的参数列表

1. 参数列表具体指的是定义期间方法名后的参数的类型列表。
   类型非常重要，列表指的是从左到右的顺序。
   名字不重要。
2. 参数列表的语法：是0个以上的变量的声明语法，没有初始化操作。
3. 参数列表里的参数名，称为形式参数，简称形参。
4. 形式参数用于规定调用者在调用期间需要传入的数据的具体类型。
扩展知识点：
方法签名：方法名+参数的类型列表
比如：m1(int a,long b, String c)的方法签名：m1(int,long,String)
在同一个类体中，不能存在方法签名相同的方法。
5. 方法的重载：
同一个类中，方法名相同，参数类型列表不同（方法签名不同）。

案例：

public class _03MethodDemo {
    public static void main(String[] args) {
        
    }
    //案列1：
    public static void m1() {
        System.out.println("----m1方法----");
    }
    //案例2:   方法签名 m2(int)
    public static void m2(int a) {
        System.out.println("----m2方法----"+a);
    }
    public static void m3(int a) {
        System.out.println("----m3方法----"+a);
    }
   /** public static void m3(int a) {
        System.out.println("----m3方法----"+a);
    }*///和上面的m3(int)是重载关系
    public static void m3(int a,int b) {
        System.out.println("----m3方法----"+a);
    }
    }
}

六、方法的调用

无参数的方法调用：
调用语法：  方法名() void修饰的方法，一般都是该语法调用。
其他返回值类型的方法，一般都是如下形式：
        返回值类型  变量 = 方法名（）
案例：

public class _04MethodDemo {
    public static void main(String[] args) {
        //void形式的方法调用
        System.out.println("--开始前--");
        myMethod1();
        System.out.println("--后续代码--");
        //返回值是int类型的方法调用
        int s = myMethod2();
        System.out.println("s="+s);
    }
    public static void myMethod1() {
        int a = 10;
        int b = 20;
        int c = a + b;
        System.out.println(c);
    }
    //计算1~100的和
    public static int myMethod2() {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            sum += i;
        }
        return sum;
    }
}

--开始前--
30
--后续代码--
s=5050

有参数的方法调用：
     - 实际参数，简称实参。在调用时，传入到方法小括号里的是变量或者是具体值。
     - 实参的作用：就是用于给形参赋值（传值），这个过程称之为传参。
void形式的方法调用：
     - 方法名有形参，传入实参。
有具体返回值的方法调用
     -  返回值类型  变量 = 方法名(有形参传入实参)

案例：
 

public class _01MethodDemo {
    public static void main(String[] args) {
        //需求1:计算两个int类型的数据之和
        int m = 5;
        int n = 6;
        /* 调用sum(int,int)
            调用的时候m和n都是实际参数，要传入到方法的小括号里。
            m给形式参数a赋值，n给形式参数b赋值。
         */
        sum(m, n);//得到的结果是21
        //需求2:计算三个int类型中的随机整数中的最大值
        int x = (int) (Math.random() * 100);
        int y = (int) (Math.random() * 100);
        int z = (int) (Math.random() * 100);
        System.out.println("x=" + x + ", y=" + y + ", z=" + z);
        //调用getMath(int,int,int)方法，实际参数x，y，z传给方法的形参。
        int max = getMax(x, y, z);
        System.out.println("max = " + max);
    }

    /**
     * 用于计算两个int类型的数据的和
     * @param a  int类型的a
     * @param b  int类型的b
     */
    public static void sum(int a, int b) {
        a = 2 * a;
        b = b + 5;
        int c = a + b;
        System.out.println("c="+c);
    }
    public static int getMax(int a, int b,int c){
        int max = Integer.MIN_VALUE;
        if(a>b&&a>c){
            max = a;
        }
        else if(b>a&&b>c){
            max = b;
        }else{
            max = c;
        }
        return max;
    }
}

c=21
x=75, y=52, z=20
max = 75

七、方法的递归

就是在方法里调用自己。但是要给一个终止条件，否则可能会进入死循环。

public class _02RecursionDemo {
    public static void main(String[] args) {
        //计算20的阶乘
        long sum = 1;
        for (int i = 1; i <= 20; i++) {
            sum*=i;
        }
        System.out.println("sum = " + sum);
        //计算阶乘也可以用如下方法递归的方式。
        long result = f(20);
        System.out.println("result = " + result);
        //计算1~100的和
        int result1 = myNum(100);
        System.out.println("result1 = " + result1);
    }
    /**设定 x = f(n)      计算20的阶乘 f(20)
     *     f(20)=f(19)*20;
     *     ..........
     *     f(2)=f(1)*2;
     *     f(1)=1;
     *     总结：
     *     f(n)=f(n-1)*n;
     */

    /**
     * 计算n的阶乘。
     * @param n 要计算的数字。
     * @return 数字n的阶乘。
     */
    public static long f(int n) {
        //需要设置递归的终止操作，n=1时，不需要调用递归方法了。
        if (n == 1)
        {return 1;
        }
        return f(n-1)*n;
    }
    /**
     * 定义一个方法，返回1~n的和
     * 方法名：mySum(int a)
     */
    public static int myNum(int n) {
        if (n == 1){
            return 1;
        }
        return myNum(n-1)+n;
    }
}

sum = 2432902008176640000
result = 2432902008176640000
result1 = 5050