标签：engine 处理 void main code rev .com ota png
我们去4s店里面买车下订单，然后汽车工厂根据我们的订单来生成对应的车辆。
public class CarShop {
public Car order(String type){
Car car = null;
if("Benz".equals(type)){
car = new BenzCar();
}else if("Tyota".equals(type)){
car = new ToytaCar();
}else{
return car;
}
car.design();
car.assemble();
car.test();
return car;
}
}
这样的代码实现，会随着车辆种类的变多变成if else 地狱，后期对车型的维护会变得无比艰难，所有需要创建Car类的地方都要维护到。我们试着将代码中会变化的部分抽离出来并封装：
public class SimpleCarFactory {
public Car createCar(String type){
Car car = null;
if("Benz".equals(type)){
car = new BenzCar();
}else if("Tyota".equals(type)){
car = new ToytaCar();
}else{
return car;
}
return car;
}
}
public class CarShop {
SimpleCarFactory simpleCarFactory;
public CarShop(SimpleCarFactory simpleCarFactory){
this.simpleCarFactory = simpleCarFactory;
}
public Car order(String type){
Car car = simpleCarFactory.createCar(type);
car.design();
car.assemble();
car.test();
return car;
}
}
这样分离之后，虽然if else地狱依然存在，但是在别的需要创建Car对象的地方就不用重复维护了。
简单工厂模式与其说是一种设计模式，不如说是一种编程习惯。类图如下：
当我们的汽车销售形成规模，在各地都需要4s店，而各地对汽车的审美都有自己的要求，即需要一些地方化的服务。我们之前一刀切式地在order方法中根据车型来创建
汽车对象的方式需要进行调整了，因为它不能满足需求了。代码调整如下：
1.将CarShop类中createCar方法抽象出来，让各地的分店自行实现自己的。
public abstract class CarShop {
public Car order(String type){
Car car = createCar(type);
car.design();
car.assemble();
car.test();
return car;
}
public abstract Car createCar(String type);
}
2.北京和大连的4s店
public class BeijingCarShop extends CarShop {
public Car createCar(String type) {
Car car = null;
if("Benz".equals(type)){
car = new BeijingBenzCar();
}else if("Tyota".equals(type)){
car = new BeijingTyotaCar();
}else{
return car;
}
return car;
}
}
public class DalianCarShop extends CarShop {
public Car createCar(String type) {
Car car = null;
if("Benz".equals(type)){
car = new DalianBenzCar();
}else if("Tyota".equals(type)){
car = new DalianTyotaCar();
}else{
return car;
}
return car;
}
}
工厂方法用来处理对象的创建，并将这样的行为封装在子类中。这样程序中超类的代码和子类对象的创建代码就解耦了。
工厂方法模式：定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法让类把实例化推迟到子类。
设计原则：依赖倒置原则--要依赖抽象，不要依赖具体类。
当我们的需求变更为为不同的品牌的车生产不同配置的车时，也就是说同样车型的车，有了不同的配置。配置大概抽出几个，如轮胎，引擎，座椅等。
面向接口设计原则，我们将这些个配置也全都抽象出来，这样上面的工厂模式就不适合了。我们来看看抽象工厂模式。
抽象工厂模式：提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。
类图如下：
代码实现：
1.配件接口，及高低端配件的实现类
引擎
public interface Engine {
public void run();
public void start();
}
class LuxuryEngine implements Engine{
public void run() {
System.out.println("跑得快");
}
public void start() {
System.out.println("启动快");
}
}
class LowEngine implements Engine{
public void run() {
System.out.println("跑得慢");
}
public void start() {
System.out.println("启动慢");
}
}
轮胎
public interface Tyre {
public void revolve();
}
class LuxuryTyre implements Tyre{
public void revolve() {
System.out.println("耐磨");
}
}
class LowTyre implements Tyre{
public void revolve() {
System.out.println("不耐磨");
}
}
座椅
public interface Seat {
public void message();
}
class LuxurySeat implements Seat{
public void message() {
System.out.println("真皮沙发");
}
}
class LowSeat implements Seat{
public void message() {
System.out.println("塑料沙发");
}
}
2.抽象工厂类
public interface CarFactory {
Engine createEngine();
Tyre createTyre();
Seat createSeat();
}
3.高低端工厂实现类
public class LowCarFactory implements CarFactory {
public Engine createEngine() {
return new LowEngine();
}
public Tyre createTyre() {
return new LowTyre();
}
public Seat createSeat() {
return new LowSeat();
}
}
public class LuxuryCarFactory implements CarFactory {
public Engine createEngine() {
return new LuxuryEngine();
}
public Tyre createTyre() {
return new LuxuryTyre();
}
public Seat createSeat() {
return new LuxurySeat();
}
}
4.测试
public class Client {
public static void main(String[] args){
CarFactory factory = new LowCarFactory();
Engine e = factory.createEngine();
e.start();
e.run();
}
}
运行结果：
要点：
简单工厂模式：虽然某种程度不符合设计原则，但实际使用最多
工厂方法模式：不修改已有类的前提下，通过增加新的工厂类实现扩展
抽象工厂模式：不可以增加产品，但可以增加产品族
应用场景：
JDK中Calendar的getInstance方法
JDBC中Connection对象的获取
Spring中IOC容器创建管理bean对象
反射中Class对象的newInstance()
标签：engine 处理 void main code rev .com ota png
原文地址：https://www.cnblogs.com/bwyhhx2018/p/10666220.html
