JAVA常用设计模式(一、单例模式、工厂模式)

JAVA设计模式之单例模式

 

import java.util.HashMap;
import java.util.Map;

/**
 * 设计模式之单例模式
 * 单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
 * 这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，
 * 不需要实例化该类的对象。
 * 
 * 1.单例模式只能有一个实例
 * 2.单例必须自己创建自己的唯一实例
 * 3.单例必须给其他所有对象提供这一实例
 * 
 * 主要解决：一个全局使用的类频繁地创建与销毁。
 * 
 * 何时使用：当您想控制实例数目，节省系统资源的时候。
 * 
 * @author dyq
 *
 */
public class DesignPatternSingleton {
    public static void main(String[] args) {
        SlackerSingletonObject slackerSingletonObject = SlackerSingletonObject.getInstance();
        HungrySingletonObject hungrySingletonObject = HungrySingletonObject.getInstance();
        EnumSingletonObject enumSingletonObject = EnumSingletonObject.INSTANCE;
    }
}
/**
 * 懒汉模式-单例模式
 * @author dyq
 *
 */
class SlackerSingletonObject{
    private static SlackerSingletonObject instance;
    private SlackerSingletonObject() {
        System.out.println("加载SlackerSingletonObject");
    }
    public static synchronized SlackerSingletonObject getInstance() {
        if(instance==null) {
            instance = new SlackerSingletonObject();
        }
        return instance;
    }
    public static Map<String,Object> getProFile(){
        Map<String,Object> map = new HashMap<String,Object>();
        map.put("jdbcDriver", "oracle");
        return map;
    }
}
/**
 * 饿汉模式-单例模式
 */
class HungrySingletonObject{
    private static HungrySingletonObject instance = new HungrySingletonObject();
    private String name ;
    private HungrySingletonObject() {
        System.out.println("加载HungrySingletonObject");
    }
    public static HungrySingletonObject getInstance() {
        return instance;
    }
    public static Map<String,Object> getProFile(){
        Map<String,Object> map = new HashMap<String,Object>();
        map.put("jdbcDriver", "oracle");
        return map;
    }
}


/**
 * 枚举--单例模式
 */
enum EnumSingletonObject{
    INSTANCE;
    public static Map<String,Object> getProFile(){
        Map<String,Object> map = new HashMap<String,Object>();
        map.put("jdbcDriver", "oracle");
        return map;
    }
}

JAVA设计模式之工厂模式

 

/**
 * 设计模式之工厂模式
 * 工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
 * 在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。
 * 
 * 主要解决：主要解决接口选择的问题。
 * 何时使用：我们明确地计划不同条件下创建不同实例时。
 * 如何解决：让其子类实现工厂接口，返回的也是一个抽象的产品。
 * 关键代码：创建过程在其子类执行。
 * @author dyq
 *
 */
public class DesignPatternFactory {
    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();
    }
}

interface Shape{
    public void draw();
}

class Rectangle implements Shape{
    @Override
    public void draw() {
         System.out.println("Inside Square::draw() method.");
    }
    
}
class Circle implements Shape{
    @Override
    public void draw() {
        System.out.println("Inside Circle::draw() method.");
    }
}
class Square implements Shape {
   @Override
   public void draw() {
      System.out.println("Inside Square::draw() method.");
   }
}
class ShapeFactory {
    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 {
            return new Square();
        }
    }
}