如果动态创建对象，并为对象设置指定的值?

Posted

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了如果动态创建对象，并为对象设置指定的值?相关的知识，希望对你有一定的参考价值。

jsp前台传入键值对形式的值，分别为其属性和值，格式为JSONArray，每次处理的时候，都需要生成相应的vo对象，并解析传入的String类型的JSONArray,代码量比较大，并且每次都基本用一样的代码。看起来不舒服。请问有什么好的方式动态创建对象，并且把指定的值设置进去。

1.我调用的接口可能为：public Object createObj(Class class,String keyAndValue);谢谢！

2.谢绝抄袭网上代码，我希望能够有demo，或者实现此功能。

3.程序可运行。

4.追高分
-----------vo-------------------
public class CacheNumber
private int capacity;
private int count;

public int getCount()
return count;


public void setCount(int count)
this.count = count;


//默认构造器
public CacheNumber()


public CacheNumber(int capacity,int count)
this.capacity = capacity;
this.count = count;


public int getCapacity()
return capacity;


public void setCapacity(int capacity)
this.capacity = capacity;


public static void main(String[] args)



----------------------------------------------
当我调用createObj(CacheNumber.class,"capacity=1,count=2");
的时候，我就能自动产生一个对象，用于Hibernate保存到数据库。并且CacheNumber 这个对象的capacity=1,count=2..

一楼的猪头！

你可以利用java反射机制就可以处理.如果我有空就帮你写写看.
我简单写了一下

package action;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Test

/**
* @param args
*/

//这是测试主方法
public static void main(String[] args)
Test test = new Test();

CacheNumber ch = (CacheNumber) test.createObj(CacheNumber.class,
"capacity=1,count=2,name=wang,montey=21.3");

System.out.println(ch.getCapacity());
System.out.println(ch.getName());
System.out.println(ch.getCount());


public Object createObj(Class cl, String keyAndValue)
Object te = null;
try
Class cla = Class.forName(cl.getName());

te = cla.newInstance();

String[] valueAndName = keyAndValue.split(",");

for (int i = 0; i < valueAndName.length; i++)

Field[] field = cla.getDeclaredFields();

for (int k = 0; k < field.length; k++)

Class[] paraTypes = new Class[] field[k].getType() ;

String name = valueAndName[i].substring(0, valueAndName[i]
.indexOf("="));
String value = valueAndName[i].substring(valueAndName[i]
.indexOf("=") + 1, valueAndName[i].length());
if (field[k].getName().equals(name))

String fieldSetter = "set"
+ name.substring(0, 1).toUpperCase()
+ name.substring(1, name.length());
Method method = cla.getMethod(fieldSetter, paraTypes);

Object[] values = null;

if (field[i].getType()==int.class)
values = new Integer[] Integer.valueOf(value) ;

if (field[i].getType()==String.class)

values = new String[] value ;

if (field[i].getType()==double.class)
values = new Double[] Double.valueOf(value) ;

if(field[i].getType()==short.class)
values = new Short[]Short.valueOf(value);

if(field[i].getType()==long.class)
values = new Long[]Long.valueOf(value);

method.invoke(te, values);







catch (ClassNotFoundException e)
e.printStackTrace();
catch (SecurityException e)
e.printStackTrace();
catch (NoSuchMethodException e)
e.printStackTrace();
catch (IllegalArgumentException e)
e.printStackTrace();
catch (IllegalAccessException e)
e.printStackTrace();
catch (InvocationTargetException e)
e.printStackTrace();
catch (InstantiationException e)
e.printStackTrace();

return te;



//这是你的CacheNumber我又加了几个类型的属性
package action;

public class CacheNumber
private int capacity;

private int count;

private String name;

private double montey;

public double getMontey()
return montey;


public void setMontey(double montey)
this.montey = montey;


public String getName()
return name;


public void setName(String name)
this.name = name;


public int getCount()
return count;


public void setCount(int count)
this.count = count;


// 默认构造器
public CacheNumber()


public CacheNumber(int capacity, int count)
this.capacity = capacity;
this.count = count;


public int getCapacity()
return capacity;


public void setCapacity(int capacity)
this.capacity = capacity;


public static void main(String[] args)



写的很简单,你看哪块不合适再改一改吧,思路就是这么个思路. 参考技术A 写了一个，既然是用于hibernate保存，那对象应该提供标准的set和get方法，并提供默认public的构造方法：

-------------Reflect.java------------------------
//package com.color.encoding;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Reflect

/**
*
* @param c
* @param fieldsAndValuelike"a=??,b=??,c=??"
* @author color4you
* @return
*/
public Object createObj(Class c, String fieldsAndValue)
Object obj = null;
Constructor con = null;
String t[] = null;
String[] values = null;
String[] keys = null;
Class[] clazz = null;

if(fieldsAndValue != null)
t = fieldsAndValue.split(",");

else
t = new String[];

values = new String[t.length];
keys =new String[t.length];
clazz= new Class[t.length];

for (int i = 0; i < t.length; i++)
String[] keyAndValue = t[i].split("=");
keys[i] = keyAndValue[0];
values[i] = keyAndValue[1];
clazz[i] = this.getFieldType(c, keys[i]);


try
// 先查询是否有按参数输入类型的构造器
con = c.getConstructor(clazz);
Object[] o = new Object[t.length];
for (int i = 0; i < keys.length; i++)
o[i] = this.getPropertyByClass(clazz[i], values[i]);

try
obj = con.newInstance(o);
return obj;
catch (Exception e)
// 如果没有,查询默认构造器
// 此构造器是必须存在的，其访问级别为public
// 并且所有属性提供标准，get和set方法
try
con = c.getConstructor();
obj = con.newInstance();
catch (Exception e2)
e2.printStackTrace();

for (int i = 0; i < t.length; i++)
try
String[] keyAndValue = t[i].split("=");

Method m = c.getMethod(this
.getSetMethodByField(keyAndValue[0]),
new Class[] this.getFieldType(c,
keyAndValue[0]) );

m.invoke(obj, new Object[] this.getPropertyByClass(
this.getFieldType(c, keyAndValue[0]),
keyAndValue[1]) );
catch (NoSuchMethodException ex)
System.out.println("未查寻到有此set方法:"
+ t[i].substring(0, t[i].indexOf("=")));
catch (Exception e1)
e.printStackTrace();


return obj;

catch (Exception e)
System.out.println("------没有找到相应的构造器------");
e.printStackTrace();
finally
System.out.println("---------执行完毕----------");

return obj;


/**
* 根据类型，返回此类型的值
*
* @param c
* @param value
* @return
* @throws ParseException
*/
public Object getPropertyByClass(Class c, String value)
if (c.equals(int.class))
return Integer.parseInt(value);
else if (c.equals(Long.class))
return Long.parseLong(value);
else if (c.equals(short.class))
return (short) Integer.parseInt(value);
else if (c.equals(char.class))
return (char) Integer.parseInt(value);
else if (c.equals(double.class) || c.equals(Double.class))
return Double.parseDouble(value);
else if (c.equals(Date.class))
DateFormat f = new SimpleDateFormat("yyyy-MM-dd");
try
return f.parse(value);
catch (ParseException e)
System.out.println("解析时间类型出错:" + value);
e.printStackTrace();


return null;


/**
* 根据字段得到其数据类型
*
* @param c
* @param field
* @return
* @throws Exception
* @throws Exception
*/
public Class getFieldType(Class c, String field)
Field f = null;
try
f = c.getDeclaredField(field);
catch (SecurityException e)
System.exit(-1);
e.printStackTrace();
catch (NoSuchFieldException e)
System.out.println("字段不存在：" + field);
System.exit(-1);
e.printStackTrace();

return f.getType();


/**
* 根据字段查询其set方法
*
* @param field
* @return
*/
public String getSetMethodByField(String field)
return "set" + field.substring(0, 1).toUpperCase() + field.substring(1);


public static void main(String[] args) throws Exception, Exception

Class clazz = CacheNumber.class;
Reflect r = new Reflect();
Object o = r.createObj(clazz, "capacity=2,count=3");

if (o instanceof CacheNumber)
CacheNumber c = (CacheNumber) o;
System.out.println(c.getCapacity());
System.out.println(c.getCount());


Class clazz2 = Demo.class;
Object o2 = r.createObj(clazz2,null);

if(o2 instanceof Demo)
Demo ops = (Demo)o2;
ops.main(new String[]);





----------测试类---------------
//package com.color.encoding;

public class CacheNumber
private int capacity;
private int count;

public int getCount()
return count;


public void setCount(int count)
this.count = count;


//默认构造器
public CacheNumber()
System.out.println("----call default constructor:"+this.getClass().getName());


// 程序先会调用这个构造器，如果不存在，
// 再调用默认构造器,所以默认构造器必须存在。
public CacheNumber(int capacity,int count)
System.out.println("---call appointed constructor:"+this.getClass().getName());
this.capacity = capacity;
this.count = count;


public int getCapacity()
return capacity;


public void setCapacity(int capacity,int count)
this.capacity = capacity;
this.count = count;


public static void main(String[] args)



--------------测试类-----------------

//package com.color.encoding;
public class Demo
public Demo()
System.out.println("---call default method:"+this.getClass().getName());

public static void main(String[] args)
System.out.println("---hello,call demo main method!---");


 参考技术B 恩，用反射机制可以做到，下午写给你个小例子吧。
很简单的，不过你的输入参数最好改一下。 参考技术C 我只看明白了一点，不知道它说的什么意思1 参考技术D 没太明白你的意思

d 对象的动态建立和释放

new 运算符动态分配堆内存

声使用形式：指针变量 = new 类型()；

指针变量 = new 类型 []；

从堆分配一块"类型"大小的存储空间，返回首地址

其中：1.常量，是初始化值，可缺省

2.创建数组对象时，不能为对象指定初始值

3.如果由于内存不足等原因而无法正常分配空间，则new会返回一个空指针NULL，用户可以根据该指针的值 判断分配空间是否成功。

? ?

? ?

? ?

delete 运算符释放已分配的内存空间

使用形式： delete 指针变量

delete[] 指针变量

其中：指针变量必须是一个 new 返回的指针

? ?

? ?

  1. int?? * p1 = new int;
  2. char??* p2 = new char;
  3. float * p3 = new float;
  4. int?? * p4 = new int[4];

    ? ?

    ? ?

  5. delete p1;
  6. delete p2;
  7. delete p3;
  8. delete[] p4;

? ?

? ?

? ?

? ?

? ?

? ?

? ?

? ?

? ?

new int; //开辟一个存放整数的存储空间，返回一个指向该存储空间的地址(即指针)

new int(100); //开辟一个存放整数的空间，并指定该整数的初值为100，返回一个指向该存储空间的地址

new char[10]; //开辟一个存放字符数组(包括10个元素)的空间，返回首元素的地址

new int[5][4]; //开辟一个存放二维整型数组(大小为5*4)的空间，返回首元素的地址

float *p=new float (3.14159); //开辟一个存放单精度数的空间，并指定该实数的初值为//3.14159，将返回的该空间的地址赋给指针变量p

? ?

? ?

? ?

使用类名定义的对象都是静态的，在程序运行过程中，对象所占的空间是不能随时释放的。但有时人们希望在需要用到对象时才建立对象，

在不需要用该对象时就撤销它，释放它所占的内存空间以供别的数据使用。这样可提高内存空间的利用率。

? ?

C++中，可以用new运算符动态建立对象，用delete运算符撤销对象

比如：

Box *pt; ?//定义一个指向Box类对象的指针变量pt

? ? pt=new Box; ?//在pt中存放了新建对象的起始地址

在程序中就可以通过pt访问这个新建的对象。如

? ? cout<<pt->height; ?//输出该对象的height成员

? ? cout<<pt->volume( ); ?//调用该对象的volume函数，计算并输出体积

C++还允许在执行new时，对新建立的对象进行初始化。如

? ? Box *pt=new Box(12,15,18);

这种写法是把上面两个语句(定义指针变量和用new建立新对象)合并为一个语句，并指定初值。这样更精炼。

新对象中的height，width和length分别获得初值12,15,18。调用对象既可以通过对象名，也可以通过指针。

在执行new运算时，如果内存量不足，无法开辟所需的内存空间，目前大多数C++编译系统都使new返回一个0指针值。只要检测返回值是否为0，就可判断分配内存是否成功。

ANSI C++标准提出，在执行new出现故障时，就"抛出"一个"异常"，用户可根据异常进行有关处理。但C++标准仍然允许在出现new故障时返回0指针值。当前，不同的编译系统对new故障的处理方法是不同的。

在不再需要使用由new建立的对象时，可以用delete运算符予以释放。如

delete pt; //释放pt指向的内存空间

这就撤销了pt指向的对象。此后程序不能再使用该对象。

如果用一个指针变量pt先后指向不同的动态对象，应注意指针变量的当前指向，以免删错了对象。在执行delete运算符时，在释放内存空间之前，自动调用析构函数，完成有关善后清理工作。

? ?

? ?

? ?

  1. #include <iostream>

    #include <cstring>

    #include <cstdio>

    #include <cstdlib>
  2. using namespace std;
  3. // 1

    //??????malloc??free????????????????c    语言的函数

    //??????new???? delete??????????????    操作符??c++的语法
  4. //2???? new 基础类型变量??分配数组变量??分配类对象
  5. //3
  6. ////分配基础类型

    void main01()
  7. {
  8. ????//c语言分配内存
    ??int *p = (int *)malloc(sizeof(int));
  9. ????*p = 10;
  10. ????free(p);

    ? ?

  11. ????//c++语言分配内存
    ??int *p2 = new int; //    分配基础类型
    ??*p2 = 20;
  12. ????free(p2);
  13. ????
  14. ????int *p3 = new int(30);
  15. ????printf("*p3:%d \\n", *p3);//30
  16. ????delete p3;

    ? ?

  17. ????cout<<"hello..."<<endl;
  18. ????system("pause");
  19. ????return ;
  20. }

    ? ?

    ? ?

  21. //分配数组变量
    int main02()
  22. {
  23. ????//c语言分配数组

    ????int *p = (int *)malloc(sizeof(int) * 10);??//int array[10];
    ????p[0] = 1;
  24. ???? free(p);
  25. ????//c++分配数组

    ??int *pArray = new int[10] ;
  26. ????pArray[1] = 2;
  27. ????delete [] pArray; //数组不要把[] 忘记

    ? ?

  28. ????char *pArray2 = new char[25] ; //char buf[25]
    ??delete [] pArray2;
  29. ????
  30. ????cout<<"hello..."<<endl;
  31. ????system("pause");
  32. ????return 0;
  33. }

    ? ?

    ? ?

  34. class Test
  35. {
  36. public:
  37. ????Test(int _a)
  38. ????{
  39. ????????a = _a;
  40. ????????cout<<"构造函数执行" <<endl;
  41. ????}
  42. ????~Test()
  43. ????{
  44. ????????cout<<"析构函数执行" <<endl;
  45. ????}
  46. protected:
  47. private:
  48. ????int a;
  49. };
  50. //分配对象new delete

    //    相同 和 不同的地方 new能执行类型构造函数?? delete操作符 能执行类的析构函数

    int main03(void)
  51. {??
  52. ????//c

    ??Test *pT1 = (Test *)malloc(sizeof(Test));
  53. ????free(pT1);

    ? ?

  54. ????//c++
    ??Test *pT2 = new Test(10);
  55. ????delete pT2;

    ? ?

  56. ????cout<<"hello..."<<endl;
  57. ????return 0;
  58. }

? ?

? ?

? ?

? ?

? ?

? ?

? ?

? ?

? ?

? ?

? ?

? ?

? ?

? ?

? ?

? ?

技术分享

? ?

new与malloc 和 delete与free在申请基础类型/数组时，可以通用

但在创建对象的时候，却不行，因为创建对象涉及构造函数的初始化和析构函数，

这个功能只有new和delete可以完成，是C++的专属特性

以上是关于如果动态创建对象，并为对象设置指定的值?的主要内容，如果未能解决你的问题，请参考以下文章