我们今天用流写一个小系统，我们将某个人的信息（姓名，年龄，成绩）通过前台获取数据，然后再中间层做处理（封装到这个人的对象里），最后再写入流中；然后我们要求可以对这个人的信息可以增删改查。
    首先分层，分成前台显示层，后台业务处理层，存储层。
    前台显示层主要的功能就是显示功能模块，但它并没有真正的功能处理能力，它只是一个显示给用户看的界面，可以获取用户提交过来的数据并将数据转交后台。
    而真正具有处理数据能力的是后台业务处理层，这是程序的核心，他可以把用户提交过来的数据加以处理，按照我们需要的功能去处理数据，最终得到我们想要的结果。
    最后我们要把处理好的数据存储到存储层，可以把它存储到流、文件或者网络中。当我们想要保存数据的时候，他就可以存储数据；当我们想要处理数据的时候，他就要把数据提取到后台由我们来处理。
    这就是业务分层，也就是我们以后写程序的核心思想，理解这个思想可以帮助我们更快更好的写程序，十分重要。

    我们做的这个系统是增删改查一个学生的信息，我们要在前台附加上一个功能界面。
下面附代码：

封装好的学生类：
public class Person implements Serializable{

    private String name;
    private int age;
    private float score;
    public Person(String name,int age,float score){
        this.name=name;
        this.age=age;
        this.score=score;
    }
    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 float getScore() {
        return score;
    }
    public void setScore(float score) {
        this.score = score;
    }
    
    public String toString(){
        return "姓名："+this.name+"，年龄："+this.age+"，成绩："+this.score;
    }
}

前台:
public class Menu {

    private InputData input = null;
    public Menu(){
        this.input = new InputData();
        while(true){
            this.show();    
        }
    }
    public void show(){
        System.out.println("\t\t\t1、增加人员信息:");
        System.out.println("\t\t\t2、删除人员信息:");
        System.out.println("\t\t\t3、修改人员信息:");
        System.out.println("\t\t\t4、浏览人员信息:");
        System.out.println("\t\t\t5、退出系统:");
        System.out.print("请输入选择：");
        
        int select = input.getInt();
        switch(select){
        case 1:{
            new FilePerson().add();
            break;
        }
        case 2:{
            new FilePerson().remove();
            break;
        }
        case 3:{
            new FilePerson().modify();
            break;
        }
        case 4:{
            new FilePerson().search();
            break;
        }
        case 5:{
            System.out.println("退出系统");
            System.exit(1);
        }
        default:{
            System.out.println("请输入数字(1-5):");
            break;
        }
        }
    }
}

看一下运行效果：


然后我们看看业务处理层：

输入数据处理层：
    他是将前台提交过来的数据进行处理，将输入的数据转化成想要的整型，浮点型或者字符型；若类型不匹配则要求用户继续输入。
public class InputData {

    private BufferedReader input = null;
    
    public InputData(){
        this.input = new BufferedReader(new InputStreamReader(System.in));
    }
    
    public String getString(){
        String str = null;
        try {
            str = input.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return str;
    }
    public int getInt(){
        int i = 0;
        String str =null;
        boolean b = true;
        
        while(b){
            str = this.getString();
            if(!(str.matches("\\d+"))){
                System.out.print("请输入整形数据:");
            }
            else{
                i = Integer.valueOf(str);
                b = false;
            }
        }
        return i;
    }
    public float getFloat(){
        float f = 0.0f;
        String str = null;
        boolean b = true;
        
        while(b){
            str = this.getString();
            if(!(str.matches("\\d+?.\\d{1}"))){
                System.out.print("请输入浮点型数据:(小数点后保留一位)");
            }
            else{
                f = Float.valueOf(str);
                b =false;
            }
        }
        return f;
    }
    
}

封装学生层：
    他是将输入正确的前台信息封装到学生对象里，然后可以对该对象进行操作（增删改查），也就是先从数据源提取数据或者存储数据，再进行处理的过程。
public class FilePerson {

    private InputData input = null;
    public FilePerson(){
        this.input = new InputData();
    }
    
    public void add(){
        String name = null;
        int age =0;
        float score = 0.0f;
        
        System.out.print("请输入姓名:");
        name = input.getString();
        System.out.print("请输入年龄:");
        age = input.getInt();
        System.out.print("请输入成绩:");
        score = input.getFloat();
        
        Person p = new Person(name,age,score);
        try {
            new FileObject().save(p);
            System.out.println("数据添加成功！");
        } catch (Exception e) {
            System.out.println("数据添加失败！");
        }
        
    }
    
    public void remove(){
        new FileObject().clear();
    }
    
    public void modify(){
        Person p = null;
        
        try {
            p = (Person)new FileObject().show();
        } catch (Exception e) {
            System.out.println("内容显示失败，请确定数据是否存在！");
        }
        
        if(p != null){
            String name = null;
            int age =0;
            float score = 0.0f;
            
            System.out.print("请输入姓名:(原姓名："+p.getName()+")");
            name = input.getString();
            System.out.print("请输入年龄:(原年龄："+p.getAge()+")");
            age = input.getInt();
            System.out.print("请输入成绩:(原成绩："+p.getScore()+")");
            score = input.getFloat();
            
            p = new Person(name,age,score);
            
            try {
                new FileObject().save(p);
                System.out.println("数据更新成功");
            } catch (Exception e) {
                System.out.println("数据更新失败");
            }
        }
    }
    
    public void search(){
        Person p = null;
        try {
            p = (Person)new FileObject().show();
        } catch (Exception e) {
            System.out.println("内容显示失败，请确定数据是否存在！");
        }
        if(p != null){
            System.out.println(p);
        }
    }
}


最后我们再看看存储层：
    他可以将封装好的数据进行存储，或者进行提取。
附代码：
public class FileObject {

    private static final String FILENAME = "E:\\person.txt";
    
    public void save(Object obj) throws IOException{
        
        ObjectOutputStream out = null;
        try {
            out = new ObjectOutputStream(new FileOutputStream(new File(FILENAME)));
        } catch (Exception e) {
            e.printStackTrace();
        }
        Person p = (Person)obj;
        out.writeObject(p);
        out.flush();
        out.close();
    }
    public Object show() throws FileNotFoundException, IOException, ClassNotFoundException{
        
        Object obj = null;
        ObjectInputStream read = null;
        read = new ObjectInputStream(new FileInputStream(new File(FILENAME)));
        obj = read.readObject();
        read.close();
        return obj;
    }
    
    public void clear(){
        ObjectOutputStream out = null;
        try {
            out = new ObjectOutputStream(new FileOutputStream(new File(FILENAME)));
        } catch (Exception e) {
            e.printStackTrace();
        }
        try {
            out.reset();
            out.flush();
            out.close();
            System.out.println("数据删除成功");
        } catch (IOException e) {
            System.out.println("数据删除失败");
        }
    }
}


我们看看运行结果：