java 常见的设计模式 1. 什么是设计模式？ 设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设 计模式是为了重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己 于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同 大厦的一块块砖石一样。项目中合理地运用设计模式可以完美地解决很多问题，每种模式在现实 中都有相应的原理来与之对应，每种模式都描述了一个在我们周围不断重复发生的问题，以及该 问题的核心解决方案，这也是设计模式能被广泛应用的原因。 2. 设计模式的类型 总共有 23 种设计模式 ， 可以分为三大类 ： 创建型模式 ， 结构型模式 ， 行为型模式 。 创建型模式 单例模式：某个类只能有一个实例，提供一个全局的访问点。 工厂模式：一个工厂类根据传入的参数决定创建出那一种产品类的实例。 抽象工厂：创建相关或依赖对象的家族，而无需明确指定具体类。 建造者模式：封装一个复杂对象的构建过程，并可以按步骤构造。 原型模式：通过复制现有的实例来创建新的实例。 结构型模式 适配器模式：将一个类的方法接口转换成客户希望的另外一个接口。 组合模式：将对象组合成树形结构以表示 “” 部分 - 整体 “” 的层次结构。 装饰模式：动态的给对象添加新的功能。 代理模式：为其他对象提供一个代理以便控制这个对象的访问。 亨元模式：通过共享技术来有效的支持大量细粒度的对象。 外观模式：对外提供一个统一的方法，来访问子系统中的一群接口。 桥接模式：将抽象部分和它的实现部分分离，使它们都可以独立的变化。 行为型模式 模板模式：定义一个算法结构，而将一些步骤延迟到子类实现。 解释器模式：给定一个语言，定义它的文法的一种表示，并定义一个解释器。 策略模式：定义一系列算法，把他们封装起来，并且使它们可以相互替换。 状态模式：允许一个对象在其对象内部状态改变时改变它的行为。 观察者模式：对象间的一对多的依赖关系。 备忘录模式：在不破坏封装的前提下，保持对象的内部状态。 中介者模式：用一个中介对象来封装一系列的对象交互。 命令模式：将命令请求封装为一个对象，使得可以用不同的请求来进行参数化。 访问者模式：在不改变数据结构的前提下，增加作用于一组对象元素的新功能。 责任链模式：将请求的发送者和接收者解耦，使的多个对象都有处理这个请求的机会。 迭代器模式：一种遍历访问聚合对象中各个元素的方法，不暴露该对象的内部结构。 3. 单例模式 单例模式，它的定义就是确保某一个类只有一个实例，并且提供一个全局访问点 。 单例模式具备典型的 3 个特点： 1 、只有一个实例。 2 、自我实例化。 3 、提供全局访问点。 代码示例 优点 在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例。 避免对资源的多重占用（比如写文件操作）。 缺点 没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来 实例化 使用场景： 1 、要求生产唯一序列号。 2 、 WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。
/**
* 用户消息类
* @author Administrator
*
*/
public class UserMassage {
//创建静态对象
public static UserMassage umsg = new UserMassage();
//对外部提供一个公共的访问方法
public static UserMassage getUserMassage(){
return umsg;
}
//一个普通方法
public void show(){
System.out.println("我是单例模式");
}
}
//测试
public static void main(String[] args) {
UserMassage msg1 = UserMassage.getUserMassage();
msg1.show();
UserMassage msg2 = UserMassage.getUserMassage();
msg2.show();
System.out.println(msg1.equals(msg2)); //输出结果为true 表示只创建了一次对象
}代码示例
/**
* 面条类
*/
public interface MianTiao {
//面条描述
public abstract void desc();
}
/**
* 兰州拉面
*/
public class LzNoodles implements MianTiao {
public void desc() {
System.out.println("这是兰州拉面");
}
}
/**
* 泡面
*/
public class PaoNoodles implements MianTiao {
public void desc() {
System.out.println("这是泡面");
}
}
/**
* 河南烩面
*/
public class HuiNoodles implements MianTiao {
public void desc() {
System.out.println("这是河南烩面");
}
}
/**
* 面馆工厂
*/
public class SimpleNoodlesFactory {
public static final int TYPE_LZ = 1;//兰州拉面
public static final int TYPE_PM = 2;//泡面
public static final int TYPE_HM = 3;//河南烩面
//根据用户的选择 创建不同的面
public static MianTiao createNoodles(int type) {
switch (type) {
case TYPE_LZ:
return new LzNoodles();
case TYPE_PM:
return new PaoNoodles();
case TYPE_HM:
default:
return new HuiNoodles();
}
}
}
public static void main(String[] args) {
//调用面馆 传入我需要生产面
MianTiao mian =
SimpleNoodlesFactory.createNoodles(SimpleNoodlesFactory.TYPE_HM);
mian.desc();
}/**
* 展示自己的接口
*/
public interface Showable {
public abstract void show();//定义展示行为
}
/**
* 女友类
* @author Administrator
*
*/
public class Girl implements Showable{
@Override
public void show() {System.out.println("女友的素颜");
}
}
/**
* 抽象装饰器
* @author Administrator
*
*/
public abstract class Decorator implements Showable{
Showable showable ;//持有一个善于展示自己某个家伙
//构造时注入这个家伙
public Decorator(Showable showable){
this.showable = showable;
}
public abstract void show(); //无须实现 因为装饰器现在还不知道要怎么化妆
}
/**
* 描眉类继承装饰器类
*/
public class MiaoMei extends Decorator{
public MiaoMei(Showable showable) {
super(showable);//调用化妆品父类
}
//重写接口化妆后展示 描眉 化妆
public void show(){
System.out.println("描眉(");
showable.show();
System.out.println(")");
}
}
/**
* 涂口红继承装饰器类
*/
public class TuKouHong extends Decorator{
public TuKouHong(Showable showable) {
super(showable);//调用化妆品父类
}
//重写接口化妆后展示 涂口红 化妆
public void show(){
System.out.println("涂口红(");
showable.show();
System.out.println(")");
}
}
public static void main(String[] args) {
//创建女友
Girl girl = new Girl();
//将女友放入描眉类
MiaoMei hzp = new MiaoMei(girl);
//将描眉后的女友放入涂口红类
TuKouHong tkh = new TuKouHong(hzp);
tkh.show();
}
输出结果：涂口红(描眉(女友的素颜))器完成用户权限和访问限制等与上网相关的其他操作（相关业务）。
/*
* 定义Network接口
*/
public interface Network {
public void browse(); // 定义浏览的抽象方法
}
/*
* 真实的上网操作
*/
public class Real implements Network {
//重写抽象方法
public void browse() {
System.out.println("上网浏览信息！");
}
}
/*
* 代理上网
*/
public class Proxy implements Network {
private Network network;
// 设置代理的真实操作
public Proxy(Network network) {
this.network = network; // 设置代理的子类
}
// 身份验证操作 其他操作
public void check() {
System.out.println("检查用户是否合法！");
}
//代码实现上网
public void browse() {
this.check(); // 调用具体的代理业务操作
this.network.browse(); // 调用真实的上网操作
}
}
public static void main(String args[]) {
Network net = null; // 定义接口对象
net = new Proxy(new Real()); // 实例化代理，同时传入代理的真实操作
net.browse(); // 调用代理的上网操作
}/**
* 观察者主题对象
*/
public interface Subject {
/**
* 订阅操作
*/
void attach(Observer observer);
/**
* 取消订阅操作
*/
void detach(Observer observer);
/**
* 通知变动
*/
void notifyChanged();
}
/**
* 观察者订阅人对象
*/
public interface Observer {
/**
* 接收变动通知
*/
void update();
}
/**
* 具体订阅人
*/
public static class RealObject implements Observer {
@Override
public void update() {
System.out.println("接收到了通知");
}
}
/*
* 具体的某家奶厂
*/
public static class RealSubject implements Subject{
//本奶厂下订奶的人集合
private List<Observer> observerList = new ArrayList<Observer>();
//添加订阅者
@Overridepublic void attach(Observer observer) {
observerList.add(observer);
}
//删除订阅者
@Override
public void detach(Observer observer) {
observerList.remove(observer);
}
//消息通知订阅者
@Override
public void notifyChanged() {
for (Observer observer : observerList) {
observer.update();
}
}
}
public static void main(String[] args) {
Subject subject = new RealSubject(); //创建奶厂
Observer observer = new RealObject();//创建订阅人
subject.attach(observer);//订阅subject奶厂
subject.notifyChanged();//奶厂发布消息 订阅者接收
}- 观察者和被观察者是抽象耦合的
- 建立了一套触发机制
- 如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间
- 如果观察者和观察目标间有循环依赖，可能导致系统崩溃
- 没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的