设计模式
设计模式的目的
- 代码重用性
- 可读性
- 可拓展性（可维护性）
- 可靠性
- 提高程序对外体现高内聚 低耦合
设计模式的原则
单一职责原则
- 降低类的复杂度一个类只负责一项职责
- 提高类的可读性，可维护性。
- 降低变更引起的风险
- 通常情况下，遵守单一职责原则，除非逻辑足够简单，可在代码级反单一职责原则，一个类方法过少，可满足方法级的单一职责原则
接口隔离原则
如果一个类A只通过某个接口B依赖某一个类C， 一个类D通接口B依赖一个类E，在接口中就包括了A和D需要的所有方法，A就要实现B的全部方法，然而一部分方法是不需要的。
拆分接口B建立几个独立的接口，A和D根据自己的需要去和相应接口建立关系。这种方式就是接口隔离原则。
未遵循接口隔离原则
遵守接口隔离原则
依赖倒转原则
A.高层次的模块不应该依赖于低层次的模块，他们都应该依赖于抽象。
B.抽象不应该依赖于具体，具体应该依赖于抽象。
- 模块间的依赖通过抽象发生，实现类之间不发生直接的依赖关系，其依赖关系是通过接口或抽象类产生的
- 接口或抽象类不依赖于实现类
- 实现类依赖于接口或抽象类
依赖传递的三种方式
- 接口声明依赖对象
- 构造方法传递
- setter方式传递
变量声明类型尽量是抽象类或接口，这样相当于变量与实际引用对象之间存在一个缓冲层，利于程序的拓展和优化
里氏替换原则
- 如果对每个类型为T1的对象o1，都有类型为T2的对象o2，使得以T1定义的所有程序P在所有的对象o1都代换成o2时，程序P的行为没有发生变化，那么类型T2是类型T1的子类型。换句话说，所有引用基类的地方必须能透明地使用其子类的对象；
- 在使用继承时，遵循里氏替换原则，
在子类中尽量不要重写父类的方法； 继承实际上让两个类耦合性增强了，给程序带来侵入性。在适当的情况下，可以通过聚合，组合，依赖来解决问题；- 继承包含这样一层含义：父类中凡是已经实现好的方法，实际上是在设定规范和契约，虽然它不强制要求所有的子类必须遵循这些契约，但是如果子类对这些已经实现的方法任意修改，就会对整个继承体系造成破坏。
public class LiskovSubstitution {
public static void main(String[] args) {
A a = new A();
System.out.println("2-1=" + a.func1(2, 1));
B b = new B();
System.out.println("2+1=" + b.func1(2, 1));
System.out.println("2+1+9=" + b.func2(2, 1));
System.out.println("B类使用A类方法：2-1=" + b.func3(2, 1));
}
}
class Base {
//把基础方法和成员抽取成基类
public int func1(int num1, int num2) {
return num1 - num2;
}
}
class A extends Base {
// public int func1(int num1, int num2) {
// return num1 - num2;
// }
}
class B extends Base {
// TODO 类 B `无意` 重写了父类 A 方法，造成原有方法发生改变。
// @Override
// public int func1(int num1, int num2) {
// return num1 + num2;
// }
@Override
public int func1(int num1, int num2) {
return num1 + num2;
}
public int func2(int num1, int num2) {
return func1(num1, num2) + 9;
}
private A a = new A();//组合
//使用 A 方法
public int func3(int num1, int num2) {
return this.a.func1(num1, num2);
}
}
开闭原则
- 开闭原则(Open Closed Principle) 是编程中最基础、最重要的设计原则；
一个软件实体，比如类，模块和函数应该对提供方扩展开放，对使用方修改关闭。用抽象构建框架，用实现扩展细节；- 当软件需要变化时，尽量通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码来实现变化；
- 编程中遵循其它原则，以及使用设计模式的目的就是遵循开闭原则。
public class OpenClosed {
public static void main(String[] args) {
Use use = new Use();
use.drawShape(new Triangle());
use.drawShape(new Circle());
use.drawShape(new OtherGraphics());//只需要让 此类继承 抽象类，子类实现具体方法 OCP原则
}
}
class Use {
public void drawShape(Shape shape) {
shape.draw();
}
}
abstract class Shape {
public abstract void draw();
}
class Triangle extends Shape {
@Override
public void draw() {
System.out.println("子类实现具体功能：三角形");
}
}
class Circle extends Shape {
@Override
public void draw() {
System.out.println("子类实现具体功能：圆形");
}
}
class OtherGraphics extends Shape {
@Override
public void draw() {
System.out.println("子类实现具体功能：任何形状");
}
}
迪米特法则
- 一个对象应该对其他对象保持最少的了解
（最少知道原则 LKP）。 - 类与类关系越密切，耦合度越大。
要求降低类之间耦合，而不是完全解耦。 - 迪米特法则(Demeter Principle)，即一个类对自己依赖的类知道的越少越好。也就是说，对于被依赖的类不管多么复杂，都尽量将逻辑封装在类的内部。对外除了提供public方法，不对外泄露任何信息。
- 迪米特法则更简单的定义：只与直接的朋友通信
- 直接的朋友：每个对象都会与其他对象有耦合关系，只要两个对象之间有耦合关系，我们就说这两个对象之间是朋友关系。耦合的方式很多，依赖，关联，组合，聚合 等。其中，我们称出现成员变量，方法参数，方法返回值中的类为直接的朋友，而出现在局部变量中的类不是直接的朋友。也就是说，陌生的类最好不要以局部变量的形式出现在类的内部。
class A{
B b;//全局变量 - 直接朋友
public B m1(){} //方法返回值 - 直接朋友
public void m2(B b){}//方法入参 - 直接朋友
public void m3(){
B b1 = new B();// 局部变量 非直接朋友
}
}
public class Demeter {
public static void main(String[] args) {
SchoolManager schoolManager = new SchoolManager();
schoolManager.printAllEmployee(new CollegeManager());
}
}
//学院员工类
class CollegeEmployee {
private String id;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
}
//管理学院员工的管理类:
class CollegeManager {
//返回学院的所有员工 //TODO CollegeEmployee 直接朋友
public List<CollegeEmployee> getAllEmployee() {
List<CollegeEmployee> list = new ArrayList<CollegeEmployee>();
for (int i = 0; i < 10; i++) { //这里我们增加了10 个员工到list ，
CollegeEmployee emp = new CollegeEmployee();
emp.setId("学院员工id " + i);
list.add(emp);
}
return list;
}
public void printCollegeEmployee() {
List<CollegeEmployee> list1 = this.getAllEmployee();
System.out.println("---学院员工----");
for (CollegeEmployee e : list1) {
System.out.println(e.getId());
}
}
}
//学校总部员工类
class SchoolEmployee {
private String id;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
}
//学校管理类
//TODO 直接朋友 Employee CollegeManager
class SchoolManager {
//返回学校总部的员工
public List<SchoolEmployee> getAllEmployee() {
List<SchoolEmployee> list = new ArrayList<SchoolEmployee>();
for (int i = 0; i < 5; i++) { //这里我们增加了5个员工到list
SchoolEmployee emp = new SchoolEmployee();
emp.setId("学校总部员工id= " + i);
list.add(emp);
}
return list;
}
//该方法完成输出学校总部和学院员工信息(id)
void printAllEmployee(CollegeManager sub) {
//获取到学院员工
//TODO 非直接朋友 CollegeEmployee 应该提取到 CollegeManager
// List<CollegeEmployee> list1 = sub.getAllEmployee();
// System.out.println("---学院员工----");
// for (CollegeEmployee e : list1) {
// System.out.println(e.getId());
// }
sub.printCollegeEmployee();//只提供方法，不把具体实现放在其他类里面。
//获取到学校总部员工
List<SchoolEmployee> list2 = this.getAllEmployee();
System.out.println("------学校总部员工------");
for (SchoolEmployee e : list2) {
System.out.println(e.getId());
}
}
}
UML 六种箭头
-
泛化
概念：泛化是一种一般与特殊、一般与具体之间关系的描述，具体描述建立在一般描述的基础之上，并对其进行了扩展。
在java中用来表示继承的关系。
表示方法：用实线空心三角箭头表示。
-
实现
概念：实现是一种类与接口的关系，表示类是接口所有特征和行为的实现，在程序中一般通过类实现接口来描述
表示方法：空心三角形箭头的虚线，实现类指向接口
-
依赖
概念：是一种使用的关系，即一个类的实现需要另一个类的协助。
java中，方法参数需要传入另一个类的对象，就表示依赖这个类。
表示方法：虚线箭头，类A指向类B。
-
关联
概念：表示类与类之间的联接,它使一个类知道另一个类的属性和方法，这种关系比依赖更强、不存在依赖关系的偶然性、关系也不是临时性的，一般是长期性的。
java中一个类的全局变量引用了另一个类，就表示关联了这个类
表示方法：实线箭头，类A指向类B
-
聚合
概念：聚合关联关系的一种特例，是强的关联关系。聚合是整体和个体之间的关系，即has-a的关系，整体与个体可以具有各自的生命周期，部分可以属于多个整体对象，也可以为多个整体对象共享。程序中聚合和关联关系是一致的，只能从语义级别来区分；
表示方法：尾部为空心菱形的实线箭头（也可以没箭头），类A指向类B
-
组合
概念：组合也是关联关系的一种特例。组合是一种整体与部分的关系，即contains-a的关系，比聚合更强。部分与整体的生命周期一致，整体的生命周期结束也就意味着部分的生命周期结束，组合关系不能共享。程序中组合和关联关系是一致的，只能从语义级别来区分。
表示方法：尾部为实心菱形的实现箭头（也可以没箭头），类A指向类B