[toc]
一、方法的语法格式
在Java中，声明一个方法的具体语法格式如下：
/*
* 方法的语法格式:
* 修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2,........){
* 执行语句;
* .......
* return 返回值;
* }
*
* */
对于上面的语法格式中具体说明如下：
- 修饰符：方法的修饰符比较多，有对访问权限进行限定的，有静态修饰符static，还有最终修饰符 final等
- 返回值类型：用于限定方法返回值的数据类型
- 参数类型：用于限定调用方法时传入参数的数据类型
- 参数名：是一个变量，用于接收调用方法时传入的数据
- return关键字：用于结束方法以及返回方法指定类型的值
- 返回值：被return语句返回的值，该值会返回给调用者
注意
- 方法中的“参数类型 参数名1，参数类型 参数名2”被称作参数列表，它用于描述方法在被调用时需要接收的参数，如果方法不需要接收任何参数，则参数列表为空，即()内不写任何内容
- 方法的返回值必须为方法声明的返回值类型，如果方法中没有返回值，返回值类型要声明void，此时，方法中return语句可以省略。
接下来通过一个简单的案例来演示方法的定义与使用，如下图所示。
package com.bjsxt.demo;
/**
* @author Rainbow
*/
public class MethodDemo2 {
public static void main(String[] args) {
//调用getArea方法
int area = getArea(3, 5);
System.out.println("The ara is\t" + area);
}
//下面定义了一个求矩形面积的方法，接受两个参数，其中x为高，y为宽
public static int getArea(int x, int y) {
int temp = x * y;
//将变量temp的值返回
return temp;
}
}
运行结果如下所示：
The ara is 15
从上述代码可以看出，运行期间，参数x和y相当于在内存中定义的两个变量。当调用getArea()方法时，传入的参数3和5分别赋值给变量x和y，并将x*y的结果通过return语句返回，整个方法的调用过程结束。变量x和y被释放
二、自定义方法
-
无返回值无参数方法
// 1、无参数、无返回值方法 public static void printRect() { for (int i = 0; i <3 ; i++) { for (int j = 0; j <3 ; j++) { System.out.print("*"); } System.out.println(); } } -
有返回值无参数方法，如键盘录入得到一个整数
// 2、无参数、有返回值方法 public static int getNumber() { Scanner scanner = new Scanner(System.in); int number = scanner.nextInt(); return number; } -
无返回值有参数方法
// 3、有参数、无返回值方法 public static void printRect2(int m,int n){ for (int i = 0; i < m; i++) { for (int j = 0; j < n; j++) { System.out.print("*"); } System.out.println(); } } -
有返回值有参数
// 4、有参数有返回值 public static double getAvg(double a, double b,double c){ double result = (a+b+c)/3; return result; }
三、方法的重载
我们假设要在程序中实现一个对数字求和的方法，由于参与求和数字的个数和类型都不确定，因此要针对不同的情况去设计不同的方法。接下来通过一个案例来实现对两个整数相加，对三个整数相加以及对两个小数相加的功能，具体如下所示：
package com.bjsxt.demo;
public class MethodDemo02 {
public static void main(String[] args) {
// 下面是针对求和方法的调用
int sum1 = add01(1, 2);
int sum2 = add02(1, 2, 3);
double sum3 = add03(1.2, 2.3);
// 下面的代码是打印求和的结果
System.out.println("sum1=" + sum1);
System.out.println("sum2=" + sum2);
System.out.println("sum3=" + sum3);
}
// 下面的方法实现了两个整数相加
public static int add01(int x, int y) {
return x + y;
}
// 下面的方法实现了三个整数相加
public static int add02(int x, int y, int z) {
return x + y + z;
}
// 下面的方法实现了两个小数相加
public static double add03(double x, double y) {
return x + y;
}
}
运行结果如下所示：
sum1=3 sum2=6 sum3=3.5
所出现的问题：程序需要针对每一种求和的情况都定义一个方法，如果每个方法的名称都不相同，在调用时很难分清哪种情况该调用哪个方法。
所解决问题的方法（方法的重载）：Java允许在一个类中定义多个名称相同的方法，但是参数的类型或个数必须不同跟返回值的类型不相关，这就是方法的重载。
举例：
public static int add(int x,int y) {逻辑} //两个整数加法
public static int add(int x,int y,int z) {逻辑} //三个整数加法
public static int add(double x,double y) {逻辑} //两个小数加法
接下来通过方法重载的方式进行修改，如下所示：
package com.bjsxt.demo;
public class MethodDemo03 {
public static void main(String[] args) {
// 下面是针对求和方法的调用
int sum1 = add(1, 2);
int sum2 = add(1, 2, 3);
double sum3 = add(1.2, 2.3);
// 下面的代码是打印求和的结果
System.out.println("sum1=" + sum1);
System.out.println("sum2=" + sum2);
System.out.println("sum3=" + sum3);
}
// 下面的方法实现了两个整数相加
public static int add(int x, int y) {
return x + y;
}
// 下面的方法实现了三个整数相加
public static int add(int x, int y, int z) {
return x + y + z;
}
// 下面的方法实现了两个小数相加
public static double add(double x, double y) {
return x + y;
}
}
MethodDemo02.java的运行结果和MethodDemo03.java一样，如下图所示：
sum1=3 sum2=6 sum3=3.5
上述代码中定义了三个同名的add()方法，它们的参数个数或类型不同，从而形成了方法的重载。
在main方法中调用add()方法时，通过传入不同的参数便可以确定调用哪个重载的方法，如add(1,2)调用的是两个整数求和的方法。指的注意的是，方法的重载与返回值类型无关，它只有两个条件：一是方法名相同，二是参数个数或参数类型不相同
3.1、重载的注意事项
-
重载方法参数必须不同：
参数个数不同，如method(int x)与method(int x,int y)不同 参数类型不同，如method(int x)与method(double x)不同 参数顺序不同，如method(int x,double y)与method(double x,int y)不同
-
重载只与方法名与参数类型相关与返回值无关
如void method(int x)与int method(int y)不是方法重载，不能同时存在
-
重载与具体的变量标识符无关
如method(int x)与method(int y)不是方法重载，不能同时存在
四、参数传递(形参与实参）
参数传递，可以理解当我们要调用一个方法时，我们会把指定的数值，传递给方法中的参数，这样方法中的参数就拥有了这个指定的值，可以使用该值，在方法中运算了。这种传递方式，我们称为参数传递。
在这里，定义方法时，参数列表中的变量，我们==称为形式参数==
调用方法时，传入给方法的数值，我们==称为实际参数==
我们看下面的两段代码，来明确下参数传递的过程：
package com.bjsxt.demo;
/**
* @Author Rainbow
*/
public class ArgumentsDemo01 {
public static void main(String[] args) {
int a = 5;
int b = 10;
//调用方法时，传入的数值称为实际参数
change(a, b);
System.out.println("a = " + a);
System.out.println("b = " + b);
}
/**
* 方法中指定的多个参数称为形式参数
*
* @param a 形式参数
* @param b 形式参数
*/
public static void change(int a, int b) {
a = 200;
b = 500;
}
}
程序的运行结果如下：
a = 5 b = 10
再看另一段代码：
package com.bjsxt.demo;
/**
* @Author Rainbow
*/
public class ArgumentsDemo02 {
public static void main(String[] args) {
int[] arr = {1, 2, 3};
//调用方法时，传入的数值称为实际参数
change(arr);
for (int i = 0; i < arr.length; i++) {
System.out.println("arr[i] = " + arr[i]);
}
}
/**
* 方法中指定的多个参数称为形式参数
*
* @param arr 多个参数(数组)
*/
public static void change(int[] arr) {
for (int i = 0; i < arr.length; i++) {
arr[i] *= 2;
}
}
}
程序的运行结果如下：
arr[i] = 2 arr[i] = 4 arr[i] = 6
4.1、值传递&&引用传递
首先了解一下jvm的内部如何保存数据：
- jvm中每个线程都对应一个运行时内存区-----栈。栈中存放线程自己用到的所有变量。
- jvm规定栈和堆分开。栈保存基本数据类型和对象引用。而对象保存在堆里。
- 对象引用中保存的值是堆中对象的地址。
调用方法时，实参赋值形参：
值传递：(形式参数类型是基本数据类型)：方法调用时，实际参数把它的值传递给对应的形式参数，形式参数只是用实际参数的值初始化自己的存储单元内容，是两个不同的存储单元，所以方法执行中形式参数值的改变不影响实际参数的值。
引用传递：(形式参数类型是引用数据类型参数)：也称为传地址。方法调用时，实际参数是对象(或数组)，这时实际参数与形式参数指向同一个地址，在方法执行中，对形式参数的操作实际上就是对实际参数的操作，这个结果在方法结束后被保留了下来，所以方法执行中形式参数的改变将会影响实际参数。
package com.bjsxt.demo;
import java.util.Arrays;
/**
* @author Rainbow
*/
public class ArrayDemo4 {
public static void main(String[] args) {
// 值传递
int a = 100;
test(a);
System.out.println("a = " + a);
System.out.println("-------------------");
// 引用传递
int[] arr = {1, 3, 5};
System.out.println(Arrays.toString(arr));
testArr(arr);
System.out.println(Arrays.toString(arr));
System.out.println("--------------------");
// String类型是引用类型，但是比较特殊，仍然是值传递
String str = "我是一个字符串";
System.out.println("str = " + str);
testStr(str);
System.out.println("str = " + str);
}
public static void testStr(String str) {
str = "上海尚学堂";
}
public static void testArr(int[] arr) {
arr[0] = 100;
arr[1] = 300;
}
public static void test(int a) {
a = 200;
}
}
运行结果如下：
a = 100
[1, 3, 5]
[100，300，5]
str = 我是一个字符串 str = 我是一个字符串
4.2、就近原则
错误演示：
在程序中，代码遵循就近原则，而我们又要遵循见名知意的约定就会出现以下尴尬情况，自己赋值给自己
package com.bjsxt.demo;
/**
* @author Rainbow
*/
public class Student {
private int age;
public void setAge(int age) {
age = age;
}
public int getAge() {
return age;
}
public static void main(String[] args) {
Student s = new Student();
s.setAge(18);
System.out.println(s.getAge());
}
}
图解：
正确演示：（this关键字）
为了避免这种情况的发生，Java语言提供了 this 关键字来区分类的变量（成员变量）和传入参数变量（局部变量）的区别。
this 表示当前正在运行的对象。
package com.bjsxt.demo;
/**
* @author Rainbow
*/
public class Student {
private int age;
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return this.age;
}
public static void main(String[] args) {
Student s = new Student();
s.setAge(18);
System.out.println(s.getAge());
}
}
图解：
寄语：
当你的才华还撑不起你的野心的时候，你就应该静下心来学习；当你的能力还驾驭不了你的目标时，就应该沉下心来，历练；梦想，不是浮躁，而是沉淀和积累， 只有拼出来的美丽，没有等出来的辉煌，机会永远是留给最渴望的那个人，学会与内心深处的你对话，问问自己，想要怎样的人生，静心学习，耐心沉淀，送给自己，共勉。
如果，此文章对你有所帮助，请帮忙点个赞呗！爱你，么么哒！！！
