单一职责原则
接口隔离原则
如果一个类A只通过某个接口B依赖某一个类C， 一个类D通接口B依赖一个类E，在接口中就包括了A和D需要的所有方法，A就要实现B的全部方法，然而一部分方法是不需要的。
拆分接口B建立几个独立的接口，A和D根据自己的需要去和相应接口建立关系。这种方式就是接口隔离原则。
未遵循接口隔离原则
遵守接口隔离原则
依赖倒转原则
A.高层次的模块不应该依赖于低层次的模块，他们都应该依赖于抽象。
B.抽象不应该依赖于具体，具体应该依赖于抽象。
依赖传递的三种方式
变量声明类型尽量是抽象类或接口，这样相当于变量与实际引用对象之间存在一个缓冲层，利于程序的拓展和优化
里氏替换原则
在子类中尽量不要重写父类的方法；继承实际上让两个类耦合性增强了，给程序带来侵入性。在适当的情况下，可以通过聚合，组合，依赖来解决问题；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);
}
}
开闭原则
一个软件实体，比如类，模块和函数应该对提供方扩展开放，对使用方修改关闭。用抽象构建框架，用实现扩展细节；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）。要求降低类之间耦合，而不是完全解耦。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());
}
}
}
概念：泛化是一种一般与特殊、一般与具体之间关系的描述，具体描述建立在一般描述的基础之上，并对其进行了扩展。
在java中用来表示继承的关系。
表示方法：用实线空心三角箭头表示。
概念：实现是一种类与接口的关系，表示类是接口所有特征和行为的实现，在程序中一般通过类实现接口来描述
表示方法：空心三角形箭头的虚线，实现类指向接口
概念：是一种使用的关系，即一个类的实现需要另一个类的协助。
java中，方法参数需要传入另一个类的对象，就表示依赖这个类。
表示方法：虚线箭头，类A指向类B。
概念：表示类与类之间的联接,它使一个类知道另一个类的属性和方法，这种关系比依赖更强、不存在依赖关系的偶然性、关系也不是临时性的，一般是长期性的。
java中一个类的全局变量引用了另一个类，就表示关联了这个类
表示方法：实线箭头，类A指向类B
概念：聚合关联关系的一种特例，是强的关联关系。聚合是整体和个体之间的关系，即has-a的关系，整体与个体可以具有各自的生命周期，部分可以属于多个整体对象，也可以为多个整体对象共享。程序中聚合和关联关系是一致的，只能从语义级别来区分；
表示方法：尾部为空心菱形的实线箭头（也可以没箭头），类A指向类B
概念：组合也是关联关系的一种特例。组合是一种整体与部分的关系，即contains-a的关系，比聚合更强。部分与整体的生命周期一致，整体的生命周期结束也就意味着部分的生命周期结束，组合关系不能共享。程序中组合和关联关系是一致的，只能从语义级别来区分。
表示方法：尾部为实心菱形的实现箭头（也可以没箭头），类A指向类B
原文：https://www.cnblogs.com/huangshen/p/13284966.html