一、体验一下方法

这里我们先来体验一下方法，先不了解其怎么使用。

 1. 不使用方法

public class Test1 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 30;
        int d = 40;
        int sum1 = a + b;
        int sum2 = b + c;
        int sum3 = c + d;
        System.out.println(sum1);
        System.out.println(sum2);
        System.out.println(sum3);
    }
}

结果为：

在我们没有学习方法时，当重复实现一个加法(功能)，总是要把其解题方法重新写一遍，这样麻烦了。

 2. 使用方法

public class Test2 {
    public static int add(int a, int b) {
        return a + b;
    }
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 30;
        int d = 40;
        int sum1 = add(a, b);
        int sum2 = add(b, c);
        int sum3 = add(c, d);
        System.out.println(sum1);
        System.out.println(sum2);
        System.out.println(sum3);
    }
}

我们可以看到其结果和不使用方法时一样：

那有人就会说，哎呀这使用方法明明比不使用的时候更加麻烦呀，这么认为是错误的，我们这里实现加法时，比较容易写，代码量少，当到后面时，一个解题方法会有十几二十行甚至更多，这时候不使用方法会显得很麻烦和凌乱。同时使用方法时可增加代码的可读性，是代码更加简洁。

二、方法的定义及调用

 1. 方法的定义

可以认为方法是一段可以重复利用的代码片段，是可以解决某一问题的。

注：方法必须定义在类体内，可以放在类体前，也可以放在类体最后或其他位置，不像 C 放在后面的话需要在开头声明，因为当执行到调用语句时，它就会在相应类体内寻找该方法。

[修饰符列表] 返回值类型 方法名(形式参数列表) {
        方法体;
}

注：
方法体由 Java 语句构成。
方法定义之后需要调用，不调用则不会执行。

1. 修饰符列表:
   目前统一写成 public static ，后面再去了解。
2. 返回值类型：
   返回值类型可以为 Java 中所有合法的数据类型，Java 中的数据类型包括基本数据类型和引用数据类型，所以可以使用的类型有： byte、short char、int、long、double、float、boolean、String…等等。
3. 有返回值：
   当有返回值时，就必须使用 "return 值";返回一个于返回值类型相对应的类型，否则会报错，如：返回值类型为 int , 我们就必须返回一个 int 类型，return 10; (int类型)
4. 无返回值：
   当不返回值时，不能空在哪里，需要使用关键字 void 表示无返回值，
   如果返回值类型是void，那么在方法体当中不能有“return 值;” 这样的语句。但是可以有“return;”语句。这个语句“return;”的作用就是用来终止当前方法的
5. 除了 void 外 剩下的都需要使用 "return 值"; 语句返回一个与返回值类型相对应的值。
6. 方法名：
   方法名应遵守驼峰式命名，见名知意，开头首单词字母小写，后面单词首字母大写。
7. 形式参数列表：
   形式参数列表中的每一个参数都是“局部变量”，方法结束之后内存释放。
   形参可以是 0~n 个，主要看实参传什么类型就用什么类型接收。
   使用：public static int add(int a, String str) {}，形参之间用逗号隔开。

 2. 方法的调用

调用方法：方法名(实数参数列表);

注意：
1. 实参的类型和形参的类型必须一一对应(注意自动转化类型)，同时个数也必须相同，可以是0~n个。并且实参是有数据的。例：

public class Test3 {
    public static void test(int a, String b) {
        System.out.println(str);
    }
    public static void main(String[] args) {
        int len = 10;
        String str = "abc";
        test(len, str);
    }
}

我们来看看这段代码能不能执行：

public class Test2 {
    public static int add(int x, int y) {
        return x + y;
    }
    public static void main(String[] args) {
        byte a = 10;
        byte b = 20;
        int ret = add(a, b);
        System.out.println(ret);
    }
}

这段代码并没有报错，因为 byte 会自动转化为 int 类型

2. 当有返回值时，可以用对应的类型进行接收返回值，如：“return 10;” 则可以用 “int ret = 方法名(实数参数类型);” 这样的语句进行接收。

public class Test3 {
    public static int add(int a, int b) {
        return a + b;
    }
    public static void main(String[] args) {
        int c = 10;
        int d = 20;
        int ret = add(c, d); //用ret接收add的返回值即a+b的值
        System.out.println(ret);
    }
}

3. 如果有返回值，无论返回值是什么类型，其返回值只有一个。

4. 在 Java 中，实参和形参是在两块不同的局部变量，即相当于我们的赋值，如"int a = 10; int b = a;" 即将 a 的值复制一份给 b 并不会改变 a 的值。即实参只是复制一份数据给形参，这种叫做传值调用。

例：

public class Test3 {
    public static void swap(int x, int y) {
        int tmp = x;
        x = y;
        y = tmp;
        System.out.println("x=" + x +" " + "y=" + y);
    }
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        swap(a, b);
        System.out.println("a="+a +" "+"b="+ b);
    }
}

其运行结果为：
交换 x、y的值并不会改变 a、b的值。

4. 因为实参和形参在不同的方法内，所以其局部变量的名字可以相同。

public class Test4 {
    public static int add(int a, int b){
        return a + b;
    }
    public static void main(String[] args) {
        int a = 5;
        int b = 10;
        int ret = add(a, b);
        System.out.println(ret);
    }
}

其结果为：
我们可以看到并没有报错。

5. 当调用方法时，此方法不在调用的类中，而在另一个类中，需要这样调用：类名.方法名(实参);

public class Test4 {
    public static void main(String[] args) {
        int a = 5;
        int b = 10;
        int ret = One.add(a, b);
        System.out.println(ret);
    }
}
class One {
    public static int add(int a, int b){
        return a + b;
    }
}

其结果为：

三、练习

学完方法我们则写一些练习加深对方法的理解。

 1. 写一个判断是否为素数的方法。

素数一般指质数，质数是指在大于1的自然数中，除了1和它本身以外不再有其他因数的自然数。

public class Test5 {
    public static boolean isPrimeNumber(int n) {
        for (int i = 2; i <= Math.sqrt(n); i++) {
            if (n % i == 0) {  //不是素数返回false
                return false;
            }
        }
        return true; //是素数返回true
    }
    public static void main(String[] args) {
        for (int i = 2; i <= 100; i++) {
            if (isPrimeNumber(i)) { //是素数则打印
                System.out.print(i + " ");
            }
        }
    }
}

Math.sqrt() 是求根号的意思。假如一个数N是合数，它有一个约数a,a×b=N 如果 a < b ，则 b 大于或等于根号N，a 小于或等于根号N。如果取a ==2开始用 n % a != 0，一直到 a 小于等于 n 的根号即说明 n 是素数。

其结果为：

 2. 写一个方法打印乘法表，可以为9 * 9也可以为10*10…

import java.util.Scanner;

public class Test6 {
    public static void mulTable(int n) {
        for (int i = 1; i <= n; i++) { //行
            for (int j = 1; j <= i; j++) { //列
                System.out.print(j + "*" + i + "=" + j*i + " ");
            }
            System.out.println();
        }
    }
    public static void main(String[] args) {
        Scanner num = new Scanner(System.in);
        int n = num.nextInt();
        mulTable(n);
    }
}

当 n == 9 时其结果为：
当 n == 10 时其结果为：

 3. 写一个方法判断是不是闰年

public class Test7 {
    public static boolean isLeapYear(int n) {
        if ((n % 4 == 0 && n % 100 !=0) || n % 400 == 0) {
            return true;
        }
        return false;
    }
    public static void main(String[] args) {
        for (int i = 1000; i <= 2000; i++) {
            if (isLeapYear(i)) {
                System.out.print(i + " ");
            }
        }
    }
}

其结果为：
当然后面还有这里显示不完。

好了，本章节方法的使用讲完了，因博主能力有限，如有发现不足和错误，请提出，谢谢各位大佬。