Java基础语法Day_04

第11节 开发工具-IDEA

　　day04_01_集成开发环境IDE的概述
　　day04_02_IntelliJ-IDEA的安装
　　day04_03_IDEA的项目结构
　　day04_04_IDEA的HelloWorld
　　day04_05_IDEA的基本配置
　　day04_06_IDEA的常用快捷键
　　day04_07_IDEA的项目关闭打开与模 
第12节 方法复习
　　day04_08_复习简单方法的使用
　　day04_09_方法的定义格式
　　day04_10_方法的三种调用格式
　　day04_11_方法的调用流程图解
　　day04_12_对比有参数和无参数
　　day04_13_对比有返回值和无返回值
　　day04_14_方法练习1_比较两个数字是否相同
　　day04_15_方法练习2_求出1到100的累加和
　　day04_16_方法练习3_打印指定次数的HelloWorld
　　day04_17_方法的注意事项
第13节 方法重载
　　day04_18_方法重载的基本使用
　　day04_19_方法重载的注意事项
　　day04_20_重载练习1_四种不同参数类型的方法
　　day04_21_重载练习2_判断方法的正确重载
　　day04_22_重载练习3_实现重载的println方法
　　小节测试
　　课后练习

 1 package cn.itcast.day04.demo02;
 2
 3 /*
 4 复习一下此前学习的方法基础入门知识。
 5
 6 定义格式：
 7 public static void 方法名称() {
 8     方法体
 9 }
10
11 调用格式：
12 方法名称();
13
14 注意事项：
15 1. 方法定义的先后顺序无所谓。
16 2. 方法定义必须是挨着的，不能在一个方法的内部定义另外一个方法。
17 3. 方法定义之后，自己不会执行的；如果希望执行，一定要进行方法的调用。
18  */
19 public class Demo01Method {
20
21     public static void main(String[] args) {
22         printMethod();
23     }
24
25     public static void printMethod() {
26         for (int j = 0; j < 5; j++) {
27             for (int i = 0; i < 20; i++) {
28                 System.out.print("*");
29             }
30             System.out.println();
31         }
32     }
33
34 }

　　MethodDefine

 1 package cn.itcast.day04.demo02;
 2
 3 /*
 4 方法其实就是若干语句的功能集合。
 5
 6 方法好比是一个工厂。
 7 蒙牛工厂     原料：奶牛、饲料、水
 8             产出物：奶制品
 9 钢铁工厂     原料：铁矿石、煤炭
10             产出物：钢铁建材
11
12 参数（原料）：就是进入方法的数据。
13 返回值（产出物）：就是从方法中出来的数据。
14
15 定义方法的完整格式：
16 修饰符 返回值类型 方法名称(参数类型 参数名称, ...) {
17     方法体
18     return 返回值;
19 }
20
21 修饰符：现阶段的固定写法，public static
22 返回值类型：也就是方法最终产生的数据结果是什么类型
23 方法名称：方法的名字，规则和变量一样，小驼峰
24 参数类型：进入方法的数据是什么类型
25 参数名称：进入方法的数据对应的变量名称
26 PS：参数如果有多个，使用逗号进行分隔
27 方法体：方法需要做的事情，若干行代码
28 return：两个作用，第一停止当前方法，第二将后面的返回值还给调用处
29 返回值：也就是方法执行后最终产生的数据结果
30
31 注意：return后面的“返回值”，必须和方法名称前面的“返回值类型”，保持对应。
32
33 定义一个两个int数字相加的方法。三要素：
34 返回值类型：int
35 方法名称：sum
36 参数列表：int a, int b
37
38 方法的三种调用格式。
39 1. 单独调用：方法名称(参数);
40 2. 打印调用：System.out.println(方法名称(参数));
41 3. 赋值调用：数据类型 变量名称 = 方法名称(参数);
42
43 注意：此前学习的方法，返回值类型固定写为void，这种方法只能够单独调用，不能进行打印调用或者赋值调用。
44 */
45 public class Demo02MethodDefine {
46
47     public static void main(String[] args) {
48         // 单独调用
49         sum(10, 20);
50         System.out.println("===========");
51
52         // 打印调用
53         System.out.println(sum(10, 20)); // 30
54         System.out.println("===========");
55
56         // 赋值调用
57         int number = sum(15, 25);
58         number += 100;
59         System.out.println("变量的值：" + number); // 140
60     }
61
62     public static int sum(int a, int b) {
63         System.out.println("方法执行啦！");
64         int result = a + b;
65         return result;
66     }
67
68 }

　　MethodParam

 1 package cn.itcast.day04.demo02;
 2
 3 /*
 4 有参数：小括号当中有内容，当一个方法需要一些数据条件，才能完成任务的时候，就是有参数。
 5 例如两个数字相加，必须知道两个数字是各自多少，才能相加。
 6
 7 无参数：小括号当中留空。一个方法不需要任何数据条件，自己就能独立完成任务，就是无参数。
 8 例如定义一个方法，打印固定10次HelloWorld。
 9  */
10 public class Demo03MethodParam {
11
12     public static void main(String[] args) {
13         method1(10, 20);
14         System.out.println("==============");
15         method2();
16     }
17
18     // 两个数字相乘，做乘法，必须知道两个数字各自是多少，否则无法进行计算
19     // 有参数
20     public static void method1(int a, int b) {
21         int result = a * b;
22         System.out.println("结果是：" + result);
23     }
24
25     // 例如打印输出固定10次文本字符串
26     public static void method2() {
27         for (int i = 0; i < 10; i++) {
28             System.out.println("Hello, World!" + i);
29         }
30     }
31
32 }

 1 package cn.itcast.day04.demo02;
 2
 3 /*
 4 题目要求：定义一个方法，用来【求出】两个数字之和。（你帮我算，算完之后把结果告诉我。）
 5 题目变形：定义一个方法，用来【打印】两个数字之和。（你来计算，算完之后你自己负责显示结果，不用告诉我。）
 6
 7 注意事项：
 8 对于有返回值的方法，可以使用单独调用、打印调用或者赋值调用。
 9 但是对于无返回值的方法，只能使用单独调用，不能使用打印调用或者赋值调用。
10  */
11 public class Demo04MethodReturn {
12
13     public static void main(String[] args) {
14         // 我是main方法，我来调用你。
15         // 我调用你，你来帮我计算一下，算完了之后，把结果告诉我的num变量
16         int num = getSum(10, 20);
17         System.out.println("返回值是：" + num);
18         System.out.println("==============");
19
20         printSum(100, 200);
21         System.out.println("==============");
22
23         System.out.println(getSum(2, 3)); // 正确写法
24         getSum(3, 5); // 正确写法，但是返回值没有用到
25         System.out.println("==============");
26
27         // 对于void没有返回值的方法，只能单独，不能打印或者赋值
28 //        System.out.println(printSum(2, 3)); // 错误写法！
29 //        System.out.println(void);
30
31 //        int num2 = printSum(10, 20); // 错误写法！
32 //        int num3 = void;
33 //        void num4 = void;
34     }
35
36     // 我是一个方法，我负责两个数字相加。
37     // 我有返回值int，谁调用我，我就把计算结果告诉谁
38     public static int getSum(int a, int b) {
39         int result = a + b;
40         return result;
41     }
42
43     // 我是一个方法，我负责两个数字相加。
44     // 我没有返回值，不会把结果告诉任何人，而是我自己进行打印输出。
45     public static void printSum(int a, int b) {
46         int result = a + b;
47         System.out.println("结果是：" + result);
48     }
49
50 }

 1 package cn.itcast.day04.demo03;
 2
 3 /*
 4 题目要求：
 5 定义一个方法，用来判断两个数字是否相同。
 6  */
 7 public class Demo01MethodSame {
 8
 9     public static void main(String[] args) {
10         System.out.println(isSame(10, 20)); // false
11         System.out.println(isSame(20, 20)); // true
12     }
13
14     /*
15     三要素：
16     返回值类型：boolean
17     方法名称：isSame
18     参数列表：int a, int b
19      */
20     public static boolean isSame(int a, int b) {
21         /*boolean same;
22         if (a == b) {
23             same = true;
24         } else {
25             same = false;
26         }*/
27
28         // boolean same = a == b ? true : false;
29
30         // boolean same = a == b;
31
32         return a == b;
33     }
34
35 }

 1 package cn.itcast.day04.demo03;
 2
 3 /*
 4 题目要求：
 5 定义一个方法，用来求出1-100之间所有数字的和值。
 6  */
 7 public class Demo02MethodSum {
 8
 9     public static void main(String[] args) {
10         System.out.println("结果是：" + getSum());
11     }
12
13     /*
14     三要素
15     返回值：有返回值，计算结果是一个int数字
16     方法名称：getSum
17     参数列表：数据范围已经确定，是固定的，所以不需要告诉我任何条件，不需要参数
18      */
19     public static int getSum() {
20         int sum = 0;
21         for (int i = 1; i <= 100; i++) {
22             sum += i;
23         }
24         return sum;
25     }
26
27 }

 1 package cn.itcast.day04.demo03;
 2
 3 /*
 4 题目要求：
 5 定义一个方法，用来打印指定次数的HelloWorld。
 6  */
 7 public class Demo03MethodPrint {
 8
 9     public static void main(String[] args) {
10         printCount(10);
11     }
12
13     /*
14     三要素
15     返回值类型：只是进行一大堆打印操作而已，没有计算，也没有结果要告诉调用处
16     方法名称：printCount
17     参数列表：到底要打印多少次？必须告诉我，否则我不知道多少次，没法打印。次数：int
18      */
19     public static void printCount(int num) {
20         for (int i = 0; i < num; i++) {
21             System.out.println("Hello, World!" + (i + 1));
22         }
23     }
24
25 }

 1 package cn.itcast.day04.demo03;
 2
 3 /*
 4 使用方法的时候，注意事项：
 5
 6 1. 方法应该定义在类当中，但是不能在方法当中再定义方法。不能嵌套。
 7 2. 方法定义的前后顺序无所谓。
 8 3. 方法定义之后不会执行，如果希望执行，一定要调用：单独调用、打印调用、赋值调用。
 9 4. 如果方法有返回值，那么必须写上“return 返回值;”，不能没有。
10 5. return后面的返回值数据，必须和方法的返回值类型，对应起来。
11 6. 对于一个void没有返回值的方法，不能写return后面的返回值，只能写return自己。
12 7. 对于void方法当中最后一行的return可以省略不写。
13 8. 一个方法当中可以有多个return语句，但是必须保证同时只有一个会被执行到，两个return不能连写。
14  */
15 public class Demo04MethodNotice {
16
17     public static int method1() {
18         return 10;
19     }
20
21     public static void method2() {
22 //        return 10; // 错误的写法！方法没有返回值，return后面就不能写返回值。
23         return; // 没有返回值，只是结束方法的执行而已。
24     }
25
26     public static void method3() {
27         System.out.println("AAA");
28         System.out.println("BBB");
29 //        return; // 最后一行的return可以省略不写。
30     }
31
32     public static int getMax(int a, int b) {
33         /*int max;
34         if (a > b) {
35             max = a;
36         } else {
37             max = b;
38         }
39         return max;*/
40
41         if (a > b) {
42             return a;
43         } else {
44             return b;
45         }
46     }
47
48 }

　　方法的重载在java中和c语言不同

 1 package cn.itcast.day04.demo04;
 2
 3 /*
 4 对于功能类似的方法来说，因为参数列表不一样，却需要记住那么多不同的方法名称，太麻烦。
 5
 6 方法的重载（Overload）：多个方法的名称一样，但是参数列表不一样。
 7 好处：只需要记住唯一一个方法名称，就可以实现类似的多个功能。
 8
 9 方法重载与下列因素相关：
10 1. 参数个数不同
11 2. 参数类型不同
12 3. 参数的多类型顺序不同
13
14 方法重载与下列因素无关：
15 1. 与参数的名称无关
16 2. 与方法的返回值类型无关
17  */
18 public class Demo01MethodOverload {
19
20     public static void main(String[] args) {
21         /*System.out.println(sumTwo(10, 20)); // 30
22         System.out.println(sumThree(10, 20, 30)); // 60
23         System.out.println(sumFour(10, 20, 30, 40)); // 100*/
24
25         System.out.println(sum(10, 20)); // 两个参数的方法
26         System.out.println(sum(10, 20, 30)); // 三个参数的方法
27         System.out.println(sum(10, 20, 30, 40)); // 四个参数的方法
28 //        System.out.println(sum(10, 20, 30, 40, 50)); // 找不到任何方法来匹配，所以错误！
29
30         sum(10, 20);
31     }
32
33     public static int sum(int a, double b) {
34         return (int) (a + b);
35     }
36
37     public static int sum(double a, int b) {
38         return (int) (a + b);
39     }
40
41     public static int sum(int a, int b) {
42         System.out.println("有2个参数的方法执行！");
43         return a + b;
44     }
45
46     // 错误写法！与方法的返回值类型无关
47 //    public static double sum(int a, int b) {
48 //        return a + b + 0.0;
49 //    }
50
51     // 错误写法！与参数的名称无关
52 //    public static int sum(int x, int y) {
53 //        return x + y;
54 //    }
55
56     public static int sum(double a, double b) {
57         return (int) (a + b);
58     }
59
60     public static int sum(int a, int b, int c) {
61         System.out.println("有3个参数的方法执行！");
62         return a + b + c;
63     }
64
65     public static int sum(int a, int b, int c, int d) {
66         System.out.println("有4个参数的方法执行！");
67         return a + b + c + d;
68     }
69
70 }

 1 package cn.itcast.day04.demo04;
 2
 3 /*
 4 题目要求：
 5 比较两个数据是否相等。
 6 参数类型分别为两个byte类型，两个short类型，两个int类型，两个long类型，
 7 并在main方法中进行测试。
 8  */
 9 public class Demo02MethodOverloadSame {
10
11     public static void main(String[] args) {
12         byte a = 10;
13         byte b = 20;
14         System.out.println(isSame(a, b));
15
16         System.out.println(isSame((short) 20, (short) 20));
17
18         System.out.println(isSame(11, 12));
19
20         System.out.println(isSame(10L, 10L));
21     }
22
23     public static boolean isSame(byte a, byte b) {
24         System.out.println("两个byte参数的方法执行！");
25         boolean same;
26         if (a == b) {
27             same = true;
28         } else {
29             same = false;
30         }
31         return same;
32     }
33
34     public static boolean isSame(short a, short b) {
35         System.out.println("两个short参数的方法执行！");
36         boolean same = a == b ? true : false;
37         return same;
38     }
39
40     public static boolean isSame(int a, int b) {
41         System.out.println("两个int参数的方法执行！");
42         return a == b;
43     }
44
45     public static boolean isSame(long a, long b) {
46         System.out.println("两个long参数的方法执行！");
47         if (a == b) {
48             return true;
49         } else {
50             return false;
51         }
52     }
53
54 }

　　常见问题

 1 package cn.itcast.day04.demo04;
 2
 3 public class Demo03OverloadJudge {
 4
 5     /*
 6     public static void open(){} // 正确重载
 7     public static void open(int a){} // 正确重载
 8     static void open(int a,int b){} // 代码错误：和第8行冲突
 9     public static void open(double a,int b){} // 正确重载
10     public static void open(int a,double b){} // 代码错误：和第6行冲突
11     public void open(int i,double d){} // 代码错误：和第5行冲突
12     public static void OPEN(){} // 代码正确不会报错，但是并不是有效重载
13     public static void open(int i,int j){} // 代码错误：和第3行冲突
14     */
15
16 }

 1 package cn.itcast.day04.demo04;
 2
 3 // byte short int long float double char boolean
 4 // String
 5 // 在调用输出语句的时候，println方法其实就是进行了多种数据类型的重载形式。
 6 public class Demo04OverloadPrint {
 7
 8     public static void main(String[] args) {
 9         myPrint(100); // int
10         myPrint("Hello"); // String
11     }
12
13     public static void myPrint(byte num) {
14         System.out.println(num);
15     }
16
17     public static void myPrint(short num) {
18         System.out.println(num);
19     }
20
21     public static void myPrint(int num) {
22         System.out.println(num);
23     }
24
25     public static void myPrint(long num) {
26         System.out.println(num);
27     }
28
29     public static void myPrint(float num) {
30         System.out.println(num);
31     }
32
33     public static void myPrint(double num) {
34         System.out.println(num);
35     }
36
37     public static void myPrint(char zifu) {
38         System.out.println(zifu);
39     }
40
41     public static void myPrint(boolean is) {
42         System.out.println(is);
43     }
44
45     public static void myPrint(String str) {
46         System.out.println(str);
47     }
48
49 }