传统属性赋值弊端
简单Java类主要是由属性所组成，并且提供有相应的setter，getter处理方法，同时简单Java类最大的特征就是对象保存相应的类属性内容。但是如果使用传统的简单Java类开发，那么也会面临非常麻烦的困难
特别强调，为了方便理解，本次Emp类之中定义的ename,job两个属性的类型使用的都是String类型。按照传统的做法此时应该首先实例化Emp类的对象，而后通过实例化对象进行setter方法的调用以设置属性内容
范例：传统调用
class Emp{
private String ename;
private String job;
public void setEname(String ename){
this.ename = ename;
}
public void setJob(String job){
this.job = job;
}
public String getEname(){
return this.ename;
}
public String getJob(){
return this.job;
}
}
public class JavaAPIDemo28 {
public static void main(String args[])throws Exception{
Emp emp = new Emp(); // 更多情况下开发者关注的是内容的设置
emp.setEname("SMITH");
emp.setJob("CLERK");
// 使用为对象设置之后
System.out.println("姓名："+emp.getEname()+"\t职位"+emp.getJob());
}
}
在这个进行Emp对象实例化并设置数据的操作过程之中，设置数据的部分是最麻烦的，你可以想象一下，如果说现在Emp类里面提供有50个属性，那么对于整个程序而言将出现一堆的setter方法调用。或者再进一步说明，在实际的开发之中，简单Java类的个数是非常多的，那么如果所有的简单Java类都牵扯到属性赋值的时候，这种情况下代码编写的重复性将会非常的高。
按照传统的直观的编程方式，所带来的问题就是代码会存在有大量的重复操作，如果要想解决对象的重复处理操作，那么唯一的解决方案就是反射机制，反射机制最大的特征就是可以根据其自身的特点（Object类直接操作，可以直接操作属性或方法）实现相同功能类的重复操作的抽象处理
属性自动赋值实现思路
经过了分析之后已经确认了当前简单Java类操作的问题所在，而对于开发者而言就需要想办法通过一种解决方案来实现属性内容的自动设置，那么这个时候的设置强烈建议采用字符串的形式来描述对应的类型
1.在进行程序开发的时候String字符串可以描述的内容有很多，并且也可以由开发者自行定义String类型的字符串的结构，下面就采用"属性:内容|属性:内容|"的形式来为简单Java类中的属性初始化
class Emp{
private String ename;
private String job;
public void setEname(String ename){
this.ename = ename;
}
public void setJob(String job){
this.job = job;
}
public String getEname(){
return this.ename;
}
public String getJob(){
return this.job;
}
}
public class JavaAPIDemo{
public static void main(String args[])throws Exception{
String value = "ename:Smith|job:Clerk";
}
}
2.类设计的基本结构：应该由一个专门的ClassInstanceFactory类负责所有的反射处理，即：接收反射对象与要设置的属性内容同时可以获取指定类的实例化对象
3.设计的基本结构
public class Emp02 {
private String ename;
private String job;
public void setEname(String ename){
this.ename = ename;
}
public void setJob(String job){
this.job = job;
}
public String getEname(){
return this.ename;
}
public String getJob(){
return this.job;
}
}
public class ClassInstanceFactory {
private ClassInstanceFactory(){
}
public static <T> T creat(Class<?> clazz,String value){
return null;
}
}
public class JavaAPIDemo30 {
public static void main(String[] args) {
String value = "ename:小黑子|job:Teacher";
Emp02 emp02 = ClassInstanceFactory.creat(Emp02.class,value);
System.out.println("姓名："+emp02.getEname()+'\t'+"职位:"+ emp02.getJob());
}
}
那么在当前的开发之中，所需要留给用户完善的就是ClassInstanceFactory.create()处理方法
单极属性赋值
对于此时的Emp类里面会发现所给出大的数据类型都没有其他引用关联了，只是描述了Emp本类的对象，所以这样的设置称为单级设置处理，所以此时应该处理两件事情：
‒ 需要通过反射进行指定类对象的实例化处理
‒ 进行内容的设置（Field属性类型，方法名称，要设置的内容）
class Emp02 {
private String ename;
private String job;
public void setEname(String ename) {
this.ename = ename;
}
public void setJob(String job) {
this.job = job;
}
public String getEname() {
return this.ename;
}
public String getJob() {
return this.job;
}
}
class ClassInstanceFactory {
private ClassInstanceFactory() {
}
/**
* 实例化对象的创建方法，该对象可以根据传入的字符串结构"属性:内容|属性:内容"
*
* @param clazz 要进行反射实例化的Class对象，由Class就可以反射实例化对象
* @param value 要设置给对象的属性内容
* @return 一个已经配置好属性内容的Java类对象
*/
public static <T> T create(Class<?> clazz, String value) {
// 如果要想采用反射进行简单Java类对象属性设置的时候，类中必须要有无参构造
try {
Object obj = clazz.getDeclaredConstructor().newInstance();
return (T) obj; // 返回对象
} catch (Exception e) {
e.printStackTrace(); // 如果此时真的出现错误，本质上抛出异常也没用
return null;
}
}
}
public class JavaAPIDemo30 {
public static void main(String args[]) throws Exception {
String value = "ename:Smith|job:Clerk";
Emp emp = ClassInstanceFactory.create(Emp.class, value);
System.out.println("姓名：" + emp.getEname() + "\t职位" + emp.getJob());
}
}
设置多种数据类型
1.定义StringUtils实现首字母大写功能
class Emp03 {
private String ename;
private String job;
public void setEname(String ename) {
this.ename = ename;
}
public void setJob(String job) {
this.job = job;
}
public String getEname() {
return this.ename;
}
public String getJob() {
return this.job;
}
}
class StringUtils{
private StringUtils(){}
public static String Initcap(String str){
if(str == null||"".equals(str)){
retrun str;
}
if(str.length() == 1){
return str.toUpperCase();
}
return str.subString(0,1).toUpperCase() + str.subString(1);
}
}
class ClassInstanceFactory {
private ClassInstanceFactory() {
}
/**
* 实例化对象的创建方法，该对象可以根据传入的字符串结构"属性:内容|属性:内容"
*
* @param clazz 要进行反射实例化的Class对象，由Class就可以反射实例化对象
* @param value 要设置给对象的属性内容
* @return 一个已经配置好属性内容的Java类对象
*/
public static <T> T create(Class<?> clazz, String value) {
// 如果要想采用反射进行简单Java类对象属性设置的时候，类中必须要有无参构造
try {
Object obj = clazz.getDeclaredConstructor().newInstance();
return (T) obj; // 返回对象
} catch (Exception e) {
e.printStackTrace(); // 如果此时真的出现错误，本质上抛出异常也没用
return null;
}
}
}
public class JavaAPIDemo31 {
public static void main(String args[]) throws Exception {
String value = "ename:Smith|job:Clerk";
Emp emp = ClassInstanceFactory.create(Emp.class, value);
System.out.println("姓名：" + emp.getEname() + "\t职位" + emp.getJob());
}
}
2.定义BeanUtils工具类，该工具类主要实现属性的设置
import java.lang.reflect.Field;
import java.lang.reflect.Method;
class Emp04 {
private String ename;
private String job;
public void setEname(String ename) {
this.ename = ename;
}
public void setJob(String job) {
this.job = job;
}
public String getEname() {
return this.ename;
}
public String getJob() {
return this.job;
}
}
class ClassInstanceFactory03 {
private ClassInstanceFactory03() {
}
/**
* 实例化对象的创建方法，该对象可以根据传入的字符串结构"属性:内容|属性:内容"
*
* @param clazz 要进行反射实例化的Class对象，由Class就可以反射实例化对象
* @param value 要设置给对象的属性内容
* @return 一个已经配置好属性内容的Java类对象
*/
public static <T> T create(Class<?> clazz, String value) {
// 如果要想采用反射进行简单Java类对象属性设置的时候，类中必须要有无参构造
try {
Object obj = clazz.getDeclaredConstructor().newInstance();
BeanUtils.setValue(obj,value); // 通过反射设置属性
return (T) obj; // 返回对象
} catch (Exception e) {
e.printStackTrace(); // 如果此时真的出现错误，本质上抛出异常也没用
return null;
}
}
}
class StringUtils{
private StringUtils(){}
public static String Initcap(String str){
if(str == null||"".equals(str)){
return str;
}
if(str.length() == 1){
return str.toUpperCase();
}
return str.substring(0,1).toUpperCase() + str.substring(1);
}
}
class BeanUtils{ // 进行Bean处理的类
private BeanUtils(){}
/**
*实现指定对象的属性设置
*@param obj 要进行反射操作的实例化对象
*@param value 包含有指定内容的字符串，格式"属性:内容|属性:内容|"
*/
public static void setValue(Object obj,String value){
String results[] = value.split("\\|"); // 按照"|"进行每一组属性的拆分
for(int x = 0; x<results.length;x++){ // 循环设置属性内容
// attval[0]保存的是属性名称，attval[1]保存的是内容
String attval [] = results[x].split(":"); // 获取属性名称与内容
// 注意：如果不用try catch环绕，直接在方法上抛出会报错，而环绕了即使属性名称错误也不会报错，而是直接返回null
try{
Field feild = obj.getClass().getDeclaredField(attval[0]);// 获取成员
Method setMethod = obj.getClass().getDeclaredMethod("set"+StringUtils.Initcap(attval[0]),feild.getType());
setMethod.invoke(obj,attval[1]); // 调用setter方法设置内容
}catch(Exception e){
}
}
}
}
public class JavaAPIDemo32 {
public static void main(String args[]) throws Exception {
String value = "ename:Smith|job:Clerk";
Emp04 emp = ClassInstanceFactory03.create(Emp.class, value);
System.out.println("姓名：" + emp.getEname() + "\t职位" + emp.getJob());
}
}
3.ClassInstanceFactory负责实例化对象并且调用BeanUtils类实现属性内容的设置
即使现在类中的属性再多，那么也可以轻松的实现setter的调用（类对象实例化处理）
这是基础实现形式
级联对象实例化
如果说现在给定的类对象之中存在有其他引用的级联关系的情况下，称为多级设置。例如：一个雇员属于一个部门，一个部门属于一个公司，所以这个时候对于简单Java类的基本关系定义如下：
Company.java
Dept.java
Emp.java
如果要通过Emp进行操作，则应该使用"."作为级联关系的处理
dept.dname:财务部：Emp类的实例化对象.getDept().setDame(“财务部”);
dept.company.name:MLDN：Emp类实例化对象.getDept().getCompany().setName(“MLDN”)
但是考虑到代码的简洁性，所以应该考虑通过级联的配置自动实现类中属性的实例化
String value = “empno:7369|ename:Smith|job:Clerk|salary:750.00|hiredate:1989-10-10|”+“dept.dname:财务部|dept.company.name:MLDN”;
现在的属性存在有多级的关系，那么多级的关系就必须与单级的配置区分开。
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
class Company06{
private String name;
private String loc;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getLoc() {
return loc;
}
public void setLoc(String loc) {
this.loc = loc;
}
}
class Dept06{
private String dname;
private String loc;
private Company06 company;
public String getDname() {
return dname;
}
public void setDname(String dname) {
this.dname = dname;
}
public String getLoc() {
return loc;
}
public void setLoc(String loc) {
this.loc = loc;
}
public Company06 getCompany() {
return company;
}
public void setCompany(Company06 company) {
this.company = company;
}
}
class Emp06 {
private long empno;
private String ename;
private String job;
private double salary;
private Date hiredate;
private Dept06 dept;
public void setDept06(Dept06 dept) {
this.dept = dept;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
public Date getHiredate() {
return hiredate;
}
public void setHiredate(Date hiredate) {
this.hiredate = hiredate;
}
public void setEname(String ename) {
this.ename = ename;
}
public void setJob(String job) {
this.job = job;
}
public String getEname() {
return this.ename;
}
public String getJob() {
return this.job;
}
public Dept06 getDept() {
return dept;
}
public void setDept(Dept06 dept) {
this.dept = dept;
}
public long getEmpno() {
return empno;
}
public void setEmpno(long empno) {
this.empno = empno;
}
}
class ClassInstanceFactory06 {
private ClassInstanceFactory06() {
}
/**
* 实例化对象的创建方法，该对象可以根据传入的字符串结构"属性:内容|属性:内容"
*
* @param clazz 要进行反射实例化的Class对象，由Class就可以反射实例化对象
* @param value 要设置给对象的属性内容
* @return 一个已经配置好属性内容的Java类对象
*/
public static <T> T create(Class<?> clazz, String value) {
// 如果要想采用反射进行简单Java类对象属性设置的时候，类中必须要有无参构造
try {
Object obj = clazz.getDeclaredConstructor().newInstance();
BeanUtils06.setValue(obj,value); // 通过反射设置属性
return (T) obj; // 返回对象
} catch (Exception e) {
e.printStackTrace(); // 如果此时真的出现错误，本质上抛出异常也没用
return null;
}
}
}
class StringUtils06{
private StringUtils06(){}
public static String Initcap(String str){
if(str == null||"".equals(str)){
return str;
}
if(str.length() == 1){
return str.toUpperCase();
}
return str.substring(0,1).toUpperCase() + str.substring(1);
}
}
class BeanUtils06{ // 进行Bean处理的类
private BeanUtils06(){}
/**
*实现指定对象的属性设置
*@param obj 要进行反射操作的实例化对象
*@param value 包含有指定内容的字符串，格式"属性:内容|属性:内容|"
*/
public static void setValue(Object obj,String value){
String results[] = value.split("\\|"); // 按照"|"进行每一组属性的拆分
for(int x = 0; x<results.length;x++){ // 循环设置属性内容
// attval[0]保存的是属性名称，attval[1]保存的是内容
String attval [] = results[x].split(":"); // 获取属性名称与内容
try{
if(attval[0].contains(".")){ // 多级配置
String temp[] = attval[0].split("\\.");
Object currentObject = obj;
// 最后一位肯定是指定类中的属性名称，所以不在本次实例化处理的范畴之内
for(int y =0;y<temp.length -1;y++){ // 实例化
// 调用相应的getter方法，如果getter方法返回了null表示该对象未实例化
Method getMethod = currentObject.getClass().getDeclaredMethod("get"+StringUtils06.Initcap(temp[y]));
Object tempObject =getMethod.invoke(currentObject);
if(tempObject == null){ // 该对象现在并没有实例化
Field field = currentObject.getClass().getDeclaredField(temp[y]); // 获取属性类型
Method method = currentObject.getClass().getDeclaredMethod("set"+StringUtils06.Initcap(temp[y]),field.getType());
Object newObject = field.getType().getDeclaredConstructor().newInstance();
method.invoke(currentObject,newObject);
currentObject = newObject;
}else{
currentObject = tempObject;
}
}
}else{
Field feild = obj.getClass().getDeclaredField(attval[0]);// 获取成员
Method setMethod = obj.getClass().getDeclaredMethod("set"+StringUtils06.Initcap(attval[0]),feild.getType());
Object convertValue = BeanUtils06.convertAttributeValue(feild.getType().getName(),attval[1]);
setMethod.invoke(obj,convertValue); // 调用setter方法设置内容
}
}catch(Exception e){
}
}
}
/**
*实现属性类型转换处理
*@param type 属性类型，通过Field获取的
*@param value 属性的内容，传入的都是字符串，需要将其变为指定类型
*@return 转换后的数据
*/
private static Object convertAttributeValue(String type,String value){
if("long".equals(type)||"java.lang.Long".equals(type)){ // 长整型
return Long.parseLong(value);
}else if("int".equals(type)||"java.lang.int".equals(type)){
return Integer.parseInt(value);
}else if("double".equals(type)||"java.lang.double".equals(type)){
return Double.parseDouble(value);
}else if("java.util.Date".equals(type)){
SimpleDateFormat sdf = null;
if(value.matches("\\d{4}-\\d{2}-\\d{2}")){ // 日期类型
sdf = new SimpleDateFormat("yyyy-MM-dd");
}else if(value.matches("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}")){
sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
}else{
return new Date(); // 当前日期
}
try{
return sdf.parse(value);
}catch(ParseException e){
return new Date(); // 当前日期
}
}else{
return value;
}
}
}
public class JavaAPIDemo34 {
public static void main(String args[]) throws Exception {
String value = "empno:7369|ename:Smith|job:Clerk|salary:750.00|hiredate:1989-10-10|"+"dept.dname:财务部|dept.company.name:MLDN";
Emp06 emp = ClassInstanceFactory06.create(Emp06.class, value);
System.out.println("雇员编号"+emp.getEmpno()+"\t姓名：" + emp.getEname() + "\t职位" + emp.getJob() + "\t基本工资" +emp.getSalary()+"\t雇佣日期"+emp.getHiredate());
System.out.println(emp.getDept());
System.out.println(emp.getDept().getCompany());
}
}
级联属性赋值
现在已经成功的实现了级联的对象实例化处理，那么随后就需要去考虑级联的属性设置了，在之前考虑级联对象实例化处理的时候，循环的时候都是少了一位的
if(attval[0].contains(".")){ // 多级配置
String temp[] = attval[0].split("\\.");
Object currentObject = obj;
// 最后一位肯定是指定类中的属性名称，所以不在本次实例化处理的范畴之内
for(int y =0;y<temp.length -1;y++){ // 实例化
// 调用相应的getter方法，如果getter方法返回了null表示该对象未实例化
Method getMethod = currentObject.getClass().getDeclaredMethod("get"+StringUtils.Initcap(temp[y]));
Object tempObject =getMethod.invoke(currentObject);
if(tempObject == null){ // 该对象现在并没有实例化
Field field = currentObject.getClass().getDeclaredField(temp[y]); // 获取属性类型
Method method = currentObject.getClass().getDeclaredMethod("set"+StringUtils.Initcap(temp[y]),field.getType());
Object newObject = field.getType().getDeclaredConstructor().newInstance();
method.invoke(currentObject,newObject);
currentObject = newObject;
}else{
currentObject = tempObject;
}
}
}
当此时代码循环处理完成之后，currentObject表示的就是可以进行setter方法调用的对象了，并且理论上该对象一定不可能为null，随后就可以按照之前的方式利用对象进行setter方法调用
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
class Company{
private String name;
private String loc;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getLoc() {
return loc;
}
public void setLoc(String loc) {
this.loc = loc;
}
}
class Dept{
private String dname;
private String loc;
private Company company;
public String getDname() {
return dname;
}
public void setDname(String dname) {
this.dname = dname;
}
public String getLoc() {
return loc;
}
public void setLoc(String loc) {
this.loc = loc;
}
public Company getCompany() {
return company;
}
public void setCompany(Company company) {
this.company = company;
}
}
class Emp05 {
private long empno;
private String ename;
private String job;
private double salary;
private Date hiredate;
private Dept dept;
public void setEmp05no(long empno) {
this.empno = empno;
}
public Dept getDept() {
return dept;
}
public void setDept(Dept dept) {
this.dept = dept;
}
public long getEmp05no() {
return empno;
}
public void setEmp05no(Long empno) {
this.empno = empno;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
public Date getHiredate() {
return hiredate;
}
public void setHiredate(Date hiredate) {
this.hiredate = hiredate;
}
public void setEname(String ename) {
this.ename = ename;
}
public void setJob(String job) {
this.job = job;
}
public String getEname() {
return this.ename;
}
public String getJob() {
return this.job;
}
}
class ClassInstanceFactory05 {
private ClassInstanceFactory05() {
}
/**
* 实例化对象的创建方法，该对象可以根据传入的字符串结构"属性:内容|属性:内容"
*
* @param clazz 要进行反射实例化的Class对象，由Class就可以反射实例化对象
* @param value 要设置给对象的属性内容
* @return 一个已经配置好属性内容的Java类对象
*/
public static <T> T create(Class<?> clazz, String value) {
// 如果要想采用反射进行简单Java类对象属性设置的时候，类中必须要有无参构造
try {
Object obj = clazz.getDeclaredConstructor().newInstance();
BeanUtils05.setValue(obj,value); // 通过反射设置属性
return (T) obj; // 返回对象
} catch (Exception e) {
e.printStackTrace(); // 如果此时真的出现错误，本质上抛出异常也没用
return null;
}
}
}
class StringUtils05{
private StringUtils05(){}
public static String Initcap(String str){
if(str == null||"".equals(str)){
return str;
}
if(str.length() == 1){
return str.toUpperCase();
}
return str.substring(0,1).toUpperCase() + str.substring(1);
}
}
class BeanUtils05{ // 进行Bean处理的类
private BeanUtils05(){}
/**
*实现指定对象的属性设置
*@param obj 要进行反射操作的实例化对象
*@param value 包含有指定内容的字符串，格式"属性:内容|属性:内容|"
*/
public static void setValue(Object obj,String value){
String results[] = value.split("\\|"); // 按照"|"进行每一组属性的拆分
for(int x = 0; x<results.length;x++){ // 循环设置属性内容
// attval[0]保存的是属性名称，attval[1]保存的是内容
String attval [] = results[x].split(":"); // 获取属性名称与内容
try{
if(attval[0].contains(".")){ // 多级配置
String temp[] = attval[0].split("\\.");
Object currentObject = obj;
// 最后一位肯定是指定类中的属性名称，所以不在本次实例化处理的范畴之内
for(int y =0;y<temp.length -1;y++){ // 实例化
// 调用相应的getter方法，如果getter方法返回了null表示该对象未实例化
Method getMethod = currentObject.getClass().getDeclaredMethod("get"+StringUtils05.Initcap(temp[y]));
Object tempObject =getMethod.invoke(currentObject);
if(tempObject == null){ // 该对象现在并没有实例化
Field field = currentObject.getClass().getDeclaredField(temp[y]); // 获取属性类型
Method method = currentObject.getClass().getDeclaredMethod("set"+StringUtils05.Initcap(temp[y]),field.getType());
Object newObject = field.getType().getDeclaredConstructor().newInstance();
method.invoke(currentObject,newObject);
currentObject = newObject;
}else{
currentObject = tempObject;
}
}
System.out.println(Arrays.toString(temp));
// 进行属性内容的设置
Field feild = currentObject.getClass().getDeclaredField(temp[temp.length-1]);// 获取成员
Method setMethod = currentObject.getClass().getDeclaredMethod("set"+StringUtils05.Initcap(temp[temp.length-1]),feild.getType());
Object convertValue = BeanUtils05.convertAttributeValue(feild.getType().getName(),attval[1]);
setMethod.invoke(currentObject,convertValue); // 调用setter方法设置内容
}else{
Field feild = obj.getClass().getDeclaredField(attval[0]);// 获取成员
Method setMethod = obj.getClass().getDeclaredMethod("set"+StringUtils05.Initcap(attval[0]),feild.getType());
Object convertValue = BeanUtils05.convertAttributeValue(feild.getType().getName(),attval[1]);
setMethod.invoke(obj,convertValue); // 调用setter方法设置内容
}
}catch(Exception e){
}
}
}
/**
*实现属性类型转换处理
*@param type 属性类型，通过Field获取的
*@param value 属性的内容，传入的都是字符串，需要将其变为指定类型
*@return 转换后的数据
*/
private static Object convertAttributeValue(String type,String value){
if("long".equals(type)||"java.lang.Long".equals(type)){ // 长整型
return Long.parseLong(value);
}else if("int".equals(type)||"java.lang.int".equals(type)){
return Integer.parseInt(value);
}else if("double".equals(type)||"java.lang.double".equals(type)){
return Double.parseDouble(value);
}else if("java.util.Date".equals(type)){
SimpleDateFormat sdf = null;
if(value.matches("\\d{4}-\\d{2}-\\d{2}")){ // 日期类型
sdf = new SimpleDateFormat("yyyy-MM-dd");
}else if(value.matches("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}")){
sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
}else{
return new Date(); // 当前日期
}
try{
return sdf.parse(value);
}catch(ParseException e){
return new Date(); // 当前日期
}
}else{
return value;
}
}
}
public class JavaAPIDemo33 {
public static void main(String args[]) throws Exception {
String value = "empno:7369|ename:Smith|job:Clerk|salary:750.00|hiredate:1989-10-10|"+"dept.dname:财务部|dept.company.name:MLDN";
Emp05 emp = ClassInstanceFactory05.create(Emp05.class, value);
System.out.println("雇员编号"+emp.getEmp05no()+"\t姓名：" + emp.getEname() + "\t职位" + emp.getJob() + "\t基本工资" +emp.getSalary()+"\t雇佣日期"+emp.getHiredate());
System.out.println(emp.getDept().getDname());
System.out.println(emp.getDept().getCompany().getName());
}
}
在以后的开发之中简单Java类的赋值处理将不再重复调用setter操作完成，而这种处理形式是在正规开发中普遍采用的方式
学习资料
阿里云开发者社区
扫一扫
1509
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
