3种工厂模式的介绍和对比！

1、作用：

 

• 实现创建和调用分离

2、分类：

1、简单工厂模式

2、工厂方法模式

3、抽象工厂模式

3、本质

• 实例化对象时不用new的方式，用工厂方法代替。

一、简单工厂模式

• 其中，Car为接口，Audi_S8和BMW是Car的具体实现类，CarFactory为工厂类，在Consumer中调用对象。

public interface Car {
    public void name();
}

• 这个Car接口必须要有，自己体会一下如果没有这个接口的话会是什么样。 

public class Audi_S8 implements Car{
    @Override
    public void name() {
        System.out.println("奥迪S8");
    }
}

public class BMW implements Car{
    @Override
    public void name() {
        System.out.println("宝马420i");
    }
}

public class CarFactory {
    public static Car getCar(String car){
        if(car.equals("BMW")){
            return new BMW();
        }else if(car.equals("Audi_S8")){
            return new Audi_S8();
        }else{
            return null;
        }
    }
}

public class Consumer {
    public static void main(String[] args) {
        //原始方式创建对象
        Car audi = new Audi_S8();
        audi.name();
        Car bmw = new BMW();
        bmw.name();

        //简单工厂模式创建对象
        Car bmw1 = CarFactory.getCar("BMW");
        bmw1.name();
    }
}

但是这种方式的不足之处在于，如果我新建了一个实现类BYD，也想通过工厂CarFactory来创建BYD的对象，那么就需要重新修改CarFactory的代码。 

二、工厂方法模式  

• 这种模式的思路是为每一种车型都创建工厂类（这些工厂类都实现同一个接口），通过不同的工厂类去创建不同类的对象。
• 个人认为这种方法反而更不方便，所以不再赘述！

三、抽象工厂模式   

• 抽象工厂模式提供了一个创建一系列相关或者相互依赖对象的接口，无需指定他们具体的类

使用场景：

1.客户端（应用层）不依赖与产品类示例如何被创建、实现等细节
2.强调一系列相关的产品对象（数据同一产品族）一起使用创建对象需要大量的重复代码
3.提供一个产品类的库，所有的产品以同样的接口出现，使得客户端不依赖于具体实现

具体实现： 

 

• 把工厂抽象为Factory接口，里面包含两个方法getPhone()和getPods()。

• 把手机抽象成PhoneProduct接口，包含两个方法call()和sendMessage()。

• 把耳机抽象成podsProduct接口，包含两个方法turnup()和turndown()。
• 华为手机、苹果手机分别为具体的实现类：HuaweiPhone、iphone
• 华为耳机、苹果耳机分别为具体的实现类：HuaweiPods、ipods
• 华为工厂和苹果工厂也是具体的实现类：HuaweiFactory、AppleFactory

 

public interface PhoneProduct {
    public void call();
    public void sendMessage();
}

public class Iphone implements PhoneProduct{

    @Override
    public void call() {
        System.out.println("苹果手机打电话");
    }

    @Override
    public void sendMessage() {
        System.out.println("苹果手机发短信");
    }
}

public class HuaweiPhone implements PhoneProduct{
    @Override
    public void call() {
        System.out.println("华为手机打电话");
    }

    @Override
    public void sendMessage() {
        System.out.println("华为手机发短信");
    }
}

public interface podsProduct {
    public void turnup();
    public void turndown();
}

public class ipods implements podsProduct{
    @Override
    public void turnup() {
        System.out.println("ipods声音调高");
    }

    @Override
    public void turndown() {
        System.out.println("ipods声音调低");
    }
}

public class HuaweiPods implements podsProduct{
    @Override
    public void turnup() {
        System.out.println("华为耳机声音调大");
    }

    @Override
    public void turndown() {
        System.out.println("华为耳机声音调小");
    }
}

public interface Factory {
    public PhoneProduct getPhone();
    public podsProduct getPods();
}

public class HuaweiFactory implements Factory{
    @Override
    public PhoneProduct getPhone() {
        return new HuaweiPhone();
    }

    @Override
    public podsProduct getPods() {
        return new HuaweiPods();
    }
}

public class AppleFactory implements Factory{

    @Override
    public PhoneProduct getPhone() {
        return new Iphone();
    }

    @Override
    public podsProduct getPods() {
        return new ipods();
    }

}

public class Consumer {
    public static void main(String[] args) {
        Factory appleFactory = new AppleFactory();
        PhoneProduct iphone = appleFactory.getPhone();
        iphone.sendMessage();
        podsProduct ipods = appleFactory.getPods();
        ipods.turndown();
    }
}