设计模式（四） Factory Pattern工厂模式

核心：

实例化对象，实现创建者和调用者的分离

简单工厂模式

工厂方法模式

抽象工厂模式

面对对象设计的基本原则：

ocp(open closed principle) 开闭原则:一个软件的实体应当对拓展开放，对修改关闭

dip(dependence inversion principle) 依赖反转原则:针对接口编程，不要针对实现编程

lod(law of demeter) demeter法则:只与你直接的朋友通信，避免与陌生人通信

简单工厂模式（Simple Factory Pattern）：

public class Car {

}

public class Byd extends Car{

}

public class Audi extends Car{

}

public class CarFactory {
    public static Car createCar(String type){
        if("audi".equals(type)){
            return new Audi();
        }else if("byd".equals(type)){
             return new Byd();
        }else return null;
    }
}

public class Test {
    public static void main(String[] args) {
        Car c=CarFactory.createCar("奥迪");
        
    }
}

UML图：

 由于上述方法未实现开闭原则，则引入工厂方法模式（FactoryMethod）

工厂方法模式（Factory Method Pattern）：

public class Car {

}

public class Audi extends Car{

}

public class Byd extends Car{

}

public interface CarFactory {
    Car createCar();
}


public class AudiFactory implements CarFactory{

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

}

public class BydFactory implements CarFactory{

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

}

public class Client {
    public static void main(String[] args) {
        Car c1=new AudiFactory().createCar();
        Car c2=new BydFactory().createCar();
    }
}

UML图：

结构复杂，但是但是容易扩展

抽象工厂模式（Abstract Factory Pattern）：

产品族：用来生产不同产品族的全部产品

package com.littlepage.factoryPattern.abstractFactory;

public interface Engine {
    void run();
    void start();
}

class LuxuryEngine implements Engine{

    @Override
    public void run() {
        System.out.println("启动快");
    }

    @Override
    public void start() {
        System.out.println("开始快");
    }
    
}

class LowEngine implements Engine{

    @Override
    public void run() {
        System.out.println("启动慢");
    }

    @Override
    public void start() {
        System.out.println("开始慢");
    }
    
}

package com.littlepage.factoryPattern.abstractFactory;

public interface Seats {
    void massage();
}

class LuxurySeat implements Seats {

    @Override
    public void massage() {
        System.out.println("自动按摩");
    }

}

class LowSeat implements Seats {

    @Override
    public void massage() {
        System.out.println("手动按摩");
    }

}
package com.littlepage.factoryPattern.abstractFactory;

public interface Tyre {
    void revolve();
}

class LuxuryTyre implements Tyre{

    @Override
    public void revolve() {
        System.out.println("旋转快");
    }
    
}

class LowTyre implements Tyre{

    @Override
    public void revolve() {
        System.out.println("旋转慢");
    }
    
}
package com.littlepage.factoryPattern.abstractFactory;

public interface CarFactory {
    Engine createEngine();
    Seats createSeat();
    Tyre createTyre();
}

class LuxuryCarFactory implements CarFactory{

    @Override
    public Engine createEngine() {
        return new LuxuryEngine();
    }

    @Override
    public Seats createSeat() {
        return new LuxurySeat();
    }

    @Override
    public Tyre createTyre() {
        return new LuxuryTyre();
    }

    
    
}

class LowCarFactory implements CarFactory{

    @Override
    public Engine createEngine() {
        return new LowEngine();
    }

    @Override
    public Seats createSeat() {
        return new LowSeat();
    }

    @Override
    public Tyre createTyre() {
        return new LowTyre();
    }

    
    
}
package com.littlepage.factoryPattern.abstractFactory;

public class Client {
    public static void main(String[] args) {
        CarFactory factory=new LuxuryCarFactory();
        Engine e=factory.createEngine();
        e.start();
    }
}

UML图(按照层级来看):