设计模式学习笔记

墙裂推荐菜鸟教程

设计模式总结

先学学建造者模式

一 原则

1 开闭

开放扩展，关闭修改

2 里氏代换

派生类代替基类不影响程序功能

3 依赖倒转

依赖抽象不依赖实体

4 接口隔离

多个隔离接口替代单独接口

5 迪米特

一个实体尽量少的和其他实体发生作用

6 合成复用

尽量使用合成替代继承

二 建造者型模式

1 工厂模式

用接口初始化实体类

1 建立一个接口（工厂）

2 根据接口实现若干实体类（产品）

3 销售（根据需求决定选择的实体类）

4 使用这个系统

interface Shape{
    public void draw();
}
class a implements Shape{
    @Override
    public void draw() {
        System.out.println("a");
    }
}
class b implements Shape{
    @Override
    public void draw() {
        System.out.println("b");
    }
}
class ShapeFactory{
    public Shape Produce(int id){
        if(id==1)return new a();
        else if(id==2)return new b();
        else return null;
    }
}
public class Main {

    public static void main(String[] args) {
       ShapeFactory factory=new ShapeFactory();
       Shape a=factory.Produce(1);
       Shape b=factory.Produce(2);
       a.draw();
       b.draw();
    }
}

2 抽象工厂模式

这里和工厂相比

相当于是一个集团

比如之前只造枪

现在需要造枪和子弹了

然后对于这个集团来说

要造很多个工厂

每个工厂要选择建造枪和子弹

interface Gun{
     void build();
}
interface Bullet{
    void build();
}
class ak47 implements Gun{
    @Override
    public void build() {
        System.out.println("ak47");
    }
}
class m16 implements Gun{
    @Override
    public void build() {
        System.out.println("m16");
    }
}
class mm7d62 implements Bullet{
    @Override
    public void build() {
        System.out.println("7.62mm");
    }
}
class mm55 implements Bullet{
    @Override
    public void build() {
        System.out.println("5.5mm");
    }
}
abstract class FullEquipment {
    //可以理解成分配各个工厂的
    abstract Gun getGun(int id)throws Exception ;
    abstract Bullet getBullet(int id)throws Exception;
}
class GunFac extends FullEquipment{
    @Override
    Gun getGun(int id) throws Exception {
        if(id==1)
        return new ak47();
        else if(id==2)
            return new m16();
        else{
            throw new Exception("no such equipment found");
        }
    }

    @Override
    Bullet getBullet(int id) {
        return null;
    }
}
class BulletFac extends FullEquipment{

    @Override
    Gun getGun(int id) {
        return null;
    }

    @Override
    Bullet getBullet(int id) throws Exception {
        if(id==1)
            return new mm7d62();
        else if(id==2)
            return new mm55();
        else{
            throw new Exception("no such equipment found");
        }
    }
}
class Factory{
    public static FullEquipment getFac(int type){
            if(type==1){
                return new GunFac();
            }else if(type==2){
                return new BulletFac();
            }else{
                return null;
            }
    }
}
public class Main {

    public static void main(String[] args) throws Exception {
       FullEquipment f= Factory.getFac(1);
       f.getGun(1).build();
        FullEquipment f1= Factory.getFac(2);
        f1.getBullet(1).build();
    }
}

3 单例模式

保证类只被new一次的同时，还要防止反射和序列化的攻击

关键：构造函数私有

饿汉
class EHAN{
  private  static EHAN h=new EHAN();
  private EHAN(){};
  public static EHAN getinstance(){
      return h;
  }
}
懒汉线程不安全
class LANHAN{
    private static LANHAN e;
    private LANHAN(){};
    public static LANHAN getInstance(){
        if(e==null){
            e=new LANHAN();
        }
        return e;
    }
}
懒汉线程安全
class SafeLANHAN{
    private static SafeLANHAN e;
    private SafeLANHAN(){};
    public static synchronized SafeLANHAN getInstance(){
        if(e==null){
            e=new SafeLANHAN();
        }
        return e;
    }
}
双重锁校验
class DCL{
    private static volatile DCL instance;
    private DCL(){};
    public static DCL getinstance(){
        if(instance==null){
            synchronized (DCL.class){
                if(instance==null){
                    instance=new DCL();
                }
            }
        }
        return instance;
    }
}
后两者用到了类加载保证线程安全（线程加载中用到了sychronized）
内部类加载
class innerDCL{
    private static class inner{
        private static final innerDCL dcl=new innerDCL();
    }
    public static innerDCL getInstance(){
        return inner.dcl;
    }
}
枚举
enum getclass{
    instance;
    
}

4 建造者模式

从基类开始逐渐建造，最终成为一个完整的类

示例

枪身+枪托先建造枪身

子弹+弹匣先建造弹夹

枪身+若干弹夹=完整体

代码大致相当于抽象工厂的实体类合集再包一层

5 原型模式

依靠clone或序列化实现深拷贝，并使用一个hashtable或hashmap返回类

目的是克隆现有的类而不需要new