Java基础篇

Java 初识

快捷键

a.sout —> System.out.print(a);

sout  —> System.out.print();

ctrl+alt+t 选择循环

alt+Enter 强制类型转换

右键generate，自动生成构造函数和get、set方法

a.fori+Enter 自动生成for循环

ctrl + alt + V 自动生成左边的接受变量

Alt+Shift+Enter 实现方法重写（抽象类尤甚）

关键字

标识符

类型转换

自动类型转换

类型范围小的变量，可以直接赋值给类型范围大的变量。

package com.itheima.conversion;

public class TypeConversionDemo1 {
    public static void main(String[] args) {

        byte a = 12;
        int b = a; // 发生自动类型转换了
        System.out.println(a); // 12
        System.out.println(b); // 12

        int c = 100;  // 4位
        double d = c; // 8位 发生自动类型转换了
        System.out.println(d); // 100.0

        char ch = 'a'; // 'a' 97 => 00000000 01100001
        int i = ch; // 发生自动类型转换了 => 00000000 00000000 00000000 01100001
        System.out.println(i); // 97
    }
}

注意：表达式的最终结果类型由表达式中的最高类型决定。

在表达式中，byte、short、char是直接转换成int类型参与运算的，所以需要用int接收。

强制类型转换

语法：数据类型变量2 = (数据类型)变量1、数据

package com.itheima.conversion;

public class TypeConversionDemo2 {
    public static void main(String[] args) {
        int a = 20;
        byte b = (byte) a; // ALT + ENTER 强制类型转换
        System.out.println(a); // 20
        System.out.println(b); // 20

        int i = 1500;
        byte j = (byte) i;
        System.out.println(j); // -36 这边就出错了

        double d = 99.5;
        int m = (int) d;
        System.out.println(m); // 99
    }
}

注意：强制类型转换可能造成数据（丢失）溢出；

浮点型强转成整型，直接丢掉小数部分，保留整数部分返回

运算符

基础知识

package com.itheima.operator;

public class OperatorDemo {
    public static void main(String[] args) {
        double score = 58.5;
        String rs = score >= 60 ? "成绩及格" : "成绩不及格";
        System.out.println(rs); // 成绩不及格

        // 找出2个整数中的较大值，并输出
        int a = 99;
        int b = 99;
        int max = a > b ? a : b;
        System.out.println(max); // 99

        // 找3个整数中的较大值
        int i = 10;
        int j = 45;
        int k = 34;
        int temp = i > j ? i : j;
        int max2 = temp > k ? temp : k;
        System.out.println(max2); // 45
    }
}

运算符优先级

优先级	运算符	结合性
1	()、[]、{}	从左到右
2	!、+、-、~、++、- -	从右到左
3	*、/、%	从左到右
4	+、-	从左到右
5	<<、>>、>>>	从左到右
6	<、<=、>、>=	从左到右
7	==、!=	从左到右
8	&	从左到右
9	^	从左到右
10	\		从左到右
11	&&	从左到右
12	\	\		从左到右
13	?	从右到左
14	=、+=、-=、*=、/=、&=、\	=、^=、~=、<<=、>>=、>>>=	从右到左

补充：Scanner 输入

package com.itheima.scanner;

import java.util.Scanner;

public class ScannerDemo {
    public static void main(String[] args) {
        // 1.导包：一般不需要我们自己做，idea工具会自动帮我们导包的；
        // 2.抄写代码：得到一个键盘扫描器对象。
        Scanner sc = new Scanner(System.in);

        // 3.开始调用sc的功能，来接受用户键盘输入的数据
        System.out.println("请您输入您的年龄：");
        int age = sc.nextInt();// 执行到这儿，会开始等待用户输入一个整数，直到用户按了回车键，才会拿到数据
        // nextInt()函数在java语言中是获取一个int类型的数。
        System.out.println("您的年龄是：" + age);

        System.out.println("请您输入您的名字：");
        String name = sc.next();// 执行到这儿，会开始等待用户输入一个整数，直到用户按了回车键，才会拿到数据
        System.out.println(name + "欢迎您进入系统~~");
    }
}
    /*
    请您输入您的年龄：
    22
    您的年龄是：22
    请您输入您的名字：
    陈平安
    陈平安欢迎您进入系统~~
    */

区分：

next()方法读取到空白符就结束，也就是读取完“我爱学 JAVA”；

nextLine()只读取到回车结束也就是“\r”；

流程控制

if 语句

for 循环

Java 有一种功能很强的循环结构，可以用来依次处理数组中的每个元素（其他类型的元素集合亦可）而不必为指定下标值而分心。

for (variable : collection) statement

package com.itheima.circulate;

public class CirculateDemo {
    public static void main(String[] args) {

        double[] myList = {1.9, 2.9, 3.4, 3.5};
        for (double a : myList) {
            System.out.print(a + " "); // 1.9 2.9 3.4 3.5
        }

    }
}

while 循环

do-while 循环

例如：在抢票时，如果先判断有没有票，再进行抢票的动作，就慢了，所以要先 do 再 while

区别：在 for 循环中，控制循环的变量只在循环中使用。while 循环中，控制循环的变量在循环后还可以继续使用。

死循环

嵌套循环

break & continue

补充：生成随机数

package com.itheima.random;

import java.util.Random;

public class RandomDemo {
    public static void main(String[] args) {
        // 1.自动导包
        // 2.创建一个Random对象，用于生成随机数
        Random rand = new Random();
        // 3.调用Random提供的功能，nextInt得到随机数
        for (int i = 0; i < 10; i++) {
            int data = rand.nextInt(10) + 1; // 获取1到10的一个随机数
            // nextInt()函数在java语言中是获取一个int类型的数。
            System.out.print(data + " ");
        }
    }
}

注意：如果要生成 65-91 之间的数，① 整体减 65，即为 0-26，②rand.nextInt(27)，③ 再加上 65
最后输出，System.out.println(rand.nextInt(27)+65);

猜数字

package com.itheima.random;

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

public class RandomDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        Random rand = new Random();
        int data = rand.nextInt(99) + 1;
        System.out.println(data);
        System.out.println("请输入1-100中的一位数字：");
        while (true) {
            int num = sc.nextInt();
            if (num == data) {
                System.out.println("猜对了！牛13格拉斯！");
            } else if (num > data) {
                System.out.println("太大了，再猜：");
            } else {
                System.out.println("太小了，再猜：");
            }
        }
    }
}

数组

数组就是一个容器，用来存储一批同种类型的数据。

数组的好处

静态初始化数组

package com.itheima.array;

public class ArrayDemo {
    public static void main(String[] args) {
        // 1.数据类型[] 数组名 = new 数据类型[]{元素1, 元素2, 元素3,......}
        int[] a = new int[]{12, 24, 36};
        double[] b = new double[]{12.1, 24.2, 36.3};
        System.out.println(a); // [I@7b23ec81
        System.out.println(b); // [D@6acbcfc0
        /*
        在Java中，基本数据类型的数组（如int[]）实际上是对象，
        但数组的元素是基本数据类型的情况下，并不能直接获取它们的内存地址。
        Java没有直接提供访问变量内存地址的功能，
        因为Java在设计时就刻意隐藏了指针的概念，以提高安全性和简化内存管理。
         */

        // 2.简化写法：
        // 数据类型[] 数据名 = {元素1, 元素2, 元素3,......}
        int[] a2 = {12, 24, 36};
        double[] b2 = {12.1, 24.2, 36.3};
        // 推荐★★★

        // 3.数据类型[] 数组名 也可以写成 数据类型 数组名[]
        int a3[] = {12, 24, 36};
        double b3[] = {12.1, 24.2, 36.3};
        // 这种写法不推荐，用第二种写法可以一眼看出是在定义一个数组
    }
}

数组的访问

数组的遍历

package com.itheima.array;

public class ArrayDemo {
    public static void main(String[] args) {
        int[] a = {12, 24, 36};

        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }
    }
}

动态初始化数组

注意：char 类型需要强转成 int 类型，即 System.out.println((int)a[i]); 才能显示出默认值，否则会因为自动转为字符，导致出现乱码或者无输出。

补充：执行原理

以 int a =20;和int[] arr = new int[3]为例，

a 是变量，直接放在栈中，a 变量中存储的就是 20 这个数据，

new int[3]是创建一个数组对象，会在堆内存中开辟区域存储 3 个整数，

arr 是变量，在栈中，arr 中存储的是数组对象在堆内存中的地址值。

举一反三

package com.itheima.array;

public class ArrayDemo {
    public static void main(String[] args) {
        int[] arr1 = {11, 22, 33};
        int[] arr2 = arr1;
        System.out.println(arr1);
        System.out.println(arr2);

        arr2[1]=99;
        System.out.println(arr1[1]);
    // 因为arr1向arr2传的是地址，所以在arr2中修改值，arr1打印出来的值也是修改后的
    }
}
	/*
	[I@7b23ec81
	[I@7b23ec81
	99
 	*/

随机排序

package com.itheima.array;

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

public class ArrayDemo {
    public static void main(String[] args) {
        // 目标：随机排名
        // 1. 定义一个动态初始化的数组用于存储5名员工的工号
        int[] codes = new int[5];
        // {0, 0, 0, 0, 0}

        // 2.提示用户录入5名员工的工号
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < codes.length; i++) {
            System.out.println("请您输入第" + i + "名员工的工号");
            int code = sc.nextInt();
            codes[i] = code;
        }

        // 3.打乱数组中的元素顺序
        Random r = new Random();
        for (int i = 0; i < codes.length; i++) {
            // 从头遍历，每遍历一个就随机跟数组中的一个元素交换一下
            int index = r.nextInt(codes.length);
            // 经典交换三部曲↓
            int temp = codes[index]; // 把随机到的值传给temp
            codes[index] = codes[i];
            codes[i] = temp;
        }

        // 4.遍历数组中的工号输出即可
        for (int i = 0; i < codes.length; i++) {
            System.out.println(codes[i] + " ");
        }
    }
}

方法

定义

类似 C++中的函数

好处：提高代码的复用性，提高开发效率，使程序逻辑更清晰。

如果方法不需要接收数据处理，不需要返回值，返回值类型就写 void ，括号里的形参列表可以不写，在结构体内部也不要写 return 返回数据。

Java：由于不支持默认参数，Java 通常通过方法重载来实现类似功能。这意味着你可以定义多个同名的方法，参数列表不同。
1
2
3
4
5
6
7
public void example(int a) {
    example(a, 10); // 调用另一个重载的方法
}

public void example(int a, int b) {
    // 实现
}

方法使用时的常见问题

package com.itheima.method;

public class MethodDemo {
    public static void main(String[] args) {

        // 一、调用有返回值的方法
        // 1.可以定义变量接收结果再调用
        int rs = sum(10,20);
        System.out.println(rs);

        // 2.可以直接输出调用
        System.out.println(sum(10,90));

        // 3.可以像这样直接调用，啥也不干
        sum(100,200);

        // 二、调用无返回值的方法，只有一种方式，直接调用
        printHelloWorld();
    }

    // 注意：方法不要写到main函数里面去
    public static int sum(int a, int b) {
        int c = a + b;
        return c;
        // return后面不要再写代码了，都会是无效代码
    }

    public static void printHelloWorld(){
        System.out.println("Hello World");
    }
}

方法参数传递

值传递（浅拷贝）

package com.itheima.method;

public class MethodDemo {
    public static void main(String[] args) {

        // 值传递（浅拷贝）
        int a =10;
        change(a);
        System.out.println("main:"+a);
    }
    public static void change(int a){
        System.out.println("change1:"+a);
        a=20;
        System.out.println("change2:"+a);
    }
}
    /*
    change1:10
    change2:20
    main:10
     */

引用传递（深拷贝）

package com.itheima.method;

public class MethodDemo {
    public static void main(String[] args) {

        // 引用传递（深拷贝）
        int[] arrs = new int[]{10, 20, 30}; // 等价于int[] arrs = {10,20,30};
        change(arrs);
        System.out.println("main:" + arrs[2]);
    }

    public static void change(int[] arrs) {
        System.out.println("change1:" + arrs[2]);
        arrs[2] = 222;
        System.out.println("change2:" + arrs[2]);
    }
}
    /*
    change1:30
    change2:222
    main:222
     */

方法重载

简单说，在一个类中方法名一样，但是括号内的形参列表不一样，编译的时候会自动选择。

形参列表不一样是指：形参的个数、类型、顺序不同，不关心形参的名称，也就是括号里叫 int a 还是 int b。

注意： 修饰符和返回值类型不同不算重载，

package com.itheima.method;

public class OverLoadDemo {
    public static void main(String[] args) {

        test();
        test(100);
        test(100, 12.2);
        test(21.1, 200);
    }

    public static void test() {
        System.out.println("===test1===");
    }

    public static void test(int a) {
        System.out.println("===test2===");
    }

    public static void test(int a, double b) {
        System.out.println("===test3===");
    }

    public static void test(double b, int a) {
        System.out.println("===test4===");
    }

}
    /*
    ===test1===
    ===test2===
    ===test3===
    ===test4===
     */

return 关键字

package com.itheima.method;

public class MethodDemo {
    public static void main(String[] args) {
        System.out.println("开始");
        chufa(10, 0); // 正常情况下分母是0会报错
        System.out.println("结束");
    }

    public static void chufa(int a, int b) {
        if (b == 0) {
            System.out.println("您的数据有误！！ 分母不可以是0！！ ");
            return; // 直接跳出并结束当前方法的执行
        }
        int c = a / b;
        System.out.println("除法结果是：" + c);
    }
}
    /*
    开始
    您的数据有误！！ 分母不可以是0！！
    结束
     */

注意区分：

return; 跳出并立即结束所在方法的执行。

break; 跳出并结束当前所在循环的执行。

continue; 结束当前所在循环的当次继续，进入下一次执行。

案例练习

生成随机验证码

package com.itheima.method;

public class Test {
    public static void main(String[] args) {
        //生成随机验证码
        System.out.print("请输入所需生成验证码位数：");
        Scanner sc = new Scanner(System.in);
        int s = sc.nextInt();
        System.out.println(createCode(s));
    }

    public static String createCode(int n) {
        String Code = "";
        Random rand = new Random();
        int r = 0;
        for (int i = 0; i < n; i++) {
            r = rand.nextInt(4);//为什么是4而不是3，是我觉得数字生成概率太低了
            if (r == 0) { // 在char中 A:65  Z:65+26
                char a1 = (char) (rand.nextInt(26) + 65);
                Code += a1;
            } else if (r == 1) { // 在char中 a:97  Z:97+26
                char a2 = (char) (rand.nextInt(26) + 97);
                Code += a2;
            } else {
                int a3 = rand.nextInt(10); // 显而易见 数字 0-9
                Code += a3;
            }
        }
        return Code;
    }
}

面向对象基础

定义

通过代码简单了解，类似 C++中的结构体

注意：需要写在同一个包下面

// Student.java
package com.itheima.object;

public class Student { // 这个class类就好比一个对象的模板，一个空表
    // 成员变量（对象的属性）
    // 注意：成员变量有默认值，不用特地写初始值。
    String name; // 姓名 默认Null
    double chinese; // 语文成绩 默认0.0
    double math; // 数学成绩 默认0.0

    // 成员方法（对象的行为）
    public void printTotalScore() {
        System.out.println(name + "的总成绩是：" + (chinese + math));
    }

    public void printAverageScore() {
        System.out.println(name + "的平均成绩是：" + (chinese + math) / 2);
    }
}

// Test.java
package com.itheima.object;

public class Test {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.name = "李槐"; // 这就是在模板/空表中填入信息
        s1.chinese = 91;
        s1.math = 82;
        s1.printTotalScore();
        s1.printAverageScore();

        Student s2 = new Student();
        s2.name = "李柳";
        s2.chinese = 96;
        s2.math = 85;
        s2.printTotalScore();
        s2.printAverageScore();
    }
}
	/*
	李槐的总成绩是：173.0
	李槐的平均成绩是：86.5
	李柳的总成绩是：181.0
	李柳的平均成绩是：90.5
	*/

方法被对象调用时，是在栈内存执行的，对象通过类地址找到方法并放入栈内存执行（既压栈），由于栈内存后进先出，所以方法运行完后就会出栈，释放栈内存空间

注意事项

在上述Student.java文件中只能有一个 class 是 public的，且public 的 class 名必须与文件名相同，如下例：

// Student.java
package com.itheima.object;

public class Student {···}

class Teacher {}

class Worker {}

···

Java 的源文件中只能有一个 public 类，‌ 这一规定主要是出于以下几个原因：‌

为了给源码阅读提供便利：‌Java 的设计者可能认为，‌ 如果一个源文件中可以有多个 public 的类，‌ 且它们的名字与源文件名不一致，‌ 那么在阅读代码时，‌ 了解某个引用类的定义情况就会变得困难。‌ 有了这个规定后，‌ 我们可以通过 import 的包名和类名准确找到源文件的位置。‌
每个编译单元只能有一个公共接口：‌ 每个编译单元（‌ 即源文件）‌ 只能有一个 public 类。‌ 这是因为每个编译单元只能有一个公开的接口，‌ 而这个接口就由其 public 类来表示。‌ 这样的设计是为了确保每个源文件都有一个明确的公共表示，‌ 便于理解和维护。‌
Java 程序的入口点：‌Java 程序的执行是从一个 public 类的 main 函数开始的。‌ 因此，‌ 被定为 public 的这个类里一定是含有 main 方法的类，‌ 而且该类的名称要和文件名一致。‌ 这是因为虚拟机开始要找 main 函数作为程序的入口点。‌ 这样的设计是为了确保程序能够正确地启动执行。‌
编译和运行的需要：‌Java 语言规范规定，‌ 一个源文件只能有一个 public 类，‌ 并且这个类的名称必须与文件名相同。‌ 这是因为 Java 编译器需要将源文件编译成一个对应的.class 文件，‌ 而每个.class 文件只能包含一个 public 类。‌ 如果一个源文件中有多个 public 类，‌ 编译器就无法生成对应的.class 文件。‌ 此外，‌ 非 public 类可以在一个源文件中存在多个，‌ 因为它们不会影响编译器生成的.class 文件。‌

综上所述，‌Java 的源文件中只能有一个 public 类的规定，‌ 既是为了方便代码阅读和维护，‌ 也是为了确保编译和运行的正确性。‌（来自百度 Ai）

this

this主要用来解决对象的成员变量与方法内部变量的名称一样时，导致访问冲突问题的。

// Student.java
package com.itheima.object;

public class Student {

    double score;

    public void printPass(double score) {
        if (this.score > score) { // 这里的this.score和上面double score的score相同
            // 上面两行右边的score相同，也可以换成score1，但上述写法更规范
            System.out.println("恭喜你，成功上岸！");
        } else {
            System.out.println("很抱歉，你落选了~");
        }
    }

// Test.java
package com.itheima.object;

public class Test {
    public static void main(String[] args) {

        Student s = new Student();
        s.score = 337;
        s.printPass(296);
    }
}
    /*
    恭喜你，成功上岸！
     */

注：

在成员方法中加入 System.out.println(this);会打印出当前对象的地址。

输出结果等同于在主函数中的System.out.println(s);

构造器

构造器作为一种方法，负责类中成员变量的初始化。类似 C++中的构造函数。

构造器，在构造一个类的时候，自动生成一个无参构造器给主函数调用，进行实例化，构造器的存在，可以重载多种形式的方法，让主函数进行实例化，其中最常用的就是生成有参构造器，在实例化时对类中的成员变量进行初始化。

public class Student{
	/** 构造器 */
	public Student(){
		···
	}
}

注意一下格式，在权限修饰符和类名中间没有返回值类型，也就是 public 和 Student 之间没有 void，string 等，要跟方法作区分。

对象创建时，我们可以指定对象去调用哪个构造器执行。

// Student.java
package com.itheima.constructor;

public class Student {

    // 无参数构造器
    public Student() {
        System.out.println("无参数构造器被触发执行了~");
    }

    // 有参数构造器
    public Student(String name, int age) {
        System.out.println("有参数构造器被触发执行了~");
    }
}

// Test.java
package com.itheima.constructor;

public class Test {
    public static void main(String[] args) {

        Student s = new Student("陈平安", 96);
    }
}
    /*
    有参数构造器被触发执行了~
     */

构造器常用于完成对象初始化。

// Student.java
package com.itheima.constructor;

public class Student {
    String name;
    int age;

    // 无参数构造器
    public Student() {
        System.out.println("无参数构造器被触发执行了~");
    }

    // 有参数构造器
    public Student(String name, int age) {
        System.out.println("有参数构造器被触发执行了~");
        this.name = name;
        this.age = age; // 把方法内部的变量传给对象的成员变量
    }
}

// Test.java
package com.itheima.constructor;

public class Test {
    public static void main(String[] args) {

        Student s1 = new Student();
        s1.name = "赊月";
        s1.age = 98;

        Student s2 = new Student("刘羡阳", 99);
        System.out.println(s2.name);
        System.out.println(s2.age);
    }
}
    /*
    无参数构造器被触发执行了~
    有参数构造器被触发执行了~
    刘羡阳
    99
     */

注意：

类在设计时，如果不写构造器，Java 是会为类自动生成一个无参构造器。

一旦定义了有参数构造器，Java 就不会帮我们的类自动生成无参构造器了，此时就建议自己手写一个无参构造器出来。

封装

定义：用类设计对象处理某一个事务的数据时，应该把要处理的数据，以及处理这些数据的方法，设计到一个对象中去。

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

设计规范：合理隐藏，合理暴露。

// Student.java
package com.itheima.encapsulation;

public class Student {
    private double score;

    public void setScore(double score) {
        if (score >= 0 && score <= 100) {
            this.score = score;
        } else {
            System.out.println("数据非法，输入有误~");
        }
    }

    public double getScore() {
        return score;
    }

    public void printPass() {
        System.out.println(score >= 60 ? "成绩合格" : "成绩不及格");
    }
}

// Test.java
package com.itheima.encapsulation;

public class Test {
    public static void main(String[] args) {
        Student s = new Student();
        s.setScore(99); // 如果输入-99，就会变成默认值0.0
        System.out.println(s.getScore());
        s.printPass();
    }
}
    /*
    99.0
    成绩合格
     */

实体类-JavaBean

// Student.java
package com.itheima.javabean;

public class Student {
    // 1.私有成员变量，并为每个成员变量都提供get set方法
    private String name;
    private double score;

    // 2.必须为类提供一个公开的无参构造器
    public Student() {
    }

    public Student(String name, double score) {
        this.name = name;
        this.score = score;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }
}

// StudentOperator.java
package com.itheima.javabean;

public class StudentOperator {
    private Student student; // 用这种成员变量的写法来接上面的实体类

    // 上面的实体类必须有无参构造器，这是操作类不一定需要无参构造器★★★
    public StudentOperator(Student student) {
        this.student = student;
    }

    public void printPass() {
        if (student.getScore() >= 60) {
            System.out.println(student.getName() + "同学的成绩及格~");
        } else {
            System.out.println(student.getName() + "同学的成绩不及格~");
        }
    }
}

// Test.java
package com.itheima.javabean;

public class Test {
    public static void main(String[] args) {
        Student s = new Student();
        s.setName("陆沉");
        s.setScore(95);
        System.out.println(s.getName());
        System.out.println(s.getScore());

        Student s1 = new Student("余斗", 18);
        System.out.println(s1.getName());
        System.out.println(s1.getScore());

        StudentOperator operator = new StudentOperator(s);
        operator.printPass();

    }
}
    /*
    陆沉
    95.0
    余斗
    18.0
    陆沉同学的成绩及格~
     */

成员变量和局部变量

案例练习

查找电影信息

// Moive.java
package com.itheima.moive;

public class Moive {
    private int id;
    private String name;
    private double price;
    private double score;
    private String director;
    private String actor;
    private String info;

    public Moive() {
    }

    public Moive(int id, String name, double price, double score, String director, String actor, String info) {
        this.id = id;
        this.name = name;
        this.price = price;
        this.score = score;
        this.director = director;
        this.actor = actor;
        this.info = info;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    public String getDirector() {
        return director;
    }

    public void setDirector(String director) {
        this.director = director;
    }

    public String getActor() {
        return actor;
    }

    public void setActor(String actor) {
        this.actor = actor;
    }

    public String getInfo() {
        return info;
    }

    public void setInfo(String info) {
        this.info = info;
    }
}

// MoiveOperator.java
package com.itheima.moive;

public class MoiveOperator {
    private Moive[] moives;

    public MoiveOperator(Moive[] moives) {
        this.moives = moives;
    }

    public void PrintAllMoives() {
        if (moives != null) {
            System.out.println("-----开始检索-----");
            for (int i = 0; i < moives.length; i++) {
                System.out.println("id:" + moives[i].getId());
                System.out.println("名称:" + moives[i].getName());
                System.out.println("评分:" + moives[i].getScore());
            }
            System.out.println("-----检索结束-----");
        }
    }

    public void SearchIdMoive(int id) {
        System.out.println("您要查找的电影资源如下:");
        for (int i = 0; i < moives.length; i++) {
            if (moives[i].getId() == id) {
                System.out.println("id:" + moives[i].getId());
                System.out.println("名称:" + moives[i].getName());
                System.out.println("票价:" + moives[i].getPrice());
                System.out.println("评分:" + moives[i].getScore());
                System.out.println("导演:" + moives[i].getDirector());
                System.out.println("主演:" + moives[i].getActor());
                System.out.println("其他:" + moives[i].getInfo());
                return;
            }
        }
        System.out.println("没有id为" + id + "的电影~");
    }
}

// Test.java
package com.itheima.moive;

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        Moive[] moive = new Moive[3];
        moive[0] = new Moive(1, "水门桥", 38.9, 9.8, "徐克", "吴京", "12万人想看");
        moive[1] = new Moive(2, "出拳吧", 39, 7.8, "唐晓白", "田雨", "3.5万人想看");
        moive[2] = new Moive(3, "月球陨落", 42, 7.9, "罗兰", "贝瑞", "17.9万人想看");

        MoiveOperator operator = new MoiveOperator(moive);
        operator.PrintAllMoives();
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请输入要查询详情的电影编号：");
            int choice = sc.nextInt();
            boolean flag = true;
            while (choice < moive.length + 1 && choice > 0) {
                operator.SearchIdMoive(choice);
                flag = false;
                break;
            }
            if (flag == true) {
                System.out.println("错误编号~");
                break;
            }
        }
    }
}
    /*
    -----开始检索-----
    id:1
    名称:水门桥
    评分:9.8
    id:2
    名称:出拳吧
    评分:7.8
    id:3
    名称:月球陨落
    评分:7.9
    -----检索结束-----
    请输入要查询详情的电影编号：
    1
    您要查找的电影资源如下:
    id:1
    名称:水门桥
    票价:38.9
    评分:9.8
    导演:徐克
    主演:吴京
    其他:12万人想看
    请输入要查询详情的电影编号：
    5
    错误编号~
     */

API

定义

常用 API（全称是 Application Program Interface 应用程序接口），说人话就是：别人写好的一些程序，让程序员直接拿去调用。

package com.itheima.pkg.itcat;

public class Demo1 {
    public void print() {
        System.out.println("DEMO1 Hello World");
    }
}

package com.itheima.pkg.itcat;

public class Demo2 {
    public void print() {
        System.out.println("itcat Demo2");
    }
}

package com.itheima.pkg.itmouse;

public class Demo2 {
    public void print() {
        System.out.println("itmouse Demo2");
    }
}

package com.itheima.pkg;

public class Demo {
    public void print() {
        System.out.println("DEMO Hello World");
    }
}

package com.itheima.pkg;

import com.itheima.pkg.itcat.Demo1;
import com.itheima.pkg.itmouse.Demo2;

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

public class Test {
    public static void main(String[] args) {
        // 1.同一个包下的程序，可以直接访问，可以相互调用
        Demo d = new Demo();
        d.print();

        // 2.访问其他包下的程序，必须导包才可以访问。导包格式：import 包名.类名
        Demo1 d2 = new Demo1();
        d2.print();

        // 3.自己的程序中调用Java提供的程序，也需要先导包才可以使用；
        // 注意：Java.lang包下的程序是不需要我们导包的，可以直接使用。
        String s = "黄庭";
        // Scanner和Random是util包下的，需要导包。
        Scanner sc = new Scanner(System.in);
        Random rand = new Random();

        // 4.访问多个其他包下的程序，这些程序名又一样的情况下，默认只能导入一个程序，另一个程序必须带包名和类名来访问
        Demo2 d3 = new Demo2();
        d3.print();

        com.itheima.pkg.itcat.Demo2 d4 = new com.itheima.pkg.itcat.Demo2();
        d4.print();
    }
}
    /*
    DEMO Hello World
    DEMO1 Hello World
    itmouse Demo2
    itcat Demo2
     */

String

package com.itheima.string;

public class StringDemo {
    public static void main(String[] args) {

        // 1.直接双引号得到字符串对象，封装字符串数据　
        String name = "itheima";
        System.out.println(name);

        // 2.new String创建字符串对象，并调用构造器初始化字符串
        String rs1 = new String();
        System.out.println(rs1); // 打印出来就是空的

        String rs2 = new String("itheima");
        System.out.println(rs2);

        char[] chars = {'a', '黑', '马'};
        String rs3 = new String(chars);
        System.out.println(rs3);

        byte[] bytes = {97, 98, 99};
        String rs4 = new String(bytes); // 这俩看看得了，感觉用不到的
        System.out.println(rs4);
    }
}
    /*
    itheima

    itheima
    a黑马
    abc
     */

package com.itheima.string;

public class StringDemo {
    public static void main(String[] args) {

        String s = "黑马Java";
        // 1.获取字符串的长度
        System.out.println(s.length());

        // 2.提取字符串中某个索引位置处的字符
        char c = s.charAt(1);
        System.out.println(c);

        // 字符串的遍历
        for (int i = 0; i < s.length(); i++) {
            // i = 0 1 2 3 4 5
            char ch = s.charAt(i);
            System.out.println(ch);
        }

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

        // 3.把字符串转换成字符数组，再进行遍历
        char[] chars = s.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            System.out.println(chars[i]);
        }

        // 4.判断字符串内容，内容一样就返回true
        String s1 = new String("黑马");
        String s2 = new String("黑马");
        System.out.println(s1 == s2); // 这是判断地址，肯定是false
        System.out.println(s1.equals(s2)); // true

        // 5.忽略大小写比较字符串内容
        String c1 = "34AeFG";
        String c2 = "34aEfG";
        System.out.println(c1.equals(c2)); // false
        System.out.println(c1.equalsIgnoreCase(c2)); // true

        // 6.截取字符串内容（包前不包后）
        String s3 = "剑来--烽火戏诸侯"; // 注意'剑'是0，'来'是1
        String rs = s3.substring(0, 4);
        System.out.println(rs);

        // 7.从当前索引位置一直截取到字符串的末尾
        String rs2 = s3.substring(4);
        System.out.println(rs2);

        // 8.把字符串中的某个内容替换成新内容，并返回新的字符串对象给我们
        String info = "这本书简直是个垃圾，垃圾电影!!";
        String rs3 = info.replace("垃圾", "**");
        System.out.println(rs3);

        // 9.判断字符串中是否包含某个关键字
        String info2 = "二月二，龙抬头。";
        System.out.println(info2.contains("二月"));
        System.out.println(info2.contains("十月"));
        System.out.println(info2.contains("十一月"));

        // 10.判断字符串是否以某个字符串开头
        String rs4 = "张三丰";
        System.out.println(rs4.startsWith("张"));
        System.out.println(rs4.startsWith("张三"));
        System.out.println(rs4.startsWith("张三2"));

        // 11.把字符串按照某个指定内容分割成多个字符串，放到一个字符串数组中返回给我们
        String rs5 = "张三丰,周芷若,殷素素,赵敏";
        String[] names = rs5.split("，");
        for (int i = 0; i < names.length; i++) {
            System.out.println(names[i]);
        }
    }
}
    /*
    6
    马
    黑
    马
    J
    a
    v
    a
    -------------------
    黑
    马
    J
    a
    v
    a
    false
    true
    false
    true
    剑来--
    烽火戏诸侯
    这本书简直是个**，**电影!!
    true
    false
    false
    true
    true
    false
    张三丰,周芷若,殷素素,赵敏
     */

注意事项

package com.itheima.string;

public class StringDemo {
    public static void main(String[] args) {

        // 1. String 的对象是不可变的
        String name = "黑马";
        name += "程序员";
        name += "007";
        System.out.println(name);

        // 2.只要是以双引号给出的字符串对象，存储在常量池中，而且内容相同时只会存储一份
        String s1 = "abc";
        String s2 = "abc";
        System.out.println(s1 == s2); // true 这个比较的是地址

        // 3.new String创建字符串对象，每次new出来的都是一个新的对象，放在堆内存中
        char[] chars = {'a', 'b', 'c'};
        String a1 = new String(chars);
        String a2 = new String(chars);
        System.out.println(a1 == a2); // false
    }
}
    /*
    黑马程序员007
    true
    false
     */

案例练习

package com.itheima.string;

import java.util.Scanner;

public class StringDemo {
    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < 3; i++) {
            System.out.println("请输入账号:");
            String admin = sc.nextLine();

            System.out.println("请输入密码:");
            String password = sc.nextLine();

            if (admin.equals("itheima") && password.equals("123456")) {
                System.out.println("成功登录~");
                break;
            } else {
                System.out.println("输入错误，请重新输入，您还剩" + (2 - i) + "次机会~");
            }
        }
    }
} // 我没有单独设计一个方法，全写在主函数里了。

package com.itheima.string;

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

public class StringDemo {
    public static void main(String[] args) {
        System.out.println("请输入要生成的验证码位数：");
        Scanner sc = new Scanner(System.in);
        int str = sc.nextInt();
        String Code = demo1(str);
        System.out.println(Code);
    }

    public static String demo1(int n) {
        String code = "";
        String data = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
        Random r = new Random();
        for (int i = 0; i < n; i++) {
            int num = r.nextInt(62);
            char c = data.charAt(num);
            code += c;
        }
        return code;
    }
}

ArrayList

ArrayList是Java 集合框架中的一个重要的类，它继承于 AbstractList，实现了 List 接口，是一个长度可变的集合，提供了增删改查的功能。

集合是什么？集合是一种容器，用来存储数据的，集合的大小可变。

package com.itheima.string;

import java.util.ArrayList;

public class StringDemo {
    public static void main(String[] args) {

        // 1.创建一个ArrayList的集合对象
        ArrayList List = new ArrayList(); // 默认大小是10，超过了会自动扩容。
        List.add("Hello");
        List.add("World");
        List.add(2024);
        System.out.println(List); // 这里可以直接打印内容，而不是打印出地址

        // ArrayList本身是泛型类（后续会讲），可以用ArrayList<E> list = new ArrayList<E>();进行约束
        // 在jdk1.7后续版本中，等号后面尖括号中的E可以省略。
        ArrayList<String> list = new ArrayList<>(); // 后面添加到元素都会被约束成String类型
        list.add("JAVA");
        list.add("Python");
        // list1.add(2020);
        System.out.println(list); // [JAVA, Python]

        // 2.往集合中的某个索引位置处添加一个数据
        list.add(1, "MySQL");
        System.out.println(list); // [JAVA, MySQL, Python]

        // 3.根据索引获取集合中某个索引位置处的值
        String rs = list.get(0);
        System.out.println(rs); // JAVA
        /*
        注意：这里我一开始写成了List.get()，也就是上文中不区分类的ArrayList()
        报错详情：java: 不兼容的类型: java.lang.Object无法转换为java.lang.String
        原因：object类型是所有其他类型的基类，索引的时候要么强转为String，要么就改改实例化对象语句。
         */

        // 4.获取集合的大小（返回集合中存储的元素个数）
        System.out.println(list.size()); // 3

        // 5.根据索引删除集合中的某个元素值，会返回被删除的元素值给我们
        System.out.println(list.remove(1));
        System.out.println(list); // [JAVA, Python]

        // 6.直接删除某个元素值，删除成功会返回true
        System.out.println(list.remove("JAVA")); // true
        System.out.println(list); // [Python]

        // 如果有相同的list.move会默认删掉第一个
        list.add("html");
        list.add("hello");
        list.add("html");
        System.out.println(list); // [Python, html, hello, html]
        System.out.println(list.remove("html")); // true
        System.out.println(list); // [Python, hello, html]

        // 7.修改某个索引位置处的数据，修改后会返回原来的值给我们
        System.out.println(list.set(2, "C++")); // html
        System.out.println(list); // [Python, hello, C++]
    }
}

ArrayList 可以直接打印的原因是因为它重写了toString()方法。‌// 看不懂没关系，后续【重写 override 篇】会详解。

当我们尝试直接打印一个对象时，‌ 如 ArrayList，‌ 实际上是在调用该对象的toString()方法。‌ArrayList 类的父类（‌ 或爷爷类）‌ 重写了toString()方法，‌ 使得当我们尝试打印 ArrayList 对象时，‌ 能够输出一个有意义的字符串表示。‌ 这个字符串通常包含了 ArrayList 中的元素信息，‌ 使得我们可以直接看到 ArrayList 的内容。‌ 例如，‌ 如果我们有一个包含几个元素的 ArrayList，‌ 打印这个 ArrayList 将会显示出一个包含这些元素的字符串，‌ 而不是对象的内存地址或其他无关信息。‌

这种机制不仅适用于 ArrayList，‌ 也适用于 Java 中的其他许多类，‌ 只要这些类重写了toString()方法。‌ 这样做的好处是，‌ 当我们需要查看对象的内容时，‌ 可以直接打印对象而不是手动提取对象的各个属性并拼接成字符串，‌ 从而提高了代码的可读性和便利性。‌

此外，‌ 这种机制也适用于更广泛的集合类型，‌ 如 Set、‌List 等，‌ 因为它们都继承自 Collection 接口，‌ 而 Collection 接口及其实现类（‌ 如 ArrayList）‌ 都提供了重写toString()方法的实现，‌ 使得我们可以直接打印这些集合对象来查看其内容。（来自百度 Ai）

案例练习

package com.itheima.string;

public class Food {
    private String name;
    private double price;
    private String desc;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }
}

package com.itheima.string;

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

public class FoodOperator {
    // 1.定义一个ArrayList集合对象，负责存储菜品对象信息
    private ArrayList<Food> foodList = new ArrayList<Food>();

    // 2.开发功能：上架菜品
    public void AddFood() {
        // 3.创建一个菜品对象，封装上架的菜品信息
        Food f = new Food();

        // 4.录入菜品信息进去
        Scanner sc = new Scanner(System.in);

        System.out.print("请输入菜品名称：");
        String name = sc.nextLine();
        f.setName(name);

        System.out.print("请输入菜品价格：");
        double price = sc.nextDouble();
        f.setPrice(price);

        // 读取残留的换行符 ★★★
        sc.nextLine();
        /*
        Scanner 类的 nextLine() 方法和其他读取方法（例如 nextDouble()）一起使用时，会产生一些问题。
        具体来说，调用 nextDouble() 之后并没有读取换行符，
        所以在下次调用 nextLine() 时，它会读取那个残留的换行符，从而导致输入被跳过。
         */

        System.out.print("请输入菜品描述：");
        String desc = sc.nextLine();
        f.setDesc(desc);

        // 5.把菜品对象存入到集合中去
        foodList.add(f);
        System.out.println("上架成功~");
    }

    // 3.展示菜品 foodList = [f1, f2, f3, ...]
    public void ShowFood() {
        if (foodList.isEmpty()) {
            System.out.println("什么菜品都没有，请先上架~");
            return;
        }
        System.out.println("---------------------");
        for (Food f : foodList) {
            System.out.println(f.getName());
            System.out.println(f.getPrice());
            System.out.println(f.getDesc());
            System.out.println("---------------------");
        }
    }

    // 负责展示操作界面
    public void start() {
        Scanner sc = new Scanner(System.in);
        while (true) { // 只要不return就一直循环
            System.out.println("请选择功能：");
            System.out.println("1.上架菜品");
            System.out.println("2.展示菜品");
            System.out.println("3.退出");
            int command = sc.nextInt();
            switch (command) {
                case 1:
                    AddFood();
                    break;
                case 2:
                    ShowFood();
                    break;
                case 3:
                    System.out.println("已退出~");
                    return; // 整个退出
                default:
                    System.out.println("您输入的指令有误~");
            }
        }
    }
}

package com.itheima.string;

public class Test {
    public static void main(String[] args) {
        // 1.设计一个菜品类Food，负责创建菜品对象，封装菜品数据。

        // 2.设计一个菜品操作类FoodOperator，负责完成对菜品的业务实现：上架、浏览信息
        FoodOperator operator = new FoodOperator();
        operator.start();
    }
}

ATM 练习

package com.itheima;

public class Account {
    private String cardId; // 卡号
    private String userName; // 用户名
    private char gender; // 性别
    private String passWord; // 密码
    private double money; // 余额
    private double quotaMoney; //限额

    public String getCardId() {
        return cardId;
    }

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

    public String getUserName() {
        return userName + (gender == '男' ? "先生" : "女士");
    }

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

    public char getGender() {
        return gender;
    }

    public void setGender(char gender) {
        this.gender = gender;
    }

    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;
    }
}

package com.itheima;

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

public class ATM {
    private ArrayList<Account> accounts = new ArrayList<>();

    Scanner sc = new Scanner(System.in);

    public void start() {
        while (true) {
            System.out.println("===欢迎登录ATM系统===");
            System.out.println("1.用户登录");
            System.out.println("2.用户开户");
            System.out.println("请输入您要进行操作的编号:");


            int choice = -1; // 用于存储用户的选择
            try {
                choice = sc.nextInt();
            } catch (InputMismatchException e) {
                System.out.println("输入无效，请输入数字：");
                sc.next(); // 清除当前的错误输入
                continue; // 继续下一次循环
            }
            /*
            sc.next() 是 Java 中 Scanner 类的一个方法，用于读取输入流中的下一个标记（token）。
            当你调用 sc.next() 时，它会尝试从输入流中读取并返回下一个完整的输入。如果输入流中没有更多的标记，它将等待用户输入。
            当用户输入错误的类型时，例如当你期望一个整数但用户输入了一个字符串，Scanner 会抛出一个 InputMismatchException 异常。
            调用 sc.next() 可以跳过当前的错误输入，并准备好读取下一个输入。
            因此，在处理用户输入时，你可以通过这种方式清除错误输入。
             */
            // 上面这个抛出异常，起因是我输入非int型直接报错了，现在看看就得了，我chatgpt的。

            switch (choice) {
                case 1:
                    LoginAccount();
                    break;
                case 2:
                    AddAccount();
                    break;
                default:
                    System.out.println("您输入的指令有误~");
            }
        }
    }

    public void AddAccount() {
        Account ac = new Account();

        System.out.println("请输入姓名：");
        String name = sc.next();
        ac.setUserName(name);

        System.out.println("请输入性别：");
        while (true) {
            char gender = sc.next().charAt(0);
            if (gender == '男' || gender == '女') {
                ac.setGender(gender);
                break;
            } else {
                System.out.println("请您重新输入正确的性别（男或女）：");
            }
        }


        while (true) {
            String password = "";
            String password1 = "";
            System.out.println("请输入六位数密码：");
            while (true) {
                password = sc.next();
                if (password.matches("\\d{6}")) { // 正则表达式
                    break;
                } else {
                    System.out.println("密码违规，请重新输入：");
                }
            }
            System.out.println("[验证]请您再次输入密码以作确认：");//23721100 57856021
            while (true) {
                password1 = sc.next();
                if (password1.matches("\\d{6}")) {
                    break;
                } else {
                    System.out.println("[验证]密码违规，请重新输入：");
                }
            }
            if (password.equals(password1)) {
                ac.setPassWord(password);
                break;
            } else {
                System.out.println("您输入的两次密码不一致~");
            }
        }

        System.out.println("请您输入每次取款的限额：");
        while (true) {
            Double quotamoney = sc.nextDouble();
            if (quotamoney < 100 || quotamoney > 500000) {
                System.out.println("限额违规，请重新输入：");
            } else {
                ac.setQuotaMoney(quotamoney);
                break;
            }
        }

        Random r = new Random();
        String Store = "0123456789";
        String id = "";
        while (true) {
            id = "";
            for (int i = 0; i < 8; i++) {
                int index = r.nextInt(9);
                char c = Store.charAt(index);
                id += c;
            }
            if (getAccountByCarId(id) == null) {

                ac.setCardId(id);
                break;
            }
        }
        accounts.add(ac); // 将新创建的 Account 对象添加到 accounts 列表中

        System.out.println("尊敬的" + ac.getUserName() + "，您已成功开户，您的卡号是：" + ac.getCardId() + "，请您妥善保管卡片信息~");
        // System.out.println(accounts);
    }

    private Account getAccountByCarId(String cardid) {
        for (int i = 0; i < accounts.size(); i++) {
            if (accounts.get(i).getCardId().equals(cardid)) {
                return accounts.get(i);
            }
        }
        // System.out.println("没找到~");
        return null;
    }

    public void LoginAccount() {
        if (accounts.isEmpty()) {
            System.out.println("[提示]当前无账户，请先进行开户操作。");
            return;
        }
        System.out.println("请输入卡号：");
        String cardid = "";
        while (true) {
            cardid = sc.next();
            if (getAccountByCarId(cardid) != null) {
                break;
            } else {
                System.out.println("请重新输入卡号：");
            }
        }
        Account loginAcc = getAccountByCarId(cardid);
        System.out.println("请输入密码：");
        for (int i = 0; i < 5; i++) {
            String password = sc.next();
            if (loginAcc.getPassWord().equals(password)) {
                System.out.println("登录成功~");
                AfterLogin(loginAcc);
                break;
            }
            if (i < 4) {
                System.out.println("您还剩" + (4 - i) + "次机会，请重新输入密码：");
            } else {
                System.out.println("次数已用完，请重新登录~");
            }

        }
    }

    private void AfterLogin(Account loginAcc) {
        while (true) {
            System.out.println("===您可以选择如下操作===");
            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.println("请输入您要进行操作的编号:");

            int choice = -1; // 用于存储用户的选择
            try {
                choice = sc.nextInt();
            } catch (InputMismatchException e) {
                System.out.println("输入无效，请输入数字：");
                sc.next(); // 清除当前的错误输入
                continue; // 继续下一次循环
            }

            switch (choice) {
                case 1:
                    showAccount(loginAcc);
                    break;
                case 2:
                    deposit(loginAcc);
                    break;
                case 3:
                    withdraw(loginAcc);
                    break;
                case 4:
                    transferAccount(loginAcc);
                    break;
                case 5:
                    changePassword(loginAcc);
                    return;
                case 6:
                    return;
                case 7:
                    cancelAccount(loginAcc);
                    return;
                default:
                    System.out.println("您输入的指令有误~");
            }
        }
    }

    private void showAccount(Account loginAcc) {
        System.out.println("用户：" + loginAcc.getUserName());
        System.out.println("卡号：" + loginAcc.getCardId());
        System.out.println("余额：" + loginAcc.getMoney());
        System.out.println("限额：" + loginAcc.getQuotaMoney());
    }

    private void deposit(Account loginAcc) {
        System.out.println("请输入存款金额：");
        Double depositmoney = sc.nextDouble();
        loginAcc.setMoney(loginAcc.getMoney() + depositmoney);
        System.out.println("存款成功，当前余额：" + loginAcc.getMoney());
    }

    private void withdraw(Account loginAcc) {
        Double withdrawmoney = 0.0;

        while (true) {
            System.out.print("请输入转账金额：");
            try {
                withdrawmoney = sc.nextDouble();
            } catch (InputMismatchException e) {
                System.out.println("输入无效，请输入数字：");
                sc.next(); // 清除当前的错误输入
                continue; // 继续下一次循环
            }

            if (loginAcc.getQuotaMoney() < withdrawmoney || loginAcc.getMoney() < withdrawmoney) {
                if (loginAcc.getQuotaMoney() < withdrawmoney) {
                    System.out.println("超过限额，无法取款~");
                } else {
                    System.out.println("当前余额不足~");
                }

                int choice = -1; // 用于存储用户的选择
                while (true) {
                    System.out.println("1.重新输入金额");
                    System.out.println("2.退出");

                    try {
                        choice = sc.nextInt();
                    } catch (InputMismatchException e) {
                        System.out.println("输入无效，请输入数字：");
                        sc.next(); // 清除当前的错误输入
                        continue; // 继续下一次循环
                    }
                    if (choice == 1) {// 这里不能用switch case语句，因为case1只能break掉当前循环，结束不了while循环
                        break;
                    } else if (choice == 2) {
                        return;
                    } else {
                        System.out.println("您输入的指令有误~");
                    }
                }
                if (choice == 1) {
                    continue;
                }

            } else {
                break;
            }
        }

        loginAcc.setMoney(loginAcc.getMoney() - withdrawmoney);
        System.out.println("取款成功，当前余额：" + loginAcc.getMoney());
    }

    private void transferAccount(Account loginAcc) {
        System.out.println("请输入转账卡号：");
        String transferCardId = sc.next();
        Account transferAccount = getAccountByCarId(transferCardId);
        if (transferAccount == null) {
            System.out.println("未找到卡号为 " + transferCardId + " 的账户");
            return;
        }

        Double transfermoney = 0.0;

        while (true) {
            System.out.print("请输入转账金额：");
            try {
                transfermoney = sc.nextDouble();
            } catch (InputMismatchException e) {
                System.out.println("输入无效，请输入数字：");
                sc.next(); // 清除当前的错误输入
                continue; // 继续下一次循环
            }

            if (loginAcc.getMoney() < transfermoney) {
                System.out.println("当前余额不足~");

                int choice = -1; // 用于存储用户的选择
                while (true) {
                    System.out.println("1.重新输入金额");
                    System.out.println("2.退出");

                    try {
                        choice = sc.nextInt();
                    } catch (InputMismatchException e) {
                        System.out.println("输入无效，请输入数字：");
                        sc.next(); // 清除当前的错误输入
                        continue; // 继续下一次循环
                    }
                    if (choice == 1) {// 这里不能用switch case语句，因为case1只能break掉当前循环，结束不了while循环
                        break;
                    } else if (choice == 2) {
                        return;
                    } else {
                        System.out.println("您输入的指令有误~");
                    }
                }
                if (choice == 1) {
                    continue;
                }

            } else {
                break;
            }
        }
        loginAcc.setMoney(loginAcc.getMoney() - transfermoney);
        transferAccount.setMoney(transferAccount.getMoney() + transfermoney);
        System.out.println("转账成功，当前余额：" + loginAcc.getMoney());
    }

    private void changePassword(Account loginAcc) {

        while (true) {
            String password = "";
            String password1 = "";
            System.out.println("请输入您的新密码:");
            while (true) {
                password = sc.next();
                if (password.matches("\\d{6}")) { // 正则表达式
                    break;
                } else {
                    System.out.println("密码违规，请重新输入（6位数字）：");
                }
            }
            System.out.println("[验证]请您再次输入密码以作确认：");
            while (true) {
                password1 = sc.next();
                if (password1.matches("\\d{6}")) {
                    break;
                } else {
                    System.out.println("[验证]密码违规，请重新输入（6位数字）：");
                }
            }
            if (password.equals(password1)) {
                loginAcc.setPassWord(password);
                System.out.println("修改密码成功，请重新登录~");
                break;
            } else {
                System.out.println("您输入的两次密码不一致~");
            }
        }
    }

    private void cancelAccount(Account loginAcc) {
        Account accountByCarId = getAccountByCarId(loginAcc.getCardId());
        accounts.remove(accountByCarId);
        // System.out.println(accounts);
        System.out.println("注销成功，已退出~");
    }

}

package com.itheima;

public class Test {
    public static void main(String[] args) {
        ATM atm = new ATM();
        atm.start();
    }
}