面向接口编程：newInstance() 和 new 的区别

通过反射机制加载类驱动和创建类实现：

 

 

配置文件内容<文件名：properties.properties>：

person=entity.PersonInstanceTest

接口：

package iInterface;

public interface IPerson {
 public void setAge(int age);
 public void setName(String name);
 public void setAddress(String address);
 public int getAge();
 public String getName();
 public String getAddress();
 public String sayHello(String name);
 public String sayGoodBye(String name);
}

接口实现类：

package entity;

import iInterface.IPerson;

public class PersonInstanceTest implements IPerson{
 private int age;
 private String name;
 private String address;
 public PersonInstanceTest() {
  System.out.println("--对象被实例化啦！--");
 }
 
 public PersonInstanceTest(int age,String name,String address){
  this.age = age;
  this.name = name;
  this.address = address;
 }
 @Override
 public int getAge() {
  return 0;
 }

 @Override
 public String getName() {
  return null;
 }

 @Override
 public String getAddress() {
  return null;
 }

 @Override
 public String sayHello(String name) {
  // TODO Auto-generated method stub
  return null;
 }

 @Override
 public String sayGoodBye(String name) {
  return null;
 }

 public void setAge(int age) {
  this.age = age;
 }

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

 public void setAddress(String address) {
  this.address = address;
 }

 @Override
 public String toString() {
  return "age: " + age + "  name: " + name + " address: " + address;
 }
}

创建类实现工具类：

package reflect;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.util.Properties;
/***
 * 面向接口编程：
 * newInstance() 和 new 有什么区别？
 * 1、区别在于创建对象的方式不一样，前者是使用类加载机制
 * 2、从jvm的角度看，我们使用new的时候，这个要new的类可以没有加载；
 * 3、使用newInstance时候，就必须保证：
 *     1、这个类已经加载；
 *     2、这个类已经连接了。
 *  而完成上面两个步骤的正是class的静态方法forName（）方法，这个静态方法调用了启动类加载器（就是加载javaAPI的那个加载器）。
 *  即：newInstance实际上是把new这个方式分解为两步,即，首先调用class的加载方法加载某个类，然后实例化
 * 
 *  [补充:]
 * newInstance: 弱类型。低效率。只能调用无参构造。
 * new: 强类型。相对高效。能调用任何public构造。
 * newInstance()是实现IOC、反射、面对接口编程 和 依赖倒置 等技术方法的必然选择，new 只能实现具体类的实例化，不适合于接口编程。
 * @author huawei
 *
 */
public class ClassReflect {
 private static Properties props;
 //采用静态语句块：类加载便会执行
 static{
  props = new Properties();
  try {
   String path = "src" + File.separator + "file" + File.separator + "properties.properties";
   props.load(new FileInputStream(path));
  } catch (FileNotFoundException e) {
   e.printStackTrace();
  } catch (IOException e) {
   e.printStackTrace();
  }
 }
 //调用类无参构造器
 public static Object createInstance(Object className)
    throws ClassNotFoundException, InstantiationException,
     IllegalAccessException, IllegalArgumentException,
     SecurityException, InvocationTargetException,
     NoSuchMethodException{
  String object = (String) props.get(className);
  Class cls = Class.forName(object);
  return cls.getConstructor().newInstance();
 }
 //调用有参构造器
 public static Object createInstance(Object className,Class[] parameterTypes,Object[] initargs) throws Exception{
  String object = (String) props.get(className);
  Class cls =  Class.forName(object);
  return cls.getConstructor(parameterTypes).newInstance(initargs);
 }
}

调用不同参数构造器测试类：

package reflect;

import org.junit.Test;

import iInterface.IPerson;
/***
 * 创建类的实例测试类：--实现面向接口编程思想
 * 1、调用无参构造器
 * 2、调用有参构造器
 * @author huawei
 *
 */
public class ClassInstanceTest {
 //调用无参构造器
 //@Test
 public void test1(){
  try {
   IPerson person = (IPerson) ClassReflect.createInstance("person");
   person.setName("beyond0851");
   person.setAge(100);
   person.setAddress("hello");
   System.out.println(person.toString());
  } catch (ClassNotFoundException e) {
   e.printStackTrace();
  } catch (Exception e) {
   e.printStackTrace();
  }
 }
 //根据参数类型不同,调用有参构造器
 @Test
 public void test2(){
  try {
   IPerson person = (IPerson) ClassReflect.createInstance("person",
        new Class[]{int.class,String.class,String.class},
         new Object[]{90,"beyond0851","love记记"});
   System.out.println(person.toString());
  } catch (ClassNotFoundException e) {
   e.printStackTrace();
  } catch (Exception e) {
   e.printStackTrace();
  }
 }
}