前言

b站java课程学习笔记整理。

b站视频: 黑马程序员全套Java教程_Java基础入门视频教程，零基础小白自学Java必备教程

53. Idea安装

略

54. Idea中的hello world

54.1 初始化

Create new project - Empty project - next - 取名然后finish - ok - Modules - + - new module - Java - 选JDK路径 - 命名- finish - ok

54.2 流程

src中选中src邮件新建package - 输入包的名称 - 选中包右键-新建一个类HelloWorld - 写Helloworld代码 - 右键 run

idea中的hello world

55. Idea中的项目结构

idea中的项目结构
项目 - 模块 - 包 - 类

56. Idea中的快捷键

热键 作用
psvm 快速生成main方法
sout 快速生成输出语句
Ctrl+ Alt+ 空格 内容提示，代码补全
Ctrl+ / 单行注释
Ctrl+ Shift+ / 多行注释
Ctrl+ Alt+ L 缩进格式化，最后代码变得美观

57. Idea中的模块操作

File - Project structure - Modules - 新建就行了。删除直接右键 Remove。

导入模块: File - Project structure - Modules - import module - 选择模块名称 ok

58. 数组定义格式

要存储的数据都是同类型的大量数据，这种情况下用数组存储。

58.1 数组的定义格式

格式如下：

1
2
int[] arr //定义了一个int数组，名为arr
int arr[] //定义了一个int变量，为arr数组

59. 数组初始化之动态初始化

Java中的数组必须先初始化，然后才能使用。所谓的初始化就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。

动态初始化：初始化时指定数组长度，由系统分配数组初始值。
格式如下:

1
int[] arr = new int[3]; // 数据类型[]变量名 = new 数据类型[数组长度];

new表示为数组申请内存空间。

60. 数组元素访问

数组名[索引]， 索引是从零开始，连续的整数。

61. 内存分配

Java程序在运行时，需要在内存中分配空间。为了提高运算效率，就对空间进行了不同区域的划分。因为没一片区域都有特定的处理数据方式和内存管理方式。
arr指向规则

左边是栈内存，右边是堆内存。左边存储局部变量，右边存储new出来的对象。

62. 单个数组内存图

arr单个数组的内存图

63. 多个数组内存图

arr多个数组的内存图

64. 多个数组指向相同的内存图

arr多个数组指向相同的内存图

首先，new生成了一个数组地址，并把这个地址赋值给了arr。然后，把arr赋值给了arr2，也就是说arr2的地址和arr的地址相同，所以改变arr2[0]的值，arr[0]也会变。

65. 数组初始化之静态初始化

静态初始化: 初始化时指定每个数组元素的初始值，由系统决定长度。

格式如下：

1
2
3
4
5
//数据类型[]变量名 = new 数据类型[]{数据1,数据2,数据3, ...};
int[] arr = new int[]{1, 2, 3};
// 简化格式(虽然省略了new但是new的操作还是存在的。)
// 数据类型[]变量名 = {数据1,数据2,数据3, ...};
int[] arr = {1, 2, 3};

66. 数组操作中两个常见小问题

66.1 索引越界

填错了索引。
索引越界

66.2 空指针异常

arr的地址错误。
空指针异常

67. 遍历

用循环。 数组名.length可以获取数组元素的数量。

通用格式:

1
2
3
4
5
6
7
8
public class bianli {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        for (int i = 0; i < arr.length; i++){
            System.out.println("第"+(i+1)+"个元素是"+arr[i]);
        }
    }
}

68. 获取最值

1
2
3
4
5
6
7
8
9
10
11
12
public class zuizhi {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 0, 5, 6, 77, 8, 9};
        int temp = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (temp < arr[i]) {
                temp = arr[i];
            }
        }
        System.out.println("最大值为" + temp);
    }
}

69. 方法概述

其实就是打包成一个自定义function, 这就是方法。方法要先定义，后调用。

70. 方法的定义和调用

定义：

1
2
3
public static void 方法名(){
    //方法体
}

调用:

1
2
方法名();
// 范例：isEvenNumber();

实战，把求最值包装成方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class zuizhi {
    public static void main(String[] args) {
    maxi();
    }
    public static void maxi(){
        int[] arr = {1, 2, 3, 0, 5, 6, 77, 8, 9};
        int temp = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (temp < arr[i]) {
                temp = arr[i];
            }
        }
        System.out.println("最大值为" + temp);
    }
}

71. 方法调用过程

先进main方法，然后发现了maxi()这个方法，然后进入到maxi()里面，然后执行maxi()的内容，执行完后返回main接着执行。

72. 方法的练习

需求：设计一个方法打印两个数中的较大数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class GetMax {
    public static void main(String[] args) {
        getMax();
    }
    public static void getMax(){
        int a =10;
        int b = 20;
        if (a>b){
            System.out.println(a);
        }else {
            System.out.println(b);
        }
    }
}

73. 带参数方法的定义和调用

格式与调用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 格式：public static void 方法名 (数据类型 变量名){...}
public static void isEvenNumber (int number){...}

public static void isEvenNumber (int number1, int number2){...}

// 调用：方法名 (参数);
// 常量调用
isEvenNumber(5);
// 变量调用
int number = 5;
isEvenNumber(number);
//多变量调用
getMax(5 , 6);

参数的数量和类型要匹配。

74. 形参和实参

形参：方法中定义的参数。 实参:方法调用时的参数。
上面是实参。下面是形参

75. 带参数方法练习

需求:设计一个方法用于打印两个数中的较大数，数据来自于方法参数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class exercise {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        getMax(a, b);
    }

    public static void getMax(int Num1, int Num2) {
        if (Num1 > Num2) {
            System.out.println(Num1);
        } else {
            System.out.println(Num2);
        }
    }
}

76. 带返回值方法的定义和调用

格式：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 定义
/*    public static 数据类型  方法名(参数){
        return 数据
    }*/
    
public class notebook {
    // 定义布尔值返回
    public static boolean isEvenNumber(int number){
        return true;
    }
}

// 调用
// 数据类型 变量名 = 方法名(参数);
boolean flag = isEvenNumber(5);

返回时注意返回数据和定义返回值的类型要匹配。返回值要定义一个变量来接受。

77. 带返回值方法的练习

需求：设计一个方法可以获取两个数的较大值，数据来自于参数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package 带返回值的方法练习;

public class exercise {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(getMax(a, b));
    }

    public static int getMax(int Num1, int Num2) {
        if (Num1 > Num2) {
            return Num1;
        } else {
            return Num2;
        }
    }
}

78. 方法的注意事项

  1. 方法不能嵌套定义。方法里面不能定义方法。

  2. void表示无返回值。如果写return，return后面不能写东西。

  3. return表示方法结束了，后面不能写代码。

79. 方法的通用格式

通用格式：

1
2
3
4
5
6
/*
public static 返回值类型 方法名（参数）{
    方法体;
    return 数据;
        }*/
// public static 修饰符，目前先记住这个格式。

定义方法时，要做到两个明确：

  1. 明确返回值类型：主要是明确方法操作完毕之后是否有数据返回，如果没有，写void；如果有，写对应的数据类型。

  2. 明确参数：主要是明确参数的类型和数量。

80. 方法重载

方法重载指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载：

  1. 多个方法再同一个类中。
  2. 多个方法具有相同的方法名。
  3. 多个方法的参数不相同，类型不同或者数量不同。

注意:

  1. 重载就看方法名称和参数就行，和返回值与返回值类型无关。
  2. 重载与方法的调用无关。

方法重载特点

项目：定义一个求和的方法，要求方法重载。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package 方法重载;

public class chongzai {
    public static void main(String[] args) {
    // 调用
        int result = sum(10,20,30);
        System.out.println(result);
    }
    // 需求1： 求两个int类型数据和
    public static int sum(int num1, int num2){
        return num1 + num2;
    }
    // 需求2： 求两个double类型数据和
    public static double sum(double num1, double num2){
        return num1 + num2;
    }
    // 需求3： 求三个int类型数据和
    public static int sum(int num1, int num2 , int num3 ){
        return num1 + num2 + num3;
    }
}

总结:方法重载实际上就是通过合体的方法让方法功能更强大。在调用的时候，java虚拟机会通过参数来区分同名的方法。

81. 方法重载的练习

需求： 使用方法重载的思想，设计比较两个整数是否相同的方法，兼容全整数类型(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
22
23
24
25
26
27
package 方法重载;

public class exercise {
    public static void main(String[] args) {
        System.out.println(isSame((byte)10, (byte)20));
        System.out.println(isSame((short)10, (short)20));
        System.out.println(isSame(10, 20));
        System.out.println(isSame(10L, 20L));
    }
    public static boolean isSame(byte a, byte b){
        System.out.println("byte:");
        return a == b;
    }
    public static boolean isSame(short a, short b){
        System.out.println("boolean:");
        return a == b;
    }
    public static boolean isSame(int a, int b){
        System.out.println("int:");
        return a == b;
    }
    public static boolean isSame(long a, long b){
        System.out.println("long:");
        return a == b;
    }
}

总结: 大转小，要注意使用强转。

82. 方法的参数传递

形参number=200 的改变是在栈中change()的块中进行的，不会影响在栈中实参number = 100。
方法参数传递的基本类型

83. 方法的参数传递

栈内存中change()方法通过访问arr[1]进入堆内存，改变了堆内存中数组的某元素的值。在之后栈内存的main方法访问这个元素时，元素的值已经发生了改变。
方法参数传递的引申

84. 数组遍历

需求：设计一个方法用于数组遍历，要求遍历的结果是在一行上的。例如[11,22,33,44,55]。
小知识:

1
2
3
System.out.println("a"); // 输出，并换行。
System.out.print("a"); // 输出，不换行
System.out.println(); // 直接换行

具体的作业代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package 数组遍历;

public class bianli {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5};
        bianli(array);
    }
    public static void bianli(int[] arr){
        System.out.print("[");
        for(int i = 0 ; i < arr.length; i++ ){
            System.out.print(arr[i]);
            if (i != arr.length-1){
                System.out.print(",");
            }
        }
        System.out.print("]");
    }
}

个人认为思路比老师的简单一点。

85. 案例：数组最大值

需求：设计一个方法用于获取数组中元素的最大值，调用方法并输出结果。

代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package 数组最大值;

public class getMax {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 55, 8};
        System.out.println(getMax(array));
    }
    public static int getMax(int[] arr){
        int temp = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (temp < arr[i]) {
                temp = arr[i];
            }
        }
        return temp;
    }
}

86. Debug使用

  1. step into：单步执行，遇到子函数就进入并且继续单步执行（简而言之，进入子函数）；

  2. step over：在单步执行时，在函数内遇到子函数时不会进入子函数内单步执行，而是将子函数整个执行完再停止，也就是把子函数整个作为一步。有一点,经过我们简单的调试,在不存在子函数的情况下是和step into效果一样的（简而言之，越过子函数，但子函数会执行）。

  3. step out：当单步执行到子函数内时，用step out就可以执行完子函数余下部分，并返回到上一层函数

(转自单步调试 step into/step out/step over 区别)

87. Debug查看偶数求和

一个小练习，不记了。

88. Debug查看方法调用

如果数据来自键盘输入，输入后debug继续。

89. 减肥计划if版

需求： 输入星期数，显示今天的减肥活动（用if）。

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
package 减肥计划;
import java.util.Scanner;
public class ifversion {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int day = sc.nextInt();
        ifversion(day);
    }

    public static void ifversion(int day){
        if (day == 1){
            System.out.println("跑步");
        }else if(day == 2){
            System.out.println("游泳");
        }else if(day == 3){
            System.out.println("慢走");
        }else if(day == 4){
            System.out.println("动感单车");
        }else if(day == 5){
            System.out.println("拳击");
        }else if(day == 6){
            System.out.println("爬山");
        }else if(day == 7){
            System.out.println("好好吃一顿");
        }else{
            System.out.println("输入日期有误");
        }
    }
}

一分钟搞定！

90. 减肥计划switch版

用switch写一遍。

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
34
35
36
package 减肥计划;
import java.util.Scanner;
public class SwitchVersion {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int day = sc.nextInt();
        SwitchVersion(day);
    }
    public static void SwitchVersion(int day){
        switch (day){
            case 1:
                System.out.println("跑步");
                break;
            case 2:
                System.out.println("游泳");
                break;
            case 3:
                System.out.println("动感单车");
                break;
            case 4:
                System.out.println("拳击");
                break;
            case 5:
                System.out.println("爬山");
                break;
            case 6:
                System.out.println("慢走");
                break;
            case 7:
                System.out.println("好好吃一顿");
                break;
            default:
                System.out.println("输入有误");
        }
    }
}

快捷键导包: Alt + Enter

91. 逢七过

案例：包含7或者是7的倍数。打印1-100之间需要过的数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package 逢七过;

public class SevenPass {
    public static void main(String[] args) {
        SevenPass();
    }

    public static void SevenPass() {
        for (int i = 1; i < 101; i++) {
            if (i % 7 == 0 || i % 10 == 7 || i /10 %10 == 7 ){
                System.out.println(i);
            }
        }
    }
}

92. 不死神兔

需求：有一对兔子，从出生后第3个月其每个月都生一对兔子，小兔子长到第三个月后又生一对兔子，假如兔子都不死，问第二十个月的兔子的对数是多少？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package 不死神兔;

public class rabbit {
    public static void main(String[] args) {
        int rabbits = 1;
        int result = rabbit(rabbits);
        System.out.println("第二十天的兔子数量是" + result);
    }

    public static int rabbit(int num) {
        int[] arr = new int[20];
        arr[0] = num;
        arr[1] = num;
        for (int i = 2; i < arr.length; i++) {
            arr[i] = arr[i - 1] + arr[i - 2];
        }
        return arr[19];
    }
}

92. 案例:百钱百鸡

案例: 公鸡五块钱，母鸡三块钱，小鸡一块钱三只。如何用一百块钱买一百只鸡?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package 百钱百鸡;

public class chicken {
    public static void main(String[] args) {
        chicken();
    }
    
    public static void chicken() {
        for (int x = 0; x <= 20; x++) {
            for (int y = 0; y <= 33; y++) {
                for (int z = 0; z <= 100; z++) {
                    if (z % 3 == 0) {
                        if (x + y + z == 100 && 5 * x + 3 * y + z / 3 == 100) {
                            System.out.print(x + ",");
                            System.out.print(y + ",");
                            System.out.print(z + ",");
                            System.out.println();
                        }
                    }
                }
            }
        }
    }
}

总结:注意去除z不是3倍数的时候！否则z/3会生成错误数。