在我们的日常生活中，方法可以理解为要做某件事情，
而采取的解决办法。
如：小明同学在路边准备坐车来学校学习。这就面临
着一件事情（坐车到学校这件事情）需要解决，解决办法
呢？可采用坐公交车或坐出租车的方式来学校，那么，这
种解决某件事情的办法，我们就称为方法。
在java中，方法就是用来完成解决某件事情或实现某
个功能的办法。
方法实现的过程中，会包含很多条语句用于完成某些
有意义的功能——通常是处理文本，控制输入或计算数值。
我们可以通过在程序代码中引用方法名称和所需的参
数，实现在该程序中执行（或称调用）该方法。方法，一
般都有一个返回值，用来作为事情的处理结果。
1 /*
2 方法的定义格式
3 修饰符 返回值类型 方法的名字 (参数列表...){
4 方法的功能主体
5 循环,判断,变量,比较,运算
6 return ;
7 }
8
9 修饰符: 固定写法 public static
10 返回值类型: 方法在运算后,结果的数据类型
11 方法名: 自定义名字,满足标识符规范, 方法名字首字母小写,后面每个单词首字母大写
12 参数列表: 方法的运算过程中,是否有未知的数据, 如果有未知的数据,定义在参数列表上 (定义变量)
13 return: 方法的返回, 将计算的结果返回. 结束方法
14 */
15 public class MethodDemo{
16
17 public static void main(String[] args){
18 //调用方法, 方法执行起来
19 // 在方法main中,调用方法 getArea
20
21 int area = getArea(5,6);
22 System.out.println("面积是: "+area);
23
24 }
25 /*
26 要求: 计算一个长方形的面积
27 定义方法解决这个要求
28 分析方法定义过程:
29 1. 明确方法计算后的结果的数据类型 int 定义格式对应的就是返回值类型
30 2. 方法计算过程中,有没有未知的数据, 宽和长, 未知数据的数据类型 int
31 未知数的变量,定义在方法的小括号内
32 */
33 public static int getArea(int w, int h){
34 //实现方法的功能主体
35 //int area = w * h;
36 return w * h;
37 }
38 }
1 package com.it.demo03_method;
2
3 /*
4 案例: 演示方法的定义格式.
5
6 方法简介:
7 概述:
8 就是把一些具有独立功能的代码封装起来, 使其成为一个具有特殊功能的代码集, 这个代码集就叫: 方法.
9 目的:
10 提高代码的复用性. //我们把重复做事儿抽取成方法, 以后需要用到该逻辑的时候, 不需要重新编写代码了, 直接调用方法即可.
11 格式:
12 修饰符 返回值的数据类型 方法名(数据类型 参数名1, 数据类型 参数名2) {
13 //方法体
14 return 具体的返回值;
15 }
16 格式详解:
17 修饰符: 目前先理解为就是 public static, 面向对象详解.
18 返回值的数据类型: 指的是方法调用完毕后, 返回给我们一个什么类型的值.
19 方法名: 遵循"小驼峰命名法", 而且要符合命名规则和规范, 是帮我们调用指定方法的.
20 (数据类型 参数名1): 形式参数, 形容调用方法的时候, 需要传入什么类型的值, 注意: 形参没有具体指.
21 方法体: 具体的逻辑代码.
22 return 具体的返回值: 方法指定完毕后, 要返回的具体的结果.
23 注意事项:
24 1. 方法与方法之间是平级关系, 不能嵌套定义.
25 2. 方法只有被调用, 才会执行.
26 3. 定义方法的时候, 参数列表中的参数叫: 形式参数(简称: 形参), 形容调用方法需要传入什么类型的值.
27 4. 调用方法的时候, 参数列表中传入的具体的值叫: 实际参数(实参), 指的是具体参与操作的数据.
28 5. 如果方法没有明确的返回值, 则返回值的数据类型必须写成 void
29 6. 如果方法没有明确的返回值, 则return语句可以省略不写.
30 7. 方法的功能越单一越好.
31 学习"方法"这个技术点的小技巧:
32 定义方法的三个明确:
33 1. 明确方法名.
34 2. 明确参数列表.
35 3. 明确返回值的数据类型.
36
37 调用方法时的三个步骤:
38 1. 写方法名, 调用谁就写谁, 注意大小写, 不要写错了.
39 2. 传参. 方法要什么类型的数据, 我们就传入什么类型的值.
40 3. 接收返回值. 方法返回什么类型的数据, 我们就用什么类型的变量来接收.
41 */
42 public class Demo01 {
43 //main方法是程序的主入口, 所有的代码都是从这里开始执行的.
44 public static void main(String[] args) {
45 //调用printHello()方法
46 printHello();
47 }
48
49 //需求: 定义printHello()方法, 用来打印"Hello World!"字符串.
50 /*
51 定义方法的三个明确:
52 1. 明确方法名. printHello()
53 2. 明确参数列表. 空参
54 3. 明确返回值的数据类型. 无具体返回值, 即: void类型
55 */
56 public static void printHello() {
57 //方法体
58 System.out.println("Hello World! 1");
59 System.out.println("Hello World! 2");
60 System.out.println("Hello World! 3");
61 System.out.println("Hello World! 4");
62 }
63 }
1 /*
2 方法的定义练习
3 */
4 import java.util.Scanner;
5 public class MethodDemo_1{
6 public static void main(String[] args){
7 //printRect();
8 //int number = getNumber();
9 //System.out.println(getNumber());
10 //printRect2(3,5);
11 double avg = getAvg(2,2,3);
12 System.out.println(avg);
13 }
14
15 /*
16 定义有返回值有参数方法，如求三个数的平均值
17 明确方法计算后的数据类型, 返回值类型 double
18 明确方法未知数, 三个未知的整数
19 */
20 public static double getAvg(double a, double b,double c){
21 return (a+b+c)/3;
22 }
23
24 /*
25 定义无返回值有参数方法，如打印指定M行，每行N个*号的矩形
26 明确方法计算后结果,控制台输出图形,没有返回值的
27 方法中有没有未知数,图形行数,和列数,是未知的, 数据类型整数int
28 */
29 public static void printRect2(int m,int n){
30 for(int i = 0 ; i < m ; i++){
31 for(int j = 0 ; j < n ; j++){
32 System.out.print("*");
33 }
34 System.out.println();
35 }
36 }
37
38 /*
39 定义有返回值无参数方法，如键盘录入得到一个整数
40 明确方法计算后结果的数据类型 int
41 明确有没有未知数,没
42 */
43 public static int getNumber(){
44 Scanner sc = new Scanner(System.in);
45 //int number = sc.nextInt();
46 return sc.nextInt();
47 }
48
49 /*
50 定义无返回值无参数方法，如打印3行，每行3个*号的矩形
51 为什么没有返回值:
52 打印矩形 ,输出效果,不需要将结果返回
53 明确未知数: 不需要未知数
54 */
55 public static void printRect(){
56 for(int i = 0 ; i < 3 ; i++){
57 for(int j = 0 ; j < 3 ;j++){
58 System.out.print("*");
59 }
60 System.out.println();
61 }
62 }
63 }
1 /*
2 方法定义和使用的注意事项
3 1. 方法不能定义在另一个方法的里面
4 2. 写错方法名字
5 3. 写错了参数列表
6 4. 方法返回值是void,方法中可以省略return 不写
7 return 下面不能有代码
8 5. 方法返回值类型,和return 后面数据类型必须匹配
9 6. 方法重复定义问题
10 7. 调用方法的时候,返回值是void, 不能写在输出语句中
11 */
12 public class MethodDemo_2{
13 public static void main(String[] args){
14 int i = print();
15 System.out.println( print() );
16 }
17 public static int print(){
18
19 return 1;
20 }
21
22 }
1 /*
2 方法,调用中的参数传递问题
3 1. 方法参数是基本数据类型
4 2. 方法参数是引用类型
5 传递的是内存地址!!!
6 */
7 public class MethodDemo_3{
8 public static void main(String[] args){
9 /*int a = 1;
10 int b = 2;
11 change(a,b);
12 System.out.println(a); //1
13 System.out.println(b); // 2
14 */
15 int[] arr = {1,2,3,4};
16 System.out.println(arr[2]); // 3
17 change(arr);
18 System.out.println(arr[2]); // 100
19 }
20
21 public static void change(int[] arr){
22 arr[2] = 100;
23 }
24
25
26 public static void change(int a,int b){
27 a = a+b;
28 b = b+a;
29 }
30 }
1 /*
2 方法的重载特性 (overload)
3 在同一个类中,允许出现同名的方法,只要方法的参数列表不同即可,这样方法就是重载
4 参数列表不同: 参数的个数,数据类型,顺序
5 */
6 public class MethodOverLoadDemo{
7 public static void main(String[] args){
8 //对于重载的调用,根据参数传递进行区分
9 //System.out.println();
10 double sum = getSum(2.3,3.5);
11 System.out.println(sum);
12 }
13 /*
14 对参数求和,利用方法的重载特性
15 */
16 public static int getSum(int a,int b){
17 System.out.println("两个int参数");
18 return a+b;
19 }
20 public static int getSum(int a,int b,int c){
21 System.out.println("三个int参数");
22 return a+b+c;
23 }
24 public static double getSum(double a,double b){
25 System.out.println("两个double参数");
26 return a+b;
27 }
28 /*
29 定义方法,对参数求和
30 参数,没规定几个,数据类型
31
32 public static int getSum(int a ,int b){
33 return a+b;
34 }
35
36 public static double getSumDouble(double a,double b){
37 return a+b;
38 }
39 public static int getSum3(int a,int b, int c){
40 return a+b+c;
41 }*/
42 }
1 /*
2 方法重载的注意事项
3 1. 参数列表必须不同
4 2. 重载和参数变量名无关
5 3. 重载和返回值类型无关
6 4. 重载和修饰符无关
7 技巧: 重载看方法名和参数列表
8 */
9 public class MethodOverLoadDemo_1{
10 //method(1l,1)
11
12
13 public static void method(int a,int b){
14
15 }
16 public static void method(double a,int b){
17
18 }
19
20 // void method(int a,int b){
21 //return 1;
22 //}
23
24 }
1 /*
2 实现商品的库存管理
3 功能:
4 1. 展示用户选择功能清单
5 2. 根据选择的功能编号,进行不同的操作
6 A. 展示所有库存
7 B. 修改库存数量
8
9 分析:
10 1. 展示用户清单:
11 输出语句, 用户输入, 选择功能序号
12 2. 根据选择,调用不同的方法
13 switch语句
14 case 1 2 3
15
16 A 展示库存
17 将存储商品的数组,遍历
18 B 修改库存
19
20 修改所有的库存数量
21 */
22 import java.util.Scanner;
23 public class Shopp{
24 public static void main(String[] args){
25 //使用数组,保存商品的信息
26 //品名,尺寸,价格,库存数, 定义5个数组
27 String[] brand = {"MacBookAir","ThinkpadT450"};
28 double[] size = {13.3,15.6};
29 double[] price = {9998.97,6789.56};
30 int[] count = {0,0};
31 while(true){
32 int choose = chooseFunction();
33 switch(choose){
34 case 1:
35 //调用查看库存清单方法
36 printStore(brand,size,price,count);
37 break;
38
39 case 2:
40 //调用修改库存的方法
41 update(brand,count);
42 break;
43
44 case 3:
45 return ;
46
47
48 default:
49 System.out.println("没有这个功能");
50 break;
51 }
52 }
53 }
54 /*
55 定义方法,修改所有商品的库存
56 用户输入1个,修改1个
57 返回值,没有
58 参数, 库存数的数组, 品名数组
59 */
60 public static void update(String[] brand, int[] count){
61 //遍历数组,遍历到一个,修改一个
62 //接受键盘输入
63 Scanner sc = new Scanner(System.in);
64 //遍历数组
65 for(int i = 0; i < brand.length ; i++){
66 System.out.println("请输入"+brand[i]+"的库存数");
67 //键盘输入,录入库存, 存储到库存的数组中
68 int newCount = sc.nextInt();
69 count[i] = newCount;
70 }
71 //int chooseNumber = sc.nextInt();
72 }
73
74 /*
75 定义方法,展示所有的库存清单,遍历
76 返回值,没有
77 参数, 数组
78 */
79 public static void printStore(String[] brand,double[] size,double[] price,int[] count){
80 System.out.println("----------商场库存清单----------");
81 System.out.println("品牌型号 尺寸 价格 库存数");
82 //定义变量,计算总库存数,和总价格
83 int totalCount = 0;
84 int totalMoney = 0;
85 //遍历数组,将数组中所有的商品信息打印出来
86 for(int i = 0 ; i < brand.length ; i++){
87 System.out.println(brand[i]+" "+size[i]+" "+price[i]+" "+count[i]);
88 totalCount += count[i];
89 totalMoney += count[i]*price[i];
90 }
91 System.out.println("总库存数: "+totalCount);
92 System.out.println("商品库存总金额: "+totalMoney);
93 }
94
95 /*
96 定义方法,实现用户的选择功能,功能的需要返回来
97 返回值, int
98 参数, 没有
99 */
100 public static int chooseFunction(){
101 System.out.println("-------------库存管理------------");
102 System.out.println("1.查看库存清单");
103 System.out.println("2.修改商品库存数量");
104 System.out.println("3.退出");
105 System.out.println("请输入要执行的操作序号：");
106 //接受键盘输入
107 Scanner sc = new Scanner(System.in);
108 int chooseNumber = sc.nextInt();
109 return chooseNumber;
110 }
111 }
1 /*
2 实现随机点名器
3 1. 存储所有学生姓名
4 2. 预览所有学生姓名,遍历数组
5 3. 随机数作为索引,到数组中找元素
6
7 将功能独立出来, 作成方法,调用方法即可
8
9 定义三个功能, 用到同一个姓名数据
10 姓名存储到数组中,三个方法,使用一个数组中的数据, 方法传递参数
11 */
12 import java.util.Random;
13 public class CallName{
14 public static void main(String[] args){
15 //定义数组,存储学生姓名
16 String[] names = new String[8];
17 //调用添加姓名方法
18 addStudent(names);
19 //调用遍历数组方法
20 printStudentName(names);
21 //调用随机姓名的方法
22 String name = randomStudentName(names);
23 System.out.println(name);
24 }
25 /*
26 定义方法,随机数,做索引,数组中找到学生姓名
27 返回值? 学生姓名
28 参数? 数组
29 */
30 public static String randomStudentName(String[] names){
31 Random ran = new Random();
32 int index = ran.nextInt(names.length);
33 return names[index];
34 }
35
36 /*
37 定义方法,遍历数组
38 返回值? 没有
39 参数? 数组
40 */
41 public static void printStudentName(String[] names){
42 for(int i = 0 ; i < names.length ;i++){
43 System.out.println(names[i]);
44 }
45 }
46
47 /*
48 定义方法,实现向数组中添加学生姓名
49 返回值? 没有,
50 参数? 参数就是数组
51 */
52 public static void addStudent(String[] names){
53 names[0] = "张三";
54 names[1] = "李四";
55 names[2] = "王五";
56 names[3] = "李蕾";
57 names[4] = "韩梅梅";
58 names[5] = "小名";
59 names[6] = "老王";
60 names[7] = "小华";
61 }
62 }
1 package com.it.demo03_method;
2
3 /*
4 案例: 演示有参无返回值的方法.
5
6 需求:
7 1.定义方法isEvenNumber(), 该方法接收一个int类型的整数num.
8 2.判断num是奇数还是偶数, 并打印结果.
9
10 涉及到的关于方法的小技巧:
11 定义方法时的三个明确:
12 1. 明确方法名.
13 2. 明确参数列表.
14 3. 明确返回值的数据类型.
15
16 调用方法时的三个步骤:
17 1. 写方法名.
18 2. 传参. 方法要什么类型的数据, 我们就传入什么类型的值.
19 3. 接收. 方法返回什么值, 我们就用对应的数据类型来接收.
20 */
21 public class Demo02 {
22 public static void main(String[] args) {
23 //调用isEvenNumber()方法, 传入变量.
24 int a = 10;
25 isEvenNumber(a); //实参, 实际参与操作的数据
26 System.out.println("-------------------");
27 //调用isEvenNumber()方法, 传入常量.
28 isEvenNumber(21); //实参, 实际参与操作的数据
29 }
30
31 /*
32 需求: 定义方法isEvenNumber(), 判断指定的数字是否是偶数, 并打印.
33
34 定义方法时的三个明确:
35 1. 明确方法名. isEvenNumber()
36 2. 明确参数列表. int num
37 3. 明确返回值的数据类型. void
38 */
39 public static void isEvenNumber(int num) { //int num = ? //形参: 形容调用方法, 需要传入什么类型的参数.
40 //判断指定的数字是否是偶数, 并打印.
41 if (num % 2 == 0)
42 System.out.println(num + "是偶数");
43 else
44 System.out.println(num + "是奇数");
45 }
46 }
1 package com.it.demo03_method;
2
3 /*
4 案例: 演示无参有返回值的方法.
5
6 需求:
7 1.定义方法getSum(), 该方法内部有两个int类型的整数.
8 2.获取上述两个整数的和, 并返回.
9 3.在main方法中调用getSum()方法, 并打印结果.
10 */
11 public class Demo03 {
12 public static void main(String[] args) {
13 /*
14 需求: 调用getSum()方法
15 调用方法时的三个步骤:
16 1. 写方法名, 调用谁就写谁, 注意大小写, 不要写错了.
17 2. 传参. 方法要什么类型的数据, 我们就传入什么类型的值.
18 3. 接收返回值. 方法返回什么类型的数据, 我们就用什么类型的变量来接收.
19 */
20 //方式一: 赋值调用, 即: 如果方法有返回值, 我们用变量接收, 然后在操作, 这种情况就叫: 赋值调用. 实际开发常用.
21 int sum = getSum();
22 //int sum = 30;
23 System.out.println(sum);
24 System.out.println("---------------------");
25
26 //方式二: 输出调用, 因为方法会直接返回一个值, 所以我们可以采用输出语句直接打印. 一般在课堂使用, 为了方便我们查看方法的执行结果.
27 System.out.println(getSum());
28 System.out.println("---------------------");
29
30 //方式三: 直接调用, 无意义, 一般不用.
31 getSum();
32 //30;
33
34 }
35
36 /*
37 需求: 定义方法getSum(), 用来获取两个整数的和, 并返回.
38 定义方法的三个明确:
39 1. 明确方法名. getSum()
40 2. 明确参数列表. 空参
41 3. 明确返回值的数据类型. int类型
42 */
43 public static int getSum() {
44 //该方法内部有两个int类型的整数, 获取上述两个整数的和, 并返回.
45 int a = 10, b = 20;
46 int sum = a + b;
47 //返回变量sum的值
48 return sum;
49 }
50 }
1 package com.it.demo03_method;
2
3 /*
4 案例: 无参有返回值的方法演示.
5
6 需求:
7 1.定义方法isEvenNumber(), 该方法内部有一个整数num.
8 2.判断num是奇数还是偶数, 并返回结果.
9 3.在main方法中调用isEvenNumber()方法, 并打印结果.
10
11 涉及到的关于方法的小技巧:
12 定义方法时的三个明确:
13 1. 明确方法名.
14 2. 明确参数列表.
15 3. 明确返回值的数据类型.
16
17 调用方法时的三个步骤:
18 1. 写方法名.
19 2. 传参. 方法要什么类型的数据, 我们就传入什么类型的值.
20 3. 接收. 方法返回什么值, 我们就用对应的数据类型来接收.
21 */
22 public class Demo04 {
23 public static void main(String[] args) {
24 //调用方法, 输出调用.
25 System.out.println(isEvenNumber());
26 System.out.println("----------------------------");
27
28 //调用方法, 赋值调用.
29 boolean flag = isEvenNumber();
30 System.out.println(flag);
31 }
32
33 //需求: 定义方法isEvenNumber(), 该方法内部有一个整数num, 判断num是奇数还是偶数, 并返回结果.
34 //明确方法名: isEvenNumber(), 明确参数列表: 空参, 明确返回值的数据类型: boolean
35
36 /**
37 * 该方法是用来判读数字是奇数还是偶数的.
38 * @return true: 偶数, false: 奇数
39 */
40 public static boolean isEvenNumber() {
41 int num = 10;
42 //判断num是奇数还是偶数, 并返回结果.
43 /* if(num % 2 == 0)
44 return true;
45 else
46 return false;*/
47
48 /*boolean flag = num % 2 == 0 ? true : false;
49 return flag;*/
50
51 /*boolean flag = num % 2 == 0;
52 return flag;*/
53
54 return num % 2 == 0;
55 }
56 }
1 package com.it.demo04_overload;
2
3 /*
4 案例: 方法重载入门
5
6 方法重载概述:
7 同一个类中, 出现方法名相同, 但是参数列表不同的 两个或以上的方法时, 称为方法重载.
8 方法重载与返回值的数据类型无关.
9
10 参数列表不同解释:
11 1. 参数个数不同.
12 2. 对应参数的数据类型不同.
13
14 解决的问题:
15 用来解决方法功能相似, 但是方法名不能重名的问题. 简单理解: 就是用来解决方法重名问题的.
16 */
17 public class Demo01 {
18 public static void main(String[] args) {
19 //1.定义方法compare(), 用来比较两个整型数据是否相等.
20 //2.要求兼容所有的整数类型, 即(byte, short, int, long)
21
22 //调用compare()方法, byte类型
23 byte b1 = 10, b2 = 20;
24 System.out.println(compare(b1, b2));
25 System.out.println("-----------------------------");
26
27 //调用compare()方法, short类型
28 short s1 = 10, s2 = 20;
29 System.out.println(compare(s1, s2));
30 System.out.println("-----------------------------");
31
32 //调用compare()方法, int类型
33 System.out.println(compare(20, 10));
34 System.out.println("-----------------------------");
35
36 //调用compare()方法, long类型
37 long s3 = 10, s4 = 20;
38 System.out.println(compare(s3, s4));
39 }
40
41 //定义方法compare(), 用来比较两个整型数据是否相等. byte类型
42 public static boolean compare(byte b1, byte b2) {
43 System.out.println("byte类型");
44 return b1 == b2;
45 }
46
47 //定义方法compare(), 用来比较两个整型数据是否相等. short类型
48 public static boolean compare(short s1, short s2) {
49 System.out.println("short类型");
50 return s1 == s2;
51 }
52
53 //定义方法compare(), 用来比较两个整型数据是否相等. int类型
54 public static boolean compare(int a, int b) {
55 System.out.println("int类型");
56 return a == b;
57 }
58
59 //定义方法compare(), 用来比较两个整型数据是否相等. byte类型
60 public static boolean compare(long b1, long b2) {
61 System.out.println("long类型");
62 return b1 == b2;
63 }
64
65 }
package com.it.demo04_overload;
/*
案例: 演示形参是基本类型的情况.
结论:
如果是基本类型作为形参: 传递的是数值, 所以形参的改变对实参没有任何影响.
*/
public class Demo02 {
public static void main(String[] args) {
int number = 100;
System.out.println("调用change方法前：" + number); //100
change(number); //实参.
System.out.println("调用change方法后：" + number); //100
}
public static void change(int number) { //形参.
number = 200;
}
}
1 package com.it.demo04_overload;
2
3 /*
4 案例: 演示形参是引用类型的情况.
5
6 结论:
7 如果是引用类型作为形参: 传递的是地址值, 所以形参的改变直接影响实参.
8 String类型除外, 当它充当形参类型的时候, 传递的是数值, 即: 用法和基本类型一致.
9 */
10 public class Demo03 {
11 public static void main(String[] args) {
12 int[] arr = {10, 20, 30}; //地址值: 0x001
13 System.out.println("调用change方法前：" + arr[1]); //20
14 change(arr);
15 System.out.println("调用change方法后：" + arr[1]); //200
16 }
17
18 public static void change(int[] arr) { //地址值: 0x001
19 arr[1] = 200;
20 }
21 }
1 package com.it.demo02_exercise;
2
3 /*
4 方法案例: 求和.
5
6 需求:
7 1.定义方法getSum(), 接收两个int类型的整数.
8 2.获取上述两个整数的和, 并返回.
9 3.在main方法中调用getSum()方法, 并打印结果.
10 */
11 public class Demo05 {
12 public static void main(String[] args) {
13 //需求: 调用getSum();
14 //方式一: 传入变量
15 int num1 = 10, num2 = 20;
16 int sum1 = getSum(num1, num2);
17 System.out.println(sum1);
18 System.out.println("-----------------------");
19
20 //方式二: 传入常量
21 /*int sum2 = getSum(22, 11);
22 System.out.println(sum2);*/
23 System.out.println(getSum(22, 11));
24 }
25
26 /*
27 定义方法的三个明确:
28 1. 明确方法名. getSum()
29 2. 明确参数列表. int a, int b
30 3. 明确返回值的数据类型. int
31 */
32
33 /**
34 * 该方法用于获取两个整数的和
35 * @param a 要进行求和运算的第一个整数.
36 * @param b 要进行求和运算的第二个整数.
37 * @return 两个整数的和
38 */
39 public static int getSum(int a, int b) { //形参, int a = ?, int b = ?
40 //求两个整数的和
41 //合并版
42 return a + b;
43
44 //分解版.
45 /*int sum = a + b;
46 return sum;*/
47 }
48 }
1 package com.it.demo02_exercise;
2
3 /*
4 方法案例: 判断奇偶数.
5
6 需求:
7 1.定义方法isEvenNumber(), 该方法接收一个int类型的整数num.
8 2.判断num是奇数还是偶数, 并返回结果.
9 3.在main方法中调用isEvenNumber()方法, 并打印结果.
10 */
11 public class Demo06 {
12 public static void main(String[] args) {
13 //需求: 调用isEvenNumber()方法
14 //赋值调用.
15 boolean flag = isEvenNumber(10);
16 System.out.println(flag);
17 System.out.println("=====================");
18
19 //输出调用
20 System.out.println(isEvenNumber(11));
21 }
22
23 //需求: 定义方法, 判断奇偶数.
24 //文档注释自己补充.
25 public static boolean isEvenNumber(int num) { //形参, int num = ?
26 //接收一个int类型的整数num., 判断num是奇数还是偶数, 并返回结果.
27 return num % 2 == 0;
28 }
29 }
1 package com.it.demo02_exercise;
2
3 /*
4 方法案例: 求最大值.
5
6 需求:
7 1.定义方法getMax(), 该方法接收两个整数.
8 2.通过该方法, 获取两个整数的最大值, 并返回.
9 3.在main方法中调用getMax()方法, 获取最大值并打印.
10 */
11 public class Demo07 {
12 public static void main(String[] args) {
13 //需求: 调用getMax()方法.
14 int max = getMax(10, 20);
15 System.out.println(max);
16 System.out.println("-------------------");
17
18 System.out.println(getMax(21, 11));
19 }
20
21 //需求: 定义方法, 获取两个整数的最大值.
22
23 /**
24 * 该方法是用于获取两个整数的最大值的.
25 * @param a 要操作的第一个整数.
26 * @param b 要操作的第二个整数
27 * @return 两个整数的最大值.
28 */
29 public static int getMax(int a, int b) {
30 //分解版
31 /*int max = a > b ? a :b;
32 return max;*/
33
34 //合并版
35 return a > b ? a : b;
36 }
37 }
1 package com.it.demo02_exercise;
2
3 /*
4 方法案例: 遍历数组
5
6 需求:
7 1.定义方法printArray(), 接收一个int类型的数组.
8 2.通过该方法, 实现遍历数组的功能.
9 3.在main方法中, 调用方法, 打印指定的数组.
10 */
11 public class Demo08 {
12 public static void main(String[] args) {
13 //需求:在main方法中, 调用方法, 打印指定的数组.
14 int[] arr = {1, 2, 3, 4, 5};
15 printArray(arr);
16 System.out.println("---------------------");
17
18 int[] arr2 = {100, 200, 300};
19 printArray(arr2);
20 }
21
22 //1.定义方法printArray(), 接收一个int类型的数组, 通过该方法, 实现遍历数组的功能.
23 /*
24 1. 明确方法名. printArray()
25 2. 明确参数列表. int[] arr
26 3. 明确返回值的数据类型. void
27 */
28 public static void printArray(int[] arr) {
29 //这里是遍历数组的代码
30 for (int i = 0; i < arr.length; i++) {
31 System.out.println(arr[i]);
32 }
33 }
34 }
1 package com.it.demo02_exercise;
2
3 /*
4 方法案例: 获取数组元素最值.
5
6 需求:
7 1.定义方法getMax(), 接收一个int类型的数组.
8 2.通过该方法, 获取数组元素中的最大值.
9 3.在main方法中, 调用方法, 打印对应的结果.
10 */
11 public class Demo09 {
12 public static void main(String[] args) {
13 //需求: 调用getMax();
14 int[] arr = {11, 33, 22, 55};
15
16 //赋值调用, 实际开发用.
17 int max = getMax(arr);
18 System.out.println(max);
19 System.out.println("-----------------------");
20
21 //输出调用, 课堂用.
22 System.out.println(getMax(arr));
23 }
24
25 /*
26 需求: 定义方法getMax(), 获取int数组元素的最大值.
27
28 定义方法的3个明确:
29 1. 明确方法名. getMax()
30 2. 明确参数列表. int[] arr
31 3. 明确返回值的数据类型. int
32 */
33 public static int getMax(int[] arr) { //形参, 形容调用方法需要给什么类型的值, int[] arr = ?
34 //1. 定义变量, 用来记录最大值.
35 int max = arr[0];
36 //2. 遍历数组, 获取每个元素.
37 for (int i = 0; i < arr.length; i++) {
38 //3. 判断当前获取到的元素是否大于临时变量max, 如果大就将其值赋值给变量max
39 if (arr[i] > max)
40 max = arr[i];
41 }
42 //4. 返回结果.
43 return max;
44 }
45 }
1 package com.it.demo02_exercise;
2
3 /*
4 方法案例: 模拟计算器.
5
6 需求:
7 1.定义方法, 接收两个int类型的整数.
8 2.分别获取这两个整数的加减乘除的运算结果, 然后返回.
9 3.在main方法中调用该方法, 并打印结果.
10 */
11 public class Demo10 {
12 public static void main(String[] args) {
13 //需求: 调用calculate(), 模拟计算器.
14 int[] arr = calculate(10, 3);//实参, 实际参与运算的数字
15
16 //遍历数组, 查看结果.
17 for (int i = 0; i < arr.length; i++) {
18 System.out.println(arr[i]);
19 }
20 }
21
22 //需求: 定义方法calculate(), 模拟计算器.
23 /*
24 定义方法的三个明确:
25 1. 明确方法名. calculate()
26 2. 明确参数列表. int a, int b
27 3. 明确返回值的数据类型. int[] 因为要同时返回加减乘除这四个值, 所以用数组.
28 */
29
30 /**
31 * 定义方法, 模拟计算器, 即: 获取两个整数的加减乘除运算结果.
32 * @param a 要操作的第一个整数
33 * @param b 要操作的第二个整数
34 * @return 返回这两个整数加减乘除的运算结果.
35 */
36 public static int[] calculate(int a, int b) { //形参, int a = ?, int b = ?
37 //1. 定义int[]数组, 长度为4, 分别表示: 加减乘除的运算结果.
38 int[] arr = new int[4];
39 //2. 进行加减乘除运算, 并把结果存储到数组中.
40 arr[0] = a + b;
41 arr[1] = a - b;
42 arr[2] = a * b;
43 arr[3] = a / b;
44 //3. 返回数组.
45 return arr;
46 }
47 }
1 package com.it.demo02_exercise;
2
3 /*
4 案例: 按照格式打印数组.
5
6 需求:
7 1.定义方法printArray(), 该方法用来打印数组. [11, 22, 33, 44, 55]
8 2.打印格式为: [11, 22, 33, 44, 55]
9 */
10 public class Demo11 {
11 public static void main(String[] args) {
12 //需求: 调用printArray()方法
13 int[] arr = {11, 22, 33, 44, 55};
14 printArray(arr);
15 }
16
17 //需求: 定义方法printArray(), 该方法用来打印数组.
18 public static void printArray(int[] arr) {
19 //里边写的是具体的打印数组元素的操作.
20 //1. 先输出"[", 记得不要换行.
21 System.out.print("[");
22 //2. 遍历数组, 获取每一个元素.
23 for (int i = 0; i < arr.length; i++) {
24 //arr[i]就是数组中的每个元素.
25 //3. 判断当前元素是否是最后一个元素, 如果是, 就输出: 元素 + "]" + 换行
26 if (i == arr.length - 1)
27 System.out.println(arr[i] + "]");
28 else
29 //4. 如果不是最后一个元素, 就输出: 元素 + ", ", 不换行
30 System.out.print(arr[i] + ", ");
31 }
32
33 }
34 }
方法调用图解
有参无返回调用图解
方法参数传递问题图解
方法的参数传递问题——引用类型