Java编程的逻辑 (16) - 继承的细节

时间 2019-11-24

标签 java 编程逻辑继承细节栏目 Java 繁體版

原文原文链接

本系列文章经补充和完善，已修订整理成书《Java编程的逻辑》，由机械工业出版社华章分社出版，于2018年1月上市热销，读者好评如潮！各大网店和书店有售，欢迎购买，京东自营连接：http://item.jd.com/12299018.htmlhtml

上节咱们介绍了继承和多态的基本概念，基本概念是比较简单的，子类继承父类，自动拥有父类的属性和行为，并可扩展属性和行为，同时，可重写父类的方法以修改行为。编程

但继承和多态概念还有一些相关的细节，本节就来探讨这些细节，具体包括：swift

构造方法
重名与静态绑定
重载和重写
父子类型转换
继承访问权限 (protected)
可见性重写
防止继承 (final)

下面咱们逐个来解释。设计模式

构造方法安全

super
微信

上节咱们说过，子类能够经过super(...)调用父类的构造方法，若是子类没有经过super(...)调用，则会自动调动父类的默认构造方法，那若是父类没有默认构造方法呢？以下例所示：框架

public class Base {
    private String member;
    public Base(String member){
        this.member = member;
    }
}

这个类只有一个带参数的构造方法，没有默认构造方法。这个时候，它的任何子类都必须在构造方法中经过super(...)调用Base的带参数构造方法，以下所示，不然，Java会提示编译错误。函数

public class Child extends Base {
    public Child(String member) {
        super(member);
    }
}

构造方法调用重写方法post

若是在父类构造方法中调用了可被重写的方法，则可能会出现意想不到的结果，咱们来看个例子：
this

这是基类代码：

public class Base {
    public Base(){
        test();
    }
    
    public void test(){
    }
}

构造方法调用了test()。这是子类代码：

public class Child extends Base {
    private int a = 123;
    
    public Child(){
    }
    
    public void test(){
        System.out.println(a);
    }
}

子类有一个实例变量a，初始赋值为123，重写了test方法，输出a的值。看下使用的代码：

public static void main(String[] args){
    Child c = new Child();
    c.test();
}

输出结果是：

0
123

第一次输出为0，第二次为123。第一行为何是0呢？第一次输出是在new过程当中输出的，在new过程当中，首先是初始化父类，父类构造方法调用 test()，test被子类重写了，就会调用子类的test()方法，子类方法访问子类实例变量a，而这个时候子类的实例变量的赋值语句和构造方法还没有执行，因此输出的是其默认值0。

像这样，在父类构造方法中调用可被子类重写的方法，是一种很差的实践，容易引发混淆，应该只调用private的方法。

重名与静态绑定

上节咱们说到，子类能够重写父类非private的方法，当调用的时候，会动态绑定，执行子类的方法。那实例变量、静态方法、和静态变量呢？它们能够重名吗？若是重名，访问的是哪个呢？

重名是能够的，重名后实际上有两个变量或方法。对于private变量和方法，它们只能在类内被访问，访问的也永远是当前类的，即在子类中，访问的是子类的，在父类中，访问的父类的，它们只是碰巧名字同样而已，没有任何关系。

但对于public变量和方法，则要看如何访问它，在类内访问的是当前类的，但子类能够经过super.明确指定访问父类的。在类外，则要看访问变量的静态类型，静态类型是父类，则访问父类的变量和方法，静态类型是子类，则访问的是子类的变量和方法。咱们来看个例子：

这是基类代码：

public class Base {
    public static String s = "static_base";
    public String m = "base";
    
    public static void staticTest(){
        System.out.println("base static: "+s);
    }
}

定义了一个public静态变量s、一个public实例变量m、一个静态方法staticTest。

这是子类代码：

public class Child extends Base {
    public static String s = "child_base";
    public String m = "child";
    
    public static void staticTest(){
        System.out.println("child static: "+s);
    }
}

子类定义了和父类重名的变量和方法。对于一个子类对象，它就有了两份变量和方法，在子类内部访问的时候，访问的是子类的，或者说，子类变量和方法隐藏了父类对应的变量和方法，下面看一下外部访问的代码：

public static void main(String[] args) {
    Child c = new Child();
    Base b = c;
    
    System.out.println(b.s);
    System.out.println(b.m);
    b.staticTest();
    
    System.out.println(c.s);
    System.out.println(c.m);
    c.staticTest();
}

以上代码建立了一个子类对象，而后将对象分别赋值给了子类引用变量c和父类引用变量b，而后经过b和c分别引用变量和方法。这里须要说明的是，静态变量和静态方法通常经过类名直接访问，但也能够经过类的对象访问。程序输出为：

static_base
base
base static: static_base
child_base
child
child static: child_base

当经过b (静态类型Base) 访问时，访问的是Base的变量和方法，当经过c (静态类型Child)访问时，访问的是Child的变量和方法，这称之为静态绑定，即访问绑定到变量的静态类型，静态绑定在程序编译阶段便可决定，而动态绑定则要等到程序运行时。实例变量、静态变量、静态方法、private方法，都是静态绑定的。

重载和重写

重载是指方法名称相同但参数签名不一样（参数个数或类型或顺序不一样），重写是指子类重写父类相同参数签名的方法。对一个函数调用而言，可能有多个匹配的方法，有时候选择哪个并非那么明显，咱们来看个例子：

这里基类代码：

public class Base {
    public int sum(int a, int b){
        System.out.println("base_int_int");
        return a+b;
    }
}

它定义了方法sum，下面是子类代码：

public class Child extends Base {
    public long sum(long a, long b){
        System.out.println("child_long_long");
        return a+b;
    }
}

如下是调用的代码：

public static void main(String[] args){
    Child c = new Child();
    int a = 2;
    int b = 3;
    c.sum(a, b);
}

这个调用的是哪一个sum方法呢？每一个sum方法都是兼容的，int类型能够自动转型为long，当只有一个方法的时候，那个方法就会被调用。但如今有多个方法可用，子类的sum方法参数类型虽然不彻底匹配可是是兼容的，父类的sum方法参数类型是彻底匹配的。程序输出为：

base_int_int

父类类型彻底匹配的方法被调用了。若是父类代码改为下面这样呢？

public class Base {
    public long sum(int a, long b){
        System.out.println("base_int_long");
        return a+b;
    }
}

父类方法类型也不彻底匹配了。程序输出为：

base_int_long

调用的仍是父类的方法。父类和子类的两个方法的类型都不彻底匹配，为何调用父类的呢？由于父类的更匹配一些。如今修改一会儿类代码，更改成：

public class Child extends Base {
    public long sum(int a, long b){
        System.out.println("child_int_long");
        return a+b;
    }
}

程序输出变为了：

child_int_long

终于调用了子类的方法。能够看出，当有多个重名函数的时候，在决定要调用哪一个函数的过程当中，首先是按照参数类型进行匹配的，换句话说，寻找在全部重载版本中最匹配的，而后才看变量的动态类型，进行动态绑定。

父子类型转换

以前咱们说过，子类型的对象能够赋值给父类型的引用变量，这叫向上转型，那父类型的变量能够赋值给子类型的变量吗？或者说能够向下转型吗？语法上能够进行强制类型转换，但不必定能转换成功。咱们以上面的例子来示例：

Base b = new Child();
Child c = (Child)b;

Child c = (Child)b就是将变量b的类型强制转换为Child并赋值为c，这是没有问题的，由于b的动态类型就是Child，但下面代码是不行的：

Base b = new Base();
Child c = (Child)b;

语法上Java不会报错，但运行时会抛出错误，错误为类型转换异常。

一个父类的变量，能不能转换为一个子类的变量，取决于这个父类变量的动态类型（即引用的对象类型）是否是这个子类或这个子类的子类。

给定一个父类的变量，能不能知道它究竟是不是某个子类的对象，从而安全的进行类型转换呢？答案是能够，经过instanceof关键字，看下面代码：

public boolean canCast(Base b){
    return b instanceof Child;
}

这个函数返回Base类型变量是否能够转换为Child类型，instanceof前面是变量，后面是类，返回值是boolean值，表示变量引用的对象是否是该类或其子类的对象。

protected

变量和函数有public/private修饰符，public表示外部能够访问，private表示只能内部使用，还有一种可见性介于中间的修饰符protected，表示虽然不能被外部任意访问，但可被子类访问。另外，在Java中，protected还表示可被同一个包中的其余类访问，无论其余类是否是该类的子类，后续章节咱们再讨论包。

咱们来看个例子，这是基类代码：

public class Base {
    protected  int currentStep;
    
    protected void step1(){
    }
    
    protected void step2(){        
    }
    
    public void action(){
        this.currentStep = 1;
        step1();
        this.currentStep = 2;
        step2();
    }
}

action() 表示对外提供的行为，内部有两个步骤step1()和step2()，使用currentStep变量表示当前进行到了哪一个步骤，step一、step2 和currentStep是protected的，子类通常不重写action，而只重写step1和step2，同时，子类能够直接访问 currentStep查看进行到了哪一步。子类的代码是：

public class Child extends Base {
    protected void step1(){
        System.out.println("child step "
                +this.currentStep);
    }
    
    protected void step2(){    
        System.out.println("child step "
                +this.currentStep);
    }
}

使用Child的代码是：

public static void main(String[] args){
    Child c = new Child();
    c.action();
}

输出为：

child step 1
child step 2

基类定义了表示对外行为的方法action，并定义了能够被子类重写的两个步骤step1和step2，以及被子类查看的变量currentStep，子类经过重写protected方法step1和step2来修改对外的行为。

这种思路和设计在设计模式中被称之为模板方法，action方法就是一个模板方法，它定义了实现的模板，而具体实现则由子类提供。模板方法在不少框架中有普遍的应用，这是使用protected的一个经常使用场景。关于更多设计模式的内容咱们暂不介绍。

可见性重写

重写方法时，通常并不会修改方法的可见性。但咱们仍是要说明一点，重写时，子类方法不能下降父类方法的可见性，不能下降是指，父类若是是public，则子类也必须是public，父类若是是protected，子类能够是protected，也能够是public，即子类能够升级父类方法的可见性但不能下降。以下所示：

基类代码为：

public class Base {
    protected void protect(){
    }
    
    public void open(){        
    }
}

子类代码为：

public class Child extends Base {
    //如下是不容许的的，会有编译错误
//    private void protect(){
//    }
    
    //如下是不容许的，会有编译错误
//    protected void open(){        
//    }
    
    public void protect(){        
    }
}

为何要这样规定呢？继承反映的是"is-a"的关系，即子类对象也属于父类，子类必须支持父类全部对外的行为，将可见性下降就会减小子类对外的行为，从而破坏"is-a"的关系，但子类能够增长父类的行为，因此提高可见性是没有问题的。

防止继承 (final)

上节咱们提到继承是把双刃剑，具体缘由咱们后续章节解说，带来的影响就是，有的时候咱们不但愿父类方法被子类重写，有的时候甚至不但愿类被继承，实现这个的方法就是final关键字。以前咱们提过final能够修饰变量，这是final的另外一个用法。

一个Java类，默认状况下都是能够被继承的，但加了final关键字以后就不能被继承了，以下所示：

public final class Base {
   //....
}

一个非final的类，其中的public/protected实例方法默认状况下都是能够被重写的，但加了final关键字后就不能被重写了，以下所示：

public class Base {
    public final void test(){
        System.out.println("不能被重写");
    }
}

小结

本节咱们讨论了Java继承概念引入的一些细节，有些细节可能平时遇到的比较少，但咱们仍是须要对它们有一个比较好的了解，包括构造方法的一些细节，变量和方法的重名，父子类型转换，protected，可见性重写，final等。

但还有些重要的地方咱们没有讨论，好比，建立子类对象的具体过程？动态绑定是如何实现的？让咱们下节来探索继承实现的基本原理。

----------------

未完待续，查看最新文章，敬请关注微信公众号“老马说编程”(扫描下方二维码)，从入门到高级，深刻浅出，老马和你一块儿探索Java编程及计算机技术的本质。原创文章，保留全部版权。

-----------

更多相关原创文章

计算机程序的思惟逻辑 (13) - 类

计算机程序的思惟逻辑 (14) - 类的组合

计算机程序的思惟逻辑 (15) - 初识继承和多态

计算机程序的思惟逻辑 (17) - 继承实现的基本原理

计算机程序的思惟逻辑 (18) - 为何说继承是把双刃剑

计算机程序的思惟逻辑 (19) - 接口的本质

计算机程序的思惟逻辑 (20) - 为何要有抽象类？

计算机程序的思惟逻辑 (21) - 内部类的本质