常用设计模式

本文详细介绍了设计模式中的单例模式、工厂模式和代理模式。单例模式确保一个类只有一个实例,提供了全局访问点。工厂模式通过工厂方法创建对象,抽象了对象的创建过程。代理模式在目标对象和客户端之间充当中介,允许动态增强或拦截对象的行为。文中还讨论了设计模式的重要原则,如开闭原则、里氏代换原则等。
摘要由CSDN通过智能技术生成

1.单例模式

1、设计模式是一套代码设计经验的总结。项目中合理的运用设计模式可以巧妙的解决很多问题

2、总体来说设计模式分为三大类:

        1)创建型模式

                工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式

        2)结构型模式

                适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式

        3)行为型模式

                策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、

                备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

3、设计模式的六大原则

1)开闭原则(Open Close Principle)

开闭原则的意思是:对扩展开放,对修改关闭。在程序需要进行拓展的时候,不能去修改原有的代码,实现一个热插拔的效果。简言之,是为了使程序的扩展性好,易于维护和升级。想要达到这样的效果,我们需要使用接口和抽象类。

2)里氏代换原则(Liskov Substitution Principle)

里氏代换原则是面向对象设计的基本原则之一。 里氏代换原则中说,任何基类可以出现的地方,子类一定可以出现。LSP 是继承复用的基石,只有当派生类可以替换掉基类,且软件单位的功能不受到影响时,基类才能真正被复用,而派生类也能够在基类的基础上增加新的行为。里氏代换原则是对开闭原则的补充。实现开闭原则的关键步骤就是抽象化,而基类与子类的继承关系就是抽象化的具体实现,所以里氏代换原则是对实现抽象化的具体步骤的规范。

3)依赖倒转原则(Dependence Inversion Principle)

这个原则是开闭原则的基础,具体内容:针对接口编程,依赖于抽象而不依赖于具体。

4)接口隔离原则(Interface Segregation Principle)

这个原则的意思是:使用多个隔离的接口,比使用单个接口要好。它还有另外一个意思是:降低类之间的耦合度。由此可见,其实设计模式就是从大型软件架构出发、便于升级和维护的软件设计思想,它强调降低依赖,降低耦合。

5)迪米特法则,又称最少知道原则(Demeter Principle)

最少知道原则是指:一个实体应当尽量少地与其他实体之间发生相互作用,使得系统功能模块相对独立。

6)合成复用原则(Composite Reuse Principle)

合成复用原则是指:尽量使用合成/聚合的方式,而不是使用继承。

4、小应用也能体现大原则

5、单例模式是Java中最简单的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式

6、单例模式确保在一个应用程序中某一个类只有一个实例,而且自行实例化并向整个系统提供这个实例单例实例。单例模式只应在有真正的“单一实例”的需求时才可使用:

1)单例类只能有一个实例

2)单例类必须自己创建自己的唯一实例

3)单例类必须给所有其他对象提供这一实例

7、Java中实现单例模式可以通过两种形式实现:

懒汉模式(类加载时不初始化)

饿汉模式(在类加载时就完成了初始化,所以类加载较慢,但获取对象的速度快)

8、编写单例必要条件:

1)构造方法变成私有

2)提供一个静态方法获取单实例对象

饿汉单例相对比较容易理解,一般表现为以下两种形式:

//构造方法私有化
private static Singleton1 instance = new Singleton1();
private Singleton1() {
}


//静态代码块的方式,实例化对象
private static Singleton1 instance = null;
static {
    instance = new Singleton1();
}

构造方法私有化为例: 

/**
 * 饿汉式单例1
 */
public class Singleton1 {
    //static保证全局唯一
    private static Singleton1 instance = new Singleton1();

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    //构造方法私有化
    private Singleton1() {
    }

    //提供一个静态方法返回实例对象
    public static Singleton1 getInstance() {
        //不能保证下面代码getInstance方法调用一次,就会获取一个新对象,不能达到单例目的
        //return new Singleton1();
        //instance就是全局唯一
        return instance;
    }

    public void sayHello() {
        System.out.println("我是博肖女孩");
    }
}
public class SingletonTest {
    public static void main(String[] args) {
        //Singleton1私有的构造方法,不能在外部new
        //Singleton1 s1=new Singleton1();

        Singleton1 instance1 = Singleton1.getInstance();
        Singleton1 instance2 = Singleton1.getInstance();
        //static全局唯一,设为static后值为true
        System.out.println(instance1 == instance2);
        instance1.sayHello();
        instance1.setName("博肖");
        System.out.println(instance1.getName());
        System.out.println(instance2.getName());
    }
}

 9、饿汉模式基于classloader机制避免了多线程的同步问题(静态初始化将保证在任何线程能够访问到域之前初始化它),不过,instance在类装载时就实例化,这时候初始化instance显然没有达到lazy loading的效果

10、懒汉方式实现单例模式能够提高类加载性能,但是和饿汉模式借助与JVM的类加载内部同步机制实现了线程安全不同,需要在延迟加载时注意单例实例的线程安全性,如果简单粗暴的实现,在多线程环境中将引起运行异常,如:

/**
 * 懒汉式: 多线程, 有问题
 */
public class Singleton3 {
    //单例实例
    private static Singleton3 instance;

    //构造方法私有化
    private Singleton3() {

    }

    //提供一个静态方法,获取单例的实例对象
    public static Singleton3 getInstance() {
        //如果instance为null,就创建一个实例对象,不为null,直接返回不再创建。
        if (instance == null) {
            instance = new Singleton3();
        }
        return instance;
    }

    public static void satHello() {
        System.out.println("调用了Singleton3的sayHello的静态方法");
    }

    public void say() {
        System.out.println("调用了Singleton3的say的实例方法");
    }
}
/**
 * 多线程不一定是单例,new多个对象,对象不同
 * 多线程不稳定,DeBug断点模拟
 */
public class Singleton3Test {
    public static void main(String[] args) {
        Singleton3.satHello();//不用调用实例
        //子线程调用getInstance方法
        Thread t = new Thread(() -> {
            Singleton3 instance1 = Singleton3.getInstance();
            instance1.say();
            System.out.println("线程t的对象:" + instance1);
        });
        t.start();

        Thread t1 = new Thread(() -> {
            Singleton3 instance1 = Singleton3.getInstance();
            instance1.say();
            System.out.println("线程t1的对象:" + instance1);
        });
        t1.start();

        //主线程调用getInstance方法
        Singleton3 instance2 = Singleton3.getInstance();
        instance2.say();//调用实例
        System.out.println("主线程main的对象:" + instance2);
    }
}

单线程: 

public class SingletonTestThread {
    public static void main(String[] args) {
        Singleton3 instance1 = Singleton3.getInstance();
        Singleton3 instance2 = Singleton3.getInstance();
        System.out.println("instance1的对象:" + instance1);
        System.out.println("instance2的对象:" + instance2);
    }
}

上述代码多线程同时访问时可能会产生多个示例,甚至会破坏实例,违背单例的设计原则

11、可以为返回单例实例的方法设置同步用来保证线程安全性

/**
 * 懒汉式:多线程安全单例  方式一
 * 效率问题
 */
public class Singleton4 {
    private static Singleton4 instance;

    private Singleton4() {
    }

    //synchronized 静态方法, 锁住的Singleton4的字节码, 因为字节码是全局唯一的.
    //synchronized 静态方法, 可以解决多线程情况, 保证创建的对象是唯一的.
    public synchronized static Singleton4 getInstance() {
        if (instance == null) {
            instance = new Singleton4();
        }
        return instance;
    }

    public void say() {
        System.out.println("调用了Singleton3的say的实例方法");
    }
}
/**
 * 懒汉式
 */
public class Singleton4Test {
    public static void main(String[] args) {
        //子线程调用getInstance方法
        Thread t = new Thread(() -> {
            Singleton4 instance1 = Singleton4.getInstance();
            instance1.say();
            System.out.println(&
  • 2
    点赞
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值