工厂模式的理解

参考资料

http://blog.csdn.net/jason0539/article/details/23020989
http://blog.csdn.net/lmj623565791/article/details/24460585

使用场景

当一些对象构建十分复杂，而使用者想要直接拿到对象而不关注对象的创建过程时，可以使用工厂模式。对象的创建由工厂完成，用户通过工厂拿到对象，不关注创建的过程。

工厂模式分类

1.静态工厂模式

public class BitmapUtils { 
   public static Bitmap zoomImg(String img, int newWidth, int newHeight) {/
/ 图片源   
     Bitmap bm = BitmapFactory.decodeFile(img);    
    if (null != bm) {      
      return zoomImg(bm, newWidth, newHeight);       
 }       
 return null;    
}

2.工厂方法模式
工厂方法模式中有一种特殊的模式 ****简单工厂模式****
(1).一个抽象产品类，可以派生出多个具体产品类。

abstract class BMW {  
    public BMW(){  
          
    }  
}  
  
public class BMW320 extends BMW {  
    public BMW320() {  
        System.out.println("制造-->BMW320");  
    }  
}  
public class BMW523 extends BMW{  
    public BMW523(){  
        System.out.println("制造-->BMW523");  
    }  
}

(2).一个工厂类负责创建对象的过程，外部通过该类拿到对象

public class Factory {  
    public BMW createBMW(int type) {  
        switch (type) {      

       case 320:  
            return new BMW320();  
       case 523:  
            return new BMW523();  
        default:  
            break;  
        }  
        return null;  
    }  
}  
当然也可以通过反射的方式生成产品对象
public class Factory {  
    public  T createBMW(Class clazz) {  
        BMW product=(BMW)Class.forName(clazz.getName()).newInstance();
        return (BMW)product;  
    }  
}
简单工厂模式的弊端：每增加一种新的车型，就要修改Factroy的switch对象。对于Factory对象来说不符合开闭原则，因此
有了工厂方法模式。

二、工厂方法模式.

1.抽象的产品类
2.抽象的工厂类，每个产品由一个工厂类负责。
3.每一个工厂负责一种产品的生产
优势：工厂方法模式去掉了简单工厂模式中工厂方法的静态属性，使得它可以被子类继承。这样在简单工厂模式里集中在工厂方法上的压力可以由工厂方法模式里不同的工厂子类来分担。
工厂方法的弊端：当产品类不断增加时，对应的工厂类也不断增加

1.抽象的产品类
abstract class BMW {  
    public BMW(){  
          
    }  
}  
public class BMW320 extends BMW {  
    public BMW320() {  
        System.out.println("制造-->BMW320");  
    }  
}  
public class BMW523 extends BMW{  
    public BMW523(){  
        System.out.println("制造-->BMW523");  
    }  
}

2.抽象的工厂，每个产品的创建对应一个工厂。
interface FactoryBMW {  
    BMW createBMW();  
}  
  
public class FactoryBMW320 implements FactoryBMW{  
  
    @Override  
    public BMW320 createBMW() {  
  
        return new BMW320();  
    }  
  
}  
public class FactoryBMW523 implements FactoryBMW {  
    @Override  
    public BMW523 createBMW() {  
  
        return new BMW523();  
    }  
}

3.抽象工厂

当工厂需要生产多种产品时，根据产品的特点，自身代码构建的需求，将具有同种特征的产品放到一个工厂下。该工厂创建多种产品，下面例子的工厂方法根据平台是android还是ios来分类。

抽象工厂使用场景：适合多种产品（每种产品实现的方式不同）提供给不同的场景使用时，可以用抽象工厂。

http://blog.csdn.net/jason0539/article/details/44976775

抽象工厂的使用

1.定义要实现的产品

public abstract class Button{
    public abstract  void  btn();
 }
public abstract class TextView{
    public abstract  void  textview();
 }
public class AndroidButton extends Button{
    public void  btn(){
       //这是Android平台下的button
    }
 }
public class IOSButton extends Button{
    public void  btn(){
       //这是IOS平台下的button
    }
 }
public class AndroidTextView extends TextView{
    public void  textview(){
       //这是Android平台下的TextView
    }
 }
public class IOSTextView extends TextView{
    public void  textview(){
       //这是IOS平台下的TextView
    }
 }

2.针对不同的使用场景提供工厂方法，抛出对象

 public abstract Factory{
    public abstract TextView getText（）；
    public abstract Button button(); 
 }

 public class AndroidFactory extends Factory{
    publict TextView getText（）{
       return new AndroidTextView ();
    }；
    public  Button button(){
         return new AndroidButton();
       }; 
 }

 public class IOSFactory extends Factory{
    publict TextView getText（）{
       return new IOSTextView ();
    }；
    public  Button button(){
         return new IOSButton();
       }; 
 }