Java入门-学习黑马程序员Java基础视频教程（更新ing）

目录

• P0：写在前面的小知识
• P3：Java环境搭建: JDK安装、常用命令
• P4：入门程序HelloWorld
• P7：补充知识：JDK组成、跨平台原理
• P8：补充知识：JDK安装后Path和JAVA_HOME环境变量
• P9：IDEA开发工具：简介、下载、安装
• P10：IDEA开发工具：开发第一个程序
• P11：IDEA开发工具：字体、快捷键、其他操作
• • P11.1 导入模块
  • P11.2 删除模块
  • P11.3 重命名模块
• P13：基础语法：注释
• P14：字面量
• P15-17：变量
• P19：基础语法：数据类型
• P20：基础语法：关键字、标识符
• P23：类型转换：自动类型转换
• P24：类型转换：表达式的自动类型转换
• P25：类型转换：强制类型转换
• P26：运算符：基本的算术运算符
• P28：运算符：加符号做连接符
• P29：运算符：自增、自减
• P31：运算符：赋值运算符
• P32：运算符：关系运算符
• P33：运算符：逻辑运算符
• P34：运算符：三元运算符
• P36：运算符：优先级问题
• P37：API介绍、案例技术：键盘录入
• P39：程序流程控制课程介绍
• P40：分支结构：if、switch
• P41：循环结构：for循环、求和、水仙花数
• P42：循环结构：while循环、珠穆朗玛峰案例
• P43：循环结构：do-while循环、三种循环的总结
• P44：死循环、循环嵌套、break、continue
• P45：案例技术：Random类，猜数字游戏
• P47：数组概述
• P48：（静态）数组定义方式一、访问、注意事项（静态数组）
• P49：（动态）数组定义方式二、元素默认值规则
• P50：数组遍历、元素求和
• P51：数组案例：求最值、猜数字、随机排名、冒泡排序
• P52：数组内存图、常见使用问题
• P53：补充知识：Debug工具
• P54：数组总结
• P56：方法定义格式、常见问题
• P57：方法案例：求和、判断奇偶数、求最值
• P59：方法参数传递机制：值传递
• P60：方法参数传递的案例
• P61：方法重载、return关键字
• P63：编程训练案例1：买飞机票
• P64：案例2：找素数
• P65：案例3：开发验证码
• P66：案例4：数组的复制
• P67：案例5：评委打分
• P68：案例6：数字加密
• P69：案例7：双色球系统开发
• P72：面向对象：设计对象、注意事项
• P72：面向对象：内存机制
• P73：面向对象实战：购物车案例
• P74：面型对象：构造器、this
• P75：面向对象：封装
• P76：面向对象：Javabean、综合实例



学习！！！2022黑马程序员Java学习路线图，好像跟菜鸟教程挺一致的：Java 教程 | 菜鸟教程。

黑马是真良心！视频中出现的资料全都分享了出来的！

领取方式：关注微信公众号：黑马程序员，回复关键词：领取资源02

在这个博客中黑马程序员Java基础视频教程-课程总结文档，我将徐磊老师写的xmind转为了图片方便观看。



P0：写在前面的小知识

面向对象的三大特征：封装、继承、多态

1.给module取名字

2.命名方法：都采用驼峰法，但是类名首字母要大写，普通变量首字母小写。

3.代码快速补充的书写技巧

• 数组遍历：arr.fori + 回车
• 与上同理，若已知一个数值变量len，则len.fori + 回车也可快速生成 i < l e n i
• 打印：sout + 回车 出现 System.out.println();
• 打印某个确定值："Hello".sout + 回车 出现 System.out.println(“Hello”);
• 如果要将某一个代码块变到 for 循环里去，则选中该代码块，再按下快捷键Ctrl+Alt+T，再选择for即可

4.内存位置

• 方法、临时变量都是在栈空间
• new出来的对象在堆空间
• Java存在自动垃圾回收器，会定期进行清理 堆内存。
• 数组、对象直接复制的话都是复制的地址，届时无论更改arr1还是arr2都会同步更改。
• this关键字代表当前对象的地址，与 Car c = new Car() 中的 c 一样，都是代表当前对象的地址

5.特殊字符，A=65，a=97，英文字母个数为26

P3：Java环境搭建: JDK安装、常用命令

• Oracle官网

• Java 18 and Java 17的下载地址（老师建议新手先下载JDK17，比较稳定）

在cmd中依次输入java和javac没有报错就表示安装成功。

查看版本号方法：输入java -version和javac -version即可。版本号：javac 17.0.3.1

P4：入门程序HelloWorld

public class HelloWorld{
	public static void main(String[] args){
		System.out.println("Hello World!");
	}
}

注意：当JDK ≥ 11时，可以直接键入java HelloWorld.java执行生成结果，它会自动生成一个临时、但我们看不见的.class文件去执行。

P7：补充知识：JDK组成、跨平台原理
P8：补充知识：JDK安装后Path和JAVA_HOME环境变量

(1) 配置java、javac环境变量

还是跟着老师的步骤，将JDK17自动加的环境变量给删了，然后手动又加入了JDK17下的bin路径。

(2) 配置JAVA_HOME环境变量

较新版的JDK只在Path中自动配置了java和javac，没有自动配置JAVA_HOME。

P9：IDEA开发工具：简介、下载、安装

官网下载地址：点击进去下载

可能有用的激活链接：Intellij IDEA 2021.2.3 最新版免费激活教程（可激活至 2099 年，亲测有效）

P10：IDEA开发工具：开发第一个程序
P11：IDEA开发工具：字体、快捷键、其他操作 P11.1 导入模块

(1) 直接导入已有模块

直接导入module存在的问题：如果直接导入的module路径不是此项目路径，则将来如果误删了此module文件夹，再使用此工程会出错（因为找不到此module了）

(2) 新建模块，再将模块的src子文件夹内容复制新模块的src中

step1：新建模块取名为 new-app2，然后会自动生成 new-app2 文件夹，包含了 src子文件夹 和 new-app2.iml 文件

step2：将待导入的模块 app2 里面的 src 文件夹中所有内容复制到 new-app2 的 src子文件 中。

P11.2 删除模块

删除之前：（第一张图的查看位置在D:Ideaworkspacejavasepro.ideamodules.xml）

彻底删除 app2模块 的步骤：

1.Remove Module用于在项目工程中删除该模块，并且在modules.xml也删除

2.在工程文件夹中，删除app2模块文件夹

P11.3 重命名模块

按下Shift + F6，会出现3个选项，选择第3个，会同时更改模块名+文件夹名

P13：基础语法：注释

P14：字面量

P15-17：变量

P19：基础语法：数据类型

P20：基础语法：关键字、标识符

P23：类型转换：自动类型转换

P24：类型转换：表达式的自动类型转换

byte i = 1;
byte j = 2;
int res = i + j;	

P25：类型转换：强制类型转换

P26：运算符：基本的算术运算符

P28：运算符：加符号做连接符

P29：运算符：自增、自减

P31：运算符：赋值运算符

P32：运算符：关系运算符

P33：运算符：逻辑运算符

常用的是&&、||、!

P34：运算符：三元运算符

P36：运算符：优先级问题

P37：API介绍、案例技术：键盘录入

• sc.nextInet() 等待录入整数
• sc.next() 等待录入字符串

P39：程序流程控制课程介绍

P40：分支结构：if、switch

不支持double、float是因为java中对浮点数的值往往表示并不精确，比如有时候1.3会表示成1.29999999。

switch的穿透性使用：

P41：循环结构：for循环、求和、水仙花数

巧妙使用 i+=2 求 1~10之间的奇数和

public class LoopDemo {
    public static void main(String[] args) {
        // 求1-10之间的奇数和 1+3+5+7+9=25
        int sum = 0;
        for (int i = 1; i <= 10; i += 2){
            sum += i;
        }
        System.out.println("sum = " + sum);
    }
}

求水仙花数以及个数

package com.itheima.loop;

public class LoopDemo2 {
    public static void main(String[] args) {
        
        int x, y, z, sum, cnt = 0;    // 个十百，立方和
        for (int i = 100; i < 1000; i++) {
            x = i / 100;
            y = i / 10 % 10;
            z = i % 10;
            sum = x * x * x + y * y * y + z * z * z;
            if (sum == i) {
                cnt++;
                System.out.print(i + "t");
            }
        }
        System.out.println("n水仙花个数为：" + cnt);
    }
}

P42：循环结构：while循环、珠穆朗玛峰案例

package com.itheima.loop;

public class WhileDemo {
    public static void main(String[] args) {
        
        int high = 8848860 * 10, i = 1, cnt = 0;
        while (i < high) {
            i *= 2;
            cnt++;
        }
        System.out.println("需要折叠次数为：" + cnt);
        System.out.println("折叠厚度为：" + i * 0.1);
    }
}

P43：循环结构：do-while循环、三种循环的总结

P44：死循环、循环嵌套、break、continue

P45：案例技术：Random类，猜数字游戏

重要内容：

• 学会用减加法求得[65,91]之间的随机数
• 生成[min,max]范围内随机整数的通用公式为： n = r a n d . n e x t I n t ( m a x − m i n + 1 ) + m i n n=rand.nextInt(max-min+1)+min n=rand.nextInt(max−min+1)+min

package com.itheima.random;

import java.util.Random;
import java.util.Scanner;

public class GuessNumber {
    public static void main(String[] args) {
        int answer, user;
        Random r = new Random();
        Scanner sc = new Scanner(System.in);
        answer = r.nextInt(100) + 1;
        System.out.println(answer);
        while (true) {
            System.out.print("请您输入猜测的答案：");
            user = sc.nextInt();
            if (user > answer) {
                System.out.println("猜测过大！");
            } else if (user < answer) {
                System.out.println("猜测过小！");
            } else {
                System.out.println("恭喜您猜对啦！正确答案为：" + answer);
                break;
            }
        }
    }
}

P47：数组概述

P48：（静态）数组定义方式一、访问、注意事项（静态数组）

重要内容：

• 创建静态数组的方式：
  • 完整格式：double[] score = new double[] {98.5, 90, 89.5};
  • 简写格式：double[] score = {98.5, 90, 89.5};（常用）
• 注意：数组变量名中存储的是数组在内存中的地址，数组是引用类型。
• 访问：arr[index]，即数组名称[索引]
• 赋值：arr[index] = data
• 数组的长度属性：arr.length
• 索引范围：index ~ [0, length-1]，前提是元素个数>0
• 注意事项：
  • 数据类型[] 数组名也可以写成数据类型 数组名[]，即int[] arr <=> int arr[]，但是更常用的是第一种int[] arr
  • 什么类型的数组存放什么类型的数据，否则会报错
  • 数组一旦定义出来，程序执行过程中，长度、类型就固定了，不可再更改。

P49：（动态）数组定义方式二、元素默认值规则

主要内容：

• 先定义（确定好数组长度），后赋值（默认值为0、0.0、false、null）
• 创建方式：int[] arr = new int[3]; // arr = {0, 0, 0}

P50：数组遍历、元素求和

主要内容：

• 数组遍历的快捷键：arr.fori + enter

P51：数组案例：求最值、猜数字、随机排名、冒泡排序

求和、最大值 + 猜数字：

package com.itheima.traverse;

import java.util.Random;
import java.util.Scanner;

public class ArrayTraverse {
    public static void main(String[] args) {
        int[] money = {16, 26, 36, 6, 100};
        //求和 + 求最值
        int sum = 0, max = 0;
        for (int i = 0; i < money.length; i++) {
            sum += money[i];

            if (money[i] > max) {
                max = money[i];
            }
        }
        System.out.println("sum = " + sum);
        System.out.println("max = " + max);

        // 猜数字
        Random r = new Random();
        Scanner sc = new Scanner(System.in);
        int[] nums = new int[5];
        int num;
        boolean flag = false;
        for (int i = 0; i < 5; i++) {
            nums[i] = r.nextInt(20) + 1;    // [1, 20]
        }

        while (!flag) {
            System.out.print("请输入一个数字：");
            num = sc.nextInt();
            for (int i = 0; i < nums.length; i++) {
                if (num == nums[i]) {
                    System.out.println("运气不错，猜中了！");
                    System.out.println(num + "第一次出现的位置是：" + (i + 1));
                    for (int i1 = 0; i1 < nums.length; i1++) {
                        System.out.print(nums[i1] + "t");
                    }
                    flag = true;
                    break;
                }
            }
            if (!flag) {
                System.out.println("未命中！请继续！");
            }
        }
    }
}

哈哈哈，说不清楚我这个是种什么排序，但是结果也是正确的，确实没有进行相邻位置排序交换，感觉是每次小循环就确定了大循环下标 i 处的元素值。

package com.itheima.traverse;

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {3, 6, 2, 13, 20, 7};
        int temp;   // 从大到小排序
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = i + 1; j < arr.length; j++){
                if(arr[i] < arr[j]){
                    temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }

        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }

    }
}

这个才是冒泡排序原始版，从i=0开始（面试时也一般是从0开始）

//按照刚才那个动图进行对应
//冒泡排序两两比较的元素是没有被排序过的元素--->
public void bubbleSort(int[] array){
    for(int i=0;i//控制比较轮次，一共 n-1 趟
        for(int j=0;j//控制两个挨着的元素进行比较
            if(array[j] > array[j+1]){
                int temp = array[j];
                array[j] = array[j+1];
                array[j+1] = temp;
            }
        }
    }
}

老师的冒泡排序，从i=1开始（也需要注意）

public void bubbleSort(int[] array){
    for(int i=1;i<=array.length-1;i++){//控制比较轮次，一共 n-1 趟
        for(int j=0;j//控制两个挨着的元素进行比较
            if(array[j] > array[j+1]){
                int temp = array[j];
                array[j] = array[j+1];
                array[j+1] = temp;
            }
        }
    }
}

P52：数组内存图、常见使用问题

P53：补充知识：Debug工具

这个跟PyCharm是一个厂家的吧？好i像是JetBrains？所以软件布局和一些快捷键、布局设置。

之前写过一个关于PyCharm的调试方式，跟这个是一样的。∴可供参考：PyCharm的Debug和中断方法

P54：数组总结

在这个博客中黑马程序员Java基础视频教程-课程总结文档

P56：方法定义格式、常见问题

方法就是函数

• 方法不需要返回结果，则申明返回值类型为void；方法不需要参数,则形参列表可以不写。
• 方法没有申明返回值类型，内部不能使用 return 返回数据。
• 自定义方法可相互调用，不在乎顺序

P57：方法案例：求和、判断奇偶数、求最值

package com.itheima.method;

public class MethodDemo2 {
    public static void main(String[] args) {
        System.out.println(sum(2));
        isOdd(3);
        int[] arr = {5, 1, 8, 2, 9};
        System.out.println(max(arr));

    }

    // 求1-n的总和
    public static int sum(int n) {
        int res = 1;
        for (int i = 2; i <= n; i++) {
            res += i;
        }
        return res;
    }

    // 判断该数是奇数还是偶数
    public static void isOdd(int x) {
        if (x % 2 == 0) {
            System.out.println(x + "是偶数");
        } else {
            System.out.println(x + "是奇数");
        }
    }

    // 求任意整型数组的最大值
    public static int max(int[] arr) {
        int maximum = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > maximum) {
                maximum = arr[i];
            }
        }
        return maximum;
    }

}

P59：方法参数传递机制：值传递

P60：方法参数传递的案例

	// 按照格式打印 -> 该数组内容为：[5, 1, 8, 2, 9]
    public static void print(int[] arr) {
        System.out.print("该数组内容为：[");
        if (arr != null && arr.length > 0) {
            for (int i = 0; i < arr.length; i++) {
                System.out.print(i != arr.length - 1 ? arr[i] + ", " : arr[i]);
            }
        }
        System.out.print("]n");
    }

    // 查找num在arr中的第一个位置并返回下标
    public static int findIndex(int[] arr, int num) {
        if (arr != null && arr.length > 0) {
            for (int i = 0; i < arr.length; i++) {
                if (num == arr[i]) {
                    return i;
                }
            }
        } else {
            System.out.println("arr is empty.");
        }
        return -1;
    }

    // 比较两个数组内容是否一样
    public static boolean isSame(int[] arr1, int[] arr2){
        if(arr1 == null || arr2 == null || arr1.length != arr2.length){
            System.out.println("arr1 == null || arr2 == null || arr1.length != arr2.length");
            return false;
        }else{
            for (int i = 0; i < arr1.length; i++) {
                if(arr1[i] != arr2[i]){
                    return false;
                }
            }
        }
        System.out.println("arr1与arr2的内容相同");
        return true;
    }

P61：方法重载、return关键字

同一个类中，出现多个方法名称相同，但是形参列表是不同的，那么这些方法就是重载方法。

P63：编程训练案例1：买飞机票

package com.itheima.practice;

import java.util.Scanner;

public class BuyPlaneTicket {
    public static void main(String[] args) {
        // 用户输入机票原价、月份、头等舱or经济舱
        Scanner sc = new Scanner(System.in);

        System.out.print("请输入机票原价：");
        int money = sc.nextInt();
        while (money <= 0){
            System.out.print("机票原价不能为非正数，请重新输入：");
            money = sc.nextInt();
        }

        System.out.print("请输入月份(1-12)：");
        int month = sc.nextInt();
        while (month < 1 || month > 12) {
            System.out.print("月份输入有误，请重新输入(1-12)：");
            month = sc.nextInt();
        }

        System.out.print("请输入仓位(头等舱0，经济舱1)：");
        int top = sc.nextInt();
        while (top != 0 && top != 1){
            System.out.print("选择头等舱或经济舱的输入有误，请重新输入0或1：");
            top = sc.nextInt();
        }

        System.out.println("您最终的机票优惠价格是：" + discount(money, month, top));
    }

    public static double discount(int money, int month, int top) {
        double lastMoney = 0;
        switch (top) {
            case 0: //头等舱
                if (month >= 5 && month <= 10) {
                    lastMoney = money * 0.9;
                } else {
                    lastMoney = money * 0.7;
                }
                break;
            case 1: //经济舱
                if (month >= 5 && month <= 10) {
                    lastMoney = money * 0.85;
                } else {
                    lastMoney = money * 0.65;
                }
                break;
        }

        return lastMoney;
    }
}

P64：案例2：找素数

素数：曾称质数。一个大于1的正整数，如果除了1和它本身以外，不能被其他正整数整除，就叫素数。

来自于一道编程题：
判断 101~200 之间有多少个素数，并输出所有素数

package com.itheima.practice;

public class FindPrimeNum {
    public static void main(String[] args) {
        int a = 101, b = 200;
        System.out.println("n" + a + "~" + b + "之间的素数个数为：" + findPrime(a, b));
    }

    public static int findPrime(int a, int b){
        int cnt = 0;
        if (a <= b){
            boolean flag;
            for (int i = a; i <= b; i++) {
                flag = true;
                for (int j = 2; j <= i / 2; j++) {
                    if (i % j == 0){    // 能除尽，则表示不是素数
                        flag = false;
                        break;
                    }
                }
                if(flag){
                    cnt++;
                    System.out.print(i + "t");
                }
            }
        }
        return cnt;
    }
}

P65：案例3：开发验证码

package com.itheima.practice;

import java.util.Random;
import java.util.Scanner;

public class Test3 {
    public static void main(String[] args) {
        System.out.print("请输入验证码长度：");
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        System.out.println("n生成的验证码为：" + createCode(n));
    }

    public static String createCode(int n){
        String code = "";
        Random r = new Random();
        for (int i = 0; i < n; i++) {
            int type = r.nextInt(3);
            switch (type){
                case 0: //大写字符
                    char ch = (char) (r.nextInt(26) + 65);
                    code += ch;
                    break;
                case 1: //小写字符
                    ch = (char) (r.nextInt(26) + 97);
                    code += ch;
                    break;
                case 2: //数字
                    code += r.nextInt(10);
            }
        }
        return code;
    }
}

P66：案例4：数组的复制

package com.itheima.practice;

public class CopyArray {
    public static void main(String[] args) {
        int[] arr1 = {1, 2, 3, 4, 5};
        int[] arr2 = new int[arr1.length];
        copyArray(arr1, arr2);

        System.out.println("-----------遍历输出arr1数组元素------------");
        print(arr1);

        System.out.println("-----------遍历输出arr2数组元素------------");
        print(arr2);
    }

    public static void print(int[] arr) {
        System.out.print("arr = [");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(i == arr.length - 1 ? arr[i] : arr[i] + ", ");
        }
        System.out.println("]");
    }

    public static void copyArray(int[] arr1, int[] arr2) {
        if (arr1 == null || arr2 == null || arr1.length != arr2.length) {
            System.out.println("arr1 == null || arr2 == null || arr1.length != arr2.length");
        } else {
            for (int i = 0; i < arr1.length; i++) {
                arr2[i] = arr1[i];
            }
        }
    }
}

P67：案例5：评委打分

package com.itheima.practice;

import java.util.Scanner;

public class Test5 {
    public static void main(String[] args) {
        System.out.println("请6位评委依次打分：");
        Scanner sc = new Scanner(System.in);
        int[] scores = new int[6];
        for (int i = 0; i < 6; i++) {
            scores[i] = sc.nextInt();
        }

        // 求出最后的除去最高最低分的平均得分
        System.out.println("最终得分为：" + meanScore(scores));
    }

    public static double meanScore(int[] arr) {
        double sum = arr[0];
        int min = arr[0], max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] < min) {
                min = arr[i];
            }
            if (arr[i] > max) {
                max = arr[i];
            }
            sum += arr[i];
        }
        System.out.println("最高分是：" + max);
        System.out.println("最低分是：" + min);
        return (sum - max - min) / (arr.length - 2);
    }
}

P68：案例6：数字加密

同样操作，对 code -> encode 再 encode 就可恢复原状code（解密）

package com.itheima.practice;

import java.util.Scanner;

public class Test6 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入待加密的数字长度：");
        int n = sc.nextInt();
        int[] code = new int[n];

        System.out.println("n请输入待加密数字：");
        for (int i = 0; i < n; i++) {
            code[i] = sc.nextInt();
        }

        System.out.println("加密前：");
        print(code);

        // 开始加密并打印加密结果
        System.out.println("加密后：");
        encode(code);
        print(code);

    }

    public static void print(int[] arr){
        System.out.print("arr = [");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(i == arr.length - 1 ? arr[i] : arr[i] + ", ");
        }
        System.out.println("]");
    }

    public static void encode(int[] arr){
        int temp, len = arr.length;
        // for(int i = 0, j = len - 1; i < j; i++, j--) 也可以写成这样
        for (int i = 0; i < len / 2; i++) {
            temp = arr[i];
            arr[i] = (arr[len - 1 - i] + 5) % 10;
            arr[len - 1 - i] = (temp + 5) % 10;
        }
    }
}

P69：案例7：双色球系统开发

package com.itheima.practice;

import java.util.Random;
import java.util.Scanner;

public class Test7 {
    public static void main(String[] args) {
        int[] luckyNumbers = createLuckyNumbers();
        int[] userNumbers = userInputNumbers();

        System.out.println("中奖号码是：");
        print(luckyNumbers);

        System.out.println("您的投注号码是：");
        print(userNumbers);

        judge(luckyNumbers, userNumbers);
    }

    public static void print(int[] arr) {
        System.out.print("arr = [");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(i == arr.length - 1 ? arr[i] : arr[i] + ", ");
        }
        System.out.println("]");
    }

    public static int[] createLuckyNumbers() {
        // 共7个数字，红色6个1~33，蓝色1个1~16
        int[] arr = new int[7];
        Random r = new Random();
        int data;
        boolean flag;

        // 生成6个不重复的随机红色球数字
        for (int i = 0; i < arr.length - 1; i++) {
            flag = true;
            while (true) {
                data = r.nextInt(33) + 1;
                for (int j = 0; j < i; j++) {
                    if (data == arr[j]){
                        flag = false;
                        break;
                    }
                }
                if (flag) {
                    arr[i] = data;
                    break;
                }
            }
        }

        // 随机生成一个蓝色球数字
        arr[arr.length - 1] = r.nextInt(16) + 1;
        return arr;
    }

    public static int[] userInputNumbers(){
        int[] arr = new int[7];
        Scanner sc = new Scanner(System.in);
        int data;
        boolean flag;
        for (int i = 0; i < arr.length - 1; i++) {
            System.out.print("请输入第" + (i + 1) + "个红球数字(1-33,不能重复)：");
            while (true){
                flag = true;
                data = sc.nextInt();

                for (int j = 0; j < i; j++) {
                    if(arr[j] == data){
                        flag = false;
                        break;
                    }
                }

                if(flag && data >= 1 && data <= 33){
                    arr[i] = data;
                    break;
                }
                System.out.print("请重新输入第" + (i + 1) + "个红球数字：");
            }
        }

        System.out.print("请输入蓝球数字(1-16)：");
        arr[arr.length - 1] = sc.nextInt();
        return arr;
    }

    public static void judge(int[] arr1, int[] arr2){
        int red = 0, blue;
        for (int i = 0; i < arr1.length - 1; i++) {
            for (int j = 0; j < arr2.length - 1; j++) {
                if(arr1[i] == arr2[j]){
                    red++;
                    break;
                }
            }
        }
        blue = arr1[arr1.length - 1] == arr2[arr2.length - 1] ? 1 : 0;
        
        System.out.println("您命中的红球个数：" + red);
        System.out.println("您命中的蓝球个数：" + blue);

        if(blue == 1 && red < 3){
            System.out.println("恭喜中了5元！");
        }else if(blue == 1 && red == 3 || blue == 0 && red == 4){
            System.out.println("恭喜中了10元！");
        }else if(blue == 1 && red == 4 || blue == 0 && red == 5){
            System.out.println("恭喜中了200元！");
        }else if(blue == 1 && red == 5){
            System.out.println("恭喜中了3000元！");
        }else if(blue == 0 && red == 6){
            System.out.println("恭喜中了500万元！");
        }else if(blue == 1 && red == 6){
            System.out.println("恭喜中了1000万元！");
        }else{
            System.out.println("谢谢您为福利彩票事业做出的贡献！");
        }
    }
}

P72：面向对象：设计对象、注意事项

P72：面向对象：内存机制

• Java存在自动垃圾回收器，会定期进行清理 堆内存。
• 数组、对象直接复制的话都是复制的地址，届时无论更改arr1还是arr2都会同步更改。

P73：面向对象实战：购物车案例

Goods.java 文件内容：

package com.lwd;

public class Goods {
    int id;
    String name;
    double price;
    int buyNum;

    public void show(){
        System.out.println("编号tt名称tt价格tt数量");
        System.out.println(id + "tt" + name + "tt" + price + "tt" + buyNum);
    }

}

GoodsMain.java 文件内容：

package com.lwd;

import java.util.Scanner;

public class GoodsMain {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int maxLen = 20, len = 0;    // 记录数组有效值长度，同时也是可插入下标
        Goods[] goods = new Goods[maxLen];

        while (true) {
            System.out.println("-------------菜单------------");
            System.out.println("添加商品：add");
            System.out.println("查看商品：query");
            System.out.println("修改数量：update");
            System.out.println("结算价格：pay");
            System.out.println("退出：exit");
            System.out.println("-----------------------------");

            System.out.print("请您选择要操作的功能：");
            String op = sc.next();

            switch (op) {
                case "add":
                    if (len < maxLen) {
                        addGoods(goods, len, sc);
                        len++;
                    } else {
                        System.out.println("购物车已满！不能再添加！");
                    }
                    break;
                case "query":
                    if (len <= 0) {
                        System.out.println("您的购物车为空，请先添加商品！");
                    } else {
                        queryGoods(goods, len);
                    }
                    break;
                case "update":
                    if (len <= 0) {
                        System.out.println("您的购物车为空，请先添加商品！");
                    } else {
                        System.out.print("请输入您待修改数量的编号：");
                        int id = sc.nextInt();
                        updateGoods(goods, len, id, sc);
                    }
                    break;
                case "pay":
                    if (len <= 0) {
                        System.out.println("您的购物车为空，请先添加商品！");
                    } else {
                        payGoods(goods, len);
                    }
                    break;
                case "exit":
                    System.out.println("您已退出！");
                    return;
                default:
                    System.out.println("您的选择有误，请重新选择操作！");
            }
        }

    }

    public static void payGoods(Goods[] goods, int len) {
        System.out.println("-------------结算pay------------");
        System.out.println("编号tt名称tt价格tt数量");

        double sum = 0;
        for (int i = 0; i < len; i++) {
            System.out.println(goods[i].id + "tt" + goods[i].name + "tt" + goods[i].price + "tt" + goods[i].buyNum);
            sum += (goods[i].price * goods[i].buyNum);
        }
        System.out.println("总金额是：" + sum);

        System.out.println("--------------------------------");
    }

    public static void updateGoods(Goods[] goods, int len, int id, Scanner sc) {
        System.out.println("-------------修改商品update------------");

        int i;
        for (i = 0; i < len; i++) {
            if (goods[i].id == id) {
                break;
            }
        }
        if (i == len) {
            System.out.println("购物车中没有该编号的商品！");
        } else {
            goods[i].show();

            System.out.print("请输入新的商品数量：");
            goods[i].buyNum = sc.nextInt();

            System.out.println("修改成功！");
            goods[i].show();
        }

        System.out.println("----------------------------------");
    }

    public static void queryGoods(Goods[] goods, int len) {
        System.out.println("------------查询商品query-----------");

        System.out.println("编号tt名称tt价格tt数量");
        for (int i = 0; i < len; i++) {
            System.out.println(goods[i].id + "tt" + goods[i].name + "tt" + goods[i].price + "tt" + goods[i].buyNum);
        }

        System.out.println("----------------------------------");
    }

    public static void addGoods(Goods[] goods, int len, Scanner sc) {
        System.out.println("-------------添加商品add------------");

        goods[len] = new Goods();
        System.out.print("请您输入商品编号(不重复)：");
        goods[len].id = sc.nextInt();
        System.out.print("请您输入商品名称：");
        goods[len].name = sc.next();
        System.out.print("请您输入商品价格：");
        goods[len].price = sc.nextDouble();
        System.out.print("请您输入购买商品的数量：");
        goods[len].buyNum = sc.nextInt();
        System.out.println("添加成功！");

        goods[len].show();
        System.out.println("----------------------------------");

    }
}

实现效果：

P74：面型对象：构造器、this

构造器：

this关键字：

• 可以出现在构造器、方法中
• 代表当前对象的地址，与 Car c = new Car() 中的 c 一样，都是代表当前对象的地址
• 作用：可以用于指定访问当前对象的成员变量、成员方法。

P75：面向对象：封装

封装的概念：

• 面向对象的三大特征：封装、继承、多态
• 封装：告诉我们，如何正确设计对象的属性和方法。
• 封装的原则：对象代表什么，就得封装对应的数据，并提供数据对应的行为。

如何更好地封装：（学会使用 private）

P76：面向对象：Javabean、综合实例

学会巧用 Alt+Insert（或者右键点击 Generate） ，直接 generate 已有的私有变量的get、set函数、有参、无参构造器等。

成员变量和局部变量的作用域：

综合案例：