java设计模式学习笔记（一）--- 创建型模式

电玩女神 2021-09-27 11:24 217阅读 0赞

### 文章目录 ###

*  简介
 *   *  设计模式所遵循的几个原则
 *  一、工厂方法模式
 *   *  简单工厂模式
     *  工厂方法模式
     *  抽象工厂模式
     *  工厂模式小结
 *  单例模式
 *   *  单例模式小结
 *  建造者模式
 *  原型模式
 *   *  原型模式的使用范围

# 简介 #

创建型模式，主要用于辅助创建对象。有人说创建对象很简单，只要new一下就好了，但是实际情况往往非常复杂。比如所创建的对象要经常修改、创建过程中有复杂的动态操作、对所创建的对象有特殊要求等等。这时就需要用到各种各样的创建型设计模式。

## 设计模式所遵循的几个原则 ##

1.  单一原则：一个对象只负责完成一个职责；高内聚，低耦合；
2.  开闭原则：对扩展开放，对修改关闭；对类的改动通过增加代码实现，而不是通过修改代码；
3.  里氏替换原则：任何父类对象都可使用子类进行替换；
4.  依赖注入原则：依赖于抽象，不依赖于具体实现（面向接口编程）
5.  接口分离原则：一个接口不要提供过多的行为
6.  迪米特原则：一个对象对其他对象尽可能少的依赖（降低耦合）
7.  多用组合，少用继承原则：父类的任何改变可能直接影响子类的行为。

这是网上随处可见的答案，也正是设计模式存在的原因。  
并不需要特意去记这些，好用才是真理，不符合实际情况的遵守规则反而会写出更糟糕的代码。  
当然，是否好用，如何认清实际情况才是最难的，它需要非常多的代码量与思考才能真正掌握。  
在学会这些之后，会发现，所谓规则不过是把自己一直在做的东西做了一个总结罢了，它不是一个指导规则，而是一个习惯。

# 一、工厂方法模式 #

出于方便查看的考虑，我的代码会全部写到一个java文件中，并且会尽量删除多余的代码。  
首先准备一下工厂所创建出的类。

interface IProduct{ }	//产品类接口
    class Product1 implements IProduct{ }	//产品1
    class Product2 implements IProduct{ }	//产品2
    class Product3 implements IProduct{ }	//产品3
    
    public class BlobFactoryTest { 
    
    	/** * @param args */
    	public static void main(String[] args) { 
    		// TODO Auto-generated method stub
    		IProduct aa = new Product1();
    		System.out.println(aa.getClass().getSimpleName());
    	}
    
    }

## 简单工厂模式 ##

public class BlobFactoryTest { 
    
    	public static void main(String[] args) { 
    		//IProduct aa = new Product1();
    		IProduct aa = SimpleFactory.getProduct("p1");
    		System.out.println(aa.getClass().getSimpleName());
    	}
    
    }
    
    class SimpleFactory{ 
    	public static IProduct getProduct(String type){ 
    		switch (type) { 
    		case "p1":
    			return new Product1();
    		case "p2":
    			return new Product2();
    		case "p3":
    			return new Product3();
    		default:
    			return null;
    		}
    	}
    }

简单工厂模式有最差的规范性，分支多了后调用所需的字符串很难记，还有写错的风险。  
但是这是最简单易懂的写法。小功能，或者几乎不需要扩展的功能可以一用。

## 工厂方法模式 ##

在简单工厂模式中，主要存在的问题有两个

1.  扩展时需要修改原先写好的方法。（记住：任何代码在直接修改后都可能出现新的bug）
2.  如果调用时，传入的字符串写错，会使程序出错。

工厂方法模式解决了这两个问题。  
直接上代码

输出

Product1
    Product2
    Product3

现在，每一个产品类都由单独的方法创建。扩展的时候无需修改原来的方法，只要继续添加方法就好了。并且不会出现拼写错误的情况。`MethodFatory.getProduct123()` 这种代码根本过不了编辑器的校验。

工厂方法模式应该是最常用的创建方法。代码简单，并且能应对大多数情况。

## 抽象工厂模式 ##

名字挺唬人的，其实就是在工厂类上做了个多态的处理。  
在工厂方法模式中，扩展时虽然不需要修改原来的方法，但是需要在这个工厂类中添加新的方法。这样就是对这个工厂类产生了修改。严格来说，这也是不符合规范的。  
在抽象工厂模式中，每添加一套新的产品类，就新建一个工厂类去处理。

public class BlobFactoryTest { 
    
    	public static void main(String[] args) { 
    		//IProduct aa = new Product1();
    // IProduct aa = SimpleFactory.getProduct("p1");
    // System.out.println(aa.getClass().getSimpleName());
    // System.out.println(MethodFatory.getProduct1().getClass().getSimpleName());
    // System.out.println(MethodFatory.getProduct2().getClass().getSimpleName());
    // System.out.println(MethodFatory.getProduct3().getClass().getSimpleName());
    		IFactory factory;
    		factory = new Product1AbsFactory();
    		System.out.println(factory.getProduct().getClass().getSimpleName());
    		factory = new Product2AbsFactory();
    		System.out.println(factory.getProduct().getClass().getSimpleName());
    		factory = new Product3AbsFactory();
    		System.out.println(factory.getProduct().getClass().getSimpleName());
    	}
    
    }
    
    interface IFactory{  public IProduct getProduct();}
    
    class Product1AbsFactory implements IFactory{ 
    	public IProduct getProduct() { 
    		return new Product1();
    	}
    }
    
    class Product2AbsFactory implements IFactory{ 
    	public IProduct getProduct() { 
    		return new Product2();
    	}
    }
    
    class Product3AbsFactory implements IFactory{ 
    	public IProduct getProduct() { 
    		return new Product3();
    	}
    }

输出

Product1
    Product2
    Product3

使用抽象工厂模式可以避免对原有的代码进行修改，这是更符合规范的写法，但是代码读起来比较累，对于复杂一些的抽象工厂类，修改起来很不方便。当在一些小功能上用时，更是有种杀鸡用牛刀的感觉。

## 工厂模式小结 ##

简单工厂模式、工厂方法模式、抽象工厂模式，这三种模式都是为了创建对象而存在的。在规范性上，依次递增。但这并不能说明后面的就比前面的更好，需要根据实际情况来选择使用哪种模式。

# 单例模式 #

有时候，对于一些类，我们只想让它创建一次。产生这种情况的原因很多，比如这个类的实例化所消耗的资源很大，或者这个类在逻辑上就应该只实例化一次。

通过程序组内的口头约定可以基本达成这样的目的，但是这并不保险，正确的做法是在代码上杜绝这样的可能性。

一个单例类的基本模式就是私有化构造方法，并提供一个返回自身实例的方法。

一种简单的实现方法

package blog.java.pattern.creater;
    
    public class Singleton_1 { 
    	
    	private static Singleton_1 obj = new Singleton_1();
    	
    	private Singleton_1(){ }
    	
    	private static Singleton_1 getInstance(){ 
    		return obj;
    	}
    
    }

其中可以根据情况将`new Singleton_1();` 放到静态块中。

这是最简单的方法，不过有一个小缺陷，那就是在加载这个类的同时，`obj = new Singleton_1();` 就会被加载。有时需要做一个延迟加载的机制，可以用下面的方法实现。

public class Singleton_2{ 
    	
    	private Singleton_2(){ }
    	
    	private static class SingletonBuild{ 
            private static Singleton_2 in_obj = new Singleton_2();
        }
    	
    	private static Singleton_2 getInstance(){ 
    		return SingletonBuild.in_obj;
    	}
    	
    	public static void main(String[] args) { 
    		System.out.println(Singleton_2.getInstance());
    	}
    	
    }

在java中，类中的静态对象会在类被加载后加载，而类会在第一次调用后加载。这一点对于内部静态类也是一样的。在类`Singleton_2` 被加载后，这句话`private static Singleton_2 in_obj = new Singleton_2();` 并不会被立即加载。它会在方法`getInstance` 被调用的时候再加载。这就起到了一个延迟加载的效果。  
写一个例子来验证这一点

package blog.java.pattern.creater;
    
    public class Singleton_2{ 
    	
    	static{ System.out.println("外部类加载");}
    	
    	private Singleton_2(){ }
    	
    	private static class SingletonBuild{ 
    		static{ System.out.println("内部类加载");}
            private static Singleton_2 in_obj = new Singleton_2();
        }
    	
    	private static Singleton_2 getInstance(){ 
    		return SingletonBuild.in_obj;
    	}
    	
    	public static void main(String[] args) throws ClassNotFoundException { 
    		Class.forName("blog.java.pattern.creater.Singleton_2");
    		Singleton_2.getInstance();
    	}
    	
    }

第三种写法

public class Singleton_2{ 
    	
    	static{ System.out.println("外部类加载");}
    	
    	private Singleton_2(){ }
    	
    	private static class SingletonBuild{ 
    		static{ System.out.println("内部类加载");}
            private static Singleton_2 in_obj = new Singleton_2();
        }
    	
    	private static Singleton_2 getInstance(){ 
    		return SingletonBuild.in_obj;
    	}
    	
    	public static void main(String[] args) throws ClassNotFoundException { 
    // Class.forName("blog.java.pattern.creater.Singleton_2");
    // Singleton_2.getInstance();
    		
    		SingletonEnumTest.INSTANCE.aaa();
    	}
    	
    }
    
    enum SingletonEnumTest{ 
    	INSTANCE;
    	public void aaa(){ System.out.println("aaa");}
    }

利用了enum 。这是很好地写法，不过从来没见过这么写的。

最后一种写法：利用同步锁来实现。不过我不想介绍这种写法。它最难写，最容易写错，所实现的功能却是一样的，我为什么要用它？

## 单例模式小结 ##

单例模式是目的性最强的一个设计模式，它通过java语言本身的一些特性来实现这个需求。我个人觉得，与其说它是一个模式，不如说它是一种技巧更容易让人理解。

# 建造者模式 #

如果对象在创建的过程中存在多种复杂的操作，并且每种操作中存在着共性，可以考虑使用建造者模式。

它的实现方式简单描述一下就是：客户程序员通过一个导演类来创建对象，导演类需要外部接收创建规则。创建中的复杂操作全部在导演类中完成。也就是说，不管这个对象的创建有多复杂，我都可以不去理会。

package blog.java.pattern.creater.builder;
    
    public class BuilderTest { 
    
    	public static void main(String[] args) { 
    		System.out.println(new Director(new Builder1()).getProduct());
    	}
    
    }
    
    interface IProduct{ }	//产品类接口
    class Product1 implements IProduct{ }	//产品类
    //规则接口
    interface IBuilder{ 
    	public void doSomeThing1();
    	public void doSomeThing2();
    }
    //创建规则1
    class Builder1 implements IBuilder{ 
    	public void doSomeThing1() { 
    		System.out.println("Builder1 doSomeThing1");
    	}
    	public void doSomeThing2() { 
    		System.out.println("Builder1 doSomeThing2");
    	}
    }
    //创建规则2
    class Builder2 implements IBuilder{ 
    	public void doSomeThing1() { 
    		System.out.println("Builder2 doSomeThing1");
    	}
    	public void doSomeThing2() { 
    		System.out.println("Builder2 doSomeThing2");
    	}
    }
    //导演类
    class Director{ 
    	IBuilder builder;
    	public Director(IBuilder builder){ 
    		this.builder = builder;
    	}
    	public IProduct getProduct(){ 
    		this.builder.doSomeThing1();
    		this.builder.doSomeThing2();
    		return new Product1();
    	}
    }

# 原型模式 #

简单来说，就是将一个对象复制。然后，没了…  
代码

public class Product implements Cloneable{ 
    
    	@Override
    	protected Object clone() throws CloneNotSupportedException { 
    		// TODO Auto-generated method stub
    		return super.clone();
    	}
    
    }

如果说单例模式是一连串的语法组成的技巧，那原型模式就只是一个语法。  
在克隆对象的时候还是要考虑一下浅拷贝之类的问题的，不过这不在设计模式的讨论范围之内。

## 原型模式的使用范围 ##

基本就是在需要拷贝的时候用。

1.  创建对象需要消耗许多额外的资源（比如需要查询一个耗资源的sql）。
2.  对象需要在多线程中使用。
3.  这个对象在经过一连串的操作后，需要复制一份到别处使用，毕竟不可能重新模拟一遍已经做过的一连串操作吧。