简单工厂模式
对于工厂模式,原先发现自己其实了解的很抽象,或者说很肤浅而已。有种一叶蔽目,不见泰山的感觉的吧。其实对于这个模式有些东西根本就没有一个全面的概念吧。
最初的一种印象就是如下所示:
package demo05;
public class FactoryDemo01 {
public static void main(String args []) throws Exception{
Fruit apple = FruitFactory.createFruit("apple");
Fruit orange = FruitFactory.createFruit("orange");
Fruit banana = FruitFactory.createFruit("banana");
if(apple != null){
apple.getName();
}
if(orange !=null){
orange.getName();
}
if(banana != null){
banana.getName();
}
}
}
interface Fruit{
public void getName();
}
class Apple implements Fruit{
public void getName(){
System.out.println("apple...");
}
}
class Orange implements Fruit{
public void getName(){
System.out.println("orange...");
}
}
class FruitFactory{
public static Fruit createFruit(String type) throws Exception{
if("apple".equalsIgnoreCase(type)){
return Apple.class.newInstance();
}else if("orange".equalsIgnoreCase(type)){
return Orange.class.newInstance();
}else{
System.out.println("没有找到相应的产品");
return null;
}
}
}
程序运行结果为:
这还是在一次面试中,我在讲这种工厂模式的时候,面试官让我说什么叫抽象工厂模式,我才傻了眼,才知道其实对于工厂模式中其实还是又有好几种。回来后慢慢查资料,才知道其实上面这种工厂模式又被称为简单工厂模式(Simple Factory Pattern),又叫静态工厂方法模式(Static FactoryMethod Pattern),主要是通过专门定义一个类来负责创建其他类的实例。
工厂模式方法
何为工厂模式?还是从以下代码着手:
package demo06;
public class FactoryDemo02 {
public static void main(String args []){
//FruitFactory factory = new AppleFactory();
FruitFactory factory = new OrangeFactory();
Fruit fruit= factory.createFruit();
fruit.getName();
}
}
interface Fruit{
public void getName();
}
class Apple implements Fruit{
public void getName(){
System.out.println("apple...");
}
}
class Orange implements Fruit{
public void getName(){
System.out.println("orange...");
}
private Orange(){
}
private static Orange orange = new Orange();
public static Orange getInstance(){
return orange;
}
}
interface FruitFactory{
public Fruit createFruit();
}
class AppleFactory implements FruitFactory{
public Fruit createFruit() {
return new Apple();
}
}
class OrangeFactory implements FruitFactory{
public Fruit createFruit() {
return Orange.getInstance();
}
}
对于这里的代码,我们明显的可以看到。对于每一个具体的类都有着一个具体的工厂类,而这个工厂类就是负责返回此具体类的一个实例。当然如何返回一个具体类的实例,可以在具体类中加上一些控制实例化的手段,比如以上代码段,可以进行单例模式的一个控制。其实归结到底,就是一个接口类,引申出实体类。一个工厂接口,引申出具体类实现的工厂。主要类的实例化一定是通过此类所对应的工厂类来实现的。而此工厂类就是通过接口工厂类实现的。(父类的引用指向子类对象)。
抽象工厂
什么叫抽象工厂?它和工厂模式又有什么区别?请看下面的代码:
package demo07;
/*
* 比如有某个人想买一套电子设备
* 电脑:imac,y470
* 手机:iphone,MI 1S
*/
public class FactoryDemo {
public static void main(String args []){
AbstractFactory factory = new DefaultFactory();
Computer computer = factory.createComputer();
CellPhone cellPhone = factory.createCellPhone();
computer.getName();
cellPhone.getName();
}
}
interface Computer{
public void getName();
}
class Imac implements Computer{
public void getName(){
System.out.println("It's imac");
}
}
class Y470 implements Computer{
public void getName(){
System.out.println("It's y470");
}
}
interface CellPhone{
public void getName();
}
class Iphone implements CellPhone{
public void getName(){
System.out.println("It's iphone");
}
}
class MI1S implements CellPhone{
public void getName(){
System.out.println("It's MI1S");
}
}
interface AbstractFactory{
public Computer createComputer();
public CellPhone createCellPhone();
}
class DefaultFactory implements AbstractFactory{
public Computer createComputer() {
return new Y470();
}
public CellPhone createCellPhone() {
return new MI1S();
}
}
class AnotherFactory implements AbstractFactory{
public Computer createComputer() {
return new Imac();
}
public CellPhone createCellPhone() {
return new Iphone();
}
}
程序运行结果如下:
抽象工厂模式是工厂方法模式的升级版本,它用来创建一组相关或者相互依赖的对象。它与工厂方法模式的区别就在于,工厂方法模式针对的是一个产品等级结构;而抽象工厂模式则是针对的多个产品等级结构。
在抽象工厂模式中,有一个产品族的概念:所谓的产品族,是指位于不同产品等级结构中功能相关联的产品组成的家族。抽象工厂模式所提供的一系列产品就组成一个产品族;而工厂方法提供的一系列产品称为一个等级结构。
无论是简单工厂模式,工厂方法模式,还是抽象工厂模式,他们都属于工厂模式,在形式和特点上也是极为相似的,他们的最终目的都是为了解耦。在使用时,我们不必去在意这个模式到底工厂方法模式还是抽象工厂模式,因为他们之间的演变常常是令人琢磨不透的。经常你会发现,明明使用的工厂方法模式,当新需求来临,稍加修改,加入了一个新方法后,由于类中的产品构成了不同等级结构中的产品族,它就变成抽象工厂模式了;而对于抽象工厂模式,当减少一个方法使的提供的产 品不再构成产品族之后,它就演变成了工厂方法模式。所以,在使用工厂模式时,只需要关心降低耦合度的目的是否达到了。