设计原则
- 开闭原则 ： 开放扩展，关闭修改
- 里氏替换原则 ： 不要改变父类的功能
- 依赖倒置: 不要依赖细节，接口编程
- 单一原则： 实现的类功能单一
- 接口隔离： 接口要精简单一
- 迪米特法则：不要越级联系，降低耦合度
- 合成复用： 优先使用组合、聚合关系
设计模式分类
- 创建模式：关注怎样创建对象，将对象的创建和使用分离
| 范围/目的 | 创建型模式 | 结构型模式 | 行为型模式 |
|---|---|---|---|
| 类模式 | 工厂方法 | 类适配器 | 模板方法 解释器 |
| 对象模式 | 单例 模型 抽象工厂 建造者 |
代理 对象适配器 桥接 装饰 外观 享元 组合 |
策略 命令 职责链 状态 观察者 中介者 迭代器 访问者 备忘录 |
一、单例模式 singleton
1、只生成一个实例，提供全局的访问点提供外部访问
2、关键字 volatile 和 synchronized 多线程关注
3、扩展为有限多例模式
singleton.png
懒汉模式
public class Singleton{
private static volatile Singleton instance=null;
private Singleton(){}
publice static synchronized Singleton getInstance(){
if(null==instance){
instance=new Singleton();
}
return instance;
}
}
饿汉模式
public class Singleton{
private static Singleton instance=new Singleton();
private Singleton(){}
public static Singleton getInstance(){
return instance;
}
}
扩展有限多例
public class Multiton{
private static List multitons=new ArraryList();
private int multiNum=3;
private Multiton(){}
static{
for(int m=0;i 二、原型模式 prototype
1、抽象原型类 例如java中Cloneable 接口
2、具体原型类 实现接口clone()
3、访问类 使用clone方法创建对象
2prototype.png
具体原型类
public class RealPrototype implements Cloneable{
public RealPrototype(){
}
public clone(){
return (RealPrototype)super.clone();
}
}
访问类
使用场景：相同或相似的属性，个别属性差异，创建比较复杂
public class UsePrototype{
public static void main(String[] arg){
RealPrototype rp= new RealPrototype();
RealPrototype rpc=(RealPrototype)rp.clone();
}
}
三、工厂方法 factory
1、知道工厂名称，就可以获取工厂产品，不关心生成过程
2、增加新的产品，新建工厂生成对应产品，原工厂不变
3、缺陷：新增产品，工厂、产品都需要新增
- 抽象产品 abstract product : 产品接口
- 具体产品 concrete product :产品类
- 抽象工厂 abstract factory ：工厂接口
-
具体工厂 concrete factory : 工厂类
3factoryMethod.png
抽象产品
interface AbstractProduct{
void print();
}
具体产品
public class AppleProduct implements AbstractProduct{
publict void print(){
System.out.println("apple");
}
}
public class OrangeProduct implements AbstractProduct{
publict void print(){
System.out.println("orange");
}
}
抽象工厂
interface AbstractFactory{
Product createProduct();
}
具体工厂
public class AppleConcreteFactory implements AbstractFactory {
public Product createProduct(){
return new AppleProduct();
}
}
public class OrangeConcreteFactory implements AbstractFactory {
public Product createProduct(){
return new OrangeProduct();
}
}
访问类
public class TestFactory{
public static void main(string[] arg ){
Factory fc= new AppleFactory();
Product pt=fc.createProduct();
pt.print();
}
}
四、抽象工厂模型 AbstractFactory
可以生成多个等级的产品,最早应用于创建不同操作系统的视窗构建，每次使用某一组产品（windows、linux）
- 抽象工厂 Abstract Factory 创建不同等级产品的接口
- 具体工厂 concrete Factory 实现抽象工厂方法
- 抽象产品 描述产品的主要特性，多个抽象产品
- 具体产品 concreteProduct 实现产品接口 N:1 具体工厂
4AbstractFactory.png
抽象工厂
interface AbstractFactory{
ProductA newProductA();
ProductB newProductB();
}
具体工厂
public class ConcreteFactoryA implements AbstractFactory{
ProductA newProductA1(){
return new PorductA1();
}
ProductB newProductB1(){
return new ProductB1();
}
}
public class ConcreteFactoryB implements AbstractFactory{
ProductA newProductA2(){
return new PorductA2();
}
ProductB newProductB2(){
return new ProductB2();
}
}
抽象产品
interface ProductA{
int weight();
}
interface ProductB{
double speed();
}
具体产品
public class ProductA1 implements ProductA{
int weight(){
System.out.println("productA1");
return 5;
}
}
public class ProductB1 implements ProductB{
double speed(){
System.out.println("productB1");
return 100.0d;
}
}
public class ProductA2 implements ProductA{
int weight(){
System.out.println("productA2");
return 6;
}
}
public class ProductB2 implements ProductB{
double speed(){
System.out.println("productB2");
return 200.0d;
}
}
访问类
农场养动物和种植物，A农场养牛和种菜 B农场养马和种水果，场景适用抽象工厂
public class TestAFactory{
public static void main(String[] args){
AbstractFacotry af= new ConcreteFacoryA();
ProductA a=af.newProductA();
a.weight();
}
}
五、建造者buider
- 产品角色 product：包含各个组件的对象，由建造者创建
- 抽象建造者 builder：定义产品组件创建的方法接口和完整产品结果 getResult
- 具体建造者 ConcreteBuilder 具体产品组件创建
- 指挥者Director ：调用建造者部件构造和组装创建，一般不涉及产品信息
5builder.png
产品角色 product
public class CDAProduct{
private Map zbdataMap;
private List> cbdataList;
private String cdaXml="";
public setZbdataMap(Map map){
this.zbdataMap=map;
}
public setCbdataList(List list){
this.cbdataList=list;
}
public setcdaXml(String xml){
this.cdaXml=xml;
}
public String show(){
return cdaXml;
}
}
抽象建造者
abstract Builder {
private CdaProduct cda= new CdaProduct();
public CdaProduct buidZdataMap();
public CdaProduct buidCbdataList();
publict CdaProduct buidCdaXml();
publict CdaProduct getResult(){
return cda;
}
}
具体建造者
class ConcreteBuilder extends Builder{
publict CdaProduct buidZbdataMap(){
Map map=new HashMap<>;
cda.setDataMap(map);
reutrn cda;
}
public CdaProduct buidCbdataList(){
List> list= new ArraryList<>;
cda.setCbdataList(list);
return cda;
}
public String buildCdaXml(){
return "";
}
}
指挥者 Director
public class Director {
private Builder builder;
public Director(Builder builder){
this.builder=builder;
}
public CdaProduct conCrete(){
builder.buildZbdataMap();
builder.buildCbdataList();
builder.buildCdaXml();
return builder.getResult();
}
}
客户类
建造者模式，适合产品各部分变化较大，组合一起算法相对稳定，产品的构建过程和最终的结果独立的。
public class TestBuilder{
public static void main(String[] args){
Builder builderA=new ConcreteBuilder();
Director director =new Director(builderA);
CdaProduct cda=director.conCrete();
cda.getCdaXml();
}
}