超详细：常用的设计模式汇总
枚举
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 中的 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();
评论