java常用的设计模式总结归纳

谁践踏了优雅 2022-05-22 13:04 160阅读 0赞

java设计模式有23种，他们分别是：

*  创建型模式：[单例模式][Link 1]、抽象工厂模式、建造者模式、[工厂模式][Link 2]、原型模式。
 *  结构型模式：[适配器模式][Link 3]、桥接模式、[装饰器模式][Link 4]、组合模式、[外观模式][Link 5]、享元模式、代理模式。
 *  行为型模式：模版方法模式、命令模式、迭代器模式、[观察者模式][Link 6]、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式(责任链模式)、访问者模式。

在这里我们只介绍6种常用的设计模式：

##### 1.单例模式 #####

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

**注意：**

*  1、单例类只能有一个实例。
 *  2、单例类必须自己创建自己的唯一实例。
 *  3、单例类必须给所有其他对象提供这一实例。

单例模式有好多种，什么饿汉模式和懒汉模式，下面介绍的这种方式采用双锁机制，安全且在多线程情况下能保持高性能。

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;  
        }  
    }

##### 2.工厂模式 #####

工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

实现步骤如下：

①、创建一个接口

public interface Shape {
       void draw();
    }

②、创建实现接口的实现类

public class Rectangle implements Shape {
     
       @Override
       public void draw() {
          System.out.println("Inside Rectangle::draw() method.");
       }
    }

public class Square implements Shape {
     
       @Override
       public void draw() {
          System.out.println("Inside Square::draw() method.");
       }
    }

public class Circle implements Shape {
     
       @Override
       public void draw() {
          System.out.println("Inside Circle::draw() method.");
       }
    }

③、创建一个工厂，生成基于给定信息的实体类的对象。

public class ShapeFactory {
        
       //使用 getShape 方法获取形状类型的对象
       public Shape getShape(String shapeType){
          if(shapeType == null){
             return null;
          }        
          if(shapeType.equalsIgnoreCase("CIRCLE")){
             return new Circle();
          } else if(shapeType.equalsIgnoreCase("RECTANGLE")){
             return new Rectangle();
          } else if(shapeType.equalsIgnoreCase("SQUARE")){
             return new Square();
          }
          return null;
       }
    }

④、使用该工厂，通过传递类型信息来获取实体类的对象。

public class FactoryPatternDemo {
     
       public static void main(String[] args) {
          ShapeFactory shapeFactory = new ShapeFactory();
     
          //获取 Circle 的对象，并调用它的 draw 方法
          Shape shape1 = shapeFactory.getShape("CIRCLE");
     
          //调用 Circle 的 draw 方法
          shape1.draw();
     
          //获取 Rectangle 的对象，并调用它的 draw 方法
          Shape shape2 = shapeFactory.getShape("RECTANGLE");
     
          //调用 Rectangle 的 draw 方法
          shape2.draw();
     
          //获取 Square 的对象，并调用它的 draw 方法
          Shape shape3 = shapeFactory.getShape("SQUARE");
     
          //调用 Square 的 draw 方法
          shape3.draw();
       }
    }

⑤、 执行程序，输出结果：

Inside Circle::draw() method.
    Inside Rectangle::draw() method.
    Inside Square::draw() method.

##### 3.适配器模式 #####

适配器模式（Adapter Pattern）是作为两个不兼容的接口之间的桥梁。这种类型的设计模式属于结构型模式，它结合了两个独立接口的功能。

这种模式涉及到一个单一的类，该类负责加入独立的或不兼容的接口功能。举个真实的例子，读卡器是作为内存卡和笔记本之间的适配器。您将内存卡插入读卡器，再将读卡器插入笔记本，这样就可以通过笔记本来读取内存卡。

我们通过下面的实例来演示适配器模式的使用。其中，音频播放器设备只能播放 mp3 文件，通过使用一个更高级的音频播放器来播放 vlc 和 mp4 文件。

步骤如下：

①、为媒体播放器和更高级的媒体播放器创建接口。

public interface MediaPlayer {
       public void play(String audioType, String fileName);
    }

public interface AdvancedMediaPlayer { 
       public void playVlc(String fileName);
       public void playMp4(String fileName);
    }

②、创建实现了 AdvancedMediaPlayer 接口的实体类。

public class VlcPlayer implements AdvancedMediaPlayer{
       @Override
       public void playVlc(String fileName) {
          System.out.println("Playing vlc file. Name: "+ fileName);      
       }
     
       @Override
       public void playMp4(String fileName) {
          //什么也不做
       }
    }

public class Mp4Player implements AdvancedMediaPlayer{
     
       @Override
       public void playVlc(String fileName) {
          //什么也不做
       }
     
       @Override
       public void playMp4(String fileName) {
          System.out.println("Playing mp4 file. Name: "+ fileName);      
       }
    }

③、创建实现了 MediaPlayer 接口的适配器类。

public class MediaAdapter implements MediaPlayer {
     
       AdvancedMediaPlayer advancedMusicPlayer;
     
       public MediaAdapter(String audioType){
          if(audioType.equalsIgnoreCase("vlc") ){
             advancedMusicPlayer = new VlcPlayer();       
          } else if (audioType.equalsIgnoreCase("mp4")){
             advancedMusicPlayer = new Mp4Player();
          }  
       }
     
       @Override
       public void play(String audioType, String fileName) {
          if(audioType.equalsIgnoreCase("vlc")){
             advancedMusicPlayer.playVlc(fileName);
          }else if(audioType.equalsIgnoreCase("mp4")){
             advancedMusicPlayer.playMp4(fileName);
          }
       }
    }

④、创建实现了 MediaPlayer 接口的实体类。

public class AudioPlayer implements MediaPlayer {
       MediaAdapter mediaAdapter; 
     
       @Override
       public void play(String audioType, String fileName) {    
     
          //播放 mp3 音乐文件的内置支持
          if(audioType.equalsIgnoreCase("mp3")){
             System.out.println("Playing mp3 file. Name: "+ fileName);         
          } 
          //mediaAdapter 提供了播放其他文件格式的支持
          else if(audioType.equalsIgnoreCase("vlc") 
             || audioType.equalsIgnoreCase("mp4")){
             mediaAdapter = new MediaAdapter(audioType);
             mediaAdapter.play(audioType, fileName);
          }
          else{
             System.out.println("Invalid media. "+
                audioType + " format not supported");
          }
       }   
    }

⑤、使用 AudioPlayer 来播放不同类型的音频格式。

public class AdapterPatternDemo {
       public static void main(String[] args) {
          AudioPlayer audioPlayer = new AudioPlayer();
     
          audioPlayer.play("mp3", "beyond the horizon.mp3");
          audioPlayer.play("mp4", "alone.mp4");
          audioPlayer.play("vlc", "far far away.vlc");
          audioPlayer.play("avi", "mind me.avi");
       }
    }

⑥、执行程序，输出结果：

Playing mp3 file. Name: beyond the horizon.mp3
    Playing mp4 file. Name: alone.mp4
    Playing vlc file. Name: far far away.vlc
    Invalid media. avi format not supported

##### 4.装饰器模式 #####

装饰器模式（Decorator Pattern）允许向一个现有的对象添加新的功能，同时又不改变其结构。这种类型的设计模式属于结构型模式，它是作为现有的类的一个包装。

这种模式创建了一个装饰类，用来包装原有的类，并在保持类方法签名完整性的前提下，提供了额外的功能。

装饰模式为已有类动态附加额外的功能就像LOL、王者荣耀等类Dota游戏中，英雄升级一样。每次英雄升级都会附加一个额外技能点学习技能。具体的英雄就是ConcreteComponent，技能栏就是装饰器Decorator，每个技能就是ConcreteDecorator；

//Component 英雄接口 
    public interface Hero {
        //学习技能
        void learnSkills();
    }
    //ConcreteComponent 具体英雄盲僧
    public class BlindMonk implements Hero {
        
        private String name;
        
        public BlindMonk(String name) {
            this.name = name;
        }
    
        @Override
        public void learnSkills() {
            System.out.println(name + "学习了以上技能！");
        }
    }
    //Decorator 技能栏
    public class Skills implements Hero{
        
        //持有一个英雄对象接口
        private Hero hero;
        
        public Skills(Hero hero) {
            this.hero = hero;
        }
    
        @Override
        public void learnSkills() {
            if(hero != null)
                hero.learnSkills();
        }    
    }
    //ConreteDecorator 技能：Q
    public class Skill_Q extends Skills{
        
        private String skillName;
    
        public Skill_Q(Hero hero,String skillName) {
            super(hero);
            this.skillName = skillName;
        }
    
        @Override
        public void learnSkills() {
            System.out.println("学习了技能Q:" +skillName);
            super.learnSkills();
        }
    }
    //ConreteDecorator 技能：W
    public class Skill_W extends Skills{
    
        private String skillName;
    
        public Skill_W(Hero hero,String skillName) {
            super(hero);
            this.skillName = skillName;
        }
    
        @Override
        public void learnSkills() {
            System.out.println("学习了技能W:" + skillName);
            super.learnSkills();
        }
    }
    //ConreteDecorator 技能：E
    public class Skill_E extends Skills{
        
        private String skillName;
        
        public Skill_E(Hero hero,String skillName) {
            super(hero);
            this.skillName = skillName;
        }
    
        @Override
        public void learnSkills() {
            System.out.println("学习了技能E:"+skillName);
            super.learnSkills();
        }
    }
    //ConreteDecorator 技能：R
    public class Skill_R extends Skills{    
        
        private String skillName;
        
        public Skill_R(Hero hero,String skillName) {
            super(hero);
            this.skillName = skillName;
        }
        
        @Override
        public void learnSkills() {
            System.out.println("学习了技能R:" +skillName );
            super.learnSkills();
        }
    }
    //客户端：召唤师
    public class Player {
        public static void main(String[] args) {
            //选择英雄
            Hero hero = new BlindMonk("李青");
            
            Skills skills = new Skills(hero);
            Skills r = new Skill_R(skills,"猛龙摆尾");
            Skills e = new Skill_E(r,"天雷破/摧筋断骨");
            Skills w = new Skill_W(e,"金钟罩/铁布衫");
            Skills q = new Skill_Q(w,"天音波/回音击");
            //学习技能
            q.learnSkills();
        }
    }

输出：

学习了技能Q:天音波/回音击
    学习了技能W:金钟罩/铁布衫
    学习了技能E:天雷破/摧筋断骨
    学习了技能R:猛龙摆尾
    李青学习了以上技能！

##### 5.外观模式 #####

外观模式（Facade Pattern）隐藏系统的复杂性，并向客户端提供了一个客户端可以访问系统的接口。这种类型的设计模式属于结构型模式，它向现有的系统添加一个接口，来隐藏系统的复杂性。

这种模式涉及到一个单一的类，该类提供了客户端请求的简化方法和对现有系统类方法的委托调用。

我们将创建一个 *Shape* 接口和实现了 *Shape* 接口的实体类。下一步是定义一个外观类 *ShapeMaker*。

*ShapeMaker* 类使用实体类来代表用户对这些类的调用。*FacadePatternDemo*，我们的演示类使用 *ShapeMaker* 类来显示结果。

①、创建一个接口。

public interface Shape {
       void draw();
    }

②、 创建实现接口的实体类。

public class Rectangle implements Shape {
     
       @Override
       public void draw() {
          System.out.println("Rectangle::draw()");
       }
    }

public class Square implements Shape {
     
       @Override
       public void draw() {
          System.out.println("Square::draw()");
       }
    }

public class Circle implements Shape {
     
       @Override
       public void draw() {
          System.out.println("Circle::draw()");
       }
    }

③、创建一个外观类。

public class ShapeMaker {
       private Shape circle;
       private Shape rectangle;
       private Shape square;
     
       public ShapeMaker() {
          circle = new Circle();
          rectangle = new Rectangle();
          square = new Square();
       }
     
       public void drawCircle(){
          circle.draw();
       }
       public void drawRectangle(){
          rectangle.draw();
       }
       public void drawSquare(){
          square.draw();
       }
    }

④、使用该外观类画出各种类型的形状。

public class FacadePatternDemo {
       public static void main(String[] args) {
          ShapeMaker shapeMaker = new ShapeMaker();
     
          shapeMaker.drawCircle();
          shapeMaker.drawRectangle();
          shapeMaker.drawSquare();      
       }
    }

⑤、执行程序，输出结果：

Circle::draw()
    Rectangle::draw()
    Square::draw()

##### 6.观察者模式 #####

当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知它的依赖对象。观察者模式属于行为型模式。

观察者模式，我理解的就是观察者订阅被观察者的状态，当被观察者状态改变的时候会通知所有订阅的观察者的过程。所以以下这种写法会让大家更加容易理解一些。

观察者接口：

public abstract class Observer {    
        public abstract void update(String msg);
    }

第一个观察者：

public class F_Observer extends Observer {
        public void update(String msg) {
            System.out.println(F_Observer.class.getName() + " : " + msg);
        }
    }

第二个观察者：

public class S_Observer extends Observer {
        public void update(String msg) {
            System.out.println(S_Observer.class.getName() + " : " + msg);
        }
    }

第三个观察者：

public class T_Observer extends Observer {
        public void update(String msg) {
            System.out.println(T_Observer.class.getName() + " : " + msg);
        }
    }

被观察者：

public class Subject {        
        private List<Observer> observers = new ArrayList<>();    //状态改变    
        public void setMsg(String msg) {        
            notifyAll(msg);    
        }   
         //订阅    
        public void addAttach(Observer observer) {        
            observers.add(observer);    
        }    
        //通知所有订阅的观察者    
        private void notifyAll(String msg) {        
            for (Observer observer : observers) {            
                observer.update(msg);        
            }   
        }
    }

使用方法：

public class Main {
           
        public static void main(String[] args) {
               
            F_Observer fObserver = new F_Observer();        
            S_Observer sObserver = new S_Observer();        
            T_Observer tObserver = new T_Observer();                
            Subject subject = new Subject();        
            subject.addAttach(fObserver);        
            subject.addAttach(sObserver);        
            subject.addAttach(tObserver);                
            subject.setMsg("msg change");    
        }
    }

[Link 1]: https://github.com/youlookwhat/DesignPattern#3-%E5%8D%95%E4%BE%8B%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F
[Link 2]: https://github.com/youlookwhat/DesignPattern#2-%E5%B7%A5%E5%8E%82%E6%A8%A1%E5%BC%8F
[Link 3]: https://github.com/youlookwhat/DesignPattern#5-%E9%80%82%E9%85%8D%E5%99%A8%E6%A8%A1%E5%BC%8F
[Link 4]: https://github.com/youlookwhat/DesignPattern#7-%E8%A3%85%E9%A5%B0%E8%80%85%E6%A8%A1%E5%BC%8F
[Link 5]: https://github.com/youlookwhat/DesignPattern#8-%E5%A4%96%E8%A7%82%E6%A8%A1%E5%BC%8F
[Link 6]: https://github.com/youlookwhat/DesignPattern#1-%E8%A7%82%E5%AF%9F%E8%80%85%E6%A8%A1%E5%BC%8F