先有企业级代码思维（代码写健壮），再有企业级代码 - 编程导航

▼
/**
复制代码
 * day29:定义Worker类（姓名/工种/工龄/评分），创建2个师傅对象并打印信息。
 * day30:给Worker加3种构造：无参/姓名+工种/全字段，分别创建对象验证；用this区分同名参数
 * day31：给Worker加static计数器count，每创建一个对象+1，打印当前平台注册师傅总数
 * day32：Worker字段全改private；setWorkYears里校验工龄不能<0（负数就置0或抛提示），setScore校验0-5分
 * day33：师傅管理小程序：Worker数组容量10，支持添加、按名字查找、打印全部（遍历调用toString前先自己拼信息）
 * day34：在Day5基础上加：按工种筛选、按评分排序、统计平均工龄，全部封装成方法
 * day35：默写Worker类（封装+构造器+计数器版）
 *
 *
 */


import java.util.Scanner;

public class Day33WorkerTest {
    //  定义程序、输入等的提示词
    private static final int MENU_ITEM_NUMBER_ADD = 1;
    private static final int MENU_ITEM_NUMBER_SEARCH = 2;
    private static final int MENU_ITEM_NUMBER_PRINT = 3;

    private static final String APP_EXIT_WORD = "EXIT";
    private static final String APP_MENU = "【1-增加师傅 | 2-按名字模糊查找 | 3-打印全部 | exit-退出】";
    private static final String INPUT_MENU_TIP = "请输入您的选择：";
    private static final String[] JOB_TYPE_DICT = {"水电工", "木工", "瓦工", "油漆工", "空调工", "智能调试"};
    private static final String APP_TITLE = "师傅管理小程序";
    private static final String APP_LINE = "--------------------------------------------------------------------------------";
    //  定义提示词常量
    private static final String EXIT_TIP = "Thanks. See you next time.";
    private static final String APP_MENU_NAME_TIP = "请输入姓名【exit - 退出】：";
    private static final String APP_MENU_JOB_TYPE_TIP = "请输入工种【exit - 退出】：";
    private static final String APP_MENU_WORK_YEAR_TIP = "请输入工龄（不能小于0，不能大于70）【exit - 返回】：";
    private static final String APP_MENU_SCORE_TIP = "请输入评分（0-5分，可以小数[小数点后一位]）【exit - 返回】：";
    private static final String ERROR_INPUT_IS_BLANK_TIP = "空输入，请重新输入！";
    private static final String ERROR_INPUT_INVALID_TIP = "无效的输入，请重新输入！";
    private static final String OVER_MAX_SIZE_TIP = "名额已满，无法再增加！";
    public static final String MSG_WORK_TYPE_NOT_EXIST = "该工种暂未收录，已为你记录上报，审核通过后全平台可用";
    public static final String NO_DATA_FOR_FOUND_TIP = "没有可供查找的数据，请先输入师傅的数据！";
    public static final String NO_DATA_FOUND_TIP = "没有找到数据！";
    public static final String NO_DATA_FOR_PRINT_TIP = "没有数据可供打印，请先输入数据！";

    //  定义哨兵值常量
    private static final int SENTINEL_EXIT = -1;
    private static final int SENTINEL_IS_BLANK = -2;
    private static final int SENTINEL_IS_INVALID = -3;

    //  正则表达式，菜单（1-3）、工龄（大于0）、评分（0-5分，可以一位小数）
    private static final String MENU_ITEM_NUMBER_REGEX = "[1-3]"; //  菜单
    private static final String WORK_YEAR_REGEX = "[0-9]+"; //  拦截负数，0放行
    private static final String SCORE_REGEX = "[0-9]+(\\.[0-9])?";    //  非负整数或一位小数

    //  定义用户数组的容量、声明数组、用户增加计数器
    private static final int WORKER_SIZE = 10;
    private static Worker33[] workers = new Worker33[WORKER_SIZE];
    private static int foundCount = 0;  //  定义查找到符合记录的计数器


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

        //  菜单流程
        while (true) {
            System.out.println(APP_TITLE);
            System.out.println(APP_LINE);
            System.out.println(APP_MENU);
            System.out.print(INPUT_MENU_TIP);

            int inputMenuItemNumber = getMenuItemNumber(in.nextLine().strip());
            if (inputMenuItemNumber == SENTINEL_EXIT) {
                System.out.println(EXIT_TIP);
                break;
            }

            switch (inputMenuItemNumber) {
                case MENU_ITEM_NUMBER_ADD -> {
                    addWorker(in);
                }
                case MENU_ITEM_NUMBER_SEARCH -> {
                    searchWorker(in);
                }
                case MENU_ITEM_NUMBER_PRINT -> {
                    printAllWorkerInfo();
                }
                default -> {
                    System.out.println(ERROR_INPUT_INVALID_TIP);
                }
            }
        }
    }

    /**
     * 模糊搜索，可以搜索多条符合的记录
     *
     * @param in 键盘输入
     */
    public static void searchWorker(Scanner in) {
        int sourceRecord = Worker33.count;   //  源记录有多少条（有多少条数据可供查找）
        foundCount = 0;  //  查找统计计数器清零
        //  没有源记录
        if (sourceRecord == 0) {
            System.out.println(NO_DATA_FOR_FOUND_TIP);
            return;
        }
        //  有源记录
        String searchName = inputName(in);
        if (searchName == null) {
            return;
        }
        //  源记录有 1 条及以上
        int[] foundIdxs = new int[sourceRecord]; //  创建源记录数量的数组
        for (int i = 0; i < sourceRecord; i++) {
            //  空数据不查找
            String name = workers[i].getName();
            int foundIdx = name.indexOf(searchName);
            if (foundIdx != -1) {
                foundIdxs[foundCount] = i;
                foundCount++;
            }
        }
        if (foundCount>0){
            for (int j = 0; j < foundCount; j++) {
                System.out.println(workers[foundIdxs[j]]);
            }
        }else{
            System.out.println(NO_DATA_FOUND_TIP);
        }
    }

    /**
     * 打印全部记录
     */
    public static void printAllWorkerInfo() {
        int sourceRecord;   //  源记录有多少条（有多少条数据可供查找）
        sourceRecord = Worker33.count;
        //  没有源记录
        if (sourceRecord == 0) {
            System.out.println(NO_DATA_FOR_PRINT_TIP);
        } else {
            for (int i = 0; i < sourceRecord; i++) {
                //  有数据才打印，空数据不打印
                System.out.println(workers[i]);
            }
        }
    }

    /**
     * 输入姓名
     *
     * @param in 键盘输入
     * @return
     */
    public static String inputName(Scanner in) {
        while (true) {
            System.out.print(APP_MENU_NAME_TIP);
            String inputStr = in.nextLine().strip();

            //  空输入
            if (inputStr.isBlank()) {
                System.out.println(ERROR_INPUT_IS_BLANK_TIP);
            } else {
                if (APP_EXIT_WORD.equalsIgnoreCase(inputStr)) {
                    return null;
                }
                return inputStr;
            }
        }
    }

    /**
     * 输入工种
     *
     * @param in 键盘输入
     * @return
     */
    public static String inputJobType(Scanner in) {
        while (true) {
            System.out.print(APP_MENU_JOB_TYPE_TIP);
            String inputStr = in.nextLine().strip();

            //  空输入
            if (inputStr.isBlank()) {
                System.out.println(ERROR_INPUT_IS_BLANK_TIP);
                continue;
            } else {
                if (APP_EXIT_WORD.equalsIgnoreCase(inputStr)) {
                    return null;
                }
                boolean isHit = false;
                for (String type : JOB_TYPE_DICT) {
                    if (type.equalsIgnoreCase(inputStr)) {
                        isHit = true;
                        break;
                    }
                }
                if (!isHit) {
                    System.out.println(MSG_WORK_TYPE_NOT_EXIST);
                    continue;
                }
                return inputStr;
            }
        }
    }

    /**
     * 输入工龄
     *
     * @param in 键盘输入
     * @return
     */
    public static Integer inputWorkYear(Scanner in) {
        while (true) {
            System.out.print(APP_MENU_WORK_YEAR_TIP);
            String inputStr = in.nextLine().strip();
            //  空输入
            if (inputStr.isBlank()) {
                System.out.println(ERROR_INPUT_IS_BLANK_TIP);
                continue;
            }
            if (APP_EXIT_WORD.equalsIgnoreCase(inputStr)) {
                return null;
            }
            if (!inputStr.matches(WORK_YEAR_REGEX)) {
                System.out.println(ERROR_INPUT_INVALID_TIP);
                continue;
            }
            if (Integer.parseInt(inputStr) > 70) {
                System.out.println(ERROR_INPUT_INVALID_TIP);
                continue;
            }
            return Integer.valueOf(inputStr);
        }
    }

    /**
     * 输入评分
     *
     * @param in 键盘输入
     * @return
     */
    public static Double inputScore(Scanner in) {
        while (true) {
            System.out.print(APP_MENU_SCORE_TIP);
            String inputStr = in.nextLine().strip();
            //  空输入
            if (inputStr.isBlank()) {
                System.out.println(ERROR_INPUT_IS_BLANK_TIP);
                continue;
            }
            if (APP_EXIT_WORD.equalsIgnoreCase(inputStr)) {
                return null;
            }
            if (!inputStr.matches(SCORE_REGEX)) {
                System.out.println(ERROR_INPUT_INVALID_TIP);
                continue;
            }
            if (Double.parseDouble(inputStr) > 5) {
                System.out.println(ERROR_INPUT_INVALID_TIP);
                continue;
            }
            return Double.valueOf(inputStr);
        }
    }

    /**
     * 增加师傅
     *
     * @param in 键盘输入
     */
    public static void addWorker(Scanner in) {
        if (Worker33.count >= WORKER_SIZE) {
            System.out.println(OVER_MAX_SIZE_TIP);
            return;
        }

        String inputtedName = inputName(in);
        if (inputtedName == null) {
            return;
        }

        String inputtedJobType = inputJobType(in);
        if (inputtedJobType == null) {
            return;
        }

        Integer inputtedWorkYear = inputWorkYear(in);
        if (inputtedWorkYear == null) {
            return;
        }

        Double inputedScore = inputScore(in);
        if (inputedScore == null) {
            return;
        }

        workers[Worker33.count] = new Worker33(inputtedName, inputtedJobType, inputtedWorkYear, inputedScore);
        System.out.println("【当前共有：" + Worker33.count + " 位师傅】");
    }

    /**
     * 获取菜单编号
     *
     * @param menuSelected 键盘输入
     * @return 返回-1（exit-退出），返回-2（空输入），返回-3（无效输入），正常返回
     */
    public static int getMenuItemNumber(String menuSelected) {
        String numStr = menuSelected.strip();
        if (numStr.isBlank()) {
            return SENTINEL_IS_BLANK;
        }
        if (APP_EXIT_WORD.equalsIgnoreCase(numStr)) {
            return SENTINEL_EXIT;
        }
        if (!numStr.matches(MENU_ITEM_NUMBER_REGEX)) {
            return SENTINEL_IS_INVALID;
        }
        return Integer.parseInt(numStr);
    }
}

▼
/**
复制代码
 *
 * day29:定义Worker类（姓名/工种/工龄/评分），创建2个师傅对象并打印信息。
 * day30:给Worker加3种构造：无参/姓名+工种/全字段，分别创建对象验证；用this区分同名参数
 * day31：给Worker加static计数器count，每创建一个对象+1，打印当前平台注册师傅总数
 * day32：Worker字段全改private；setWorkYears里校验工龄不能<0（负数就置0或抛提示），setScore校验0-5分
 * day33：师傅管理小程序：Worker数组容量10，支持添加、按名字查找、打印全部（遍历调用toString前先自己拼信息）
 * day34：在Day5基础上加：按工种筛选、按评分排序、统计平均工龄，全部封装成方法
 * day35：默写Worker类（封装+构造器+计数器版）
 *
 */

class Worker33 {
    private String name;
    private String jobType;
    private int workYear;
    private double score;
    static int count = 0;

    public Worker33(){this(null,null,0,0.0);}
    public Worker33(String name, String jobType){
        this(name, jobType, 0, 0.0);
    }
    public Worker33(String name, String jobType, int workYear, double score){
        count++;
        this.setName(name);
        this.setJobType(jobType);
        this.setWorkYear(workYear);
        this.setScore(score);
    }

    public void setName(String name){
        this.name = name;
    }
    public void setJobType(String jobType){
        this.jobType = jobType;
    }
    public void setWorkYear(int workYear){
        if (workYear < 0){
            System.out.println("工龄不能小于0，已置0");
            this.workYear = 0;
        }else{
            this.workYear = workYear;
        }
    }
    public void setScore(double score){
        if (!(score >= 0 && score <=5)){
            System.out.println("评分不能小于0或大于5，已置0");
            this.score = 0;
        }else{
            this.score = score;
        }
    }

    public String getName(){
        return this.name;
    }
    public String getJobType(){
        return this.jobType;
    }
    public int getWorkYear(){
        return this.workYear;
    }
    public double getScore(){
        return this.score;
    }

    @Override
    public String toString(){
        return ("姓名：" + this.getName() + "，工种：" + this.getJobType() + "，工龄：" + this.getWorkYear() + "，评分：" + this.getScore());
    }
}