java的设计模式之工厂

        设计模式是前人将一些类似的问题加以总结，从而衍生出的一系列的解决方案。我们在平时开发的过程中遇到类似的问题直接进行套用就可以了，这样极大的节省了我们的思考时间，所以设计模式还是要好好学习一下。并且很多java常用的开发框架也都是使用了各种各样的设计模式，学习设计模式也可以让我们更好的理解这些开发框架，从而我们也能写出类似的框架出来。

简单工厂模式

1. 目的 
        工厂模式就是专门负责将大量有共同接口的类实例化,而且不必事先知道每次是要实例化哪一个类的模式。它定义一个用于创建对象的接口，由子类决定实例化哪一个类。

2 . 简单工厂模式的结构 

    a、工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑。在java中它往往由一个具体类实现。
    b、抽象产品角色：它一般是具体产品继承的父类或者实现的接口。在java中由接口或者抽象类来实现。
    c、具体产品角色：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。

3. 一个简单例子
java 代码

// 产品接口         
public interface Product {   
  
    public void getName();   
  
}   
  
// 具体产品A   
public class ProductA implements Product {   
  
    public void getName() {   
        System.out.println("  I am ProductA  ");   
    }   
  
}   
  
// 具体产品B   
public class ProductB implements Product {   
  
    public void getName() {   
        System.out.println("  I am ProductB  ");   
    }   
  
}   
  
// 工厂类   
public class ProductCreator {   
  
    public Product createProduct(String type) {   
        if (" A ".equals(type)) {   
            return new ProductA();   
        }   
        if (" B ".equals(type)) {   
            return new ProductB();   
        } else  
            return null;   
    }   
  
    public static void main(String[] args) {   
        ProductCreator creator = new ProductCreator();   
        creator.createProduct(" A ").getName();   
        creator.createProduct(" B ").getName();   
    }   
}

4. 小结工厂模式的适用范围 
在编码时不能预见需要创建哪一种类的实例。 
一个类使用它的子类来创建对象。 
开发人员不希望创建了哪个类的实例以及如何创建实例的信息暴露给外部程序。  
 
抽象工厂模式 
1. 抽象工厂模式可以说是简单工厂模式的扩展，它们主要的区别在于需要创建对象的复杂程度上。 
在抽象工厂模式中，抽象产品可能是一个或多个，从而构成一个或多个产品族。 在只有一个产品族的情况下，抽象工厂模式实际上退化到工厂方法模式。 
2. 抽象工厂模式的结构 

     a、系统中有多个产品族，而系统一次只可能消费其中一族产品
     b、同属于同一个产品族的产品一起使用时。
           来看看抽象工厂模式的各个角色（和工厂方法的如出一辙）：
           抽象工厂角色：这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。
           具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。在java中它由具体的类来实现。
           抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。
           具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。

           抽象工厂这块不太好理解，如果你是在不明白的话建议下载一些java视频教程来看下就会比较容易明白了。

3. 一个简单例子
java 代码

//  产品 Plant接口         
public interface Plant {   
}   
  
// 具体产品PlantA，PlantB   
public class PlantA implements Plant {   
  
    public PlantA() {   
        System.out.println(" create PlantA ! ");   
    }   
  
    public void doSomething() {   
        System.out.println("  PlantA do something  ");   
    }   
}   
  
public class PlantB implements Plant {   
    public PlantB() {   
        System.out.println(" create PlantB ! ");   
    }   
  
    public void doSomething() {   
        System.out.println("  PlantB do something  ");   
    }   
}   
  
// 产品 Fruit接口   
public interface Fruit {   
}   
  
// 具体产品FruitA，FruitB   
public class FruitA implements Fruit {   
    public FruitA() {   
        System.out.println(" create FruitA ! ");   
    }   
  
    public void doSomething() {   
        System.out.println("  FruitA do something  ");   
    }   
}   
  
public class FruitB implements Fruit {   
    public FruitB() {   
        System.out.println(" create FruitB ! ");   
    }   
  
    public void doSomething() {   
        System.out.println("  FruitB do something  ");   
    }   
}   
  
// 抽象工厂方法   
public interface AbstractFactory {   
    public Plant createPlant();   
  
    public Fruit createFruit();   
}   
  
// 具体工厂方法   
public class FactoryA implements AbstractFactory {   
    public Plant createPlant() {   
        return new PlantA();   
    }   
  
    public Fruit createFruit() {   
        return new FruitA();   
    }   
}   
  
public class FactoryB implements AbstractFactory {   
    public Plant createPlant() {   
        return new PlantB();   
    }   
  
    public Fruit createFruit() {   
        return new FruitB();   
    }   
}

4. 小结 
在以下情况下，应当考虑使用抽象工厂模式。 
　　首先，一个系统应当不依赖于产品类实例被创立，组成，和表示的细节。这对于所有形态的工厂模式都是重要的。 
　　其次，这个系统的产品有多于一个的产品族。 
　　第三，同属于同一个产品族的产品是设计成在一起使用的。这一约束必须得在系统的设计中体现出来。 
　　最后，不同的产品以一系列的接口的面貌出现，从而使系统不依赖于接口实现的细节。 

　　其中第二丶第三个条件是我们选用抽象工厂模式而非其它形态的工厂模式的关键性条件。

其实用过spring的同学肯定深有体会，我们将对象的创建过程全部交给spring来管理，而spring就是一个大工厂，我们需要什么样的对象，直接找spring拿就是了，极大的节省了开发中一些繁琐的步骤。

设计模式需要我们掌握其原理，做到手中无剑心中有剑即可。

如果对单例模式不了解的同学可以看下这篇博客

设计模式之单例模式：http://blog.csdn.net/savagegarden5/article/details/42237983 

本文出自 “爱编程” 博客，请务必保留此出处http://coder5.blog.51cto.com/6032091/1597653