java常用重点掌握设计模式

java常用重点设计模式

• 示例中代码的入口均为main方法，可以一步一步看。刚刚学习完，总结分享一下

1.1 java反射

​ 动态实现对象或方法创建，大大增加java可配置性、灵活性，但相比直接new 对象()，性能有所下降

1.2 使用反射创建对象

//使用反射创建实例
public class test(){
  //使用反射生成apple实例并调用say()
  public void getInstance(){
    apple app=null;
    try{
      /**
       *forName()-->按类的全限定名查找
       *getConstructor()-->构造函数行参类型
       *newInstance()-->实例化类并传入初始化参数
       */
      app=(apple)Class.forName("xxx.xxx.apple").getConstructor(String.class).newInstance("绿色");
      app.say();
    }catch(Exception ex){
      ex.printStackTrace();
    }
  } 
  //调用getInstance
  public static void main(String[] args) {
        getInstance();
    }
}

//包含构造函数的类
class apple{
  private String color;
  public apple(String color){
    this.color=color;
  }
  public void say(){
    System.out.println("我是一个"+color+"色的大苹果，我想站在你头上");
  }
}

1.3 反射方法

//使用反射创建实例并调用方法
public class test {
    public static void main(String[] args) {
        getInstance();
    }
		//使用反射生成apple实例并继续反射方法
    public static void getInstance(){
        try {
            /**
             *forName()-->按类的全限定名查找
             *getConstructor()-->构造函数行参类型
             *newInstance()-->实例化类并传入初始化参数
             */
            apple app=(apple) Class.forName("xxx.xxx.apple").getConstructor(String.class).newInstance("绿色");
            //getMeth("方法名","方法参数类型")
            Method method=app.getClass().getMethod("say", double.class);
          	//invoke("类对象",方法参数);
            method.invoke(app,0.5);
        }catch (Exception e){
            e.printStackTrace();
        }
    }

  
//包含构造函数的类
public class apple{
    private String color;
    public apple(String color){
        this.color=color;
    }
    public void say(double weight){
        System.out.println("我是一个"+weight+"kg的"+color+"色的大苹果，我想站在你头上");
    }
}

2.1 jdk动态代理模式、责任链模式

• 动态代理：生成一个代理对象，来代理真实对象，从而控制真实对象的访问

  {买二手车(调用者)——中间商(代理对象)——二手车主（真实对象}

• 例

  /**
   * jdk动态代理
   */
  //动态绑定和代理逻辑实现
  public class jdkproxy implements InvocationHandler {
  
      //真实对象
      private Object target=null;
  
      /**
       * 建立代理对象和真实对象的代理关系，并返回代理对象
       * @param target    真实对象
       * @return  代理对象
       */
      public Object bind(Object target){
          this.target=target;
        	/**
        	 *newProxyInstance3个参数含义：
        	 *1.被代理类
        	 *2.接口，表示将生成的动态代理对象给到哪个接口
        	 *3.this表示当前对象。
        	 */
          return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces()
                                        ,this);
      }
  
      /**
       * 代理方法逻辑
       * @param proxy 代理对象
       * @param method    当前调度方法
       * @param args  当前方法参数
       * @return  代理结果返回
       * @throws Throwable    异常
       *	此方法会在生成代理关系后自动执行
       */
      @Override
      public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
          System.out.println("进入代理逻辑方法");
          System.out.println("在调度真实对象之前的服务");
          Object obj=method.invoke(target,args);
          System.out.println("调度后");
          return obj;
      }
  		//调用建立代理关系方法
      public static void main(String[] args) {
          hello proxy=(hello) new jdkproxy().bind(new apple());
          proxy.say();
      }
  }
  
  class apple{
      public void say(){
          System.out.println("我是一个苹果，我想站在你头上");
      }
  }
  

• 责任链模式（实际就是多个嵌套拦截器）

//拦截器接口定义
public interface Inter {
  	//事前执行
    public boolean before(Object proxy, Object target, Method method,Object[] args);
  	//before返回false执行
    public void around(Object proxy, Object target, Method method,Object[] args);
  	//事后执行
    public void after(Object proxy, Object target, Method method,Object[] args);
}

//定义两个拦截器

//拦截器1
public class myinter implements Inter{
    @Override
    public boolean before(Object proxy, Object target, Method method, Object[] args) {
        //反射方法前逻辑
        System.out.println(1);
        return true;
    }

    @Override
    public void around(Object proxy, Object target, Method method, Object[] args) {
        System.out.println("取代被代理对象的方法");

    }

    @Override
    public void after(Object proxy, Object target, Method method, Object[] args) {
        System.out.println(1);
    }
}

//拦截器2
public class myinter2 implements Inter{
    @Override
    public boolean before(Object proxy, Object target, Method method, Object[] args) {
        System.out.println(2);
        return true;
    }

    @Override
    public void around(Object proxy, Object target, Method method, Object[] args) {

    }

    @Override
    public void after(Object proxy, Object target, Method method, Object[] args) {
        System.out.println(2);
    }
}

//实现jdk动态代理
public class interjdkproxy implements InvocationHandler {

    private Object target;
    private String interclass=null;

    public interjdkproxy(Object target,String interclass){
        this.target=target;
        this.interclass=interclass;
    }

    public static Object bind(Object target,String interclass){
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),new interjdkproxy(target,interclass));
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if(interclass==null){
            return method.invoke(target,args);
        }
        Object result=null;
        //通过反射生成拦截器
        Inter inter=(Inter) Class.forName(interclass).newInstance();
        if(inter.before(proxy,target,method,args)){
            result=method.invoke(target,args);
        }else{
            inter.around(proxy,target,method,args);
        }
        inter.after(proxy,target,method,args);
        return result;
    }

    public static void main(String[] args) {
        apple app=(apple) interjdkproxy.bind(new helloimpl(),"xxx.xxx.myinter");
        apple app2=(apple) interjdkproxy.bind(hello,"demo.reflect.myinter2");
        app2.say();
    }
}

class apple{
    public void say(){
        System.out.println("我是一个绿颜色的苹果，我想站在你头上");
    }
}

3.1 观察者模式

• 朋友间还欠款：甲：小**的该还钱了！ 乙：真小气，这就给你！以后再也不问你借钱了 甲：我丢。。。
• 支付宝还欠款：到期通知还款后自动扣款

//欠款信息（被观察者）
public class product extends Observable {
    private static product instance=null;
    private product(){}
		//设置为单例模式
    public static product getInstance(){
        if(instance==null){
            instance=new product();
        }
        return instance;
    }
		//添加观察者
    public void addpro(Observer observer){
        this.addObserver(observer);
    }
  	//通知还款
    public void notify(String newpro){
        System.out.println("通知还款");
        this.setChanged();//设置被观察对象发生改变
        this.notifyObservers(newpro);//通知观察者还款
    }
}

//观察者张三
class zhangsan implements Observer{
    @Override
    public void update(Observable o, Object arg) {
        System.out.println("张三"+arg);
    }
}

//观察者李四
class lisi implements Observer{
    @Override
    public void update(Observable o, Object arg) {

        System.out.println("李四"+arg);
    }
}

class main{
    public static void main(String[] args) {
      	//创建被观察者
        product product= demo.observable.product.getInstance();
        zhangsan zs=new zhangsan();
        lisi ls=new lisi();
      	//添加两个观察者
        product.addpro(zs);
        product.addpro(ls);
      	//调用通知方法，通知观察者按时还款
        product.notify("到期还款成功");
    }
}

4.1 工厂模式

4.1.1 普通工厂模式

• 工厂根据不同客户的需要生产指定的产品

//工厂类
public class factory {
    public static product create(String pno){
        switch (pno){
            case "1":
                return new product1();
            case "2":
                return new product2();
            case "3":
                return new product3();
                default:
                    return null;
        }
    }
}

//某一类接口
interface product{}

//具体产品1
class product1 implements product{}

//具体产品2
class product2 implements product{}

//具体产品3
class product3 implements product{}

//测试运行
class ceshi{
    public static void main(String[] args) {
        factory.create("1");
    }
}

4.1.2 抽象工厂模式

• 以车厂为例，生产商将所有车型都放在一个车厂生产，会导致难以管理和维护。这个时候就需要将车型细分为轿车、大巴车、警车……
• 车厂——>轿车厂——>福特野马——>黑色野马

//汽车加工厂
interface carfactory{
    public product create(String pno);
}

//汽车加工厂1
class factory1 implements carfactory{
    @Override
    public product create(String pno) {
      	//找到具体品牌车辆后，根据编号查找具体颜色的车辆
        switch (pno){
            case "1":
                return new product1();
            case "2":
                return new product2();
            case "3":
                return new product3();
            default:
                return null;
        }
    }
}

//汽车加工厂2
class factory2 implements carfactory{
    @Override
    public product create(String pno) {
        switch (pno){
            case "1":
                return new product1();
            case "2":
                return new product2();
            case "3":
                return new product3();
            default:
                return null;
        }
    }
}

//汽车加工厂3
class factory3 implements carfactory{
    @Override
    public product create(String pno) {
        switch (pno){
            case "1":
                return new product1();
            case "2":
                return new product2();
            case "3":
                return new product3();
            default:
                return null;
        }
    }
}

//车型
interface product{}
//车型颜色（红）
class product1 implements product{
    public product1(){
        System.out.println("p1");
    }
}
//车型颜色（白）
class product2 implements product{
    public product2(){
        System.out.println("p2");
    }
}
//车型颜色（黑）
class product3 implements product{
    public product3(){
        System.out.println("p3");
    }
}
//创建一个公共大工厂
class pf implements carfactory{
    @Override
    public product create(String pno) {
        char c=pno.charAt(0);
        carfactory carfactory=null;
      	//选择具体车辆编号，并前往具体车型工厂
        switch (c){
            case '1':carfactory = new factory1();
            case '2':carfactory = new factory2();
            case '3':carfactory = new factory3();
        }
      	//如果找到具体车型工厂，就去工厂中寻找具体品牌车辆
        if(carfactory!=null){
            return carfactory.create(String.valueOf(c));
        }
        return null;
    }
}
//运行测试
class ceshi{
    public static void main(String[] args) {
        pf p=new pf();
        p.create("1");
    }
}