工厂模式（简单工厂模式， 工厂方法模式， 抽象工厂模式）二

看了上一篇博客内容，我们就应该理解一些那三种工厂设计模式了。现在我们来做一些总结！

首先总结简单工厂模式：

简单工厂模式的特点是工厂为一个实体类，没有继承任何接口，并且所有的工作都是在一个静态方法中去做！以制造水果为例子，

有代码如下：

首先是水果接口定义：

public interface FruitInterface {
public void taste();
}

然后是两种不同水果的定义

1 苹果的定义

public class AppleFruit implements FruitInterface{


@Override
public void taste() {
// TODO Auto-generated method stub
System.out.println("苹果的味道！");
}


}

2香蕉的定义

public class BananaFruit implements FruitInterface{


@Override
public void taste() {
// TODO Auto-generated method stub
System.out.println("香蕉的味道！");
}


}

然后是工厂的定义了，注意，这个工厂类没有继承任何其他类

public class Factory {
public static FruitInterface CreateFruite(String fruitName) {   //工厂用一个静态方法做了所有的事情
if(fruitName.equals("Banana"))
{
return new BananaFruit();
}
else if(fruitName.equals("Apple"))
{
return new AppleFruit();
}
return null;
}
}

测试代码：

public class FactoryMode {

public static void main(String[] args)
{
Factory factory = new Factory();
FruitInterface fruitA;
fruitA = factory.CreateFruite("Apple");
FruitInterface fruitB;
fruitB = factory.CreateFruite("Banana");
fruitA.taste();
fruitB.taste();
}
}

测试结果：

苹果的味道！
香蕉的味道！

然后我们开始总结第二种工厂模式， 工厂方法模式！

简单工厂模式其实几乎已经能做很多事情了，但是，工厂貌似很固执，是一个定义好的不能改变了的类，我们会遇到什么样的问题呢？

如果我们需要制造很多种类的产品，那么最好是同种类的产品用同一个工厂去制造，这样才有层次感，并且分工合理！如果只有简单

工厂模式的话，那么我们就会把事情做的很乱，你想想，你用简单工厂模式只有两种方法，要么把一个工厂写的很复杂，要么去定义很多

不同种类的工厂，都显得有些乱！我们看看自己的代码是如何实现的：

先定义工厂接口，定义工厂功能

public interface FruitInterface {
public void taste();
}

定义水果接口，定义了水果的属性

public interface FruitInterface {
public void taste();
}

定义了“苹果”这种水果

public class AppleFruit implements FruitInterface{


@Override
public void taste() {
// TODO Auto-generated method stub
System.out.println("苹果的味道！");
}

}

定义了“香蕉”这种水果

public class BananaFruit implements FruitInterface{


@Override
public void taste() {
// TODO Auto-generated method stub
System.out.println("香蕉的味道！");
}


}

定义生产苹果的工厂

public class AppleFactory implements FactoryInterface{


@Override
public FruitInterface createFruit() {
// TODO Auto-generated method stub
return new AppleFruit();
}


}

定义生产香蕉的工厂

public class BananaFactory implements FactoryInterface{


@Override
public FruitInterface createFruit() {
// TODO Auto-generated method stub
return new BananaFruit();
}

}

进行测试：

public class FactoryMethodMode {
public static void main(String[] args)
{
FactoryInterface appleFactory = new AppleFactory();
FactoryInterface bananaFactory = new BananaFactory();
FruitInterface fruitApple;
FruitInterface fruitBanana;

fruitApple = appleFactory.createFruit();
fruitBanana = bananaFactory.createFruit();

fruitApple.taste();
fruitBanana.taste();

}
}

测试结果：

苹果的味道！
香蕉的味道！

可以看出，工厂方法模式通过定义了一个抽象的工厂模型（即 工厂接口）增加了产品的层次感，当种类繁多的时候，不会显得混乱！

接着，我们再来总结最后一种工厂模式， 抽象工厂模式

首先我们需要明白抽象工厂模式是为了解决什么样的问题而设计的，通过上一篇转载的博客内容，看到了它是为了解决生产不同产品

的一个组合的工厂，（其实你说也怪，我觉得只需要在上一个工厂方法中增加一个函数不就可以了嘛，反正我觉得跟上一个模式没啥

太大的区别，不过还是需要用代码验证去感受一下）。

写代码的时候才发现，才真正感觉到抽象工厂模式的好处，比如，你东北的工厂出来的东西肯定都是东北特色的，无论是蔬菜还是水果；你西南的工厂出来的东西肯定都是西南特色的，无论是蔬菜还是水果。其实，抽象工厂的实现很简单，就是把工厂和同类产品（比如，水果为一类，蔬菜为一类，但是水果和蔬菜都有东北的和西南的）都抽象出来，然后在工厂的一个实现类中实现两个不同 的方法而已，理论上看起来的确没什么，但是，你真正自己去写一遍自己i的抽象工厂模式的时候，真的，感觉很爽，很舒服，东北工厂里的东西出来的都是东北的，西南工厂里出来的东西都是西南的，让人思路很清晰。上代码吧，这里用热带和寒带来打比方！（注：tropical，热带；frigid，寒带）

抽象出水果

public interface FruitInterface {
public void testate();
}

抽象出蔬菜

public interface VegetablesInterface {
public void testate();
}

//定义出热带水果

public class TropicalFruit implements FruitInterface{


@Override
public void testate() {
// TODO Auto-generated method stub
System.out.println("热带水果有点热");
}


}

//定义出热带蔬菜

public class TropicalVegetables implements VegetablesInterface{


@Override
public void testate() {
// TODO Auto-generated method stub
System.out.println("热带蔬菜有点热！");
}

}

//定义出寒带水果

public class FrigidFruit implements FruitInterface{


@Override
public void testate() {
// TODO Auto-generated method stub
System.out.println("寒带水果有点凉！");
}


}

//定义出寒带蔬菜

public class FrigidVegetables implements VegetablesInterface{


@Override
public void testate() {
// TODO Auto-generated method stub
System.out.println("寒带蔬菜有点凉！");
}


}

//开始定义热带的工厂，肯定只能生产出热带的东西了

public class TropicalFactory implements FactoryInterface{


@Override
public FruitInterface createFruit() {
// TODO Auto-generated method stub
return new TropicalFruit();
}


@Override
public VegetablesInterface createVegt() {
// TODO Auto-generated method stub
return new TropicalVegetables();
}


}

//开始构造寒带的工厂，肯定只能生产寒带的东西了

public class FrigidFactory implements FactoryInterface{


@Override
public FruitInterface createFruit() {
// TODO Auto-generated method stub
return new FrigidFruit();
}


@Override
public VegetablesInterface createVegt() {
// TODO Auto-generated method stub
return new FrigidVegetables();
}


}

测试代码：

public class AbstractFactoryMode {
public static void main(String[] args)
{
FactoryInterface tropicalFactory = new TropicalFactory();
FactoryInterface frigidFactory = new FrigidFactory();

FruitInterface tropicalFruit;
VegetablesInterface tropicalVeg;

FruitInterface frigidFruit;
VegetablesInterface frigidVeg;
//热带工厂开始工作（生产出来的肯定都是热带的东西）
tropicalFruit = tropicalFactory.createFruit();
tropicalVeg = tropicalFactory.createVegt();
//寒带工厂工作（生产出来的肯定都是寒带东西）
frigidFruit = frigidFactory.createFruit();
frigidVeg = frigidFactory.createVegt();
//热带东西怎么样？
tropicalFruit.testate();
tropicalVeg.testate();
//寒带东西怎么样？
frigidFruit.testate();
frigidVeg.testate();
}
}

测试结果：

热带水果有点热
热带蔬菜有点热！
寒带水果有点凉！
寒带蔬菜有点凉！

结论，的确是，有些东西看是看不出来什么东西的，要去动手感觉！这里我没有弄出几个UML图来，的确是一个自己没装这个软件，还有就是今天的确有点晚了。不过，我找到了一篇博客非常好，在我的第三篇博客中已经转来来了，大家看看那里的图就全明白了！