设计模式，单例，工厂，模板，

单例—饿汉：

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

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

单例—懒汉：

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

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

}

public class Test {
    public static void main(String[] args) {
        List<single02> single02List = new ArrayList<>();
        for (int i = 0; i <3 ; i++) {
            single02 instance = single02.getInstance();
            single02List.add(instance);
        }
        for (single02 single02 : single02List) {
            System.out.println(single02);
        }

    }
}

工厂模式：

子类实现父类的方法：

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

public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫咪喵喵叫");
    }
}

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗狗汪汪叫");
    }
}

工厂类

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

测试：

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

        Animal dog =  factory.fator("dog");
        dog.eat();
    }
}

模板模式：

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

    public void formart(){
        template();
    }

    public abstract void template();
}

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

public class Test {
    /**
     *   模版方法设计:
     *     实现功能: 功能一部分清楚,一部分不清楚
     *     Web: HTTP协议: 传输什么
     */
    public static void main(String[] args) {
        //通过多态new子类对象，用父类对象来存
        Template template = new SubTempate();
        //调用父类中的暴露的打印时间方法，其中具体的时间方法，
        // 由实现模板的子类方法来实现。
        // 也就是执行的是子类的实现方法。
        template.formart();
    }
}