java笔记2

Java基础进阶笔记

面向对象程序设计（oop）

设计对象并使用

• 类是对象共同特征的描述

• 对象是真实存在的具体实例

• 在java中必须先设计类在创建对象再使用

public class 类名{
    1.成员变量（代表属性，一般是名词）
    2.成员方法（代表行为，一般是动词）
    3.构造器
    4.代码块
    5.内部类
}

创建对象：
类名  对象名 = new 类名（）；

对象名.成员变量
对象名.成员方法（）；

注意事项：
类名首字母建议大写,且有意义,满足“驼峰模式”


一个Java文件中可以定义多个class类,但只能一个类是public修饰,而且public修饰的类名必须成为代码文件名。
实际开发中建议还是一个文件定义一个class类。


成员变量的完整定义格式是:修饰符数据类型 变量名称=初始化值;一般无需指定初始化值,存在默认值。

public String name；

默认值：
byte short int long      0
double                   0.0
boolean                  false
String等引用类型           null

对象在内存中的运行机制

多个对象的内存图

两个变量指向同一个对象内存图

构造器

构造器的作用：

• 定义在类中的，可以用于初始化一个对象，并返回对象的地址

修饰符 类名（形参列表）{
    ...
}


public class Car{
    ...
    //无参构造器
        public Car(){
        
    }
    
    //有参构造器
    public Car(String n,double p){
        ...
    }
    
}

• 任何类型定义出来，默认自带了无参数构造器，写不写都有
• 写了有参构造器无参构造器自动就没了，如果要用就需要写

this关键字

可以出现在构造器、方法中

代表当前对象的地址

• 可以用于指定访问当前对象的成员变量、成员方法

封装

告诉我们如何正确设计对象的属性和方法

对象代表什么，就待封装在对应的数据，并提供数据对应的行为

标准的 JavaBean

• 也可称为实体类，起对象可以在程序中封装数据

成员变量和局部变量

综合案例

package com.wuxibin.demo;

public class Test {
    public static void main(String[] args) {
        /**
         * "《长津湖》",9.7,"吴京"
         * "《我和我的父辈》",9.6,"吴京"
         * "《扑水少年》",9.5,"王川"
         */
        Movie[] Movies = new Movie[3];

        Movie m1 = new Movie("《长津湖》",9.7,"吴京");
        Movie m2 = new Movie("《我和我的父辈》",9.6,"吴京");
        Movie m3 = new Movie( "《扑水少年》",9.5,"王川");

        Movies[0] = m1;
        Movies[1] = m2;
        Movies[2] = m3;

        for (int i = 0; i < Movies.length; i++) {
            Movie m = Movies[i];
            System.out.println("电影的名字是："+m.getName());
            System.out.println("电影的评分是："+m.getScore());
            System.out.println("电影的主演是："+m.getActor());
            System.out.println("------------------------------");
        }

    }
}





package com.wuxibin.demo;

public class Movie {
    private String name;
    private double score;
    private String actor;

    public Movie() {
    }

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

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

    public String getActor() {
        return actor;
    }

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

API

• java写好的技术

http://www.oracle.com/technetwork/java/javaes/downloads/index.html

String

• String类定义的变量可以用于储存字符串，同时String类提供了很多操作字符串的功能，我们可以直接使用
• java.lang.String 类代表字符串，String类定义的变量可以用于指向字符串对象，然后操作该字符串

String name = "小黑";
String shoolName = "黑马程序员";

String 类的特点

• String其实常被称为不可变字符串类型，他的对象在创建后不能被改变
• 以" "方式给出的字符串对象，在字符串常量池中储存

String类创建对象的两种方式

• 一、 直接使用 “” 定义：

String name = "学生1"

• 二、 通过String类的构造器创建对象

区别:

• 以“”方式给出的字符串对象，在字符串常量池中存储，而且相同的内容只会在其中存储一份
• 通过构造器new对象，每new一次都会产生一个新对象，放在堆内存中

String 常用的其他API：

equers方法   比较字符串内容是否一样

package com.wuxibin.Demo01;

public class StringExec {
    /*
    * String 类常用的API
    * */
    public static void main(String[] args) {
        //1.public int length();获取字符串长度
        String name = "我爱你中国love";
        System.out.println(name.length());
        //2.public char charAt(int index):获取某个索引位置处的字符
        char c = name.charAt(1);
        System.out.println(c);

        System.out.println("--------------------");
        for (int i = 0; i < name.length(); i++) {
            System.out.println(name.charAt(i));
        }
        //3.public char() toCharArray(); :把字符串转换成字符数组
        char[] chars = name.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            char ch = chars[i];
            System.out.println(ch);
        }
        //4.public String substring(int beginIndex,int endIndex); 包前不包后
        String name2 = "java是最厉害的语言";
        String rs = name2.substring(0,9);
        System.out.println(rs);
        String rs2 = name2.substring(4,9);
        System.out.println(rs2);
        //5.public String substring(int begIndex) ; 从当前索引一直截取到末尾
        String rs1 = name2.substring(4);
        System.out.println(rs1);
        //6.public String replace(CharSequence target,CharSequence replacement)
        String name3 = "金三胖是最厉害的80后，金三胖棒棒的！";
        String rs3 = name3.replace("金三胖","***");
        System.out.println(rs3);
        //7.public boolean contains(CharSequence s)
        System.out.println(name3.contains("金三胖"));
        System.out.println(name3.contains("金二胖"));
        //8.public boolean starsWiths(String prefix)
        System.out.println(name3.startsWith("金三胖"));
        System.out.println(name3.startsWith("金三胖是最不厉害的"));
        //9.public String[] split(String s)  :按照某个内容把字符串分割成字符串数组返回
        String name4 = "王宝强，贾乃亮，程宇凡";
        String[] names = name4.split(",");
        for (int i = 0; i < names.length; i++) {
            System.out.println("选择了："+names[i]);
        }
    }
}

String案例:

//随机五位数验证码
package com.wuxibin.Demo03oop;

import java.util.Random;

public class Test03 {
    public static void main(String[] args) {
        //定义可能出现的字符信息
        String dates = "abcdefghigklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ123456789";

        //循环五次，每次生成一个随机索引，提取对应的字符连接起来即可
        String code = "";
        Random r =new Random();
        for (int i = 0; i < 5; i++) {
            //随机一个索引
            int index = r.nextInt(dates.length());
            char a = dates.charAt(index);
            code += a;
        }

        //输出字符串变量即可
        System.out.println(code);
    }
}

//模拟用户登录功能，三次登录机会：

package com.wuxibin.Demo03oop;

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

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

        //2.定义一个循环，循环三次，让用户登录
        Scanner sc =new  Scanner(System.in);
        for (int i = 1; i <= 3; i++) {
            System.out.println("请输入登录名称");
            String loginName = sc.next();
            System.out.println("请输入登录密码");
            String password = sc.next();

            //3.判断登录是否成功
            if (okLoginName.equals(loginName)){
                if (okPassword.equals(password)){
                    System.out.println("登录成功！欢迎进入系统~~~~");
                    break;
                }
                System.out.println("密码错误！您剩余"+(3-i)+"次机会");
            }else{
                System.out.println("登录名错误！您剩余"+(3-i)+"次机会");
            }
        }
    }
}

//手机号码屏蔽

package com.wuxibin.Demo03oop;

import java.util.Random;
import java.util.Scanner;
//以字符串的形式从键盘接受一个手机号，将中间四位号码屏蔽，最终效果为： 158****7839
public class Test03 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请您输入手机号码：");
        String tel = sc.next();

        // 2.截取号码的前三位后四位
        String before = tel.substring(0,3);//0 1 2
        String after = tel.substring(7);//从索引开始截取到末尾

        String s = before + "****" + after;
        System.out.println(s);
    }
}

ArrayList

集合是与数组相似，也是一种容器，用于帐数据的

• 数组定义完成启动后，类型确定，长度固定。
• 集合的大小不固定，启动后可动态变化，类型也可以不固定
• 集合非常适合做元素个数不确定，且要进行增删操作的业务场景
• 集合的提供了许多丰富、好用的功能，而数组的功能单一

ArrayList是集合的一种，他支持索引

public ArrayList()    创建一个空的集合对象

方法名	说明
public boolean add(E e)	将指定的元素追加到此集合的末尾
public void add(int index , E e)	在此集合中的指定位置插入指定的元素

package com.wuxibin.Demo03oop;

import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;
//以字符串的形式从键盘接受一个手机号，将中间四位号码屏蔽，最终效果为： 158****7839
public class Test03 {
    public static void main(String[] args) {
        //创建ArrayList集合的对象
        ArrayList list = new ArrayList();
        list.add("java");
        list.add("java");
        list.add("MySQL");
        list.add("黑马");
        list.add(23);
        list.add(23.5);
        list.add('中');

        list.add(1,"杨");
        System.out.println(list);
    }
}

泛型类

• ArrayList:

  其实就是一个泛型类，可以在编译截断约束集合

ArrayList集合常用放方法：

package com.wuxibin.Demo03oop;

import java.util.ArrayList;


public class Test03 {
    public static void main(String[] args) {
       ArrayList<String> list = new ArrayList<String>();//JKD 1.7开始，泛型后面的类型声明可以不用写
        list.add("java");
        list.add("java");
        list.add("MySQL");
        list.add("MyBatis");
        list.add("HTML");


        //1.public E get(int index) :获取某个索引位置处的元素值
        String e = list.get(3);
        System.out.println(e);
        //2.public int size() :获取集合的大小（元素个数）
        System.out.println(list.size());
        //3.完成集合的遍历
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }

        //4.public E remove(int index):删除某个索引位置处的元素值，并返回被删除的元素值
        System.out.println(list);
        String e2 = list.remove(2);
        System.out.println(e2);
        System.out.println(list);

        //5.public boolean remove(Object o):直接删除元素值，删除成功返回true，删除失败返回false
        System.out.println(list.remove("MyBatis"));
        System.out.println(list);


        ArrayList<String> list1 = new ArrayList<>();
        list1.add("java");
        list1.add("MyBatis");
        list1.add("java");
        list1.add("HTML");
        System.out.println(list1);
        //只会删除第一次出现的元素值，后面的不会删除
        System.out.println(list1.remove("java"));
        System.out.println(list1);

        //6.public E set(int index,E element):修改某个索引位置处的元素值。
        String e3 = list1.set(0,"Date");
        System.out.println(e3);
        System.out.println(list1);
    }
}

案例

遍历并删除元素值

package com.wuxibin.Demo03oop;

import java.util.ArrayList;

public class Test04 {
    public static void main(String[] args) {
        //目标：遍历并删除元素的正确方案：
        //1.创建一个ArrayList集合存储一个班级学生的成绩
        ArrayList<Integer> scores =new ArrayList<>();
        scores.add(98);
        scores.add(77);
        scores.add(66);
        scores.add(89);
        scores.add(79);
        scores.add(50);
        scores.add(100);
        System.out.println(scores);

        //2.遍历集合中的元素并将低于80的删除
          方法一： i --
        for (int i = 0; i < scores.size(); i++) {
            int score = scores.get(i);
            if (score < 80){
                scores.remove(i);
                i --;
            }
        }
        System.out.println(scores);
        
        
        //放法二    倒着遍历

        for (int i = scores.size()-1; i >= 0; i--) {
            int score = scores.get(i);
            if (score < 80){
                scores.remove(i);
            }
        }
        System.out.println(scores);
    }
}

影片信息在程序中的表示


package com.wuxibin.Demo03oop;

import java.util.ArrayList;

/*
 目标：理解ArrayList集合存储自定义类型的对象
"《肖申克的救赎》",9.7,"罗宾斯"
"《霸王别姬》",9.6,"张国荣，张丰毅"
"《阿甘正传》",9.5,"汤姆·汉克斯"*/
public class Test04 {
    public static void main(String[] args) {
        //1.定义电影类
        //2.创建三个电影对象
        Movie m1 = new Movie("《肖申克的救赎》",9.7,"罗宾斯");
        Movie m2 = new Movie("《霸王别姬》",9.6,"张国荣，张丰毅");
        Movie m3 = new Movie("《阿甘正传》",9.5,"汤姆·汉克斯");
        //3.创建一个电影类型的ArrayList集合，存储三部电影对象
        ArrayList<Movie> list = new ArrayList<>();
        list.add(m1);
        list.add(m2);
        list.add(m3);
        System.out.println(list);

        for (int i = 0; i < list.size(); i++) {
            Movie m = list.get(i);
            System.out.println("电影的名字是："+m.getName());
            System.out.println("电影的评分是："+m.getScore());
            System.out.println("电影的主演是："+m.getActor());
            System.out.println("------------------------");
        }

    }
}


package com.wuxibin.Demo03oop;

public class Movie {
    private String name ;
    private double score ;
    private String actor ;

    public Movie() {
    }

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

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

    public String getActor() {
        return actor;
    }

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

集合中存储的元素并不是对象本身，而是对象的地址

ArrayList 集合案例：元素搜索

//学生系统的数据搜索
学号       姓名     年龄     班级
20180302  叶孤城    23     护理一班
20180303  东方不败  23      推拿二班
20180304  西门吹雪  26     中药学四班
20180305  梅超风    26     神经科二班
后台程序需要存储如上学生信息并展示，然后要提供按照学号搜索学生信息的功能


package com.wuxibin.Demo03oop;

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

public class Test05 {
    public static void main(String[] args) {
        /*学生系统的数据搜索
        学号       姓名     年龄     班级
        20180302  叶孤城    23     护理一班
        20180303  东方不败  23      推拿二班
        20180304  西门吹雪  26     中药学四班
        20180305  梅超风    26     神经科二班
        后台程序需要存储如上学生信息并展示，然后要提供按照学号搜索学生信息的功能*/


        System.out.println("学号        名称     年龄   班级");
        ArrayList<Students> Student = new ArrayList<>();
        Student.add(new Students("20180302", "叶孤城",23,"护理一班"));
        Student.add(new Students("20180303", "东方不败",23,"推拿二班"));
        Student.add(new Students("20180304", "西门吹雪",26,"中药学四班"));
        Student.add(new Students("20180305", "梅超风",26,"神经科二班"));
        for (int i = 0; i < Student.size(); i++) {
            Students s = Student.get(i);
            System.out.println(s.getStudyNumber()+"\t"+s.getName()+"\t"+s.getAge()+"\t"+s.getClassName() );
        }

        Scanner sc = new Scanner(System.in);
        while (true){
            System.out.println("请您输入学号：");
            String studyNumber = sc.next();

            Students s = getStudentByIn(Student,studyNumber);

            if (s == null){
                System.out.println("对不起，查无此人~~~");
            }else {
                System.out.println("您查询的学生信息如下：");
                System.out.println(s.getStudyNumber()+"\t"+s.getName()+"\t"+s.getAge()+"\t"+s.getClassName() );

            }
        }

    }

    /**
     * 根据学生的学号查询学生对象返回
     * @param s   存储全部学生对象的集合
     * @param studyNumber  搜索的学生的学号
     * @return
     */
    public static Students getStudentByIn(ArrayList<Students> s,String studyNumber){
        //1.遍历全部学生对象
        for (int i = 0; i < s.size(); i++) {
            Students s1 = s.get(i);
            if (s1.getStudyNumber().equals(studyNumber)){
                return s1;
            }
        }
        return null;
    }
}




package com.wuxibin.Demo03oop;

public class Students {
    private String studyNumber;
    private String name;
    private int age;
    private String className;

    public Students() {
    }

    public Students(String studyNumber, String name, int age, String className) {
        this.studyNumber = studyNumber;
        this.name = name;
        this.age = age;
        this.className = className;
    }

    public String getStudyNumber() {
        return studyNumber;
    }

    public void setStudyNumber(String studyNumber) {
        this.studyNumber = studyNumber;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }
}

ATM系统

import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;
/*
* ATM系统的入口类
* */
public class ATMSystem {
    public static void main(String[] args) {
        //1.定义账户类
        //2.定义一个集合容器，储存以后的账户对象，进行相关的业务操作
        ArrayList<Account> accounts = new ArrayList<>();
        //3.展示系统的首页
        while (true) {
            System.out.println("===========ATM系统===========");
            System.out.println("1.账户登录");
            System.out.println("2.账户注册");
            Scanner sc = new Scanner(System.in);
            System.out.println("请您选择操作：");
            int command = sc.nextInt();

            switch (command){
                case 1:
                    // 用户登录
                    login(accounts,sc);
                    break;
                case 2:
                    // 用户注册
                    register(accounts,sc);
                    break;
                default:
                    System.out.println("您输入的命令不存在~~~");
            }
        }
    }

    /**
     *  登录功能
     * @param accounts 全部账户的集合
     * @param sc  扫描器
     */
    private static void login(ArrayList<Account> accounts, Scanner sc) {
        System.out.println("=========系统登录操作========");
        //1.判断账户集合汇总中是否存在账户，如果不存在，登录不能进行
        if(accounts.size() == 0){
            System.out.println("对不起，当前系统中，无任何好账户，请先开户，再来登录~~");
            return; //
        }

        //2。登录操作
        while (true) {
            System.out.println("请您输入登录卡号：");
            String cardId = sc.next();
            //3.判断卡号是否存在，根据卡号去账户集合中查询账户对象
            Account acc = getAccountByCardId(cardId,accounts);
            if(acc != null){
                while (true) {
                    //卡号存在
                    //让用户输入密码
                    System.out.println("请您输入登录密码：");
                    String passWord = sc.next();
                    if(acc.getPassWord().equals(passWord)){
                        //登录成功
                        //展示登录获得操作
                        System.out.println("恭喜您，"+ acc.getUserName()+"先生/女生进入系统，您的卡号是："+acc.getCardId());
                        showUserCommand(sc,acc,accounts);
                        return;
                    }else {
                        System.out.println("对不起，您输入的密码有误~~");
                    }
                }
            }else {
                System.out.println("对不起，系统中不存在该账户卡号~~");
            }
        }

    }

    /**
     * 展示登录后的操作页
     */
    private static void showUserCommand(Scanner sc,Account acc,ArrayList<Account> accounts) {
        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 command = sc.nextInt();
            switch (command){
                case 1:
                    // 查询账户
                    showAccount(acc);
                    break;
                case 2:
                    // 存款
                    depositMoney(acc,sc);
                    break;
                case 3:
                    // 取款
                    drawMoney(acc,sc);
                    break;
                case 4:
                    // 转账
                    transferMoney(sc,acc, accounts);
                    break;
                case 5:
                    // 修改密码
                    updatePassWord(sc,acc);
                    return;
                case 6:
                    // 退出
                    System.out.println("退出成功，欢迎下次光临");
                    return;
                case 7:
                    // 注销账户
                    if (deleteAccount(acc,sc,accounts)){
                        return;
                    }else {
                        break;
                    }
                default:
                    System.out.println("您输入的操作命令不正确");
            }
        }

    }

    /**
     * 用户销户
     * @param acc
     * @param sc
     * @param accounts
     */
    private static boolean deleteAccount(Account acc, Scanner sc, ArrayList<Account> accounts) {
        System.out.println("您确认要注销账户吗？y/n");
        String rs= sc.next();
        switch (rs){
            case "y":
                if (acc.getMoney() > 0){
                    System.out.println("您的账户还有存款，不允许销户~~");
                }else {
                    accounts.remove(acc);
                    System.out.println("您的账户系销户完成~~");
                    return true;
                }
                break;
            default:
                System.out.println("");
        }
        return false;
    }

    /**
     *  修改密码
     * @param sc 扫描仪
     * @param acc  当前用户对象
     */
    private static void updatePassWord(Scanner sc, Account acc) {
        System.out.println("============用户密码修改===========");
        while (true) {
            System.out.println("请您输入当前密码：");
            String passWord = sc.next();
            if (acc.getPassWord().equals(passWord)){
                //密码正确
                // 2.输入新密码
                while (true) {
                    System.out.println("请您输入新密码：");
                    String newPassWord = sc.next();

                    System.out.println("请您确认新密码：");
                    String okPassWord = sc.next();

                    if (newPassWord.equals(okPassWord)){
                        acc.setPassWord(newPassWord);
                        System.out.println("恭喜您，修改密码成功！");
                        return;
                    }else {
                        System.out.println("您输入的2次密码不一致~~");
                    }
                }

            }else{
                System.out.println("您输入的密码不正确~~");
            }
        }
    }

    /**
     *  转账功能
     * @param sc 扫描器
     * @param acc 自己账户对象
     * @param accounts 全部账户集合
     */
    private static void transferMoney(Scanner sc, Account acc, ArrayList<Account> accounts) {
        System.out.println("===========用户转账操作========");
        if (accounts.size() < 2){
            System.out.println("当前系统中不足两个账户，不能进行转账，请去开户吧~~");
            return;
        }

        //2.判断自己账户是否有钱
        if (acc.getMoney() == 0){
            System.out.println("对不起，您自己都没钱~~");
            return;
        }

        //3.转账
        while (true) {
            System.out.println("请您输入对方的卡号");
            String carId = sc.next();
            //卡号不能是自己的
            if (carId.equals(acc.getCardId())){
                System.out.println("对不起，不能给自己转账~~");
                continue;
            }
            // 判断这个卡号是否存在，根据卡号查账户对象
            Account account = getAccountByCardId(carId,accounts);

            if (account == null){
                System.out.println("对不起，您输入的卡号不存在~~");
            }else{
                //  对象存在，继续认证姓氏
                String uerName = account.getUserName();
                String tip = "*" + uerName.substring(1);
                System.out.println("请您输入["+tip+"]的姓氏");
                String perName = sc.next();

                // 认证姓氏是否正确
                if (uerName.startsWith(perName)){
                    while (true) {
                        // 认证通过
                        System.out.println("请您输入转账金额：");
                        double money = sc.nextDouble();
                        if (money > acc.getMoney()){
                            System.out.println("对不起，您的余额不足，您最多可转账"+acc.getMoney());
                        }else {
                            // 余额足够
                            acc.setMoney(acc.getMoney() - money) ;
                            account.setMoney(account.getMoney() + money);
                            System.out.println("转账成功！您的账户还剩余："+acc.getMoney());
                            return;
                        }
                    }

                }else {
                    System.out.println("对不起，您输入的姓氏有误~~");
                }
            }
        }
    }

    /**
     *  取钱
     * @param acc    当前账户
     * @param sc   扫描器
     */
    private static void drawMoney(Account acc, Scanner sc) {
        System.out.println("===========用户取钱操作==========");
        // 1.判断是否100元
        if (acc.getMoney() < 100){
            System.out.println("对不起，当前账户不够100元，不能取钱~~");
            return;
        }

        //2.提示用户输入取钱金额
        while (true) {
            System.out.println("请输入取钱金额：");
            double money = sc.nextDouble();

            //判断是否满足要求
            if (money > acc.getQuotaMoney()){
                System.out.println("对不起，您当前取钱金额超过单次限额，每次最多可取："+acc.getQuotaMoney());
            }else {
                if (money > acc.getMoney()){
                    System.out.println("余额不足，您账户目前总余额："+acc.getMoney());
                }else {
                    System.out.println("恭喜您，取钱"+money+"元，成功");
                    acc.setMoney(acc.getMoney() - money);
                    showAccount(acc);
                    return;
                }
            }
        }
    }

    /**
     *  存钱
     * @param acc 当前用户对象
     * @param sc  扫描器
     */
    private static void depositMoney(Account acc, Scanner sc) {
        System.out.println("========用户存钱操作========");
        System.out.println("请输入存款金额：");
        double money = sc.nextDouble();

        // 更新账户余额，  原来的钱 + 新存的钱
        acc.setMoney(acc.getMoney()+money);
        System.out.println("恭喜您，存钱成功，当前账户信息如下：");
        showAccount(acc);
    }

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

    /**
     * 用户注册
     * @param accounts 接受的账户集合
     */
    private static void register(ArrayList<Account> accounts,Scanner sc) {
        System.out.println("==========系统开户操作========");
        //1.创建一个账户对象，用于后期封装用户信息
        Account account = new Account();
        //2.录入当前这个账户的信息，注入到账户对象中去
        System.out.println("请您输入账户名：");
        String userName = sc.next();
        account.setUserName(userName);

        while (true) {
            System.out.println("请输入账户密码：");
            String passWord = sc.next();
            System.out.println("请输入账户密码：");
            String okPassWord = sc.next();
            if(okPassWord.equals(passWord)){
                //密码认证通过，可以注入给账户
                account.setPassWord(okPassWord);
                break;
            }else{
                System.out.println("对不起，您输入的2次密码不一致，请重新输入~~");
            }
        }

        System.out.println("请您输入当次限额：");
        double quotaMoney = sc.nextDouble();
        account.setQuotaMoney(quotaMoney);

        // 为账户随机以为八位且不重复的卡号。（独立功能）
        String cardId = getRandomCardId(accounts);
        account.setCardId(cardId);

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

    /**
     * 为账户随机以为八位且不重复的卡号
     * @return
     */
    private static String getRandomCardId(ArrayList<Account> accounts) {
        Random r = new Random();
        while (true) {
            // 1.生成8位数字
            String cardId = "";
            for (int i = 0; i < 8; i++) {
                cardId += r.nextInt(10);
            }
            //2.判断这个8位卡号是否与其他账户的卡号重复
            Account acc = getAccountByCardId(cardId,accounts);
            if (acc == null){
                //说明carId 此时没有重复，这个卡号是一个新卡号了，可以使用
                return cardId;
            }
        }
    }

    /**
     * 根据卡号查询出一个账户的对象出来
     * @param cardId  卡号
     * @param accounts  全部账号的集合
     * @return  账户对象 | null
     */
    private static Account getAccountByCardId(String cardId,ArrayList<Account> accounts){
        for (int i = 0; i < accounts.size(); i++) {
            Account acc = accounts.get(i);
            if(acc.getCardId().equals(cardId)){
                return acc;
            }
        }
        return null; //查无此账号
    }
}

/*
* 账户类*/
public class Account {
    private String cardId;
    private String userName;
    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;
    }

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

    public String getPassWord() {
        return passWord;
    }

    public void setPassWord(String passWord) {
        this.passWord = passWord;
    }

    public double getMoney() {
        return money;
    }

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

    public double getQuotaMoney() {
        return quotaMoney;
    }

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

for (int i = 0; i < accounts.size(); i++) {
Account acc = accounts.get(i);
if(acc.getCardId().equals(cardId)){
return acc;
}
}
return null; //查无此账号
}
}

```java
/*
* 账户类*/
public class Account {
    private String cardId;
    private String userName;
    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;
    }

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

    public String getPassWord() {
        return passWord;
    }

    public void setPassWord(String passWord) {
        this.passWord = passWord;
    }

    public double getMoney() {
        return money;
    }

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

    public double getQuotaMoney() {
        return quotaMoney;
    }

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