第一章 开发工具IntelliJ IDEA

1.1 概述

IDEA是一个专门针对Java的集成开发工具(IDE)，由Java语言编写。所以，需要有JRE运行环境并配置好环境变量。 它可以极大地提升我们的开发效率。可以自动编译，检查错误。

1.2 安装

双击安装包进行安装

  1. 欢迎界面
    无脑Next

  2. 选择安装路径
    不要装在C盘

  3. 配置安装选项
    建议只勾选64快捷启动方式

  4. 开始菜单
    无脑Next

  5. 安装完毕

1.3首次启动

  1. 不导入任何设置

    1. 选择第二个，ok

  2. 创建一个项目
    项目结构
    4.0 IDEA、方法扩展 - 图1

  3. 点击 new 按钮，配置安装的 JDK9 版本

  4. 不使用模板

  5. 为工程起名字 demo ，并存储到 d:\ideawork\demo 目录下，如果d盘没有这个目录，会自动创建

1.4idea常用快捷键

4.0 IDEA、方法扩展 - 图2

=========================================================================================================

Alt+回车 导入包,自动修正
Ctrl+N 查找类
Ctrl+Shift+N 查找文件
Ctrl+Alt+L 格式化代码
Ctrl+Alt+O 优化导入的类和包
Alt+Insert 生成代码(如get,set方法,构造函数等)
Ctrl+E或者Alt+Shift+C 最近更改的代码
Ctrl+R 替换文本
Ctrl+F 查找文本
Ctrl+Shift+Space 自动补全代码
Ctrl+空格 代码提示
Ctrl+Alt+Space 类名或接口名提示
Ctrl+P 方法参数提示
Ctrl+Shift+Alt+N 查找类中的方法或变量
Alt+Shift+C 对比最近修改的代码
Shift+F6 重构-重命名
Ctrl+X 删除行
Ctrl+D 复制行
Ctrl+/ 或 Ctrl+Shift+/ 注释（// 或者/…/ ）
Ctrl+J 自动代码
Ctrl+E 最近打开的文件
Ctrl+H 显示类结构图
Ctrl+Q 显示注释文档
Alt+F1 查找代码所在位置
Alt+1 快速打开或隐藏工程面板
Ctrl+Alt+ left/right 返回至上次浏览的位置
Alt+ left/right 切换代码视图
Alt+ Up/Down 在方法间快速移动定位
Ctrl+Shift+Up/Down 代码向上/下移动。
F2 或Shift+F2 高亮错误或警告快速定位
代码标签输入完成后 按Tab，生成代码。
选中文本，按Ctrl+Shift+F7 高亮显示所有该文本，按Esc高亮消失。
Ctrl+W 选中代码，连续按会有其他效果
选中文本，按Alt+F3 逐个往下查找相同文本，并高亮显示。
Ctrl+Up/Down 光标跳转到第一行或最后一行下
Ctrl+B 快速打开光标处的类或方法

第二章 方法

2.1回顾—方法的定义与调用

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

  1. /*
  2. * 方法入门基础知识
  3. *
  4. * 定义格式：
  5. * public static void 方法名称() {
  6. *   方法体;
  7. * }
  8. *
  9. * 调用格式:
  10. *   方法名称();
  11. *
  12. * 注意事项：
  13. * 1，方法定义先后顺序无所谓
  14. * 2，方法定义必须是挨着的，不能在一个方法内定义另一个方法
  15. * 3，方法定义之后，自己不会执行，只有在调用后才会执行
  16. */
  17. public class Demo01Method {
  18.     public static void main(String[] args) {
  19.         printMenthod();
  20.     }
  22.     public static void printMenthod() {
  23.         for (int i = 0; i < 5; i++) {
  24.             for (int i1 = 0; i1 < 20; i1++) {
  25.                 System.out.print("*");
  26.             }
  27.             System.out.println();
  28.         }
  29.     }
  30. }

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

2.2方法的格式及含义

格式：

  1. 修饰符 返回值类型 方法名称(参数类型 参数名称,...) {
  3.     方法体;
  5.     return 返回值;
  7. }

格式含义：

  • 修饰符：现阶段的固定写法：public static

  • 返回值类型：就是方法最终产生的数据结果的类型

  • 方法名称：方法的名字，规则和变量一样，小驼峰

  • 参数类型：进入方法的参数的数据类型

    • PS：如果有多个参数，使用逗号进行分割

  • 方法体：方法需要做的事情，若干行代码

  • return：两个作用，一是停止当前方法，二是将后面的返回值还给调用处

  • 返回值：也就是方法执行后最终产生的数据

    • 注意：return后面的“返回值”，必须和方法名称前面的“返回值类型”保持对应

方法的三要素：

  • 返回数据类型
  • 方法名称
  • 参数列表

2.3方法的调用

方法的三种调用格式：

1，单独调用：方法名称(参数)

2，输出调用：System.out.println(方法名称(参数));

3，赋值调用：数据类型 变量名称 = 方法名称(参数);

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

2.4调用方法的流程

1，找到方法

2，参数传递

3，执行方法体

4，带着返回值回到方法的调用处

4.0 IDEA、方法扩展 - 图3

  1. package JavaRumen.Java04.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. *   PS：如果有多个参数，使用逗号进行分割
  26. * 方法体：方法需要做的事情，若干行代码
  27. * return：两个作用，一是停止当前方法，二是将后面的返回值还给调用处
  28. * 返回值：也就是方法执行后最终产生的数据
  29. *   注意：return后面的“返回值”，必须和方法名称前面的“返回值类型”保持对应
  30. *
  31. * 定义一个两个int数字相加的方法，三要素
  32. * 返回数据类型：int
  33. * 方法名称：sum
  34. * 参数列表：int a, int b;
  35. *
  36. * 方法的三种调用格式：
  37. * 1，单独调用：方法名称(参数)
  38. * 2，输出调用：System.out.println(方法名称(参数));
  39. * 3，赋值调用：数据类型 变量名称 = 方法名称(参数);
  40. *
  41. * 注意：此前学习的方法，返回值类型固定写为void，这种方法只能够单独调用，不能进行打印调用或则赋值调用
  42. *
  43. * 方法调用的流程
  44. *   1，找到方法
  45. *   2，参数传递
  46. *   3，执行方法体
  47. *   4，带着返回值回到方法的调用处
  48. * */
  49. public class Demo02MethodDefine {
  50.     public static void main(String[] args) {
  52.         // 单独调用
  53.         sum(10, 20);
  54.         System.out.println("=============");
  56.         // 输出调用
  57.         System.out.println(sum(11, 22));
  58.         System.out.println("=============");
  60.         // 赋值调用
  61.         int number= sum(3, 7);
  62.         System.out.println("变量的值" + number);
  64.     }
  65.     public static int sum(int a, int b){
  66.         System.out.println("方法执行了！");
  68. //        int result = a + b;
  69. //        return result; // 变量声明和赋值占用了内存，造成了冗余，建议使用精简版
  71.         return a + b; // 精简版
  72.     }
  73. }

2.5方法参数的有无

  • 有参数：小括号当中有内容，当一个方法需要一些数据条件，才能完成任务的时候，就是有参数

    • 例如：两个数子相加，必须知道数字的值是多少，才能相加

  • 无参数：小括号当中留空，一个方法不需要任何数据条件，自己就能完成任务，就是无参数

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

2.6方法返回值的有无

有：对于有返回值的方法，可以使用单独调用、打印调用和赋值调用【必须写返回值】

无：但是对于无返回值的方法，只能使用单独调用，不呢个使用打印调用或则赋值调用【必须不写返回值】

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

2.7方法的练习

1，定义一个方法，用来判断两个数字是否相同

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

2，定义一个方法，用来求出1-100的累加和

  1. package JavaRumen.Java04.demo03;
  2. /*
  3. * 定义一个方法，用来求出1-100的累加和
  4. * */
  5. public class Demo02MethodSum {
  6.     public static void main(String[] args) {
  8.         sum1();
  9.         System.out.println("===================");
  11.         System.out.println("1-100的累加和是" + sum2());
  12.     }
  14.     /*
  15.     * 三要素
  16.     * 返回值：有返回值，计算结果是个int
  17.     * 方法名称：getSum
  18.     * 参数列表：数据范围已确定，为固定，不需要数据条件，无参数
  19.     * */
  20.     public static void sum1(){
  21.         int sum = 0;
  22.         for (int i = 1; i <= 100; i++) {
  23.             sum += i;
  24.         }
  25.         System.out.println("1-100的累加和是" + sum);
  26.     }
  28.     public static int sum2(){
  29.         int sum = 0;
  30.         for (int i = 1; i <= 100; i++) {
  31.             sum += i;
  32.         }
  33.         return sum;
  34.     }
  35. }

3，定义一个方法用来打印指定要求的HelloWorld

  1. package JavaRumen.Java04.demo03;
  2. /*
  3. * 题目要求：
  4. * 定义一个方法用来打印指定要求的HelloWorld
  5. * */
  6. public class Demo03MethodPrint {
  7.     public static void main(String[] args) {
  8.         printCount(10);
  9.     }
  11.     /*
  12.     * 三要素：
  13.     * 返回值：只是打印操作，无计算，无结果，不需要返回值
  14.     * 参数名称：printCount
  15.     * 参数列表：打印次数
  16.     * */
  17.     public static void printCount(int num ) {
  18.         for (int i = 1; i <= num; i++) {
  19.             System.out.println("Hello World!" + i);
  20.         }
  21.     }
  22. }

2.8 方法的注意事项

1，方法应该定义在类中，但是不能在方法中再定义方法。不能嵌套

2，方法定义的前后顺序无所谓

3，方法定义之后不会执行，如果希望执行，一定要调用：单独调用、打印调用、赋值调用

4，如果方法有返回值，那么必须写上“return 返回值”，不能没有

5，return后面的返回值数据，必须和方法的返回值类型对应

6，对于一个void没有返回值的方法，不能写return后面的返回值，只能写return自己

7，对于void方法当中的最后一行的return可以省略不写

8，一个方法中可以有多个return语句，但是必须保证同时只有一个return会被执行到，两个return不能连写

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

2.9 方法的重载

概念

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

重载的相关因素

  1. 不同时，可以建立重载

1，参数个体不同

2，参数类型不同

3，参数的多类型顺序不同

重载的无关因素

  1. 不同时，无法建立重载，会报错

1，与参数的名称无关

2，与方法返回值类型无关

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

重载的练习

1，比较两个数据是否相等

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

2，判断哪些方法是重载关系

  1. public static void open(){}
  2. public static void open(int a){}
  3. static void open(int a,int b){}
  4. public static void open(double a,int b){}
  5. public static void open(int a,double b){}
  6. public void open(int i,double d){}
  7. public static void OPEN(){}
  8. public static void open(int i,int j){}
  1. public static void open(){} // 真确重载
  2. public static void open(int a){} // 真确重载
  3. static void open(int a,int b){} // 代码错误 与第8行冲突
  4. public static void open(double a,int b){} // 正确重载
  5. public static void open(int a,double b){} // 代码错误，与第6行冲突
  6. public void open(int i,double d){} // 代码错误，与第5行冲突
  7. public static void OPEN(){} // 代码真确，但不是有效重载
  8. public static void open(int i,int j){} // 代码错误，与第3行冲突

方法重载关系的判断

  1.     方法重载的主要形式有：参数的个体不同、参数的类型不同、参数的顺序不同，与形参变量名和返回值类型无关，但建议返回值类型最好相同
  3.     判断方法是否重载的核心：调用能否区分

3，实现重载的println方法

  1. package JavaRumen.Java04.demo04;
  3. // byte short int long float double char boolean
  4. // String
  5. // 在调用输出语句的时候，println方法其实就是进行了多种数据类型的重载形式
  6. public class Demo04OverloadPrint {
  7.     public static void main(String[] args) {
  8.         myPrint(3.14);
  10.         myPrint("ddd");
  12.         myPrint('3');
  13.     }
  15.     public static void myPrint(byte num) {
  16.         System.out.println(num);
  17.     }
  19.     public static void myPrint(short num) {
  20.         System.out.println(num);
  21.     }
  23.     public static void myPrint(int num) {
  24.         System.out.println(num);
  25.     }
  27.     public static void myPrint(long num) {
  28.         System.out.println(num);
  29.     }
  31.     public static void myPrint(float num) {
  32.         System.out.println(num);
  33.     }
  35.     public static void myPrint(double num) {
  36.         System.out.println(num);
  37.     }
  39.     public static void myPrint(char zifu) {
  40.         System.out.println(zifu);
  41.     }
  43.     public static void myPrint(boolean is) {
  44.         System.out.println(is);
  45.     }
  47.     public static void myPrint(String str) {
  48.         System.out.println(str);
  49.     }
  50. }
  51. // 10.fori 快捷创建10此循环
  52. //