【笔记】面向对象设计模式

今天参加公司的学习会，学了几种设计模式，稍微回忆一下，并且自己找了一些补充资料进一步加深理解。

Singleton模式（单例模式）

看字面的意思就知道，一个类Class只有一个实例存在。单例模式的好处就是它限制了实例的个数，有利于节约内存，方便java回收。

它的写法也很简单，一看就懂。

public class Singleton{
   private static Singleton instance = null;
　　
　　private void Singleton(){
   }

　　public static synchronized Singleton getInstance(){
　　　 if(instance == null){
　　　　　　instance = new Singleton();
　　　　}　
　　　　return instance;

　　}
}

 

 

Factory模式（工厂模式）

工厂模式也同样简单，它相当于new实例化，只不过是将new进行封转，从而更方便扩展。

举个栗子，比方说要生成一个Product之前要做许多初始化工作，如果每次生成Product之前都要写这些初始化（init），会显得很繁琐，所以可以将init+new Product()封装成一个单独的类，以提高代码的重用性，减少耦合性。

Product也可能是一个接口，在Product的基础上会衍生出不同的Product子类出来。

比如：

interface  IProduct(){}

class ProductA implements Product(){}
class ProductB implements Product(){}

这样在使用这些子类的时候，就需要讲这些子类一一实例化。

Product A = new ProductA();
Product B = new ProductB();

如此一来就不方便对Product的扩展。因此我们就可以在Factory 中对Product进行再次封装。

public Factory {

　　public static create(int i){
　　　　Product result=null;
　　　　switch(i){
　　　　　　case 1:new ProductA();break;
　　　　　　case 2:new ProcuctB();break;
　　　　}
　　　　return result;
　　}
}

Abstract Factory模式（抽象工厂模式）

抽象工厂模式其实是对上面所诉的工厂模式做进一步的抽象，适用于更加复杂的结构模式中。

在工厂模式中，我们仅仅是对Product进行实例化，那如果还要对Student，Teacher等完全不一样的类进行实例化时又该如何呢？

假如将所有的实例化都放在同一个工厂模式里面，想想都觉得这样的结构非常不清晰。因此针对完全不一样的类，我们可以在不同的工厂中进行实例化，并且将这些工厂类抽象到一个类中进行管理。

比如说

public abstract class Factory{

　　public abstract Sample creator();

　　public abstract Sample2 creator(String name);

}

public class SimpleFactory extends Factory{

　　public Sample creator(){
　　　　.........
　　　　return new SampleA
　　}

　　public Sample2 creator(String name){
　　　　.........
　　　　return new Sample2A
　　}

}

public class BombFactory extends Factory{

　　public Sample creator(){
　　　　......
　　　　return new SampleB 
　　}

　　public Sample2 creator(String name){
　　　　......
　　　　return new Sample2B
　　}

}