Java 复习整理day04

　　在我们的日常生活中，方法可以理解为要做某件事情，

而采取的解决办法。

　　如：小明同学在路边准备坐车来学校学习。这就面临

着一件事情（坐车到学校这件事情）需要解决，解决办法

呢？可采用坐公交车或坐出租车的方式来学校，那么，这

种解决某件事情的办法，我们就称为方法。

　　在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 }

方法调用图解

有参无返回调用图解

方法参数传递问题图解

方法的参数传递问题——引用类型