方法的概述
什么是方法？
方法是具有特定功能的代码块。
简单的理解就是：把一段完整的代码，看成一个整体，并给这段代码起个名字，以后在用的时候，使用这个名字就相当于执行了这一段代码。
例如：洗衣机洗衣服就是一系列动作看成了一个整体。 打开洗衣机，放入衣服，放入洗衣液，注水，洗涤，甩干，排水。一提到洗衣机洗衣服，我们就会想到上述过程。
方法必须先创建才可以使用，创建只需要进行一次创建，使用可以多次。方法的创建过程称为方法的定义。
和变量类似，变量必须先定义再使用，方法也是先定义再使用。
方法创建后并不是直接运行的，需要手动使用才执行，使用方法称为方法调用。
方法的定义
方法隶属于类，因此方法要定义在类中，且方法不能定义在别的方法内。---类后面会详细讲。
方法定义的格式
public static 返回值类型 方法名(参数列表){
方法体
}public、static在讲类和对象的时候会详细讲，此处先固定这么写。
方法名的命名规范和变量名的命名规范相同。
返回值、参数列表 下面专门讲解。
方法定义示例
public static void sum() {
Scanner scanner = new Scanner(System.in);
System.out.print("请输入一个整数，将为您计算1到这个数的和：");
int num = scanner.nextInt();
int sum = 0;
for(int i = 1; i <= num; i++) {
sum += i;
}
System.out.println("1到" + num + "的和是：" + sum);
}上述案例就是一个方法，这个方法的功能是计算从1到num的和，num是用户输入的数据。
由此可见：方法是一个具有特定功能的代码段。我们定义的方法sum的功能是求从1到num的和。
方法的调用
方法定义好之后，就可以在想要使用的时候调用方法，达到使用方法的目的。
方法调用的格式
方法名(参数);
方法调用的示例
public class LessonMethod {
public static void main(String[] args) {
sum();//调用sum方法
}
public static void sum() {
Scanner scanner = new Scanner(System.in);
System.out.print("请输入一个整数，将为您计算1到这个数的和：");
int num = scanner.nextInt();
int sum = 0;
for(int i = 1; i <= num; i++) {
sum += i;
}
System.out.println("1到" + num + "的和是：" + sum);
}
}上述代码就是方法的调用，main方法是程序的入口，在main方法中我们调用了sum方法。
方法可以简化程序的代码，让代码得以复用。
方法的调用过程
public static void main(String[] args) {
System.out.println("sum方法执行之前");
sum();
System.out.println("sum方法执行之后");
sum();
System.out.println("sum方法再次执行之后");
}
public static void sum() {
Scanner scanner = new Scanner(System.in);
System.out.print("请输入一个整数，将为您计算1到这个数的和：");
int num = scanner.nextInt();
int sum = 0;
for(int i = 1; i <= num; i++) {
sum += i;
}
System.out.println("1到" + num + "的和是：" + sum);
}
程序的入口是main方法，因此程序一旦运行会自动执行main方法。
首先会打印一句话 “sum方法执行之前”
然后执行 sum 方法，此时程序会跳转到sum方法中，将sum方法中的代码全部执行完毕之后，回到main方法中。此时相当于 sum() 执行完毕。
然后打印一句话 “sum方法执行之后”
紧接着执行sum方法，此时程序会跳转到sum方法中，将sum方法中的代码全部执行完毕之后，回到main方法中。此时相当于 sum() 执行完毕。
然后打印一句话 “sum方法再次执行之后”
最后main函数结束执行，程序结束。
方法的组成
修饰符：public、static
方法名称：命名方式遵循变量的命名方式
参数：方法执行所需要的外界数据，多个参数用 "," 分隔。
返回值：方法执行完之后，给外界的数据。
方法体：方法中封装的要执行的代码
例如：
public static 饭 买饭(钱, 饭的名字){
买饭的具体过程
}再例如：
public static 钱 ATM取钱(银行卡, 取款金额){
取款的具体过程
}方法的分类
方法按有没有参数，有没有返回值可以分为以下4类：
-
无参数无返回值方法
-
无参数有返回值方法
-
有参数无返回值方法
-
有参数有返回值方法
无参数无返回值方法
如果一个方法没有参数，也没有返回值，这样的方法就是无参数无返回值方法。
如果方法没有返回值，我们在定义方法的时候，将返回值类型指定为 void。
无参数无返回值方法的定义格式
public static void 方法名(){
方法体
}无参数无返回值方法示例
public static void sum() {
Scanner scanner = new Scanner(System.in);
System.out.print("请输入一个整数，将为您计算1到这个数的和：");
int num = scanner.nextInt();
int sum = 0;
for(int i = 1; i <= num; i++) {
sum += i;
}
System.out.println("1到" + num + "的和是：" + sum);
}无参数无返回值方法的调用格式
方法名();无参数无返回值方法的调用示例
public static void main(String[] args) {
sum();//调用sum方法
}
public static void sum() {
Scanner scanner = new Scanner(System.in);
System.out.print("请输入一个整数，将为您计算1到这个数的和：");
int num = scanner.nextInt();
int sum = 0;
for(int i = 1; i <= num; i++) {
sum += i;
}
System.out.println("1到" + num + "的和是：" + sum);
}无参数有返回值方法
如果一个方法没有参数，但是有返回值，这样的方法就是无参数有返回值方法。
如果方法有返回值，方法体里要通过return语句将结果返回给外界。
定义方法时，返回值类型必须 和 方法体中return 返回的值的类型一致。
无参数有返回值方法的定义格式
public static 返回值类型 方法名(){
方法体
return 返回值;
}无参数有返回值方法示例
public static double PI(){
return 3.1415926;
}无参数有返回值方法的调用格式
数据类型 变量名 = 方法名();//如果外界要用返回值，拿一个变量接收返回值或
方法名();//如果外界不需要使用返回值，可以不接收无参数有返回值方法的调用示例
public static void main(String[] args) {
double num = PI();//方法调用
double area = num * 10 * 10;
System.out.println(area);
}
public static double PI() {
return 3.1415926;
}有参数无返回值方法
有参数无返回值方法的定义格式
public static void 方法名(参数类型 参数名1, 参数类型 参数名2, ...){
方法体
}有参数无返回值方法示例
//打印一个整数
public static void printNum(int num) {
System.out.println(num);
}
//打印一个数组
public static void printArray(int[] array) {
for(int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
System.out.println();
}有参数无返回值方法的调用格式
方法名(参数值1,参数值2,...);有参数无返回值方法的调用示例
public static void main(String[] args) {
int a = 100;
printNum(a);//方法调用
int[] arr = {10, 7, 21, 13, 45, 17};
printArray(arr);//方法调用
}
// 打印一个整数
public static void printNum(int num) {
System.out.println(num);
}
// 打印一个数组
public static void printArray(int[] array) {
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
System.out.println();
}有参数有返回值方法
有参数有返回值方法的定义格式
public static 返回值类型 方法名(参数类型 参数1, 参数类型 参数2, ...){
方法体
return 返回值;
}有参数有返回值方法示例
//计算圆的面积
public static double area(double r) {
return 3.1415926 * r * r;
}
//求三个数的和
public static int sum(int a, int b, int c) {
return a + b + c;
}有参数有返回值方法的调用格式
数据类型 变量名 = 方法名(参数1,参数2,...);//如果外界要用返回值，拿一个变量接收返回值或
方法名(参数1,参数2,...);//如果外界不需要使用返回值，可以不接收有参数有返回值方法的调用示例
public static void main(String[] args) {
double a = area(10);//方法调用
System.out.println(a);
int sum = sum(10,20,30);//方法调用。变量名可以和方法名重名。
System.out.println(sum);
}
// 计算圆的面积
public static double area(double r) {
return 3.1415926 * r * r;
}
// 求三个数的和
public static int sum(int a, int b, int c) {
return a + b + c;
}方法分类总结
-
如果方法有返回值，在方法体内必须要有return语句。并且 return后面的返回值 必须和 返回值类型一致。
-
如果方法有参数，参数可以是1个也可以是多个，如果是多个参数，参数与参数之间用“,”隔开。
-
定义方法时的参数叫形参（形式参数），调用方法时的参数叫实参（实际参数）。
-
定义方法时：参数的类型和参数名都不能少。
-
调用方法时：不需要参数类型
-
参数可以是常量、变量、表达式、或者另外一个方法的返回值。
-
方法不能嵌套定义。
形参、实参
形参
形参：全名叫形式参数，出现在方法定义中，形参只是用来占位的，用来代表未来调用方法时传递过来的数据。
实参
实参：全名叫实际参数，出现在方法调用中，实参是方法执行时真正要用到的数据。在方法调用时，会把实参传递给形参，在执行方法过程中用于参与运算。
在方法调用时，要保证实参的数据类型和形参的数据类型一致。
实参到形参只是单向的值拷贝过程。如果实参是个数据，会把数据拷贝给形参；如果实参是个地址，会把地址拷贝给形参。----实参和形参是2个变量，只是值相等，实参的值拷贝给了形参。
public static void main(String[] args) {
int num = 100;
changeValue(num);
System.out.println(num)
int[] arr = { 10, 20, 30 };
changeArrayValue(arr);
System.out.println(arr[0]);
}
public static void changeValue(int num) {
num = 200;
}
// 打印一个数组
public static void changeArrayValue(int[] array) {
arry[0]=200;
}
如果参数是引用类型，可以在方法内修改内容。
如果参数是基本数据类型，无法在方法内修改内容。
方法重载
在同一个类中，如果多个方法具有相同的方法名，但参数类型或者参数个数不相同（或都不相同），这就是方法的重载。-----方法重载和返回值没有关系，不看返回值，只看方法名以及参数。
public static void main(String[] args) {
System.out.println(sum(10,20));
System.out.println(sum(3.5, 2.0));
System.out.println(sum(1,2,3));
}
public static double sum(double x, double y) {
return x +y;
}
public static int sum(int x, int y) {
return x +y;
}
public static int sum(int x, int y, int z) {
return x + y + z;
}不定参数方法
不定参数方法：指的是方法的参数是可变的，不确定的，只有调用的时候，才知道参数的具体个数。
public static void main(String[] args) {
int num1 = calculate(1,2,3);
System.out.println(num1);
int num2 = calculate(100,20,50,30,200,150);
System.out.println(num2);
}
//不定参数方法
public static int calculate(int... nums) {
int sum = 0;
for(int i = 0; i < nums.length; i++) {
sum += nums[i];
}
return sum;
}在不定参数的方法里，形参本质上是一个数组，数组里存放的是各个实参，实参按顺序存入数组。取的时候按数组名[下标]取出元素使用即可。
public static void main(String[] args) {
int num1 = calculate(true, 1, 2, 3, 4, 5);
System.out.println(num1);
int num2 = calculate(false, 2, 5, 20);
System.out.println(num2);
}
//不定参数方法---既有固定参数，又有不定参数时，不定参数要放到最后。
public static int calculate(boolean doAdd,int... nums) {
int result = doAdd ? 0 : 1;//如果是求和，初值设置为0，否则初值设置为1（求乘积）
if(doAdd) {
for(int i = 0; i < nums.length; i++) {
result += nums[i];
}
}else {
for(int i = 0; i < nums.length; i++) {
result *= nums[i];
}
}
return result;
}不定参数有两个规定：
第一，方法的参数列表中最多只有一个不定长度的参数；
第二，就是不定长度的参数的位置必须是最后一个参数。
对于第一个规定，是因为如果有多于一个不定长度的参数，当真正调用这个方法的时候，JVM将不知道前面的不定长度参数有多长, 下一个参数是从哪里开始.
对于第二个参数也是一样，编译器不知道不定长度参数的长度，无法确定从哪里开始下一个参数。
不定参数方法，也可以重载。
方法练习
打印2个数的最大值
-
需求：设计一个方法，用于打印2个数中的最大数，并调用方法测试结果是否正确。
-
代码：
public static void main(String[] args) { System.out.print("请输入2个整数："); Scanner scanner = new Scanner(System.in); int x = scanner.nextInt(); int y = scanner.nextInt(); printMaxNum(x, y); } //需求：设计一个方法，用于打印2个数中的最大数，并调用方法测试结果是否正确。 //分析： //1.打印2个数的最大数。----无需返回值、有2个参数、方法名见名知意。 //2.方法体： 计算出最大值，并打印最大值。 //3.在main方法中调用方法，测试方法的正误 public static void printMaxNum(int a, int b) { int max = a > b ? a : b; System.out.println(max); }
求2个数的最大值
-
需求：设计一个方法，返回2个数的最大值，并调用方法测试结果是否正确。
-
代码：
public static void main(String[] args) { System.out.print("请输入2个整数："); Scanner scanner = new Scanner(System.in); int x = scanner.nextInt(); int y = scanner.nextInt(); int max = maxOfTwoNum(x, y); System.out.println(max); } //需求：设计一个方法，返回2个数的最大值，并调用方法测试结果是否正确。 //分析： //1. 返回2个数的最大值----- 有返回值， 有2个参数，返回值类型和参数类型相同 ， 方法名见名知意 //2. 方法体： 计算2个数的最大值，返回最大值。 //3. 在main方法中调用方法，测试方法的正误 public static int maxOfTwoNum(int num1, int num2) { int max = num1 > num2 ? num1 : num2; return max; }在设计方法的时候，一定要弄清楚2件事：1.有没有参数，几个参数，每个参数什么数据类型；2.有没有返回值，返回值是什么类型。
一般来说：如果某个方法只是为了完成某件事情，这样的方法通常没有返回值。如果某个方法是为了做计算，这样的方法通常会有返回值。
求从min到max的和
-
需求：设计一个方法，有两个参数min和max，计算从min累加到max的和。
-
代码：
public static void main(String[] args) { int a = sum(5, 8); int b = sum(1, 100); System.out.println(a); System.out.println(b); } //需求：设计一个方法，有两个参数min和max，计算从min累加到max的和。 //分析： //有返回值，有2个参数。 //方法体：计算从min到max的和 public static int sum(int min, int max) { int sum = 0; for(int i = min; i <= max; i++) { sum += i; } return sum; }
限制用户输入内容
-
需求：设计一个方法，获取用户输入的数据。要求用户必须输入0~9之间的数，如果不是，让用户重新输入，直到用户输入的内容合法。
-
代码：
public static void main(String[] args) { int num = getInputNum(); System.out.println(num); } //需求：设计一个方法，获取用户输入的数据。 //要求用户必须输入0~9之间的数，如果不是，让用户重新输入，直到用户输入的内容合法。 //分析： //有返回值，没有参数 //方法体：处理用户输入过程 public static int getInputNum() { Scanner scanner = new Scanner(System.in); int num = 0; do { System.out.print("请输入0~9之间的数："); num = scanner.nextInt(); if(num >= 0 && num <= 9) { break; }else { System.out.println("输入的内容超出范围！"); } }while(true); return num; }
计算数字位数
-
需求：设计一个方法计算数字是几位数。
-
代码：
public static void main(String[] args) { System.out.println(bitsOfNum(9527)); System.out.println(bitsOfNum(10086)); } //需求：设计一个方法计算数字是几位数。 //分析： //有返回值，有1个参数 //方法体：计算数字的位数 public static int bitsOfNum(int num) { int bits = 0; while(num != 0) { num /= 10; bits++; } return bits; }
数7游戏
-
需求：设计一个方法，实现数n游戏，n是一个0~9之间的数。
数n游戏：遍历100以内的数字，如果数字是n的倍数或者数字包含n，输出过，否则输出数据本身。
例如：如果数字是7的倍数或者数字包含7，输出过，否则输出数据本身。
-
代码：
public static void main(String[] args) { countGame(7); countGame(4); countGame(9); } //需求：设计一个方法，实现数n游戏，并调用方法测试结果是否正确。 //数n游戏：遍历100以内的数字，如果数字是n的倍数或者数字包含n，输出过，否则输出数据本身。 //分析： //1. 通过分析得知，无需返回值，需要一个参数（数几）。 //2. 方法体：遍历100以内的数，根据判断结果输出内容 //3. 在main方法中调用方法，测试方法的正误 public static void countGame(int num) { for(int i = 1; i < 100; i++) { if(i % num == 0 || (i % 10 == num || i / 10 == num)) { System.out.print("过 "); }else { System.out.print(i + " "); } } System.out.println(); }
查看数组中是否包含某个数据（练习）
-
需求：设计一个方法，查找数组中是否包含指定的数据。
-
代码：
public static void main(String[] args) { int[] array = {10, 20, 18, 32, 7}; System.out.println(isArrayContainsNum(array, 20)); System.out.println(isArrayContainsNum(array, 15)); } //需求：设计一个方法，查找数组中是否包含指定的数据。 //分析： //有返回值（boolean类型） 有2个参数 public static boolean isArrayContainsNum(int[] arr, int num) { boolean isContain = false; for(int i = 0; i < arr.length; i++) { if(arr[i] == num) { isContain = true; break; } } return isContain; }
判断两个数组是否相等（练习）
-
需求：设计一个方法，判断两个数组是否相等
-
代码：
public static void main(String[] args) { int[] array = {10, 20, 18, 32, 7}; int[] array2 = {10, 20, 18, 32, 7}; System.out.println(isArrayEqual(array, array2)); } //需求：设计一个方法，判断两个数组是否相等 //有返回值（boolean类型），有2个参数 public static boolean isArrayEqual(int[] arr1, int[] arr2) { boolean isEqual = true; int length1 = arr1.length; int length2 = arr2.length; if(length1 == length2) { for(int i = 0; i < length1; i++) { if(arr1[i] != arr2[i]) { isEqual = false; break; } } }else { isEqual = false; } return isEqual; }
数组拷贝
-
需求：设计一个方法，实现数组拷贝
-
代码：
public static void main(String[] args) { int[] array = {10, 20, 18, 32, 7}; int[] array2 = new int[10]; arrayCopy(array, array2); printArray(array2); } //需求：设计一个方法，实现数组拷贝 //有返回值（boolean类型） 2个参数 public static boolean arrayCopy(int[] source, int[] destination) { int sourceLength = source.length; int destinationLength = destination.length; if(destinationLength < sourceLength) { return false; }else { for(int i = 0; i < sourceLength; i++) { destination[i] = source[i]; } return true; } } // 打印一个数组 public static void printArray(int[] array) { for (int i = 0; i < array.length; i++) { System.out.print(array[i] + " "); } System.out.println(); }
数组翻转
-
需求：设计一个方法，实现数组翻转
-
代码：
public static void main(String[] args) { int[] array = { 10, 20, 18, 32, 7 }; printArray(array); invertArray(array); printArray(array); } // 需求：设计一个方法，实现数组翻转 // 没有返回值，有参数 public static void invertArray(int[] arr) { for (int i = 0; i < arr.length / 2; i++) { int temp = arr[i]; arr[i] = arr[arr.length - 1 - i]; arr[arr.length - 1 - i] = temp; } } // 打印一个数组 public static void printArray(int[] array) { for (int i = 0; i < array.length; i++) { System.out.print(array[i] + " "); } System.out.println(); }
冒泡排序
-
需求：设计一个方法，实现数组排序（冒泡）。
-
代码：
public static void main(String[] args) { int[] array = {18, 25, 11, 36, 9, 20, 3}; bubbleSort(array); printArray(array); } //需求：设计一个方法，实现往数组数组排序（冒泡）。 //分析： //无返回值，有一个参数 public static void bubbleSort(int[] arr) { for(int i = 0; i < arr.length - 1; i++) { for(int j = 0; j < arr.length - 1 - i; j++) { if(arr[j] > arr[j+1]) { int temp = arr[j]; arr[j] = arr[j+1]; arr[j+1] = temp; } } } } // 打印一个数组 public static void printArray(int[] array) { for (int i = 0; i < array.length; i++) { System.out.print(array[i] + " "); } System.out.println(); }
总结
方法是具有特定功能的代码块。方法可以大大简化程序的代码，提高代码的复用度。
方法分为：无参数无返回值方法，无参数有返回值方法，有参数无返回值方法，有参数有返回值方法。
方法必须先定义，再使用。
方法调用时，实参的值会拷贝给形参，实参和形参是2个变量。
在Java中，方法可以重载。
不定参数的方法，不定参数一定要放到末尾，而且一个方法最多只能有1个不定参数。
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
