那位给点思路!

Question

现有一个List,里边有1-8条数据，最大8条，最小1条，现在有个实体类，其中有
setN1,setN2,.....setN8,8个方法
我需要把List中的数据取出来,set到这个实体中,当list有一条数据的时候只需要setN1，依次类推,也就是动态控制set的个数。
现在我是通过获取list的大小来控制set的个数,也就是写8个if判断，我觉得这样写不灵活，所以肯请各位给点思路。

Answer 1

一定要用8个set方法？
用了的话，难免要if或者switch啊

Answer 2

写一个抽象类，里面有8个set方法，再分别写8个实现，分别有1-8个set方法。根据list.size()判断应用那个实现类好像就可以吧。
也就是说class Father是个抽象类，有8个不同的setN方法
再写8个子类Child1 - Child8分别实现其中的一个到8个setN方法
根据list.size()的值，判断应用那个child的类就能保证用了相应个数的setN方法了

Answer 3

完全赞成goziung() 的意见，如果你想实现你的思想，又比较灵活的话，我想这种方法是很不错的，把JAVA的特点都体现出来了。

Answer 4

goziung()的意见虽然体现了OO的思想,不过还是逃不掉SWITCH的烦恼。
要取出SWITCH我看只好请出反射了，将setN方法的调用参数化。

Answer 5

楼主所提的问题，是一个很有代表性的问题．下面是我编的代码，有不对的地方，多多指教啊
package qujianfeng;import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
//楼主所说的实体类
public class TheObject {
//八个属性
private String n1;
private String n2;
private String n3;
private String n4;
private String n5;
private String n6;
private String n7;
private String n8;
public String getN1() {
return n1;
}
/**
 * 注意：这是楼主要的关键所在
 */
public void setValues(List list) throws SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException{
Class clazz=this.getClass();
Method method=clazz.getMethod("setN7",new Class[]{java.lang.String.class});
for(int i=0;i<list.size();i++){
method=clazz.getMethod("setN"+(i+1),new Class[]{java.lang.String.class});
//调方法，把list中的值放入对象
method.invoke(this, new Object[]{list.get(i)});
}
}
public void setN1(String n1) {
this.n1 = n1;
}
public String getN2() {
return n2;
}
public void setN2(String n2) {
this.n2 = n2;
}
public String getN3() {
return n3;
}
public void setN3(String n3) {
this.n3 = n3;
}
public String getN4() {
return n4;
}
public void setN4(String n4) {
this.n4 = n4;
}
public String getN5() {
return n5;
}
public void setN5(String n5) {
this.n5 = n5;
}
public String getN6() {
return n6;
}
public void setN6(String n6) {
this.n6 = n6;
}
public String getN7() {
return n7;
}
public void setN7(String n7) {
this.n7 = n7;
}
public String getN8() {
return n8;
}
public void setN8(String n8) {
this.n8 = n8;
}
public String toString() {
StringBuffer sb=new StringBuffer();
sb.append("N1="+getN1());
sb.append(";N2="+getN2());
sb.append(";N3="+getN3());
sb.append(";N4="+getN4());
sb.append(";N5="+getN5());
sb.append(";N6="+getN6());
sb.append(";N7="+getN7());
sb.append(";N8="+getN8());
return sb.toString();
}
//来，大家测试一下效果
public static void main(String[] args) throws SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException {
List list=new ArrayList();
list.add("n1_value");
list.add("n2_value");
list.add("n3_value");
list.add("n4_value");
list.add("n5_value");
list.add("n6_value");
list.add("n7_value");
list.add("n8_value");
TheObject theObject=new TheObject();
theObject.setValues(list);
System.out.println(theObject.toString());
}
}

Answer 6

如果实际中的setN1,setN2。方法真如LZ所说的那样定义的set方法的话，并且只有这几个方法，完全可以采用Java反射机制来实现

Answer 7

我感觉只要你写一个setN(int n)方法里面的参数,然后调用int i=list.size()，将i的大小传到函数setN()方法中，就可以解决了。
这是我的思路。

Answer 8

你的这个List中是不同的对象,所以你要用set1,set2.....set8的方法是么?这样的话最好把List的对象封装成抽象或者接口类,8个不同的对象都继承这个类,这样取的时候只要一个set方法即可,取出来的统一都是父类,具体的子类实例可以通过instance of判断出来的interface Base {
    
} ;class N1 implements Base{
};class N2 implements Base{
};.......
public   Set(List lsObj)
{
    for(int i=0,len=lsObj.size();i<len;i++)
    {
         Base base = (Base)lsObj.get(i);
         if(base instance of N1)
         {
          }
         else if(base instance of N2)        
         {
          }
         ........
     }
}

Answer 9

第一个反射小程序，写得不好请大家指教！
================
package reflect;import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;public class ReflectTest {    private String name = null;
    private Long salary = null;
    
    public static String[] methodsByOrder = {"setName", "setSalary"};
    /**
     * @param args
     */
    public static void main(String[] args) throws Exception{
        List list = new ArrayList();
        list.add("malligator");
        list.add(new Long(88888));    
        
        ReflectTest rt = new ReflectTest();
        Class[] argClass = {Object.class};
        for (int i = 0; i < methodsByOrder.length; i++) {
            if(i >= list.size())
                break;
            
            String methodName = methodsByOrder[i];
            Method runMethod = ReflectTest.class.getDeclaredMethod(methodName,argClass); 
            
            rt.callMethod(runMethod, list.get(i));
        }
        
        // display me
        rt.display();
    }
    
    public void callMethod(Method runMethod, Object obj)  throws Exception {
        Object[] args = new Object[]{obj};
        
        runMethod.invoke(this, args);
    }
    
    public ReflectTest( ) {
        
    }
    
    public void display(){
        System.out.println("This is " + this.getClass().getSimpleName()
                + "\n and my field:name = " + name + ", salary = " + salary);
    
    }
    
    public void setName(Object name){
        if(name instanceof String)
            this.name = (String) name;
        // for test
        System.out.println("int method->setName" );
    }
    
    public void setSalary(Object salary){
        if(salary instanceof Long)
            this.salary = (Long) salary;
        // for test
        System.out.println("int method->setSalary" );
    }    public String getName() {
        return name;
    }    public Long getSalary() {
        return salary;
    }}