1、开闭原则
    开闭原则是最基础的设计原则，对扩展开放，对修改关闭；其他五大原则都是开闭的具体实现；

    2、里氏替换原则

    继承
    继承的优点
    代码共享，减少创建类的工作量，每个子类都拥有父类的属性和方法；
    提高代码的重用性；
    提高代码的可扩展性；
    继承的缺点：
    继承具有侵入性，只要继承了父类，则必须拥有父类的所有属性和方法；
    降低了代码的灵活性；
    增强了代码的耦合性，当父类的属性和方法需要修改时，必须要考虑到所有子类；

    举例说明继承的一些缺点

    1. //需要完成一个两数相减的功能，由类A来负责
    2. class A{  
    3.     public int func1(int a, int b){  
    4.         return a-b;  
    5.     }  
    6. }  
    8. public class Client{  
    9.     public static void main(String[] args){  
    10.         A a = new A();  
    11.         System.out.println("100-50="+a.func1(100, 50));  
    12.         System.out.println("100-80="+a.func1(100, 80));  
    13.     }  
    14. }
    15. //结果：
    16. 100-50=50
    17. 100-80=20
    19. //现在增加一个功能：完成两数相加，然后再与100求和，由类B来负责
    20. class B extends A{  
    21.     public int func1(int a, int b){  
    22.         return a+b;  
    23.     }  
    25.     public int func2(int a, int b){  
    26.         return func1(a,b)+100;  
    27.     }  
    28. }  
    30. public class Client{  
    31.     public static void main(String[] args){  
    32.         B b = new B();  
    33.         System.out.println("100-50="+b.func1(100, 50));  
    34.         System.out.println("100-80="+b.func1(100, 80));  
    35.         System.out.println("100+20+100="+b.func2(100, 20));  
    36.     }  
    37. }  
    38. 结果：
    39. 100-50=150
    40. 100-80=180
    41. 100+20+100=220

    我们看到原来相减的功能方法得出的结果是错误的，是因为我们在子类中的方法无意与父类中的方法名和参数一致，实现了重写，这样就会让我们继承体系的可复用性大大降低，特别是运用多态特别频繁时，出错的概率就特别大，违反了里氏替换原则；

    什么是里氏替换原则
    子类一定可以替换掉父类，只要是父类出现的地方，换成其子类不会出现任何的异常。要实现这个原则，必须 要做到四点：
    子类必须要实现父类的所有抽象方法，但不能重写父类的非抽象方法；
    子类可以增加自己特有的方法；
    子类如果要重载父类的方法，那么子类方法的前置条件（方法的参数）一定得比父类方法的参数要更加宽松
    子类实现父类的抽象方法时，子类方法的后置条件（方法的返回值）一定得比父类方法的返回值要更加严格

    总结一下里氏替换原则就是：子类可以扩展父类的功能，但是不能改变父类原有的功能。