Java设计单例模式

定义

java中单例模式是一种常见的设计模式：懒汉式单例、饿汉式单例
单例模式有以下特点：
1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。

作用

单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。
线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。
选择单例模式就是为了避免不一致状态。
eg：
1.每台计算机可以有若干个打印机，但只能有一个Printer Spooler，以避免两个打印作业同时输出到打印机中。
2.每台计算机可以有若干通信端口，系统应当集中管理这些通信端口，以避免一个通信端口同时被两个请求同时调用`

实现

//饿汉单例模式
public class Singleton{
      private static Singleton instance = new Singleton();
      //私有构造方法，保证外界无法直接实例化
      private Singleton(){ }
      //通过公有的静态方法获取对象实例
      public static Singleton getInstance(){
           return instance;
      }
}

//懒汉单例模式
public class Singleton{
      private static Singleton instance = null;
      //私有构造方法，保证外界无法直接实例化
      private Singleton(){ }
      //通过公有的静态方法获取对象实例
      public static Singleton getInstance(){
           if(instance==null){
                  instance = new Singleton();
           }
           return instance;
      }
}

Java工厂模式

定义

“工厂”表示一个负责创建其他类型对象的类。
一个工厂的类有一个对象以及与它关联的多个方法。客户端使用某些参数调用此方法之后，工厂会据此创建所需类型的对象，然后将它们返回给客户端。

优势

1.在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。
2.松耦合，即对象的创建可以独立于类的实现
3.可以轻松地在工厂中添加其他类来创建相应的对象，而这无需更改客户端代码

简单工厂模式

定义一个工厂，根据参数不同返回不同的实例，被创建实例具有共同的父类或接口

适用于：创建对象少，客户端不关心对象创建过程、

父类接口
public interface Shape {
    void draw();
}

编写具体的类
//圆形
public class CircleShape implements Shape{
    public CircleShape() { System.out.println("CircleShape:created");}
    @Override
    public void draw() { System.out.println("draw:Circledraw");}
}
//正方形
public class RectShape implements Shape{
    public RectShape() {System.out.println("RectShape:created");}
    @Override
    public void draw() {System.out.println("draw:RectShape");}
}
//三角形
public class TriangleShape implements Shape{
    public TriangleShape() {System.out.println("TriangelShape:created");}
    @Override
    public void draw() {System.out.println("draw:TriangleShape");}
}

工厂类实现
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;
    }
}
简单工厂核心：为工厂类传入不同的type可以new不同的类，但返回结果都为Shape型

工厂方法模式

不再提供统一的工厂类来创建所有的对象，而是针对不同的对象提供不同的工厂。
每个对象都有一个与其对应的工厂

适用场景：客户端不知道对象的类，可以通过子类创建指定对象
实现思路：用于创建对象接口，子类决定将哪一个类实例化。工厂方法模式让一个类的实例化延迟到其子类

父类接口
public interface Shape {
    void draw();
}

编写具体的类
//圆形
public class CircleShape implements Shape{
    @Override
    public void draw() { System.out.println("draw:Circledraw");}
}
//正方形
public class RectShape implements Shape{
    @Override
    public void draw() {System.out.println("draw:RectShape");}
}
//三角形
public class TriangleShape implements Shape{
    @Override
    public void draw() {System.out.println("draw:TriangleShape");}
}

定义抽象工厂接口
public interface ShapeFactory{
         Shape getShape();
}

每个类提供一个工厂，继承工厂接口
public class CircleShapeFactory implements ShapeFactory{
     @Override
     public Shape getShape() { return new CircleShape();}
}
public class RectShapeFactory implements ShapeFactory{
     @Override
     public Shape getShape() { return new RectShape();}
}
public class TriangleShapeFactory implements ShapeFactory{
     @Override
     public Shape getShape() { return new TriangleShape();}
}

抽象工厂模式

策略模式

策略模式，是一种比较简单的模式。
它的目的是定义一组算法，将每个算法都封装起来，并且使它们之间可以互换。
其用意是针对一组算法，将每一个算法封装到具有共同接口的独立的类中，从而使得它们可以相互替换，使得算法可以在不影响到客户端的情况下发生变化。
优势
提供了管理相关的算法族的办法
提供了可以替换继承关系的办法
劣势
客户端必须知道所有的策略类
策略模式造成很多的策略类，臃肿

观察者模式

观察者模式，它的目的是定义对象间一种一对多的依赖关系，使得每当一个对象改变状态，则所有依赖于它的对象都会得到通知并被自动更新。
优势
观察者和被观察者之间是抽象耦合
支持广播通信
劣势
一个主题有多个直接或间接的观察者，则通知所有的观察者会花费很多时间，且开发和调试都比较复杂。
观察者模式没有提供相应的机制使观察者知道所观察的对象是如何发生变化

责任链模式

责任链模式一种常见的行为模式，它的目的是使多个对象都有机会处理请求，从而避免了请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止。

装饰器模式

装饰器的目的是动态地给一个对象添加一些额外的职责，这个对象的类型不会发生变化，但是行为却发生了改变。

适配器模式

适配器的目的是将一个类的接口变换成客户端所期待的另一种接口，就是可以将一个对象包装成另外的一个接口。

Java设计模式