设计模式---工厂模式

工厂模式属于创建型模式，它提供了一种创建对象的最佳方式。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

public interface Car {
    void makecar();
}

public class BMW implements Car {
    @Override
    public void makecar() {
        System.out.println("BMW");
    }
}

public class wuling implements Car{
    @Override
    public void makecar() {
        System.out.println("五菱宏光");
    }
}

public class Client {
    public static void main(String[] args) {
        BMW bmw = new BMW();
        bmw.makecar();
        wuling wuling = new wuling();
        wuling.makecar();
    }
}

上面这个例子，虽然顾客Client得到了BMW和五菱宏光这两辆车，但是我们的实现类和接口紧紧的绑在了一起，不利于后期维护，并且如果Client需要Audi的话，需要覆盖已有的代码。

简单工厂模式：

现在我们增加一个CarFactory类，替我们new BMW和wuling两个实例。这样我们不需要直接和工厂接触了。

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

public class Client {
    public static void main(String[] args) {
        //简单工厂模式
        Car car = CarFactory.getCar("BMW");
        car.makecar();

        Car car1 = CarFactory.getCar("wuling");
        car1.makecar();
    }
}

特点

1 它是一个具体的类，非接口 抽象类。有一个重要的getCar方法，利用if或者 switch创建产品并返回。

2 getCar方法通常是静态的，所以也称之为静态工厂。

缺点

1 扩展性差（我想增加一种面条，除了新增一个面条产品类，还需要修改工厂类方法）

2 不同的产品需要不同额外参数的时候 不支持。

工厂模式

抽象产品

public interface Car {
    void makecar();
}

具体产品类

public class wuling implements Car{
    @Override
    public void makecar() {
        System.out.println("五菱宏光");
    }
}

public class BMW implements Car {
    @Override
    public void makecar() {
        System.out.println("BMW");
    }
}

抽象工厂

public interface Factory {
    Car getcar();
}

具体工厂

public class wulingFactory implements Factory {
    @Override
    public Car getcar() {
        return new wuling();
    }
}

public class BMWfactory implements Factory {
    @Override
    public Car getcar() {
        return new BMW();
    }
}

实现类

public class Client {
    public static void main(String[] args) {
        //工厂模式
        Car car = new BMWfactory().getcar();
        car.makecar();
        Car car1 = new wulingFactory().getcar();
        car1.makecar();
    }
}

模式分析：

• 工厂方法类的核心是一个抽象工厂类，而简单工厂模式吧核心都放在一个具体类上。

• 工厂方法当系统需要扩展需要添加新的产品对象时，仅仅需要添加一个具体的产品对象以及一个具体的工厂对象，原有的工厂对象不需要进行任何修改，也不需要修改客户端，很好的符合了开闭原则。

• 工厂方法中，产品类和工厂类具有平行的等级结构，他们之间一一对应

抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

例子：一个工厂可以生产多种产品，海尔工厂可以生产电视和空调，TCL工厂可以生产TCL空调和TCl电视，相同品牌的电器构成一个产品族，相同类型的产品构成一个产品等级结构

抽象产品

public interface TV {
    void make_TV();
}

public interface AirCon {
    void make_AirCon();
}

具体产品类

public class TCL_TV implements TV {
    @Override
    public void make_TV() {
        System.out.println("TCl-TV");
    }
}

public class Hair_TV implements TV {
    @Override
    public void make_TV() {
        System.out.println("Hair--TV");
    }
}

public class TCL_Air implements AirCon {
    @Override
    public void make_AirCon() {
        System.out.println("TCL--AirCon");
    }
}

public class Hair_AirCon implements AirCon {
    @Override
    public void make_AirCon() {
        System.out.println("Hair--AirCon");
    }
}

抽象工厂

public interface AbstractFactory {
    TV getTV();
    AirCon getAirCon();
}

具体工厂

public class TCL_Factory implements AbstractFactory {
    @Override
    public TV getTV() {
        return new TCL_TV();
    }

    @Override
    public AirCon getAirCon() {
        return new TCL_Air();
    }
}

public class HairFactory implements AbstractFactory {
    @Override
    public TV getTV() {
        return new Hair_TV();
    }
    @Override
    public AirCon getAirCon() {
        return new Hair_AirCon();
    }
}

实现类

public class Client {
    public static void main(String[] args) {
        TCL_Factory tcl_factory = new TCL_Factory();
        tcl_factory.getAirCon().make_AirCon();

        //        TV tv = tcl_factory.getTV();
        //        tv.make_TV();
        tcl_factory.getTV().make_TV();

        System.out.println("----------分割线-----------");

        HairFactory hairFactory = new HairFactory();
        hairFactory.getAirCon().make_AirCon();
        hairFactory.getTV().make_TV();
    }
}