Java 设计模式-工厂模式

Java 设计模式-工厂模式

工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。

工厂模式在《Java与模式》中分为三类：
1）简单工厂模式（Simple Factory）：
2）工厂方法模式（Factory Method）：
3）抽象工厂模式（Abstract Factory）：

简单工厂模式

简单工厂模式又称静态工厂方法模式。定义一个用于创建对象的接口。简单工厂模式有一下三个部分组成：

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

简单工厂模式的UML 如下：

Java 代码如下：

//工厂类

   public static Animal getAnimal(Class type) {
      //reflector
      try {
         return  (Animal)type.newInstance();
      } catch (Exception e) {
         e.printStackTrace();
      }
      return null;
   }
}

// 抽象产品角色

public abstract class Animal {
   public abstract void describe();
}

// 具体产品角色

public class Human extends Animal {
   public Human(){
      System.out.println("Human");
   }
   @Override
   public void describe() {
      System.out.print("Human describe");
   }
}
public class Cat extends Animal {
   public Cat() {
      System.out.println("Cat");
   }
   @Override
   public void describe() {
      System.out.print("Cat describe");
   }
}

//测试类

public class Client {
   public static void main(String[] args) {
      Animal y = AnimalFactory.getAnimal(Human.class);
      y.describe();
   }
}

打印如下：

Human
Human describe

工厂方法模式

工厂方法模式是简单工厂模式的进一步抽象化和推广，工厂方法模式里不再只由一个工厂类决定那一个产品类应当被实例化,这个决定被交给抽象工厂的子类去做。
工厂方法模式有以下四个部分组成：

1)抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。

2)具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。

3)抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。

4)具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。
工厂方法模式使用继承自抽象工厂角色的多个子类来代替简单工厂模式中的工厂类。

工厂方法模式UML 如下：

代码：

//抽象产品角色

public interface Animal {
   public void identity();
}

//具体产品角色

public class Cat implements Animal {
   @Override
   public void identity() {
      System.out.println("Cat Class");
   }
}
public class Dog implements Animal {
   @Override
   public void identity() {
      System.out.println("Dog Class");
   }
}

//抽象工厂

public interface AnimalCreator {
   public Animal creatAnimal();
}

//具体工厂

public class CatCreator implements AnimalCreator {
   @Override
   public Animal creatAnimal() {
      return new Cat();
   }
}
public class DogCreator implements AnimalCreator {
   @Override
   public Animal creatAnimal() {
      return new Dog();
   }
}

//测试类

public class Client {
   public static void main(String[] args) {
      AnimalCreator animalCreator = new DogCreator();
      Animal animal = animalCreator.creatAnimal();
      animal.identity();
   }
}

抽象工厂模式

抽象工厂模式为创建一组对象提供了一种解决方案。与工厂方法模式相比，抽象工厂模式中的具体工厂不只是创建一种产品，它负责创建一族产品。

UML

代码如下：

// 创建产品类

public abstract class SystemFactory {
   //public SystemFactory getSytem();
   FileSystem fileSystem;
   ProgramLanguage programLanguage;
   public void getFileSystem(){
      System.out.println(fileSystem.getFileSystemName());
   }
   public void getProgramLanguage(){
      System.out.println(programLanguage.getProgramLanguage());
   }
}

// 具体的工厂类 1

   public Windows(){
      fileSystem=new NTFS();
      programLanguage=new Cmd();
   }
}

// 具体的工厂类2

public class Linux extends SystemFactory{

   public Linux(){
      fileSystem=new Ext3();
      programLanguage=new Shell();
   }
}

// 抽象产品接口A

public abstract class ProgramLanguage {
   public String getProgramLanguage(){
      return this.getClass().toString();
   }
}

// 抽象产品接口B

public abstract class FileSystem {
   public String getFileSystemName(){
      return this.getClass().toString();
   }
}

//测试类

public class Client {
   public static void main(String[] args) {
      SystemFactory win = new Windows();
      win.getFileSystem();
      win.getProgramLanguage();

      SystemFactory linux = new Linux();
      linux.getFileSystem();
      linux.getProgramLanguage();
   }
}