写点什么

超详细:常用的设计模式汇总

  • 2021 年 11 月 12 日
  • 本文字数:3935 字

    阅读完需:约 13 分钟



枚举


public?enum?Singleton { ?


INSTANCE; ?


public?void?whateverMethod()?{ ?


} ?


}


这种方式是 Effective Java 作者 Josh Bloch 提倡的方式,它不仅能避免多线程同步问题,而且还能防止反序列化重新创建新的对象,可谓是很坚强的壁垒啊,不过,个人认为由于 1.5 中才加入 enum 特性,用这种方式写不免让人感觉生疏。




双重校验锁


public?class?Singleton?{ ?


private?volatile?static?Singleton singleton; ?


private?Singleton?(){} ?


public?static?Singleton?getSingleton()?{ ?


if?(singleton ==?null) { ?


synchronized?(Singleton.class) { ?


if?(singleton ==?null) { ?


singleton =?new?Singleton(); ?


} ?


} ?


} ?


return?singleton; ?


} ?


}


总结:我个人比较喜欢静态内部类写法和饿汉式写法,其实这两种写法能够应付绝大多数情况了。其他写法也可以选择,主要还是看业务需求吧。


观察者模式


对象间一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新。



观察者模式 UML 图


看不懂图的人端着小板凳到这里来,给你举个栗子:假设有三个人,小美(女,28),老王和老李。小美很漂亮,很风骚,老王和老李是两个中年男屌丝,时刻关注着小美的一举一动。有一天,小美说了一句:我老公今天不在家,一个人好无聊啊~~~,这句话被老王和老李听到了,结果乐坏了,蹭蹭蹭,没一会儿,老王就冲到小美家门口了,于是进门了……………………..帕~啪啪啪啪啪~ 在这里,小美是被观察者,老王和老李是观察者,被观察者发出一条信息,然后观察者们进行相应的处理,看代码:


public?interface?Person?{


//老王和老李通过这个接口可以接收到小美发过来的消息


void?getMessage(String s);


}


这个接口相当于老王和老李的电话号码,小美发送通知的时候就会拨打 getMessage 这个电话,拨打电话就是调用接口,看不懂没关系,先往下看


public?class?LaoWang?implements?Person?{


private?String name =?"老王";


public?LaoWang()?{


}


@Override


public?void?getMessage(String s)?{


System.out.println(name +?"接到了小美打过来的电话,电话内容是:"?+ s);


}


}


public?class?LaoLi?implements?Person?{


private?String name =?"老李";


public?LaoLi()?{


}


@Override


public?void?getMessage(String s)?{


System.out.println(name +?"接到了小美打过来的电话,电话内容是:->"?+ s);


}


}


代码很简单,我们再看看小美的代码:


public?class?XiaoMei?{


List<Person>?list?=?new?ArrayList<Person>();


public?XiaoMei(){


}


public?void?addPerson(Person person){


list.add(person);


}


//遍历 list,把自己的通知发送给所有暗恋自己的人


public?void?notifyPerson()?{


for(Person person:list){


person.getMessage("今天家里就我一个人,你们过来吧,谁先过来谁就能得到我!");


}


}


}


我们写一个测试类来看一下结果对不对


public?class?Test?{


public?static?void?main(String[] args)?{


XiaoMei xiao_mei =?new?XiaoMei();


LaoWang lao_wang =?new?LaoWang();


LaoLi lao_li =?new?LaoLi();


//老王和老李在小美那里都注册了一下


xiao_mei.addPerson(lao_wang);


xiao_mei.addPerson(lao_li);


//小美向老王和老李发送通知


xiao_mei.notifyPerson();


}


}


运行结果我截图了



运行结果


完美~~~


装饰者模式


【一线大厂Java面试题解析+后端开发学习笔记+最新架构讲解视频+实战项目源码讲义】
浏览器打开:qq.cn.hn/FTf 免费领取
复制代码


对已有的业务逻辑进一步的封装,使其增加额外的功能,如 Java 中的 IO 流就使用了装饰者模式,用户在使用的时候,可以任意组装,达到自己想要的效果。 举个栗子,我想吃三明治,首先我需要一根大大的香肠,我喜欢吃奶油,在香肠上面加一点奶油,再放一点蔬菜,最后再用两片面包夹一下,很丰盛的一顿午饭,营养又健康。(ps:不知道上海哪里有卖好吃的三明治的,求推荐~)那我们应该怎么来写代码呢? 首先,我们需要写一个 Food 类,让其他所有食物都来继承这个类,看代码:


public?class?Food?{


private?String food_name;


public?Food()?{


}


public?Food(String food_name)?{


this.food_name = food_name;


}


public?String?make()?{


return?food_name;


};


}


代码很简单,我就不解释了,然后我们写几个子类继承它:


//面包类


public?class?Bread?extends?Food?{


private?Food basic_food;


public?Bread(Food basic_food)?{


this.basic_food = basic_food;


}


public?String?make()?{


return?basic_food.make()+"+面包";


}


}


//奶油类


public?class?Cream?extends?Food?{


private?Food basic_food;


public?Cream(Food basic_food)?{


this.basic_food = basic_food;


}


public?String?make()?{


return?basic_food.make()+"+奶油";


}


}


//蔬菜类


public?class?Vegetable?extends?Food?{


private?Food basic_food;


public?Vegetable(Food basic_food)?{


this.basic_food = basic_food;


}


public?String?make()?{


return?basic_food.make()+"+蔬菜";


}


}


这几个类都是差不多的,构造方法传入一个 Food 类型的参数,然后在 make 方法中加入一些自己的逻辑,如果你还是看不懂为什么这么写,不急,你看看我的 Test 类是怎么写的,一看你就明白了


public?class?Test?{


public?static?void?main(String[] args)?{


Food food =?new?Bread(new?Vegetable(new?Cream(new?Food("香肠"))));


System.out.println(food.make());


}


}


看到没有,一层一层封装,我们从里往外看:最里面我 new 了一个香肠,在香肠的外面我包裹了一层奶油,在奶油的外面我又加了一层蔬菜,最外面我放的是面包,是不是很形象,哈哈~ 这个设计模式简直跟现实生活中一摸一样,看懂了吗? 我们看看运行结果吧



运行结果


一个三明治就做好了~~~


适配器模式


将两种完全不同的事物联系到一起,就像现实生活中的变压器。假设一个手机充电器需要的电压是 20V,但是正常的电压是 220V,这时候就需要一个变压器,将 220V 的电压转换成 20V 的电压,这样,变压器就将 20V 的电压和手机联系起来了。


public?class?Test?{


public?static?void?main(String[] args)?{


Phone phone =?new?Phone();


VoltageAdapter adapter =?new?VoltageAdapter();


phone.setAdapter(adapter);


phone.charge();


}


}


// 手机类


class?Phone?{


public?static?final?int?V =?220;// 正常电压 220v,是一个常量


private?VoltageAdapter adapter;


// 充电


public?void?charge()?{


adapter.changeVoltage();


}


public?void?setAdapter(VoltageAdapter adapter)?{


this.adapter = adapter;


}


}


// 变压器


class?VoltageAdapter?{


// 改变电压的功能


public?void?changeVoltage()?{


System.out.println("正在充电...");


System.out.println("原始电压:"?+ Phone.V +?"V");


System.out.println("经过变压器转换之后的电压:"?+ (Phone.V -?200) +?"V");


}


}



工厂模式


简单工厂模式:一个抽象的接口,多个抽象接口的实现类,一个工厂类,用来实例化抽象的接口


// 抽象产品类


abstract?class?Car?{


public?void?run();


public?void?stop();


}


// 具体实现类


class?Benz?implements?Car?{


public?void?run()?{


System.out.println("Benz 开始启动了。。。。。");


}


public?void?stop()?{


System.out.println("Benz 停车了。。。。。");


}


}


class?Ford?implements?Car?{


public?void?run()?{


System.out.println("Ford 开始启动了。。。");


}


public?void?stop()?{


System.out.println("Ford 停车了。。。。");


}


}


// 工厂类


class?Factory?{


public?static?Car?getCarInstance(String type)?{


Car c =?null;


if?("Benz".equals(type)) {


c =?new?Benz();


}


if?("Ford".equals(type)) {


c =?new?Ford();


}


return?c;


}


}


public?class?Test?{


public?static?void?main(String[] args)?{


Car c = Factory.getCarInstance("Benz");


if?(c !=?null) {


c.run();


c.stop();


}?else?{


System.out.println("造不了这种汽车。。。");


}


}


}


工厂方法模式:有四个角色,抽象工厂模式,具体工厂模式,抽象产品模式,具体产品模式。不再是由一个工厂类去实例化具体的产品,而是由抽象工厂的子类去实例化产品


// 抽象产品角色


public?interface?Moveable?{


void?run();


}


// 具体产品角色


public?class?Plane?implements?Moveable?{


@Override


public?void?run()?{


System.out.println("plane....");


}


}


public?class?Broom?implements?Moveable?{


@Override


public?void?run()?{


System.out.println("broom.....");


}


}


// 抽象工厂


public?abstract?class?VehicleFactory?{


abstract?Moveable?create();


}


// 具体工厂


public?class?PlaneFactory?extends?VehicleFactory?{


public?Moveable?create()?{


return?new?Plane();


}


}


public?class?BroomFactory?extends?VehicleFactory?{


public?Moveable?create()?{


return?new?Broom();


}


}


// 测试类


public?class?Test?{


public?static?void?main(String[] args)?{


VehicleFactory factory =?new?BroomFactory();


Moveable m = factory.create();


m.run();


}


}


抽象工厂模式:与工厂方法模式不同的是,工厂方法模式中的工厂只生产单一的产品,而抽象工厂模式中的工厂生产多个产品


/抽象工厂类


public?abstract?class?AbstractFactory?{


public?abstract?Vehicle?createVehicle();


public?abstract?Weapon?createWeapon();


public?abstract?Food?createFood();


}


//具体工厂类,其中 Food,Vehicle,Weapon 是抽象类,


public?class?DefaultFactory?extends?AbstractFactory{


@Override


public?Food?createFood()?{


return?new?Apple();


}


@Override


public?Vehicle?createVehicle()?{


return?new?Car();


}


@Override


public?Weapon?createWeapon()?{


return?new?AK47();


}


}


//测试类


public?class?Test?{


public?static?void?main(String[] args)?{


AbstractFactory f =?new?DefaultFactory();


Vehicle v = f.createVehicle();


v.run();


Weapon w = f.createWeapon();


w.shoot();


Food a = f.createFood();

评论

发布
暂无评论
超详细:常用的设计模式汇总