java设计模式之工厂模式

gof设计模式之工厂模式大致分为3中方式：

A 简单工厂模式

B 工厂方法模式

C 抽象工厂模式

A 简单工厂模式：整个模式以工厂类为核心，由工厂类实现指定类型的对象的创建.

方便之处见图：

代码实现：

//水果

interface Friut{
    public Friut get();
}

//苹果
class Apple implements Friut{
    public Friut get(){
        return new Apple();
    }
}

//橘子
class Orange implements Friut{
    public Friut get(){
        return new Orange();
    }
}

//香蕉
class Banana implements Friut{
    public Friut get(){
        return new Banana();
    }
}

//水果厂
class FriutFactory{
    public static Friut make(Friut friut){
        return friut.get();
    }
}

//水果店
class FriutShop{
    public static Friut take(String name){
        if("apple".equals(name)){
            return FriutFactory.make(new Apple());
        }else if("orange".equals(name)){
            return FriutFactory.make(new Orange());
        }else if("banana".equals(name)){
            return FriutFactory.make(new Banana());
        }else{
            System.out.println("暂时没该水果供售");
            return null;
        }
    }

    public static void main(String[] args){
        System.out.println("进入商店买水果:");
        take("apple");
        take("banana");
        take("orange");
    }


}

B 工厂方法模式

从上面的简单工厂可以看出，如果只是简单的几种类别需要产出，那还是很方便的，要是水果店要卖个1000中水果，那工厂里面可是一大堆的逻辑判断了..由此引出工厂方法模式

工厂方法模式：核心工厂类不再负责对象的创建，将创建具体的对象延迟到具体的工厂类中，核心工厂类只负责子工厂类必须实现的接口，而屏蔽创建的细节.

这样就是水果点业务扩大，品种齐全了，实行专一生产.看着比简单工厂就是正规点

代码实现：

interface Friut{
    public Friut get();
}
class Apple implements Friut{
    public Friut get(){
        return new Apple();
    }
}
class Orange implements Friut{
    public Friut get(){
        return new Orange();
    }
}
class Banana implements Friut{
    public Friut get(){
        return new Banana();
    }
}
interface FriutFactory{
    public Friut makeFriut();
}
class AppleFactory implements FriutFactory{
    @Override
    public Friut makeFriut() {
        return new Apple();
    }  
}
class OrangeFactory implements FriutFactory{
    @Override
    public Friut makeFriut(){
        return new Orange();
    }
}
class BananaFactory implements FriutFactory{
    @Override
    public Friut makeFriut() {
        return new Banana();
    }
  
}

class FriutShop{
    public static Friut take(FriutFactory factory){
        return factory.makeFriut();
    }  
    public static void main(String[] args){
        System.out.println("进入商店买水果:");
        take(new AppleFactory());
        take(new BananaFactory());
        take(new OrangeFactory());
    }
}

C 抽象工厂方法

工厂方法已经很专一了，为什么还要抽象工厂呢？

原来水果店规模以后，已经不单单只卖某一种水果了，现在要产品成套销售(苹果+香蕉=》天天美容装)

从现在看，每个工厂都生产不同种类的产品（这里可能区分不是很明显,只是用苹果和苹果汁带表示，you can understand ?）

这是工厂方法和抽象工厂的差别，从单一对象的创建扩展了.

代码实现：

interface Friut{
    public Friut get();
}
interface Drink{
    public Drink get();
}
class AppleCider implements Drink{
    @Override
    public Drink get() {
        return new AppleCider();
    }
  
}
class Apple implements Friut{
    public Friut get(){
        return new Apple();
    }
}


class Orange implements Friut{
    public Friut get(){
        return new Orange();
    }
}
class OrangeCider implements Drink{
    @Override
    public Drink get() {
        return new OrangeCider();
    }
}

class BananaCider implements Drink{
    @Override
    public Drink get() {
        return new BananaCider();
    }
}
class Banana implements Friut{
    public Friut get(){
        return new Banana();
    }
}
interface ShopFactory{
    public Friut makeFriut();
    public Drink makeDrink();
}
class AppleFactory implements ShopFactory{
    @Override
    public Friut makeFriut() {
        return new Apple();
    }

    @Override
    public Drink makeDrink() {
        return new AppleCider();
    }
  
}
class OrangeFactory implements ShopFactory{
    @Override
    public Friut makeFriut(){
        return new Orange();
    }

    @Override
    public Drink makeDrink() {
        return new OrangeCider();
    }
}
class BananaFactory implements ShopFactory{
    @Override
    public Friut makeFriut() {
        return new Banana();
    }
    @Override
    public Drink makeDrink() {
        return new BananaCider();
    }
}

class FriutShop{
    public static String take(ShopFactory factory){
        System.out.println("要是有个有个名字该多好啊.一定记住是一族产品");
        return factory.makeFriut().toString() + factory.makeDrink().toString();
    }  
    public static void main(String[] args){
        System.out.println("进入商店买水果:");
        take(new AppleFactory());
        take(new BananaFactory());
        take(new OrangeFactory());
    }
}

就假设果汁和对应的水果做组合套吧..

这是我的一些理解..要是有问题的话请you 指出啊.

http://blog.csdn.net/maomaolingyu/archive/2010/07/27/5768835.aspx