【JAVA基础】重新系统学习Java(八)案例二

最新推荐文章于 2024-03-28 22:56:56 发布

猫猫全栈

最新推荐文章于 2024-03-28 22:56:56 发布

阅读量2.2k

点赞数 4

分类专栏： Java基础文章标签： java

本文链接：https://blog.csdn.net/m0_64501863/article/details/124455125

版权

Java基础专栏收录该内容

8 篇文章 5 订阅

订阅专栏

编程案例汇总

面向对象

定义手机类

定义手机类，手机有品牌(brand),价格(price)和颜色(color)三个属性，有打电话call()和sendMessage()两个功能。

请定义出手机类，类中要有空参、有参构造方法，set/get方法。

定义测试类，在主方法中使用空参构造创建对象，使用set方法赋值。

调用对象的两个功能，打印效果如下：

正在使用价格为3998元黑色的小米手机打电话....
正在使用价格为3998元黑色的小米手机发短信....

//test
package com.catboss.opptest;

public class Test1 {
    public static void main(String[] args) {
        Phone p = new Phone();
        p.setBrand("小米");
        p.setPrice(3998.0);
        p.setColor("黑色");
        p.call();
        p.sendMessage();
    }
}

//phone
package com.catboss.opptest;

public class Phone {
    String brand;
    Double price;
    String color;

    public Phone() {

    }

    public Phone(String brand, Double price, String color) {
        this.brand = brand;
        this.price = price;
        this.color = color;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public Double getPrice() {
        return price;
    }

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

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public void call() {
        System.out.println("正在使用价格为" + price + "元" + color + "的" + "手机打电话...");
    }

    public void sendMessage() {
        System.out.println("正在使用价格为" + price + "元" + color + "的" + "手机发短信..");
    }
}

女朋友

定义一个女朋友类。女朋友的属性包含：姓名，身高，体重。行为包含：洗衣服wash()，做饭cook()。另外定义一个用于展示三个属性值的show()方法。请在测试类中通过有参构造方法创建对象并赋值，然后分别调用展示方法、洗衣服方法和做饭方法。打印效果如下：

我女朋友叫凤姐,身高155.0厘米,体重130.0斤
女朋友帮我洗衣服
女朋友给我做饭

//test2
package com.catboss.opptest;

public class Test2 {
    public static void main(String[] args) {
        Gril g = new Gril("小美", 159.0, 94.0);
        g.show();
        g.wash();
        g.cook();
    }
}

//Girl
package com.catboss.opptest;

public class Gril {
    private String name;
    private Double height;
    private Double weight;

    public Gril() {
    }

    public Gril(String name, Double height, Double weight) {
        this.name = name;
        this.height = height;
        this.weight = weight;
    }

    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 getWeight() {
        return weight;
    }

    public void setWeight(Double weight) {
        this.weight = weight;
    }

    public void wash() {
        System.out.println("女朋友帮我洗衣服");
    }

    public void cook() {
        System.out.println("女朋友给我做饭");
    }

    public void show() {
        System.out.println("我女朋友叫" + name + ",身高" + height + "厘米，体重" + weight + "斤");
    }
}

工作类别

定义项目经理类Manager。属性：姓名name，工号id，工资salary，奖金bonus。行为：工作work()
定义程序员类Coder。属性：姓名name，工号id，工资salary。行为：工作work()

要求：

1.按照以上要求定义Manager类和Coder类,属性要私有,生成空参、有参构造，set和get方法
2.定义测试类,在main方法中创建该类的对象并给属性赋值(set方法或有参构造方法)
3.调用成员方法,打印格式如下:

工号为123基本工资为15000奖金为6000的项目经理正在努力的做着管理工作,分配任务,检查员工提交上来的代码.....
工号为135基本工资为10000的程序员正在努力的写着代码......

//Test3
package com.catboss.opptest;

public class Test3 {
    public static void main(String[] args) {
        Manager m = new Manager("项目经理", 123, 15000.0, 6000.0);
        Coder c = new Coder("程序员", 135, 10000.0);
        m.work();
        c.work();
    }
}

//经理类
package com.ithemia.opptest;

public class Manager {
    private String name;
    private int id;
    private Double salary;
    private Double bonus;

    public Manager() {
    }

    public Manager(String name, int id, Double salary, Double bonus) {
        this.name = name;
        this.id = id;
        this.salary = salary;
        this.bonus = bonus;
    }

    public String getName() {
        return name;
    }

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

    public int getId() {
        return id;
    }

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

    public Double getSalary() {
        return salary;
    }

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

    public Double getBonus() {
        return bonus;
    }

    public void setBonus(Double bonus) {
        this.bonus = bonus;
    }

    public void work() {
        System.out.println("工号为" + id + "基本工资为" + salary + "奖金为" + bonus + "的" + name + "正在努力的做着管理工作，分配任务，检查员工提交上来的代码......");
    }
}

//程序员类
package com.catboss.opptest;

public class Coder {
    private String name;
    private int id;
    private Double salary;

    public Coder() {
    }

    public Coder(String name, int id, Double salary) {
        this.name = name;
        this.id = id;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

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

    public int getId() {
        return id;
    }

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

    public Double getSalary() {
        return salary;
    }

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

    public void work() {
        System.out.println("工号为" + id + "基本工资为" + salary + "的" + name + "正在努力的写着代码......");
    }
}

猫猫狗狗

定义猫类Cat。属性:毛的颜色color，品种breed。行为:吃饭eat()，抓老鼠catchMouse()
定义狗类Dog。属性:毛的颜色color，品种breed。行为:吃饭()，看家lookHome()
要求:
1.按照以上要求定义Cat类和Dog类,属性要私有,生成空参、有参构造，set和get方法
2.定义测试类,在main方法中创建该类的对象并给属性赋值(set方法或有参构造方法)
3.调用成员方法,打印格式如下:

花色的波斯猫正在吃鱼.....
花色的波斯猫正在逮老鼠....
黑色的藏獒正在啃骨头.....
黑色的藏獒正在看家.....

//Test4
package com.catboss.opptest;

public class Test4 {
    public static void main(String[] args) {
        Cat c = new Cat("花色", "波斯猫");
        c.eat();
        c.catchMouse();
        Dog d = new Dog("黑色", "藏獒");
        d.eat();
        d.lookHome();
    }
}

//Cat
package com.catboss.opptest;

public class Cat {
    private String color;
    private String breed;

    public Cat() {
    }

    public Cat(String color, String breed) {
        this.color = color;
        this.breed = breed;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String getBreed() {
        return breed;
    }

    public void setBreed(String breed) {
        this.breed = breed;
    }

    public void eat() {
        System.out.println(color + "的" + breed + "正在吃鱼......");
    }

    public void catchMouse() {
        System.out.println(color + "的" + breed + "正在逮老鼠......");
    }
}

//Dog
package com.catboss.opptest;

public class Dog {
    private String color;
    private String breed;

    public Dog() {
    }

    public Dog(String color, String breed) {
        this.color = color;
        this.breed = breed;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String getBreed() {
        return breed;
    }

    public void setBreed(String breed) {
        this.breed = breed;
    }

    public void eat() {
        System.out.println(color + "的" + breed + "正在啃骨头......");
    }

    public void lookHome() {
        System.out.println(color + "的" + breed + "正在看家......");
    }
}

Stirng

工人类

现已知工人（Worker）类，属性包含姓名（name）、工龄（year），请编写该类，提供构造方法和get、set方法。在测试类中，请查看键盘录入Scanner类的API，创建工人类对象，属性值由键盘录入，打印对象的属性值。输出效果如下：

请录入工人姓名：
张三
请录入工人工龄：
5
该工人对象的属性信息如下：
姓名：张三
工龄：5

//测试类
package com.catboss.stringdemo;

import java.util.Scanner;

public class Test1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入工人姓名：");
        String name = sc.next();
        System.out.println("请输入工人工龄：");
        int year = sc.nextInt();
        Worker w = new Worker(name, year);
        System.out.println("该工人对象的属性信息如下：");
        System.out.println("姓名：" + w.getName());
        System.out.println("工龄：" + w.getYear());
    }
}

//Worker类
package com.catboss.stringdemo;

public class Worker {
    private String name;
    private int year;

    public Worker() {
    }

    public Worker(String name, int year) {
        this.name = name;
        this.year = year;
    }

    public String getName() {
        return name;
    }

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

    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }
}

验证码

在登录注册页面中，除了用户名和密码外，通常也会包含验证码。验证码是用来区分用户是计算机还是人，防止恶意破解密码、刷票、灌水等行为。请查看Random、StringBuilder相关API，定义方法，获取一个包含4个字符的验证码，每一位字符是随机选择的字母和数字，可包含a-z,A-Z,0-9。

//个人低级代码
package com.catboss.stringdemo;

import java.util.Random;

public class Test2 {
    public static void main(String[] args) {
        String code = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
        Random r = new Random();
        String c = "";
        for (int i = 0; i < 4; i++) {
            int num = r.nextInt(62) + 1;
            c += code.charAt(num);
        }
        System.out.println(c);
    }
}

1、定义方法，返回值是String，参数列表为空。

2、定义StringBuilder对象，将可选择的字符都放到StringBuilder对象中。

2.1、定义循环从a-z，使用StringBuilder的append方法依次添加所有小写字母

2.2、定义循环从A-Z，使用StringBuilder的append方法依次添加所有大写字母

2.3、定义循环从0-9，使用StringBuilder的append方法依次添加所有数字字符

3、创建Random对象。定义一个空字符串用于保存验证码。

4、定义一个执行4次的循环，用于获取4个字符。

4.1、在循环中，使用Random的nextInt方法，随机获取一个从索引0（包含）到字符串的长度（不包含）的索引。

4.2、使用StringBuilder的charAt方法，获取该索引上的字符，将其拼接到验证码字符串中。

5、返回结果，并在主方法中调用方法查看结果。

package com.catboss.stringdemo;

import java.util.Random;

public class NewTest2 {
    public static void main(String[] args) {
        String code = getRandomCode();
        System.out.println(code);
    }

    public static String getRandomCode() {
        StringBuilder sb = new StringBuilder();
        for (char ch = 'a'; ch < 'z'; ch++) {
            sb.append(ch);
        }
        for (char ch = 'A'; ch <= 'Z'; ch++) {
            sb.append(ch);
        }
        for (char ch = '0'; ch <= '9'; ch++) {
            sb.append(ch);
        }
        Random r = new Random();
        String code = "";
        for (int i = 0; i < 4; i++) {
            int index = r.nextInt(sb.length());
            code += sb.charAt(index);
        }
        return code;
    }
}

输入验证码

在登录注册页面中，除了用户名和密码外，通常也会包含验证码。验证码是用来区分用户是计算机还是人，防止恶意破解密码、刷票、灌水等行为。在判断验证码时一般不区分大小写。请编写程序模拟验证码的判断过程，如果输入正确，给出提示，结束程序。如果输入错误，给出提示，验证码刷新，重新输入，直至正确为止。

生成4位随机验证码的功能在之前的题目中已经完成，可以直接使用。《定义方法，获取一个包含4个字符的验证码，每一位字符是随机选择的字母和数字，可包含a-z,A-Z,0-9。》

生成的验证码为：BkhD
请输入验证码
abcd
输入错误，请重新输入...
生成的验证码为：n1wX
请输入验证码
aaaa
输入错误，请重新输入...
生成的验证码为：Fm1a
请输入验证码
fm1a
输入正确

package com.catboss.stringdemo;

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

public class Test3 {
    public static void main(String[] args) {
        while (true) {
            String code = getRandomCode();
            System.out.println("生成的验证码为：" + code);
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入验证码：");
            String line = sc.next();
            if (line.equalsIgnoreCase(code)) {
                System.out.println("输入正确");
                break;
            } else {
                System.out.println("输入错误，请重新输入");
            }
        }
    }

    public static String getRandomCode() {
        StringBuilder sb = new StringBuilder();
        for (char ch = 'a'; ch < 'z'; ch++) {
            sb.append(ch);
        }
        for (char ch = 'A'; ch <= 'Z'; ch++) {
            sb.append(ch);
        }
        for (char ch = '0'; ch <= '9'; ch++) {
            sb.append(ch);
        }
        Random r = new Random();
        String code = "";
        for (int i = 0; i < 4; i++) {
            int index = r.nextInt(sb.length());
            code += sb.charAt(index);
        }
        return code;
    }
}

统计字母数字

请编写程序，由键盘录入一个字符串，统计字符串中英文字母和数字分别有多少个。比如：Hello12345World中字母：10个，数字：5个。

package com.catboss.stringdemo;

import java.util.Scanner;

public class Test4 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("输入一串字符：");
        String code = sc.next();
        int l = 0;
        int n = 0;
        int error = 0;
        for (int i = 0; i < code.length(); i++) {
            char c = code.charAt(i);
            if (c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z') {
                l++;
            } else if (c >= '0' && c <= '9') {
                n++;
            } else {
                error++;
            }
        }
        System.out.println(code + "中字母：" + l + "个，数字：" + n + "个");
    }
}

判断字符串是否对称

请定义一个方法用于判断一个字符串是否是对称的字符串，并在主方法中测试方法。例如：“abcba”、"上海自来水来自海上"均为对称字符串。

//自己没有做出来，抄的参考答案
package com.catboss.stringdemo;

import java.util.Scanner;

public class Test5 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("输入一串字符串：");
        String code = sc.next();
        System.out.println("是否是对称字符串：" + isSym(code));
    }

    public static boolean isSym(String str) {
        // 为了程序的健壮，如果传递的是空值，返回false
        if (str == null) {
            return false;
        }
        // 转换为StringBuilder
        StringBuilder sb = new StringBuilder(str);
        // 反转，再转成String
        String reStr = sb.reverse().toString();
        // 比较与原字符串是否相等
        // 相等返回true，不相等返回false，正好与equals的返回值一致，直接返回即可。
        return reStr.equals(str);
    }
}

身份证规则

我国的居民身份证号码，由由十七位数字本体码和一位数字校验码组成。请定义方法判断用户输入的身份证号码是否合法，并在主方法中调用方法测试结果。规则为：号码为18位，不能以数字0开头，前17位只可以是数字，最后一位可以是数字或者大写字母X

package com.catboss.stringdemo;

import java.util.Scanner;

public class Test6 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入身份证号：");
        String id = sc.next();
        System.out.println("输入身份证是否正确：" + check(id));
    }

    public static boolean check(String id) {
        if (id == null) {
            return false;
        }
        if (id.startsWith("0")) {
            return false;
        }
        if (id.length() != 18) {
            return false;
        }
        for (int i = 0; i < id.length(); i++) {
            char c = id.charAt(i);
            if (i == id.length() - 1) {
                if (c < '0' || c > '9' && c != 'X') {
                    return false;
                } else {
                    if (c < '0' || c > '9') {
                        return false;
                    }
                }
            }
        }
        return true;
    }
}

拼接字符串

定义一个方法，把 int 数组中的数据按照指定的格式拼接成一个字符串返回，调用该方法，并在控制台输出结果。

要求：

1、如果传递的参数为空，返回null

2、如果传递的数组元素个数为0，返回[]

3、如果数组为int[] arr = {1,2,3}; ，执行方法后的输出结果为：[1, 2, 3]

//参考答案
public class Test07 {
    public static void main(String[] args) {
        // 定义一个 int 类型的数组，用静态初始化完成数组元素的初始化
        int[] arr = {1, 2, 3};
        // 调用方法，输出结果
        System.out.println(arrayToString(arr));
    }

    /*定义一个方法，用于把 int 数组中的数据按照指定格式拼接成一个字符串返回
		返回值类型：String
		参数：int[] arr
     */
    public static String arrayToString(int[] arr) {
        // 健壮性判断
        if (arr == null) {
            return null;
        }
        //在方法中用 StringBuilder 按照要求进行拼接，并把结果转成 String 返回
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (int i = 0; i < arr.length; i++) {
            // 拼接元素
            sb.append(arr[i]);
            // 如果不是最后一个元素，再拼接逗号和空格
            if (i != arr.length - 1) {
                sb.append(", ");
            }
        }
        sb.append("]");
        return sb.toString();
    }
}

统计词次数

在String类的API中，有如下两个方法：

// 查找参数字符串str在调用方法的字符串中第一次出现的索引，如果不存在，返回-1
public int indexOf(String str)

// 截取字符串，从索引beginIndex（包含）开始到字符串的结尾
public String substring(int beginIndex)

请仔细阅读API中这两个方法的解释，完成如下需求。

现有如下文本：“Java语言是面向对象的，Java语言是健壮的，Java语言是安全的，Java是高性能的，Java语言是跨平台的”。请编写程序，统计该文本中"Java"一词出现的次数。

//参考答案
package com.catboss.stringdemo;

public class Test8 {
    public static void main(String[] args) {
        String str = "Java语言是面向对象的，Java语言是健壮的，Java语言是安全的，Java是高性能的，Java语言是跨平台的";
        String tar = "Java";
        // 调用方法并输出
        System.out.println(search(str, tar));
    }

    public static int search(String str, String tar) {
        // 定义统计变量表示次数
        int count = 0;
        // 定义索引变量，表示每次找到子串出现的索引
        int index = -1;
        // 定义循环，判断条件为在字符串中找到了目标子串
        while ((index = str.indexOf(tar)) != -1) { // 将找到的索引赋值给变量并判断
            // 次数累加
            count++;
            // 把查找过的部分剪切掉，从找到的索引+子串长度的位置开始截取。
            str = str.substring(index + tar.length());
        }
        return count;
    }
}

ArrayList

集合存入输出

现有如下字符串元素：[“aaa”, “bbb”, “aaa”, “aaa”, “ccc”, “bbb”]，请将所有的元素按顺序存入ArrayList集合中，并遍历集合查看存储结果。

package com.catboss.arraydemo;

import java.util.ArrayList;

public class Test1 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("aaa");
        list.add("aaa");
        list.add("ccc");
        list.add("bbb");
        for (int i = 0; i < list.size(); i++) {
            String element = list.get(i);
            System.out.println(element);
        }
    }
}

遍历集合存储对象

请定义教师（Teacher）类，属性包含姓名和专业名称。将若干教师对象存入ArrayList集合中，并遍历集合打印教师信息，格式如下：

姓名：赵老师, 专业：javase
姓名：钱老师, 专业：javaee
姓名：孙老师, 专业：php
姓名：李老师, 专业：python

package com.catboss.arraydemo;

import java.util.ArrayList;

public class Test2 {
    public static void main(String[] args) {
        Teacher t1 = new Teacher("赵老师", "javase");
        Teacher t2 = new Teacher("钱老师", "javaee");
        Teacher t3 = new Teacher("孙老师", "php");
        Teacher t4 = new Teacher("李老师", "python");
        ArrayList<Teacher> list = new ArrayList<>();
        list.add(t1);
        list.add(t2);
        list.add(t3);
        list.add(t4);
        for (int i = 0; i < list.size(); i++) {
            Teacher element = list.get(i);
            System.out.print("姓名：" + element.getName() + ",\t");
            System.out.println("专业：" + element.getSubject());
        }
    }
}

员工操作

有如下员工信息：

姓名：张三，工资：3000
姓名：李四，工资：3500
姓名：王五，工资：4000
姓名：赵六，工资：4500
姓名：田七，工资：5000

先需要将所有的员工信息都存入ArrayList集合中，并完成如下操作：

1、判断是否有姓名为“王五”的员工，如果有，改名为“王小五”

2、判断是否有姓名为“赵六”的员工，如果有，将其删除

3、给姓名为“田七”的员工，涨500工资

//自己
package com.catboss.arraydemo;

import java.util.ArrayList;

public class Test3 {
    public static void main(String[] args) {
        Worker w1 = new Worker("张三", 3000);
        Worker w2 = new Worker("李四", 3500);
        Worker w3 = new Worker("王五", 4000);
        Worker w4 = new Worker("赵六", 4500);
        Worker w5 = new Worker("田七", 5000);
        ArrayList<Worker> list = new ArrayList<>();
        list.add(w1);
        list.add(w2);
        list.add(w3);
        list.add(w4);
        list.add(w5);
        for (int i = 0; i < list.size(); i++) {
            Worker w = list.get(i);
            if ("王五".equals(w.getName())) {
                w.setName("S王小五");
            }
            if ("赵六".equals(w.getName())) {
                list.remove(i);
                i--;
            }
            if ("田七".equals(w.getName())) {
                w.setMoney(w.getMoney() + 500);
            }

        }
        list.forEach((w) -> {
            System.out.print("姓名：" + w.getName() + ",\t");
            System.out.println("工资：" + w.getMoney());
        });
    }
}

//参考答案
public class Worker {
    private String name;
    private int salary;

    public Worker() {
    }

    public Worker(String name, int salary) {
        this.name = name;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

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

    public int getSalary() {
        return salary;
    }

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

import java.util.ArrayList;

public class Test03 {
    public static void main(String[] args) {
        // 创建集合对象
        ArrayList<Worker> list = new ArrayList<>();
        // 创建员工对象并添加到集合中
        list.add(new Worker("张三", 2000));
        list.add(new Worker("李四", 2500));
        list.add(new Worker("王五", 3000));
        list.add(new Worker("赵六", 3500));
        list.add(new Worker("田七", 4000));
        // 判断是否有王五，如果有，改名为王小五
        // 判断是否有赵六，如果有，删除赵六
        // 给田七加500块工资
        for (int i = 0; i < list.size(); i++) {
            Worker w = list.get(i);
            if ("王五".equals(w.getName())) {
                w.setName("王小五");
                list.set(i, w);
            }
            if ("赵六".equals(w.getName())) {
                // 注意，一旦删除元素，后面的元素会往前走，索引再加1就会有元素遗漏，所以删除后要--
                list.remove(i--);
            }
            if ("田七".equals(w.getName())) {
                w.setSalary(w.getSalary() + 500);
                list.set(i, w);
            }
        }
        // 再次遍历查看结果
        for (int i = 0; i < list.size(); i++) {
            Worker w = list.get(i);
            System.out.println(w.getName() + "---" + w.getSalary());
        }
    }
}

图书管理系统

利用面向对象的思想设计一个图书管理系统。图书的属性有：编号，书名，作者，价格。要求提供如下功能：

1、提供操作菜单，可以选择要进行的操作。

2、可以添加图书，添加图书时，编号需要唯一，添加成功，返回到菜单。

3、可以查询图书，显示所有图书信息，然后返回到菜单。

4、可以根据书名，查询单本图书信息，显示信息后，返回到菜单。

5、可以删除图书，通过编号删除，删除成功后，返回到菜单。

6、可以修改图书的信息，但编号不可以修改，修改成功后，返回到菜单。

7、可以退出系统，结束程序运行。

//测试类
package com.catboss.arraydemo;

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

public class Test4 {
    public static void main(String[] args) {
        ArrayList<Book> list = new ArrayList<>();
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("----图书管理系统----");
            menu();
            System.out.println("输入要操作的编号：");
            String type = sc.nextLine();
            switch (type) {
                case "1":
                    addBook(list);
                    break;
                case "2":
                    findAllBook(list);
                    break;
                case "3":
                    findBookByName(list);
                    break;
                case "4":
                    updateBook(list);
                    break;
                case "5":
                    deleteBook(list);
                    break;
                case "6":
                    System.out.println("感谢使用，再见");
                    System.exit(0);
                    //1.正常终止当前运行的Java虚拟机：System.exit(0)
                    //2.异常终止当前运行的Java虚拟机：System.exit(非零的int型参数)
                default:
                    System.out.println("没有此操作，请重新输入");
                    break;
            }
        }
    }

    public static void menu() {
        System.out.println("1.添加图书");
        System.out.println("2.查询图书");
        System.out.println("3.根据书名查询图书");
        System.out.println("4.根据编号修改图书");
        System.out.println("5.根据编号删除图书");
        System.out.println("6.退出系统");
    }

    /**
     * 查询编号是否存在 存在返回true 不存在返回false
     *
     * @param list
     * @param id
     * @return
     */
    public static boolean isExist(ArrayList<Book> list, String id) {
        for (int i = 0; i < list.size(); i++) {
            if (id.equals(list.get(i).getId())) {
                return true;
            }
        }
        return false;
    }

    //删除图书
    public static void deleteBook(ArrayList<Book> list) {
        Scanner sc = new Scanner(System.in);
        System.out.println("----删除图书----");
        System.out.println("请输入要删除的图书编号");
        String id = sc.nextLine();
        for (int i = 0; i < list.size(); i++) {
            Book b = list.get(i);
            if (id.equals(b.getId())) {
                list.remove(i);
                return;
            }
        }
        System.out.println("未找到您要删除的图书");
    }

    //修改图书
    public static void updateBook(ArrayList<Book> list) {
        Scanner sc = new Scanner(System.in);
        System.out.println("----修改图书----");
        System.out.println("输入要修改图书的编号：");
        String id = sc.nextLine();
        for (int i = 0; i < list.size(); i++) {
            Book b = list.get(i);
            if (id.equals(b.getId())) {
                System.out.println("编号\t\t书名\t\t\t作者\t\t\t价格");
                System.out.println(b.getId() + "\t\t" + b.getName() + "\t\t" + b.getAuthor() + "\t\t" + b.getPrice());
                System.out.println("请输入修改后的书名：");
                String name = sc.nextLine();
                System.out.println("请输入修改后的z作者：");
                String author = sc.nextLine();
                System.out.println("请输入修改后的价格：");
                String prise = sc.nextLine();
                Book newBook = new Book(id, name, author, prise);
                list.set(i, newBook);
                System.out.println("----修改成功----");
                return;
            }
        }
        System.out.println("没有该编号的图书信息");
    }

    //根据书名查询
    public static void findBookByName(ArrayList<Book> list) {
        Scanner sc = new Scanner(System.in);
        System.out.println("----查询图书----");
        System.out.println("请输入要查询的图书书名：");
        String name = sc.nextLine();
        for (int i = 0; i < list.size(); i++) {
            Book b = list.get(i);
            if (name.equals(b.getName())) {
                System.out.println("找到以下书籍");
                System.out.println("编号\t\t书名\t\t\t作者\t\t\t价格");
                System.out.println(b.getId() + "\t\t" + b.getName() + "\t\t" + b.getAuthor() + "\t\t" + b.getPrice());
                return;
            }
        }
        System.out.println("没有您要找的图书");
    }

    //查询所有图书
    public static void findAllBook(ArrayList<Book> list) {
        System.out.println("----所有图书信息----");
        System.out.println("编号\t\t书名\t\t\t作者\t\t\t价格");
        for (int i = 0; i < list.size(); i++) {
            Book b = list.get(i);
            System.out.println(b.getId() + "\t\t" + b.getName() + "\t\t" + b.getAuthor() + "\t\t" + b.getPrice());
        }
    }

    //添加图书
    public static void addBook(ArrayList<Book> list) {
        Scanner sc = new Scanner(System.in);
        System.out.println("----添加图书----");
        System.out.println("请输入图书编号：");
        String id;
        while (true) {
            id = sc.nextLine();
            if (isExist(list, id)) {
                System.out.println("该编号已经存在，请重新输入");
            } else {
                break;
            }
        }
        System.out.println("请输入书名：");
        String name = sc.nextLine();
        System.out.println("请输入作者：");
        String author = sc.nextLine();
        System.out.println("请输入价格：");
        String prise = sc.nextLine();
        Book b = new Book(id, name, author, prise);
        list.add(b);
        System.out.println("----添加成功----");
    }
}

//图书类
package com.catboss.arraydemo;

public class Book {
    private String id;
    private String name;
    private String author;
    private String price;

    public Book() {
    }

    public Book(String id, String name, String author, String price) {
        this.id = id;
        this.name = name;
        this.author = author;
        this.price = price;
    }

    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 String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public String getPrice() {
        return price;
    }

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