文章目录

笔记内容
学习目标
1. 回顾--方法的定义和调用
2. 定义方法的格式详解
3. 定义方法的两个明确
4. 调用方法的流程图解
5. 定义方法练习
6. 定义方法的注意事项
7. 调用方法的三种形式
8. 方法重载
9. 方法重载练习
10. 总结

笔记内容

方法的参数和返回值
方法的重载

学习目标

掌握方法定义的参数和返回值含义
了解方法的调用过程
了解方法的三种调用形式
掌握方法定义的注意事项
掌握方法重载的概念
能够判断出方法的重置

1. 回顾–方法的定义和调用

前面的课程中，使用过嵌套循环输出矩形，控制台打印出矩形就可以了，因此将方法定义为void，没有返回值。在主方法main中直接被调用。

public class Method_Demo1 {
    
    
public static void main(String[] args) {
    
    
print();
}
private static void print() {
    
    
for (int i = 0; i < 5; i++) {
    
    
for (int j = 0; j < 8; j++) {
    
    
System.out.print("*");
}
System.out.println();
}
}
}

print方法被main方法调用后直接输出结果，而main方法并不需要print方法的执行结果，所以被定义为void。

2. 定义方法的格式详解

修饰符 返回值类型 方法名(参数列表){
    
    
//代码省略...
return 结果;
}

修饰符： public static 固定写法
返回值类型：表示方法运行的结果的数据类型，方法执行后将结果返回到调用者
参数列表：方法在运算过程中的未知数据，调用者调用方法时传递
return：将方法执行后的结果带给调用者，方法执行到 return ，整体方法运行结束

注意！

return 结果; 这里的"结果"在开发中，我们正确的叫法成为方法的返回值

3. 定义方法的两个明确

**需求：**定义方法实现两个整数的求和计算。
**明确返回值类型：**方法计算的是整数的求和，结果也必然是个整数，返回值类型定义为int类型。
**明确参数列表：**计算哪两个整数的和，并不清楚，但可以确定是整数，参数列表可以定义两个int类型的变量，由调用者调用方法时传递

public class Method_Demo2 {
    
    
public static void main(String[] args) {
    
    
// 调用方法getSum，传递两个整数，这里传递的实际数据又称为实际参数
// 并接收方法计算后的结果，返回值
int sum = getSum(5, 6);
System.out.println(sum);
}
/*
定义计算两个整数和的方法
返回值类型，计算结果是int
参数：不确定数据求和，定义int参数.参数又称为形式参数
*/
public static int getSum(int a, int b) {
    
    
return a + b;
}
}

程序执行，主方法main调用getSum方法，传递了实际数据5和6，两个变量a和b接收到的就是实际参数，并将计算后的结果返回，主方法main中的变量sum接收的就是方法的返回值。

4. 调用方法的流程图解

5. 定义方法练习

5.1 练习一

比较两个整数是否相同

**分析：**定义方法实现功能，需要有两个明确，即返回值和参数列表。
**明确返回值：**比较整数，比较的结果只有两种可能，相同或不同，因此结果是布尔类型，比较的结果相同为true。
**明确参数列表：**比较的两个整数不确定，所以默认定义两个int类型的参数。

public class Method_Demo3 {
    
    
public static void main(String[] args) {
    
    
//调用方法compare，传递两个整数
//并接收方法计算后的结果，布尔值
boolean bool = compare(3, 8);
System.out.println(bool);
}
/*
定义比较两个整数是否相同的方法
返回值类型，比较的结果布尔类型
参数：不确定参与比较的两个整数
*/
public static boolean compare(int a, int b) {
    
    
if (a == b) {
    
    
return true;
} else {
    
    
return false;
}
}
}

5.2 练习二

计算1+2+3…+100的和

**分析：**定义方法实现功能，需要有两个明确，即返回值和参数。
**明确返回值：**1~100的求和，计算后必然还是整数，返回值类型是int
**明确参数：**需求中已知到计算的数据，没有未知的数据，不定义参数

public class Method_Demo4 {
    
    
public static void main(String[] args) {
    
    
//调用方法getSum
//并接收方法计算后的结果，整数
int sum = getSum();
System.out.println(sum);
}
/*
定义计算1~100的求和方法
返回值类型，计算结果整数int
参数：没有不确定数据
*/
public static int getSum() {
    
    
//定义变量保存求和
int sum = 0;
//从1开始循环，到100结束
for (int i = 1; i <= 100; i++) {
    
    
sum = sum + i;
}
return sum;
}
}

5.3 练习三

实现不定次数打印

分析：定义方法实现功能，需要有两个明确，即返回值和参数。
**明确返回值：**方法中打印出HelloWorld即可，没有计算结果，返回值类型 void 。
**明确参数：**打印几次不清楚，参数定义一个整型参数

public class Method_Demo5 {
    
    
public static void main(String[] args) {
    
    
//调用方法printHelloWorld，传递整数
printHelloWorld(9);
}
/* 定义
打印HelloWorld方法
返回值类型，计算没有结果 void
参数：不确定打印几次
*/
public static void printHelloWorld(int n) {
    
    
for (int i = 0; i < n; i++) {
    
    
System.out.println("HelloWorld");
}
}
}

6. 定义方法的注意事项

定义位置，类中方法外面。
返回值类型，必须要和 return 语句返回的类型相同，否则编译失败。

// 返回值类型要求是int
public static int getSum() {
    
    
return 5;// 正确，int类型
return 1.2;// 错误，类型不匹配
return true;// 错误，类型不匹配
}

不能在return后面写代码，return意味着方法结束，所有后面的代码永远不会执行，属于无效代码。

public static int getSum(int a,int b) {
    
    
return a + b;
System.out.println("Hello");// 错误，return已经结束，这里不会执行，无效代码
}

7. 调用方法的三种形式

**直接调用：**直接写方法名调用

public static void main(String[] args) {
    
    
print();
}
public static void print() {
    
    
System.out.println("方法被调用");
}

**赋值调用：**调用方法，在方法前面定义变量，接收方法返回值

public static void main(String[] args) {
    
    
int sum = getSum(5,6);
System.out.println(sum);
}
public static int getSum(int a,int b) {
    
    
return a + b;
}

输出语句调用：
在输出语句中调用方法，System.out.println(方法名())。

public static void main(String[] args) {
    
    
System.out.println(getSum(5,6));
}
public static int getSum(int a,int b) {
    
    
return a + b;
}

不能用输出语句调用 void 类型的方法。因为方法执行后没有结果，也就打印不出任何内容。

public static void main(String[] args) {
    
    
System.out.println(printHello());// 错误，不能输出语句调用void类型方法
}
public static void printHello() {
    
    
System.out.println("Hello");
}

8. 方法重载

**方法重载：**指在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同即可，与修饰符和返
回值类型无关。
参数列表：个数不同，数据类型不同，顺序不同。
重载方法调用：JVM通过方法的参数列表，调用不同的方法。

9. 方法重载练习

9.1 练习一

比较两个数据是否相等。参数类型分别为两个byte类型，两个short类型，两个int类型，两个long类型，并在main方法中进行测试。

public class Method_Demo6 {
    
    
public static void main(String[] args) {
    
    
//定义不同数据类型的变量
byte a = 10;
byte b = 20;
short c = 10;
short d = 20;
int e = 10;
int f = 10;
long g = 10;
long h = 20;
// 调用
System.out.println(compare(a, b));
System.out.println(compare(c, d));
System.out.println(compare(e, f));
System.out.println(compare(g, h));
}
// 两个byte类型的
public static boolean compare(byte a, byte b) {
    
    
System.out.println("byte");
return a == b;
}
// 两个short类型的
public static boolean compare(short a, short b) {
    
    
System.out.println("short");
return a == b;
}
// 两个int类型的
public static boolean compare(int a, int b) {
    
    
System.out.println("int");
return a == b;
}

// 两个long类型的
public static boolean compare(long a, long b) {
    
    
System.out.println("long");
return a == b;
}
}

9.2 练习二

判断哪些方法是重载关系。

public static void open(){
    
    }
public static void open(int a){
    
    }
static void open(int a,int b){
    
    }
public static void open(double a,int b){
    
    }
public static void open(int a,double b){
    
    }
public void open(int i,double d){
    
    }
public static void OPEN(){
    
    }
public static void open(int i,int j){
    
    }

9.3 练习三

模拟输出语句中的println方法效果，传递什么类型的数据就输出什么类型的数据，只允许定义一个方法名println。

public class Method_Demo7 {
    
    
public static void println(byte a) {
    
    
System.out.println(a);
}
public static void println(short a) {
    
    
System.out.println(a);
}
public static void println(int a) {
    
    
System.out.println(a);
}
public static void println(long a) {
    
    
System.out.println(a);
}
public static void println(float a) {
    
    
System.out.println(a);
}
public static void println(double a) {
    
    
System.out.println(a);
}
public static void println(char a) {
    
    
System.out.println(a);
}
public static void println(boolean a) {
    
    
System.out.println(a);
}
public static void println(String a) {
    
    
System.out.println(a);
}
}

10. 总结

方法的三种调用格式。

单独调用：方法名称(参数);
打印调用：System.out.println(方法名称(参数));
赋值调用：数据类型变量名称 = 方法名称(参数);

**注意：**此前学习的方法，返回值类型固定写为void，这种方法只能够单独调用，不能进行打印调用或者赋值调用。

注意事项：

对于有返回值的方法，可以使用单独调用、打印调用或者赋值调用。
但是对于无返回值的方法，只能使用单独调用，不能使用打印调用或者赋值调用。
方法应该定义在类当中，但是不能在方法当中再定义方法。不能嵌套。
方法定义的前后顺序无所谓。
方法定义之后不会执行，如果希望执行，一定要调用：单独调用、打印调用、赋值调用。
如果方法有返回值，那么必须写上“return 返回值;”，不能没有。
return后面的返回值数据，必须和方法的返回值类型，对应起来。
对于一个void没有返回值的方法，不能写return后面的返回值，只能写return自己。
对于void方法当中最后一行的return可以省略不写。
一个方法当中可以有多个return语句，但是必须保证同时只有一个会被执行到，两个return不能连写。

**方法的重载（Overload）：**多个方法的名称一样，但是参数列表不一样。

**好处：**只需要记住唯一一个方法名称，就可以实现类似的多个功能。

方法重载与下列因素相关：

参数个数不同
参数类型不同
参数的多类型顺序不同

方法重载与下列因素无关：

与参数的名称无关
与方法的返回值类型无关

第1章 2.3 方法