设计模式

设计模式

设计模式 + 反射 + 泛型 + 注解/配置文件等

单例模式

最简单，考的最多的一个设计模式

要点

　　（1）构造器私有化

　　（2）在本类中创建这个唯一的实例

分类

//饿汉式
//形式一
class Hungry{
    public static final Hungry INSTANCE = new Hungry();
    private Hungry(){
    }
}
//形式二
class Hungry{
    private static final Hungry INSTANCE = new Hungry();
    private Hungry(){
    }
    public static Hungry getInstance(){
        return INSTANCE;
    }
}

//懒汉式
//形式一：（有线程安全问题）
class Lazy{
    private static Lazy instance;
    private Lazy(){
    }
    //延迟创建对象
    public static Lazy getInstance(){
        if(instance == null){
            instance = new Lazy();
        }
        return instance;
    }
}
//形式二：（解决线程安全问题）
//也可以叫双检锁模式
public class Lazy{
    private static Lazy instance;
    private Lazy(){}
    public static Lazy getInstance(){
        if(instance == null){
            synchronized(Lazy.class){
                if(instance == null){
                    instance = new Lazy();
                }
            }
        }
        return instance;
    }
}

//枚举式
enum Single{
    INSTANCE
}
//是特殊的饿汉式

模板设计模式（识别）

使用的情景

　　当某个功能在实现时，它的主体的算法结构是确定的，只是其中的某一个或几个步骤无法给出具体的实现，那么这个时候，把这个或几个的步骤抽取成抽象方法，由子类去给出具体的实现，那么子类继承父类时，既可以保留父类的主体算法结构，又可以对这几个抽象部分给出具体的实现

示例代码：

例如：计算某段代码的执行时间
算法结构：
1、获取开始时间
2、执行代码
3、获取结束时间
4、计算差值
public abstract class CalTime{
    public final long getTime(){
        //1、获取开始时间
        long start = System.currentTimeMillis();
        //2、执行代码
        doWork();
        //3、获取结束时间
        long end = System.currentTimeMillis();
        //4、计算差值
        return end - start;
    }
    protected abstract void doWork();
}
class MyCalTime extends CalTime{
    public void doWork(){
        .......
    }
}

工厂设计模式

为什么要用工厂模式

　　把创建对象者与对象的使用者分离（把创建者与使用者分离）

　　解耦合

形式

　　1、简单工厂模式

　　　　特点　　一个工厂生产所有产品

　　　　缺点　　增加一个新产品， 就要修改工厂类代码　　违反了“对扩展开发，对修改关闭”的面向对象的设计原则

　　　　优点　　类少，简单

　　　　示例代码

//1、产品的接口
interface  Car{
    void run();
}
//2、各种产品
class Benz implements Car{
    public void run(){
            ...
    }
}
class BMW implements Car{
    public void run(){
            ...
    }
}
//3、工厂
class SimpleFactory {
    public static Car getCar(String type){
        if("benz".equals(type)){
            return new Benz();
        }else if("bmw".equals(type)){
            return new BMW();
        }
        return null;
    }
}
//4、使用者
Car  car = SimpleFactory.getCar("benz");
car.run();

 

　　2、工厂方法模式

　　　　特点　　个产品配一个工厂

　　　　缺点　　类比较多

　　　　优点　　增加一个新产品，对原来的代码不需要修改，只需要增加对应的工厂即可

　　　　示例代码

//1、产品的接口
interface  Car{
    void run();
}
//2、各种产品
class Benz implements Car{
    public void run(){
            ...
    }
}
class BMW implements Car{
    public void run(){
            ...
    }
}
//3、各种工厂
interface  Factory{
    Car getCar();
}
class BenzFactory implements Factory{
    public Benz getCar(){
        return new Benz();
    }
}
class BMWFactory implements Factory{
    public BMW getCar(){
        return new BMW();
    }
}
//4、使用者
BenzFactory f = new BenzFactory();
Car car = f.getCar();
car.run();

　　3、抽象工厂设计模式