工厂模式

   定义：
          是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
   作用：
         1、一个调用者想创建一个对象，只要知道其名称就可以了，调用者不用关心产品的具体的实现 ，只需关心产品的接口，降低了耦合度。
         2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。使得代码结构更加清晰。
   使用场景：
         1、一个对象拥有很多子类。
         2、创建某个对象时需要进行许多额外的操作。

         3、系统后期需要经常扩展，把对象实例化的任务交由实现类完成，扩展性好

    工厂模式分为三类：简单工厂模式 ，工厂方法模式 ，抽象工厂模式 

        1）简单工厂模式

                一般都把简单工厂模式看为工厂方法模式的一种特例，两者归为一类。

                代码实现：

// 抽象产品 这
public interface Car {
    void drive();
}

// 具体产品 宝马车
public class BMWCar implements Car {
    @Override
    public void drive() {
        System.out.println("Drive  BMWCar!!!");
    }
}

// 具体产品 奔驰车
public class BenzCar implements Car {
    @Override
    public void drive() {
        System.out.println("Drive  BenzCar!!!");
    }
}
// 工厂角色
public class CarFactory {
        public Car getCar(String type){
            if ("BMW".equals(type)){
                return new BMWCar();
            } else if ("Benz".equals(type)){
                return new BenzCar();
            } else {
                return null;
            }
        }
// 优化：使用反射
//    public Car getCar(String className){
//
//        try {
//            Car car = (Car)Class.forName(className).newInstance();
//            return car;
//        } catch (ClassNotFoundException e) {
//            e.printStackTrace();
//        } catch (IllegalAccessException e) {
//            e.printStackTrace();
//        } catch (InstantiationException e) {
//            e.printStackTrace();
//        }
//        return null;
//    }



public class Factory01 {
    public static void main(String[] args) {
                CarFactory factory = new CarFactory();
                Car bmw = factory.getCar("Benz");
                bmw.drive();
                Car benz = factory.getCar("BMW");
                benz.drive();
    //        CarFactory factory = new CarFactory();
    //        Car bmw = factory.getCar("com.hukaiguo.factory01.SportCar");
    //        bmw.drive();
    //        Car benz = factory.getCar("com.hukaiguo.factory01.BusinessCar");
    //        benz.drive();
    }

}

        2）工厂方法模式 

            提供一个产品类的接口。产品类均要实现这个接口(也可以是abstract类，即抽象产品)。
            提供一个工厂类的接口。工厂类均要实现这个接口(即抽象工厂)。

            由工厂实现类创建产品类的实例。工厂实现类应有一个方法，用来实例化产品类。

            代码实现：

            

// 抽象产品车
public interface Car {
    void drive();
}

// 具体产品 宝马车
public class BMWCar implements Car {
    @Override
    public void drive() {
        System.out.println("Driver  BusinessCar!!!");
    }
}

// 具体产品奔驰车
public class BenzCar implements Car {
    @Override
    public void drive() {
        System.out.println("Driver  SportCar!!!");
    }
}

// 抽象工厂角色
public interface CarFactory {

    public Car getCar();

}
// 具体创建奔驰工厂
public class BenzCarFactory implements CarFactory {
    @Override
    public Car getCar() {
        return new BenzCar();
    }
}

// 具体创建宝马工厂
public class BMWCarFactory implements CarFactory {
    @Override
    public Car getCar() {
        return new BMWCar();
    }
}


public class Factory02 {
    /**
     工厂方法模式
     */
    public static void main(String[] args) {
        CarFactory factory = new BMWCarFactory();
        factory.getCar().drive();
        CarFactory factory2 = new BenzCarFactory();
        factory.getCar().drive();
    }

}

        3）抽象工厂模式 

                产品族:是指位于不同产品等级结构中功能相关联的产品组成的家族

                多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。   
                一个抽象工厂类，可以派生出多个具体工厂类。   

                每个具体工厂类可以创建多个具体产品类的实例。

                代码实现：

// 抽象产品 跑车
public interface SportCar {
   void createCar();
}

// 抽象产品 商务车
public interface BusinessCar {
    void createCar();
}

// 具体产品 宝马跑车
public class BMWSportsCar implements SportCar {
    @Override
    public void createCar() {
        System.out.println("create BMWSportsCar!!!");
    }
}
// 具体产品 奔驰跑车
public class BenzSportsCar implements SportCar {
@Override public void createCar() { System.out.println("create BenzSportsCar!!!"); }}
//具体产品 宝马商务车
public class BMWBusinessCar implements BusinessCar { @Override public void createCar() { System.out.println("create BMWBusinessCar!!!"); }}
//具体产品 奔驰商务车
public class BenzBusinessCar implements BusinessCar { @Override public void createCar() { System.out.println("create BenzBusinessCar!!!"); }}
//抽象工厂
public interface CarFactory {

    public SportCar getSportCar();

    public BusinessCar getBusinessCar();

}
// 宝马 具体工厂
public class BMWCarFactory implements  CarFactory{

    @Override
    public SportCar getSportCar() {
        return new BMWSportsCar();
    }

    @Override
    public BusinessCar getBusinessCar() {
        return new BMWBusinessCar();
    }
}
//奔驰 具体工厂
public class BenzCarFactory implements  CarFactory{


    @Override
    public SportCar getSportCar() {
        return new BenzSportsCar();
    }

    @Override
    public BusinessCar getBusinessCar() {
        return new BenzBusinessCar();
    }
}

public class Factory03 {
    public static void main(String[] args) {
        BenzCarFactory benzCarFactory = new BenzCarFactory();
        BusinessCar businessCar = benzCarFactory.getBusinessCar();
        businessCar.createCar();
    }

}