憨憨呆呆的IT之旅

if (obj typeof SubClass1) {
    // do a
} else if (obj typeof SubClass2) {
    // do b
}

protected void processOption() {
    System.out.println("\n\n\t\t在线考试系统");
    System.out.println("---------------------------------");
    System.out.println("\t[1] 学员登录\t\t[2] 管理员登录");
    System.out.println("\t[0] 退出系统");
    System.out.print("请选择操作：");
    int choice = scanner.nextInt();
    System.out.println("您的选择是: " + choice);
    // 后续处理
    System.out.println("后续处理逻辑。。。");
}

protected void processOption() {
    while(true) {
        System.out.print("请选择操作：");
        int choice = scanner.nextInt();
        System.out.println("您的选择是: " + choice);
        if (choice >=0 && choice <=2) {
           // 输入的选项合法，跳出循环
           break;
        }
    }
    // 后续处理
    System.out.println("后续处理逻辑。。。");
}

protected void processOption() {
    while(true) {
        try {
            System.out.print("请选择操作：");
            int choice = scanner.nextInt();
            System.out.println("您的选择是: " + choice);
            if (choice >=0 && choice <=2) {
                // 输入的选项合法，跳出循环
                break;
            }
        } catch (InputMismatchException e) {
            System.out.println("输入错误！请输入数字选项。");
        }
    }
    // 后续处理
    System.out.println("后续处理逻辑。。。");
}

// java.util.Scanner.java 
    public int nextInt(int radix) {
        // Check cached result
        if ((typeCache != null) && (typeCache instanceof Integer)
            && this.radix == radix) {
            int val = ((Integer)typeCache).intValue();
            useTypeCache();
            return val;
        }
        setRadix(radix);
        clearCaches();
        // Search for next int
        try {
            String s = next(integerPattern());
            if (matcher.group(SIMPLE_GROUP_INDEX) == null)
                s = processIntegerToken(s);
            return Integer.parseInt(s, radix);
        } catch (NumberFormatException nfe) {
            position = matcher.start(); // don't skip bad token
            throw new InputMismatchException(nfe.getMessage());
        }
    }

protected void processOption() {
    while(true) {
        try {
            System.out.print("请选择操作：");
            int choice = scanner.nextInt();
            System.out.println("您的选择是: " + choice);
            if (choice >=0 && choice <=2) {
                // 输入的选项合法，跳出循环
                break;
            }
        } catch (InputMismatchException e) {
            System.out.println("输入错误！请输入数字选项。");
            scanner.next(); // 增加这一句，消费掉输入错误的字符串
        }
    }
    // 后续处理
    System.out.println("后续处理逻辑。。。");
}

protected void processOption() {
    while(true) {
        System.out.print("请选择操作：");
        String temp = scanner.next();
        int choice = -1;
        boolean match = temp.matches("[0-9]+");
        if (match) {
            int choice = Integer.parseInt(temp);
            System.out.println("您的选择是: " + choice);
            if (choice >=0 && choice <=2) {
                // 输入的选项合法，跳出循环
                break;
            } else {
                continue;
            }
        } else {
            System.out.println("输入错误！请输入数字选项。");
            continue;
        }
    }
    // 后续处理
    System.out.println("后续处理逻辑。。。");
}

public class User implements Serializable {
    private static final long serialVersionUID = 1105545465577482303L;
    private String name;
    private int age;
    private transient String phone; // transient 关键字表示该成员不参与序列化

    public User() {
    }

    public User(String name, int age, String phone) {
        this.name = name;
        this.age = age;
        this.phone = phone;
    }
    
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", phone='" + phone + '\'' +
                '}';
    }

public class SerializableTest {
    public static void main(String[] args) {
        // 1. 准备要序列化的数据
        User[] users = {
                new User("张三",33, "185000011133"),
                new User("李四",44, "185000011144"),
                new User("王五",55, "185000011155"),
                new User("赵六",66, "185000011166"),
        };
        ObjectOutputStream oos = null;
        ObjectInputStream ois = null;
        try {
            // 2. 准备输出流和输入流
            String fileName = "./out/oos_1.txt";
            oos = new ObjectOutputStream(new FileOutputStream(fileName));
            FileInputStream fis = new FileInputStream(fileName);
            ois = new ObjectInputStream(fis);
            // 3. 序列化到文件,并反序列化读取并输出
//            testSerialize1(users, oos, ois);
//            testSerialize2(users, oos, ois);
            testSerialize3(users, oos, ois);
//            testSerialize4(users, oos, ois, fis);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            // 4. 关闭流
            if (null != ois) {
                try {
                    ois.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != oos) {
                try {
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

/**
     * 方法1： 使用集合保存多个对象，对集合进行序列化反序列化
     * @param users
     * @param oos
     * @param ois
     */
    private static void testSerialize1(User[] users, ObjectOutputStream oos, ObjectInputStream ois) throws IOException, ClassNotFoundException {
        ArrayList<User> list1 = new ArrayList<>();
        for (User user : users) {
            list1.add(user);
        }
        oos.writeObject(list1);
        oos.flush();
        System.out.println("方法1写入完毕！");
        Object obj = ois.readObject();
        System.out.println("方法1读取数据为：" + obj);
        ArrayList<User> list2 = (ArrayList<User>)obj;
        for (User user: list2) {
            System.out.println(user);
        }
    }

/**
     * 方法2： 使用Object数组保存多个对象，对整个数组进行序列化反序列化
     * @param users
     * @param oos
     * @param ois
     */
    private static void testSerialize2(User[] users, ObjectOutputStream oos, ObjectInputStream ois) throws IOException, ClassNotFoundException {
        oos.writeObject(users);
        oos.flush();
        System.out.println("方法2写入完毕！");
        Object[] objs = (Object[])ois.readObject();
        System.out.println("方法2读取数据为：");
        for (Object obj: objs) {
            System.out.println(obj);
        }
    }

/**
     * 方法3： 依次写入多个对象,再追加一个null对象表示结束，读取时判断读到的对象是否为null
     * @param users
     * @param oos
     * @param ois
     */
    private static void testSerialize3(User[] users, ObjectOutputStream oos, ObjectInputStream ois) throws IOException, ClassNotFoundException {
        for (User user: users) {
            oos.writeObject(user);
        }
        oos.writeObject(null);
        oos.flush();
        System.out.println("方法3写入完毕！");

        System.out.println("方法3读取数据为：");
        Object obj = null;
        while ((obj = ois.readObject()) != null) {
            System.out.println(obj);
        }
    }

/**
     * 方法4： 依次写入多个对象，读取时使用fis.available()方法判断是否读取到末尾
     * @param users
     * @param oos
     * @param ois
     * @param fis
     */
    private static void testSerialize4(User[] users, ObjectOutputStream oos, ObjectInputStream ois, FileInputStream fis) throws IOException, ClassNotFoundException {
        for (User user: users) {
            oos.writeObject(user);
        }
        oos.flush();
        System.out.println("方法4写入完毕！");

        System.out.println("方法4读取数据为：");
        while (fis.available() > 0) {
            Object obj = ois.readObject();
            System.out.println(obj);
        }
    }