一、Java反射技术

Java反射的最大好处是可以通过配置生成对象，解除程序的耦合度，程序显得灵活易用。不过缺点是程序运行比较慢，但很多情况下为了灵活度，还是会使用反射，springIOC容器就是一大应用。

下面为反射生成无构造方法参数的类对象

//反射实现类
public class ReflectServiceImpl {
    public void sayHello(String name){
        System.out.println("Hello" + name + "by Reflect");
    }
}

 //反射生成对象
    public ReflectServiceImpl getInstance(){
        ReflectServiceImpl reflectService = null;
        try{
            //给类加载器注册一个ReflectServiceImpl全限定名，再newInstance()初始化一个类对象
            reflectService = (ReflectServiceImpl) Class.forName("ReflectServiceImpl").newInstance();
        }catch(ClassNotFoundException | InstantiationException | IllegalAccessException ex){
            ex.printStackTrace();
        }
        return reflectService;
    }

但如果类的构造方法带有参数,即

//反射实现类
public class ReflectServiceImpl {
    private String name;
    public ReflectServiceImpl(String name){
        this.name = name;
    }
}

则改变一下上面反射生成对象的一行代码即可，通过getConstructor()方法

 //给类加载器注册一个ReflectServiceImpl全限定名，再newInstance()初始化一个类对象
 reflectService = (ReflectServiceImpl) Class.forName("ReflectServiceImpl").getConstructor(String.class).newInstance("小江");

反射方法，下面以一个实例来演示

//反射实现类
public class ReflectServiceImpl {
    public void sayHello(String name){
        System.out.println("Hello " + name +" by Reflect");
    }
}

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

public class Main {
    public static void main(String[] args) {
        ReflectServiceImpl object = null;
        try{
            object = (ReflectServiceImpl) Class.forName("ReflectServiceImpl").newInstance();
            Method method = object.getClass().getMethod("sayHello", String.class);
            method.invoke(object,"小江");
        }catch(ClassNotFoundException | IllegalAccessException | NoSuchMethodException
                | InstantiationException | InvocationTargetException ex){
            ex.printStackTrace();
        }
        return;
    }
}

二、观察者模式（Observer）

观察者定义了一种一对多的依赖关系，让多个观察者对象同时监视着被观察者的状态，当被观察者状态发生变化时，会通知所有观察者，并让其自动更新自己。

如下实例，演示观察者模式

//实现观察者接口——京东接口
public class JingDongObserver implements Observer {
    @Override
    public void update(java.util.Observable o, Object product) {
        String newProduct = (String) product;
        System.out.println("发送新产品【"+newProduct+"】同步到京东商城");
    }
}
//实现观察者接口——淘宝接口
public class TaoBaoObserver implements Observer {
    @Override
    public void update(Observable o, Object product) {
        String newProduct = (String) product;
        System.out.println("发送新产品【"+newProduct+"】同步到淘宝商城");
    }
}

下面是一个被观察者类，当观察者发生了变化则告知观察者，如果没有则无法触发setChanged方法

//被观察者类
public class ProductList extends Observable {
    private List<String> productList = null; //定义产品列表
    private static ProductList instance;  //类唯一实例

    private ProductList(){     //构造方法私有化，单例模式的应用，避免直接通过new方式创建对象

    }
    //返回产品列表唯一实例
    public static ProductList getInstance(){
        if(instance == null){
            instance = new ProductList();
            instance.productList = new ArrayList<String>();
        }
        return instance;
    }
    //增加观察者（电商接口）
    public void addProductListObserver(Observer observer){
        this.addObserver(observer);
    }
    //新增产品
    public void addProudct(String newProduct){
        productList.add(newProduct);
        System.out.println("产品列表新增了产品：" + newProduct);
        this.setChanged();   //设置被观察者发生变化的状态
        this.notifyObservers(newProduct);  //通知观察者，并传递新产品
    }
}

最后用一个main方法来测试调用它

public class Main {
    public static void main(String[] args) {
        ProductList observable = ProductList.getInstance();
        JingDongObserver jingDongObserver = new JingDongObserver();
        TaoBaoObserver taoBaoObserver = new TaoBaoObserver();
        //对被观察者注册观察者
        observable.addProductListObserver(jingDongObserver);
        observable.addProductListObserver(taoBaoObserver);
        observable.addProudct("小米手环");
    }
}

运行结果截图：