常用设计模式

QCY企鹅

于 2017-09-15 22:44:48 发布

阅读量201

点赞数

分类专栏：设计模式文章标签：设计模式

本文链接：https://blog.csdn.net/renjie3274/article/details/77996515

版权

设计模式专栏收录该内容

1 篇文章 0 订阅

订阅专栏

单例模式

概念：单例模式保证一个类中只有一个实例。
特点:
1.一个类中只能有一个实例
2.单例类必须自己创建唯一实例
3.单例类必须给其他对象提供唯一实例

分为饿汉式、饱汉式。
饿汉式：线程安全，创建类的同时就实例化出一个对象，第一次调用会很快，因为资源初始化已经完成。

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

饿汉式：
1.双检索模式：线程不安全，第一次使用的时候才会实例化对象，会延迟加在，需要实现线程安全。弊端：由于编译器存在指令重排序，所以当对象已经创建但并没有进行初始化是，可能会获得没有初始化的对象，错误可能会发生在（1）处。

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

最佳：静态内部类创建

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

策略模式

特点：将算法封装到一系列策略类里，不改变对象自身，而是通过策略对象来改变对象的行为。
例如：对整数按绝对值大小来排序，使用Integer是不行的，此时不需要修改Integer对象，只需要一个实现了Comparator接口的对象来实现控制他的排序就行。
代码示例

public static void sortByAbs(List<Integer> list){
    Collections.sort(list,new Comparator<Object>(){
        public int compare(Object o1,Object o2){
            Integer r1= Math.abs((Integer)o1);
            Integer r2= Math.abs((Integer)o2);
            return r1-r2;
        }
    })
}

示例2：

抽象策略类
public interface IStrategy{
    public void operator();
}
具体策略类
实现类1：
public Result1 implements IStartegy{
    public void operator(){
    System.out.println("result1");
    }
}
实现类2：
public Result2 implements IStartegy{
    public void operator(){
    System.out.println("result2");
    }
}
实现类3：
public Result3 implements IStartegy{
    public void operator(){
    System.out.println("result3");
    }
}
环境类:
public class Context{
private IStartegy startegy;
private Context(IStartegy startegy){
    this.startegy=  startegy;
}
public void setStartegy(IStartegy startegy){
    this.startegy=  startegy;
}
public void operator(){
    startegy.operator();
}
}

主函数
public class Main{
    public static void main(String[] args){
        Context context=null;
        //1
        context=new Context(new Restult1());
        context.operator();

        //2
        context.setStartegy(new Restult2());
        context.operator();

        //3
        context.setStartegy(new Restult3());
        context.operator();
    }
}

工厂模式

工厂模式包括简单工厂模式、抽象工厂模式、工厂模式。它们的本质都是将不变的部分提出来，将可变的部分留作接口，以达到最大程度上的复用。
1.简单工厂模式是使用一个工厂来创建新对象。以生产杯子为例，此时需要声场玻璃杯与瓷杯，按传统方式直接new对象，需要创建两条生产线，但其实只是材料不同而已，制作过程是一样的，因此只需要先将模具制作好，到时候将材料注入模具就可，但是java并不能new一个抽象类，此时就可以使用简单工厂模式。
代码示例：

abstract class Cup{
    public void operator();
}
public Glass extends Cup{
    public void operator(){
        System.out.println("glass");
    }
}
public Stone extends Cup{
    public void operator(){
        System.out.println("stone");
    }
}
//工厂类
public class Factory{
    public Cup createCup(int type){
        switch(type){
        case 0:return new Glass();break;
        case 1:return new Stone();break;
        default:return null;
        }
        return null;
    }
}
主函数：
public class Main{
    public static void main(String[] args){
    Factory factory =new Factory ();
    factory.createCup(0);
    factory.createCup(1);
    ｝
｝

缺点：每次生产新的材料的杯子时都需要更改工厂里的createCup方法

2.抽象工厂模式
抽象工厂模式对简单工厂模式进行修改，创建工厂抽象类与抽象方法，每次添加新材料的杯子只需要继承这个抽象类并重写抽象方法即可。
代码如下：

abstract class Cup{
    public void operator();
}
public Glass extends Cup{
    public void operator(){
        System.out.println("glass");
    }
}
public Stone extends Cup{
    public void operator(){
        System.out.println("stone");
    }
}
抽象工厂：
interface IFactory{
    public Cup createCup();
} 
public GlassIFtory implements IFactory{
    public Cup createCup(){
    System.out.println("glass");
    }
}
public StoneFtory implements IFactory{
    public Cup createCup(){
    System.out.println("stone");
    }
}

主函数：
public class Main{
    public static void main(String[] args){
    GlassIFtory glassIFtory =new GlassIFtory ();
    glassIFtory.create();
    StoneFtory stoneFtory =new StoneFtory ();
    stoneFtory .create();
    ｝
｝

缺点：当声场一个水壶的时候，不能在声场水杯的同时生产水壶，又需要创建一条生产线。

3.工厂模式
解决抽象工厂模式出现的问题。

代码如下：

//水杯
abstract class Cup{

}
public Glass extends Cup{
    public Glass (){
        System.out.println("glass");
    }
}
public Stone extends Cup{
    public Stone (){
        System.out.println("stone");
    }
}
//水壶
abstract class Kettle{

}
public KettleA extends Kettle{
    public KettleA (){
        System.out.println("KettleA ");
    }
}
public KettleB extends Cup{
    public KettleB (){
        System.out.println("KettleB ");
    }
}

//工厂类
interface IFactory{
    public Cup createCup();
    public Cup createKettle();
} 
public GlassIFtory implements IFactory{
    public Cup createCup(){
    return new Glass ();
    }
    public Cup createKettle(){
    return new KettleA ();
    }
}
public StoneFtory implements IFactory{
    public Cup createCup(){
    return new Stone ();
    }
    public Cup createKettle(){
    return new KettleB ();
    }
}

//主函数
public class Main{
    public static void main(String[] args){
    GlassIFtory glassIFtory =new GlassIFtory ();
    glassIFtory .createCup();
    glassIFtory .createKettle();
    StoneFtory stoneFtory =new StoneFtory ();
    stoneFtory .createCup();
    stoneFtory .createKettle();
    ｝
｝