设计模式(工厂\抽象工厂\单例)

最新推荐文章于 2024-09-04 15:29:36 发布

辰若月熙

最新推荐文章于 2024-09-04 15:29:36 发布

阅读量67

点赞数

文章标签： java java-ee 开发语言

原文链接：https://www.runoob.com/design-pattern/design-pattern-tutorial.html

版权

工厂模式

流程图引用一下链接
工厂模式

步骤1

**Shape.java**

    public interface Shape{
        void draw();
    }

步骤2

**Rectangle.java**

    public class Rectangle implements Shape{
        @Override
        public void draw(){
            System.out.println("Inside Rectangle::draw() method.")
        }
    }

**Square.java**

public class Square implements Shape {
 
   @Override
   public void draw() {
      System.out.println("Inside Square::draw() method.");
   }
}

**Circle.java**

public class Circle implements Shape {
 
   @Override
   public void draw() {
      System.out.println("Inside Circle::draw() method.");
   }
}

步骤3

创建一个工厂,生成基于给定信息的实体类的对象

**ShapeFactory.java**

public class ShapeFactory {
    
   //使用 getShape 方法获取形状类型的对象
   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;
   }
}

步骤4

使用该工厂,通过传递类型信息来获取实体类的对象

**FactoryPatternDemo.java**

public class FactoryPatternDemo {
 
   public static void main(String[] args) {
      ShapeFactory shapeFactory = new ShapeFactory();
 
      //获取 Circle 的对象，并调用它的 draw 方法
      Shape shape1 = shapeFactory.getShape("CIRCLE");
 
      //调用 Circle 的 draw 方法
      shape1.draw();
 
      //获取 Rectangle 的对象，并调用它的 draw 方法
      Shape shape2 = shapeFactory.getShape("RECTANGLE");
 
      //调用 Rectangle 的 draw 方法
      shape2.draw();
 
      //获取 Square 的对象，并调用它的 draw 方法
      Shape shape3 = shapeFactory.getShape("SQUARE");
 
      //调用 Square 的 draw 方法
      shape3.draw();
   }
}

步骤5

执行结果

Inside Circle::draw() method.
Inside Rectangle::draw() method.
Inside Square::draw() method.

抽象工厂模式

流程图引用一下链接
抽象工厂模式

在这里插入图片描述

步骤1

为形状创建一个接口

public interface Shape {
   void draw();
}

步骤2

创建实现接口实体类Rectangle.java

public class Rectangle implements Shape {
 
   @Override
   public void draw() {
      System.out.println("Inside Rectangle::draw() method.");
   }
}
**Square.java**

public class Square implements Shape {
 
   @Override
   public void draw() {
      System.out.println("Inside Square::draw() method.");
   }
}

**Circle.java**

public class Circle implements Shape {
 
   @Override
   public void draw() {
      System.out.println("Inside Circle::draw() method.");
   }
}

步骤3

为颜色创建一个接口

public interface Color {
   void fill();
}

步骤4

创建实现接口的实体类

**Red.java**
public class Red implements Color {
 
   @Override
   public void fill() {
      System.out.println("Inside Red::fill() method.");
   }
}

**Green.java**
public class Green implements Color {
 
   @Override
   public void fill() {
      System.out.println("Inside Green::fill() method.");
   }
}

**Blue.java**
public class Blue implements Color {
 
   @Override
   public void fill() {
      System.out.println("Inside Blue::fill() method.");
   }
}

步骤5

为Color和Shape对象创建抽象类来获取工厂

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

步骤6

创建扩展了 AbstractFactory 的工厂类，基于给定的信息生成实体类的对象。

**ShapeFactory.java**
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;
   }
}

**ColorFactory.java**
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;
   }
}

步骤7

创建一个工厂创造器/生成器类，通过传递形状或颜色信息来获取工厂。


**FactoryProducer.java**
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;
   }
}

步骤8

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

**AbstractFactoryPatternDemo.java**
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();
   }
}

执行结果

执行程序，输出结果：

Inside Circle::draw() method.
Inside Rectangle::draw() method.
Inside Square::draw() method.
Inside Red::fill() method.
Inside Green::fill() method.
Inside Blue::fill() method.

单例模式

流程图引用一下链接
单例模式

在这里插入图片描述

步骤1

创建一个 Singleton 类。


**SingleObject.java**
public class SingleObject {
 
   //创建 SingleObject 的一个对象
   private static SingleObject instance = new SingleObject();
 
   //让构造函数为 private，这样该类就不会被实例化
   private SingleObject(){}
 
   //获取唯一可用的对象
   public static SingleObject getInstance(){
      return instance;
   }
 
   public void showMessage(){
      System.out.println("Hello World!");
   }
}

步骤2

从 singleton 类获取唯一的对象。


**SingletonPatternDemo.java**
public class SingletonPatternDemo {
   public static void main(String[] args) {
 
      //不合法的构造函数
      //编译时错误：构造函数 SingleObject() 是不可见的
      //SingleObject object = new SingleObject();
 
      //获取唯一可用的对象
      SingleObject object = SingleObject.getInstance();
 
      //显示消息
      object.showMessage();
   }
}

步骤3

输出结果

Hello World!

单例模式的集中实现方式

懒汉式,线程不安全
是否Lazy初始化: 是
是否多线程安全:否
实现难度:易
描述: 不支持多线程,没有加锁synchronized

public class Singleton {  
   private static Singleton instance;  
   private Singleton (){}  

   public static Singleton getInstance() {  
   if (instance == null) {  
      instance = new Singleton();  
   }  
   return instance;  
   }  
}

懒汉式,线程安全

是否Lazy初始化:是
是否是线程安全:是
实现难度:易
优点: 第一次调用才初始化,避免内存浪费
缺点: 必须加锁synchronized才能保证单例,但加锁会影响效率

 public class Singleton {  
      private static Singleton instance;  
      private Singleton (){}  
      public static synchronized Singleton getInstance() {  
      if (instance == null) {  
         instance = new Singleton();  
      }  
      return instance;  
      }  
   }

饿汉式,线程安全

是否Lazy初始化:否
是否多线程安全: 是
实现难度:易
优点: 执行效率高一点

public class Singleton {  
    private static Singleton instance = new Singleton();  
    private Singleton (){}  
    public static Singleton getInstance() {  
    return instance;  
    }  
}

双检锁/双重校验锁
优点:采用双锁机制,安全且在多线程情况下能保持高性能

public class Singleton {  
    private volatile static Singleton singleton;  
    private Singleton (){}  
    public static Singleton getSingleton() {  
    if (singleton == null) {  
        synchronized (Singleton.class) {  
        if (singleton == null) {  
            singleton = new Singleton();  
        }  
        }  
    }  
    return singleton;  
    }  
}

登记式/静态内部类

public class Singleton {  
    private static class SingletonHolder {  
    private static final Singleton INSTANCE = new Singleton();  
    }  
    private Singleton (){}  
    public static final Singleton getInstance() {  
    return SingletonHolder.INSTANCE;  
    }  
}

枚举


public enum Singleton {  
    INSTANCE;  
    public void whateverMethod() {  
    }  
}

一般情况下，不建议使用第 1 种和第 2 种懒汉方式，建议使用第 3 种饿汉方式。只有在要明确实现 lazy loading 效果时，才会使用第 5 种登记方式。如果涉及到反序列化创建对象时，可以尝试使用第 6 种枚举方式。如果有其他特殊的需求，可以考虑使用第 4 种双检锁方式。

private static class SingletonHolder {  
private static final Singleton INSTANCE = new Singleton();  
}  
private Singleton (){}  
public static final Singleton getInstance() {  
return SingletonHolder.INSTANCE;  
}

}


6. 枚举

```java

public enum Singleton {  
    INSTANCE;  
    public void whateverMethod() {  
    }  
}

辰若月熙

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
设计模式(工厂\抽象工厂\单例)

工厂模式流程图引用一下链接工厂模式#mermaid-svg-GnK94S46XO4bCC3A {font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}#mermaid-svg-GnK94S46XO4bCC3A .error-icon{fill:#552222;}#mermaid-svg-GnK94S46XO4bCC3A .error-text{fill:#552222;stroke:#552222;}
复制链接

扫一扫