工厂模式定义 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
以上就是工厂模式的基本简单用法，欢迎大家查看并指出不足的地方，万分感谢
