JAVA常用设计模式

设计模式

一.单例模式

1.1单例设计模式-饿汉式

案例实现

/**
 *  类Single对象具有唯一性
 *  实现步骤:
 *    1: 私有构造方法
 *    2: 自己创建自己类的对象
 *    3: 提供公共的访问方式,方法
 *
 *    只能通过方法 getInstance()获取对象
 *    需要对象才能调用,非静态的
 *    只有一个调用方法 类.方法()
 *
 *    单例设计模式-饿汉式
 *
 *    运行一个类,必须进入内存(方法区)
 *    类进入内存,初始化自己的静态成员
 */
public class Single {
    //私有构造方法
    private Single(){}
    //自己创建自己类的对象
    private static Single s = new Single();
    //定义方法,返回创建的对象
    public static Single getInstance(){
        return s;
    }
}

/*
 *  设计模式:
 *    在软件开发,遇到各种问题,汇总处理
 *    前人将问题,经验汇总处理,方式称为设计模式
 *    基于面向对象思想
 *    Java中23种设计模式
 *
 *  单例设计模式: 保证一个类的对象,在内存中唯一性
 */
public class Test {
    public static void main(String[] args) {
        //获取Single类的对象,方法getInstance()
        Single s = Single.getInstance();
        System.out.println(s);
        s = Single.getInstance();
        System.out.println(s);
        s = Single.getInstance();
        System.out.println(s);
        s = Single.getInstance();
        System.out.println(s);
        s = Single.getInstance();
        System.out.println(s);
        s = Single.getInstance();
        System.out.println(s);
    }
}

1.2单例设计模式-饿汉式

案例实现

/**
 *  类Single对象具有唯一性
 *  单例中的懒汉式,对象延迟加载
 *
 *  实现步骤:
 *    1: 私有构造方法
 *    2: 自己创建自己类的变量,不创建对象
 *    3: 提供公共的访问方式,方法

 */
public class Single {
    //私有构造方法
    private Single(){}
    //自己创建自己类的变量,不创建对象
    private static Single s = null;
    //定义方法,返回本类对象
    //保证多线程运行的安全问题, 同步方法
     //同步方法,只能被一个线程调用
    public static  synchronized Single getInstance(){
        //判断变量s是不是null
        if(s == null){
            s = new Single();
        }
        return s;
    }
}

/*
 *  设计模式:
 *    在软件开发,遇到各种问题,汇总处理
 *    前人将问题,经验汇总处理,方式称为设计模式
 *    基于面向对象思想
 *    Java中23种设计模式
 *
 *  单例设计模式: 保证一个类的对象,在内存中唯一性
 */
public class Test {
    public static void main(String[] args) {
        //获取Single类的对象,方法getInstance()
        Single s = Single.getInstance();
        System.out.println(s);

    }
}

二.工厂模式

什么是工厂模式

1.工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
2.在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，是通过使用一个共同的接口来指向新创建的对象。

栗子

您需要一辆汽车，可以直接从工厂里面提货，而不用去管这辆汽车是怎么做出来的，以及这个汽车里面的具体实现。

优缺点

优点： 1、一个调用者想创建一个对象，只要知道其名称就可以了。 2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。 3、屏蔽产品的具体实现，调用者只关心产品的接口。
缺点：每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。

案例实现

public  abstract class Animal {
    public abstract void eat();
}

public class Cat extends Animal {
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

public class Dog  extends  Animal{
    public void eat() {
        System.out.println("狗啃骨头");
    }
}

public abstract class Factory {
    /*
     * 工厂类,定义方法,创建动物对象
     * 下订单,方法参数
     */
    public static Animal getInstance(String s){
        if("cat".equals(s)){
            return new Cat();
        }
        if("dog".equals(s)){
            return new Dog();
        }
        return null;
    }
}

/**
 *  简单工厂设计:
 *    工厂创建产品,工厂是创建对象的
 *    创建什么对象: 范围,动物对象
 *    创建对象,下订单
 */
public class Test {
    public static void main(String[] args) {
        //工厂类的方法,获取对象
        Animal a = Factory.getInstance("dog");
        a.eat();

        a = Factory.getInstance("cat");
        a.eat();
    }
}

三.模板模式

public class SubTemplate extends Template {
    @Override
    public void template() {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy:MM:dd");
        System.out.println(sdf.format(new Date()));
    }
}

public  abstract class Template {
    /*
     * 功能有的知道,有的不知道
     * 不知道部分: 对外暴露出去(方法),等待子类延迟实现
     */
    public void format(){
        template();
    }

    public abstract void template();
}

/**
 *   模版方法设计:
 *     实现功能: 功能一部分清楚,一部分不清楚
 *     Web: HTTP协议: 传输什么
 */
public class Test {
    public static void main(String[] args) {
        Template template = new SubTemplate();
        template.format();
    }
}

构建者模式

什么是构建者模式

构建者模式一般用在构建流程或者组成部件固定的场合，将这些部件分开构建成为组件对象，再将这些组件对象整合成为目标对象。　　

栗子

组装台式电脑的情况，我们可以分别购买主板、CPU、内存、硬盘等部件，然后将这些部件组装在一起就形成了一台完整的电脑。

构建者模式和工厂模式的区别

工厂模式一般都是创建一个产品，注重的是把这个产品创建出来就行，只要创建出来，不
关心这个产品的组成部分。从 代码上看，工厂模式就是一个方法，用这个方法就能生产出
产品。

构建者模式也是创建一个产品，但是不仅要把这个产品创建出来，还要关心这个产品的组
成细节，组成过程。从代码上看，建造者模式在建造产品时，这个产品有很多方法，建造
者模式会根据这些相同方法但是不同执行顺序建造出不同组成细节的产品