架构师训练营 -Week 03 学习总结

关注
发布于: 2020 年 06 月 24 日
设计模式的分类功能分类：
创建模式：对类的实例化过程的抽象
结构模式：将类或者对象结合到一起，形成更大的结构
行为模式：对在不同的对象之间划分职责和算法的抽象化
方式分类：
类模式：以继承的方式实现模式，静态的
对象模式：以组合的方式实现模式，动态的
﻿
常用的几种设计模式工厂模式（Factory Design Pattern）：可分为三种更加细分的类型：简单工厂、工厂方法和抽象工厂
简单工厂模式：是客户端不再依赖接口的具体实现。可以通过配置文件，使工厂动态生成所需对象。不过也限制了类只能通过默认构造函数创建。
public abstract class BMW {
	private String name;
	
	public BMW(String name) {
		this.name = name;
	}
}
public class BMW250 extends BMW {
	public BMW250(String name) {
		super(name);
		System.out.println("制造一部" + name + "宝马车");
	}
 
}
public class BMW320 extends BMW {
	public BMW320(String name) {
		super(name);
		System.out.println("制造一部" + name + "宝马车");
	}
}
public class BMWFactory {
	
	public BMW createBMW(String name) {
		if ("BMW320".equals(name)) {
			return new BMW320(name);
		} else if ("BMW250".equals(name)) {
			return new BMW250(name);
		}
		return null;
	}
}
public class Customer {
	
	public static void main(String[] args) {
		BMWFactory factory = new BMWFactory();
		BMW bmw250 = factory.createBMW("BMW250");
		BMW bmw320 = factory.createBMW("BMW320");
	}
}
﻿
单例模式（Singleton Design Pattern）：一个类只允许创建一个实例。
从业务概念上，有些数据在系统中只应该保存一份，就比较适合设计为单例类。比如，系统的配置信息类。除此之外，我们还可以使用单例解决资源访问冲突的问题。
单例有下面几种经典的实现方式。
饿汉式
/**
 * 单例模式实现方式之一
 * 饿汉式 
 * 是否延迟加载初始化：是
 * 是否多线程安全： 是
 * 实现难度：易
 * 描述：这种方式比较常用，但容易产生垃圾对象。
 * 优点：没有加锁，执行效率会提高。
 * 缺点：类加载时就初始化，浪费内存。
 * 它基于 classloder 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，虽然导致类装载的原因有很多种，
 * 在单例模式中大多数都是调用 getInstance 方法， 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance 显然没有达到 lazy loading 的效果。
 */
public class Signleton {
	
	private static Signleton instance = new Signleton();
	
	private Signleton() {
		
	}
	
	public static Signleton getIntance() {
		return instance;
	}
}
﻿
懒汉式
/**
 * 单例模式实现方式之一
 * 懒汉式 线程安全
 * 是否延迟加载初始化：是
 * 是否多线程安全： 是
 * 实现难度：易
 * 描述：这种方式具备很好的 lazy loading，能够在多线程中很好的工作，但是，效率很低，99% 情况下不需要同步。
 * 优点：第一次调用才初始化，避免内存浪费。
 * 缺点：必须加锁 synchronized 才能保证单例，但加锁会影响效率。
 *
 */
public class Signleton {
	
	private static Signleton instance;
	
	private Signleton() {
		
	}
	
	public static synchronized Signleton getInstance() {
		if (instance == null) {
			instance = new Signleton();
		}
		
		return instance;
	}
}
﻿
双重检测
/**
 * 单例模式实现方式一
 * 双检锁/双重校验锁（DCL，即 double-checked locking）
 * JDK 版本：JDK1.5 起 
 * 是否 Lazy 初始化：是
 * 是否多线程安全：是
 * 实现难度：较复杂
 * 描述：这种方式采用双锁机制，安全且在多线程情况下能保持高性能。
 *
 */
public class Signleton {
	
	private volatile static Signleton instance;
	
	private Signleton() {
		
	}
	
	public static Signleton getInstance() {
		if (instance == null) {
			synchronized (Signleton.class) {
				if (instance == null) {
					instance = new Signleton();
				}
			}
		}
		return instance;
	}
	
}
﻿
静态内部类
/**
 * 单例模式实现方式之一
 * 静态内部类 线程安全
 * 是否延迟加载初始化：是
 * 是否多线程安全： 是
 * 实现难度：易
 * 描述：利用了JVM保证线程安全和唯一性
 */
public class Signleton {
	private Signleton() {} 
	
	private static class SingletonHolder{ 
		private static final Signleton instance = new Signleton(); 
	} 
	
	public static Signleton getInstance() { 
		return SingletonHolder.instance; 
	}
}
﻿
枚举
/**
 * 单例模式实现方式之一
 * 静态内部类 线程安全
 * 是否延迟加载初始化：是
 * 是否多线程安全： 是
 * 实现难度：易
 * 描述：通过 Java 枚举类型本身的特性，保证了实例创建的线程安全性和实例的唯一性
 */
public enum Singleton {
    INSTANCE;
    public Singleton getInstance(){
        return INSTANCE;
    }
}
﻿
观察者模式（Observer Design Pattern）：也被称为发布订阅模式（Publish-Subscribe Design Pattern），在对象之间定义一个一对多的依赖，当一个对象状态改变的时候，所有依赖的对象都会自动收到通知。
public interface Subject {
  void registerObserver(Observer observer);
  void removeObserver(Observer observer);
  void notifyObservers(Message message);
}
public interface Observer {
  void update(Message message);
}
public class ConcreteSubject implements Subject {
  private List<Observer> observers = new ArrayList<Observer>();
  @Override
  public void registerObserver(Observer observer) {
    observers.add(observer);
  }
  @Override
  public void removeObserver(Observer observer) {
    observers.remove(observer);
  }
  @Override
  public void notifyObservers(Message message) {
    for (Observer observer : observers) {
      observer.update(message);
    }
  }
}
public class ConcreteObserverOne implements Observer {
  @Override
  public void update(Message message) {
    System.out.println("ConcreteObserverOne is notified.");
  }
}
public class ConcreteObserverTwo implements Observer {
  @Override
  public void update(Message message) {
    System.out.println("ConcreteObserverTwo is notified.");
  }
}
public class Test {
  public static void main(String[] args) {
    ConcreteSubject subject = new ConcreteSubject();
    subject.registerObserver(new ConcreteObserverOne());
    subject.registerObserver(new ConcreteObserverTwo());
    subject.notifyObservers(new Message());
  }
}
﻿
适配器模式（Adapter Design Pattern）：将不兼容的接口转换为可兼容的接口，让原本由于接口不兼容而不能一起工作的类可以一起工作。对于这个模式，有一个经常被拿来解释它的例子，就是 USB 转接头充当适配器，把两种不兼容的接口，通过转接变得可以一起工作。
// 类适配器: 基于继承
public interface ITarget {
  void f1();
  void f2();
  void fc();
}
public class Adaptee {
  public void fa() { //... }
  public void fb() { //... }
  public void fc() { //... }
}
public class Adaptor extends Adaptee implements ITarget {
  @override
  public void f1() {
    super.fa();
  }
  
  @override
  public void f2() {
    
  }
  
}
public interface ITarget {
  void f1();
  void f2();
  void fc();
}
public class Adaptee {
  public void fa() { //... }
  public void fb() { //... }
  public void fc() { //... }
}
public class Adaptor implements ITarget {
  private Adaptee adaptee;
  
  public Adaptor(Adaptee adaptee) {
    this.adaptee = adaptee;
  }
  
  public void f1() {
    adaptee.fa(); //委托给Adaptee
  }
  
  public void f2() {
    //...重新实现f2()...
  }
  
  public void fc() {
    adaptee.fc();
  }
}
﻿
发布于: 2020 年 06 月 24 日阅读数: 50
华乐彬

关注
还未添加个人签名 2019.03.13 加入
还未添加个人简介
发布
暂无评论
创作场景

架构师训练营 -Week 03 学习总结

设计模式的分类

常用的几种设计模式

华乐彬

评论
