【Java开发】入门学习-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_62604985/article/details/143812819

Java入门学习

Day01 初见java

第一个代码

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

注意代码类名称必须与文件名一致

如何在命令行中进行编译运行？

命令行打开文件所在目录

javac 文件名.java

java 文件名

idea管理java程序结构

英文	含义
project	项目、工程
module	模块
package	包
class	类

常用快捷键

快捷键	功能效果
main/psvm/sout等	快捷键入相关代码
Ctrl+D	复制当前行到下一行
Ctrl+Y/X	删除所在行
Ctrl+Alt+L	格式化代码
Alt+Shitf+↑/↓	上下移动代码
Shift+/	对代码进行注释

Day02 数据类型、运算符

类型转换

自动类型转换：

类型范围小的变量直接赋值给类型范围大的变量

public class Day2 {
    public static void main(String[] args) {
//    自动类型转换
        byte a1=12;
        int b1=a1;
        System.out.println(a1);
        System.out.println(b1);
    }
    }

自动类型转换

byte–>short–>int (char)–>long–>float–>double

强制类型转换

大范围变量不能直接赋值给小范围变量

package hello;
public class Day2 {
    public static void main(String[] args) {
//     强制类型转换
        int a2=20;
        byte b2=(byte)a2;
        System.out.println(a2);
        System.out.println(b2);
    }
    }

如果将超大数据（超过小范围变量范围）强制类型转换给小范围变量会怎么样

package hello;
public class Day2 {
    public static void main(String[] args) {
//     强制类型转换
        int a2=1500;
        byte b2=(byte)a2;
        System.out.println(a2);
        System.out.println(b2);
    }
    }

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

浮点强制转换成为整型，小数部分丢弃

自增自减运算符

自增 ++

自减 - -

同C语言，自增自减前后也有区别；

package hello;
public class Day2 {
    public static void main(String[] args) {
//        自增自减
        int a3=1;
        a3++;
        System.out.println(a3);
        a3--;
        System.out.println(a3);
    }
    }

赋值运算符

基本运算符

= 从右边往左边看

拓展运算符

+= 加后赋值

-= 减后赋值

*= 乘后赋值

/= 除后赋值

%= 取余后赋值

package hello;
public class Day2 {
    public static void main(String[] args) {
//        拓展运算符
        int a4=4;
        int b4=2;
        a4+=b4;
        System.out.println(a4);
        a4/=b4;
        System.out.println(a4);
//        其他的拓展运算符同理
    }
    }

关系运算符

例如> 、>= 、 < 、<= 、== 、 !=

含义理解同C 语言，返回为True和False

逻辑运算符

&: 与运算多个条件必须全是True

|：或运算其中一个条件是True

！逻辑非取反

^ 逻辑异或前后结果相同返回false 结果不同返回false

package hello;
public class Day2 {
    public static void main(String[] args) {
//        目标： 需求手机内存等于8G，尺寸大于6.95英寸
        double size=6.95;
        int storage=8;
        boolean rs=size>=6.95&storage==8;
        System.out.println(rs);
    }
    }

&&（||）与&（|）运算结果相同，但是过程不同，双：判断出错（对）后不再继续运算

三元运算符

格式：

条件表达式?值1:值2；

首先计算关系表达式的值，如果值为true，则返回值1，否则返回值2

package hello;
public class Day2 {
    public static void main(String[] args) {
//        三元运算符
//        判断成绩是否合格
        double  score=95;
        String  ans;
        ans=score>=60?"成绩及格":"成绩不及格";
        System.out.println(ans);
    }
    }

案例技术：用户程序交互

需求：程序中提示用户通过键盘输入自己的姓名、年龄并能在程序中收到这些数据

名词解释： API （应用程序编程接口）： java写好的程序，程序员可以直接使用

使用scanner接收用户键盘输入的数据，步骤如下：
①导包：告诉程序去jdk的那个包中寻找扫描技术
②抄代码：代表得到键盘扫描对象（东西）
③抄代码：等待接收用户输入数据

实际案例

package hello;
import java.util.Scanner;
public class Day2 {
    public static void main(String[] args) {
//        案例展示：用户程序交互
//        1.导包  一般不需要我们导包，idea会自动帮忙
//        2.抄写代码
        Scanner sc=new Scanner(System.in);
//        3.接受用户键盘输入的数据
        System.out.println("请输入您的年龄:");
        int age=sc.nextInt();
        System.out.println("您的年龄是："+age);
        System.out.println("请您输入您的姓名:");
        String name=sc.next();
        System.out.println(name+",欢迎您进入系统");
    }
    }

Day03 循环控制、Random随机数

三种执行顺序：

顺序结构：自上而下的执行代码

分支结构：根据条件、选择对应的代码执行

循环结构：控制某段代码重复执行

分支结构

if

if（条件表达式）{
	代码；
}

if（条件表达式）{
	代码1；
}
else{
	代码2；
}

if（条件表达式1）{
	代码1；
}
else if（条件表达式2）{
	代码2；
}
else{
	代码3；
}

switch

switch（表达式）{
 	case 值1：
 		执行代码；
 		break；
 	case 值2：
 		执行代码；
 		break；
      .....
}

switch案例举例：日程表

注意：

1.switch表达式只能是byte、short、int、char、String不支持double、float和long;

2.case给出的值不能重复且不能为变量;

3.不能忘记写break,否则会出现穿透现象;

循环结构

For循环

package hello;
public class Day2 {
    public static void main(String[] args) {
//        for循环案例
        for(int i = 1; i<5;i++){
            System.out.println("Hello world!");
        }
    }
    }

常见应用场景：减少代码重复编写，灵活的控制程序的执行

While循环

package hello;
public class Day2 {
    public static void main(String[] args) {
//        while循环案例
       int  i=0;
        while(i<5){
            System.out.println("Hello World");
            i++;
        }
    }
    }

while与for的使用方式

知道循环几次时使用for循环，不知道循环几次时使用while

Do while 循环

package hello;
public class Day2 {
    public static void main(String[] args) {

//        do while 循环
        System.out.println("----------------------");
        i=0;
        do {
            System.out.println("Hello World!");
            i++;
        }while(i<5);

    }
    }

do while 先执行，后判断 while 先判断再执行

死循环

可以一直执行下去，没有干预不会停止(服务器程序)

package hello;
public class Day3 {
    public static void main(String[] args) {
//        死循环
        for (  ;  ;  ){
            System.out.println("Hello World!");
        }

        while(true){
            System.out.println("Hello World!");
        }
        
        do {
            System.out.println("Hello World!");
        }while(true)；
    }
    }

循环嵌套

循环中包含循环

可以参照c语言典型的循环嵌套：冒泡排序法

跳转关键字：

break：用于结束所在循环；

continue：用于跳出当前循环的当次执行，直接进入循环的下一次执行；

案例技术：生成随机数

Random技术：生成随机数

使用random技术 步骤如下：
① 导包：告诉jdk去那个包中寻找random
②：写一行代码拿到随机数对象
③：调用随机数的功能获取0-9之间的随机数

package hello;

import java.util.Random;

public class Day3 {
    public static void main(String[] args) {
//        random随机数技术
        Random num = new Random();
        for (i = 0;i<5;i++){
            int data = num.nextInt(10);
            System.out.println(data);
        }
    }

}

如何生成指定区间随机数？

例如：要生成1-10之间的随机数，使用减加法：（1 - 10）=> -1 => (0-9) +1

案例实战：猜数字游戏

要求：随机生成一个1-100之间的数据，提示用户猜测，猜大提示用户过大，猜小提示用户过小，直到猜中结束游戏

package hello;

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

public class Guess_Num {
    public static void main(String[] args) {
        Random Num = new Random();
        int PcN= Num.nextInt(99)+1;
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入您猜测的数字：");
        int UserN= sc.nextInt();
        while(UserN!=PcN){
            if (UserN>PcN)
                System.out.println("您猜测的数字太大");
            else
                System.out.println("您猜测的数字太小");
            System.out.println("请您再猜一次：");
            UserN= sc.nextInt();
        }
        System.out.println("恭喜您！猜对啦！");
    }
}

我的代码与老师的代码有什么区别？

老师使用的是死循环，当猜对后才会调用break跳出死循环;

package hello;
import java.util.Random;
import java.util.Scanner;

public class Guess_Num {
    public static void main(String[] args) {
        Random Num = new Random();
        int PcN= Num.nextInt(99)+1;
        Scanner sc=new Scanner(System.in);
        while (true){
        System.out.println("请输入您猜测的数字：");
        int UserN= sc.nextInt();
            if (UserN>PcN){
                System.out.println("您猜测的数字太大");
                System.out.println("请您再猜一次！");
            } else if (UserN<PcN){
                System.out.println("您猜测的数字太小");
                System.out.println("请您再猜一次！");
            }else{
                System.out.println("恭喜您！猜对啦！");
                break;
            }
        }
    }
}

Day04 数组

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

静态初始化数组:

package hello;

public class Day4 {
    public static void main(String[] args) {
//        静态数组定义与遍历
        int[] ages = new int[]{11,12,13};//完整格式
        int[] Nums = {12,12,12};

//        访问数组数据
        for (int i=0;i<3;i++){
            System.out.println(ages[i]);
        }
    }
}

动态初始化数组

定义数组时不存入具体的元素值，只确定数组的数据类型与数组的长度

package hello;

import java.util.Scanner;

public class Day4 {
    public static void main(String[] args) {
//        动态初始化数组
        int[] score = new int[3];
        for (int j = 0; j <3 ; j++) {
            score[j]=j;
            System.out.println(score[j]);
        }
    }
}

多个变量指向同一数组对象

package hello;

import java.util.Scanner;

public class Day4 {
    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]);
    }
}

案例技术：求最值，数组反转，随即排名

①：求最值

package hello;

import java.util.Scanner;

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

//        数组求最值
        int[] scores = {15, 900, 9000, 54, 55, 456};
        int max = scores[0];
        for (int i = 0; i < 6; i++) {
            if (max < scores[i])
                max = scores[i];
        }
        System.out.println(max);
    }
}

②数组反转

package hello;

import java.util.Scanner;

public class Day4 {
    public static void main(String[] args) {
//        数组反转
        int[] test={1,2,3,4,5,6};
        int temp;
        for (int i=0,j=test.length-1;i<j;i++,j--){
            temp= test[j];
            test[j]=test[i];
            test[i]=temp;
        }
        for (int i=0;i< test.length;i++){
            System.out.println(test[i]);
        }
    }
}

③：随机排名

需求：有五名员工要进行汇报，汇报顺序要进行随机排名

package hello;

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

public class Day4 {
    public static void main(String[] args) {
//        随机排名
        Scanner sc=new Scanner(System.in);
        int[] code=new int[5];
        for (int i=0;i< code.length;i++){
            System.out.println("Please enter the codes:");
            int cod =sc.nextInt();
            code[i]=cod;
        }
        Random r= new Random();
        for (int i=0;i< code.length;i++){
            int Num=r.nextInt(code.length);
            int temp;
            temp = code[Num];
            code[Num]=code[i];
            code[i]=temp;
        }
        for (int i=0;i< code.length;i++){
            System.out.println(code[i]);
        }
    }
}

补充知识：Debug工具使用

断点调试工具，控制代码一行一行执行，在执行过程中观察程序执行情况

使用方法的好处是提高了代码的复用性，使得代码的逻辑更加清晰

注意方法要定义在主程序之外

项目是由一个一个方法堆积而成的

Day05 方法（函数）

概述

修饰符  返回值类型   方法名（形参列表）{
    方法体代码（执行功能代码）；
        return 返回值；
        // 可以定义无参无返方法  有参一定要传参 无参一定不能传参
}

package hello;

public class Day5 {
    //        方法定义
    public static int sum(int a,int b){
        int c=a+b;
        return c;
    }
    
    public static void main(String[] args) {
        int ans=sum(1,2); // 调用函数
        System.out.println(ans);
    }
}

方法案例

package hello;

public class Day5 {

//    求1-n的和
public static int add （int n）{
    int sum=0;
        for (int i=0;i<=n;i++){
        sum+=i;
    }
        return sum;
    }
}

方法重载

一个类中，出现多个方法的名称相同，但是他们的形参列表不同，呢么这些方法就被称为是被重载了

案例需求：

①默认发射一枚武器

②指定地区发射一枚武器

③指定地区发射多枚武器

package hello;

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

        fire();
        fire("hahahah");
        fire("hahahah",6);
    }

    public static void fire(){
        System.out.println("已发射1枚武器！");
    }
    public static void fire(String country){
        System.out.println("已向"+country+"发射1枚武器！");
    }

    public static void fire(String country,int number){
        System.out.println("已向"+country+"发射"+number+"枚武器");
    }
}

Day06 编程案例实战

案例一：抢红包

发起抢红包活动，分别有9，666，188，520，9999五个红包，先来先得，随机抽取，抽完即止，并且一个红包只能被抽取一次，先抽/后抽哪个红包是随机的

需要接收数据处理，接收一个数组
不需要返回数据，直接在方法中完成抽奖
抽完的红包使用0来代替


package hello;

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

public class QiangHongBao {

    public static void main(String[] args) {
        int[] moneys={9,666,188,520,9999};
    	start(moneys);
}
    
    public static void start(int[] moneys){
        Random r=new Random();
        Scanner sc=new Scanner(System.in);
        for (int i=0;i< moneys.length;i++) {
            System.out.println("请您输入任意内容来进行红包抽奖:");
            sc.next();

            while (true) {
                int index = r.nextInt(moneys.length);
                int money = moneys[index];
                if (money != 0) {
                    System.out.println("恭喜您！抽到了 " + moneys[index] + " 元");
                    System.out.println("-*************************************************-");
                    moneys[index] = 0;
                    break;
                }
            }
        }
        System.out.println("本次抽奖活动已结束！");
    }
}
// 本抽奖程序可能有性能问题，需要一次一次检测是否还有空红包

解决性能问题，将红包金额打乱，然后每次抽奖依次取出金额即可

案例二：双色球

双色球红球：1-33 不可重复六位

双色球蓝球：1-13不可重复一位

package hello;

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

public class ShuangSeQiu {

    public static void main(String[] args) {
        int[] UserNumber=User();
        Print(UserNumber);
        int[] PcNumber=Pc();
        System.out.println("---------------------------------------------");
        System.out.println("本期双色球获奖号码为：");
        Print(PcNumber);
        fun(UserNumber,PcNumber);
    }

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


//    用户投注号码,前六个为红球号码，第七个为蓝球号码
    public static int[] User(){
        Scanner sc=new Scanner(System.in);
        int[] numbers= new int[7];
        for (int i=0;i< numbers.length-1;i++){
            while (true) {
                System.out.println("请您输入第"+(i+1)+"个红球号码（1-33之间，不可重复）:");
                int number=sc.nextInt();
                if (number<1|number>33) {
                        System.out.println("对不起，您输入的号码无效，请重新输入！");
                }else{
                        if (judge(numbers,number)){
                            System.out.println("对不起，您输入的号码无效，请重新输入！");
                    }else{
                            numbers[i]=number;
                            break;
                        }
                }
            }
        }
        System.out.println("请您输入蓝球号码（1-16）：");
        while (true) {
            int number= sc.nextInt();
            if (number<1|number>16){
                System.out.println("对不起，您输入的号码无效，请重新输入！");
            }else{
                numbers[6]=number;
                break;
            }
        }
        return numbers;
    }


//    判断双色球是否重复
    public static boolean judge(int[] numbers,int number){
        for (int i=0;i<numbers.length;i++){
            if(numbers[i]==number){
                return true;
            }
        }
    return false;
    }


//    获取双色球中奖号码
    public static int[] Pc(){
        Random ra=new Random();
        int[] numbers=new int[7];
        int number;
        for (int i=0;i< numbers.length-1;i++){
            while(true){
                number=ra.nextInt(32)+1;
                if (!judge(numbers,number)){
                    numbers[i]=number;
                    break;
                }
            }
        }
        number= ra.nextInt(15)+1;
            numbers[6]=number;
    return numbers;
    }

//    判断用户的中奖情况
    public static void fun(int[] arr1,int[] arr2){
        int red=0;
        int blue=0;
        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[6]==arr2[6]?1:0;
        if (red == 6&& blue ==1){
            System.out.println("恭喜您，一等奖!");
        } else if (red==6&&blue==0) {
            System.out.println("恭喜您，二等奖!");
        } else if (red==5) {
            System.out.println("恭喜您，三等奖!");
        } else if (red==4) {
            System.out.println("恭喜您，四等奖!");
        } else if (red == 3||red == 2) {
            System.out.println("恭喜您，五等奖!");
        } else if (red == 1) {
            System.out.println("恭喜您，六等奖!");
        }else {
            System.out.println("很遗憾，您没用中奖!");
        }
    }
}

Day07 面向对象编程

基本快速入门

① 创建学生（Student）类（本节内容Student类均为此）

package object;

public class Student {
    String name;
    double chinese;
    double math;
    double score;

    public void PrintTotalScore(){
        System.out.println(name+"的总成绩为"+(chinese+math));
    }
    public void PrintAverageScore(){
        System.out.println(name+"的平均成绩为"+(chinese+math)/2);
    }
    public void PrintThis(){
        System.out.println(this);
    }
    public void PrintPass(double score){
        if (score > this.score){
            System.out.println("对不起!");
        }else {
            System.out.println("恭喜!");
        }
    }

//    无参构造器
    public Student(){
        System.out.println("无参构造器执行1");
    }
//    有参构造器
    public Student(String name,double math,double chinese,double score){
        System.out.println("有参构造器执行了！");
        this.name=name;
        this.score=score;
        this.math=math;
        this.chinese=chinese;
    }
}

② 创建学生数据

类名 对象名 = new 类名（）

package object;

public class test {
    public static void main(String[] args) {
//        目标：面向对象编程
//        创建一个学生对象，封装一个学生的数据
        Student s1=new Student();
        s1.name="刘宁";
        s1.math=111.5;
        s1.chinese=120.6;
        s1.PrintAverageScore();;
        s1.PrintTotalScore();
//         在创建一个对象
        Student s2=new Student();
        s2.name="LiuNing";
        s2.math=95;
        s2.chinese=99;
        s2.PrintTotalScore();
        s2.PrintAverageScore();

    }
}

万物皆对象

汽车对象找汽车对象处理；手机数据找手机处理；

符合人类思维习惯，使得编程更加简单直观;

对象本质上是一个特殊的数据结构

this 关键字

this 就是一个变量，可以用在方法中，来拿到当前的对象的数据

主要解决：变量名冲突问题

package object;

public class test {
    public static void main(String[] args) {
//        目标：面向对象编程
//        创建一个学生对象，封装一个学生的数据
        Student s1=new Student();
        s1.name="刘宁";
        s1.math=111.5;
        s1.chinese=120.6;
        s1.score=350;
       
       System.out.println(s1);
       s1.PrintThis();
       s1.PrintPass(220);

    }
}

构造器（构造函数）

创建对象时，对象会自动调用构造器

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

一旦定义了有参构造器，java类就不会自动生成无参构造器，需要自己再编写一个

创建对象时，同时完成对对象成员变量的初始化赋值

package object;

public class test {
    public static void main(String[] args) {
//         调用有参构造器
        Student s3=new Student("Liu",99.5,11,12);
        System.out.println(s3.name);
    }
}

封装

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

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

public 和 private 公有私有数据

设置Teacher类

package object;

public class Teacher {
    private double Number;
   
   public void setNumber(double Number){
        if (Number>0&&Number<100){
            this.Number=Number;
        }else {
            System.out.println("数据非法！");
        }
    }
   
   public double getNumber(){
        return Number; 
       
}

package object;

public class test {
    public static void main(String[] args) {
        Teacher t1=new Teacher()；
        t1.setNumber(99);
        System.out.println(t1.getNumber());
    }
}

Java Bean（实体类）

特殊形式的类成员变量全部私有，对外提供getxxx，setxxx方法，必须有一个公有的无参构造器

右击生成 getter and setter

无其他数据处理方式，只能用来保存某个事物数据

package object;
//   建立Phone类
public class Phone {
    private String name;
    private double price;

    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 Phone(String name, double price) {
        this.name = name;
        this.price = price;
    }
    public Phone() {
    }
}

为什么要开发实体类？应用场景

实体类只负责数据存储，而对数据的处理交给其他类来进行完成，以实现数据和数据业务的相互分离

package object;
//   对 Phone进行操作
public class PhoneOperator {
    private Phone phone;
//		接收Phone类中某一具体物体的数据
    public PhoneOperator(Phone phone) {
        this.phone = phone;
    }
    public void PrintPrice() {
        System.out.println(phone.getPrice());
    }
    public void PrintName() {
        System.out.println(phone.getName());
    }
}

package object;
//  		主函数
public class test {
    public static void main(String[] args) {

        Phone p=new Phone();
        p.setPrice(99);
        p.setName("xiaomi");
//			将p中的数据传输给phone操作类
        PhoneOperator phoneOperator=new PhoneOperator(p);
        phoneOperator.PrintName();
        phoneOperator.PrintPrice();
    }
}

面向对象编程实战：电影信息系统设计

需求：

①展示系统中的全部电影（每部电影展示：名称、价格）；

②允许用户根据电影编号（id）查询出每个电影的详细信息；

Movie实体类编写

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

    public Movie(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 Movie() {
    }
    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;
    }


}

Movie操作类编写

public class MovieOperator {
    private Movie[] movies;

    public MovieOperator(Movie[] movies) {
        this.movies = movies;
    }

    public void PrintMovie(Movie[] movies) {
        for (int i = 0; i < movies.length; i++) {
            System.out.println("************************************* ");
            System.out.println("电影ID编号:" + movies[i].getId());
            System.out.println("   名  称：" + movies[i].getName());
            System.out.println("   票  价：" + movies[i].getPrice());
            System.out.println("   得  分：" + movies[i].getScore());
            System.out.println("************************************  ");
        }
    }

    public void FindMovie(int id) {
        for (int i = 0; i < movies.length; i++) {
            if (id == movies[i].getId()) {
                System.out.println("已成功为您查询到ID为" + id + "的电影:" + movies[i].getName());
                System.out.println("电影ID编号:" + movies[i].getId());
                System.out.println("   名  称：" + movies[i].getName());
                System.out.println("   票  价：" + movies[i].getPrice());
                System.out.println("   得  分：" + movies[i].getScore());
                System.out.println("   导  演：" + movies[i].getDirector());
                System.out.println("   主  演：" + movies[i].getActor());
                System.out.println("   信  息：" + movies[i].getInfo());
                return;
            }
        }
        System.out.println("没有该电影信息");
    }

}

Movie主函数编写

import com.sun.security.jgss.GSSUtil;

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        Movie[] movies = new Movie[3];
        MovieOperator movieOperator = new MovieOperator(movies);
        movies[0] = new Movie(1, "你好", 60, 9.9, "niu", "liu", "好看的");
        movies[1] = new Movie(2, "我好", 61, 9.5, "hai", "nihao", "还行");
        movies[2] = new Movie(3, "大家好", 62, 9.1, "dajia", "dajiaren", "tuijjian");
        Scanner scanner = new Scanner(System.in);


        while (true) {
            System.out.println("************电影信息系统************");
            System.out.println("  1.  查询全部电影信息；");
            System.out.println("  2.  查询指定ID电影信息；");
            System.out.println("************请输入指定命令************");
            int command = scanner.nextInt();
            if (command == 1) {
                movieOperator.PrintMovie(movies);
                break;
            } else if (command == 2) {
                System.out.println("请输入您想要查询的电影id:");
                int id = scanner.nextInt();
                movieOperator.FindMovie(id);
                break;
            }else {
                System.out.println("请检查输入！");
            }
        }
    }
}

相较于老师的代码，我在判断command时使用的是if语句，有效避开switch中的break与使得程序中断使用的break冲突，使得程序在完成1/2命令时会自动结束进程，而在输入非法数据时继续循环。

Day08 常见API（应用程序编程接口）

重点学习javabase

包：包是分门别类管理程序的

如何在自己程序中调用其他包下的程序

Demo程序

package Day08;

public class Demo {
    public  void print() {
        System.out.println("你好");
    }
}

package Day08;

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

package Day08;

import lal.Demo1;

public class test1 {
    public static void main(String[] args) {
//        2.访问其他报下的程序，必须导包才能进行
        Demo1 p=new Demo1();
        p.print();
        // 已经添加自动导包
    }
}

package Day08;

import java.util.Scanner;

public class test1 {
    public static void main(String[] args) {
//        3.自己程序调用java的包，也要导包
        Scanner scanner = new Scanner(System.in);
    }
}

package Day08;

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

package lal;

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

package Day08;

import lal.Demo1;

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

public class test1 {
    public static void main(String[] args) {
//        4.访问多个其他包下的程序，这些程序名又一样的情况下，默认只能导入一个程序，另一个程序必须要用报名带类名来进行访问
        Demo2 m=new Demo2();
        m.print();
        lal.Demo2 n=new lal.Demo2();
        n.print();
    }
}

String

构造器

package Day08;

public class StringDemo {
    public static void main(String[] args) {
//        1.直接双引号得到字符串对象，封装字符串数据
        String name="Study Java";
        System.out.println(name);
        
//        2.new string创建字符串，并调用构造器初始化字符串
        String rs1=new String();
        System.out.println(rs1);
        
        String rs2=new String("Study" );
        System.out.println(rs2);
        
        char[] chars={'j','a','v','a'};
        String rs3=new String(chars);
        System.out.println(rs3);
        
        byte[] bytes={97,98,99};
        String rs4=new String(bytes);
        System.out.println(rs4);
        
    }
}

String常用方法

package Day08;

import javax.lang.model.element.NestingKind;

public class StringDemo {
    public static void main(String[] args) {
//        1.直接双引号得到字符串对象，封装字符串数据
        String name="Study Java";
        System.out.println(name);
//        2.new string创建字符串，并调用构造器初始化字符串
        String rs1=new String();
        System.out.println(rs1);

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

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

        byte[] bytes={97,98,99};
        String rs4=new String(bytes);
        System.out.println(rs4);


//        String 常用方法
        String ss="Java";
        
        
//        获取字符串长度
        System.out.println(ss.length());
        
        
//        提取字符串中某个索引位置的字符
        char c= ss.charAt(1);
        System.out.println(c);
        
        
//        字符串遍历
        for (int i = 0; i < ss.length(); i++) {
            char ch=ss.charAt(i);
            System.out.println(ch);
        }
        
        
//        把字符串转换成字符数组在进行遍历
        char[] charss= ss.toCharArray();
        for (int i = 0; i < charss.length; i++) {
            System.out.println(charss[i]);
        }
        
        
//        判断字符串内容，一样就返回true
        String ss1="lalalal";
        String ss2="lalalal";
        System.out.println(ss1.equals(ss2));


//        忽略大小写与另一个内容比较
        ss2="Lalalal";
        System.out.println(ss1.equalsIgnoreCase(ss2));


//        截取字符串内容(包前不包后/从开始到最后)
        String ss3="JAVA是最好的编程语言";
        String stmp=ss3.substring(0,8);
        System.out.println(stmp);
        stmp=ss3.substring(5);
        System.out.println(stmp);


//        某一个内容替换成新内容，并替换新的字符串
        ss3.replace("JAVA","C++");
        System.out.println(ss3);


//        判断字符串中是否包含某个关键字
        System.out.println(ss3.contains("JAVA"));
//        判断字符串是否以某个字开头
        System.out.println(ss3.startsWith("J"));
        System.out.println(ss3.startsWith("JAVA"));


//        把字符串按照某个指定内容分割成多个字符串，放到一个字符串中返回给我们；
        String[] words=ss3.split("A");
        for (int i = 0; i < words.length; i++) {
            System.out.println(words[i]);
        }

    }
}

String是不可变对象

“ ”创建的字符串相同内容只存储一份，存储到字符串常量池

通过new方式创建字符串对象，会把新的对象放在堆内存中

String 案例实战：用户登录系统

package Login;

import java.util.Scanner;

public class Login {
    public static void main(String[] args) {
        for (int i=0;i<3;i++) {
            System.out.println("请您输入登录账号：");
            Scanner scanner=new Scanner(System.in);
            String Username= scanner.next();
            System.out.println("请输入您的登录密码：");
            String Password=scanner.next();
            boolean r=login(Username,Password);
            if(r){
                System.out.println("登录成功！");
                break;
            }else {
                System.out.println("用户名或密码错误！");
            }
        }
    }
    
//    判断账户用户名 密码正确
    public static boolean login(String Username,String Password){
        String Rusername="LiuNing";
        String Rpassword="20212471";
     return Username.equals(Rusername)&&Password.equals(Rpassword);
    }
}

String案例实战：验证码

实现随机产生验证码，验证码的每一位可能是数字大写字母，小写字母

package Day08;

import java.util.Random;

public class YanZhengMa {
    public static void main(String[] args) {
        System.out.println(creatcode(4));
        System.out.println(creatcode(5));
    }

//    创建验证码
    public static String creatcode(int n){
        String code="";
        String data="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";

        Random random=new Random();
        for (int i = 0; i < n; i++) {
            int index=random.nextInt(data.length());
            code+=data.charAt(index);
        }
        return code;
    }
    
}

ArrayList

什么是集合?

集合是一种容器，用来封装数据，类似于数组；

数组定义后，长度就固定了，而集合大小可变，开发中用的更多，例如购物车

如何学ArrayList?

1.会提供创建容器对象的方式

2.会提供相应的方法对容器进行操作

增、删、改、查

package Day08;

import java.util.ArrayList;

public class ArrylistDemo {
    public static void main(String[] args) {
//        创建list集合对象,不规范内容数据类型
        ArrayList list=new ArrayList();
        list.add("牛逼");
        list.add(16);
        list.add(99.9);
        System.out.println(list);
//        规定数据类型为String
        ArrayList<String> list1=new ArrayList<String>();
        list1.add("nihao");
        list1.add("JAVA");

//        往集合中的某个索引位置添加一个数据
        list1.add(2,"MySql");
        System.out.println(list1);

//        根据索引获得集合某个索引位置处的值
        String s=list1.get(1);
        System.out.println(s);

//        返回集合大小(元素存储个数)
        int i=list1.size();
        System.out.println(i);

//        根据索引删除某个元素值,会返回被删除的元素值给我们;
        String ss=list1.remove(1);
        System.out.println(ss);
//        直接删除某个元素值,删除成功返回true,反之false
        System.out.println(list1.remove("nihao"));

//        修改索引处的值,返回原来的值给我们
        String sss= list1.set(0,"JAV");
        System.out.println(sss);

    }
}

ArryList案例实战：购物车

现在购物车中含有java入门，黑枸杞，人字拖，特级枸杞。用户现在不需要购买枸杞了，选择了批量删除，请完成该成绩需求

package Day08;

import java.util.ArrayList;

public class Shop {
    public static void main(String[] args) {
//        创建购物车
        ArrayList<String> list=new ArrayList<>();
        list.add("java入门");
        list.add("宁夏枸杞");
        list.add("黑枸杞");
        list.add("人字拖");
        list.add("特级枸杞");
        list.add("枸杞子");
        System.out.println("展示现在的购物车内容:");
        System.out.println(list);

//        从集合中找到含有枸杞的数据并删除它
        for (int i = 0; i <list.size(); i++) {
            String s=list.get(i);
            if (s.contains("枸杞")) {
                list.remove(s);
                i--;
            }
        }
        System.out.println(list);
    }
}

**注意：**每次删除数据后，会出现跳数据的现象，故每次删除数据后，要进行 i-- 来修正索引

//  解决跳数据的第二种方法： 从后往前删除
for (int i = list.size(); i >=0 ; i--) {
    String s= list.get(i);
    if (s.contains("枸杞"))
        list.remove(s);
  }

ArryList案例实战：模仿外卖系统中的商家系统

需求：（面向对象+ArryList）

完成菜品的上架，以及菜品的信息浏览功能

Food编写：

public class Food {
    private String food;;
    private double price;
    private String info;

    public Food() {
    }

    public Food(String food, double price, String info) {
        this.food = food;
        this.price = price;
        this.info = info;
    }

    public String getFood() {
        return food;
    }

    public void setFood(String food) {
        this.food = food;
    }

    public double getPrice() {
        return price;
    }

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

    public String getInfo() {
        return info;
    }

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

FoodOperator编写：

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

public class FoodOperator {
    private ArrayList<Food> foodlist = new ArrayList<>();


//    上架商品功能
    public void addFood(){
        Food f=new Food();
        Scanner scanner=new Scanner(System.in);

        System.out.println("请您输入菜品名称:");
        String name=scanner.next();
        f.setFood(name);

        System.out.println("请您输入菜品价格:");
        double  price= scanner.nextDouble();
        f.setPrice(price);

        System.out.println("请您输入菜品信息:");
        String info=scanner.next();
        f.setInfo(info);

        foodlist.add(f);
        System.out.println("上架成功!");
        System.out.println("-------------------");
        System.out.println("");
    }

//    展示菜品功能
    public void ShowFood(){
        if (foodlist.size()==0){
            System.out.println("商品为空,请先上架");
            return;
        }
        for (int i = 0; i < foodlist.size(); i++) {
            Food food=foodlist.get(i);
            System.out.println("菜品名称:");
            System.out.println(food.getFood());
            System.out.println("菜品价格:");
            System.out.println(food.getPrice());
            System.out.println("菜品信息:");
            System.out.println(food.getInfo());
            System.out.println("-------------------");
        }
        System.out.println("");
    }

//    负责展示操作界面
    public void start(){
        while (true) {
            System.out.println("系统功能:");
            System.out.println("1.上架商品");
            System.out.println("2.展示商品");
            System.out.println("3.退出系统");
            System.out.println("-------------------");
            System.out.println("请输入您选择的功能:");

            Scanner scanner=new Scanner(System.in);
            System.out.println("-------------------");
            int command =scanner.nextInt();
            switch (command){
                case 1:
                    addFood();
                    break;
                case 2:
                    ShowFood();
                    break;
                case 3:
                    System.out.println("下次再来哦!");
                    //  有效结束方法，退出循环
                    return;
                default:
                    System.out.println("输入命令不存在!");
                    System.out.println("");
            }
        }
    }

}

Operator中：

创建了一个Food类型的集合，每个food类对象下封装有food，price，info三种信息

main程序：

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        FoodOperator operator=new FoodOperator();
        operator.start();
    }
}

Day09 Java基础入门结课作业：ATM系统编写

定义Account账户类，至少包含：卡号，姓名，性别，密码，余额，取现额度

定义ATM类，负责提供所有的业务需求，比如，展示atm的系统欢迎页，开通账户，转账等

定义一个测试类

Account账户类

public class Account {
    private String CardId;
    private String UserName;
    private char sex;
    private String PassWprd;
    private double money;
    private double limit;

    public Account() {
    }

    public Account(String cardId, String userName, char sex, String passWprd, double money, double limit) {
        CardId = cardId;
        UserName = userName;
        this.sex = sex;
        PassWprd = passWprd;
        this.money = money;
        this.limit = limit;
    }

    public String getCardId() {
        return CardId;
    }

    public void setCardId(String cardId) {
        CardId = cardId;
    }

    public String getUserName() {
        return UserName;
    }

    public void setUserName(String userName) {
        UserName = userName;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public String getPassWprd() {
        return PassWprd;
    }

    public void setPassWprd(String passWprd) {
        PassWprd = passWprd;
    }

    public double getMoney() {
        return money;
    }

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

    public double getLimit() {
        return limit;
    }

    public void setLimit(double limit) {
        this.limit = limit;
    }
}

ATM系统编写

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

public class ATM {
    private ArrayList<Account> accounts = new ArrayList<>();
    private Scanner scanner = new Scanner(System.in);
    private Random random = new Random();

    private Account LoginUser;

    //    系统欢迎页
    public void start() {
        while (true) {
            System.out.println("*************欢迎进入小刘银行*************");
            System.out.println("1.用户登录");
            System.out.println("2.用户开户");
            System.out.println("3.退出系统");
            System.out.println("*************欢迎进入小刘银行*************");
            System.out.println();
            System.out.println("请输入您需要的服务");
            int command = scanner.nextInt();
            switch (command) {
                case 1:
                    //                    用户登录
                    Login();
                    break;
                case 2:
                    //                    用户开户
                    CreatAccount();
                    break;
                case 3:
                    return;
                default:
                    System.out.println("您输入的命令不存在!");
                    System.out.println("");
            }
        }
    }


    
    //    开户功能实现
    private void CreatAccount() {
        Account account = new Account();
        System.out.println();
        System.out.println();
        System.out.println();
        System.out.println("***************系统开户***************");
        System.out.println("请输入您的开户信息：");

        System.out.println("账户名称：");
        String name = scanner.next();
        account.setUserName(name);

        while (true) {
            System.out.println("性别：");
            char sex = scanner.next().charAt(0);
            if (sex == '男' || sex == '女') {
                account.setSex(sex);
                break;
            } else {
                System.out.println("您输入的性别有误，请重新输入!");
            }
        }

        while (true) {
            System.out.println("密码：");
            String password = scanner.next();
            System.out.println("请再次输入密码：");
            String Rpassword = scanner.next();
            if (Rpassword.equals(password)) {
                account.setPassWprd(password);
                break;
            } else {
                System.out.println("您两次输入的密码不一致，请重新确认！");
            }
        }

        System.out.println("取现额度：");
        double limit = scanner.nextDouble();
        account.setLimit(limit);

        System.out.println("系统已自动为您生成卡号：");
        account.setCardId(CreatCardId());
        System.out.println(account.getCardId());

        accounts.add(account);
        System.out.println("恭喜您！" + account.getUserName() + "开户成功！");
        System.out.println();
        System.out.println();
        System.out.println();
    }

    
    //    生成卡号
    private String CreatCardId() {
        String cardid = "";
        while (true) {
            for (int i = 0; i < 8; i++) {
                int data = random.nextInt(10);
                cardid += data;
            }
            Account account = FindCardId(cardid);
            if (account == null) {
                return cardid;
            }
        }
    }

    
    //    根据用户卡号进行寻找账户
    private Account FindCardId(String cardid) {
        for (int i = 0; i < accounts.size(); i++) {
            Account account = accounts.get(i);
            if (account.getCardId().equals(cardid))
                return account;
        }
        return null;
    }

    
    //    用户登录功能;
    private void Login() {
        System.out.println("***************用户登录***************");
        if (accounts.size() == 0) {
            System.out.println("系统中无任何账户，请先开户");
            System.out.println();
            System.out.println();
            System.out.println();
            return;
        }
        while (true) {
            System.out.println("请您输入您的登录卡号:");
            String cardid = scanner.next();
            Account account = FindCardId(cardid);
            if (account == null) {
                System.out.println("您输入的账户不存在！");
            } else {
                while (true) {
                    System.out.println("请输入您的密码:");
                    String password = scanner.next();
                    if (account.getPassWprd().equals(password)) {
                        System.out.println("恭喜您！" + account.getUserName() + "登录成功！");
                        LoginUser = account;
                        Operator();
                        return;  //跳出并结束当前登录方法
                    } else {
                        System.out.println("请重新输入密码");
                    }
                }
            }
        }
    }

    
    //    操作页面
    private void Operator() {
        while (true) {
            System.out.println(LoginUser.getUserName() + ",您可以选择如下功能:");
            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.注销当前账户");
            int command = scanner.nextInt();
            switch (command) {
                case 1:
                    ShowInfoLoginU();
                    break;
                case 2:
                    cunqian();
                    break;
                case 3:
                    quqian();
                    break;
                case 4:
                    zhuanzhang();
                    break;
                case 5:
                    xiugai();
                    return;
                case 6:
                    System.out.println(LoginUser.getUserName() + "再见！欢迎下次再来~");
                    System.out.println();
                    System.out.println();
                    return;
                case 7:
                    if (xiaohu()){
                        return;
                    }
                    break;
                default:
                    System.out.println("当前选择操作不存在");
            }
        }
    }



    //    展示当前登录账户信息;
    private void ShowInfoLoginU() {
        System.out.println();
        System.out.println();
        System.out.println("***************当前账户信息***************");
        System.out.println("卡号：" + LoginUser.getCardId());
        System.out.println("用户名：" + LoginUser.getUserName());
        System.out.println("用户性别：" + LoginUser.getSex());
        System.out.println("用户余额：" + LoginUser.getMoney());
        System.out.println("转账额度:" + LoginUser.getLimit());
        System.out.println();
        System.out.println();
    }

    
//    存钱
    private void cunqian() {
        System.out.println("==存钱==");
        System.out.println("请您输入存款金额：");
        double money = scanner.nextDouble();
        LoginUser.setMoney(LoginUser.getMoney() + money);
        System.out.println("恭喜您，成功存款" + money + "元，当前余额为：" + LoginUser.getMoney() + "元");
        System.out.println();
        System.out.println();
        return;
    }


    
//    取钱
    private void quqian() {
        System.out.println("==取钱==");
        if (LoginUser.getMoney() == 0) {
            System.out.println("对不起，您的账户余额为0");
            System.out.println();
            System.out.println();
            return;
        }
        while (true) {
            System.out.println("请您输入取款金额：");
            double money = scanner.nextDouble();
            if (LoginUser.getMoney() < money) {
                System.out.println("对不起，您当前的账户余额不足，当前余额为：" + LoginUser.getMoney() + "元");
            } else if (LoginUser.getLimit() < money) {
                System.out.println("对不起，您的取款金额超过单次取款限额，请重新输入");
            } else {
                LoginUser.setMoney(LoginUser.getMoney() - money);
                System.out.println("恭喜您，成功取款" + money + "元，当前余额为：" + LoginUser.getMoney() + "元");
                break;
            }
        }
        System.out.println();
        System.out.println();
    }

    
//    转账
    private void zhuanzhang() {
        System.out.println("==转账==");
        if (accounts.size() < 2) {
            System.out.println("当前系统中只有一个账户，无法转账");
            return;
        }
        if (LoginUser.getMoney() == 0) {
            System.out.println("当前账户余额为0");
            return;
        }
        while (true) {
            System.out.println("请输入收款人卡号:");
            String cardid = scanner.next();
            Account account = FindCardId(cardid);
            if (account == null) {
                System.out.println("对不起，您输入的卡号不存在，请检查");
            } else {
                String name = "*" + account.getUserName().substring(1);
                System.out.println("请输入【" + name + "】的姓氏:");
                String preName = scanner.next();
                if (account.getUserName().startsWith(preName)) {
                    while (true) {
                        System.out.println("请您输入转账金额");
                        double money = scanner.nextDouble();
                        if (LoginUser.getMoney() < money) {
                            System.out.println("对不起，您的余额不足，请重新输入");
                        } else {
                            System.out.println("恭喜您，转账成功");
                            LoginUser.setMoney(LoginUser.getMoney() - money);
                            account.setMoney(account.getMoney() + money);
                            System.out.println("当前账户余额：" + LoginUser.getMoney() + "元");
                            System.out.println("目标账户余额：" + account.getMoney() + "元");
                            return;
                        }
                    }
                } else {
                    System.out.println("对不起，请重新确认您的转账信息");
                }
            }
            System.out.println();
            System.out.println();
        }
    }

    //销户
    private boolean xiaohu() {
        System.out.println("==销户==");
        System.out.println("请问您确认销户吗？Y/N");
        String command=scanner.next();
        switch (command){
            case "Y" :
                if (LoginUser.getMoney()==0){
                    System.out.println("恭喜您，销户成功！");
                    accounts.remove(LoginUser);
                    return true;
                }else {
                    System.out.println("对不起，您的账户中有余额："+LoginUser.getMoney()+"元");
                    return false;
                }
            default:
                System.out.println("您的账户保留");
                return false;
        }
    }

    //修改密码
    private void xiugai(){
        System.out.println("==修改密码==");
        while (true) {
            System.out.println("请您输入旧密码：");
            String password=scanner.next();
            if (LoginUser.getPassWprd().equals(password)){
                System.out.println("验证成功！");
                while (true) {
                    System.out.println("请输入新密码：");
                    String Password = scanner.next();
                    System.out.println("请再次输入密码：");
                    String RPassword = scanner.next();
                    if (Password.equals(Password)) {
                        LoginUser.setPassWprd(Password);
                        System.out.println("恭喜您，成功修改密码");
                        System.out.println("请重新登录");
                        return;
                    } else {
                        System.out.println("您两次输入的密码不一致，请重新确认！");
                    }
                }
            }else {
                System.out.println("您输入的密码不正确。");
            }
        }
    }
}

Test测试类编写

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

out.println(“恭喜您，转账成功”);
LoginUser.setMoney(LoginUser.getMoney() - money);
account.setMoney(account.getMoney() + money);
System.out.println(“当前账户余额：” + LoginUser.getMoney() + “元”);
System.out.println(“目标账户余额：” + account.getMoney() + “元”);
return;
}
}
} else {
System.out.println(“对不起，请重新确认您的转账信息”);
}
}
System.out.println();
System.out.println();
}
}

//销户
private boolean xiaohu() {
    System.out.println("==销户==");
    System.out.println("请问您确认销户吗？Y/N");
    String command=scanner.next();
    switch (command){
        case "Y" :
            if (LoginUser.getMoney()==0){
                System.out.println("恭喜您，销户成功！");
                accounts.remove(LoginUser);
                return true;
            }else {
                System.out.println("对不起，您的账户中有余额："+LoginUser.getMoney()+"元");
                return false;
            }
        default:
            System.out.println("您的账户保留");
            return false;
    }
}

//修改密码
private void xiugai(){
    System.out.println("==修改密码==");
    while (true) {
        System.out.println("请您输入旧密码：");
        String password=scanner.next();
        if (LoginUser.getPassWprd().equals(password)){
            System.out.println("验证成功！");
            while (true) {
                System.out.println("请输入新密码：");
                String Password = scanner.next();
                System.out.println("请再次输入密码：");
                String RPassword = scanner.next();
                if (Password.equals(Password)) {
                    LoginUser.setPassWprd(Password);
                    System.out.println("恭喜您，成功修改密码");
                    System.out.println("请重新登录");
                    return;
                } else {
                    System.out.println("您两次输入的密码不一致，请重新确认！");
                }
            }
        }else {
            System.out.println("您输入的密码不正确。");
        }
    }
}

}


### Test测试类编写

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