面向对象-继承

基本概念

继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。
继承的好处：
1.提高代码的复用性；
2.让类与类之间产生了关系，给第三个特征–多态提供了前提。
继承的弊端：打破封装性。
java语言中支持单继承，不直接支持多继承，但是对C++中的多继承机制进行了改良，java通过“多实现”的方式来体现多继承。
单继承：一个子类只能有一个直接父类；
多继承：一个子类可以有多个直接父类。

多继承的弊端：当多个父类中有相同的成员时，会产生调用的不确定性。
Java中支持多重（多层）继承：C extends B,B extends A. 这样就会出现继承体系。当要使用继承体系时：
1.查看该体系的顶层类，了解该体系的基本功能；
2.创建体系的最子类功能，完成功能的使用。
什么时候定义使用继承：
当类与类之间存在着所属关系（A is a B）,就定义继承。

子父类的成员特点

成员变量

this和super
当本类的成员和局部成员同名时，用this区分；
当子父类的成员变量同名时，用super区分。

this和super的用法很相似。不同之处在于：
this代表一个本类对象的引用；super代表一个父类空间，不代表父类对象。（因为创建子类对象的时候，可能不会创建父类对象实体，所以不存在父类对象，用super代替父类空间。）
子类不能直接访问父类的私有内容，但是如果父类有get方法就可以访问了（super.getXxx();）

class parent
{
    private int num=4;
    public int getNum()
    {
        return num;
    }

}
class son
{
    int num=5;//这种情况下的变量同名不多见，只是作为一个示例了解   因为父类有的变量子类可以继承过来，不需要重新定义这样的同名变量
    void show()
    {
        System.out.println(num+"-"+super.getNum());//其中 num是this.num的简写
    }
    class ExtendsDemo
    {
        public static void main(String[] args)
        {
            son kid=new son();
            kid.show();
        }//输出： 5-4
    }

成员函数

覆盖
当子父类中出现成员函数一模一样的情况（函数声明一致），会运行子类的函数。这种操作称为覆盖操作。这是函数在子父类中的特性。

函数的两个特性：
1.重载（overload）：在同一个类中，参数列表等不一样，只是函数名必须一样。
2.覆盖（override）：在子父类中，也叫重写，复写。函数名、参数列表，返回类型等都必须一模一样。

覆盖的注意事项：
1.子类方法覆盖父类方法时，子类权限必须大于或者等于父类的权限（public、private、无权限修饰符等）
父类方法私有，子类方法名相同时，这种情况不叫覆盖，因为父类私有方法子类访问不到，子类并不知道父类有这种方法。
2.静态方法只能被静态覆盖，或者静态覆盖。

什么时候使用覆盖操作：
当对一个类进行子类扩展时，子类需要保留父类的功能声明，但是要定义子类中该功能的特有内容时，就使用覆盖操作来完成。

class Phone
{
    void call()
    {
        //方法体
    }
    void show()
    {
        System.out.println("12345");
    }
}
class NewPhone extends Phone
{//继承了Phone里的call和show方法
    void show()//覆盖show函数
    {
        System.out.println("miaomiao");//函数里新加的功能
        super.show();//父类中原有的功能，不需要重写一遍

    }
}
class ExtendsDemo1
{
    NewPhone np=new NewPhone();
    np.show();
}

子父类里的构造函数

特点：
1.在子类实例化对象时，发现访问子类构造函数时，父类的构造函数也运行了，这是因为在子类的构造函数中第一行有一个默认的隐式语句：super();
(super();调用的就是父类的空参数构造函数，this();调用的是本类的空参数构造函数)
2.如果父类的构造函数不是空参数的，则在子类中的super就必须显式为非空参数的。
3.构造函数不能覆盖，也不可以继承（只能通过super来访问）

子类实例化的过程：子类中所有的构造函数默认都会访问父类的空参数构造函数。

为什么子类实例化时要访问父类的构造函数：
因为子类继承了父类，获取到了父类中的内容（属性），所以在使用父类内容前，要先看父类是如何对自己的内容进行初始化的，因此子类在构造对象时，必须访问父类的构造函数。为了完成这个必须的动作，就在子类的构造函数中，加入了super语句。如果父类中没有定义空参数构造函数，那么子类的构造函数就必须用super明确要调用的父类中的哪个构造函数。
注意：super语句必须要定义在子类构造函数的第一行，因为父类的初始化动作要先完成。
子类的构造函数中，如果使用this调用本类构造函数时，那么super就没有了因为super和this都只能定义在第一行，所以只能有一个。但是可以保证的是，子类中肯定会有其他的构造函数（被this调用的构造函数）访问父类的构造函数。

class parent
{
    parent()
    {
        super();//隐式语句，继承于Object类
        show();
        return();//隐式语句
    }
    void show()
    {
        System.out.println("parent show");
    }
}
class son extends parent
{
    int num=8;
    son()
    {
        super();//这是一个分水岭。通过super初始化父类内容时，子类的完成并未进行显示初始（num此时默认初始化为0），等super();执行完父类初始化完毕后，才进行子类的成员变量初始化（num显示初始化为8）
        return；//隐式语句
    }
    void show()
    {
        System.out.println("son show..."+num);
    }
}
class ExtendsDemo2
{
    public static void main(String[] args)
    {
        son ss=new son();
        ss.show();
    }
}

以上代码会输出：
son show…0
son show…8

证明了一个对象实例化过程：
以Person p=new Person();为例
1、JVM会读取指定路径下的Person.class文件，并加载进内存，且会先加载Person的父类（如果有直接父类的情况下）；
2、在堆内存中开辟空间，分配地址；
3、并且在对象空间中，对对象中的属性进行默认初始化；
4、调用对应的构造函数进行初始化；
5、在构造函数中，第一行会先调用父类的构造函数进行初始化；
6、父类初始化完毕后，再对子类的属性进行显示初始化；
7、再进行子类构造函数的特定初始化；
8、初始化完毕后，将堆分配的地址值赋值给引用变量。