您的位置:首页 > 软件设计 > 面向对象 > 正文

什么是里氏替换原则

更多 时间:2014-6-10 类别:面向对象 浏览量:2403

什么是里氏替换原则

什么是里氏替换原则

一、继承的弊端

继承作为面向对象三大特性之一,在给程序设计带来巨大便利的同时,也带来了弊端。例如

1、继承是侵入性的。只要继承,就必须拥有父类的所有属性和方法;

2、降低代码的灵活性。子类必须拥有父类的属性和方法,让子类自由的世界中多了些约束;

3、增强了耦合性。当父类的常量、变量和方法被修改时,必需要考虑子类的修改,而且在缺乏规范的环境下,这种修改可能带来非常糟糕的结果——大片的代码需要重构。

二、里氏替换原则的定义

1、里氏替换原则通俗的来讲就是:子类可以扩展父类的功能,但不能改变父类原有的功能。

2、里氏代换原则告诉我们,在软件中将一个基类对象替换成它的子类对象,程序将不会产生任何错误和异常,反过来则不成立,如果一个软件实体使用的是一个子类对象的话,那么它不一定能够使用基类对象。

3、里氏代换原则是实现开闭原则的重要方式之一,由于使用基类对象的地方都可以使用子类对象,因此在程序中尽量使用基类类型来对对象进行定义,而在运行时再确定其子类类型,用子类对象来替换父类对象

三、里氏替换原则包含的含义

1、子类可以实现父类的抽象方法,但是不能覆盖父类的非抽象方法

在我们做系统设计时,经常会设计接口或抽象类,然后由子类来实现抽象方法,这里使用的其实就是里氏替换原则。子类可以实现父类的抽象方法很好理解,事实上,子类也必须完全实现父类的抽象方法,哪怕写一个空方法,否则会编译报错。

里氏替换原则的关键点在于不能覆盖父类的非抽象方法。父类中凡是已经实现好的方法,实际上是在设定一系列的规范和契约,虽然它不强制要求所有的子类必须遵从这些规范,但是如果子类对这些非抽象方法任意修改,就会对整个继承体系造成破坏。而里氏替换原则就是表达了这一层含义。

在面向对象的设计思想中,继承这一特性为系统的设计带来了极大的便利性,但是由之而来的也潜在着一些风险。所以,类C1继承类C时,可以添加新方法完成新增功能,尽量不要重写父类C的方法。否则可能带来难以预料的风险。

例如

  •  
  • Java 代码   复制
  • 
    public class C {
        public int func(int a, int b){
            return a+b;
        }
    }
     
    public class C1 extends C{
        @Override
        public int func(int a, int b) {
            return a-b;
        }
    }
     
    public class Client{
        public static void main(String[] args) {
            C c = new C1();
            System.out.println("2+1=" + c.func(2, 1));
        }
    }
    
    		
  • 运行结果:2+1=1

    上面的运行结果明显是错误的。类C1继承C,后来需要增加新功能,类C1并没有新写一个方法,而是直接重写了父类C的func方法,违背里氏替换原则,引用父类的地方并不能透明的使用子类的对象,导致运行结果出错。

    2、子类中可以增加自己特有的方法

    在继承父类属性和方法的同时,每个子类也都可以有自己的个性,在父类的基础上扩展自己的功能。前面其实已经提到,当功能扩展时,子类尽量不要重写父类的方法,而是另写一个方法,所以对上面的代码加以更改,使其符合里氏替换原则

    例如

  •  
  • Java 代码   复制
  • 
    public class C {
        public int func(int a, int b){
            return a+b;
        }
    }
     
    public class C1 extends C{
        public int func2(int a, int b) {
            return a-b;
        }
    }
     
    public class Client{
        public static void main(String[] args) {
            C1 c = new C1();
            System.out.println("2-1=" + c.func2(2, 1));
        }
    }
    
    		
  • 运行结果:2-1=1

    3、当子类覆盖或实现父类的方法时,方法的前置条件(即方法的形参)要比父类方法的输入参数更宽松

    例如

  •  
  • Java 代码   复制
  • 
    import java.util.HashMap;
    public class Father {
        public void func(HashMap m){
            System.out.println("执行父类...");
        }
    }
     
    import java.util.Map;
    public class Son extends Father{
        public void func(Map m){//方法的形参比父类的更宽松
            System.out.println("执行子类...");
        }
    }
     
    import java.util.HashMap;
    public class Client{
        public static void main(String[] args) {
            Father f = new Son();//引用基类的地方能透明地使用其子类的对象。
            HashMap h = new HashMap();
            f.func(h);
        }
    }
    
    
    		
  • 运行结果:执行父类...

    注意Son类的func方法前面是不能加@Override注解的,因为否则会编译提示报错,因为这并不是重写(Override),而是重载(Overload),因为方法的输入参数不同。

    4、当子类的方法实现父类的抽象方法时,方法的后置条件(即方法的返回值)要比父类更严格

    例如

  •  
  • Java 代码   复制
  • 
    import java.util.Map;
    public abstract class Father {
        public abstract Map func();
    }
     
    import java.util.HashMap;
    public class Son extends Father{
         
        @Override
        public HashMap func(){//方法的返回值比父类的更严格
            HashMap h = new HashMap();
            h.put("h", "执行子类...");
            return h;
        }
    }
     
    public class Client{
        public static void main(String[] args) {
            Father f = new Son();//引用基类的地方能透明地使用其子类的对象。
            System.out.println(f.func());
        }
    }
    
    		
  • 执行结果:{h=执行子类...}

    四、在使用里氏代换原则时需要注意如下几个问题

    1、子类的所有方法必须在父类中声明,或子类必须实现父类中声明的所有方法。根据里氏代换原则,为了保证系统的扩展性,在程序中通常使用父类来进行定义,如果一个方法只存在子类中,在父类中不提供相应的声明,则无法在以父类定义的对象中使用该方法。

    2、我们在运用里氏代换原则时,尽量把父类设计为抽象类或者接口,让子类继承父类或实现父接口,并实现在父类中声明的方法,运行时,子类实例替换父类实例,我们可以很方便地扩展系统的功能,同时无须修改原有子类的代码,增加新的功能可以通过增加一个新的子类来实现。里氏代换原则是开闭原则的具体实现手段之一。

    3、在系统设计时,遵循里氏替换原则,尽量避免子类重写父类的方法,可以有效降低代码出错的可能性。

    本文地址:http://www.studyofnet.com/news/482.html

    标签:面向对象