设计模式---工厂模式

工厂方法：

定义一个用于创建对象的接口，让子类决定实例化哪一个类。FactoryMethod 使一个类的实例延迟到其子类。

适用性：
1.当一个类不知道它所必须创建的对象的类的时候。

2.当一个类希望由它的子类来指定它所创建的对象的时候。

3.当将创建对象的职责委托给多个帮助类中的某一个，并且希望将哪一个帮助子类是代理者这一信息局部化的时候。

参与者：
1.Product 定义工厂方法所创建的对象的接口。

2.ConcreteProduct 实现 Product 接口。

3.Creator 声明工厂方法，该方法返回一个 Product 类型的对象 Creator 也可以定义一个工厂方法的缺省实现，它返回一个缺省的 ConcreteProduct 对象。 可以调用工厂方法以创建一个 Product 对象。

4.ConcreteCreator 重定义工厂方法以返回一个 ConcreteProduct 实例。

类图：

例子：

Product 

public interface Work { 
 
    void doWork();
 }

ConcreteProduct  
 
public class StudentWork implements Work { 
 
    public void doWork() {
             System.out.println("学生做作业!");
         } 
} 
 
public class TeacherWork implements Work { 
 
    public void doWork() {
             System.out.println("老师审批作业!");
         } 
}

Creator  
 
public interface IWorkFactory { 
 
    Work getWork();
 }

ConcreteCreator  
 
public class StudentWorkFactory implements IWorkFactory { 
 
    public Work getWork() {
             return new StudentWork(); 
         } 
} 
 
public class TeacherWorkFactory implements IWorkFactory { 
 
    public Work getWork() {
             return new TeacherWork();
        }
} 

Test  
 
public class Test { 
 
    public static void main(String [] args) {
             IWorkFactory studentWorkFactory = new StudentWorkFactory();
             studentWorkFactory.getWork().doWork();
             IWorkFactory teacherWorkFactory = new TeacherWorkFactory();         
             teacherWorkFactory.getWork().doWork();
        } 
}

result  
 
学生做作业!
老师审批作业!

抽象工厂：

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

适用性：

1.一个系统要独立于它的产品的创建、组合和表示时。

2.一个系统要由多个产品系列中的一个来配置时。

3.当你要强调一系列相关的产品对象的设计以便进行联合使用时。

4当你提供一个产品类库，而只想显示它们的接口而不是实现时。

参与者：

1.AbstractFactory 声明一个创建抽象产品对象的操作接口。

2.ConcreteFactory 实现创建具体产品对象的操作。

3.AbstractProduct 为一类产品对象声明一个接口。

4.ConcreteProduct 定义一个将被相应的具体工厂创建的产品对象。 实现AbstractProduct 接口。

5.Client 仅使用由 AbstractFactory 和 AbstractProduct类声明的接口

类图 ：

例子：

AbstractFactory  
 
public interface IAnimalFactory { 
 
    ICat createCat();
    IDog createDog();
 } 

ConcreteFactory  
 
public class BlackAnimalFactory implements IAnimalFactory { 
 
    public ICat createCat() {
    		return new BlackCat();
     } 
 
    public IDog createDog() {         
    		return new BlackDog();     
    } 
} 
 
public class WhiteAnimalFactory implements IAnimalFactory { 
 
    public ICat createCat() {
             return new WhiteCat();     
             } 
 
    public IDog createDog() {
             return new WhiteDog();     
             } 
}

AbstractProduct  
 
public interface ICat { 
 
    void eat(); 
    } 
 
public interface IDog { 
 
    void eat(); 
    }

ConcreteProduct  
 
public class BlackCat implements ICat { 
 
    public void eat() {
             System.out.println("The black cat is eating!");     
             } 
 
} 
 
public class WhiteCat implements ICat { 
 
    public void eat() {         
    		System.out.println("The write cat is eating!");     
    } 
} 
 
public class BlackDog implements IDog { 
 
    public void eat() {         
    		System.out.println("The black dog is eating");     
    		} 
} 
 
public class WhiteDog implements IDog { 
 
    public void eat() {
             System.out.println("The white dog is eating!");     
             } 
}

Client  
 
public static void main(String[] args) {
     IAnimalFactory blackAnimalFactory = new BlackAnimalFactory();    
     ICat blackCat = blackAnimalFactory.createCat();
     		blackCat.eat();     
     IDog blackDog = blackAnimalFactory.createDog();    
            blackDog.eat(); 
     
     IAnimalFactory whiteAnimalFactory = new WhiteAnimalFactory();     
     ICat whiteCat = whiteAnimalFactory.createCat();     
            whiteCat.eat();     
     IDog whiteDog = whiteAnimalFactory.createDog();    
            whiteDog.eat(); 
    }

result  
 
The black cat is eating! 
The black dog is eating! 
The white cat is eating! 
The white dog is eating!