面向对象编程的七大原则有（开口单依最合里）：
开闭原则------------------------------------开
接口隔离原则------------------------------口
单一职责原则------------------------------单
依赖倒转(倒置)原则----------------------依
迪米特法则（最少知道原则）--------最
合成复用原则------------------------------合
里氏替换原则------------------------------里
指对于类或者方法来讲：
一个类所拥有的方法不应该超出所代表的对象应该拥有的范围，比如一个实体类不应该拥有查询数据库的能力，而应该把处理与数据库交互的方法封装到dao类中。
一个方法处理的功能应该是单一的，比如dao查询数据的方法中不应该包含修改数据的逻辑代码，而应该重新创建一个修改方法。
指程序使用某一个接口时，不应该使用过大的接口，也就是说程序用不到的方法不应该被包含在所使用的的接口中。
因为类与类之间的依赖（类与类之间的调用）是通过调用接口完成的，当接口中的定义的方法过多时，会迫使实现类非常臃肿，实现一些不需要的方法，代码的重用性和可读性变差，此时我们就应该将过于复杂的接口分解成多个简单的接口，这样就可以根据需要实现部分接口，使得实现类变得简单易读。
指的是面向接口编程，当客户端需要调用某个类时，转换为调用它实现的接口。这要就把对实现类的依赖转换成了对接口的依赖，即依赖倒转。
这样做的好处在于提高代码的可维护性，后续替换实现类非常方便，可拓展性强。
里氏替换原则说的就是继承关系，当类A继承了类B时，将程序中对类B的引用替换成类A时，程序的运行结果并不会发生变化，此时A类称为子类，B类称为父类。
让我们遵守里氏替换原则，就是告诉我们尽量不要重写父类中的方法，因为这样就破坏了里式替换的效果，程序的运行会受到影响。特别是在多态使用比较多的场景中，很容易弄混具体使用的是父类中的版本还是子类中的版本，进而降低程序的可读性。
但是，继承本身就是一种耦合，在遵循里氏替换原则的前提下（不重写父类的方法），对父类的修改会影响所有的子类，进而导致引用子类的程序受到影响。
所以，在完全遵守里氏替换原则的条件下，当我们需要重写B类的方法时，我们就不应该采用继承关系，而应该让A类继承B类的上一级类型C（可能是一个接口、也可能是一个类），这样就可以解除A、B之间的耦合。如果需要在A类中使用B类的版本，可以在A类中设置一个B类的成员变量，再去进行调用即可。
也就是说，继承在原则上是拒绝重写方法的；如果需要重写，就不要继承。
开闭原则指的是：对扩展开放、对修改关闭，扩展是对类的提供方而言的，修改是对类的使用方而言的。当需要给程序添加新的功能时，应当为类的提供方书写新的实现，尽量不修改或者少修改原有的代码。
想要实现开闭原则，必须遵守依赖倒置原则，即类的使用方依赖类的提供方使用的接口。
例如：设计一个程序，完成绘图功能
main方法： public static void main(String[] args) { GraphicEditor editor = new GraphicEditor(); editor.drawShape(new Rectangle()); editor.drawShape(new Circle()); } 绘图器：（Shape使用方） class GraphicEditor { public void drawShape(Shape s) { if (s.m_type == 1) drawRectangle(s); else if (s.m_type == 2) drawCircle(s); } public void drawRectangle(Shape r) { System.out.println(" 矩形 "); } public void drawCircle(Shape r) { System.out.println(" 圆形 "); } } 图形：(Shape提供方) abstract class Shape { int m_type; } 矩形： class Rectangle extends Shape { Rectangle() { super.m_type = 1; } } 圆形： class Circle extends Shape { Circle() { super.m_type = 2; } } 当我们使用上面的代码实现功能时，就不符合开闭原则，因为当我们需要让程序绘制一个三角形时，我们比较要书写Shape的三角形实现，我们还需要修改Shape的使用方GraphicEditor中的drawShape方法，这是不允许的。
更合理的做法是：
main方法： public static void main(String[] args) { GraphicEditor editor = new GraphicEditor(); editor.drawShape(new Rectangle()); editor.drawShape(new Circle()); } 绘图器：（Shape使用方） class GraphicEditor { public void drawShape(Shape s) { s.draw(); } } 图形：(Shape提供方) abstract class Shape { int m_type; public void draw();//将使用方中的绘图方法放入到提供方标准中，由各个实现类实现 } 矩形： class Rectangle extends Shape { Rectangle() { super.m_type = 1; } public void draw(){ System.out.println("矩形"); } } 圆形： class Circle extends Shape { Circle() { super.m_type = 2; } public void draw(){ System.out.println("圆形"); } } 这样做的话，我们增加绘制三角形的功能就只需要书写新的实现就可以了，不需要改动使用方的代码。
想要准确的使用开闭原则，重点要把握类的提供方和使用方，在使用方中更多的使用抽象的东西，将具体的实现交给提供方。
又称为最少知识原则，目的是减少类与类之间的耦合。类与类之间的耦合可以分为直接朋友耦合和陌生耦合，例如现在有两个类：A类和B类，A类中依赖了B类。
如果：B类作为成员变量、方法参数或者方法返回值存在于A类中，我们就将B类称为A类的朋友类，产生的耦合叫做直接朋友耦合。
如果：B类作为局部变量存在于A类中，我们就将B类称为A类的陌生类，产生的耦合叫做陌生耦合。
直接朋友耦合不是迪米特法则关注的部分，它关注的是陌生耦合的消灭，即：我们不应该将陌生类作为成员变量，所以迪米特法则又可以被简单的表述为：一个类只应该与直接的朋友进行通信。
例如： 有一个集团公司，下属单位有分公司和直属部门，现在要求打印出所有下属单位的员工ID。先来看一下违反迪米特法则的设计。
//总公司员工 public class Employee { private String id; public void setId(String id){ this.id = id; } public String getId(){ return id; } } //分公司员工 public class SubEmployee { private String id; public void setId(String id){ this.id = id; } public String getId(){ return id; } } //子公司管理员 public class SubCompanyManager { public List<SubEmployee> getAllEmployee() { List<SubEmployee> list = new ArrayList<SubEmployee>(); for (int i = 0; i < 100; i++) { SubEmployee emp = new SubEmployee(); //为分公司人员按顺序分配一个ID emp.setId("分公司" + i);list.add(emp); } return list; } } //总公司管理员 public class CompanyManager { public List<Employee> getAllEmployee(){ List<Employee> list = new ArrayList<Employee>(); for(int i=0; i<30; i++){ Employee emp = new Employee(); //为总公司人员按顺序分配一个ID emp.setId("总公司"+i); list.add(emp); } return list; } /** * 所有员工的id * @param sub */ public void printAllEmployee(SubCompanyManager sub){ List<SubEmployee> list1 = sub.getAllEmployee(); for(SubEmployee e:list1){ System.out.println(e.getId()); } List<Employee> list2 = this.getAllEmployee(); for(Employee e:list2){ System.out.println(e.getId()); } } } //测试类 public class Main { public static void main(String[] args){ CompanyManager e = new CompanyManager(); e.printAllEmployee(new SubCompanyManager()); } } 现在这个设计的主要问题出在CompanyManager中，根据迪米特法则，只与直接的朋友发生通信，而SubEmployee类并不是CompanyManager类的直接朋友（以局部变量出现的耦合不属于直接朋友），从逻辑上讲总公司管理员只与他的分公司管理员耦合就行了，与分公司的员工并没有任何联系，这样设计显然是增加了不必要的耦合。按照迪米特法则，应该避免类中出现这样非直接朋友关系的耦合。
修改方法：
应该将CompanyManager中打印子公司员工的代码移动到SubCompanyManager中，这样就消除了总公司管理员与分公司员工的耦合，而是让分公司的员工与分公司的管理员发生耦合，他们属于直接朋友类。
这就是迪米特法则的作用：消除一个类与陌生类之间的耦合，只与直接朋友类进行通信。
前置知识：类与类之间的关系
依赖： 表示一个类依赖于另外一个类的定义。依赖关系仅仅描述了类与类之间的一种使用与被使用的关系，在Java中体现为局部变量、方法的参数或者是对静态方法的调用。
关联： 表示一个类知道另外一个类的属性和方法， 关联可以是双向的，也可以是单向的。 体现在Java中，关联关系是通过成员变量来实现的。
合成和聚合都是关联的特殊种类。
聚合： 表示较弱的“拥有”关系，即A类拥有B类的成员变量， 代表部分的B类对象有可能会被多个代表整体的对象所共享，而且不一定会随着某个代表整体的对象被销毁或破坏而被销毁或破坏，部分的生命周期可以超越整体。例如，班级和学生，当班级删除后，学生还能存在，学生可以被培训机构引用。
class Student { } class Classes{ privateStudent student; //student的赋值仅仅是从外部传递过来一个引用，并不是在类的内部创建的 //这个引用可能被其他的类引用，此对象的产生于销毁与house对象不同步 publicClasses(Student student){ this.student=student; } } 合成： 表示强得多的“拥有”关系。 在一个合成关系里，部分和整体的生命周期是一样的。一个合成的新对象完全拥有对其组成部分的支配权，包括它们的创建和湮灭等。 例如，一个人由头、四肢和各种器官组成，人与这些具有相同的生命周期，人死了，这些器官也就挂了。
class Room{ public Room createRoom(){ System.out.println(“创建房间”); return new Room(); } } class House{ private Room room; //room的赋值使用的是在类的内部创建的对象，此对象的产生于销毁与house对象同步 public House(){ room=new Room(); } public void createHouse(){ room.createRoom(); } } 合成复用原则说的就是：当一个类A需要复用类B中的方法时，应该尽量使用合成/聚合的方式，而不是采用继承。
为什么使用合成/聚合复用，而不使用继承复用？
1、合成/聚合复用
由于合成或聚合可以将已有对象纳入到新对象中，使之成为新对象的一部分，因此新对象可以调用已有对象的功能。这样做的好处有
（1） 新对象存取成分对象的唯一方法是通过成分对象的接口。
（2） 这种复用是黑箱复用，因为成分对象的内部细节是新对象看不见的。
（3） 这种复用支持包装。
（4） 这种复用所需的依赖较少。
（5） 每一个新的类可以将焦点集中到一个任务上。
（6） 这种复用可以再运行时间内动态进行，新对象可以动态地引用与成分对象类型相同的对象。
一般而言，如果一个角色得到了更多的责任，那么可以使用合成/聚合关系将新的责任委派到合适的对象。当然，这种复用也有缺点。最主要的缺点就是通过这种复用建造的系统会有较多的对象需要管理。
2、继承复用
继承复用通过扩展一个已有对象的实现来得到新的功能，基类明显的捕获共同的属性和方法，而子类通过增加新的属性和方法来扩展超类的实现。继承是类型的复用。
继承复用的优点：
（1） 新的实现较为容易，因为超类的大部分功能可以通过继承关系自动进入子类。
（2） 修改或扩展继承而来的实现较为容易。
继承复用的缺点。
（1） 继承复用破坏包装，因为继承将超类的实现细节暴露给了子类。因为超类的内部细节常常对子类是透明的，因此这种复用是透明的复用，又叫“白箱”复用。
（2） 如果超类的实现改变了，那么子类的实现也不得不发生改变。因此，当一个基类发生了改变时，这种改变会传导到一级又一级的子类，使得设计师不得不相应的改变这些子类，以适应超类的变化。
（3） 从超类继承而来的实现是静态的，不可能在运行时间内发生变化，因此没有足够的灵活性。
由于继承复用有以上的缺点，所有尽量使用合成/聚合而不是继承来达到对实现的复用，是非常重要的设计原则。
设计原则的核心使用思想：
1) 找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。 2) 针对接口编程，而不是针对实现编程。 3) 为了交互对象之间的松耦合设计而努力。
