开发原则&设计模式

1、关于软件开发中的开发原则和设计模式：

　　1.1、开发原则
　　　　1.1.1、什么是开发原则？
　　　　　　开发原则就是开发的依据，只要依照这些原则进行开发，将来开发的软件具有很强的扩展力，很低的耦合度。
　　　　　　开发原则不属于java语言，也不属于任何一个编程语言，开发原则属于软件工程学的内容。

　　　　1.1.2、常见的开发原则？
　　　　- 开闭原则：所有开发原则中有一个最基本的原则，该原则叫做：OCP【开闭原则】，其它所有的原则都是围绕OCP开展的。
　　　　　　* 连接数据库的信息编写到配置文件当中，不要编写到java源程序当中，这就是符合OCP开发原则的。
　　　　　　* 开闭原则指的是：对扩展开放，对修改关闭。
　　　　　　* 开闭原则的本质是：在扩展软件功能的时候，不修改源程序达到轻松扩展。
　　　　- 接口隔离原则：
　　　　　　* 一个接口尽可能的定义的专业一些，这个接口只为用户服务，例如：UserService，这个接口只为系统服务，例如SystemService
　　　　　　* 尽可能接口定义的精细一些，以下接口定义的比较宽泛，不够专业，当Person实现这个接口的时候会强制Person实现不应该实现的方法，导致角色污染。

　　　　CommonInterface{
　　　　　　void eat();
　　　　　　void sing();
　　　　　　void dance();
　　　　　　void study();
　　　　　　void paxing();
　　　　　　....
　　　　　　....
　　　　}
　　　　Person implements CommonInterface{
　　　　　　//角色污染
　　　　}

　　　　- 合成聚合复用原则：
　　　　　　* 尽量使用has a 代替 is a
　　　　　　* 代码要想复用可以使用继承方式，但继承不是一种很好的解决方案，因为继承之后两个类之间的关系比较紧密，其中一个类发生改变的时候，另一个类会受到影响。耦合度高
　　　　　　* 代码要想复用还有另一种方式，就是A对象中含有B对象的引用，这样在A类中可以直接使用B类中的相关方法，这也是达到代码复用，这种方式A类发生改变B类不受影响，耦合度低。

　　　　- 迪米特法则：
　　　　　　* 不要和陌生人说话
　　　　　　* 一个软件实体应该和其它的软件实体尽可能少的发生关系。降低耦合度。

　　　　- 依赖倒转原则：
　　　　　　* 面向抽象编程，面向接口编程，不要面向具体编程。
　　　　　　* 依赖关系倒转过来
　　　　　　class A{
　　　　　　　　//假设B类是一个具体的类，就违背了依赖倒转原则。
　　　　　　　　//因为当B类这个具体的类发生改变之后，A类会受到牵连。
　　　　　　　　//假设A是上，B是下。此时实际上是“上”依赖“下”
　　　　　　　　B b;
　　　　　　}

　　　　　　class A{
　　　　　　　　//假设B是一个接口，不是具体的类，这就符合了依赖倒转原则。
　　　　　　　　//依赖关系扭转过来了，此时“上”不再依赖“下”，也就是说A不依赖：B1、B2、B3等实现类。
　　　　　　　　//A面向抽象的B接口。
　　　　　　　　B b;
　　　　　　}

　　　　　　class B1 implements B{
　　　　　　}
　　　　　　class B2 implements B{
　　　　　　}
　　　　　　class B3 implements B{
　　　　　　}

　　　　　　- 里氏代换原则：
　　　　　　　　尽可能使用多态语法机制，父类型引用指向子类型对象。
　　　　　　　　编译阶段绑定父类中的方法，运行阶段动态调用到子类对象中的方法。

　　总结：
　　　　以上所有的开发原则都是为了达到一个共同的目标：高内聚、低耦合。达到高内聚低耦合的好处是，可重用性增强，可扩展性增强。
　　　　高内聚表示：专业，只做一件事。只有达到高内聚，才可以达到低耦合，高内聚和低耦合是相辅相成的。

-----------------------------------------------------------------------------------------------------
1.2、设计模式

1.2.1、什么是设计模式？
专门为了解决某个特定的问题而存在的一种固定解决方案，可重复使用。
遇到这个问题，直接套用模式解决。

1.2.2、设计模式和开发原则的关系？
大部分的设计模式都是符合开发原则的。
开发原则概念比较大，设计模式只是为了解决某个特定问题，概念比开发原则小得多。

1.2.3、设计模式包括：
* Gof设计模式
* JavaEE设计模式
*.....

1.2.4、我们通常所说的设计模式是：Gof设计模式，1995年四位作者提出的23种设计模式。

1.2.5、Gof95设计模式分类：

* 创建型设计模式
　　- 主要用来解决对象的创建问题
* 行为型设计模式
　　- 这些设计模式主要和算法、方法有关的设计模式
* 结构型设计模式
　　- 更多的类更多的对象组合成更大的结构来解决某个特定的问题

1.2.6、JavaEE的设计模式包括：

* 单例模式【创建型】

　　- 单例模式的构造函数私有化，这也是真单例的标准。

　　- 单例模式的真实应用场景：
　　* 由于构造方法只执行一次，在构造方法中解析xml配置文件，可保证配置文件只被解析一次。当然，这种机制也可以在静态代码块中完成。
　　* 单例模式的对象无法被垃圾回收器回收，所以通常使用单例模式来实现缓存机制。因为缓存是不希望被回收的。

　　- 其实除了真单例之外，还存在假单例，例如：Servlet就是一个假单例，因为Servlet构造方法没有私有化，由于Servlet对象的生命周期
　　由容器来管理，程序员无权干涉，所以Servlet对象也是一个单实例的。

　　- 单例模式包括：饿汉和懒汉
　　　　* 饿汉：类加载时创建对象
　　　　* 懒汉：方法调用的时候创建对象，懒汉单例存在线程安全问题，需要加synchronized进行同步。
　　　　public synchronized static Singleton getInstance(){
　　　　　　if(s == null){
　　　　　　　　s = new Singleton();
　　　　　　}
　　　　　　return s;
　　　　}

　　单例模式的类无法被继承。因为子类需要调用父类中的构造方法，单例模式的构造方法私有化，在子类中无法调用，所以单例模式的类型无法被继承。

* 工厂模式【创建型】

　　- 简单工厂：生产单系列的产品
　　　　- 工厂方法：生产多系列的产品
　　- 抽象工厂：生产多系列的产品，并且加入反射机制....

* 模板方法设计模式【行为型】
　　- 代表是：HttpServlet

* 责任链设计模式【行为型】
　　- 过滤器 servlet规范中的Filter
　　- 拦截器 springmvc中的Interceptor
　　责任链设计模式：能够在运行阶段做到方法的动态调用组合，能够让程序的达到真正意义上的可插拔性
　　责任链设计模式要想实现的话，必须采用相关的配置文件，通过修改配置文件来实现运行期绑定

* 策略模式【行为型】
　　- 集合中的Comparator

* 迭代模式【行为型】
　　- 集合中的Iterator

* 监听模式【行为型】
　　- Servlet中的Listener：ServletContextListener

* 适配器模式【结构型】
　　- GenericServlet

* 装饰器模式【结构型】
　　- IO流

* 代理模式【结构型】
　　- Spring中的AOP就是使用代理模式实现的。

==============================

1.1. 常见的UML图有哪些？
类图：Class Diagram
描述类的详细信息，以及描述类和类之间的关系信息【ER图、CDM概念数据模型】
用例图：Use Case Diagram
站在系统用户的角度，分析系统存在哪些功能
时序图：Sequence Diagram
描述一个功能的实现流程，方法的调用过程
状态图：Statechart Diagram

=============================

泛化    A  is  a   B      B继承A

实现

A is like a B，  类和接口

关联关系

聚合

合成

依赖