方法概述
什么是方法
方法 (method) 就是一段具有独立功能的代码块，不调用就不执行
方法 : 一个代码片段，如果定义了方法，就相当于给他起了个名字，就可以反复调用
方法就是一段用来完成特定功能的代码片段，类似于其他语言的函数
语句块 : 用{ }括起来的变量，只能执行一次，除非给这个语句块起个名字
方法的出现，可以提高代码的复用性
(图1)
方法使用前提须知
方法必须先创建才可以使用，该过程称为方法定义
方法创建后并不是直接运行的，需要手动使用后才执行，该过程称为方法调用
方法的定义和调用
方法声明格式
1
2
3
[修饰符1 修饰符2 ...] 返回值类型 方法名(形式参数列表) {
Java语句; ... ... ...
}
方法的调用方式
1
2
3
4
5
6
7
8
9
10
11
12
public class TestMethod {
public static void loveU ( int num ){ //形式参数
System . out . println ( "I love Ul" );
System . out . println ( "520!" );
System . out . printIn ( "我爱你！" );
System . out . println ( "521!" + "=====" + num + "年" );
}
public static void main ( String [] args ){
LoveU ( 10000 ); //实际参数
}
}
注意
实参的数目、数据类型和次序必须和所调用的方法声明的形式参数列表匹配。
代码有错误时 alt + enter
return 关键字代表的是 “结束整个方法”
Java中进行方法调用中传递参数时，遵循值传递的原侧（传递的都是数据的副本）
案例
定义一个方法外理迟到问题：
① 迟到 1-10分钟，警告。
② 迟到 11-20分钟，罚款 100元。
③ 迟到 21分钟- 30分钟，罚款 200元。
④ 迟到 30分钟以上，扣除半日工资。
⑤ 迟到 1 小时以上，按照旷工计算，扣除3日工资。
(3) 输出罚款金额
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public static int late ( int lateMinute , double monthSalary ){
int faKuan = 0 ; //罚款
if ( lateMinute <= 10 ){
System . out . println ( "警告" );
} else if ( lateMinute <= 20 ){
faKuan = 100 ;
} else if ( lateMinute <= 30 ){
faKuan = 200 ;
} else if ( lateMinute <= 60 ){
//monthSalary/(21.75 * 2) = monthSalary / 21.75 /2
faKuan = ( int ) ( monthSalary / ( 21 . 75 * 2 )); //21.75 月平均工作日
} else {
//monthSalary/(21.75 * 3) = monthSalary / 21.75 / 3
faKuan = ( int )( monthSalary / ( 21 . 75 * 3 ));
}
System . out . println ( "罚款" + faKuan );
return faKuan ;
}
public static void main ( String [] args ) {
late ( 15 , 5000 );
}
十步天才思维法
(图2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
（方法，对象，线程之类的核心概念使用十步思维法）
十步思维法(方法)
1.学习方法的目的
在 Java 中，方法可以实现对代码片段的反复调用，提高效率，方法使代码片段模块化，有利于团队分工开发
2.方法是什么?方法用在哪里?
对一个语句块进行定义，从而使他有自己的名字，这就叫方法，也可看成是具有独立功能的代码块
在一些需要重复执行的代码片段，使用方法
3.如何使用方法
定义：
[修饰符1，修饰符2……] 返回值类型 方法名 (形式参数列表){
Java语句
}
调用：
方法名.(实际参数列表)
4.深度思维(模拟设计者思维过程)
我的理解是没有方法的时候，一些特定功能的代码片段，不用的话需要删除，用的话在 main 函数里站的位置太多，多个具有特定功能的代码片段在一块还容易搞混，而有了方法，不同功能的代码片段有了名字，用的时候调用，不用的时候不调用即可，不用再删除了，其次各个功能代码片段清晰分明
5.广度思维(类比其他概念)
变量：变量名指向内存的某个地址空间，通过调用变量名来调用那片空间
方法名：方法名指向某个代码片段，通过调用方法名来调用那些代码片段
6.广度思维(联系已知，底层原理分析)
我感觉方法的底层原理应该是，在调用方法时，跳到方法所在的代码片段进行执行，执行完后再跳回到调用方法的那条语句所在位置，继续执行下一行代码
7.广度思维(类比生活中的例子)
在学校制定迟到惩罚事项，抓到迟到的人，对他试试惩罚事项
上班迟到罚款规则，抓到迟到人，根据迟到的时间罚相应的款
8.可视化辅助或分享
没找到相关动画视频
方法调用过程
方法 没有被调用 的时候，都在 方法区 中的字节码文件 (.class) 中存储
方法 被调用 的时候，需要进入到 栈内存 中运行
方法练习-奇偶数判断
需求：设计一个方法 method, 方法中定义一个变量（数值随意）
判断这个变量是奇数还是偶数，并在 main 方法中调用 method。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/*
1.定义method方法
2.方法中定义变量，使用if语句判断是奇数还是偶数
3.main方法中调用nethod
*/
public static void main ( String [] args ){
//3.main方法中调用nethod
method （） ;
}
//1.定义nethod方法
public static void method (){
//2.方法中定义变量，使用f语句判断是奇数还是偶数
int num = 10 ;
if ( num % 2 == 0 ){
System . out . printIn ( "偶数" );
} else {
System . out . println ( "奇数" );
}
}
带参数方法的定义和调用
1
2
3
4
5
6
7
8
9
10
11
public static void main ( String [] args ){
method （ 10 ） ;
}
public static void method ( int num ){
if ( num % 2 == 0 ){
System . out . printIn ( "偶数" );
} else {
System . out . println ( "奇数" );
}
}
形参和实参
形参：全称形式参数，是指方法 定义 中的参数 (假如我们有一个方法, 不给他传变量, 那么他只能是一个形式上的参数)
实参：全称实际参数，方法 调用 中的参数
带参数方法的练习
需求：设计一个方法 (print) 用于打印 n 到 m 之间所有的奇数
1
2
3
4
5
6
7
8
9
10
11
//1:定义方法，名称为print
//2：为方法添加两个int类型的形参，准备接收调用者传递过来的实参
public static void print ( int n , int m ){ //10,20
//3:方法中设计for循环，循环从n开始，到m结束
for ( int i = n ; i <= m ; i ++ ){
//4:循环中加入if判断，是奇数，则打印
if ( i % 2 == 1 ){
System . out . println ( i );
}
}
}
带返回值方法的定义和调用
1
2
3
4
5
6
7
8
9
public static void main ( String [] args ){
int num = add ( 10 , 20 );
System . out . println ( num );
}
public static int add ( int a , int b ){
int c = a + b ;
return c ;
}
带返回值方法练习
需求：设计一个方法可以获取两个数的较大值，数据来自于参数
1
2
3
4
5
6
7
8
9
10
11
public static void main ( String [] args ){
System . out . println ( getMax ( 10 , 20 )); //输出调用
}
public static int getMax ( int a , int b ){
if ( a > b ){
return a ;
} else {
return b ;
}
}
方法的通用格式
1
2
3
4
public static 返回值类型 方法名(参数) {
方法体;
return 数据;
}
方法的注意事项
方法不能嵌套定义
(图3)
方法的返回值类型为 void，表示该方法没有返回值，没有返回值的方法可以省略 return 语句不写 如果要编写 return，后面不能跟具体的数据。
(图4)
return; 表示直接结束这个方法, 也就是说方法执行过程中, 执行到了 return; , 就会把自己从栈内存中弹出去, 方法结束执行
return语句下面，不能编写代码，因为永远执行不到，属于无效的代码
(图5)
return; 的应用场景
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public static void main ( String [] args ){
print ( 20 , 10 );
}
public static void print ( int n , int m ){
if ( m < n ){
System . out . println ( "您传入的数据有误，请检查" );
//return; 可以用于结束方法，也就是将方法从栈内存中弹出去，该过程称之为方法的弹栈
return ;
}
System . out . println ( n + "到" + m + "之间的奇数为：" ) ；
for ( int i = n ; i <= m ; i ++ ){
if ( i % 2 == 1 ){
System . out . println ( i );
}
}
}
方法重载 (overload)
方法的重载是指一个类中可以定义多个 方法名相同 ，但 参数不同 的方法，调用时，会根据不同的参数自动匹配对应的方法
重载的方法，实际是完全不同的方法，只是名称相同而已
方法的重载意义：当定义一个相加的方法名字为 add( )，再定义一个具有相同功能的方法，如果起名字为 jia(), 两个方法含义相同，名字来回切换，会把人搞晕
构成方法重载的条件：
不同的含义：形参类型，形参顺序，形参个数不同
只有返回值不同不构成方法的重载，如：int a(String str){} 与 void a(String str){} 不构成方法重载
只有形参的名称不同，不构成方法的重载
形参顺序不同是指：
1
2
3
4
5
6
7
public static int add ( double a , int b ){
return ( int )( a + b );
}
public static int add ( int a , double b ){
return ( int )( a + b );
}
注意 ：识别方法之间是否是重载关系，只看方法名和参数，跟返回值无关。
方法重载练习
需求：使用方法重载的思想，设计比较两个整数是否相同的方法，兼容全整数类型 (byte、short、int、long)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public static void main ( String [] args ){
int a = 10 ;
int b = 20 ;
System . out . println ( compare ( a , b ));
}
public static boolean compare ( byte a , byte b ){
return a == b ;
}
public static boolean compare ( short a , short b ){
return a == b ;
}
public static boolean compare ( int a , int b ){
return a == b ;
}
public static boolean compare ( long a , long b ){
return a == b ;
}
方法的参数传递
基本数据类型
基本数据类型: 基本数据类型作为参数, 方法在调用时, 传递的是该变量记录的具体 “数值”
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class ArgsDemo01 {
public static void main ( String [] args ){
int number = 100 ;
sout ( "调用change方法前：" + number );
change ( number ); //change(100)
sout ( "调用change方法后：" + number );
public static void change ( int number ){ //int number = 100
number = 200 ; //number = 200, 修改的只是当前方法中的number, 并没有影响main方法中nunmber的值
}
}
调用change方法前 ： 100
调用change方法后 ： 100
引用数据类型
引用数据类型: 引用数据类型作为参数, 方法在调用时, 传递的是内存 “地址”
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class ArgsDemo02 {
public static void main ( string [] args ){
int [] arr = { 10 , 20 , 30 };
sout ( "调用change方法前：" + arr [ 1 ] );
change ( arr );
sout ( "调用change方法后：" + arr [ 1 ] );
public static void change ( int [] arr ){
arr [ 1 ] = 200 ;
}
)
调用change方法前 ： 20
调用change方法后 ： 200
案例: 数组遍历
需求：设计一个方法用于数组遍历，要求遍历的结果是在一行上的。例如：[11, 22, 33, 44, 55]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public static void main ( String [] args )
int [] arr = { 11 , 22 , 33 , 44 , 55 };
printArray ( arr );
}
public static void printArray ( int [] arr ){
System . out . print ( "[" );
for ( int i = 0 ; i < arr . length ; i ++ ){
if ( i == arr . length - 1 ){
//如果满足条件，说明是最后一个元素，最后一个元素，特殊处理
System . out . println ( arr [ i ] + "]" ); //最后一个元素打印完, 换行
} else {
//遍历打印的时候，数据不换行
System . out . print ( arr [ i ] + "," );
}
}
}
案例: 获取数组最大值
需求：设计一个方法用于获取数组中元素的最大值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public static void main ( String [] args ){
//1.定义一个数组，用静态初始化完成数组元素初始化
int [] arr = { 11 , 55 , 22 , 44 , 33 };
//3.调用获取最大值方法，用变量接收返回结果
int pax = getMax ( arr );
}
public static int getMax ( int [] arr ){
int max = arr [ 0 ] ;
for ( int i = 1 ; i < arr . length ; i ++ ){
if ( max < arr [ i ] ){
max = arr [ i ] ;
}
}
return max ;
}
案例: 获取数组最大值和最小值
需求：设计一个方法，该方法能够同时获取数组的最大值和最小值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public static void main ( String [] args ){
int [] arr = { 11 , 55 , 33 , 22 , 44 };
int [] maxAndMin = getMaxArdMin ( arr );
System . out . println ( maxAndMin [ 0 ] );
System . out . println ( maxAndMin [ 1 ] );
}
public static int getMaxAndMin ( int [] arr ){
int max = arr [ 0 ] ;
for ( int i = 1 ; i < arr . length ; i ++ ){
if ( max < arr [ i ] ){
max = arr [ i ] ;
}
}
int min = arr [ 0 ] ;
for ( int i = 1 ; i < arr . length ; i ++ ){
if ( min > arr [ i ] ){
min = arr [ i ] ;
}
}
//注意return语句只能返回一个结果, 如果要返回多个结果, 只能用数组装起来
int [] maxAndMin = { 10 , 20 };
return maxAndMin ;
}
