前言
面试被提问到三种工厂模式 回答得十分模糊 于是花了一上午时间梳理并总结 ,为了方便大家实践,我把代码都编写在一个.java里面
,复制即可食用.写完总结了一下,三种工厂设计模式产品和工厂对应关系类似,多对一,一对一,以及一对多
简单工厂模式
首先介绍简单工厂模式,它的主要特点是需要在工厂类中做判断,从而创造相应的产品。当增加新的产品时,就需要修改工厂类。
举个例子。有一家生产处理器核的厂家,它只有一个工厂,能够生产两种型号的处理器核。客户需要什么样的处理器核,一定要显示地告诉生产工厂。下面给出一种实现方案。
流程图:
测试表代码
package sample;
//简单工厂代码demo
public class FactoryDemo {
interface Product{
public void saySmoe() ;
}
static class ProductA implements Product{
@Override
public void saySmoe() {
System.out.println("say ProductA");
}
}
static class ProductB implements Product{
@Override
public void saySmoe() {
System.out.println("say ProductB");
}
}
static class ProductFactory{
public static Product getProduct(String name) {
if("productA".equals(name)) {
return new ProductA();
}else if("productB".equals(name)) {
return new ProductB();
}else {
return null;
}
}
}
public static void main(String[] args) {
// 使用工厂模式 降低使用者与被使用者之间的耦合
//Product productA = new productA();
// 将使用者与被使用者之间的依赖转移到使用者与工厂之间的依赖
Product productA = ProductFactory.getProduct("productA");
if(null!=productA) {
productA.saySmoe();
}
}
}
结果:
say ProductA
工厂模式
简单工厂模式虽然方便,但是每次添加新的产品就需要修改工厂类。这就违反了开放封闭原则:软件实体(类、模块、函数)可以扩展,但是不可修改。于是,工厂方法模式出现了。所谓工厂方法模式,是指定义一个用于创建对象的接口,让子类决定实例化哪一个类。Factory Method使一个类的实例化延迟到其子类。
流程图:
测试表代码
package sample;
//简单工厂代码demo
public class FactoryDemo {
interface Product{
public void saySmoe() ;
}
interface AbstarctFactory{
Product getProduct();
}
static class ProductA implements Product{
@Override
public void saySmoe() {
System.out.println("say ProductA");
}
}
static class ProductB implements Product{
@Override
public void saySmoe() {
System.out.println("say ProductB");
}
}
static class ProductFactoryA implements AbstarctFactory{
@Override
public Product getProduct() {
return new ProductA();
}
}
static class ProductFactoryB implements AbstarctFactory{
@Override
public Product getProduct() {
return new ProductB();
}
}
public static void main(String[] args) {
AbstarctFactory productFactoryA = new ProductFactoryA();
AbstarctFactory productFactoryB = new ProductFactoryB();
productFactoryA.getProduct().saySmoe();
productFactoryB.getProduct().saySmoe();
}
}
抽象工厂模式
既然有了简单工厂模式和工厂方法模式,为什么还要有抽象工厂模式呢?它到底有什么作用呢?还是举这个例子,这家公司的技术不断进步,不仅可以生产单核处理器,也能生产多核处理器。现在简单工厂模式和工厂方法模式都鞭长莫及。抽象工厂模式登场了。它的定义为提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。具体这样应用,这家公司还是开设两个工厂,一个专门用来生产A型号的单核多核处理器,而另一个工厂专门用来生产B型号的单核多核处理器
流程图:
package sample;
//简单工厂代码demo
public class AbstractFactoryDemo {
interface ProductA{
public void saySmoe() ;
}
interface ProductB{
public void eatFood() ;
}
interface AbstarctFactory{
ProductA getProductA();
ProductB getProductB();
}
static class ProductA1 implements ProductA{
@Override
public void saySmoe() {
System.out.println("say ProductA1");
}
}
static class ProductA2 implements ProductA{
@Override
public void saySmoe() {
System.out.println("say ProductA2");
}
}
static class ProductB1 implements ProductB{
@Override
public void eatFood() {
System.out.println("say ProductB1");
}
}
static class ProductB2 implements ProductB{
@Override
public void eatFood() {
System.out.println("say ProductB2");
}
}
static class ProductFactory1 implements AbstarctFactory{
@Override
public ProductA getProductA() {
return new ProductA1();
}
@Override
public ProductB getProductB() {
return new ProductB1();
}
}
static class ProductFactory2 implements AbstarctFactory{
@Override
public ProductA getProductA() {
return new ProductA2();
}
@Override
public ProductB getProductB() {
return new ProductB2();
}
}
public static void main(String[] args) {
//构造一个制作 产品A1 和 产品B1的的工厂
AbstarctFactory abstarctFactory1 = new ProductFactory1();
abstarctFactory1.getProductA().saySmoe();
abstarctFactory1.getProductB().eatFood();
System.out.println("===================");
//构造一个制作 产品A2 和 产品B2的的工厂
AbstarctFactory abstarctFactory2 = new ProductFactory2();
abstarctFactory2.getProductA().saySmoe();
abstarctFactory2.getProductB().eatFood();
}
}
结果:
say ProductA1
say ProductB1
===================
say ProductA2
say ProductB2
免费学习视频欢迎关注云图智联:https://e.yuntuzhilian.com/