设计模式-工厂模式

工厂模式定义 Define an interface for creating an object,but let subclasses decide which class to instantiate.Factory Method lets a class defer instantiation to subclasses.（定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类）

• 类图比较简单，AbstractCarFactory是一个抽象类，CarFactory为实现类，完成具体的任务——创建车；Car接口是车类的总称，其三个实现类分别为三类车；Client类是一个场景类，负责模拟这个造车场景，执行相关的任务。

image.png

看一个简单的例子

//接口
public interface Car {

    //每个车都有颜色
    public void getColor();

    //每个车都有轮胎颜色
    public void getTire();
}

//实现类
public class AudiBlackCar implements Car {
    @Override
    public void getColor() {
        System.out.println("黑色奥迪车");
    }

    @Override
    public void getTire() {
        System.out.println("黑色轮胎");
    }
}

//实现类
public class AudiRedCar implements Car {
    @Override
    public void getColor() {
        System.out.println("红色奥迪车");
    }

    @Override
    public void getTire() {
        System.out.println("红色轮胎");
    }
}

//实现类
public class AudiWhiteCar implements Car {
    @Override
    public void getColor() {
        System.out.println("白色奥迪车");
    }

    @Override
    public void getTire() {
        System.out.println("白色轮胎");
    }
}

//抽象工厂类
public abstract class AbstractCarFactory {
    public abstract <T extends Car> T createCar(Class<T> c);
}

//实现类
public class CarFactory extends AbstractCarFactory {
    @Override
    public <T extends Car> T createCar(Class<T> c) {
        //定义一个车
        Car car = null;
        try {
            car = (T)Class.forName(c.getName()).newInstance();
        }catch (Exception e) {
            System.out.println("车生产错误");
        }
        return (T)car;
    }
}

//客户端
public class Client {

    public static void main(String[] args) {
        AbstractCarFactory carFactory = new CarFactory();
        AudiBlackCar audiBlackCar = carFactory.createCar(AudiBlackCar.class);
        audiBlackCar.getColor();
        audiBlackCar.getTire();
        System.out.println("+++++++++++++++++++++");
        AudiWhiteCar audiWhiteCar = carFactory.createCar(AudiWhiteCar.class);
        audiWhiteCar.getColor();
        audiWhiteCar.getTire();
        System.out.println("+++++++++++++++++++++");
        AudiRedCar audiRedCar = carFactory.createCar(AudiRedCar.class);
        audiRedCar.getColor();
        audiRedCar.getTire();
    }
}

以上就是一个简单的工厂模式，造不同颜色的车，比较清晰明了

• 工厂模式的优点

1.良好的封装性，代码结构清晰。创建对象简单只需要知道对象的类名就可以
2.比较容易扩展，增加产品的时候，只需要需改具体工厂类或者新增一个工厂类就可以。
3.屏蔽产品类。产品如何变化，调用者不需要关心，只需要关心接口。
4.工厂类典型解耦框架。高层模块只需要知道产品的抽象类，其他不用关心。

• 工厂模式使用场景

1.需要灵活，可扩展框架时候可以考虑工厂模式
2.说白了工厂类就是new一个对象的替代品。

• 工厂模式扩展

1. 把上面例工厂类可以扩展为静态方法

public class EnhangeCarFactory {
    public static   <T extends Car> T createCar(Class<T> c) {
        //定义一个车
        Car car = null;
        try {
            car = (T)Class.forName(c.getName()).newInstance();
        }catch (Exception e) {
            System.out.println("车生产错误");
        }
        return (T)car;
    }
}

2. 把上面例子升级多个工厂：目的是把所有产品放到一个工厂方法里面有可能结构不清晰。现在把生产每种颜色的车工厂都定义一个创造者，让调用者自己去选择与那个工厂关联。

主要代码如下

//抽象类
public abstract class AbstractEnCarFactory {
    public abstract Car createCar();
}

//实现类
public class AudiBlackCarFactory extends AbstractEnCarFactory {

    @Override
    public Car createCar() {
        return new AudiBlackCar();
    }
}

//实现类
public class AudiRedCarFactory extends AbstractEnCarFactory {
    @Override
    public Car createCar() {
        return new AudiRedCar();
    }
}

//实现类
public class AudiWhiteCarFactory extends AbstractEnCarFactory {
    @Override
    public Car createCar() {
        return new AudiWhiteCar();
    }
}

public class Client {

    public static void main(String[] args) {
        Car audiBlackCar = new AudiBlackCarFactory().createCar();
        audiBlackCar.getColor();
        audiBlackCar.getTire();
        Car audiRedCar = new AudiRedCarFactory().createCar();
        audiRedCar.getColor();
        audiRedCar.getTire();
        Car audiWhiteCar = new AudiWhiteCarFactory().createCar();
        audiWhiteCar.getColor();
        audiWhiteCar.getTire();
    }
}

image.png

以上就是工厂模式的基本简单用法，欢迎大家查看并指出不足的地方，万分感谢