设计模式整理_工厂模式

Posted 2020-07-26 大胡龙的小圈子

一.简单工厂模式.

　　通常情况下,在代码中需要创建一系列对象的时候,如果需要创建新的同类型的对象,就需要对原代码进行修改,此时就不符合对修改关闭的原则,因此,我们将创建对象于使用对象的代码分隔开来,在工厂类中创建工厂,然后如果需要新的对象,只需要修改工厂的类即可.

　　

public interface Car /*在这里定义需要生成的实例,针对抽象组件*/{
    public void run();
}
class BenzCar /*实例*/ implements Car {

    @Override
    public void run() {
        System.out.println("Benz run.");
    }
    
}
class AudiCar /*实例*/ implements Car {
    @Override
    public void run() {
        System.out.println("Audi run");
    }
}

public class CarFactory /*通过工厂产生实例*/{
    String name;
    public Car get(String name) {
        if(name.equals("Benz")) {
            return new BenzCar();
        }
        else if(name.equals("Audi")) {
            return new AudiCar();
        }
        return null;
    }
}

/*
 * 测试简单工厂模式.
 * */
public class Test1 {
    public static void main(String[] args) {
        CarFactory factory=new CarFactory();        //定义工厂
        AudiCar audi=(AudiCar) factory.get("Audi"); //产生AudiCar实例
        BenzCar benz=(BenzCar) factory.get("Benz"); //产生BenzCar实例
        audi.run();
        benz.run();
    }
}

二.工厂方法模式.

　　工厂方法模式定义了一个创建对象的接口,但由子类决定要实例化的类是哪一个,工厂方法让类把实例化推迟到子类.

　　工厂方法模式需要注意的细节:

　　1.工厂方法模式将工厂抽象成为接口(创建者类),在编写创建类是不需要知道实际创建产品的是哪一个,选择了使用哪个子类工厂就决定了实际创建的产品是什么.

　　2.对于创建者类如果增加产品或者改变产品的实现,它不会受到任何影响,这实现了解耦.

　　3.简单工厂模式不具备工厂方法模式的弹性,因为简单工厂模式不能变更正在创建的产品.

　　工厂方法模式体现了一个很重要的原则:要依赖抽象,不要依赖具体类.

　　这个原则的具体内容是让我们在编写代码的时候,最好依赖的都是抽象类,而不依赖具体类,对于高层以及低层模块都应该如此.

　　具体来说,即:变量不可以持有具体的类的引用,如果使用new,就会持有具体类的引用,应当采用工厂来避免这样的情况发生.不要让类派生自具体类,应当让其派生于一个抽象,不要覆盖基类中已实现的方法,基类已实现的方法应当由所有子类共享.

　　以下是工厂方法的实例,定义了产品接口Car,创建者接口CarFactory,采用具体的子类来生成具体的产品.

public interface Car/*定义产品类*/ {
    public void run();
}
class GoodAudiCar implements Car/*实现具体的产品*/ {

    @Override
    public void run() {
        System.out.println("Good Audi run..zzz");
    }
    
}
class BadAudiCar implements Car {
    @Override
    public void run() {
        System.out.println("Bad Audi run...ouch!");
    }
}

public interface Factory /*定义创建者类,定义一个抽象的工厂方法,让子类去实现此方法.*/{
public Car produceCar();
}
class GoodAudiFactory implements Factory /*实现具体的创建者.*/{

@Override
public Car produceCar() {
return new GoodAudiCar();
}

}
class BadAudiFactory implements Factory{

@Override
public Car produceCar() {
return new BadAudiCar();
}

}

/*
 *     演示工厂方法模式.
 * */
public class Test2 {
    public static void main(String[] args) {
        Factory factory1=new GoodAudiFactory();
        Factory factory2=new BadAudiFactory();
        
        Car good=factory1.produceCar();
        Car bad= factory2.produceCar();
        good.run();
        bad.run();
    }
}

　　类图如下:

三.抽象工厂模式.

　　抽象工厂模式提供了一个接口,用来创建相关的对象的家族(一系列产品),而不需要明确制定具体类.

　　引用新类型的工厂,也就是所谓的抽象工厂来创建一系列产品,通过抽象工厂所提供的接口,可以创建产品的家族,利用这个接口书写代码,可以在不同上下文中,实现各式各样的工厂,创建出各种类型的产品,因为代码从实际产品中解耦出来了,所以我们可以替换不同的工厂来取得不同的行为.

　　工厂方法模式是通过子类来创建具体的对象,负责将客户从具体类型中,解耦,而抽象工厂模式将一群相关的产品集合起来,提供了一个用于创建一个产品家族的抽象类型,这个类型的子类定义了产品被产生的方法,要想使用这个方法,必须先实例化它,然后将它传入一些针对抽象类型所写的代码中.

　　下面是工厂方法模式的实例,产品为Engine,Wheel类,抽象工厂Factory定义了产生产品族的方法,而将具体的实现交给其子类来完成,随后在另一个类中,传入工厂,获取产品族.

　　

/*
 * 定义Wheel产品
 * */
public interface Wheel {
    public void run();
}
class GoodWheel implements Wheel {

    @Override
    public void run() {
        System.out.println("GoodWheel run.");
    }
}
class BadWheel implements Wheel {

    @Override
    public void run() {
        System.out.println("BadWheel run.");
    }
    
}

/*
 * 定义Engine产品
 * */
public interface Engine {
    public void start();
}
class GoodEngine implements Engine{

    @Override
    public void start() {
        System.out.println("GoodEngine start");
    }
}
class BadEngine implements Engine {

    @Override
    public void start() {
        System.out.println("BadEngine start");
    }
}

//定义抽象工厂来生成产品.
public interface Factory {
    /*两个产品*/
    public Engine getEngine();
    public Wheel getWheel();
}
class GoodFactory implements Factory {

    @Override
    public Engine getEngine() {
        return new GoodEngine();
    }

    @Override
    public Wheel getWheel() {
        return new GoodWheel();
    }
}
class BadFactory implements Factory {

    @Override
    public Engine getEngine() {
        return new BadEngine();
    }

    @Override
    public Wheel getWheel() {
        return new BadWheel();
    }
    
}

//获取产品族
public abstract class Car {
    Engine en;
    Wheel wh;
    public abstract void prepareCar();
}
class BadCar extends Car {
    Factory fa;
    /*需要传入一个抽象工厂来获取产品族*/
    public BadCar(Factory fa) {
        this.fa = fa;
    }

    @Override
    public void prepareCar() {
        en=fa.getEngine();
        en.start();
        wh=fa.getWheel();
        wh.run();
    }
    
}
class GoodCar extends Car {
    Factory fa;
    
    public GoodCar(Factory fa) {
        this.fa = fa;
    }
    
    @Override
    public void prepareCar() {
        en=fa.getEngine();
        en.start();
        wh=fa.getWheel();
        wh.run();
    }
    
}

//测试抽象工厂方法.
public class Test3 {
    public static void main(String[] args) {
        Factory fa1=new GoodFactory();    //创建一个抽象工厂的具体实现类
        Car c1=new GoodCar(fa1);    //像Car类中传入工厂以获取产品族
        c1.prepareCar();            //调用获取产品族的方法
        Factory fa2=new BadFactory();
        Car c2=new BadCar(fa2);
        c2.prepareCar();
    }
}

　　抽象工厂模式的类图如下: