使用java反射机制编写Student类并保存

定义Student类

package org;

public class Student {
    private String _name = null;
    private int _age = -1;
    private int _score = -1;
    
    public Student()
    {
        
    }
    
    public Student(String name, int age, int score)
    {
        _name = name;
        _age = age;
        _score = score;
    }
    
    public void setName(String name)
    {
        _name = name;
    }
    
    public String getName()
    {
        return _name;
    }
    
    public void setAge(int age)
    {
        _age = age;    
    }
    
    public int getAge()
    {
        return _age;
    }
    
    public void setScore(int score)
    {
        _score = score;
    }
    
    public int getScore()
    {
        return _score;
    }
    
    public void set(Student stu)
    {
        setName(stu._name);
        setAge(stu._age);
        setScore(stu._score);
    }
    
    public String toString()
    {
        return "Name: " + _name + ", age: " + _age + ", score: " + _score; 
    }
}

保存Student类的信息  SaveStudents类

package org;
import java.io.FileOutputStream;
import java.io.OutputStream;

public class SaveStudents {
    private String _file_name = null;
    
    public SaveStudents(String file_name)
    {
        _file_name = file_name;
    }
    
    public boolean save(Student stu) throws Exception
    {
        OutputStream os = new FileOutputStream(_file_name, true);
        boolean flag = false;        //    是否保存成功的标志
        
        if (null != stu.getName()) {
            os.write(stu.toString().getBytes());
            os.close();
            flag = true;
        }
        
        return flag;
    }
}

代理调用类InvokeProxy

package org;
import java.lang.reflect.Method;

public class InvokeProxy {
    public static String init_metName(String met_name)
    {
        return met_name.substring(0, 1).toUpperCase() + met_name.substring(1);
    }
    
    public static void setter(Object obj, String met_name, Object value, Class<?> type)
    {
        try {
            Method met = obj.getClass().getMethod("set" + init_metName(met_name), type);
            met.invoke(obj, value);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    /*
    public static Object getter(Object obj, String met_name)
    {
        Object result = null;
        
        try {
            Method met = obj.getClass().getMethod("get" + init_metName(met_name));
            result = met.invoke(obj);
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        return result;
    }
    */
}

package org;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

public class tmp {
    public static void main(String[] args)
    {
        Class<?> c0 = null;
        Class<?> c1 = null;
        String obj_name = "org.Student";
        String save_name = "org.SaveStudents";
        String file_name = "F:\Code\java\text\test15.txt";
        
        try {
            c0 = Class.forName(obj_name);
            c1 = Class.forName(save_name);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        
        String name = null;
        int age = -1;
        int score = -1;
        
        //    Inputs
        {
            BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
            OutputStream os = System.out;
            
            try {
                os.write("Input name: ".getBytes());
                name = buf.readLine();
                
                os.write("Input age: ".getBytes());
                age = Integer.parseInt(buf.readLine());
                
                os.write("Input score: ".getBytes());
                score = Integer.parseInt(buf.readLine());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        
        //    instance Student
        Student stu = null;
        try {
            stu = (Student)c0.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        //    set
        {
            InvokeProxy.setter(stu, "name", name, String.class);
            InvokeProxy.setter(stu, "age", age, int.class);
            InvokeProxy.setter(stu, "score", score, int.class);
        }
        
        //    instance SaveStudents and invoke save() method
        SaveStudents ss = null;
        Constructor<?> con1 = null;
        try {
            con1 = c1.getConstructor(String.class);
            ss = (SaveStudents)con1.newInstance(file_name);
            Method met = ss.getClass().getMethod("save", Student.class);
            met.invoke(ss, stu);
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}