23种设计模式与6大设计原则学习

最新推荐文章于 2021-11-11 23:56:49 发布

任错错

最新推荐文章于 2021-11-11 23:56:49 发布

阅读量278

点赞数

本文链接：https://blog.csdn.net/qq_36250202/article/details/101022057

版权

设计模式:

设计模式（Design pattern）代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。

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

设计模式分为三大类：
创建型模式：这些设计模式提供了一种在创建对象的同时隐藏创建逻辑的方式，而不是使用 new 运算符直接实例化对象。这使得程序在判断针对某个给定实例需要创建哪些对象时更加灵活。

共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
结构型模式：这些设计模式提供了一种在创建对象的同时隐藏创建逻辑的方式，而不是使用 new 运算符直接实例化对象。这使得程序在判断针对某个给定实例需要创建哪些对象时更加灵活。

共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
行为型模式：这些设计模式特别关注对象之间的通信。

共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

J2EE模式:这些设计模式特别关注表示层。这些模式是由 Sun Java Center 鉴定的。

MVC 模式（MVC Pattern）
业务代表模式（Business Delegate Pattern）
组合实体模式（Composite Entity Pattern）
数据访问对象模式（Data Access Object Pattern）
前端控制器模式（Front Controller Pattern）
拦截过滤器模式（Intercepting Filter Pattern）
服务定位器模式（Service Locator Pattern）
传输对象模式（Transfer Object Pattern）

第 1 章策略模式【Strategy Pattern】

小故事：刘备要到江东娶老婆了，走之前诸葛亮给赵云（伴郎）三个锦囊妙计，说是按天机拆开解决棘手问题，

嘿，还别说，真是解决了大问题，搞到最后是周瑜陪了夫人又折兵呀，那咱们先看看这个场景是什么样子

的。先说这个场景中的要素：三个妙计，一个锦囊，一个赵云，妙计是小亮同志给的，妙计是放置在锦囊

里，俗称就是锦囊妙计嘛，那赵云就是一个干活的人，从锦囊中取出妙计，执行，然后获胜，用 JAVA 程序

怎么表现这个呢？我们先看类图：

package csii.test;

/**
 * 策略模式学习
 *  三个锦囊妙计的接口
 */
public interface IStrategy {

    //每个锦囊妙计都是一个可执行的算法
    public void operate();
}

//======================实现三个妙计=================//
/**
 * 找乔国老帮忙，使孙权不能杀刘备
 */
class  BacDoor implements IStrategy{
    @Override
    public void operate() {
        System.out.println("找乔国老帮忙，让吴国太给孙权施加压力");
    }
}
/**
 * @author cbf4Life cbf4life@126.com
 * I'm glad to share my knowledge with you all.
 * 求吴国太开个绿灯
 */
class GivenGreenLight implements IStrategy{
    public void operate() {
        System.out.println("求吴国太开个绿灯,放行！");
    }
}

/**
 * @author cbf4Life cbf4life@126.com
 * I'm glad to share my knowledge with you all.
 * 孙夫人断后，挡住追兵
 */
class BlockEnemy implements IStrategy {
    public void operate() {
        System.out.println("孙夫人断后，挡住追兵");
    }
}

//=====================妙计放入锦囊中=======================//

/**
 * 把妙计封装在一个锦囊中（类)
 * 计谋有了，那还要有锦囊
 */
class Context {
    //构造函数，你要使用那个妙计
    private IStrategy straegy;    
    public Context(IStrategy strategy){
        this.straegy = strategy;
    }
    //使用计谋了，看我出招了
    public void operate(){
        this.straegy.operate();
    }
}


//===================调用妙计=================//

class DiaoYong{
    public static void main(String[] args) {
        Context context;
        System.out.println("------------------调用第一个---------------------");
        context =new Context(new BacDoor());
        context.operate();
        System.out.println("第一个调用结束/");
        System.out.println("------------------调用第二个---------------------");
        context =new Context(new GivenGreenLight());
        context.operate();
        System.out.println("第二个调用结束/");
        System.out.println("------------------调用第三个---------------------");
        context =new Context(new  BlockEnemy());
        context.operate();
        System.out.println("第三个调用结束/");
    }
}

第 2 章代理模式【Proxy Pattern】

在代理模式（Proxy Pattern）中，一个类代表另一个类的功能。这种类型的设计模式属于结构型模式。

在代理模式中，我们创建具有现有对象的对象，以便向外界提供功能接口。

代理人与被代理人有共特的特性，这个就是接口（interface）

package Test;

/**
 * 定义一种类型的女人，王婆和潘金莲都属于这个类型的女人
 * 这类型女人有共同的特性，所以是一个接口
 */
public interface KindWomen {

    public void makeEyesWithMan();//抛媚眼

    public void happyWithMan(); //可以快乐的事儿

}

/**
 * 定义潘金莲类，她是一个人，独立的个体，但是她的实现KindWomen类
 */
class panjinlian implements KindWomen{

    @Override
    public void makeEyesWithMan() {
        System.out.println("潘金莲抛媚眼");
    }

    @Override
    public void happyWithMan() {
        System.out.println("潘金莲在和阿门滚床单.....");
    }
}

/**
 * 定义王婆实现她的共性
 * 但是王婆老了，干不了这些事了，但是她可以做这一类女人的代理
 */
class Wangpo implements KindWomen{
    private  KindWomen kindWomen;//招聘需要这类型的


    public Wangpo(){
        this.kindWomen=new panjinlian();//专门默认潘金莲的代理
    }
    //她可以是KindWomen的任何一个女人的代理，只要你是这一类型
    public Wangpo(KindWomen kindWomen){
        this.kindWomen = kindWomen;
    }
    public void happyWithMan() {
        this.kindWomen.happyWithMan(); //自己老了，干不了，可以让年轻的代替
    }
    public void makeEyesWithMan() {
        this.kindWomen.makeEyesWithMan(); //王婆这么大年龄了，谁看她抛媚眼？！
    }
}


//两个女主角已经叫来了，该男主角阿门上场了:
/**
 *
 * 定义一个西门庆，这人色中饿鬼
 */
class XiMenQing {
    /*
     * 水浒里是这样写的：西门庆被潘金莲用竹竿敲了一下难道，痴迷了，
     * 被王婆看到了, 就开始撮合两人好事，王婆作为潘金莲的代理人
     * 收了不少好处费，那我们假设一下：
     * 如果没有王婆在中间牵线，这两个不要脸的能成吗？难说的很！
     */
    public static void main(String[] args) {
        //阿门不能直接叫小莲，但可以把王婆叫出来再让王婆叫小莲
        Wangpo wangPo = new Wangpo();
        //然后西门庆就说，我要和潘金莲happy，然后王婆就安排了西门庆丢筷子的那出戏:
        wangPo.makeEyesWithMan(); //看到没，虽然表面上时王婆在做，实际上爽的是潘金莲
        wangPo.happyWithMan(); 
    }
}

第 3 章单例模式【Singleton Pattern】

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

注意：

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

介绍

意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。

主要解决：一个全局使用的类频繁地创建与销毁。

何时使用：当您想控制实例数目，节省系统资源的时候。

如何解决：判断系统是否已经有这个单例，如果有则返回，如果没有则创建。

关键代码：构造函数是私有的。

应用实例：定义一个皇帝，中国历史上一般在一个时期只能有一个皇帝

package csii.test;

/**
 * 定义一个皇帝，中国历史上一般在一个时期只能有一个皇帝
 */
public class Emperor {
    //采用懒汉模式：线程不安全，静态的成员
    private static Emperor emperor = null;//定义一个皇帝
    //定义私有构造器
    private Emperor(){
        //避免外部生产第二个皇帝
    }

    //定义公共静态方法，其中static关键字修饰的即表示静态的。
    /*生命周期（Lifecycle）：

    静态方法（Static Method）与静态成员变量一样，属于类本身，在类装载的时候被装载到内存（Memory），不自动进行销毁，会一直存在于内存中，直到JVM关闭。

    非静态方法（Non-Static Method）又叫实例化方法，属于实例对象，实例化后才会分配内存，必须通过类的实例来引用。不会常驻内存，当实例对象被JVM 回收之后，也跟着消失。

    效率：
    静态方法的使用效率比非静态方法的效率高。*/
    /*静态方法与非静态方法最明显的区别：
    就是如果某个方法是公共静态的，那么可以直接通过类名.方法名的方法来调用，而公共实例方法则需要事先实例化对象，然后才能调用*/
    public static  Emperor getInstance(){
        if(emperor==null){
            emperor = new Emperor();
        }
        return emperor;
    }
    //给皇帝定义一个名字
    public  static  void emperorInfo(){
        System.out.println("我是万历皇帝朱。。。。");
    }
}

/**
 * 模拟大臣见皇帝
 */
class Minister{

    public static void main(String[] args) {
        Emperor emperor1 = Emperor.getInstance();
        emperor1.emperorInfo();

        Emperor emperor2 = Emperor.getInstance();
        Emperor.emperorInfo();

        Emperor emperor3 = Emperor.getInstance();
        emperor3.emperorInfo();

        //三个大臣见的都是同一个人

    }
}

因上述代码采用了懒汉模式创建的单例模式：所以在一个 B / S 项目中，每个 H T T P R e q u e s t 请求到 J 2 E E
的容器上后都创建了一个线程,每个线程都要创建同一个单例对象,怎么办?

创建一个通用安全的单例模式：采用饿汉模式，并且在定义公共的静态方法时加同步锁

package csii.test;

/**
 * 定义一个皇帝，中国历史上一般在一个时期只能有一个皇帝
 */
public class Emperor {
    //采用饿汉模式：线程安全，静态的成员
    private static final Emperor emperor = new Emperor();//定义一个皇帝,并实例化
    //定义私有构造器
    private Emperor(){
        //避免外部生产第二个皇帝
    }
    //使用同步锁锁住
    public synchronized  static  Emperor getInstance(){

        return emperor;
    }
    //给皇帝定义一个名字
    public  static  void emperorInfo(){
        System.out.println("我是万历皇帝朱。。。。");
    }
}

/**
 * 模拟大臣见皇帝
 */
class Minister{

    public static void main(String[] args) {
        Emperor emperor1 = Emperor.getInstance();
        emperor1.emperorInfo();

        Emperor emperor2 = Emperor.getInstance();
        Emperor.emperorInfo();

        Emperor emperor3 = Emperor.getInstance();
        emperor3.emperorInfo();

        //三个大臣见的都是同一个人

    }
}

第 4 章多例模式【Multition Pattern】

第 5 章工厂方法模式【Factory Method Pattern】

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

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

介绍

意图：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。

主要解决：主要解决接口选择的问题。

何时使用：我们明确地计划不同条件下创建不同实例时。

如何解决：让其子类实现工厂接口，返回的也是一个抽象的产品。

关键代码：创建过程在其子类执行。

应用实例： 1、您需要一辆汽车，可以直接从工厂里面提货，而不用去管这辆汽车是怎么做出来的，以及这个汽车里面的具体实现。 2、Hibernate 换数据库只需换方言和驱动就可以。

优点： 1、一个调用者想创建一个对象，只要知道其名称就可以了。 2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。 3、屏蔽产品的具体实现，调用者只关心产品的接口。

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

使用场景： 1、日志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方。 2、数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时。 3、设计一个连接服务器的框架，需要三个协议，"POP3"、"IMAP"、"HTTP"，可以把这三个作为产品类，共同实现一个接口。

注意事项：作为一种创建类模式，在任何需要生成复杂对象的地方，都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只需要通过 new 就可以完成创建的对象，无需使用工厂模式。如果使用工厂模式，就需要引入一个工厂类，会增加系统的复杂度

实现

我们将创建一个 Shape 接口和实现 Shape 接口的实体类。下一步是定义工厂类 ShapeFactory。

FactoryPatternDemo 类使用 ShapeFactory 来获取 Shape 对象。它将向 ShapeFactory 传递信息（CIRCLE / RECTANGLE / SQUARE），以便获取它所需对象的类型。

步骤 1

创建一个接口:

public interface Shape {
    void draw();
}

步骤 2

创建实现接口的实体类。

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

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

public class Square implements Shape{

    public void draw() {
        System.out.println("Inside Square::draw() method.");
    }
}

步骤 3

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

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

}

步骤 4

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

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

}

步骤 5

执行程序，输出结果：

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

Process finished with exit code 0

感谢语:感谢《菜鸟教程》、感谢《24种设计模式与6大设计原则》

任错错

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
0
评论
23种设计模式与6大设计原则学习

设计模式: 设计模式（Design pattern）代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了重用代码、让代码...
复制链接

扫一扫