【设计模式】 设计模式基本概念

封装（Encapsulation）

不需要知道对象具体实现细节，通过共有方法暴露对象的功能

继承（Inheritance）

使用已经存在的类作为基础类（父类），在此基础上建立新类（子类）， 
子类既可以复用父类的功能，也能进行扩展，从而提高了代码的复用。 
另外，Java不像C++一样可以同时继承多个父类，只能够树形的继承，比如： 
Animal -> Person -> Man，或者通过 接口和内部类 实现多继承！

多态（Polymorphism）

一个类实例的相同方法在不同情形下有不同的表现形式，一般有两种

编译时多态(OverLoading) —— 方法重载 

运行时多态(OverRidding) —— 继承 + 方法重写 + 父类引用指向子类对象

类与类之间的关系

类与类之间的关系可以根据关系的强度依次分为以下五种：

依赖关系(Dependency)---关联关系(Association)---聚合(Aggregation)---组合(Composition)---泛化(Generalization)

依赖关系

依赖关系是五种关系中耦合最小的一种关系。使用虚线加箭头表示，如下图所示：

代码：

[java]  view plain  copy

1. public class Person {  
2.       
3.     public void Call(){  
4.         Phone phone = new Phone();  
5.     }  
6.   
7. }  

[java]  view plain  copy

1. public class Phone {  
2.   
3. }  

解释：Person 和 Phone之间是没有关系的，但是由于偶尔的需要，Person需要使用Phone，在Person类中的具体方法中需要实例化Phone,这时Person就依赖于Phone.持有Phone类的是Person类的一个方法，而不是Person类，这点是最重要的。

关联关系

关联关系是实线加箭头表示。表示类之间的关系比依赖要强，如下图所示：

代码：

[java]  view plain  copy

1. public class Person {  
2.     //头部是人的一个属性  
3.     public Head head;  
4.       
5.     public Person() {  
6.         // TODO Auto-generated constructor stub  
7.     }  
8. }  

[java]  view plain  copy

1. public class Head {  
2.       
3.     public Head() {  
4.         // TODO Auto-generated constructor stub  
5.     }  
6.   
7. }  

解释：Head是作为Person类的一个内部属性来使用，一旦实例化了Person类，同时也实例化了一个Head实例，所以他们的依赖性更强。与关联最大的区别是：依赖时是在类的内部具体方法中使用到另外一个类，而关联则是作为内部属性来用，依赖关系仅当具体方法被调用时才会实例化，比如刚才的Person只有打电话时才调用Phone实例化，而关联是在new一个Person时就同时实例化了一个Head类来作为Person的内部属性.

聚合关系

聚合关系通过一个空心的菱形加箭头表示，如下图所示：

代码：

[java]  view plain  copy

1. public class PersonGroup {  
2.       
3.     public Person person;  
4.     //将person作为构造方法的参数传进去  
5.     public PersonGroup(Person person) {  
6.         // TODO Auto-generated constructor stub  
7.         this.person = person;  
8.     }  
9.   
10. }  

[java]  view plain  copy

1. public class Person {  
2.       
3.     public Person() {  
4.         // TODO Auto-generated constructor stub  
5.     }  
6. }  

解释：Person类是PersonGroup构造方法的参数，因此可以Person类可以完全脱离PersonGroup类而存在，不会因为PersonGroup实例的消亡而消亡，就像现实生活中，人不会因为脱离人群就挂了...

组合关系

组合关系通过一个实心的菱形加箭头表示，如下图所示：

代码：

[java]  view plain  copy

1. public class Person {  
2.       
3.     public Foot foot;  
4.       
5.     public Person() {  
6.         // TODO Auto-generated constructor stub  
7.         //在构造方法中实例化  
8.         foot = new Foot();  
9.     }  
10. }  

[java]  view plain  copy

1. public class Foot {  
2.       
3.     public Foot() {  
4.         // TODO Auto-generated constructor stub  
5.     }  
6.   
7. }  

解释：

Foot类是在Person类的构造方法中才被具体实例化，一旦Person实例生成，则Foot实例也生成，当Person实例消亡，其Foot实例也消亡，就像现实生活中，生成一个人，并定会伴随着脚的生成，但是如果那个人挂了，它的脚自然而然也就...（怎么听着怪怪-.-)

泛化关系

泛化关系通常包含类与类之间的继承关系和类与接口实现关系，如下图所示：

继承：

接口：

面向对象七大基本原则

---

1.单一职责原则(Single Responsibility Principle)

每一个类应该专注于做一件事情。 
即：高内聚，低耦合

2.开闭原则（Open Close Principle）

一个对象对扩展开放，对修改关闭。 
即：对类的改动是通过增加代码进行的，而不是修改现有代码

3.里氏替换原则（Liskov Substitution Principle）

在任何父类出现的地方都可以用它的子类来替代。

4.依赖倒置原则（Dependence Inversion Principle）

要依赖于抽象，不要依赖于具体实现。

5.接口隔离原则（Interface Segregation Principle）

应当为客户端提供尽可能小的单独的接口，而不是提供大的总的接口。

6.迪米特原则（Law Of Demeter）

一个对象应当尽量少地与其他对象之间发生相互作用，使得系统功能模块相对独立。

7.组合/聚合复用原则（Composite/Aggregate Reuse Principle）

尽量使用合成/聚合的方式，而不是使用继承

设计模式分为三大类：

创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

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

其实还有两类：并发型模式和线程池模式。