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

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.请你比较一下简单工厂、工厂方法、抽象工厂有何异同？

• 简单工厂模式其实并不算是一种设计模式,更多的时候是一种编程习惯。简单工厂的实现思路是,定义一个工厂类,根据传入的参数不同返回不同的实例,被创建的实例具有共同的父类或接口。
• 工厂方法模式是简单工厂的仅一步深化, 在工厂方法模式中,我们不再提供一个统一的工厂类来创建所有的对象,而是针对不同的对象提供不同的工厂。也就是说每个对象都有一个与之对应的工厂。工厂方法的实现思路是,定义一个用于创建对象的接口,让子类决定将哪一个类实例化。工厂方法模式让一个类的实例化延迟到其子类。
• 抽象工厂模式是工厂方法的仅一步深化,在这个模式中的工厂类不单单可以创建一个对象,而是可以创建一组对象。这是和工厂方法最大的不同点。抽象工厂的实现思路是,提供一个创建一系列相关或相互依赖对象的接口,而无须指定它们具体的类。