【Java反射机制】_Class类的使用笔记

【Java反射机制】_Class类的使用笔记

本章目标：
可以使用Class类完成对象的实例化操作
可以通过Constructor类调用有参构造方法完成对象的实例化操作

具体内容：
Class主要是反射的源头，不光可以取得对象所在类的信息，也可以直接通过Class类的方法进行对象的实例化操作正常情况下，使用关键字new 为对象实例化，如果现在已经实例化好了Class对象，则就可以通过Class类中提供的

public T new Instance()throws InstantiationException,IllegalAccessException
实例化对象

package org.lxh.demo15.instancedemo;
class Person{
    private String name;
    private int age;
    public void setName(String name){
        this.name = name;    
    }
    public void setAge(int age){
        this.age = age;
    }
    public String getName(){
        return this.name;
    }
    public int getAge(){
        return this.age;
    }
    public String toString(){
        return "姓名："+this.name+",年龄："+this.age;
    }
}
public class InstanceDemo01{
    public static void main(String[] args){
        Class<?> c = null;    //声明Class对象
        try{
            c = Class.forName("org.lxh.demo15.instancedemo.Person");
        }catch(ClassNotFoundException e){
            e.printStackTrace();
        }
        Person per = null;    //声明Person对象
        try{
            per = (Person)c.newInstance();
        }catch(Exception e){
            e.printStackTrace();
        }
        per.setName("李兴华");        //设置姓名
        per.setAge(30);            //设置年龄
        System.out.println(per);    //内容输出，调用toString
    }
}

通过以上的代码，可以发现，即使不使用关键字new对象也可以进行实例化操作，反射的作用。
但是，在使用以上操作的时候有一点必须注意，在操作中类中必须存在无参构造方法。否则无法实例化。

package org.lxh.demo15.instancedemo;
class Person{
    private String name;
    private int age;
    public Person(String name,int age){
        this.setName(name);
        this.setAge(age);
    }
    public void setName(String name){
        this.name = name;
    }
    public void setAge(int age){
        this.age = age;
    }
    public String getName(){
        return this.name;
    }
    public int getAge(){
        return this.age;
    }
    public String toString(){
        return "姓名:"+this.name+",年龄："+this.age;
    }
};
public class InstanceDemo02{
    public static void main(String args[]){
        Class<?> c = null;
        try{
            c = Class.forName("org.lxh.demo15.instancedemo.Person");
        }catch(ClassNotFoundException e){
            e.printStackTrace();        
        }
        Person per = null;    //声明person对象
        try{
            per = (Person)c.newInstance();    //实例化对象
        }catch(Exception e){
            e.printStackTrace();
        }
        per.setName("牛儿吃草");    //设置姓名
        per.setAge(30);            //设置年龄
        System.out.println(per);    //内容输出，调用toString
    }
}

出现以下错误：
java.lang.InstantiationException:org.lxh.demo15.instancedemo.Person

所以说，发现，使用以上的方式实际上还是需要类中构造方法的支持，符合于对象的实例化要求。
如果要想解决这样的的问题，则必须明确的指定要调用的构造方法，半传递参数。但是从实际的开发角度来讲，一般使用反射实例化对象的时候，类中都最好存在一个无参构造，这样的操作比较合理。
如果要想调用有参，则必须按照以下的步骤进行：


操作的注意：被实例化对象的类中必须存在无参构造方法，如果不存在的话，则肯定是无法实例化的。
对于以上的程序也并非没有解决的方法，也是可以通过其他的方式进行实例化操作的，只是在操作的时候需要明确的调用类中的构造方法，并将参数传递进去之后才可以进行实例化操作，操作步骤如下：

1、通过Class类中的getConstructors()取得本类的全部构造方法。
2、向构造方法中传递一个对象数组进去，里面包含了构造方法中所需的各个参数。
3、之后通过Constructor实例化对象。

在Constructor类中存在一个方法：

public T newInstance(Object... initargs)
         throws instantiationException,
            IllegalAccessException,
            IllegalArgumentException,
            InvocationTargetException
传递初始化参数，以进行对象的实例化操作。




明确调用有参构造，实例化对象：

package org.lxh.demo15.instancedemo;
import java.lang.reflect.Constructor;
class Person{
    private String name;
    private int age;
    public Person(String name,int age){
        this.setName(name);
        this.setAge(age);        
    }
    public void setName(String name){
        this.name = name;
    }
    public void setAge(int age){
        this.age = age;
    }
    public String getName(){
        return this.name;
    }
    public int getAge(){
        return this.age;
    }
    public String toString(){
        return "姓名："+this.name+",年龄:"+this.age;
    }
}
public class InstanceDemo03{
    public static void main(String args[]){
        Class<?> c = null;
        try{
            c = Class.forName("org.lxh.demo15.instancedemo.Person");
        }catch(ClassNotFoundException e){
            e.printStackTrace();
        }
        Person per = null;    //声明Person对象
        Constructor<?> cons[] = null;
        cons = c.getConstructors();
        try{
            per = (Person) cons[0].newInstance("李兴华",30);    //实例化对象
        }catch(Exception e){
            e.printStackTrace();
        }
        System.out.println(per);    //内容输出，调用toString()
    }
}

但是，从实际角度看，如果要使用反射进行对象的实例化操作，最好在类中存在无参构造。

总结：
1、本章的功能是Class用的最多的功能，而且在开发中用户也会经常使用到的开发模式
2、在使用Class 实例化对象，必须保证类中存在一个无参构造，否则无法使用。
3、如果要想调用有参构造进行对象的实例化操作，则必须使用Constructor类完成，此类表示构造方法，并通过可变参数传递要求的内容。