java常用的几种设计模式

一  工厂模式       

工厂模式从字面可以理解，就是我们需要某个实例，不需要一个个去new出来，而是通过某个工厂批量产生，这样设计的好处就是如果某个类被替换，那么在客户端我们不需要改动，只要在工场类中去修改，降低了类之间的依赖性。

代码实例:

package com.example.springboot_test.test;

/**
 * com.xinguangnet.tuchao.merchant.manage
 *
 * @Author : Wukn
 * @Date : 2018/2/5
 */

/**
 * 工厂设计模式
 *
 *
 *
 */
interface  Persion { //定义接口

    public void eat();//定义一个方法

}

class Aa implements Persion {

    @Override
    public void eat() {
        System.out.println("Aa----------");
    }
}

class Bb implements Persion {

    @Override
    public void eat() {
        System.out.println("Bb-----------");
    }
}


class FactoryTest {

    public static Persion FactoryClass(String str) {
        Persion persion = null;
        if(str.equals("Aa")) {
            persion = new Aa();
        }
        if(str.equals( "Bb" )){
            persion = new Bb();
        }
        return persion;
    }
    /**
     * 注意在判断字符串时最好是将字符串写在前面，这样可以防止空指针异常
     *if("Aa".equals(str)) {
        persion = new Aa();
     }
     if("Bb".equals(str)){
        persion = new Bb();
     }
     *
     */
    static class TestClass {

    public static void main(String[] args) {
        Persion persion = FactoryTest.FactoryClass("Aa");
        persion.eat();
    }
}}

二 代理模式

  

package com.example.springboot_test.test;

/**
 * com.xinguangnet.tuchao.merchant.manage
 *
 * @Author : Wukn
 * @Date : 2018/2/5
 *
 *
 * 代理设计模式
 */


/**
 *定义一个租房接口这个接口房东和中介都去实现
 为什么要定义一个公共的接口呢，我的理解是，不管是房东或者中介要想把房子租出去就必须要发一个租房广告
 */
public interface ProxyTest {
    public void sent();
}


class Fangdong implements ProxyTest {//对于房东而言他的目的就是只要把房子租出去,谁租的房子他都不关心

    @Override
    public void sent() {
        System.out.println("房东直租。。。。。。");
    }
}


class ZhongJie implements ProxyTest {//对于中介而言，他的目的就是将房东的房子租出去，中介会定租金和租给谁

    private  Fangdong fangdong;

    public ZhongJie(Fangdong fangdong) {
        this.fangdong = fangdong;
    }


    public void money(){
        System.out.println("交钱");
    }
    public void stay() {
        System.out.println("入住");
    }



    @Override
    public void sent() {
        money();
        fangdong.sent();//这个是真正的租房信息，被中介代理的内容
        sent();
    }
}


class TestSent {
    public static void main(String[] args) {
        /**
         * //租房子的人找到中介，他根本不知道这个房子是不是直租，他只是找到中介，中介把房东的房子租给了需要租的人
         */
        ProxyTest proxyTest = new ZhongJie(new Fangdong());
        proxyTest.sent();//租房完成
    }
}



 *

/**
 * 在整个租房的开始到完成中需要思考每个人物完成了哪些事情、
 * 房东：
 *      房东实现了公共的接口
 *      房东将租房子的广告信息发不出来
 *
 * 中介:
 *      中介实现了公共的接口
 *      中介代理了房东的租房广告信息
 *      中介丰富了租房的过程
 *
 * 客户：
 *       找到中介，交钱租房
 *
 *
 *
 * 在上面的过程中，我的理解是，所谓代理设计，其实就是两个目的相同的类公共区实现一个公共的业务接口，这两个类一个是原始类，一个是
 * 代理类，代理类中其实实例化了原始类，这样在代理类中可以将代理类和原始类公共的方法进行增强，有前增强，后增强等，
 * 对于客户端而言，只需要关注代理类的实现方式而不需要关注具体的业务组成，降低了模块之间的耦合度。有利于适应更多的业务场景。
 *
 *

三 适配器模式

package com.example.springboot_test.test;

/**
 * com.xinguangnet.tuchao.merchant.manage
 *
 * @Author : Wukn
 * @Date : 2018/2/5
 */

/**
 * 适配器模式
 */




interface AdaperTest {

    /**
     * 对于一个接口而言，如果某个类实现了这个接口，就必须实现这个接口里面的所以方法，
     * 但是在具体的业务场景，有的时候我们不需要实现接口里面的所以方法，我们可能只需要几个方法，
     * 但是只是一个空的方法体，然后再用一个普通类去继承这个接口，具体的代码就可以写在这个普通类里面的方法体中，
     * 这种设计思想就是设配器模式。
     */

    public void a1();
    public void a2();
    public String b1();
    public Integer b2();
}

abstract class Aaa implements AdaperTest {


    /**
     * 空的方法体
     */
    @Override
    public void a1() {

    }

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



class Shoe extends Aaa {

    @Override
    public void a2() {
        System.out.println("ddd");

    }

    @Override
    public Integer b2() {
        Integer a = 123;
        return a;
    }
}


/**
 *
 * 在以上的程序中其实可以有一个疑问就是
 *              为什么抽象类可以不用全部实现接口的方法？
 *
 *
 *       我的理解是既然是抽象类，如果必须要实现接口的全部方法。那之前对于接口的规范是没有意义的，
 *       抽象类中定义了抽象类如果没有被继承那么这个抽象类的创造就没有意义，试想，如果抽象类全部实现了接口的方法，
 *       所有的操作都在抽象类中完成，就不需要被其他类继承了，那么就和之前定的规范矛盾。
 *
 *
 *
 *
 *
 */

抽象类与接口之间的关系