设计模式之--工厂模式

工厂模式

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

介绍

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

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

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

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

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

简单工厂模式：

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

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

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

例如：

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

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

package one;

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

Dog---具体产品角色

package one;

public class Dog extends Animal{

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

Cat----具体产品角色

package one;

public class Cat extends Animal{

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

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

package one;

public class AnimalFactory {
    
    private AnimalFactory() {
        
    }
    /*public static Dog createDog() {
        return new Dog();
    }
    
    public static Cat createCat() {
        return new Cat();
    }*/
    
    public static Animal createAnimal(String type) {
        if("dog".equals(type)) {
            return new Dog();
        }else if("cat".equals(type)){
            return new Cat();
        }else {
            return null;
        }
    }
}

AnimalDemo测试

package one;

public class AnimalDemo {
    public static void main(String[] args) {
        Dog d=new Dog();
        d.eat();
        Cat c=new Cat();
        c.eat();
        System.out.println("===============");
        //有了工厂之后
        /*Dog dog = AnimalFactory.createDog();
        Cat cat = AnimalFactory.createCat();
        dog.eat();
        cat.eat();*/
        //工厂改进
        Animal a=AnimalFactory.createAnimal("dog");
        a.eat();
        
    }
}

工厂方法模式：

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

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

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

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

例子：

Animal

package two;

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

Dog

package two;

public class Dog extends Animal{

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

Cat

package two;

public class Cat extends Animal{

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

Factory

package two;

public interface Factory {
    public abstract Animal creatAnimal();
}

DogFactory

package two;

public class DogFactory implements Factory{

    @Override
    public Animal creatAnimal() {
        return new Dog();
    }
}

CatFactory

package two;

public class CatFactory implements Factory {

    @Override
    public Animal creatAnimal() {
        return new Cat();
    }
}

AnimalDemo--测试

package two;

public class AnimalDemo {
    public static void main(String[] args) {
        //要狗
        Factory f=new DogFactory();
        Animal dog = f.creatAnimal();
        dog.eat();
        System.out.println("===========");
        f=new CatFactory();
        Animal cat=f.creatAnimal();
        cat.eat();
    }
}

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

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