Java设计模式学习笔记

1、什么是设计模式？设计模式有什么用？

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

2、设计模式应该遵循的面向对象设计原则

1994年，在由设计模式四人帮GOF出版的著作Design Patterns - Elements of Reusable Object-Oriented Software（中文译名：设计模式 - 可复用的面向对象软件元素）中提出，设计模式应该遵循以下两条面向对象设计原则：

对接口编程而不是对实现编程
优先使用对象组合而不是继承

“对接口编程而不是对实现编程”，对于这句话我的理解就是：要善于使用多态。变量的声明尽量使用超类型（父类），而不是某个具体的子类，超类型中的各个具体方法的实现都是写在不同的子类中。程序在执行时能够根据不同的情况来调用到不同的子类方法，这样做更加灵活，并且我们在声明一个变量时无需关心以后执行时的真正的数据类型是哪种（某个子类类型），这是种解耦合（松耦合）的思想。实例代码如下：

package Test;

public interface Animal {
    public void makenoise();
}


package Test;

public class Dog implements Animal {
    @Override
    public void makenoise() {
        System.out.println("汪汪汪！");
    }
}

class Cat implements Animal{
    @Override
    public void makenoise() {
        System.out.println("喵喵喵！");


package Test;

public class AnimalTest {
    public static void hearnoise(Animal animal){
        animal.makenoise();
    }
    public static void main(String[] args) {
        AnimalTest.hearnoise(new Dog());
        AnimalTest.hearnoise(new Cat());
    }
}


执行结果：
汪汪汪！
喵喵喵！

3、设计模式的六大原则

开闭原则（Open Close Prinprinciple），开闭原则的意思是：对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。简言之，是为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类。
里氏代换原则（Liskov Substitution Principle），里氏代换原则是面向对象设计的基本原则之一。里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。LSP 是继承复用的基石，只有当派生类可以替换掉基类，且软件单位的功能不受到影响时，基类才能真正被复用，而派生类也能够在基类的基础上增加新的行为。里氏代换原则是对开闭原则的补充。实现开闭原则的关键步骤就是抽象化，而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范（LSP我曾经在另一篇文章重新思考接口和抽象类中举了一个例子）。
依赖倒转原则（Dependence Inversion Principle），这个原则是开闭原则的基础，具体内容：针对接口编程，依赖于抽象而不依赖于具体。
接口隔离原则（Interface Segregation Principle），使用多个隔离的接口，比使用单个接口要好。它还有另外一个意思是：降低类之间的耦合度。由此可见，其实设计模式就是从大型软件架构出发、便于升级和维护的软件设计思想，它强调降低依赖，降低耦合。
迪米特法则，又称最少知道原则（Demeter Principle），一个实体应当尽量少地与其他实体之间发生相互作用，使得系统功能模块相对独立。
合成复用原则（Composite Reuse Principle），尽量使用合成/聚合的方式，而不是使用继承。

4、设计模式的四种类型（包括J2EE设计模式）

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

工厂模式
抽象工厂模式
单例模式
建造者模式
原型模式

结构型模式，这些设计模式关注类和对象的组合。继承的概念被用来组合接口和定义组合对象获得新功能的方式。结果型模式包括以下几种设计模式：

适配器模式
桥接模式
过滤器模式
组合模式
装饰器模式
外观模式
享元模式
代理模式

行为型模式，这些设计模式特别关注对象之间的通信。行为型模式包括以下几种设计模式：

责任链模式
命令模式
解释器模式
迭代器模式
中介者模式
备忘录模式
观察者模式
状态模式
空对象模式
策略模式
模板模式
访问者模式

J2EE模式，这些设计模式特别关注表现层，这些模式是由Sun Java Center鉴定的。J2EE模式包括以下几种设计模式：

MVC模式
业务代表模式
组合实体模式
数据访问对象模式
前端控制器模式
拦截过滤器模式
服务器定位器模式
传输对象模式

5、几种常见的设计模式

5.1、工厂模式

工厂模式（Factory Pattern）是Java中最常见的设计模式之一，属于创建者模式。顾名思义，它的思路是设计一个对象生产工厂，它提供了一种绝佳的创建对象的方式。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过一个共同的接口来创建对象。

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

优点：

一个调用者想创建一个实例对象，只需要知道其名字就行。
扩展性高，如果想增加一个产品，只要扩展工厂类就行。
屏蔽了产品的具体实现，调用者只关心产品的接口。

缺点：

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

实现示例：就以一家生产多个不同品牌的汽车生产厂为例，先创建一个Car接口和三个实现类BENZ、BMW、TOYOTA，再定义一个工厂类CarFactory。我们使用这个工厂类CarFactory来生产不同品牌的汽车。

package FactoryDemo;

public interface Car {
    public void Brand();
}

public class BENZ implements Car{
    @Override
    public void Brand() {
        System.out.println("生产一辆奔驰");
    }
}

public class BMW implements Car{
    @Override
    public void Brand() {
        System.out.println("生产一辆宝马");
    }
}

public class TOYOTA implements Car{
    @Override
    public void Brand() {
        System.out.println("生产一辆丰田");
    }
}

//用来生成汽车的工厂类
//equalsIgnoreCase()方法只能比较字符串，equals()可以比较字符串和对象，且equalsIgnoreCase()
//中不区别大小写，A-Z和a-z是一样的
public class CarFactory {
    public Car getcar(String carbrand) {
        if (carbrand.equalsIgnoreCase("BENZ")) {
            return new BENZ();
        } else if (carbrand.equalsIgnoreCase("BMW")) {
            return new BMW();
        } else if (carbrand.equalsIgnoreCase("TOYOTA")) {
            return new TOYOTA();
        } else
            System.out.println("对不起我们不生产这辆车");

        return null;

    }

}

//实例化工厂类
public class CarFactoryTest {
    public static void main(String[] args) {
        CarFactory carfactory = new CarFactory();
        Car car1 = carfactory.getcar("Benz");
        car1.Brand();

        Car car2 = carfactory.getcar("Bmw");
        car2.Brand();

        Car car3 = carfactory.getcar("toyota");
        car3.Brand();


    }
}

执行结果：
生产一辆奔驰
生产一辆宝马
生产一辆丰田

5.2、抽象工厂模式

抽象工厂模式是围绕一个超级工厂创建其他工厂，这个超级工厂是生产其他工厂的工厂。这种设计模式属于创建型模式，它提供了一种创建对象的最佳方式。在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式地指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

主要解决的问题：主要解决接口选择的问题。系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。

优点：当一个产品族中的多个对象被设计在一起工作时，它能保证客户端始终只使用一个产品族中的对象。

缺点：产品族的扩展非常困难，要增加一个系列的某个产品，不但要在创造工厂里新增大量代码，还要在具体实现里加代码，产品族难以扩展。

实现示例：还是以上一个实例为基础来说明抽象工厂模式。一家汽车集团公司，旗下有两个工厂，一家是生产国外品牌车（BENZ、BMW、TOYATA），另一家是生产国内品牌车（JAC、BYD、ROEWE）（这就相当于两个产品族）。集团有一家自营销售门店，采取顾客下单后再生产的经营策略（这就相当于系统只在一个时刻消费某一族的产品）。有两个接口：ForeignCar（国外品牌车）、DomesticCar（国内品牌车），汽车实现类：Benz、Bmw、Toyota、Jac、Byd、Roewe。一个工厂抽象类AbstractFactory，两个工厂类继承自这个抽象类：ForeigncarFactory、DomesticcarFactory。最后还有一个工厂生产者FactoryProducer和一个测试类AbstractFactoryTest。具体代码实现如下：

国外品牌车接口及实现类

public interface ForeignCar {
    public void Brand();
}

public class BNEZ implements ForeignCar{
    @Override
    public void Brand() {
        System.out.println("生产一辆奔驰");
    }
}

public class BMW implements ForeignCar{
    @Override
    public void Brand() {
        System.out.println("生产一辆宝马");
    }
}

public class TOYOTA implements ForeignCar{
    @Override
    public void Brand() {
        System.out.println("生产一辆丰田");
    }
}

国内品牌车接口及实现类

public interface DomesticCar {
    public void Brand();
}

public class BYD implements DomesticCar{
    @Override
    public void Brand() {
        System.out.println("生产一辆比亚迪");
    }
}

public class JAC implements DomesticCar{
    @Override
    public void Brand() {
        System.out.println("生产一辆江淮");
    }
}

public class ROEWE implements DomesticCar{
    @Override
    public void Brand() {
        System.out.println("生产一辆荣威");
    }
}

工厂的抽象类及两个工厂实现类

public abstract class AbstractFactory {
    public abstract ForeignCar getforeigncar(String brand);

    public abstract DomesticCar getdomesticcar(String brand);
}

public class ForeigincarFactory extends AbstractFactory{
    @Override
    public ForeignCar getforeigncar(String brand) {
        if (brand.equalsIgnoreCase("Benz")){
            return new BNEZ();
        }
        else if (brand.equalsIgnoreCase("Bmw")){
            return new BMW();
        }
        else if (brand.equalsIgnoreCase("Toyota")){
            return new TOYOTA();
        }
        else
            System.out.println("我们没有这个品牌授权");
        return null;
    }

    @Override
    public DomesticCar getdomesticcar(String brand) {
        return null;
    }
}

public class DomesticcarFactory extends AbstractFactory{
    @Override
    public ForeignCar getforeigncar(String brand) {
        return null;
    }

    @Override
    public DomesticCar getdomesticcar(String brand) {
        if (brand.equalsIgnoreCase("Jac")){
            return new JAC();
        }
        else if (brand.equalsIgnoreCase("Byd")){
            return new BYD();
        }
        else if (brand.equalsIgnoreCase("Roewe")){
            return new ROEWE();
        }
        else
            System.out.println("我们没有这个品牌授权");
        return null;
    }
}

工厂生产者及测试类

public class FactoryProducer {
    public static AbstractFactory CreateFactory(String choice){
        if (choice.equalsIgnoreCase("ForeignCar")){
            return new ForeigincarFactory();
        }
        else if (choice.equalsIgnoreCase("DomesticCar")){
            return new DomesticcarFactory();
        }
        else
            System.out.println("我们没有这个工厂");
        return null;
    }
}

public class AbstractFactoryTest {
    public static void main(String[] args) {
        AbstractFactory abstractFactory1 = FactoryProducer.CreateFactory("ForeignCar");

        ForeignCar car1 = abstractFactory1.getforeigncar("toyota");
        car1.Brand();

        AbstractFactory abstractFactory2 = FactoryProducer.CreateFactory("DomesticCar");

        DomesticCar car2 = abstractFactory2.getdomesticcar("byd");
        car2.Brand();
    }
}

执行结果

生产一辆丰田
生产一辆比亚迪

---------------------------------------------------------------------------待更新-------------------------------------------------------------------------------------

Java设计模式学习笔记

1、什么是设计模式？设计模式有什么用？

2、设计模式应该遵循的面向对象设计原则

3、设计模式的六大原则

4、设计模式的四种类型（包括J2EE设计模式）

5、几种常见的设计模式

5.1、工厂模式

5.2、抽象工厂模式

钉钉打卡速度慢

Nginx R31 doc 官方文档-01-nginx 如何安装

Qt/C++音视频开发74-合并标签图形/生成yolo运算结果图形/文字和图形合并成一个/水印滤镜

挑战程序设计竞赛 2.2章习题 POJ - 3617 Best Cow Line 贪心

字节面试：MySQL什么时候锁表？如何防止锁表？

.NET8连接SQL SERVER 2008 R2 报：证书链是由不受信任的颁发机构颁发的

golang开发环境搭建(win10)

python计算机视觉学习笔记——PIL库的用法

Golang初学：获取程序内存使用情况，std runtime

深入理解Java虛擬機第三章讀書筆記：HotSpot虛擬機中的各個垃圾收集器

深入理解Java虛擬機第三章讀書筆記：垃圾回收算法

線程安全和鎖

線程池類ThreadPoolExecutor解析

常見的幾種Java設計模式

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結