Java基础知识(JavaSE)总结进阶拓展01

一阶段: JavaSE基础进阶拓展01

看不懂或者不想看的可以跳往下一篇，这个只是让你知识面更宽更广

1.技师管理系统拓展：

环境搭建(暂时这样记包名，类自己定义，到后面框架可能会有所不同)

包(记住)	储存的类	作用
entry	InfoManagerEntry.java	程序的入口类，提供一个main方法
domain	Technician.java	封装技师信息
controller	TechnicianController.java	和用户打交道(客服接待)
service	TechnicianService.java	业务逻辑处理(业务员)
dao	TechnicianDao.java	访问储存数据的数组，进行增删查改(数据管理员)

菜单搭建实现步骤

• 需求
  • 技师管理系统菜单搭建
• 实现步骤
  1. 展示欢迎页面,用输出语句完成主界面的编写
  2. 获取用户的选择,用Scanner实现键盘录入数据
  3. 根据用户的选择执行对应的操作,用switch语句完成操作的选择

​ 由于仿照某视频学生管理系统的实现，所以借鉴它的图，不过实现是差不多的。

• 添加功能实现步骤
  

• 添加功能优化:判断id是否存在
  

• 查询功能实现步骤
  

• 删除功能实现步骤
  

• 修改功能实现步骤
  
  代码实现：(有一定的难度，看着图片实现)

entry包:(未导包，复制请导包)

import java.util.Scanner;
/**
 * @author 你的大龙猫啊
 */
public class InfoManagerEntry {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        while (true) {
            //主菜单搭建
            System.out.println("--------欢迎来到龙猫信息管理系统--------");
            System.out.println("请输入您的选择: 1.技师管理  2.经理管理  3.退出");
            String choice = sc.next();
            switch (choice) {
                case "1":
                    TechnicianController technicianController = new TechnicianController();
                    technicianController.start();
                    break;
                case "2":
                    System.out.println("经理管理");
                    break;
                case "3":
                    //退出当前正在运行的JVM虚拟机
                    System.out.println("感谢你的使用");
                    System.exit(0);
                    //break; jvm已经结束  不需要使用
                default:
                    System.out.println("您的输入有误，请重新输入");
                    break;
            }
        }
    }
}

domain包:(未导包，复制请导包)

/**
 * @author 你的大龙猫啊
 */
public class Technician {
    private String id;
    private String name;
    private String age;
    private String birthday;

    public Technician() {
    }

    public Technician(String id, String name, String age, String birthday) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.birthday = birthday;
    }

    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 getAge() {
        return age;
    }

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

    public String getBirthday() {
        return birthday;
    }

    public void setBirthday(String birthday) {
        this.birthday = birthday;
    }
}

controller包:(未导包，复制请导包)

import java.util.Scanner;
/**
 * @author 你的大龙猫啊
 * @company www.com.hui
 */
public class TechnicianController {
    //1.键盘接收学生信息
    private Scanner sc = new Scanner(System.in);
    //创建技师服务对象
    private TechnicianService technicianService = new TechnicianService();

    public void start() {
        // Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("--------欢迎来到 <技师> 管理系统--------");
            System.out.println("请输入您的选择: 1.添加技师  2.删除技师  3.修改技师  4.查看技师  5.退出");
            String choice = sc.next();
            switch (choice) {
                case "1":
                    addTechnician();
                    break;
                case "2":
                    deleteById();
                    break;
                case "3":
                   updateById();
                    break;
                case "4":
                    findAllTechnician();
                    break;
                case "5":
                    //退出当前正在运行的JVM虚拟机
                    System.out.println("感谢你的使用技师管理系统");
                    return;   //不建议使用break的标记的做法 建议使用return
                default:
                    System.out.println("您的输入有误，请重新输入");
                    break;
            }
        }
    }

    public void findAllTechnician() {
        //1.调用业务员中的获取方法，得到学生的对象数组
        Technician[] ts = technicianService.findAllTechnician();
        //2.判断数组的内存地址，是否为null
        if (ts == null) {
            System.out.println("查无信息，请添加后重试");
            return;
        }
        //3.遍历数组,获取学生信息并打印在控制台
        System.out.println("学号\t\t姓名\t年龄\t生日");
        for (int i = 0; i < ts.length; i++) {
            Technician t = ts[i];
            if (t != null) {
                System.out.println(t.getId() + "\t" + t.getName() + "\t" + t.getAge() + "\t\t" + t.getBirthday());
            }
        }

    }

    public void addTechnician() {
        String id;
        while (true) {
            System.out.println("请输入技师ID：");
            id = sc.next();
            boolean flag = technicianService.isExists(id);
            if (flag) {
                System.out.println("ID已经被占用,请重新输入");
            } else {
                break;
            }
        }
        System.out.println("请输入技师姓名：");
        String name = sc.next();
        System.out.println("请输入技师年龄：");
        String age = sc.next();
        System.out.println("请输入技师生日：");
        String birthday = sc.next();
        //2.将技师信息封装为技师对象
        Technician t = new Technician(id, name, age, birthday);
        //3.将技师对象，传递给TechnicianService(业务员)中的addTechnician方法
        boolean result = technicianService.addTechnician(t);
        //4.根据返回的boolean类型结果，在控制台打印成功/失败
        if (result) {
            System.out.println("添加成功");
        } else {
            System.out.println("添加失败");
        }
    }

    public void deleteById() {
        //1.调用业务员中的获取方法，得到学生的对象数组
        Technician[] ts = technicianService.findAllTechnician();
        //2.判断数组的内存地址，是否为null
        if (ts == null) {
            System.out.println("查无信息，请添加后重试");
            return;
        }
        String did;
        while (true) {
            //键盘录入要删除的学生id
            System.out.println("请输入你要删除的技师id");
            did = sc.next();
            //2.判断id在容器中是否存在，如果不存在，则需要一直录入
            boolean exists = technicianService.isExists(did);
            if (!exists) {
                System.out.println("你输入的id不存在，请重新输入");
            } else {
                break;
            }
        }
        //3.调用业务员中的deleteById方法根据id删除学生
        technicianService.deleteById(did);
        //4.提示删除成功
        System.out.println("删除成功");
    }

    private void updateById() {
        //1.调用业务员中的获取方法，得到学生的对象数组
        Technician[] ts = technicianService.findAllTechnician();
        //2.判断数组的内存地址，是否为null
        if (ts == null) {
            System.out.println("查无信息，请添加后重试");
            return;
        }

        String uid;
        while (true){
            System.out.println("请输入要修改的技师ID");
            uid= sc.next();
            boolean exists = technicianService.isExists(uid);
            if(!exists){
                System.out.println("你输入的ID不存在，请重新录入");
            }else {
                break;
            }
        }
        System.out.println("请输入技师姓名");
        String name = sc.next();
        System.out.println("请输入技师姓名");
        String age = sc.next();
        System.out.println("请输入技师姓名");
        String birthday = sc.next();
        Technician newT = new Technician(uid,name,age,birthday);

        technicianService.updateTechnician(uid,newT);   //确定ID 更改为newT
        System.out.println("修改成功");

    }
}

service包:(未导包，复制请导包)

/**
 * @author 你的大龙猫啊
 */
public class TechnicianService {
    //1.创建addTechnician(库管)
    private TechnicianDao technicianDao = new TechnicianDao();

    public boolean addTechnician(Technician t) {
        //2.将技师对象，传递给TechnicianDao 库管中的addTechnician
        //3.将返回的boolean类型结果,返回给TechnicianController
        return technicianDao.addTechnician(t);
    }

    public boolean isExists(String id) {
        Technician[] ts = technicianDao.findAllTechnician();
        //假设id在数组中不存在
        boolean exists = false;
        //遍历数组，获取每一个技师
        for (int i = 0; i < ts.length; i++) {
            Technician technician = ts[i];
            if (technician != null && technician.getId().equals(id)) {
                exists = true;
                break;
            }
        }
        return exists;
    }

    public Technician[] findAllTechnician() {
        //1.调用库管对象的findAllTechnician获取技师对象数组
        Technician[] allTechnician = technicianDao.findAllTechnician();
        //2.判断数组中是否有技师信息(有：返回地址，没有：返回null)
        //思路：数组中只要存在一个不是null的元素，那就代表有技师
        boolean flag = false;
        for (int i = 0; i < allTechnician.length; i++) {
            Technician ts = allTechnician[i];
            if (ts != null) {
                flag = true;
                break;
            }
        }
        if (flag) {
            //有信息
            return allTechnician;
        } else {
            return null;
        }
    }


    public void deleteById(String did) {
        technicianDao.deleteById(did);
    }

    public void updateTechnician(String uid, Technician newT) {
        technicianDao.updateById(uid,newT);
    }
}

dao包:(未导包，复制请导包)

package com.hui.day01.manager.dao;

import com.hui.day01.manager.domain.Technician;

/**
 * @author 你的大龙猫啊
 * @company www.com.hui
 */
public class TechnicianDao {
    private static Technician[] ts = new Technician[5];
//使用静态代码快自动生成一些数据，此处可不写
    static {
        Technician t1 = new Technician("heima001","张三","18","1999-11-11");
        Technician t2 = new Technician("heima002","李四","18","1999-11-11");
        Technician t3 = new Technician("heima003","王五","18","1999-11-11");
        ts[0] = t1;
        ts[1] = t2;
        ts[2] = t3;
    }

    public void deleteById(String did) {
        //1.查找id在容器中所在的索引位置
        int index = getIndex(did);
        //2.将该索引位置，使用null元素进行覆盖
        ts[index] = null;
    }

    public boolean addTechnician(Technician t) {
        //1.创建技师对象数组
        //2.添加技师到数组
        //2.1定义变量index=-1，假设数组已经全部存满，没有null的元素
        int index = -1;
        //2.2遍历数组取出每一个元素，判断是否是null
        for (int i = 0; i < ts.length; i++) {
            Technician technician = ts[i];
            if (technician == null) {
                index = i;
                //2.3如果为null，让index变量记录当前索引位置，并使用break结束循环遍历
                break;
            }
        }
        //3.返回是否添加成功的boolean类型状态
        if (index == -1) {
            //装满了
            return false;
        } else {
            //没有装满，正常添加，返回true
            ts[index] = t;
            return true;
        }
    }

    public Technician[] findAllTechnician() {
        return ts;
    }

    //根据id获取索引
    public int getIndex(String id) {
        int index = -1;
        for (int i = 0; i < ts.length; i++) {
            Technician t = ts[i];
            if (t != null && t.getId().equals(id)) {
                index = i;
                break;
            }
        }
        return index;
    }

    public void updateById(String uid, Technician newT) {
        //1.查找uid在容器中索引的位置
        int index = getIndex(uid);
        //2.将该索引位置的学生对象，使用新的学生对象进行替换
        ts[index] = newT;
    }
}