产品
摘要
设计模式（Design Pattern）是一套被反复使用、多数人知晓的、无数工程师实践的代码设计经验的总结，它是面向对象思想的高度提炼和模板化，使用设计模式是为了让代码具有更高的可重用性，更好的灵活性和可拓展性，更易被人阅读和理解。GoF 提到的模式有四个基本要素：
我一直坚信：程序源于生活，又高于生活！程序的灵魂在于思维的方式，而思维的灵感来源于生活的精彩。互联网是一个虚拟的世界，而程序本身就是对生活场景的虚拟和抽象，每一个模式我都能在生活中找到他的影子。比如，说到状态模式我能想到水有冰、水、气三种状态，而人也有少、壮、老三个不同的阶段；提起中介模式我能立马想到房产中介；看到单例模式，脑海中会即刻浮现心目中的那个她……
设计模式是面向对象的高度抽象和总结，而越抽象的东西越难以理解。本系列文章的目地就是为了降低设计模式的阅读门槛，以生活中的小故事开始，用风趣的方式，由浅入深地讲述每一个模式。让你再次看到设计模式时不只是一个模式，还是生活中的一个个小确幸！程序不是冷冰冰的代码，它还有生活的乐趣和特殊意义。二、为什么要学设计模式
设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案，这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。所以不管你是新手还是老手，学习设计模式将对你都有莫大的帮助。
学习设计模式的理由有很多，这里只列出几个最实现的：
开闭原则（Open-Closed Principle, OCP）是指一个软件实体如类、模块和函数应该对扩展开放，对修改关闭。所谓的开闭，也正是对扩展和修改两个行为的一个原则。强调的是用抽象构建框架，用实现扩展细节。可以提高软件系统的可复用性及可维护性。开闭原则，是面向对象设计中最基础的设计原则。它指导我们如何建立稳定灵活的系统，例如：我们版本更新，我尽可能不修改源代码，但是可以增加新功能。
登录后复制
class GraphicEditor {
public void drawShape(Shape s) {
if (s.m_type == 1) {
drawRectangle(s);
} else if (s.m_type == 2) {
drawCircle(s);
} else if (s.m_type == 3) {
drawTriangle(s);
}
}
public void drawRectangle(Shape r) {
System.out.println("矩形");
}
public void drawCircle(Shape r) {
System.out.println("圆形");
}
public void drawTriangle(Shape r) {
System.out.println("三角形");
}
}
class Shape {
public int m_type;
}
class RectangleShape extends Shape {
RectangleShape() {
m_type = 1;
}
}
class CircleShape extends Shape {
CircleShape() {
m_type = 2;
}
}
class TriangleShape extends Shape {
TriangleShape() {
m_type = 3;
}
}
优缺点
方式 1 的改进的思路分析
把创建 Shape 类做成抽象类，并提供一个抽象的 draw 方法，让子类去实现即可，这样我们有新的图形种类时，只需要让新的图形类继承 Shape，并实现 draw 方法即可，使用方的代码就不需要修改，满足了开闭原则。
登录后复制
class GraphicEditor {
public void drawShape(Shape s) {
s.draw();
}
}
abstract class Shape {
int m_type;
public abstract void draw();
}
class RectangleShape extends Shape {
RectangleShape() {
m_type = 1;
}
@Override
public void draw() {
System.out.println("矩形");
}
}
class CircleShape extends Shape {
CircleShape() {
m_type = 2;
}
@Override
public void draw() {
System.out.println("圆形");
}
}
class TriangleShape extends Shape {
TriangleShape() {
m_type = 3;
}
@Override
public void draw() {
System.out.println("三角形");
}
}
对类来说的，即一个类应该只负责一项职责。如类A负责两个不同职责：职责1，职责2。当职责1需求变更而改变A时，可能造成职责2执行错误，所以需要将类A的粒度分解为A1，A2
应用实例：以交通工具案例讲解
登录后复制
/**
* 方式1的分析
* 1.在方式1的run方法中，违反了单一职责原则
* 2.解决的方案非常的简单，根据交通工具运行方法不同，分解成不同类即可
*/
class Vehicle{
public void run(String type){
if ("汽车".equals(type)) {
System.out.println(type + "在公路上运行...");
} else if ("轮船".equals(type)) {
System.out.println(type + "在水面上运行...");
} else if ("飞机".equals(type)) {
System.out.println(type + "在天空上运行...");
}
}
}
public class SingleResponsibility1 {
public static void main(String[] args) {
Vehicle vehicle = new Vehicle();
vehicle.run("汽车");
vehicle.run("轮船");
vehicle.run("飞机");
}
}
登录后复制
/**
* 方案2的分析
* 1.遵守单一职责原则
* 2.但是这样做的改动很大，即将类分解，同时修改客户端
* 3.改进：直接修改Vehicle类，改动的代码会比较少=>方案3
*/
class RoadVehicle{
public void run(String type){
System.out.println(type + "在公路上运行...");
}
}
class WaterVehicle{
public void run(String type){
System.out.println(type + "在水面上运行...");
}
}
class AirVehicle{
public void run(String type){
System.out.println(type + "在天空上运行...");
}
}
public class SingleResponsibility2 {
public static void main(String[] args) {
RoadVehicle roadVehicle = new RoadVehicle();
roadVehicle.run("汽车");
WaterVehicle waterVehicle = new WaterVehicle();
waterVehicle.run("轮船");
AirVehicle airVehicle = new AirVehicle();
airVehicle.run("飞机");
}
}
登录后复制
/**
* 方式3的分析
* 1.这种修改方法没有对原来的类做大的修改，只是增加方法
* 2.这里虽然没有在类这个级别上遵守单一职责原则，但是在方法级别上，仍然是遵守单一职责
*/
class Vehicle2{
public void run(String type){
System.out.println(type + "在公路上运行...");
}
public void runWater(String type){
System.out.println(type + "在水面上运行...");
}
public void runAir(String type){
System.out.println(type + "在天空上运行...");
}
}
public class SingleResponsibility3 {
public static void main(String[] args) {
Vehicle2 vehicle = new Vehicle2();
vehicle.run("汽车");
vehicle.runWater("轮船");
vehicle.runAir("飞机");
}
}
总结
注意事项和细节
登录后复制
interface Interface1 {
void operation1();
void operation2();
void operation3();
void operation4();
void operation5();
}
class B implements Interface1 {
@Override
public void operation1() {
System.out.println("B 实现了 operation1");
}
@Override
public void operation2() {
System.out.println("B 实现了 operation2");
}
@Override
public void operation3() {
System.out.println("B 实现了 operation3");
}
@Override
public void operation4() {
System.out.println("B 实现了 operation4");
}
@Override
public void operation5() {
System.out.println("B 实现了 operation5");
}
}
class D implements Interface1 {
@Override
public void operation1() {
System.out.println("D 实现了 operation1");
}
@Override
public void operation2() {
System.out.println("D 实现了 operation2");
}
@Override
public void operation3() {
System.out.println("D 实现了 operation3");
}
@Override
public void operation4() {
System.out.println("D 实现了 operation4");
}
@Override
public void operation5() {
System.out.println("D 实现了 operation5");
}
}
/**
* A类通过接口Interface1依赖（使用）B类，但是只会用到1，2，3方法
*/
class A {
public void depend1(Interface1 i) {
i.operation1();
}
public void depend2(Interface1 i) {
i.operation2();
}
public void depend3(Interface1 i) {
i.operation3();
}
}
/**
* C类通过接口Interface1依赖（使用）D类，但是只会用到1，4，5方法
*/
class C {
public void depend1(Interface1 i) {
i.operation1();
}
public void depend4(Interface1 i) {
i.operation4();
}
public void depend5(Interface1 i) {
i.operation5();
}
}
应用实例
登录后复制
/**
* 方式1分析
* 1.简单，比较容易想到
* 2.如果我们获取的对象是微信，短信等等，则新增类，同时 Peron也要增加相应的接收方法
* 3.解决思路：
* 引入一个抽象的接口IReceiver，表示接收者，这样Person类与接口IReceiver发生依赖
* 因为Email，Weixin等等属于接收的范围，他们各自实现IReceiver接口就ok，这样我们就符号依赖倒转原则
*/
class Email {
public String getInfo() {
return "电子邮件信息：Hello World！";
}
}
class Person {
public void receive(Email email) {
System.out.println(email.getInfo());
}
}
登录后复制
interface IReceiver {
String getInfo();
}
class Email implements IReceiver {
@Override
public String getInfo() {
return "电子邮件信息：Hello World！";
}
}
class Weixin implements IReceiver {
@Override
public String getInfo() {
return "微信消息：Hello World！";
}
}
class ShortMessage implements IReceiver {
@Override
public String getInfo() {
return "短信信息：Hello World！";
}
}
class Person {
public void receive(IReceiver receiver) {
System.out.println(receiver.getInfo());
}
}
依赖关系传递的三种方式
接口传递
登录后复制
//方式1：通过接口传递实现依赖
//开关的接口
interface IOpenAndClose {
void open(ITV tv);//抽象方法，接收接口
}
//ITV接口
interface ITV {
void play();
}
//实现接口
class OpenAndClose implements IOpenAndClose {
public void open(ITV tv){
tv.play();
}
}
构造方法传递
登录后复制
//方式2：通过构造函数实现依赖
//开关的接口
interface IOpenAndClose {
void open();//抽象方法
}
//ITV接口
interface ITV {
public void play();
}
//实现接口
class OpenAndClose implements IOpenAndClose {
private ITV tv; // 成员
public OpenAndClose(ITV tv){ // 构造器
this.tv = tv;
}
public void open(){
this.tv.play();
}
}
setter 方式传递
登录后复制
//方式3，通过setter方法传递
interface IOpenAndClose{
void open();//抽象方法
void setTv(ITV tv);
}
//ITV接口
interface ITV{
void play();
}
//实现接口
class OpenAndClose implements IOpenAndClose{
private ITV tv;
public void setTv(ITV tv){
this.tv=tv;
}
public void open(){
this.tv.play();
}
}
注意事项和细节
应用实例：有一个学校，下属有各个学院和总部，现要求打印出学校总部员工 ID 和学院员工的 id
登录后复制
//总部员工
class Employee {
private String id;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
}
//学院员工
class CollegeEmployee {
private String id;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
}
//学院员工管理 类
class CollegeManager {
public List<CollegeEmployee> getAllEmployee() {
List<CollegeEmployee> list = new ArrayList<>();
CollegeEmployee collegeEmployee;
for (int i = 0; i < 10; i++) {
collegeEmployee = new CollegeEmployee();
collegeEmployee.setId("学院员工id=" + i);
list.add(collegeEmployee);
}
return list;
}
}
//总部员工管理类
class SchoolManager {
public List<Employee> getAllEmployee() {
List<Employee> list = new ArrayList<>();
Employee employee;
for (int i = 0; i < 5; i++) {
employee = new Employee();
employee.setId("总部员工id=" + i);
list.add(employee);
}
return list;
}
public void printAllEmployee(CollegeManager sub) {
System.out.println("--------------学院员工--------------");
List<CollegeEmployee> list1 = sub.getAllEmployee();
for (CollegeEmployee collegeEmployee : list1) {
System.out.println(collegeEmployee.getId());
}
System.out.println("---------------总部员工-------------");
List<Employee> list2 = this.getAllEmployee();
for (Employee employee : list2) {
System.out.println(employee.getId());
}
}
}
修改后的代码：
注意事项和细节
原则是尽量使用合成/聚合的方式，而不是使用继承
OO 中继承性的思考和说明
5）在使用继承时，遵循里氏替换原则，在子类中尽量不要重写父类的方法。
6）里氏替换原则告诉我们，继承实际上让两个类耦合性增强了，在适当的情况下，可以通过聚合、组合、依赖来解决问题
class A {
//返回两个数的差
public int func1(int num1, int num2) {
return num1 - num2;
}
}
class B extends A {
@Override
public int func1(int num1, int num2) {
return num1 + num2;
}
//增加了一个新功能：完成两个数相加，然后和9求和
public int func2(int num1, int num2) {
return func1(num1, num2) + 9;
}
}
public void test() {
A a = new A();
System.out.println("11-3=" + a.func1(11, 3));
System.out.println("1-8=" + a.func1(1, 8));
System.out.println("---------------------");
B b = new B();
System.out.println("11-3=" + b.func1(11, 3));
System.out.println("1-8=" + b.func1(1, 8));
System.out.println("11+3+9=" + b.func2(11, 3));
}
我们发现原来运行正常的相减功能发生了错误。原因就是类 B 无意中重写了父类的方法，造成原有功能出现错误。在实际编程中，我们常常会通过重写父类的方法完成新的功能，这样写起来虽然简单，但整个继承体系的复用性会比较差。特别是运行多态比较频繁的时候
通用的做法是：原来的父类和子类都继承一个更通俗的基类，原有的继承关系去掉，采用依赖、聚合、组合等关系代替，改进方案：
登录后复制
//创建一个更加基础的基类
class Base {
//将更基础的成员和方法写到Base类中
}
class A extends Base {
//返回两个数的差
public int func1(int num1, int num2) {
return num1 - num2;
}
}
class B extends Base {
//如果B需要使用A类的方法，使用组合关系
private A a;
public int func1(int num1, int num2) {
return num1 + num2;
}
//增加了一个新功能：完成两个数相加，然后和9求和
public int func2(int num1, int num2) {
return func1(num1, num2) + 9;
}
public int func3(int num1, int num2) {
return this.a.func1(num1, num2);
}
}
四、UML 类图画 UML 图与写文章差不多，都是把自己的思想描述给别人看，关键在于思路和条理，UML图分类：
只要是在类中用到了对方，那么他们之间就存在依赖关系。如果没有对方，连编译都通过不了
登录后复制
public class PersonServiceBean {
// 类的成员属性
private PersonDao personDao;
// 方法接收的参数类型
public void save(Person person) {
}
// 方法的返回类型
public IDCard getIDCard(Integer personid) {
return null;
}
// 方法中使用到
public void modify() {
Department department = new Department();
}
}
泛化关系实际上就是继承关系，它是依赖关系的特例
登录后复制
public abstract class DaoSupport {
public void save(Object entity) {
}
public void delete(Object id) {
}
}
public class PersonServiceBean extends DaoSupport {
}
登录后复制
public interface PersonService {
void delete(Integer id);
}
public class PersonServiceBean implements PersonService {
@Override
public void delete(Integer id) {
System.out.println("delete...");
}
}
关联关系实际上就是类与类之间的联系，它是依赖关系的特例
单向一对一关系
登录后复制
public class Person {
private IDCard card;
}
public class IDCard {}
双向一对一关系
登录后复制
public class Person {
private IDCard card;
}
public class IDCard {
private Person person;
}
聚合关系表示的是整体和部分的关系，整体与部分可以分开。聚合关系是关联关系的特例，所以它具有关联的导航性与多重性。如：一台电脑由键盘（keyboard）、显示器（monitor），鼠标等组成；组成电脑的各个配件是可以从电脑上分离出来的，使用带空心菱形的实线来表示：
登录后复制
public class Mouse {}
public class Monitor {}
public class Computer {
private Mouse mouse;
private Monitor monitor;
public void setMouse(Mouse mouse) {
this.mouse = mouse;
}
public void setMonitor(Monitor monitor) {
this.monitor = monitor;
}
}
组合关系也是整体与部分的关系，但是整体与部分不可以分开，如果我们认为 Mouse、Monitor 和 Computer 是不可分离的，则升级为组合关系
登录后复制
public class Mouse {}
public class Monitor {}
public class Computer {
private Mouse mouse = new Mouse();
private Monitor monitor = new Monitor();
}
再看一个案例，在程序中我们定义实体：Person 与 IDCard、Head，那么 Head 和 Person 就是组合，IDCard 和 Person 就是聚合
但是如果在程序中，Person 实体中定义了对 IDCard 进行级联删除，即删除 Person 时连同 IDCard 一起删除，那么 IDCard 和 Person 就是组合了五、设计模式概述和分类
设计模式分为至种类型，共 23 种
免责声明：本文系网络转载或改编，未找到原创作者，版权归原作者所有。如涉及版权，请联系删
155-2731-8020
