方法的概述
什么是方法?
方法是具有特定功能的代码块。
简单的理解就是:把一段完整的代码,看成一个整体,并给这段代码起个名字,以后在用的时候,使用这个名字就相当于执行了这一段代码。
例如:洗衣机洗衣服就是一系列动作看成了一个整体。 打开洗衣机,放入衣服,放入洗衣液,注水,洗涤,甩干,排水。一提到洗衣机洗衣服,我们就会想到上述过程。
方法必须先创建才可以使用,创建只需要进行一次,使用可以多次。方法的创建过程称为方法的定义。
和变量类似,变量必须先定义再使用,方法也是先定义再使用。
方法创建后并不是直接运行的,需要手动使用才执行,使用方法称为方法调用。
方法的定义
方法隶属于类,因此方法要定义在类中,且方法不能定义在别的方法内。(书写位置:类中其他方法外)
方法定义的格式
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 钱 ATM取钱(银行卡, 取款金额){
取款的具体过程
}
方法按有没有参数,有没有返回值可以分为以下4类:
1. 无参数无返回值方法
2. 无参数有返回值方法
3. 有参数无返回值方法
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);
}
无参数有返回值方法
如果一个方法没有参数,但是有返回值,这样的方法就是无参数有返回值方法。
如果方法有返回值,方法体里要通过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);//方法调用
arr[0] = 55;
arr[2] = 40;
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;
}
方法分类总结
1. 如果方法有返回值,在方法体内必须要有return语句。并且 return后面的返回值 必须和 返回值类型一致。
2. 如果方法有参数,参数可以是1个也可以是多个,如果是多个参数,参数与参数之间用逗号隔开。
3. 定义方法时的参数叫形参(形式参数),调用方法时的参数叫实参(实际参数)。
4. 定义方法时:参数的类型和参数名都不能少。
5. 调用方法时:不需要参数类型
6. 参数可以是常量、变量、表达式、或者另外一个方法的返回值。
7. 方法不能嵌套定义。
8. 没有返回值的方法(即返回值类型为void),方法体中也可以出现return,return后面不返回任何内容,可用于结束方法的执行。
形参、实参
形参
形参:全名叫形式参数,出现在方法定义中,形参只是用来占位的,用来代表未来调用时传递过来的数据。
实参
实参:全名叫实际参数,出现在方法调用中,实参是方法执行时真正要用到的数据。在方法调用时,会把实参传递给形参,在执行方法过程中用于参与运算。
在方法调用时,要保证实参的数据类型和形参的数据类型一致。
实参到形参只是单向的值拷贝过程。如果实参是个数据,会把数据拷贝给形参;如果实参是个地址,会把地址拷贝给形参。----实参和形参是2个变量,只是值相等,实参的值拷贝给了形参。
public static void main(String[] args) {
int num = 100;
changeValue(num);
System.out.println(num);
int[] arr = { 10, 20, 30 };
changeArrayValue(arr);
printArray(arr);
}
public static void changeValue(int num) {
num = 200;
}
public static void changeArrayValue(int[] arr) {
arr[0] = 200;
}
// 打印一个数组
public static void printArray(int[] array) {
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
System.out.println();
}
如果参数是引用类型,可以在方法内修改内容。
如果参数是基本数据类型,无法在方法内修改内容。
方法重载(overload)
在同一个类中,如果多个方法具有相同的方法名,但参数类型或者参数个数不相同(或都不相同),这就是方法的重载。-----方法重载和返回值没有关系,不看返回值,只看方法名以及参数。
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个数的最大值
1. 需求:设计一个方法,返回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.有没有返回值,返回值是什么类型。
一般来说:如果某个方法只是为了完成某件事情,这样的方法通常没有返回值。如果某个方法是为了做计算,这样的方法通常会有返回值。
限制用户输入内容
1. 需求:设计一个方法,获取用户输入的数据。要求用户必须输入0~9之间的数,如果不是,让用户重新输入,直到用户输入的内容合法。
2. 代码:
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;
}
冒泡排序
1. 需求:设计一个方法,实现数组排序(冒泡)。
2. 代码:
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个不定参数。