面试之设计模式

单例设计模式

解决的问题： 防止一个全局使用的类，频繁的创建和销毁
使用场景：

1. 要求生产唯一序列号。
2. WEB 中的计数器，用单例先缓存起来，不用每次刷新都在数据库里加一次。
3. 创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。

静态内部类

public class Singleton{
	private static class Holder{
		private static Singleton singleton=new Singleton();
	}
	private Singleton(){}
	public static Singleton getSingleton(){
		return Holder.singleton;
	}
	//在序列化完成后readResolve返回的对象将替代readObject的，不会创建新对象
 	private Object readResolve() {
     	return singleton;
 	}
}

枚举方式

public enum Singleton{
	INSTANCE;
	public Singleton getInstance(){
		return this.INSTANCE;
	}
}

工厂模式

解决的问题： 接口选择的，明确知道不同条件下创建不同对象的问题。
使用场景： 日志记录器：可以选择日志记录在本地硬盘、远程服务器等
优点： 使用者只要知道对象的名称就可以使用了，并且扩展性高，只要增加一个工厂类就可以了
缺点： 每次增加一个产品时都要增加一个具体类和对象实现工厂，也增加了系统具体类的依赖。
注意事项： 工厂模式适合复杂对象的创建，对于简单对象只需要new就可以解决的问题，不要使用工厂模式，因为会增加系统复杂度。

具体实现：
结构：

步骤1： 创建一个接口：

public interface Shape {
	void draw();
}

步骤2： 创建实现接口的具体类
Rectangle的j类

public class Rectangle implements Shape{
	@Override
	public void draw() {
		System.out.println("Rectangle创建对象");
	}
}

Square的类

public class Square implements Shape {
	@Override
	public void draw() {
		System.out.println("Square创建对象");
	}
}

Circle的类

public class Circle implements Shape {
	@Override
	public void draw() {
		System.out.println("Circle创建对象");
	}
}

步骤3：
创建一个工厂，根据给定的类名称返回对象

public class ShapeFactory {
	public Shape getShape(String shapeType){
		if(null==shapeType){
			return null;
		}
		if(shapeType.equalsIgnoreCase("CIRCLE")){
			return new Circle();
		}else if(shapeType.equalsIgnoreCase("SQUARE")){
			return new Square();
		}else if(shapeType.equalsIgnoreCase("RECTANGLE")){
			return new Rectangle();
		}
		return null;
	}
}

步骤4： 测试

public class FactoryPatternDemo {
	public static void main(String[] args) {
		ShapeFactory factory=new ShapeFactory();
		
		//获取circle，并调用draw方法
		Shape circle = factory.getShape("CIRCLE");
		circle.draw();
		
		//获取square对象，并调用draw方法
		Shape square = factory.getShape("SQUARE");
		square.draw();
		
		//获取rectangle对象，并调用draw方法
		Shape rectangle = factory.getShape("RECTANGLE");
		rectangle.draw();	
	}	
}

测试结果：

Circle创建对象
Square创建对象
Rectangle创建对象

参考链接：https://www.runoob.com/design-pattern/factory-pattern.html

抽象工厂模式

解决的问题： 系统里有多个产品族，而每次只消费其中的某一个产品
使用场景： qq换一整套皮肤，生成不同操作系统的程序
优点： 当一个产品族中只使用多个对象被设计成一起工作时，可以保证客户端只使用同一个产品族中的对象
缺点： 扩展困难。
注意事项： 产品族难扩展，产品易于扩展。
比上面的工厂模式多了一层，工厂接口继承一个抽象工厂，外界可以访问抽象工厂来获取工厂接口然后创建具体类对象执行操作。
实现：
结构：

步骤1： 创建形状工厂接口和颜色接口
形状接口：

public interface Shape {
	void draw();
}

颜色接口：

public interface Color {
	public void fill();
}

步骤2： 创建实现接口的具体类
Rectangle的j类实现形状接口

public class Rectangle implements Shape{
	@Override
	public void draw() {
		System.out.println("Rectangle创建对象");
	}
}

Square的类实现形状接口

public class Square implements Shape {
	@Override
	public void draw() {
		System.out.println("Square创建对象");
	}
}

Circle的类实现形状接口

public class Circle implements Shape {
	@Override
	public void draw() {
		System.out.println("Circle创建对象");
	}
}

Red类实现颜色接口

public class Red implements Color {
	@Override
	public void fill() {
		System.out.println("我是红色");
	}
}

Green类实现颜色接口

public class Green implements Color{
	@Override
	public void fill() {
		System.out.println("我是绿色");
	}
}

Blue类实现颜色接口

public class Blue implements Color {
	@Override
	public void fill() {
		System.out.println("我是蓝色");
	}
}

步骤3： 为Shape和Color创建抽象工厂类来获取工厂对象

public abstract class AbstractFactory {
	public abstract Color getColor(String color);
	public abstract Shape getShape(String shape);
}

步骤4： 创建扩展抽象工厂类的实现类，基于给定的对象名称创建具体对象
形状工厂

public class ShapeFactory extends AbstractFactory {   
   @Override
   public Shape getShape(String shapeType){
      if(shapeType == null){
         return null;
      }        
      if(shapeType.equalsIgnoreCase("CIRCLE")){
         return new Circle();
      } else if(shapeType.equalsIgnoreCase("RECTANGLE")){
         return new Rectangle();
      } else if(shapeType.equalsIgnoreCase("SQUARE")){
         return new Square();
      }
      return null;
   }
   @Override
   public Color getColor(String color) {
      return null;
   }
}

颜色工厂

public class ColorFactory extends AbstractFactory {
    
   @Override
   public Shape getShape(String shapeType){
      return null;
   }
   
   @Override
   public Color getColor(String color) {
      if(color == null){
         return null;
      }        
      if(color.equalsIgnoreCase("RED")){
         return new Red();
      } else if(color.equalsIgnoreCase("GREEN")){
         return new Green();
      } else if(color.equalsIgnoreCase("BLUE")){
         return new Blue();
      }
      return null;
   }
}

步骤5： 创建工厂生成器类，通过给定的工厂名称生成工厂

public class FactoryProducer {
   public static AbstractFactory getFactory(String choice){
      if(choice.equalsIgnoreCase("SHAPE")){
         return new ShapeFactory();
      } else if(choice.equalsIgnoreCase("COLOR")){
         return new ColorFactory();
      }
      return null;
   }
}

测试： 使用 FactoryProducer 来获取 AbstractFactory，通过传递类型信息来获取实体类的对象。

public class AbstractFactoryPatternDemo {

	public static void main(String[] args) {
		//获取形状工厂
	      AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE");
	 
	      //获取形状为 Circle 的对象
	      Shape shape1 = shapeFactory.getShape("CIRCLE");
	 
	      //调用 Circle 的 draw 方法
	      shape1.draw();
	 
	      //获取形状为 Rectangle 的对象
	      Shape shape2 = shapeFactory.getShape("RECTANGLE");
	 
	      //调用 Rectangle 的 draw 方法
	      shape2.draw();
	      
	      //获取形状为 Square 的对象
	      Shape shape3 = shapeFactory.getShape("SQUARE");
	 
	      //调用 Square 的 draw 方法
	      shape3.draw();
	 
	      //获取颜色工厂
	      AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");
	 
	      //获取颜色为 Red 的对象
	      Color color1 = colorFactory.getColor("RED");
	 
	      //调用 Red 的 fill 方法
	      color1.fill();
	 
	      //获取颜色为 Green 的对象
	      Color color2 = colorFactory.getColor("Green");
	 
	      //调用 Green 的 fill 方法
	      color2.fill();
	 
	      //获取颜色为 Blue 的对象
	      Color color3 = colorFactory.getColor("BLUE");
	 
	      //调用 Blue 的 fill 方法
	      color3.fill();
	}
	
}

结果：

Circle创建对象
Rectangle创建对象
Square创建对象
我是红色
我是绿色
我是蓝色

参考链接：https://www.runoob.com/design-pattern/abstract-factory-pattern.html