【学习笔记】-JavaSE基础入门

JavaSE基础入门

一、Java环境搭建
- 1.JRE和JDK
- 2.JDK的下载和安装
二、IDEA集成开发工具
三、Java基础语法
- 1.注释
- 2.字面量
- 3.变量
- 4.关键字、标识符
- 5.类型转换
- 6.运算符
- - 1）基本的算数运算符
  - 3）+符号做连接符
  - 4）自增、自减运算符
  - 5）赋值运算符
  - 6）关系运算符
  - 7）逻辑运算符
  - 8）三元运算符
  - 9）运算符优先级
- 7.键盘录入技术
四、程序流程控制
- 1.分支结构
- - 1）if
  - 2）switch
- 2.循环结构
- - 1）for循环
  - 2）while循环
  - 3）do-while循环
  - 4）三种循环的区别
  - 5）死循环
  - 6）跳转关键字break、continue
  - 7）案列技术：随机数Random类
五、数组
- 1.数组的定义
- - 1）静态初始化数组
  - 2）动态初始化数组
- 2.数组的内存图
- - 1）Java内存分配介绍
  - 2）数组内存图
- 3.数组常见的问题
六、方法
- 1.方法概述
- 2.方法的定义、调用
- 3.方法调用的内存图
- 4.方法的参数传递机制
- 5.方法重载
- 6.单独使用return关键字
七、编程练习
- 1.买飞机票
- 2.找素数
- 3.验证码
- 4.评委打分
- 5.数字加密
- 6.双色球系统
八、面向对象
- 1.设计对象并使用
- 2.对象在内存中的运行机制
- 3.面向对象小练习：购物车模拟
- 4.构造器
- 5.this关键字
- 6.封装
- 7.JavaBean
- 8.成员变量和局部变量的区别
九、常用API（String、ArrayList）
- 1.String
- - 1）String概述
  - 2）String类创建对象的两种方式
  - 3）String常见面试题
  - 4）String类常用API
- 2.ArrayList
- - 1）集合概述
  - 2）ArrayList集合的使用
  - 3）ArrayList对于泛型的支持
  - 4）ArrayList常用API
  - 5）ArrayList练习案列
十、编程练习-ATM系统模拟

一、Java环境搭建 1.JRE和JDK

JRE（Java Runtime Environment）：是Java程序的运行时环境，包含JVM和运行时所需要的核心类库。想要运行一个已有的Java程序，只需安装JRE即可。
JDK（Java Development Kit）：是Java程序开发工具包，包含JRE和开发人员使用的工具。其中的开发工具：编译工具（javac.exe）和运行工具（java.exe）。想要开发一个全新的Java程序，必须安装JDK。
JDK、JRE和JVM的关系：

2.JDK的下载和安装

下载网址：www.oracle.com
验证JDK是否安装成功：
1. 按下Win+R，输入cmd。
2. 输入java -version、javac -version查看版本号。
JDK的安装目录：

目录名称	说明
bin	存放JDK各种工具命令。javac（编译工具）和java（执行工具）就在这个目录。
conf	存放JDK的相关配置文件。
include	存放一些平台特定的头文件。
jmods	存放JDK的各种模块。
legal	存放JDK各模块的授权文档。
lib	存放JDK工具的一些补充JAR包。

配置环境变量：
1. 高级系统设置->高级->环境变量。
2. 把JDK的bin包的位置配置到path中（或直接%JAVA_HOME%bin）。
3. 把JDK的位置配置到JAVA_HOME中。

二、IDEA集成开发工具

下载地址：https://www.jetbrains.com/idea/
IDEA项目结构：project（项目）、module（模块）、package（包）、class（类）。
IDEA常用快捷键：

快捷键	功能效果
main/psvm、sout…	快速输入相关代码
Ctrl+D	复制当前行数据到下一行
Ctrl+Y	删除所在行
Ctrl+ALT+L	格式化代码
ALT+SHIFT+↑，ALT+SHIFT+↓	上下移动当前代码
Ctrl+/，Ctrl+Shift+/	对代码进行注释

Debug工具
1. 在需要控制的代码左侧，点击一下，形成断点。
2. 选择debug方式启动程序，启动后程序会在断点暂停。
3. 控制代码一步一步往下执行。

三、Java基础语法 1.注释

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

快捷键注释	效果
Ctrl+/	对当前行进行注释
Ctrl+shift+/	对选中的代码进行注释

2.字面量

public class LiteralDemo {
    public static void main(String[] args) {
//        常见数据的书写格式
//        1.整数
        System.out.println(888);

//        2.小数
        System.out.println(3.14);

//        3.字符；必须要单引号围起来，且只能有一个字符
        System.out.println('a');
        System.out.println('0');
        System.out.println('好');
        System.out.println(' ');  //空字符
        System.out.println('n');  //换行
        System.out.println('t');  //缩进tab

//        4.字符串：必须要双引号围起来，里面的内容随意
        System.out.println("Hello，你好吗？");
        System.out.println("      ");

//        5.布尔值，只能输出true或者false
        System.out.println(true);
        System.out.println(false);
    }
}

3.变量

使用注意事项：
1. 变量要先声明再使用。
2. 变量声明后，不能存储其他类型数据。
3. 变量的有效范围是从定义开始到 “}” 截止，且在同一范围内部不能定义2个变量名。
4. 变量定义时可以没有初始值，但使用时必须给初始值。
ASCII码
- a对应97，A对应65,0对应48。

        char ch = 'a';  //对应ASCII值为97
        System.out.println(ch);  //输出a
        System.out.println(ch + 1);  //输出98

基本数据类型：

4.关键字、标识符

关键字：
- Java自己保留的一些单词，作为特殊功能，例如：public、class、byte、int…
- 不能用来作为类名或者变量名
标识符：
- 要求：
  - 基本要求：由数字、字母、下划线、和美元符号等组成。
  - 强制要求：不能以数字开头、不能是关键字、区分大小写。
- 命名规范：
  - 变量名称：首字母小写，满足“驼峰模式”，如：int studyNumber=0。
  - 类名：首字母大写，满足“驼峰模式”，如：HelloWorld.java。

5.类型转换

自动类型转换：类型范围小的变量，可以直接赋值给类型范围大的变量。

表达式的自动类型转换：在表达式中，小范围类型的变量会自动转换成较大范围的类型再运算。
- 表达式最终结果类型由表达式中的最高类型决定的。
- 在表达式中，byte、short、char是直接转换成int类型参与运算。

        byte c = 10;
        byte d = 20;
        // byte e=c+d;   报错，因为c和d自动转成int类型进行运算
        int e = c + d;

强制类型转换：可以强行将类型范围大的变量、数据赋值给类型范围小的变量。
- (数据类型) 变量2= (数据类型) 变量1、数据；
- 强制转换可能造成数据（丢失）溢出。
- 浮点型强转成整型，直接丢掉小数部分，保留整数部分返回。

        int aa = 10;
        byte bb = (byte) aa;   //bb输出为10

        int i = 1500;
        byte j = (byte) i;  //j输出为-36，数据溢出

        double m = 99.9;
        int n = (int) m;  //n输出为99

6.运算符 1）基本的算数运算符

public class OperatorDemo1 {
    public static void main(String[] args) {
//        基本算数运算符
        int a = 10;
        int b = 3;
        System.out.println(a + b);//输出13
        System.out.println(a - b);//输出7
        System.out.println(a * b);//输出30
        System.out.println(a / b);//输出3
        System.out.println(a * 1.0 / b);//输出3.3333
        System.out.println(3 / 2);//输出1
        System.out.println(3 * 1.0 / 2);//输出1.5
        System.out.println(3 / 2 * 1.0);//输出1.0
        System.out.println(a % b);//输出1
    }
}

3）+符号做连接符

+号除了做基本数学运算，与字符串做+运算时被当成连接符，其结果还是字符串。
连接规则：能算则算，不能算就连接在一起。

public class OperatorDemo2 {
    public static void main(String[] args) {
        int a = 5;
        System.out.println("abc" + 'a');//输出abca
        System.out.println("abc" + a);//输出abc5
        System.out.println(5 + a);//输出10
        System.out.println("abc" + 5 + 'a');//输出abc5a
        System.out.println(15 + "abc" + 15);//输出15abc15
        System.out.println(a + 'a');//输出102
        System.out.println(a + "" + 'a');//输出5a
        System.out.println(a + 'a' + " itstudy");//输出102 itstudy
        System.out.println("itstudy" + a + 'a');//输出itstudy5a
        System.out.println("itstudy" + (a + 'a'));//输出itstudy102
    }
}

4）自增、自减运算符

自增、自减运算符只能用于变量中，不可用于字面量中。
自增、自减运算符如果不是单独使用，放在变量前后会有明显区别。放在变脸前面，先对变量值进行+1、-1，再拿变量的值进行运算。放在变脸后面，先拿变量的值进行运算，再对变量进行+1、-1。

5）赋值运算符

基本运算符：=。
拓展赋值运算符（包含强制类型转换）

符号	作用	说明
+=	加后赋值	a+=b等价于a=(a的数据类型)a+b
-=	减后赋值	a-=b等价于a=(a的数据类型)a-b
*=	乘后赋值	a=b等价于a=(a的数据类型)ab
/=	除后赋值	a/=b等价于a=(a的数据类型)a/b
%=	取余后赋值	a%=b等价于a=(a的数据类型)a%b

6）关系运算符

是对数据进行条件判断的符号，最终会返回一个比较的布尔结果（false、true）

符号	说明
==	a==b，判断a和b的值是否相等，成立为true，不成立为false
!=	a!=b，判断a和b的值是否不相等，成立为true，不成立为false
>	a>b，判断a是否大于b，成立为true，不成立为false
>=	a>=b，判断a是否大于等于b，成立为true，不成立为false
<	a
<=	a<=b，判断a是否小于等于b，成立为true，不成立为false

7）逻辑运算符

可以把多个条件的布尔结果放在一起运算，最终返回一个布尔值。

符号	介绍	说明
&	逻辑与	必须都是true，结果才能是true。只要有一个false，结果一定是false
&&	短路与	一个为false，结果为false。前一个为false，后一个条件就不执行了
\|	逻辑或	只要有一个为true，结果就是true
\|\|	短路或	一个为true，结果就是true。前一个为true，后一个条件就不执行了
!	逻辑非	!true=false、!false=true
^	逻辑异或	如果聊过条件都是false或者都是true则结果是false。两个条件不同结果是true

8）三元运算符

格式：条件表达式 ? 值1 : 值2
执行流程：首先计算关系表达式的值，如果为true，返回值1，如果为false，返回值2。

9）运算符优先级

优先级	运算符
1	()
2	!、-、++、- -
3	*、/、%
4	+、-
5	<<、>>、>>>
6	<、<=、>、>=、instanceof
7	==、!=
8	&
9	^
10	\|
11	&&
12	\|\|
13	?:
14	=、+=、-=、*=、/=、%=、&=

7.键盘录入技术

API（应用程序编程接口）：java写好的功能代码，可以直接调用。
API文档下载：https://www.oracle.com/java/technologies/downloads/


import java.util.Scanner;//1.导包操作

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

        Scanner sc = new Scanner(System.in);//2.得到一个键盘扫描对象

        //3.调用sc对象的功能等待接收用户输入的数据
        System.out.println("请输入你的年龄：");
        int age = sc.nextInt();
        System.out.println("你的年龄是：" + age);

        System.out.println("请输入你的姓名：");
        String name = sc.next();
        System.out.println("欢迎" + name);

    }
}

四、程序流程控制 1.分支结构 1）if

格式1：

if(条件表达式){
     代码...
}

格式2：

if(条件表达式){
    代码...
}else{
    代码...
}

格式3：

if(条件表达式){
    代码...
}else if(条件表达式){
    代码...
}else if(条件表达式){
    代码...
}
...
else{
    代码...
}

2）switch

switch(表达式){
    case 值1：
        执行代码;
        break;
    case 值2：
        执行代码;
        break;
    ...
    case 值n：
        执行代码;
        break;
    default:
        执行代码;
}

注意事项：
1. 表达式类型只能是byte、short、int、char，JDK5开始支持枚举，JDK7开始支持String。不支持double、float、long。
2. case给出的值不能重复，且只能是字面量，不能是变量。
3. 不要忘记写break，否则会出现穿透现象。
switch穿透性：如果代码执行到没有写break的case块,执行完后直接进入下一个case块执行代码（而且不会进行任何匹配），直到遇到break才跳出分支。

//利用switch穿透性简化代码
//需求：输入月份，显示天数
public class SwitchDemo {
    public static void main(String[] args) {

        System.out.println("请输入月份：");
        Scanner sc=new Scanner(System.in);
        int month= sc.nextInt();

        switch(month){
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
            case 12:
                System.out.println(month+"月有31天");
                break;
            case 4:
            case 6:
            case 9:
            case 11:
                System.out.println(month+"月有30天");
                break;
            case 2:
                System.out.println(month+"月有28/29天");
                break;
        }

    }
}

2.循环结构 1）for循环

格式：

for (初始化语句;循环条件;迭代语句){
    重复执行的代码;
}

2）while循环

格式：

初始化语句;
while (循环条件) {
    循环体语句;
    迭代语句;
}

3）do-while循环

格式：

初始化语句;
do {
    循环体语句;
    迭代语句;
}while(循环条件)

4）三种循环的区别

三种循环的区别
- for循环和while循环：先判断再执行。
- do-while循环：第一次执行后判断。
for循环和while循环的区别
- 如果已知循环次数建议使用for循环，如果不知道循环次数建议使用while循环。
- for循环中，控制循环的变量只在循环中华可以使用。while循环中，控制循环的变量在循环后可以继续使用。

5）死循环

会一直循环的执行下去，没有干预就不会停下来。
格式

        //格式1
        for(;;){
            System.out.println("我是死循环！");
        }
        //格式2
        while (true) {
            System.out.println("我是死循环！");
        }
        //格式3
        do{
            System.out.println("我是死循环！");
        }while (true);

6）跳转关键字break、continue

break
- 跳出并结束当前所在循环。
- 只能用于结束所在循环，或者结束所在switch分支的执行。
continue
- 用于跳出当前循环当次执行，进入下一次循环。
- 只能在循环中使用。

7）案列技术：随机数Random类

Random生成随机数的特点：nextInt(n)功能只能生成0-（n-1）之间的随机数。
Random生成区间随机数的方法：加减法。

public class RandomDemo {
    public static void main(String[] args) {
        Random r=new Random();
        int number1=r.nextInt(10);//生成0-9之间的随机数
        int number2=r.nextInt(10)+1;//生成1-10之间的随机数
        System.out.println(number1);
        System.out.println(number2);
    }
}

五、数组 1.数组的定义 1）静态初始化数组

定义数组时直接给数组赋值。
格式

//完整格式
数据类型[]  数组名 = new  数据类型[]{元素1,元素2,元素3...};
//简化格式
数据类型[]  数组名 = new  {元素1,元素2,元素3...};

数组变量名中存储的是数组在内存中的地址，数组是引用类型。
数组的访问：数组名称[0]-数组名称[length-1]。
数组的长度属性：数组名称.length。
注意事项：
1. “数据类型[] 数组名”也可以写成“数据类型数组名[]”。
2. 什么类型的数组存放什么类型的数据。
3. 数组一旦定义出来，程序执行过程中，长度、类型就固定了。

2）动态初始化数组

定义数组时只确定元素的类型和数组长度，之后再存入具体数据。
格式

数组类型[] 数组名 = new 数据类型[长度];

动态初始化数组的元素默认值

数据类型	默认值
byte、short、char、int 、long	0
float、double	0.0
boolean	false
类、接口、数组、String	null

2.数组的内存图 1）Java内存分配介绍

2）数组内存图

3.数组常见的问题

如果访问的元素位置超过最大索引，执行时会出现ArrayIndexOutOfBoundsException（数组索引越界异常）。
如果数组变量中没有存储数组的地址，而是null，在访问数组信息时会出现NullPointerException（空指针异常）。

六、方法 1.方法概述

概念：方法是一种语法结构，它可以把一段代码封装成一个功能，以方便重复调用。
好处：提高代码复用性、让程序逻辑更清楚。

2.方法的定义、调用

定义格式

//返回参数
public static int sum(int a, int b) {  

    int c = a + b;
    return c;  //返回值
}

//不返回参数
public static void print() {
    System.out.println("Hello World!");
}

注意事项
1. 方法编写顺序无所谓。
2. 方法与方法之间是平级关系，不能套嵌定义。
3. 方法的返回值类型为void，方法内不能使用return返回数据。如果方法返回值类型写了具体类型，方法内部必须使用return返回对应类型的数据。
4. 方法不调用就不执行，调用时必须严格匹配方法的参数情况。

3.方法调用的内存图

4.方法的参数传递机制

基本数据类型的传递机制：在传输实参给方法的形参的时候，并不是传输实参变量本身，而是传输实参变量中存储的数据值。
引用类型的传递机制：参数传输存储的地址值。

5.方法重载

形式：同一类中，多个方法的名称相同，形参列表不同。
作用：对于相似功能的业务场景，可读性好。

6.单独使用return关键字

可以立即跳出并结束当前方法的执行。

    public static void chu(int a, int b) {
        if (b == 0) {
            System.out.println("数据有误");
            return;  //结束当前方法
        }
        int c = a / b;
        System.out.println("除法结构为：" + c);
    }

七、编程练习 1.买飞机票

package com.itstudy.demo;

import java.util.Scanner;


public class Test1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入机票原价：");
        double oldmoney = sc.nextDouble();

        System.out.println("请输入月份：");
        int month = sc.nextInt();

        System.out.println("请输入仓位类型：");
        String type = sc.next();

        System.out.println("机票优惠后的价格是：" + calc(oldmoney, month, type));
    }

    public static double calc(double oldmoney, int month, String type) {
        double newmoney = 0.0;
        if (month >= 5 && month <= 10) {
            //判断为旺季
            switch (type) {
                case "头等舱":
                    newmoney = oldmoney * 0.9;
                    break;
                case "经济舱":
                    newmoney = oldmoney * 0.85;
                    break;
                default:
                    System.out.println("您输入的数据有误！");
                    return -1;//表示当前无法计算价格
            }
        } else if (month == 11 || month == 12 || month >= 1 && month <= 4) {
            //判断为淡季
            switch (type) {
                case "头等舱":
                    newmoney = oldmoney * 0.7;
                    break;
                case "经济舱":
                    newmoney = oldmoney * 0.65;
                    break;
                default:
                    System.out.println("您输入的数据有误！");
                    return -1;//表示当前无法计算价格
            }
        } else {
            System.out.println("您输入的数据有误！");
            return -1;//表示当前无法计算价格
        }
        return newmoney;
    }
}

2.找素数

package com.itstudy.demo;


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

        for (int i = 101; i <= 200; i++) {
            boolean flag = true; //初始标记为素数
            for (int j = 2; j <= i / 2; j++) {
                if (i % j == 0) {
                    flag = false;  //如果能被整除，标记不是素数
                    break;
                }
            }
            if (flag) {
                System.out.println(i + "t");
            }
        }
    }
}

3.验证码

package com.itstudy.demo;

import java.util.Random;


public class Test3 {
    public static void main(String[] args) {
        String code = createCode(5);
        System.out.println("随机验证码为：" + code);

    }

    public static String createCode(int n) {    //n为验证码位数
        String code = "";    //定义验证码code初始为空
        Random r = new Random();
        for (int i = 0; i < n; i++) {    //定义一个for循环，依次生成随机字符
            int type = r.nextInt(3);   //随机生成一种类型，0为大写字母，1为小写字母，2位数字
            switch (type) {
                case 0:
                    //大写字母（A：65-Z：65+25）
                    char ch1 = (char) (r.nextInt(26) + 65);
                    code = code + ch1;
                    break;
                case 1:
                    //小写字母（a：97-z：97+25）
                    char ch2 = (char) (r.nextInt(26) + 97);
                    code = code + ch2;
                    break;
                case 2:
                    //数字(0-9)
                    code = code + r.nextInt(10);
                    break;
            }
        }
        return code;
    }
}

4.评委打分

package com.itstudy.demo;

import java.util.Scanner;


public class Test4 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        int[] score = new int[6];
        for (int i = 0; i < score.length; i++) {  //评委依次打分
            System.out.println("请第" + (i + 1) + "位评委打分：");
            score[i] = sc.nextInt();
        }

        int max = score[0];  //初始第一个评委打的分为最高分
        int min = score[0];  //初始第一个评委打的分为最低分
        int sum = 0;  //总分初始为0
        for (int i = 0; i < score.length; i++) {
            sum = sum + score[i];  //求总分
            if (score[i] > max) {
                max = score[i];  //如果大于最高分，更新最高分数值
            }
            if (score[i] < min) {
                min = score[i];  //如果小于最低分，更新最低分数值
            }
        }

        double result = (sum - max - min) * 1.0 / (score.length - 2);  //计算平均分
        System.out.println("选手最终平均分为：" + result);
        
    }

}

5.数字加密

package com.itstudy.demo;

import java.util.Scanner;


public class Test5 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入密码长度：");
        int length = sc.nextInt();
        int[] arr = new int[length];

        for (int i = 0; i < length; i++) {
            System.out.println("请输入第" + (i + 1) + "位密码：");
            arr[i] = sc.nextInt();
        }

        System.out.println("原密码为：");
        printArray(arr);

        for (int i = 0; i < arr.length; i++) {
            arr[i] = (arr[i] + 5) % 10;  //每位+5再对10取余
        }

        //数字反转
        int leftflag = 0;
        int rightflag = arr.length - 1;
        while (leftflag < rightflag) {
            int change = arr[leftflag];
            arr[leftflag] = arr[rightflag];
            arr[rightflag] = change;
            leftflag++;
            rightflag--;
        }

        System.out.println("密码加密后为：");
        printArray(arr);

    }

    public static void printArray(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("]");
    }
}

6.双色球系统

package com.itstudy.demo;

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


public class Test6 {

    public static void main(String[] args) {
        System.out.println("请选择你的幸运号码：");
        int[] chooseLuckNumbers = chooseLuckNumber();  //调用方法输入抽奖号码
        System.out.println("你所选择的抽奖号码为：");
        printNumber(chooseLuckNumbers);

        int[] luckNumbers = createLuckNumber();  //调用方法生成中奖号码
        System.out.println("本期中奖号码为：");
        printNumber(luckNumbers);

        bonus(chooseLuckNumbers, luckNumbers);

    }

    //用户选择抽奖号码
    public static int[] chooseLuckNumber() {
        int[] numbers = new int[7];  //1.初始化一个数组，用于存放用户选择抽奖号码
        Scanner sc = new Scanner(System.in);

        //2.选择红球号码
        for (int i = 0; i < 6; i++) {  //依次选择1-6位蓝球号码
            while (true) {
                boolean isRedFinish = true;  //初始化此位输入情况标记为true
                System.out.println("请选择第" + (i + 1) + "位红球号码：");
                numbers[i] = sc.nextInt();  //用户输入此位号码
                //判断输入数字是否越界
                if (numbers[i] < 1 || numbers[i] > 33) {
                    System.out.println("发生错误！数字超过范围！请重新选择！");
                    isRedFinish = false;  //如果越界，继续执行此死循环
                }
                //判断输入数字是否与前面数字重复
                for (int j = 0; j < i; j++) {
                    if (numbers[j] == numbers[i]) {
                        System.out.println("发生错误！数字重复！请重新进行选择");
                        isRedFinish = false;  //如果重复，跳出此判断重复循环，继续执行此死循环
                        break;
                    }
                }
                if (isRedFinish == true) {
                    break;  //如果无异常情况，跳出此死循环
                }
            }
        }

        //3.选择蓝球号码
        while (true) {
            System.out.println("请选择蓝球号码：");
            numbers[6] = sc.nextInt();  //用户输入此位号码
            //判断是否越界
            if (numbers[6] < 1 || numbers[6] > 16) {
                System.out.println("发生错误！数字超过范围！请重新选择！");
                continue;  //如果越界，执行下次循环
            } else {
                break;  //没有越界，跳出此死循环
            }
        }

        return numbers;//4.返回用户选择抽奖号码
    }


    //生成中奖号码
    public static int[] createLuckNumber() {
        int[] numbers = new int[7];  //1.初始化一个数组，用于存放中奖号码
        Random r = new Random();

        //2.生成红球号码
        for (int i = 0; i < 6; i++) {
            while (true) {
                boolean isFinish = true;  //初始化判断是否完成生成数标记为true
                numbers[i] = r.nextInt(33) + 1;
                //判断生成的数是否和前面的数重复
                for (int j = 0; j < i; j++) {
                    if (numbers[j] == numbers[i]) {
                        isFinish = false;
                        break;  //如果重复，跳出判定是否重复循环，继续此位生成随机数循环
                    }
                }
                if (isFinish == true) {  //如果标记为true,跳出此位生成随机数循环
                    break;
                }
            }

        }

        numbers[6] = r.nextInt(16) + 1;  //3.生成蓝球号码
        return numbers;  //4.返回生成的中奖号码
    }

    //打印号码
    public static void printNumber(int numbers[]) {
        System.out.print("[");
        for (int i = 0; i < numbers.length; i++) {
            System.out.print(i == numbers.length - 1 ? numbers[i] : numbers[i] + "，");
        }
        System.out.println("]");
    }

    //判断奖金
    public static void bonus(int[] chooseLuckNumbers, int[] luckNumbers) {
        int redRight = 0;  //初始化红球猜中个数为0
        int blueRight = 0;  //初始化蓝球猜中个数为0
        int level = 0;   //判断中奖等级为0
        int money = 0;

        //判断红球猜中个数
        for (int i = 0; i < 6; i++) {
            for (int j = 0; j < 6; j++) {
                if (chooseLuckNumbers[i] == luckNumbers[j]) {
                    redRight++;
                    break;
                }
            }
        }

        //判断蓝球号码猜中个数
        if (chooseLuckNumbers[6] == luckNumbers[6]) {
            blueRight++;
        }

        //判断获奖等级
        if (redRight == 6 && blueRight == 1) {
            level = 1;
            money = 10000000;
        } else if (redRight == 6 && blueRight == 0) {
            level = 2;
            money = 5000000;
        } else if (redRight == 5 && blueRight == 1) {
            level = 3;
            money = 3000;
        } else if ((redRight == 5 && blueRight == 0) || (redRight == 4 && blueRight == 1)) {
            level = 4;
            money = 200;
        } else if ((redRight == 4 && blueRight == 0) || (redRight == 3 && blueRight == 1)) {
            level = 5;
            money = 10;
        } else if ((redRight == 2 && blueRight == 1) || (redRight == 1 && blueRight == 1) || (redRight == 0 && blueRight == 1)) {
            level = 6;
            money = 5;
        }

        if (level == 0) {
            System.out.println("很遗憾！你没有中奖！");
        } else {
            System.out.println("恭喜你中了" + level + "等奖！");
        }
        System.out.println("猜中红球个数为：" + redRight);
        System.out.println("猜中蓝球个数为：" + blueRight);
        System.out.println("获得奖金" + money + "元！");
    }
}

八、面向对象 1.设计对象并使用

类：是对象共同特征的描述。
对象：是真实存在的具体实例。
在Java中，必须先设计类，才能创建对象并使用。
设计类

public class Car {
    //成员变量
    String name;
    double price;
    //成员方法
    public void start(){

    }
    public void run(){

    }
}

得到类及使用

public class Test1 {
    public static void main(String[] args) {
        Car c=new Car();  //得到类的对象
        c.name="奔驰";  //使用对象
        c.price=60.5;
        c.start(); 
        c.run();
    }
}

定义类的注意事项：
1. 类名首字母大写，且有意义，满足“驼峰模式”。
2. 一个Java文件中可以定义多个class类，但只能一个类是public修饰，而且public修饰的类名必须成为文件代码名。实际开发中还是建议一个文件定义一个class类。
3. 成员变量的完整定义格式为：修饰符数据类型变量名称 = 初始值; 。一般无需指定初始值，存在默认值

2.对象在内存中的运行机制

多个对象的内存图
两个变量指向用一个对象内存图

3.面向对象小练习：购物车模拟

package com.itstudy.shoptest;

public class Goods {
    int id;  //编号
    String name;  //名称
    double price;  //价格
    int buyNumber;  //购买数量

}

package com.itstudy.shoptest;

import java.util.Scanner;

public class ShopTest {
    public static void main(String[] args) {
        //1.定义商品类，用于后期创建商品对象
        //2.定义购物车对象，用一个数组表示
        Goods[] shopCar = new Goods[100];
        //.搭建操作架构
        while (true) {
            System.out.println("请选择如下命令进行操作");
            System.out.println("添加商品到购物车：add");
            System.out.println("查询商品到购物车：query");
            System.out.println("修改商品购买数量：update");
            System.out.println("结算商品购买金额：pay");
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入您的命令：");
            String command = sc.next();
            switch (command) {
                case "add":
                    addGoods(shopCar, sc);
                    break;
                case "query":
                    queryGoods(shopCar);
                    break;
                case "update":
                    updateGoods(shopCar, sc);
                    break;
                case "pay":
                    payGoods(shopCar);
                    break;
                default:
                    System.out.println("没有该功能！");
            }
        }

    }

    public static void payGoods(Goods[] shopCar) {
        double allPrice = 0.0;
        for (int i = 0; i < shopCar.length; i++) {
            if (shopCar[i] != null) {
                allPrice = allPrice + shopCar[i].buyNumber * shopCar[i].price;
            } else {
                break;
            }
        }
        System.out.println("付款总金额为：" + allPrice);
    }

    //修改商品购买数量
    public static void updateGoods(Goods[] shopCar, Scanner sc) {
        while (true) {
            System.out.println("请输入要修改的商品id：");
            int id = sc.nextInt();
            Goods g = g = getGoodsId(id, shopCar);
            if (g == null) {
                System.out.println("输入商品id错误！请重新输入！");
                continue;
            } else {
                System.out.println("请修改购买数量：");
                g.buyNumber = sc.nextInt();
                System.out.println("修改成功！");
                queryGoods(shopCar);
                break;
            }
        }

    }

    //输入id，获取商品信息的方法
    public static Goods getGoodsId(int id, Goods[] shopCar) {
        for (int i = 0; i < shopCar.length; i++) {
            if (shopCar[i] != null) {
                if (shopCar[i].id == id) {
                    return shopCar[i];
                }
            } else {
                return null;
            }
        }
        return null;

    }

    //查询购物车中的商品信息
    public static void queryGoods(Goods[] shopCar) {
        System.out.println("============购物车信息查询如下============");
        System.out.println("编号ttt名称ttt价格ttt购买数量");
        for (int i = 0; i < shopCar.length; i++) {
            if (shopCar[i] != null) {
                System.out.println(shopCar[i].id + "ttt" + shopCar[i].name + "ttt" + shopCar[i].price + "ttt" + shopCar[i].buyNumber);
            } else {
                break;
            }
        }
    }

    //将商品添加到购物车
    public static void addGoods(Goods[] shopCar, Scanner sc) {
        // 录入用户购买商品信息
        System.out.println("请输入商品编号（不重复）：");
        int id = sc.nextInt();
        System.out.println("请输入商品名称：");
        String name = sc.next();
        System.out.println("请输入商品价格：");
        double price = sc.nextDouble();
        System.out.println("请输入购买数量：");
        int buyNumber = sc.nextInt();

        //将录入的商品信息封装成一个商品对象
        Goods g = new Goods();
        g.id = id;
        g.name = name;
        g.price = price;
        g.buyNumber = buyNumber;

        for (int i = 0; i < shopCar.length; i++) {
            if (shopCar[i] == null) {
                shopCar[i] = g;
                break;
            }
        }
        System.out.println("您的商品" + g.name + "已经添加到购物车");

    }

}

4.构造器

构造器的作用
定义在类中的，可以用于初始化一个类的对象，并返回对象的地址。
构造器的格式

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

调用构造器得到对象的格式

Car c1 = new Car();
Car c2 = new Car("奔驰",66.6);

构造器的分类和作用
- 无参构造器（默认存在的）：初始化对象时，成员变量的数据均采用默认值。
- 有参构造器：在初始化对象的时候，同时可以接受参数为对象进行赋值。
构造器的注意事项
- 任何类定义出来，默认就自带了无参构造器。
- 一旦定义了有参构造器，那么无参构造器就没有了，如果还想用无参构造器，就需要自己手动写一个。

5.this关键字

this可以出现在构造器、方法中，代表当前对象的地址。
this关键字的作用：可以用于指定访问当前对象的成员变量、成员方法。

6.封装

面向对象的三大特征：封装、继承、多态。
封装：告诉我们如何正确设计对象的属性、方法。
封装原则：对象代表什么，就得封装对应的数据，并提供对应数据的行为。
如何更好地封装
- 一般建议对成员变量使用private（私有、隐藏）关键字修饰（private修饰的成员只能在当前类中访问）。
- 为每个成员变量提供配套public修饰的getter、setter方法保护其取值和赋值。

7.JavaBean

也称为实体类，其对象可以用于在程序中封装数据。
标准JavaBean必须满足如下书写要求：
- 成员变量使用private修饰。
- 提供成员变量对应的setXX()、getXX()方法。
- 提供一个无参构造器，有参构造器可写可不写。、

package com.itstudy.javabean;

public class User {
    //1.成员变量建议使用private私有
    private String name;
    private double height;
    private double salary;

    //2.提供无参构造器，有参构造器可写可不写
    public User() {
    }

    public User(String name, double height, double salary) {
        this.name = name;
        this.height = height;
        this.salary = salary;
    }

    //3.提供成套get和set方法
    public String getName() {
        return name;
    }

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

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }
}

package com.itstudy.javabean;

public class Test {
    public static void main(String[] args) {
        //1.通过无参数构造器创建对象封装一个用呼吸
        User u1 = new User();
        u1.setName("HAHA");
        u1.setHeight(180.0);
        u1.setSalary(10000);

        //2.通过有参构造器创建对象封装成一个用户信息
        User u2 = new User("ANNA", 175.5, 15000);
        System.out.println(u2.getName());
        System.out.println(u2.getHeight());
        System.out.println(u2.getSalary());
    }
}

8.成员变量和局部变量的区别

区别	成员变量	局部变量
类中位置不同	类中，方法外	常见于方法中
初始化值不同	有默认值，无需初始化	没有默认值，使用前需赋值
内存位置不同	堆内存	栈内存
生命周期不同	随对象的创建而存在，随着对象消失而消失	随方法的调用而存在，随方法运行结束而消失
作用域		在所属的大括号中

九、常用API（String、ArrayList） 1.String 1）String概述

java.lang.String类代表字符串，String类定义的变量可以用于指向字符串对象，然后操作该类字符串。
String常被称为不可变字符串类型，它的对象在创建后不能被更改。String变量每次修改其实都是产生并指向了新的字符串对象。

2）String类创建对象的两种方式

直接使用 “” 定义。
通过String类构造器创建对象。

构造器	说明
public String ()	创建一个空白字符串对象，不含任何内容
public String (String original)	根据传入字符串的内容，来创建字符串对象
public String (char[] chs)	根据字符数组的内容，来创建字符串对象
public String (byte[] chs)	根据字节数组的内容，来创建字符串对象

两者区别（面试常考）
- 以 “” 方式给出的字符串对象，在字符串常量池中存储，而且相同内容只会在其中存储一份。
- 通过构造器new对象，每new一次都会产生一个新对象，放在堆内存中。

3）String常见面试题

public class Test1 {
    public static void main(String[] args) {
        String s1 = new String("abc");
        //创建了2个对象，双引号给出的abc放在常量池中，new出来的对象放在堆内存中
        String s2 = "abc";
        //创建了0个对象，双引号创建的abc常量池中已经有了。如果没有上一行代码，就创建了1个。
        System.out.println(s1 == s2);
        //false，s1地址指向堆内存中，s2地址指向常量池中。
    }
}

public class Test2 {
    public static void main(String[] args) {
        String s1 = "abc";
        String s2 = "ab";
        String s3 = s2 + "c";
        System.out.println(s1 == s3);
        //false
    }
}

public class Test3 {
    public static void main(String[] args) {
        String s1 = "abc";
        String s2 = "a" + "b" + "c";
        System.out.println(s1 == s2);
        //true,Java 存在优化机制，程序在编译时："a"+"b"+"c"会直接转成"abc"
    }
}

4）String类常用API

字符串的内容比较
- 不适合用 == 比较。
- 推荐使用String类提供的equals或equalsIsIgnoreCase（忽略大小写）比较。
遍历、替换、截取、分割操作

方法名	说明
public int length ()	返回此字符串的长度
public char charAt (int index)	获取某个索引位置处的字符
public char[] toCharArray ()	将当前字符串转换成字符数组返回
public String substring (int bgdinIndex , int endIndex)	根据开始和结束索引进行截取，得到新的字符串（包前不包后）
public String substring (int bgdinIndex)	从传入的索引处截取，截取到末尾，得到新的字符串
public String replace (CharSequence target , CharSequence replacement)	使用新值，将字符串中的旧值替换，得到新的字符串
public boolean contains (CharSequence s)	判断字符串中是否包含传入的字符串
public boolean startsWith (Sring prefix)	判断字符串是否以传入的字符串开始的
public String[] split (String regex)	根据传入的规则切割字符串，得到字符串数组返回

2.ArrayList 1）集合概述

集合与数组类似，也是一种容器，用于装数据的。
数组定义完成并启动后，类型确定、长度固定。集合的大小不固定，启动后可以动态变化，类型也可以选择不固定。

2）ArrayList集合的使用

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

import java.util.ArrayList;

import java.util.ArrayList;

public class ArrayListTest {
    public static void main(String[] args) {
        //1.创建ArrayList集合的对象
        ArrayList list1 = new ArrayList();

        //2.添加数据
        list1.add("Java");
        list1.add(500.25);
        list1.add('哈');
        list1.add(true);
        System.out.println(list1);//显示的不是地址，而是集合的内容

        //3.给指定索引位置插入元素
        list1.add(1, "haha");
    }
}

3）ArrayList对于泛型的支持

ArrayList <类型>，可以在编译阶段约束集合对象只能操作某种数据类型。
集合中只能存储引用数据类型，不支持基本数据类型。

4）ArrayList常用API

        //1）public E get (int index) ：获取某个索引位置的元素
        System.out.println(list1.get(2));

        //2）public int size () ：获取集合大小
        System.out.println(list1.size());

        //3）public E remove (int index) ：删除索引位置处的元素值
        list1.remove(1);
        
        //4）public boolean remove (Object o) ：直接删除元素值，只会删除第一次出现的元素值。成功返回true，失败返回false
        System.out.println(list1.remove("haha"));
        
        //5）public E set (int index,E element) ：修改某个索引位置处的元素值
        list1.set(0,"java");

5）ArrayList练习案列

遍历并删除元素值

public class ArrayListTest1 {
    public static void main(String[] args) {
        ArrayList 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);

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

存储自定义类型的对象

public class ArrayListTest2 {
    public static void main(String[] args) {
        Movie m1 = new Movie("《肖申克的救赎》", 9.7, "罗宾斯");
        Movie m2 = new Movie("《霸王别姬》", 9.6, "张国荣、张丰毅");
        Movie m3 = new Movie("《阿甘正传》", 9.7, "汤姆·汉克斯");
        ArrayList movies = new ArrayList<>();
        movies.add(m1);
        movies.add(m2);
        movies.add(m3);
        for (int i = 0; i < movies.size(); i++) {
            Movie m = movies.get(i);
            System.out.println("电影名称：" + m.getName());
            System.out.println("电影评分：" + m.getScore());
            System.out.println("电影主演：" + m.getActor());
            System.out.println("-----------------");
        }
    }
}

package com.itstudy.arraylist;

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

元素搜索

public class ArrayListTest3 {
    public static void main(String[] args) {
        ArrayList students = new ArrayList<>();
        students.add(new Student("202230401", "黄大", 22, "Java1班"));
        students.add(new Student("202230402", "王二", 23, "Java2班"));
        students.add(new Student("202230403", "张三", 22, "Java1班"));
        students.add(new Student("202230404", "李四", 24, "Java3班"));

        for (int i = 0; i < students.size(); i++) {
            Student stu = students.get(i);
            System.out.println(stu.getId() + "t" + stu.getName() + "t" + stu.getAge() + "t" + stu.getClassName());
        }

        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请输入学号查询学生信息：");
            String id = sc.next();
            Student stu = getStudentById(students, id);
            if (stu == null) {
                System.out.println("查无此人！");
            } else {
                System.out.println("学生信息如下：");
                System.out.println(stu.getId() + "t" + stu.getName() + "t" + stu.getAge() + "t" + stu.getClassName());
            }
        }
    }

    
    public static Student getStudentById(ArrayList students, String id) {
        for (int i = 0; i < students.size(); i++) {
            Student stu = students.get(i);
            if (stu.getId().equals(id)) {
                return stu;
            }
        }
        return null;
    }
}

public class Student {
    private String id;
    private String name;
    private int age;
    private String className;

    public Student() {

    }

    public Student(String id, String name, int age, String className) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.className = className;
    }

    public String getId() {
        return id;
    }

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

    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系统模拟

package com.itstudy.atmsimulator;

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


public class ATMSystem {
    public static void main(String[] args) {
        //定义了一个集合容器，用于存放所有账户对象
        ArrayList accounts = new ArrayList<>();

        Scanner sc = new Scanner(System.in);

        //系统首页
        while (true) {
            System.out.println("============ATM系统============");
            System.out.println("1.账户登录");
            System.out.println("2.账户注册");
            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("输入的选择错误！");
            }
        }
    }

    
    private static void login(ArrayList accounts, Scanner sc) {
        System.out.println("============账户登录============");
        while (true) {
            System.out.println("请输入您的卡号：");
            String cardId = sc.next();
            Account ac = getAccountByCardId(cardId, accounts);  //根据卡号得到账户信息
            if (ac != null) {
                //查询有此账号
                while (true) {
                    System.out.println("请输入您的密码：");
                    String password = sc.next();
                    if (ac.getPassword().equals(password)) {
                        //登陆成功
                        System.out.println(ac.getName() + "恭喜您！登录成功！");
                        //登录后的操作页
                        showUserCommand(sc, ac, accounts);
                        return;  //结束登录方法
                    } else {
                        //密码输入错误
                        System.out.println("您输入的密码有误");
                    }
                }
            } else {
                //查询没有此账号
                System.out.println("对不起，系统中没有您的账户！请重新输入！");
            }
        }
    }

    
    private static void showUserCommand(Scanner sc, Account ac, ArrayList 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(ac);
                    break;
                case 2:
                    //存款
                    depositMoney(ac, sc);
                    break;
                case 3:
                    //取款
                    drawMoney(ac, sc);
                    break;
                case 4:
                    //转账
                    transferMoney(ac, sc, accounts);
                    break;
                case 5:
                    //修改密码
                    upDatePassword(ac, sc);
                    return;
                case 6:
                    //退出
                    System.out.println("退出成功！");
                    return;  //结束操作页方法
                case 7:
                    //注销账户
                    if (deleteAccount(ac, sc, accounts)) {
                        return;  //结束操作页方法
                    } else {
                        break;
                    }
                default:
                    System.out.println("输入的选择错误！");
            }
        }
    }

    
    private static boolean deleteAccount(Account ac, Scanner sc, ArrayList accounts) {
        System.out.println("您真的要销户？y/n");
        String yORn = sc.next();
        switch (yORn) {
            case "y":
                accounts.remove(ac);
                System.out.println("您的账户销户完成！");
                return true;  //返回销户成功标记
            default:
                System.out.println("当前账户继续保留！");
                return false;  //返回销户失败标记
        }
    }

    
    private static void upDatePassword(Account ac, Scanner sc) {
        System.out.println("============用户修改密码操作============");
        System.out.println("请输入当前密码：");
        String oldPassword = sc.next();
        if (ac.getPassword().equals(oldPassword)) {
            //旧密码输入成功
            while (true) {
                System.out.println("请输入新的密码：");
                String newPassword = sc.next();
                System.out.println("请确认新的密码：");
                String okNewPassword = sc.next();
                if (newPassword.equals(okNewPassword)) {
                    //两次输入新密码一致
                    ac.setPassword(newPassword);
                    System.out.println("密码修改成功！");
                    return;  //结束修改密码方法
                } else {
                    //两次输入密码不一致
                    System.out.println("输入的两次密码不一致！");
                }
            }
        } else {
            //旧密码输入失败
            System.out.println("密码不正确！");
            return;  //结束修改密码方法
        }
    }

    
    private static void transferMoney(Account ac, Scanner sc, ArrayList accounts) {
        System.out.println("============用户转账操作============");
        while (true) {
            System.out.println("请您输入对方操作的卡号：");
            String cardId = sc.next();
            Account acB = getAccountByCardId(cardId, accounts);  //根据输入的卡号得到对方账户信息
            if (acB == null) {
                //对方账户为空
                System.out.println("对不起！您输入的账户不存在！");
            } else {
                //对方账户存在
                
                //根据姓氏验证账户是目标账户
                String nameB = acB.getName();
                String tip = "*" + nameB.substring(1);
                System.out.println("请您输入" + tip + "的姓氏");
                String preName = sc.next();
                if (nameB.startsWith(preName)) {
                    //账户是目标账户
                    while (true) {
                        System.out.println("请您输入转账金额：");
                        double money = sc.nextDouble();
                        if (money > ac.getMoney()) {
                            //转账金额超过余额
                            System.out.println("余额不足！您的账户当前余额为：" + ac.getMoney());
                        } else {
                            //转账金额符合要求
                            ac.setMoney(ac.getMoney() - money);
                            acB.setMoney(acB.getMoney() + money);
                            System.out.println("转账成功！您的账户当前余额为：" + ac.getMoney());
                            return;  //结束转账方法
                        }
                    }
                } else {
                    //账户不是目标账户
                    System.out.println("您输入的信息有误！");
                }
            }
        }
    }

    
    private static void drawMoney(Account ac, Scanner sc) {
        System.out.println("============用户取钱操作============");
        while (true) {
            System.out.println("请您输入取款金额：");
            double money = sc.nextDouble();
            if (money > ac.getQuotaMoney()) {
                //超过单次限额
                System.out.println("对不起！当前账户限额为" + ac.getQuotaMoney());
            } else {
                //没有超过单次限额
                if (money > ac.getMoney()) {
                    //超过账户余额
                    System.out.println("余额不足！您的账户目前余额为：" + ac.getMoney());
                } else {
                    //转账金额符合要求
                    ac.setMoney(ac.getMoney() - money);
                    System.out.println("取款" + money + "成功！");
                    System.out.println("存款" + money + "成功！账户信息如下：");
                    showAccount(ac);  //显示账户信息
                    return;  //结束取钱方法
                }
            }
        }
    }

    
    private static void depositMoney(Account ac, Scanner sc) {
        System.out.println("============用户存钱操作============");
        System.out.println("请您输入存款金额：");
        double money = sc.nextDouble();
        ac.setMoney(ac.getMoney() + money);
        System.out.println("存款" + money + "成功！账户信息如下：");
        showAccount(ac);  //显示账户信息
    }

    
    private static void showAccount(Account ac) {
        System.out.println("============当前账户信息============");
        System.out.println("卡号：" + ac.getCardId());
        System.out.println("账户名：" + ac.getName());
        System.out.println("余额：" + ac.getMoney());
        System.out.println("限额：" + ac.getQuotaMoney());
    }

    
    private static void register(ArrayList accounts, Scanner sc) {
        //添加账户对象，用于后期封装账户信息
        Account ac = new Account();

        //录入账户信息到账户对象中
        System.out.println("============账户注册============");
        System.out.println("请输入您的账户名：");
        String name = sc.next();
        ac.setName(name);
        while (true) {
            System.out.println("请输入您的密码");
            String password = sc.next();
            System.out.println("请确认您的密码");
            String okPassword = sc.next();
            if (password.equals(okPassword)) {
                ac.setPassword(password);
                break;  //密码录入成功，结束循环
            } else {
                System.out.println("两次输入密码不一致！请重新输入！");
            }
        }
        System.out.println("请输入您每次取现的额度：");
        double quotaMoney = sc.nextDouble();
        ac.setQuotaMoney(quotaMoney);

        //为账户随机一个8位且独一无二的卡号
        String cardId = getRandomCardId(accounts);
        ac.setCardId(cardId);

        //把账户对象添加到账户集合中去
        accounts.add(ac);
        System.out.println("尊敬的" + ac.getName() + ",恭喜您！开户成功！您的卡号为：" + ac.getCardId());
    }

    
    private static String getRandomCardId(ArrayList accounts) {
        Random r = new Random();
        while (true) {
            //生成8位数字
            String cardId = "";
            for (int i = 0; i < 8; i++) {
                cardId += r.nextInt(10);
            }

            //判断卡号是否重复
            Account ac = getAccountByCardId(cardId, accounts);
            if (ac == null) {
                return cardId;
            }
        }

    }

    
    private static Account getAccountByCardId(String cardId, ArrayList accounts) {
        for (int i = 0; i < accounts.size(); i++) {
            Account ac = accounts.get(i);
            if (ac.getCardId().equals(cardId)) {
                return ac;
            }
        }
        return null;
    }
}

package com.itstudy.atmsimulator;


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

    public Account() {
    }

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

    public String getCardId() {
        return cardId;
    }

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

    public String getName() {
        return name;
    }

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

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

【学习笔记】-JavaSE基础入门

Java相关栏目本月热门文章