JAVA常用的七种设计模式

学习设计模式之前,我们先要了解一下设计模式的怎么来的?

对于设计人员,特别是开发人员吗,往往受限于眼界或经验不能够体会到设计原则的实用性,或者在处理具体问题时,不知道如何把设计原则应用到到设计和代码,因此产生了“模式”。
随着参与的项目越来越多,人们发现:很多问题并不是一个项目中出现的,它会在很多的项目中出现。于是人们就把这些问题总结出来,然后给出了解决这些问题的方案,而这些方案–“模式”(解决问题的套路)。

设计模式的分类

1.创建模式:创建一些特殊的对象,或者在特殊要求下创建对象。
2.结构模式:主要利用组合/聚合或者继承,让类与类能够形成某种关联关系 – 代理。
3.行为模式:刻画了类和对象交换及分配职责的方式。

接下来我们正式介绍七种常用的设计模式

单例模式

1.饿汉模式(最基本的单例模式)

类加载时,会直接实例化单例对象,以后都返回该对象的引用。

  • 缺点:类加载时,会直接实例化单例对象,不管是否使用到该单例对象,浪费内存。
  • 优点:没有枷锁,执行效率高,线程安全的实例。
	public class Singleton{
		private Singleton{
		}
		//创建本类的私有构造方法
		private static Singleton singleton = new Singleton();
		
		public static Singleton getInstance(){
			return singleton;
		}
	}

2.懒汉模式(线程不安全、线程安全但效率低)

不要直接在类加载时实例化,而是在调用方法时,再实例化。

  • 优点:不会占用内存
  • 缺点:安全方面 单线程情况下,是安全的,但是在多线程下,多个线程可能同时执行singleton == null 都为true,会创建多个实例在内存中。
	public class LazySingleton{
		private LazySingleton(){
		}
		
		private static LazySingleton singleton;
		
		public static LazySingleton getInstance(){
			if(singleton == null){
				singleton = new LazySingleton();
			}
			return singleton;
		}
	}

2.1懒汉模式(双重检验模式(线程安全,且效率高的) 把锁的粒度变小,只锁第一次初始化时)

  • 实例会在调用getInstance方法时创建,仅在第一调用初始化时需要锁住。
		public class LazySingleton{
		private LazySingleton(){
		}
		
		private static LazySingleton singleton;
		
		public static LazySingleton getInstance(){
		/*
            双重检验
            首先先判断实例是否为null,为null则使用synchronized锁住类,
            然后在同步块中,再一次判断实例是否为null,为null则初始化实例。
            synchronized(需要锁的对象){}
        */
			if(singleton == null){
				synchronized(LazySingleton .class){
					if(singleton == null){
						singleton = new LazySingleton();
					}
				}
			}
			return singleton;
		}
	}

3.内部类实现模式

通过静态内部类,完成单例模式的创建。

  • 在外部类加载时,并不会加载内部类,也就是不会执行new 实例(),这属于懒加载。
  • 只有第一次调用getInstance方法时,才会加载。
	public class InnerSingleton{
		private InnerSingleton(){
		}
		
		private static class Inner{
			private static InnerSingleton instance = new InnerSingleton();
		}
		
		public static InnerSingleton getInstance(){
			return Inner.instance;
		}
	}

4.枚举实现

通过枚举创建 单例模式。

  • 实现单例的最佳方法。简洁,支持自动序列化机制,防止多次实例化,但目前还没有被广泛采用。
	public class EnumSingleton{
		private EnumSingleton(){
			
		}
		
		private static enum SinEnum{
			//自定义的枚举值,如果没有该自定义枚举值,无法获取枚举对象
			SIN;
			private EnumSingleton es = new EnumSingleton();
		}
		
		public static EnumSingleton getInstance(){
			SinEnum s = SinEnum.SIN;
			return s.es;
		}
	}

工厂模式

讲使用者和对象的生产者进行分离。

在工厂模式中,几乎都有三种角色,工厂(抽象工厂、具体工厂) 产品(抽象产品、具体产品) 使用者。使用者想要使用产品,不用自己去生产产品,把生产的动作交给工厂去做,使用者只需要从工厂提供产品的位置(方法)去拿就好。

  • 1.简单工厂模式–顾客需要给出清单。
    变化点在产品对象上,所以我们会抽象产品,然后通过一个工厂,根据不同的情况产生不同的产品对象。

  • 2.工厂方法模式–根据工厂能产生什么顾客拿什么。
    工厂可以产生统一品牌的商品,会根据商品去抽象工厂,对每一个产品,提供一个工厂实现类。

  • 3.抽象工厂模式–根据工厂能产生什么顾客拿什么,但是工厂能产生的产品会有多种品牌。
    超级工厂,可以生产不同品牌的各种产品,抽象出超级工厂,也要抽象出产品,然后根据不同的品牌给出该品牌商品的工工厂实现类。

原型模式

根据一个已经存在的对象,创建一个和他一样的对象。-- 克隆

浅克隆-- 利用Object中clone()实现

1.让被克隆的类实现Cloneable接口。

2.重写clone方法,方法访问修饰符public。

3.对象.clone()的方式的到一个一样的对象。

浅克隆指,被克隆的对象会产生一个新的,但是对象属性不会产生。

	public class Man implements Cloneable {
		private String name;
		public Car car = new Car();
		
		public Man clone() throws CloneNotSupportedException{
			Object obj = super.clone();
			return (Man)obj;
		}
	}

深度克隆

1.克隆对象所涉及的自定义类,需要实现序列化接口。

2.在需要克隆的类中,添加一个方法,完成序列化反序列化即可。

	public class Man implements Cloneable,Serializable {
		private String name;
		public Car car = new Car();
			
		public Man depthClone() throws IOException, ClassNotFoundException {
			//获取对象信息,把当前对象写入另一块内存
	        ByteArrayOutputStream bo = new ByteArrayOutputStream();
	        ObjectOutputStream objOut = new ObjectOutputStream(bo);
	        objOut.writeObject(this);
	
	        //读取内存 创建对象
	        ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
	        ObjectInputStream objIn = new ObjectInputStream(bi);
	        Object obj = objIn.readObject();
	        return (Man) obj;
			}
		}

代理模式

1.静态代理

根据目标对象需要代理的行为,抽象出一个接口(包含了需要代理的行为),目标类和代理类都需要去实现该接口,然后将目标对象注入到代理类中,此时就可以在代理类中调用目标对象的行为,并为止附加非功能性逻辑。

2.动态代理之JDK代理

  • 第一步,实现接口InvocationHandler,然后重写invoke方法,在invoke方法中调用目标对的方法。

  • 第二步,提供一个自定义的方法,通过Proxy.newProxyInstance()得到代理对象。

	public class LivePeople implements InvocationHandler {

    private IEat target;//目标对象

    public LivePeople(IEat target) {
        this.target = target;
    }

    //获取代理对象
    public Object getProxy() {
        //Proxy()类中的newProxyInstance()方法
        /*
            第一个参数:目标对象的类加载器
            第二个参数:目标对象实现的所有接口
            第三个参数:代理类的对象
         */
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);

    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("订餐");
        Object returnInfo = method.invoke(target, args);//执行目标对象的方法
        System.out.println("结账,开发票");
        return returnInfo;
    }
}

3.动态代理之Cglib代理

  • 第一步,导入Cglib依赖(包)。

  • 第二步,实现接口MethodInterceptor,重写intercept方法,在其中完成目标对象的方法调用。

  • 第三步,提供自定义方法,通过工具类获取得到代理对象。

	public class CglibProxy implements MethodInterceptor {

    private IEat target;

    public CglibProxy(IEat target) {
        this.target = target;
    }

    //给目标对象创建代理对象(自定义)
    public Object getProxyInstance() {
        //创建工具栏对象
        Enhancer en = new Enhancer();
        //设置目标对象父类
        en.setSuperclass(target.getClass());
        //设置回调函数
        en.setCallback(this);
        //创建代理对象
        return en.create();
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("订餐");
        Object returnInfo = methodProxy.invokeSuper(o, objects);//调用目标对象的方法并传入参数
        System.out.println("付款,开发票");
        return returnInfo;
    }
}

装饰器模式

对象功能的扩展能够根据需要来动态地实现。

以咖啡举例:

  • 1.根据对象抽象一个公共的接口。

  • 2.根据接口给出不同的实现类(主料类(主料类产生的对象就是被装饰的对象) 和 配料类–装饰类)。

  • 3.在配料类中注入被装饰的对象。

  • 4.生产咖啡时,先生产主料(被修饰的对象),然后用配料不断去修饰主料。

适配器模式

使得原本不兼容的两个接口(功能)可以兼容 – 搭建了两个接口间的桥梁。

	class Tel{
    public void call(){}
	}
	class Carame{
	    public void make(){}
	}
	class Phone extends Tel{
	    private Carame c = new Carame();
	    public void make(){
	        c.make();
	    }
	}

实现适配器的方案,继承或者依赖(推荐使用)

优点:

  • 可以让没有任何关联的类,一起运行;

  • 提高了类的复用

  • 灵活性好

缺点:

  • 过多的使用适配器,会导致系统非常混乱,不容具体把控

  • java是单继承。

观察者模式

  • 主题类(由它产生的对象 就是 被观察的对象) 继承 Observable的类。
    在主题类,需要针对主题(价格的变化进行关注,设置变化点,然后通知观察者价格有了变化)。
	public class Product extends Observable {
    private double price;
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
        // 通知观察者注意到主题的变化
        this.setChanged();// 设置变化点
        this.notifyObservers(price);//通知观察者
    }
}
  • 观察者类(由它产生的对象 就是 观察者) 实现Observer接口。
    重写update(当主题发生变化时,会调用方法)。
	public class ProductProxy1 implements Observer {
    private double price;
    /**
     * 当主题类的值发生变化后,会调用该方法
     * @param o 主题对象
     * @param arg 主题更新的值对象
     */
    @Override
    public void update(Observable o, Object arg) {
        double factoryPrice = (double) arg;
        this.price = factoryPrice * 1.5;
    }
    public double getPrice() {
        return price;
    }
}
  • 首先产生主题对象(被观察对象),产生观察者对象,然后给主题对象设置观察者,最后通过更改主题的值,测试观察者是否有观测到主题值的改变。
	public class Test {
    public static void main(String[] args) {
        // 产生主题对象  -- 被观察者
        Product product = new Product();
        // 产生观察者
        ProductProxy1 p1 = new ProductProxy1();
        // 给主题对象添加观察者
        product.addObserver(p1);
        // 主题发生变化
        product.setPrice(1000);
        System.out.println("出厂价格:"+ product.getPrice() +
                           "\n代理商售卖价格:" + p1.getPrice());
        // 主题发生变化
        product.setPrice(2000);
        System.out.println("出厂价格:"+ product.getPrice() + 
                           "\n代理商售卖价格:" + p1.getPrice());
    }
}

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
©️2022 CSDN 皮肤主题:大白 设计师:CSDN官方博客 返回首页
评论 4

打赏作者

青梧w

你的鼓励将是我创作的最大动力

¥2 ¥4 ¥6 ¥10 ¥20
输入1-500的整数
余额支付 (余额:-- )
扫码支付
扫码支付:¥2
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值