Java 学习笔记(6)——继承

以前说过了Java中面向对象的第一个特征——封装，这篇来说它的第二个特征——继承。通常在程序设计中，继承是为了减小重复代码。

继承的基本介绍

public class Child extends Parent{
    //TODO
}

使用继承后，子类中就包含了父类全部内容的一份拷贝。

子类与父类重名成员的访问。

重名属性

当子类与父类中有重名的数据成员时，若是使用子类对象的引用进行调用，那么优先调用子类的成员，若是子类成员中没有找到那么会向上查找找到父类成员。例如

public class Parent{
    public int num = 10;
}

public class Child extends Parent{
    public int num = 20;

    public static void main(String[] args){
        Parent obj = new Child();
        System.out.println(obj.num); //输出10
        Child c = new Child();
        System.out.println(c.num); //输出20
    }
}

两者一样是建立的Child对象，那么为什么一个是10，而一个是20 呢？ 在C/C++中常常提到一个概念就是，指针自己存储的是一个地址值，指针自己是没有任何数据类型的，而指针指向的地址有，咱们在程序中定义的指针类型决定了代码在访问指针所指向的内存时是如何翻译这段内存的。Java中虽说没有开放操做内存的能力，可是引用自己也是一个指针。若是将父类类型的引用来保存子类对象的地址，那么从引用类型来看，它只能看到父类的相关内容，因此这里它将对象所在内存当作父类的类型，因此第一个打印语句访问到的是父类的 num 成员。而第二个它能看到子类的整个内存，因此说它优先使用子类的 num 成员。

上面是第一种状况，即在外部直接调用，若是经过方法来访问呢

public class Parent{
    private int num = 10;

    public int getNum(){
        return this.num;
    }
}

public class Child extends Parent{
    public int num = 20;

    public int getNum(){
        return this.num;
    }

    public static void main(String[] args){
        Parent obj = new Child();
        System.out.println(obj.getNum()); //输出20
        Child c = new Child();
        System.out.println(c.getNum()); //输出20
    }
}

第一条输出语句实际上使用了Java中的多态特性，这个时候会调用子类的方法，而第二条直接调用子类方法，而在子类方法中经过this调用自身的 num 成员，因此这里会输出两个20

无论哪一种状况，在经过对象的引用调用对象成员的时候会根据引用类型来翻译对应的内存，找到须要访问的变量，若是子类中未找到则向上查找父类，若是父类也未找到，则会报错。

下面来看看Java中继承的内存图来加深这个的理解

public class Parent{
    public int num = 10;

    public int getNum(){
        return this.num;
    }
}

public class Child extends Parent{
    public int num = 20;

    public int getNum(){
        return this.num;
    }

    public void show(){
        int num = 30;
        System.out.println(num); //30
        System.out.println(this.num); //20
        System.out.println(super.num); //10
    }

    public static void main(String[] args){
        Child obj = new Child();
        obj.Show();
        obj.getNum(); //20
    }
}

对象的内存分布大体以下:

首先JVM加载程序的时候将类定义放到方法区中，此时方法区中有两个类的定义，其中子类中有一个 [[class_super]] 标志，用于标明它的父类是哪一个。而后建立main的栈并执行main函数，在main函数中建立了一个Child的对象，那么JVM会根据方法区中的相关内容在堆中建立子类对象， 子类对象中包含一整份的父类的拷贝。而后调用Show方法，它首先根据方法区中的标识查找，在子类中找到了这个方法建立方法栈并调用。在方法中，定义了一个局部变量 num，当访问 num这个变量时会首先在栈中查找，若是找到则访问，若是没有则在子类中查找，若是子类中也没有，则会访问父类。就这样在栈中找到了num。接着访问 this.num。 这个时候JVM会首先到子类中查找，找不到则会进一步查找父类。发如今子类中找到了。接着访问 super.num，那么JVM会主动去父类中查找。

show方法执行完了以后，JVM回收它的堆栈，接着调用getNum() 方法，查找方式与调用show的相同。后面的就再也不说了，与以前的相似。

重写

向上面的例子中这样的。当子类与父类的方法名、参数列表相同时，若是用子类对象进行调用，那么会调用子类方法，这个时候父类的同名方法就被重写了。注意：这里并无强调返回值也同样，其实这里只须要返回值能正常的发生隐式转换便可。这里也没有规定它的访问权限，这里只要求子类方法的访问权限大于等于父类方法的访问权限，也就是在同一条件下保证两者都能访问。虽然没有这两方面的限制，可是通常状况下父类的方法与子类重写的方法在形式上应该是彻底同样的。

public class Parent{
    public int num = 10;

    public int getNum(int n){
        return this.num;
    }
}

public class Child extends Parent{
    public int num = 20;

    public int getNum(float f){
        return this.num;
    }
}

上面的代码并无实现重写的功能，可是若是程序员本身理解不到为，认为这是一个重写，而且在代码中按照重写在使用，那么编译虽然不会报错，可是在运行过程当中可能会出现问题，这个时候可使用 @Overwrite 注解，来告诉编译器，这里是一个重写，若是编译器判断这个不是重写，那么编译会报错，这样就将运行时错误提高到了编译时，有注意bug的排除。

注解与注释有什么相同与区别呢：我认为两者都是用于对程序作一个说明，可是注释是给人看的，注解是给机器看的。

重写与重载有什么区别呢？

1. 重写是发生在类的继承关系中的，要求函数名、参数列表相同
2. 重载并无规定使用的场合，要求函数名相同、而参数列表不一样

既然说到重载，我想起来了java与c++中重载的一个区别

void sayHello(long f);
void sayHello(int);

根据上述函数的定义，java和c++中都造成了一个重载的关系，若是在C中使用代码 sayHello(10) 来调用的时候，由于这里的10既能够理解为long也能够理解为int，因此这里发生了二义性，编译会报错，而java中 10 默认为int，因此这里会调用int参数的函数，而想要调用long型的参数，得写成 sayHello(10L)。这算是两者之间和有趣的一个现象。

构造函数

与C/C++中的相同，调用构造的时候会优先调用父类构造，像上面的代码中，并无明显的调用构造，在建立类的时候会隐式的调用构造，并在子类构造中隐式调用父类构造。可是一旦手工定义了构造，那么编译器将再也不额外提供构造。

public class Parent{
    Parent(int n){
        System.out.println(n);
    }
}

public class Child extends Parent{
    Child(){ //这个会编译报错
        System.out.println("Child");
    }
}

Child构造函数默认会调用父类的无参构造，可是因为父类提供了构造，此时编译器再也不提供默认的无参构造，因此这里找不到父类的无参构造，报错。这个代码能够进行以下的修改

public class Child extends Parent{
    Child(){ //这个会编译报错
        super(19);
        System.out.println("Child");
    }

    //或者
    Child(int n){
        //隐式调用super(n)
        System.out.println("Child");
    }
}

这里使用super关键字显示调用父类的带参构造。或者定义一个带参构造，编译器会默认为你添加上调用父类带参构造的过程。

在Java中super关键字的做用主要有如下几点:

1. 在子类中访问父类成员
2. 在子类中调用父类构造函数，这种用法必须保证super在子类构造中是第一条被执行的语句，并且只能有惟一的一条

咱们说super表明父类，那么this表明的就是类自己，那么它有什么具体的做用，又有哪些须要注意的点呢？

1. this能够访问本类成员变量
2. 在本类的成员方法中访问另外一个成员方法
3. 在本类构造方法中访问另外一个构造

注意：第3中用法中，this关键字必须是构造方法执行的第一条语句，并且只能有惟一的一条。这条规则与super关键字的相同，那么在构造中既有this又有super的时候该怎么办呢？答案是没法这么使用，Java中规定this和super关键字在构造函数中只能出现一个。

Java中的 继承关系

在C++中，最让人头疼的是多继承的菱形继承关系，为了防止二义性，Java禁止多继承，只容许单继承。可是java中运行多继承，而且一个父类运行有多个子类。

在Java的多级继承中若是出现同名的状况，访问时该怎么办呢？

原则仍然相同，根据new出来的对象和左侧保存对象的引用类型来判断，若是是父类类型，则访问成员变量时只能访问父类，若是是访问方法则须要考虑多态。若是建立的是父类则只能访问父类的成员变量和方法