面试最常见的设计模式之工厂模式

简介: 面试最常见的设计模式之工厂模式

1.什么是工厂模式,谈谈你的理解?

工厂模式(Factory Method Pattern)也叫虚拟构造函数模式或多态性工厂模式,其用意是定义一个创建产品对象的工厂接口,将实际创建性工作推迟到子类中。 工厂模式是一种创建型的设计模式。

2.工厂模式有哪些?

工厂模式可以分为简单工厂、工厂方法和抽象工厂模式 简单工厂模式严格来讲并不算是一种设计模式,更多的时候是一种编程习惯。

3.什么是简单工厂?简单工厂的基本思路是什么?并写代码举例说明?

简单工厂的实现思路是,定义一个工厂类,根据传入的参数不同返回不同的实例,被创建的实例具有共同的父类或接口。简单工厂适用于需要创建的对象较少或客户端不关心对象的创建过程的情况。

package com.example;

//定义图形类的父类图形接口
public interface Shape {
   
    //通过接口定义一个抽象的方法  接下来帮我们绘制制定的图形
    public abstract void draw();
}
package com.example;

//这是我们的的三角形图形  并实现我们的图形接口   重写方法
public class TriangleShape implements Shape {
   

    public TriangleShape(){
   
        System.out.println("三角形创建");
    }

    @Override
    public void draw() {
   
        System.out.println("这是一个三角形的图形");
    }
}
package com.example;

//这是我们的的矩形图形  并实现我们的图形接口   重写方法
public class RectShape implements Shape {
   

    public RectShape(){
   
        System.out.println("矩形创建");
    }

    @Override
    public void draw() {
   
        System.out.println("这是一个矩形的图形");
    }
}
package com.example;

//这是我们的的圆形图形  并实现我们的图形接口   重写方法
public class CircleShape implements Shape {
   

    public CircleShape(){
   
        System.out.println("圆形创建");
    }

    @Override
    public void draw() {
   
        System.out.println("这是一个圆形的图形");
    }

}
package com.example;

//定义我们的图形工厂   通过传入不同的参数做相关的逻辑判断  帮助我们创建相应的对象
public class ShapeFactory {
   
    public static Shape getShape(String type){
   
        Shape shape = null;
        if(type.equalsIgnoreCase("circle")){
   
            shape=new CircleShape();
        }else if(type.equalsIgnoreCase("rect")){
   
            shape=new RectShape();
        }else if(type.equalsIgnoreCase("triangle")){
   
            shape=new TriangleShape();
        }
        return shape;
    }
}

4.什么是工厂方法?工厂方法的基本思路是什么?并写代码举例说明?

工厂方法模式具有良好的封装性,代码结构清晰,一个对象创建是有条件约束的,如果一个调用者需要一个具体的产品对象,只要知道这个产品的类名或约束字符串即可,不用知道创建对象的过程如何,降低了模块间的耦合。工厂模式还拥有优秀的可扩展性,在增加产品类的情况下,只要适当地修改具体的工厂类或扩展一个工厂类,就可以适应变化。工厂方法模式是典型的解耦框架,高层模块只需要知道产品的抽象类或接口,其他的实现类都不用关心。

package com.test;

//通过一个接口定义一个Car 同时为其定义相关的三个接口
public interface Car {
   

    //品牌 
    public abstract void brand(); 
    //速度
    public abstract void speed(); 
    //价格 
    public abstract void price(); 

}
package com.test;

//定义一个奔驰的类  实现car  并重写相关的方法
public class BenChi implements Car {
   
     @Override 
    public void brand() {
    
        System.out.println("这是一台奔驰");
    } 
    @Override 
    public void speed(){
    
        System.out.println("快"); 
    }
     @Override 
    public void price() {
    
        System.out.println("贵"); 
    }
}
package com.test;

//定义一个奥迪的类  实现car  并重写相关的方法
public class AaoDi implements Car {
   
     @Override 
    public void brand() {
    
        System.out.println("这是一台奥迪");
    } 
    @Override 
    public void speed(){
    
        System.out.println("慢"); 
    }
     @Override 
    public void price() {
    
        System.out.println("便宜"); 
    }
}
package com.test;

//定义一个有关的Car的工厂 定义为我们产生相关相关车类型的接口方法
public interface CarFactory {
   
    public abstract Car factory(); 
}
package com.test;

//定义一个产生奔驰工厂的类  实现CarFactory  并重写相关的方法
public class BenChiFactory implements CarFactory{
   

    @Override
    public Car factory(){
   
        return new BenChi();
    }

}
package com.test;

//定义一个产生奥体工厂的类  实现CarFactory  并重写相关的方法
public class AaoDiFactory implements CarFactory{
   

    @Override
    public Car factory(){
   
        return new AaoDi();
    }

}
package com.test;

//我们最后实现的测试类
public class Main {
   
    public static void main(String[] args) {
   
        CarFactory carFactory= new BenChiFactory(); 
        Car benchi = carFactory.factory(); 
        benchi.brand(); 
        benchi.speed(); 
        benchi.price(); 
        carFactory=new AaoDiFactory(); 
        Car aodi = carFactory.factory(); 
        aodi.brand();
        aodi.speed(); 
        aodi.price(); 
    }  
}

5.什么是抽象工厂?抽象工厂的基本思路是什么?并写代码举例说明?

抽象工厂模式是工厂方法的仅一步深化,在这个模式中的工厂类不单单可以创建一个对象,而是可以创建一组对象。

package com.test;
//创建一个关于水果的接口
public interface Fruit {
   
  void printInfo();
}
package com.test;
//创建一个苹果类  实现我们的水果接口并重写我们指定的方法
public class Apple implements Fruit{
   
  @Override
  public void printInfo() {
   
    // TODO Auto-generated method stub
    System.out.println("苹果");
  }
}
package com.test;
//创建一个香蕉类  实现我们的水果接口并重写我们指定的方法
public class Banana implements Fruit{
   
  @Override
  public void printInfo() {
   
    // TODO Auto-generated method stub
    System.out.println("香蕉");
  }
}
package com.test;
//再创建一个关于蔬菜的接口 
public interface Vegetable {
   
  public void printInfo();
}
package com.test;
//创建一个西红柿的接口  实现我们的蔬菜接口   并重写指定的方法
public class Tomato implements Vegetable{
   
  @Override
  public void printInfo() {
   
    // TODO Auto-generated method stub
    System.out.println("西红柿");
  }
}
package com.test;
//创建一个白菜的接口  实现我们的蔬菜接口   并重写指定的方法
public class Cabbage implements Vegetable{
   
  @Override
  public void printInfo() {
   
    // TODO Auto-generated method stub
    System.out.println("白菜");
  }
}
package com.test;
//让我们生产水果的工厂继承总的工厂
public class FruitFactory extends PlantFactory{
   
  public static final int APPLE=1;
  public static final int BANANA=2;
  @Override
  public Fruit getFruit(int fruitType){
   
    if(fruitType==APPLE){
   
      return new Apple();
    }
    if(fruitType==BANANA){
   
      return new Banana();
    }
    return null;
  }
  @Override
  Vegetable getVegetable(int vegetableType) {
   
    // TODO Auto-generated method stub
    return null;
  }
}
package com.test;
//让我们生产蔬菜的工厂继承总的工厂
public class VegetableFactory extends PlantFactory {
   
  public static final int CABBAGE=1;
  public static final int TOMATO=2;
  @Override
  Fruit getFruit(int fruitType) {
   
    // TODO Auto-generated method stub
    return null;
  }
  @Override
  public Vegetable getVegetable(int vegetableType) {
   
    // TODO Auto-generated method stub
    if(vegetableType==CABBAGE){
   
      return new Cabbage();
    }
    if(vegetableType==TOMATO){
   
      return new Tomato();
    }
    return null;
  }
}
package com.test;
//定义我们的总的工厂  其中包含生产水果的工厂和生产蔬菜的工厂
public abstract class PlantFactory {
   
  abstract Fruit getFruit(int fruitType);
  abstract Vegetable getVegetable(int vegetableType);
}
package com.test;
//根据我们定义的静态常量去确定我们最后工厂生产的结果
public class Plantation {
   
  public static final int FRUIT=1;
  public static final int VEGETABLE=2;
  public static PlantFactory getFactory(int factoryType){
   
    if(factoryType==FRUIT){
   
      return new FruitFactory();
    }
    if(factoryType==VEGETABLE){
   
      return new VegetableFactory();
    }
    return null;
  }
}
package com.test;
//我们的测试类 
public static void main(String[] args) {
   
  // TODO Auto-generated method stub

  FruitFactory fruitFactory=(FruitFactory)Plantation.getFactory(Plantation.FRUIT);
  Apple apple=(Apple) fruitFactory.getFruit(FruitFactory.APPLE);
  apple.printInfo();

  VegetableFactory vegetableFactory=(VegetableFactory)Plantation.getFactory(Plantation.VEGETABLE);
  Tomato tomato=(Tomato) vegetableFactory.getVegetable(VegetableFactory.TOMATO);
  tomato.printInfo();
}

6.请你比较一下简单工厂、工厂方法、抽象工厂有何异同?

  • 简单工厂模式其实并不算是一种设计模式,更多的时候是一种编程习惯。简单工厂的实现思路是,定义一个工厂类,根据传入的参数不同返回不同的实例,被创建的实例具有共同的父类或接口。
  • 工厂方法模式是简单工厂的仅一步深化, 在工厂方法模式中,我们不再提供一个统一的工厂类来创建所有的对象,而是针对不同的对象提供不同的工厂。也就是说每个对象都有一个与之对应的工厂。工厂方法的实现思路是,定义一个用于创建对象的接口,让子类决定将哪一个类实例化。工厂方法模式让一个类的实例化延迟到其子类。
  • 抽象工厂模式是工厂方法的仅一步深化,在这个模式中的工厂类不单单可以创建一个对象,而是可以创建一组对象。这是和工厂方法最大的不同点。抽象工厂的实现思路是,提供一个创建一系列相关或相互依赖对象的接口,而无须指定它们具体的类。
相关文章
|
2月前
|
设计模式 Java 关系型数据库
【Java笔记+踩坑汇总】Java基础+JavaWeb+SSM+SpringBoot+SpringCloud+瑞吉外卖/谷粒商城/学成在线+设计模式+面试题汇总+性能调优/架构设计+源码解析
本文是“Java学习路线”专栏的导航文章,目标是为Java初学者和初中高级工程师提供一套完整的Java学习路线。
347 37
|
24天前
|
设计模式 缓存 Java
面试题:谈谈Spring用到了哪些设计模式?
面试题:谈谈Spring用到了哪些设计模式?
|
2月前
|
设计模式 安全 算法
【Java面试题汇总】设计模式篇(2023版)
谈谈你对设计模式的理解、七大原则、单例模式、工厂模式、代理模式、模板模式、观察者模式、JDK中用到的设计模式、Spring中用到的设计模式
【Java面试题汇总】设计模式篇(2023版)
|
3月前
|
设计模式 安全 图形学
Unity精华☀️ 面试官眼中的「设计模式」
Unity精华☀️ 面试官眼中的「设计模式」
|
3月前
|
设计模式 算法 Java
面试官:JDK中都用了哪些设计模式?
面试官:JDK中都用了哪些设计模式?
42 0
|
4月前
|
设计模式 安全 Java
Java面试题:设计模式如单例模式、工厂模式、观察者模式等在多线程环境下线程安全问题,Java内存模型定义了线程如何与内存交互,包括原子性、可见性、有序性,并发框架提供了更高层次的并发任务处理能力
Java面试题:设计模式如单例模式、工厂模式、观察者模式等在多线程环境下线程安全问题,Java内存模型定义了线程如何与内存交互,包括原子性、可见性、有序性,并发框架提供了更高层次的并发任务处理能力
73 1
|
4月前
|
设计模式 Java 数据库连接
Java面试题:简述工厂模式的种类及其应用场景,你能举个例子吗?
Java面试题:简述工厂模式的种类及其应用场景,你能举个例子吗?
29 0
|
4月前
|
设计模式 存储 缓存
Java面试题:结合设计模式与并发工具包实现高效缓存;多线程与内存管理优化实践;并发框架与设计模式在复杂系统中的应用
Java面试题:结合设计模式与并发工具包实现高效缓存;多线程与内存管理优化实践;并发框架与设计模式在复杂系统中的应用
52 0
|
4月前
|
设计模式 缓存 安全
Java面试题:设计模式在并发编程中的创新应用,Java内存管理与多线程工具类的综合应用,Java并发工具包与并发框架的创新应用
Java面试题:设计模式在并发编程中的创新应用,Java内存管理与多线程工具类的综合应用,Java并发工具包与并发框架的创新应用
37 0
|
4月前
|
设计模式 并行计算 安全
Java面试题:如何使用设计模式优化多线程环境下的资源管理?Java内存模型与并发工具类的协同工作,描述ForkJoinPool的工作机制,并解释其在并行计算中的优势。如何根据任务特性调整线程池参数
Java面试题:如何使用设计模式优化多线程环境下的资源管理?Java内存模型与并发工具类的协同工作,描述ForkJoinPool的工作机制,并解释其在并行计算中的优势。如何根据任务特性调整线程池参数
49 0