设计模式之--工厂模式

工厂模式

　　工厂模式（Factory Pattern）是Java中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

介绍

意图：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。

何时使用：我们明确地计划不同条件下创建不同实例时。

如何解决：让其子类实现工厂接口，返回的也是一个抽象的产品。

关键代码：创建过程在其子类执行。

注意事项：作为一种创建类模式，在任何需要生成复杂对象的地方，都可以使用工厂方法模式。

简单工厂模式：

又叫静态工厂方法模式，它定义一个具体的工厂类负责创建一些类的实例。

优点：客户端不需要在负责对象的创建，从而明确了各个类的职责

缺点：这个静态工厂类负责所有对象的创建，如果有新的对象增加，或者某些对象的创建方式不同，就需要不断的修改工厂类，不利于后期的维护。

例如：

有一个工厂，里面有静态创建动物的方法，里面时创建动物的逻辑代码，当客户端调用工厂的静态方法创建动物时只需传一个参数即可，就能得到想要的类的对象（具体的动物）

定义一个抽象的Animal类---抽象产品角色

1 package one;
2 
3 public abstract class Animal {
4     public abstract void eat();
5 }

Dog---具体产品角色

1 package one;
2 
3 public class Dog extends Animal{
4 
5     @Override
6     public void eat() {
7         System.out.println("狗吃肉");
8     }
9 }

Cat----具体产品角色

1 package one;
2 
3 public class Cat extends Animal{
4 
5     @Override
6     public void eat() {
7         System.out.println("猫吃鱼");
8     }
9 }

AnimalFactory生产动物-----工厂类角色

 1 package one;
 2 
 3 public class AnimalFactory {
 4     
 5     private AnimalFactory() {
 6         
 7     }
 8     /*public static Dog createDog() {
 9         return new Dog();
10     }
11     
12     public static Cat createCat() {
13         return new Cat();
14     }*/
15     
16     public static Animal createAnimal(String type) {
17         if("dog".equals(type)) {
18             return new Dog();
19         }else if("cat".equals(type)){
20             return new Cat();
21         }else {
22             return null;
23         }
24     }
25 }

AnimalDemo测试

 1 package one;
 2 
 3 public class AnimalDemo {
 4     public static void main(String[] args) {
 5         Dog d=new Dog();
 6         d.eat();
 7         Cat c=new Cat();
 8         c.eat();
 9         System.out.println("===============");
10         //有了工厂之后
11         /*Dog dog = AnimalFactory.createDog();
12         Cat cat = AnimalFactory.createCat();
13         dog.eat();
14         cat.eat();*/
15         //工厂改进
16         Animal a=AnimalFactory.createAnimal("dog");
17         a.eat();
18         
19     }
20 }

工厂方法模式：

　　工厂方法模式中抽象工厂类负责定义创建对象的接口，具体对象的创建工作由继承抽象工厂的具体类实现。

优点：客户端不需要在负责对象的创建，从而明确了各个类的职责，如果有新的对象添加，只需要增加一个具体的类和具体的工厂类即可，不影响已有的代码，后期维护容易，增强了系统的扩展性。

缺点：需要额外的编写代码，增加了工作量。

　　工厂方法模式定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method是一个类的实例化延迟到其子类。

例子：

Animal

1 package two;
2 
3 public abstract class Animal {
4     public abstract void eat();
5 }

Dog

package two;

public class Dog extends Animal{

    @Override
    public void eat() {
        System.out.println("狗吃肉");
    }
}

Cat

1 package two;
2 
3 public class Cat extends Animal{
4 
5     @Override
6     public void eat() {
7         System.out.println("猫吃鱼");
8     }
9 }

Factory

1 package two;
2 
3 public interface Factory {
4     public abstract Animal creatAnimal();
5 }

DogFactory

1 package two;
2 
3 public class DogFactory implements Factory{
4 
5     @Override
6     public Animal creatAnimal() {
7         return new Dog();
8     }
9 }

CatFactory

1 package two;
2 
3 public class CatFactory implements Factory {
4 
5     @Override
6     public Animal creatAnimal() {
7         return new Cat();
8     }
9 }

AnimalDemo--测试

 1 package two;
 2 
 3 public class AnimalDemo {
 4     public static void main(String[] args) {
 5         //要狗
 6         Factory f=new DogFactory();
 7         Animal dog = f.creatAnimal();
 8         dog.eat();
 9         System.out.println("===========");
10         f=new CatFactory();
11         Animal cat=f.creatAnimal();
12         cat.eat();
13     }
14 }

https://wenku.baidu.com/view/a4bae12c0066f5335a812160.html 见链接有三种工厂的详解

电脑eclipse/XJS_Factory对三个工厂的代码实现

设计模式之--工厂模式

工厂模式

介绍

猜你喜欢