设计模式(2)——工厂模式

工厂模式

作用：实现了创建者和调用者分离

核心本质：实例化对象不使用new，用工厂方法代替

​ 将选择实现类，创建对象统一管理和控制。从而将调用者跟我们的实现类解耦

三种模式：

• 简单工厂模式（静态工厂模式）
  • 用来生产同一等级结构中的任意产品（对于增加的新产品，需要修改已有代码）
  • 虽然某种程度上不符合设计原则，但实际应用最多
• 工厂方法模式
  • 用来生产同一等级结构中的固定产品（支持增加任意产品）
  • 不修改已有类的前提下，通过增加新的工厂类实现扩展
• 抽象工厂模式
  • 围绕一个超级工厂创建其他工厂，该超级工厂有称为其他工厂的工厂
  • 不可以直接产品，可以增加产品族

应用场景

• JDK中Calendar的getInstance()
• JBDC中的Connection对象的获取
• Spring在IOC容器创建关联bean对象
• 反射中Class对象的newInsatnce()

简单工厂模式

Car接口

public interface Car {
    void name();
}

实现类

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

实现类

public class Tesla implements Car{

    @Override
    public void name() {
        System.out.println("特斯拉");
    }
}

简单工厂模式

//简单工厂模式，也叫静态工厂模式
//不满足开闭原则，增加对象会对类进行修改
public class CarFactory {
    //增加时会修改代码
//    public static Car getCar(String name) {
//        if (name.equals("宝马")) {
//            return new Baoma();
//        }else if (name.equals("特斯拉")) {
//            return new Tesla();
//        }else {
//            return null;
//        }
//    }

    public static Car getBaoma(String name) {
        return new Baoma();
    }
    public static Car getTesla(String name) {
        return new Tesla();
    }
}

测试

public class Test {
    public static void main(String[] args) {
        //每次创建对象都需要用new
//        Car baoma = new Baoma();
//        Car tesla = new Tesla();
//
//        baoma.name();
//        tesla.name();

        //运用简单工厂模式
//        Car car = CarFactory.getCar("宝马");
//        car.name();
//        Car car1 = CarFactory.getCar("特斯拉");
//        car1.name();

        //运用简单工厂模式
        Car car = CarFactory.getBaoma("宝马");
        car.name();
        Car car1 = CarFactory.getTesla("特斯拉");
        car1.name();
    }
}

工厂方法模式

相比简单工厂模式增加的

汽车工厂

//工厂方法模式
public interface CarFactory {
    Car getCar();
}

宝马工厂

public class BaomaFactory implements CarFactory {
    @Override
    public Car getCar() {
        return new Baoma();
    }
}

特斯拉工厂

public class Teslafactory implements CarFactory {
    @Override
    public Car getCar() {
        return new Tesla();
    }
}

测试

public class Test {
    public static void main(String[] args) {
        Car car = new Teslafactory().getCar();
        Car car1 = new BaomaFactory().getCar();
        car.name();
        car1.name();
    }
}

当每次增加车的时候，只用增加相应的车工厂即可，但是代码量变多了

根据设计模式原则：工厂方法模式

根据实际开发：简单工厂模式

抽象工厂模式(产品组概念)

定义：抽象工厂模式提供了一个创建一系列修改或者相互依赖对象的接口，无需指定它们具体的来

适用场景：

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

优点：

• 规定了所有可能被创建的产品集合，产品组中扩展新产品困难
• 增加了系统的抽象性和理解难道
  

public interface AbstractFactory {
    Phone phone();
    Watch watch();
}

public interface Phone {
    void useP();
    void play();
}

public interface Watch {
    void useW();
    void timer();
}

public class XiaomiFactory implements AbstractFactory {
    @Override
    public Phone phone() {
        return new XaiomiPhone();
    }

    @Override
    public Watch watch() {
        return new XiaomiWatch();
    }
}

public class HuanweiFactory implements AbstractFactory {
    @Override
    public Phone phone() {
        return new HuaweiPhone();
    }

    @Override
    public Watch watch() {
        return new HuaweiWatch();
    }
}

public class XaiomiPhone implements Phone {
    @Override
    public void useP() {
        System.out.println("使用小米手机");
    }

    @Override
    public void play() {
        System.out.println("用小米手机打游戏");
    }
}

public class XiaomiWatch implements Watch{
    @Override
    public void useW() {
        System.out.println("使用小米手环");
    }

    @Override
    public void timer() {
        System.out.println("小米手环计时");
    }
}

public class HuaweiPhone implements Phone {
    @Override
    public void useP() {
        System.out.println("使用华为手机");
    }

    @Override
    public void play() {
        System.out.println("用华为手机打游戏");
    }
}

public class HuaweiWatch implements Watch {
    @Override
    public void useW() {
        System.out.println("使用华为手环");
    }

    @Override
    public void timer() {
        System.out.println("华为手环计时");
    }
}

public class Test {
    public static void main(String[] args) {
        XiaomiFactory xiaomiFactory = new XiaomiFactory();
        Phone phone = xiaomiFactory.phone();
        phone.useP();

        HuanweiFactory huanweiFactory = new HuanweiFactory();
        Watch watch = huanweiFactory.watch();
        watch.useW();
    }
}