Java入门-学习黑马程序员Java基础视频教程（到P92）

已于 2022-06-13 17:24:53 修改
阅读量2.4k 收藏 21
点赞数 2
分类专栏： Java学习ing 文章标签： java intellij-idea
于 2022-06-07 13:04:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LWD19981223/article/details/125154130
版权

目录


🍅🍅🍅🍅🍅🍅🍅🍅🍅

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

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

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

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

🍅🍅🍅🍅🍅🍅🍅🍅🍅


P0：写在前面的小知识

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

1.给module取名字

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

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

  • 数组遍历：arr.fori + 回车
  • 与上同理，若已知一个数值变量len，则len.fori + 回车也可快速生成 i < l e n i<len i<len 的for循环
  • 打印：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 一样，都是代表当前对象的地址
  • ArrayList集合存储的元素并不是对象本身，而是对象的地址。

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


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

在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开发工具：简介、下载、安装

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


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:\Ideaworkspace\javasepro\.idea\modules.xml）

彻底删除 app2模块 的步骤：

1.Remove Module用于在项目工程中删除该模块，并且在\modules.xml也删除
在这里插入图片描述

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


P11.3 重命名模块

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


P13：基础语法：注释

在这里插入图片描述

在这里插入图片描述

P14：字面量

在这里插入图片描述

在这里插入图片描述


P15-17：变量

在这里插入图片描述

在这里插入图片描述

P19：基础语法：数据类型

Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。

  • 整数：包括 byte，short，int，long （字节长度 1，2，4，8）
  • 浮点型：float，double （字节长度 4，8）
  • 字符：char （字节长度 2）
  • 布尔：boolean （字节长度 1/8）

java基本数据类型所占字节：（参考：java基本数据类型所占字节）

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述


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

在这里插入图片描述

在这里插入图片描述


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

在这里插入图片描述

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

在这里插入图片描述
在这里插入图片描述

/**
一道面试题，问res的数据类型应该是什么？
这里res的数据类型只能是int，不能是byte，因为在表达式中byte是直接转换成功int参与计算的
*/

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) {
        /* 需求：在控制台输出所有的“水仙花数”，水仙花数必须满足如下2个要求：
                1.水仙花数是一个三位数
                2.水仙花数的个位、十位、百位的数字立方和等于原数
                3.附加还要知道水仙花数的个数
         */
        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) {
        /*
        需求:
        世界最高山峰是珠穆朗玛峰(8848.86米=8848860毫米)，假如我有一张足够大的纸,
        它的厚度是0.1毫米。请问，折叠多少次，可以折成珠穆朗玛峰的高度。
         */
        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<array.length-1;i++){//控制比较轮次，一共 n-1 趟
        for(int j=0;j<array.length-1-i;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<array.length-i;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("编号\t\t名称\t\t价格\t\t数量");
        System.out.println(id + "\t\t" + name + "\t\t" + price + "\t\t" + 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("编号\t\t名称\t\t价格\t\t数量");

        double sum = 0;
        for (int i = 0; i < len; i++) {
            System.out.println(goods[i].id + "\t\t" + goods[i].name + "\t\t" + goods[i].price + "\t\t" + 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("编号\t\t名称\t\t价格\t\t数量");
        for (int i = 0; i < len; i++) {
            System.out.println(goods[i].id + "\t\t" + goods[i].name + "\t\t" + goods[i].price + "\t\t" + 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函数、有参、无参构造器等。

在这里插入图片描述
成员变量和局部变量的作用域：

在这里插入图片描述

综合案例：

在这里插入图片描述

在这里插入图片描述

P78：String、ArrayList课程安排

  • API（Application Programming Interface，应用程序接口）
  • Java SE Development Kit 18 Documentation（JDK18 API 官方文档）

在这里插入图片描述

P79：String概述、对象创建的原理

字符串对象的特点（面试常问）：

  • 双引号创建的字符串对象，在字符串常量池中存储同一个。
  • 通过 new 构造器创建的字符串对象，在堆内存中分开存储。

在这里插入图片描述

在这里插入图片描述

P80：String类常见面试题

  • 只要不是""直接给出来的，就一定是放在堆内存的；反之如果是用""括起来的就是放在字符串常量池的。

在这里插入图片描述

在这里插入图片描述


P81：String类常用API

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

P82：String案例：验证码、登录、隐私号码

在这里插入图片描述

package com.lwd.prctice;

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

public class CodeTest {
    public static void main(String[] args) {
        // 1.构造 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
        String code = "";
        for (int i = 0; i < 26; i++) {
            code += (char) ('a' + i);
        }
        for (int i = 0; i < 26; i++) {
            code += (char) ('A' + i);
        }
        code += "0123456789";
        System.out.println("code = \"" + code + "\"");

        // 2.构造指定长度的验证码
        System.out.print("请输入验证码位数：");
        Scanner sc = new Scanner(System.in);
        int len = sc.nextInt(), index;
        Random r = new Random();

        String code2 = "";
        for (int i = 0; i < len; i++) {
            index = r.nextInt(code.length());
            code2 += code.charAt(index);
        }
        System.out.println("验证码为：" + code2);
    }
}

在这里插入图片描述

package com.lwd.prctice;

import java.util.Scanner;

public class LoginTest {
    public static void main(String[] args) {
        // 1.自定义正确的用户名和密码
        String okLoginName = "admin";
        String okPassWord = "lwd";

        // 2.循环控制3次判断登陆是否成功
        Scanner sc = new Scanner(System.in);
        String name = "", pwd = "";
        for (int i = 1; i <= 3; i++) {
            System.out.print("请输入用户名：");
            name = sc.next();
            System.out.print("请输入密码：");
            pwd = sc.next();
            
            if (name.equals(okLoginName)) {
                if (pwd.equals(okPassWord)) {
                    System.out.println("登陆成功！");
                    break;
                } else {
                    System.out.println("您的密码输入有误！您还有" + (3 - i) + "次机会！");
                }
            } else {
                if (pwd.equals(okPassWord)) {
                    System.out.println("您的用户名输入有误！您还有" + (3 - i) + "次机会！");
                } else {
                    System.out.println("您的用户名、密码都输入有误！您还有" + (3 - i) + "次机会！");
                }
            }

        }
    }
}

在这里插入图片描述

package com.lwd.prctice;

import java.util.Scanner;

public class SplitTest {
    public static void main(String[] args) {
        System.out.print("请您输入电话号码(11位)：");
        Scanner sc = new Scanner(System.in);
        String phone = sc.next();
        String new_phone = phone.substring(0, 4) + "****" + phone.substring(7);
        System.out.println(new_phone);
    }
}

P83：集合概述、ArrayList的使用

特点：

  • 集合的大小不固定，启动后可以动态变化，数据类型也可以选择不固定。
    • 但是尽量使用同一数据类型添加到ArrayList容器中，所以需要使用泛型去约束ArrayList集合操作的数据类型，且数据类型只能是引用类型，如String、Integer
    • 写成：ArrayList<String> list = new ArrayList<>();
  • 集合非常适合做元素个数不确定，且要进行增删操作的业务场景。
  • 集合的提供了许多丰富、好用的功能，而数组的功能很单一。

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

P84：集合案例、ArrayList遍历删除、存对象、搜索

  • 方法1：正向从左到右删除，但是循环体内下标i--，使得能下标回退不会跳过此处数据（而且list.size()一直在变，i的取值范围因此在一直缩小）
  • 方法2：逆向从右到左删除，循环体内不做其余操作

在这里插入图片描述

package com.lwd.ArrayList;

import java.util.ArrayList;

public class RemoveTest {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(98);
        list.add(77);
        list.add(66);
        list.add(89);
        list.add(79);
        list.add(50);
        list.add(100);

        // 1.方法1：正向从左到右删除，但是循环体内下标i--，使得能下标回退不会跳过此处数据
        for (int i = 0; i < list.size(); i++) {
            if(list.get(i) < 80){
                list.remove(i);
                i--;
            }
        }
        System.out.println("list = " + list);

        // 2.方法2：逆行从右到左删除，循环体内不做其余操作
        for (int i = list.size() - 1; i >= 0; i--) {
            if (list.get(i) < 80){
                list.remove(i);
            }
        }
        System.out.println("list = " + list);
    }
}

在这里插入图片描述

package com.lwd.prctice;

import java.util.ArrayList;

public class ObjectTest {
    public static void main(String[] args) {
        ArrayList<Movie> movies= new ArrayList<>();
        Movie m1 = new Movie("《肖申克的救赎》", 9.7, "罗宾斯");
        Movie m2 = new Movie("《霸王别姬》", 9.6, "张国荣、张丰毅");
        Movie m3 = new Movie("《阿甘正传》", 9.5, "汤姆.汉克斯");

        movies.add(m1);
        movies.add(m2);
        movies.add(m3);

        for (int i = 0; i < movies.size(); i++) {
            System.out.println("--------------------");
            Movie movie = movies.get(i);
            System.out.println("片名：" + movie.getName());
            System.out.println("评分：" + movie.getScore());
            System.out.println("主演：" + movie.getActor());
        }
    }
}

在这里插入图片描述

package com.lwd.prctice;

import java.util.ArrayList;
import java.util.Scanner;

public class StudentManageTest {
    public static void main(String[] args) {
        ArrayList<Student> students = new ArrayList<>();

        students.add(new Student("20180302", "叶孤城", 23, "护理一班"));
        students.add(new Student("20180303", "东方不败", 23, "推拿二班"));
        students.add(new Student("20180304", "西门吹雪", 26, "中药学四班"));
        students.add(new Student("20180305", "梅超风", 26, "神经科二班"));

        // 打印学生信息
        printStudents(students);

        // 根据学号查找学生
        Scanner sc = new Scanner(System.in);
        while (true){
            System.out.print("请输入待查找的学生学号：");
            String id = sc.next();
            findStuById(students, id);
        }
    }

    public static Student findStuById(ArrayList<Student> students, String id) {
        Student s;
        for (int i = 0; i < students.size(); i++) {
            s = students.get(i);
            if(s.getStuId().equals(id)){
                System.out.println("学号\t\t姓名\t\t年龄\t\t班级");
                System.out.println(s.getStuId() + "\t" + s.getName() + "\t" + s.getAge() + "\t" + s.getClassNum());
                return s;
            }
        }
        System.out.println("查无此人！");
        return null;
    }

    public static void printStudents(ArrayList<Student> students) {
        System.out.println("学号\t\t姓名\t\t年龄\t\t班级");
        for (int i = 0; i < students.size(); i++) {
            Student s = students.get(i);
            System.out.println(s.getStuId() + "\t" + s.getName() + "\t" + s.getAge() + "\t" + s.getClassNum());
        }
    }

}

P86：ATM系统-01：项目介绍、功能演示

在这里插入图片描述

在这里插入图片描述

P87：ATM系统-02：系统准备、首页、开户功能

在这里插入图片描述
在这里插入图片描述


P88：ATM系统-03：用户登录、查询、退出、存取钱操作

在这里插入图片描述
在这里插入图片描述


Account.java

package com.ATM;

public class Account {
    private String cardId;      // 卡号
    private String userName;    // 用户名
    private String password;    // 密码
    private double money;       // 账户余额
    private double quotaMoney;  // 每次取现额度

    public Account() {
    }

    public Account(String cardId, String userName, String password, double money, double quotaMoney) {
        this.cardId = cardId;
        this.userName = userName;
        this.password = password;
        this.money = money;
        this.quotaMoney = quotaMoney;
    }

    public String getCardId() {
        return cardId;
    }

    public void setCardId(String cardId) {
        this.cardId = cardId;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    public double getQuotaMoney() {
        return quotaMoney;
    }

    public void setQuotaMoney(double quotaMoney) {
        this.quotaMoney = quotaMoney;
    }
}

ATMSystem.java

package com.ATM;

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

public class ATMSystem {
    public static void main(String[] args) {
        // 1.定义账户集合
        ArrayList<Account> accounts = new ArrayList<>();
        Scanner sc = new Scanner(System.in);
        int command;

        while (true) {
            // 展示系统首页
            System.out.println("\n==================欢迎来到ATM首页====================");
            System.out.println("1、账户登录");
            System.out.println("2、账户开户");

            System.out.println("请您选择操作：");
            command = sc.nextInt();
            switch (command) {
                case 1:
                    // 账户登录
                    login(accounts, sc);
                    break;
                case 2:
                    // 账户开户
                    register(accounts, sc);
                    break;
                default:
                    System.out.println("您的选择有误！");
            }
        }
    }

    // 登录
    private static void login(ArrayList<Account> accounts, Scanner sc) {
        if (accounts.size() == 0) {
            System.out.println("当前没有帐户，请先开户！");
            return;
        }

        System.out.println("\n=================系统登录操作================");
        Account account;

        // 输入卡号
        while (true) {
            System.out.print("请您输入卡号：");
            String cardId = sc.next();
            account = getAccountByCardId(cardId, accounts);
            if (account == null) {
                System.out.println("该登陆卡号不存在，请重新操作！");
            } else {
                break;
            }
        }

        // 输入正确密码
        while (true) {
            System.out.print("请您输入密码：");
            String password = sc.next();
            if (account.getPassword().equals(password)) {
                break;
            } else {
                System.out.println("密码错误，请重新操作！");
            }
        }

        System.out.println(account.getUserName() + "先生/女士，您已登录成功!您的卡号为：" + account.getCardId());

        // 进入到用户操作功能
        showUserCommand(accounts, account, sc);

    }

    private static void showUserCommand(ArrayList<Account> accounts, Account account, Scanner sc) {
        while (true) {
            System.out.println("\n===================用户操作页==================");
            System.out.println("1、查询账户");
            System.out.println("2、存款");
            System.out.println("3、取款");
            System.out.println("4、转账");
            System.out.println("5、修改密码");
            System.out.println("6、退出");
            System.out.println("7、注销账户");
            System.out.print("请选择：");

            int command = sc.nextInt();
            switch (command) {
                case 1: // 查询
                    showAccount(account);
                    break;
                case 2: // 存款
                    depositMoney(account, sc);
                    break;
                case 3: // 取款
                    drawMoney(account, sc);
                    break;
                case 4: // 转账
                    transferMoney(accounts, account, sc);
                    break;
                case 5: // 修改密码 + 回到首页
                    updatePassword(account, sc);
                    return;
                case 6: // 退出 + 回到首页
                    System.out.println("退出成功！欢迎下次使用！");
                    return;
                case 7: // 成功注销账户 + 回到首页 or 未注销 + 回到用户页
                    if(deleteAccount(accounts, account, sc)){
                        return;
                    }else{
                        break;
                    }
                default:
                    System.out.println("您的输入有误！");
            }
        }
    }

    private static boolean deleteAccount(ArrayList<Account> accounts, Account account, Scanner sc) {
        System.out.println("\n=================用户注销账户操作================");
        System.out.println("您真的要销户吗？(y/n)");
        String rs = sc.next();

        switch (rs) {
            case "y":
                if (account.getMoney() > 0) {
                    System.out.println("您的余额不为0，不能销户！");
                } else {
                    accounts.remove(account);
                    System.out.println("您的账户销户完成！");
                }
                return true;
            default:
                System.out.println("好的，当前账户继续保留~");
        }
        return false;
    }

    private static void updatePassword(Account account, Scanner sc) {
        System.out.println("\n=================用户修改密码操作================");
        while (true) {
            System.out.print("请您输入原始密码：");
            String password = sc.next();

            if (!password.equals(account.getPassword())) {
                System.out.println("你的原始密码输入有误，请重新操作！");
            } else {
                break;
            }
        }

        while (true) {
            System.out.print("请您输入新密码：");
            String password = sc.next();

            if (password.equals(account.getPassword())) {
                System.out.println("新密码不能与原始密码相同！请重新操作！");
                continue;
            }

            System.out.print("请您再次输入新密码：");
            if (!password.equals(sc.next())) {
                System.out.println("两次新密码输入不一致，请重新操作！");
            } else {
                account.setPassword(password);
                System.out.println("您已成功修改登录密码为：" + password);
                return;
            }
        }

    }

    private static void transferMoney(ArrayList<Account> accounts, Account account, Scanner sc) {
        System.out.println("\n=================用户转账操作================");

        if (accounts.size() < 2) {
            System.out.println("当前系统中，不足2个账户，无法进行转账，请先去开户吧！");
            return;
        }

        if (account.getMoney() == 0) {
            System.out.println("对不起，您的余额为0，就先别转了吧~");
            return;
        }

        while (true) {
            System.out.print("请输入转账用户的卡号：");
            String cardId = sc.next();

            // 不能给自己转账
            if (cardId.equals(account.getCardId())) {
                System.out.println("对不起，您不能给自己转账！");
                continue;
            }

            Account acc = getAccountByCardId(cardId, accounts);
            if (acc == null) {
                System.out.println("该卡号不存在，请重新操作！");
            } else {
                String userName = acc.getUserName();
                String tip = "*" + userName.substring(1);
                System.out.print("请您输入[" + tip + "]的姓氏：");

                String preName = sc.next();
                if (userName.startsWith(preName)) {
                    // 开始转账
                    System.out.print("请您输入转账金额：");
                    double money = sc.nextDouble();
                    if (money > account.getMoney()) {
                        System.out.println("对不起，您的余额不足，最多转账：" + account.getMoney() + "元");
                    } else {
                        account.setMoney(account.getMoney() - money);
                        acc.setMoney(acc.getMoney() + money);
                        System.out.println("您已成功给[ " + acc.getCardId() + " " + acc.getUserName() + " ]转账" + money + "元，您当前余额为：" + account.getMoney() + "元");
                        return;
                    }
                } else {
                    System.out.println("对不起，您输入的信息有误~~");
                }
            }
        }


    }

    private static void drawMoney(Account account, Scanner sc) {
        System.out.println("\n=================用户取钱操作================");

        // 如果当前不足100元，则无法取出
        if (account.getMoney() < 100) {
            System.out.println("您的余额为：" + account.getMoney() + "，不足100元无法取出！");
            return;
        }

        while (true) {
            System.out.print("请您输入取款金额：");
            double money = sc.nextDouble();
            if (money > account.getMoney()) {
                System.out.println("您的余额为：" + account.getMoney() + "元，不足以取到" + money + "元，请调整取款金额！");
            } else {
                if (money > account.getQuotaMoney()) {
                    System.out.println("您的取款金额超出额度：" + account.getQuotaMoney() + "元，请调整取款金额！");
                } else {
                    account.setMoney(account.getMoney() - money);
                    break;
                }
            }
        }

        System.out.println("您已成功取款，余额为：" + account.getMoney());
    }

    private static void depositMoney(Account account, Scanner sc) {
        System.out.println("\n=================用户存钱操作================");
        System.out.print("请您输入存款金额：");
        double money = sc.nextDouble();
        money += account.getMoney();
        account.setMoney(money);

        System.out.println("您已存款成功！");
        showAccount(account);
    }

    private static void showAccount(Account account) {
        System.out.println("\n=================当前账户信息如下================");
        System.out.println("卡号：" + account.getCardId());
        System.out.println("户主：" + account.getUserName());
        System.out.println("余额：" + account.getMoney());
        System.out.println("限额：" + account.getQuotaMoney());
    }

    // 开户
    private static void register(ArrayList<Account> accounts, Scanner sc) {
        System.out.println("\n=================系统开户操作================");

        Account account = new Account();
        System.out.print("请您输入姓名：");
        account.setUserName(sc.next());

        while (true) {
            System.out.print("请您输入密码：");
            String password = sc.next();
            System.out.print("请您确定输入密码：");
            if (password.equals(sc.next())) {
                account.setPassword(password);
                break;
            } else {
                System.out.println("两次密码输入不一致！请重新输入密码！");
            }
        }

        System.out.print("请您输入取现额度：");
        account.setQuotaMoney(sc.nextDouble());

        // 生成随机一个8位卡号
        String cardId = getRandomCardId(accounts);
        account.setCardId(cardId);

        // 添加到集合中去
        accounts.add(account);
        System.out.println("恭喜您，" + account.getUserName() + "先生/女士，您已开户成功，您的卡号是：" + cardId + "，请您妥善保管卡号");
    }

    // 返回随机生成的不重复的8位卡号
    private static String getRandomCardId(ArrayList<Account> accounts) {
        Random r = new Random();
        while (true) {
            // 生成随机8位卡号
            String cardId = "";
            for (int i = 0; i < 8; i++) {
                cardId += r.nextInt(10);
            }

            if (getAccountByCardId(cardId, accounts) == null) {
                return cardId;
            }
        }
    }

    // 根据卡号查找账户
    private static Account getAccountByCardId(String cardId, ArrayList<Account> accounts) {
        for (int i = 0; i < accounts.size(); i++) {
            if (accounts.get(i).getCardId().equals(cardId)) {
                return accounts.get(i);
            }
        }
        return null;
    }
}

🍀 后续课程：

🍀 JavaSE基础加强-学习黑马程序员Java基础视频教程（P93开始）

孟孟单单
关注
  • 2
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
大学城外包22-实验4-循环结构程序设计---教材P92课后习题三(6)：求水仙花数.c
10-28
大学城外包22-实验4-循环结构程序设计---教材P92课后习题三(6)：求水仙花数.c
python从入门到精通地址.txt
06-27
零基础入门学习Python P1. 000愉快的开始 P2. 001我和Python的第一次亲密接触 P3. 002用Python设计第一个游戏 P4. 003小插曲之变量和字符串 P5. 004改进我们的小游戏 P6. 005闲聊之Python的数据类型 P7. 006Pyhon之常用操作符 P8. 007了不起的分支和循环1 P9. 008了不起的分支和循环2 P10. 009了不起的分支和循环3 P11. 010列表：一个打了激素的数组1 P12. 011列表：一个打了激素的数组2 P13. 012列表：一个打了激素的数组3 P14. 013元组：戴上了枷锁的列表 P15. 014字符串：各种奇葩的内置方法 P16. 015字符串：格式化 P17. 016序列！序列！ P18. 017函数：Python的乐高积木 P19. 018函数：灵活即强大 P20. 019函数：我的地盘听我的 P21. 020函数：内嵌函数和闭包 P22. 021函数：lambda表达式 P23. 022函数：递归是神马 P24. 023递归：这帮小兔崽子 P25. 024递归：汉诺塔 P26. 025字典：当索引不好用时1 P27. 026字典：当索引不好用时2 P28. 027集合：在我的世界里，你就是唯一 P29. 028文件：因为懂你，所以永恒 P30. 029文件：一个任务 P31. 030文件系统：介绍一个高大上的东西 P32. 031永久存储：腌制一缸美味的泡菜 P33. 032异常处理：你不可能总是对的1 P34. 033异常处理：你不可能总是对的2 P35. 034丰富的else语句及简洁的with语句 P36. 035图形用户界面入门：EasyGui P37. 036类和对象：给大家介绍对象 P38. 037类和对象：面向对象编程 P39. 038类和对象：继承 P40. 039类和对象：拾遗 P41. 040类和对象：一些相关的BIF P42. 041魔法方法：构造和析构 P43. 042魔法方法：算术运算1 P44. 043魔法方法：算术运算2 P45. 044魔法方法：简单定制 P46. 045魔法方法：属性访问 P47. 046魔法方法：描述符（Property的原理） P48. 047魔法方法：定制序列 P49. 048魔法方法：迭代器 P50. 049乱入：生成器 P51. 050模块：模块就是程序 P52. 051模块：__name__=___main___、搜索路径和包 P53. 052模块：像个极客一样去思考 P54. 053论一只爬虫的自我修养1 P55. 054论一只爬虫的自我修养2：实战 P56. 055论一只爬虫的自我修养3：隐藏 P57. 056轮一只爬虫的自我修养4：OOXX P58. 057论一只爬虫的自我修养5：正则表达式 P59. 058论一只爬虫的自我修养6：正则表达式2 P60. 059论一只爬虫的自我修养7：正则表达式3 P61. 060论一只爬虫的自我修养8：正则表达式4 P62. 061论一只爬虫的自我修养9：异常处理 P63. 062论一只爬虫的自我修养10：安装Scrapy P64. 063论一只爬虫的自我修养11：Scrapy框架之初窥门径 P65. 064GUI的终极选择：Tkinter1 P66. 065GUI的终极选择：Tkinter2 P67. 066GUI的终极选择：Tkinter3 P68. 067GUI的终极选择：Tkinter4 P69. 068GUI的终极选择：Tkinter5 P70. 069GUI的终极选择：Tkinter6 P71. 070GUI的终极选择：Tkinter7 P72. 071GUI的终极选择：Tkinter8 P73. 072GUI的终极选择：Tkinter9 P74. 073GUI的终极选择：Tkinter10 P75. 074GUI的终极选择：Tkinter11 P76. 075GUI的终极选择：Tkinter12 P77. 076GUI的终极选择：Tkinter13 P78. 077GUI的终极选择：Tkinter14 P79. 078Pygame：初次见面，请大家多多关照 P80. 079Pygame：解惑 P81. 080Pygame：事件 P82. 081Pygame：提高游戏的颜值1 P83. 082Pygame：提高游戏的颜值2 P84. 083Pygame：提高游戏的颜值3 P85. 084Pygame：基本图形绘制 P86. 085Pygame：动画精灵 P87. 086Pygame：碰撞检测 P88. 087Pygame：播放声音和音效 P89. 088Pygame：摩擦摩擦 P90. 089Pygame：游戏胜利 P91. 090Pygame：飞机大战1 P92. 091Pygame：飞机大战2 P93. 092Pygame：飞机大战3 P94. 093Pygame：飞机大战4 P95. 094Pygame：飞机大战5 P96. 095Pygame：飞机大战6 P97. 096Pygame：飞机大战7
p92 - p99软中断和硬中断
05-15
p92 - p99软中断和硬中断
p91、p92高压管道t型角焊缝的超声波检测.pdf
05-27
p91、p92高压管道t型角焊缝的超声波检测.pdfp91、p92高压管道t型角焊缝的超声波检测.pdfp91、p92高压管道t型角焊缝的超声波检测.pdfp91、p92高压管道t型角焊缝的超声波检测.pdfp91、p92高压管道t型角焊缝的超声波检测.pdf
恒润CAN基础2014.pdf
04-15
P92，概述：CAN标准，CAN的通信机制，数据帧，错误检测与错误帧，CAN的帧格式，位定位与同步，物理连接。Controller Area Network 是20世纪80年代初德国bosch公司为解决现代汽车中众多控制单元之间的实时数据交换而开发的一种串行通信协议。
JavaSE基础加强-学习黑马程序员Java基础视频教程（P93开始）
孟孟单单的博客
06-11 2133
JavaSE基础加强
Java进阶01-语法-徐磊
超级氯化钾的博客
06-22 575
文章目录代码块 代码块 package com.kcl._13代码块; import java.util.ArrayList; import java.util.List; /** * 目标: 静态代码块研究(重点) * * 类有5大成分: 成员变量，方法，构造器，代码块，内部类 * * 代码块按照有无static修饰可以分为：静态代码块，实例代码块 * * (1)静态代码块：属于类，会和类一起加载，而且自动触发执行一次！ * static{ * conte
JavaSE学习（黑马程序员徐磊老师）day01
不躺平的DD的博客
12-21 476
javase的入门
Java基础知识总结
一个2年工作经验的程序测试员
06-05 901
Java基础知识总结 写代码： 1，明确需求。我要做什么？ 2，分析思路。我要怎么做？1,2,3。 3，确定步骤。每一个思路部分用到哪些语句，方法，和对象。 4，代码实现。用具体的java语言代码把思路体现出来。 学习新技术的四点： 1，该技术是什么？ 2，该技术有什么特点(使用注意)： 3，该技术怎么使用。demo 4，该技术什么时候用？test。 --------...
黑马程序员---Java从入门到起飞 基础概念
我亦无他，唯手熟尔
06-27 2356
黑马程序员Java教程及资料【全套教程下载】下载地址：https://pan.baidu.com/s/1LxIxcHDO7SYB96SE-GZfuQ提取码：dor4【其他精品教程】下载地址：https://pan.baidu.com/s/1oPdzQ7vO2bivTYtttD1jfw提取码：1234【B站在线观看】地址：https://www.bilibili.com/read/cv9965357【了解Java全体系课程】
黑马程序员 比较受欢迎的Java类
li13615680696的专栏
04-17 337
1. java.lang.String String类无可争议的获得冠军，应该没有人会否认这一点。这是一个最终类，用于创建/操作不可变的字符串文字。它从JDK 1.0开始就有了。 2. java.lang.System System类的使用取决于你工作的项目类型。你可能没有在项目中使用过它，但它仍然是受欢迎的Java类之一。这是一个不能被实例化的工具类。这个类的主要用途是访问
Java教程-黑马程序员版
黑马程序员官方博客
07-01 1305
很多初学Java的小伙伴，在选择Java教程的时候有很多困惑。哪一套Java教程更适合入门？某一个技术学完之后能做什么？黑马程序员为大家整理了2022年Java教程的选择建议。希望对大家有帮助~
黑马程序员--java基础知识点总结
王小乖
06-05 874
——- android培训、java培训、期待与您交流！ ———- 标识符概念 在java语言中的包、类、方法、参数、变量也有自己的标识，允许程序员对程序中的各个元素加以命名，这种字符串称为标识符。标识符命名规则1.标识符由字母、数字、下划线（_）和美元符号（$）组成，但标识符不能以数字开头。2.标识符不能是java的关键字和保留字，但可以包含其在内。3.标识符中字符大小写
mybatisPlus使用MetaObjectHandler对字段进行更新
m0_56356631的博客
04-23 779
都是符合我们的预期的。
java方法重写（重点讲），方法重载
weixin_46281068的博客
04-27 852
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
string模拟实现
m0_73969414的博客
04-23 1782
c++中string的模拟实现，面试必会知识点
Day25-Java基础之常用类1
最新发布
m0_46053885的博客
04-27 852
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。
实现自定义注解、实现自定义幂等性注解
qq_44721738的博客
04-23 1044
添加 Spring AOP 依赖。创建自定义注解。创建一个新的 Java 注解类，通过@interface关键字来定义，并可以添加元注解以及属性。@Target(ElementType.METHOD) //表示作用于方法上@Retention(RetentionPolicy.RUNTIME) // 表示这个注解在运行时是可见的，这样 AOP 代理才能在运行时读取到这个注解编写 AOP 拦截（自定义注解）的逻辑代码。@Aspect@Component// 方法执行前的处理。
C语言案例——输出 Fibonacci 数列（斐波那契数列）的前 40 项
悟道子HD
04-25 479
输出 Fibonacci 数列（斐波那契数列）的前 40 项 #include void main() { int a[40]= {1,1}; int i; printf( "%12d%12d",a[0],a[1]); for(i=2; i
用小脚丫STEP FPGA开发板的数码管、三色灯、sw实现：1.Sw4来控制启停，当Sw4往下拨开始计数；2.从0开始用两个数码管计数，每隔3s加一个数；3.加到15后，三色灯循环闪烁，按照红色1秒，蓝色1秒，黄色1s这个循环闪烁持续10s；4.重复步骤2和3，直到Sw4往上拨的时候停止的Quarter代码和FPGA管脚设置
06-13
NET "digit1<7>" LOC = "P92" | IOSTANDARD = "LVCMOS33"; // 数码管1 dp NET "digit2<0>" LOC = "P93" | IOSTANDARD = "LVCMOS33"; // 数码管2 a NET "digit2<1>" LOC = "P94" | IOSTANDARD = "LVCMOS33"; // ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

孟孟单单

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值