那位给点思路!
现有一个List,里边有1-8条数据，最大8条，最小1条，现在有个实体类，其中有
setN1,setN2,.....setN8,8个方法
我需要把List中的数据取出来,set到这个实体中,当list有一条数据的时候只需要setN1，依次类推,也就是动态控制set的个数。
现在我是通过获取list的大小来控制set的个数,也就是写8个if判断，我觉得这样写不灵活，所以肯请各位给点思路。
[解决办法]
一定要用8个set方法？
用了的话，难免要if或者switch啊
[解决办法]
长度为list.size()
[解决办法]
写一个抽象类，里面有8个set方法，再分别写8个实现，分别有1-8个set方法。根据list.size()判断应用那个实现类好像就可以吧。
也就是说class Father是个抽象类，有8个不同的setN方法
再写8个子类Child1 - Child8分别实现其中的一个到8个setN方法
根据list.size()的值，判断应用那个child的类就能保证用了相应个数的setN方法了
[解决办法]
楼上的方法好
符合ＯＯ思想
[解决办法]
楼主所提的问题，是一个很有代表性的问题．下面是我编的代码，有不对的地方，多多指教啊
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());
}
}
[解决办法]
如果实际中的setN1,setN2。。。。方法真如LZ所说的那样定义的set方法的话，并且只有这几个方法，完全可以采用Java反射机制来实现
[解决办法]
我感觉只要你写一个setN(int n)方法里面的参数,然后调用int i=list.size()，将i的大小传到函数setN()方法中，就可以解决了。
这是我的思路。
[解决办法]
你的这个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)
{
}
........
}
}
[解决办法]
第一个反射小程序，写得不好请大家指教！
================
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;
}
}
