Java中常见的设计模式

目录

一、什么是设计模式 

二、设计模式的类型

        1、创建型模式

        2、结构型模式

        3、行为型模式

三、单例模式

        1、代码示例

        2、优点

        3、缺点

        4、使用场景

四、工厂模式

        1、代码示例

        2、优点

        3、缺点

五、装饰模式

        1、代码示例

        2、优点

        3、缺点

六、代理模式

        1、代码示例

        2、优点

        3、缺点

七、观察者模式

        1、代码示例

        2、优点

        3、缺点

八、尾注

---

一、什么是设计模式 

        设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设 计模式是为了重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己 于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。
        项目中合理地运用设计模式可以完美地解决很多问题，每种模式在现实 中都有相应的原理来与之对应，每种模式都描述了一个在我们周围不断重复发生的问题，以及该 问题的核心解决方案，这也是设计模式能被广泛应用的原因。

二、设计模式的类型

        总共有 23 种设计模式 ， 可以分为三大类 ： 创建型模式 ， 结构型模式 ， 行为型模式 。

        1、创建型模式

                单例模式：某个类只能有一个实例，提供一个全局的访问点。

                工厂模式：一个工厂类根据传入的参数决定创建出那一种产品类的实例。

                抽象工厂：创建相关或依赖对象的家族，而无需明确指定具体类。

                建造者模式：封装一个复杂对象的构建过程，并可以按步骤构造。

                原型模式：通过复制现有的实例来创建新的实例。

        2、结构型模式

                适配器模式：将一个类的方法接口转换成客户希望的另外一个接口。

                组合模式：将对象组合成树形结构以表示“”部分-整体“”的层次结构。

                装饰模式：动态的给对象添加新的功能。

                代理模式：为其他对象提供一个代理以便控制这个对象的访问。

                亨元模式：通过共享技术来有效的支持大量细粒度的对象。

                外观模式：对外提供一个统一的方法，来访问子系统中的一群接口。

                桥接模式：将抽象部分和它的实现部分分离，使它们都可以独立的变化。

        3、行为型模式

                模板模式：定义一个算法结构，而将一些步骤延迟到子类实现。

                解释器模式：给定一个语言，定义它的文法的一种表示，并定义一个解释器。

                策略模式：定义一系列算法，把他们封装起来，并且使它们可以相互替换。

                状态模式：允许一个对象在其对象内部状态改变时改变它的行为。

                观察者模式：对象间的一对多的依赖关系。

                备忘录模式：在不破坏封装的前提下，保持对象的内部状态。

                中介者模式：用一个中介对象来封装一系列的对象交互。

                命令模式：将命令请求封装为一个对象，使得可以用不同的请求来进行参数化。

                访问者模式：在不改变数据结构的前提下，增加作用于一组对象元素的新功能。

                责任链模式：将请求的发送者和接收者解耦，使的多个对象都有处理这个请求的机会。

                迭代器模式：一种遍历访问聚合对象中各个元素的方法，不暴露该对象的内部结构。

三、单例模式

        单例模式，它的定义就是确保某一个类只有一个实例，并且提供一个全局访问点 。

        单例模式具备典型的3个特点：①只有一个实例。②自我实例化。③提供全局访问点。

        1、代码示例

        用户消息类(UserMassage.java)

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 表示只创建了一次对象
    }
}

        2、优点

        在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例。 避免对资源的多重占用（比如写文件操作）。

        3、缺点

        没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

        4、使用场景

        ①要求生产唯一序列号。

        ②WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。

        ③创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等

        注意事项：getUserMassage() 方法中需要使用同步锁 synchronized (UserMassage.class) 防止多线程同时进入造成  UserMassage 被多次实例化。

四、工厂模式

        工厂模式定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个，也就是说工厂方法模式让实例化推迟到子类。

        1、代码示例

//面条接口类  MianTiao.java
public interface MianTiao {
    //面条描述
    public abstract void desc();
}


//兰州拉面类实现面条接口类  LzNoodles.java
public class LzNoodles implements MianTiao {
    public void desc() {
        System.out.println("这是兰州拉面");
    }
}


//泡面类实现面条接口类  PaoNoodles.java
public class PaoNoodles implements MianTiao {
    public void desc() {
        System.out.println("这是泡面");
    }
}

//烩面类实现面条接口类  HuiNoodles.java
public class HuiNoodles implements MianTiao {
    public void desc() {
        System.out.println("这是烩面");
    }
}

//面馆工厂类 SimpleNoodlesFactory.java
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();
    }
}

        2、优点

        ①一个调用者想创建一个对象，只要知道其名称就可以了。

        ②扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。

        ③屏蔽产品的具体实现，调用者只关心产品的接口。

        3、缺点

        每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定 程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。

五、装饰模式

        装饰模式是用来替代继承的一种设计模式。它通过一种无须定义子类的方式来给对象动态增加职责，使用对象之间的关联关系取代类之间的继承关系。降低了系统的耦合，可以动态的增加或者删除对象的职责。

        1、代码示例

//展示自己的接口类 Showable.java
public interface Showable {
     //定义展示行为
	public abstract void show();
}

//女友类实现展示自己的接口类 Girl.java
public class Girl implements Showable {
	public void show() {
		System.out.print("女友的素颜");
	} 
}

//抽象装饰器类 Decorator.java
public abstract class Decorator implements Showable{
    //持有一个善于展示自己某个家伙
	Showable showable;
    //构造时注入这个家伙
	public Decorator(Showable showable){
		this.showable = showable; 
	}
    //无须实现
	public abstract void show();
}

//描眉类继承装饰器类 MiaoMei.java
public class MiaoMei extends Decorator{
	public MiaoMei(Showable showable) {
		super(showable);
	}
    //重写接口化妆后展示
	public void show(){
		System.out.print("描眉(");
		showable.show();
		System.out.print(")");
	}
}

//涂口红继承装饰器类 TuKouHong.java
public class TuKouHong extends Decorator{
	public MiaoMei(Showable showable) {
		super(showable);
	}
    //重写接口化妆后展示
	public void show(){
		System.out.print("涂口红(");
		showable.show();
		System.out.print(")");
	}
}

//测试类 Main.java
public class Main {
    public static void main(String[] args) {
        //创建女友
        Girl girl = new Girl();
        //将女友放入描眉类
        MiaoMei hzp = new MiaoMei(girl);
        //将描眉后的女友放入涂口红类
        TuKouHong tkh = new TuKouHong(hzp);
        tkh.show();
    }
}
//输出结果：涂口红(描眉(女友的素颜))

        2、优点

        ①对于扩张一个对象的功能，装饰模式比继承模式更加灵活，不会导致类的数量急剧增加。

        ②可以通过一种动态的方式扩张一个类的功能，同过配置文件可以在运行时进行选择，不同的装饰类。

        ③ 可以对一个对象进行多次装饰，通过使用不同的具体装饰类以及这些装饰类的排列组合可以创造不同的行为的组合。

        3、缺点

        ① 在使用装饰模式的时候进行系统设计时会产生很多小对象，这些对象的区别在于他们之间相互连接 的方式有所不同，而不是他们的类或者属性值有所不同，大量小对象势必产生一大部分的系统资源开销，影响系统性能。

        ②装饰模式是一种比继承更加灵活的解决方案。但同时，也意味着比继承更加容易出错，更加难排长。对于多层装饰的对象，需要逐级排查，较为繁琐。

六、代理模式

        代理模式指由一个代理主题来操作真实主题，真实主题执行具体的业务操作，而代理主题负责其他相关业务的处理。比如生活中的通过代理访问网络，客户通过网络代理连接网络（具体业务），由代理服务器完成用户权限和访问限制等与上网相关的其他操作（相关业务）。

        1、代码示例

//定义Network接口类 Network.java
public interface Network {
    // 定义浏览的抽象方法
    public void browse();
}

//真实的上网操作类实现Network接口类 Real.java
public class Real implements Network{
    @Override
    //重写抽象方法
    public void browse(){
        System.out.println("上网浏览信息........");
    }
}

//代理上网类实现Network接口类 Proxy.java
public class Proxy implements Network{
    private Network network;//上网接口
    //设置代理的真实操作
    public Proxy(Network network){
         // 设置代理的子类
        this.network=network;
    }
    //身份验证操作 其他操作
    public void check(){
        System.out.println("验证账号密码是否合法");
    }
    @Override
    //代码实现上网
    public void browse(){
        //调用具体的代理业务操作
        this.check();
        //调用真实的上网操作
        this.network.browse();
    }
}

//测试类 Main.java
public class Main {
    public static void main(String[] args){
        //定义接口对象
        Network network=null;
        //实例化代理，同时传入代理的真实操作
        network=new Proxy(new Real());
        //调用代理的上网操作
        network.browse();
    }
}

        2、优点

        ①代理模式能将代理对象与真实被调用的目标对象隔离

        ②一定程度上降低了系统的耦合度，扩展性好

        ③可以起到保护目标对象的作用

        ④可以对目标对象的功能增强

        3、缺点

        ① 代理模式会造成系统设计中类的数量增加

        ②在客户端与目标对象之间增加一个代理对象，会造成请求处理速度变慢

        ③增加了系统的复杂度

七、观察者模式

        观察者模式定义了对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都将得到通知，并自动更新。观察者模式属于行为型模式，行为型模式关注的是对象之间的通讯，观察者模式就是观察者和被观察者之间的通讯。

        观察者模式有一个别名叫“发布-订阅模式”，或者说是“订阅-发布模式”，订阅者和订阅目标是联系在一起的，当订阅目标发生改变时，逐个通知订阅者。我们可以用报纸期刊的订阅来形象的说明，当你订阅了一份报纸，每天都会有一份最新的报纸送到你手上，有多少人订阅报纸，报社就会发多少份报纸，报社和订报纸的客户就是上面开头所说的“一对多”的依赖关系。

        1、代码示例

//观察者主题对象  Subject.java
//Subject 接口类
public interface Subject {
    //订阅操作
    void attach(Observer observer);
    //取消订阅操作
    void detach(Observer observer);
    //通知变动
    void notifyChanged();
}

//观察者订阅人对象 Observer.java
//Observer 接口类
public interface Observer {
    //接收变动通知
    void update();
}

//具体订阅人 RealObject.java
//RealObject 类实现 Observer 接口类
public class RealObject implements Observer {
    @Override
    public void update() {
        System.out.println("接收到了通知");
    }
}

//具体的某家奶厂 Subject.java
//RealSubject 类实现 Subject 接口类
public class RealSubject implements Subject{
    //本奶厂下订奶的人集合
    private List observerList = new ArrayList();
    //添加订阅者
    @Override
    public 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();
        }
    }
}

//测试类 Main.java
public class Main {
    public static void main(String[] args) {
        //创建奶厂
        Subject subject = new RealSubject();
        Observer observer = new RealObject();
        subject.attach(observer);
        subject.notifyChanged();
    }
}

        2、优点

        ①观察者和被观察者是抽象耦合的

        ②建立了一套触发机制

        3、缺点

        ①如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。

        ②如果观察者和观察目标间有循环依赖，可能导致系统崩溃。

        ③没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的。

---

八、尾注

        希望这篇文章对你有所帮助，记得转载、点赞、收藏，支持一下，小编将会持续更新哦