Java OOP - 三大特性之继承性(Inheritance)

什么是继承？

Java中的继承作为Java面向对象三大特性之一。子类继承父类，表明子类是一种特殊的父类，并且具有父类所不具有的一些属性或方法，允许创建分等级层次的类。

类初始化

从类的结构上而言，其内部可以有如下四种常见形态：属性（包括类属性和实例属性）、方法（包括类方法和实例方法）、构造器和初始化块（包括类的初始化块和实例的初始化块）。对于继承中的初始化顺序，又具体分为类的初始化和对象的初始化。

在jvm装载类的准备阶段，首先为类的所有类属性和类初始化块分配内存空间。并在类首次初始化阶段中为其进行初始化，类属性和类初始化块之间的定义时的顺序决定了其初始化的顺序。若类存在父类，则首先初始化父类的类属性和类初始化块，一直上溯到Object类最先执行。对象初始化：

在new创建对象时，首先对对象属性和初始化块分配内存，并执行默认初始化。如果存在父类，则先为父类对象属和初始化块先分配内存并执行初始化。然后执行父类构造器中的初始化程序，接着才开始对子类的对象属性和初始化块执行初始化。

注意：

1. 在对象初始化阶段，属性和方法均针对子类可以从父类继承过来的属性和方法而言，一般而言，都是针对父类中非private而言的。因为private修饰的为父类所特有的，子类没有继承过来，当new子类时，无须为其分配空间并执行初始化。当然了，父类的构造器子类也是不继承过来的，但构造器另当别论。

2. 类的初始化只执行一次，当对同一个类new多个对象时，类属性和类初始化块只初始化一次。

访问控制符

Java类具有三种访问控制符：private、protected和public，同时当不写这三个访问控制符时，表现为一种默认的访问控制状态。因此，一共具有四种访问控制级别。

具体访问控制表现如下：

• private修饰的属性或方法为该类所特有，在任何其他类中都不能直接访问；
• default修饰的属性或方法具有包访问特性，同一个包中的其他类可以访问；
• protected修饰的属性或方法在同一个中的其他类可以访问，同时对于不在同一个包中的子类中也可以访问；
• public修饰的属性或方法外部类中都可以直接访问。

当子类继承父类，子类可以继承父类中具有访问控制权限的属性和方法（一般来说是非private修饰的），对于private修饰的父类所特有的属性和方法，子类是不继承过来的。

当子类需要改变继承过来的方法时，也就是常说的重写父类的方法。一旦重写后，父类的此方法对子类来说表现为隐藏。以后子类的对象调用此方法时，都是调用子类重写后的方法，但子类对象中想调用父类原来的此方法时，可以通过如下两种方式：

1. 将子类对象类型强制转化为父类类型，进行调用；
2. 通过super调用。

同样的，如果在子类中定义父类中相同名称的属性时，父类属性在子类中表现为隐藏。

this和super

构造器中的this表示当前正在初始化的对象引用，方法中的this表示当前正在调用此方法的对象引用。this具体用法表现在一下几个方面：

1. 当具多个重载的构造器时，且一个构造器需要调用另外一个构造其，在其第一行使用this（param）形式调用，且只能在第一行；
2. 当对象中一个方法需要调用本对象中其他方法时，使用this作为主调，也可以不写，实际上默认就是this作为主调；
3. 当对象属性和方法中的局部变量名称相同时，在该方法中需要显式的使用this作为主调，以表示对象的属性，若不存在此问题，可以不显式的写this。

其实，其牵涉到的一个问题就是变量的查找规则：先局部变量 => 当前类中定义的变量 => 其父类中定义的可以被子类继承的变量 => 父类...

super表示调用父类中相应的属性和方法。在方法中，若需要调用父类的方法时，也一定要写在第一行

继承与组合

从单纯的实现效果上看，继承和组合都能达到同样的目的。并且都是实现代码复用的有效方式。但在一般性的概念层次中，两者具有较为明显的差别。

继承表现为一般——特殊的关系，子类是一个特殊的父类，是is-a的关系。父类具有所有子类的一般特性。

组合表现为整体——部分关系，即has-a关系。在组合中，通过将“部分”单独抽取出来，形成自己的类定义，并且在“整体”

这个类定义中，将部分定义为其中的一个属性，并通过get和set方法，以此可以调用“部分”类中的属性和方法。

对于若干个相同或者相识的类，我们可以抽象出他们共有的行为或者属相并将其定义成一个父类或者超类，然后用这些类继承该父类，他们不仅可以拥有父类的属性、方法还可以定义自己独有的属性或者方法。

在使用继承时需要记住三句话：

1. 子类拥有父类非private的属性和方法。
2. 子类可以拥有自己属性和方法，即子类可以对父类进行扩展。
3. 子类可以用自己的方式实现父类的方法。（以后介绍）。

综上所述，使用继承确实有许多的优点，除了将所有子类的共同属性放入父类，实现代码共享，避免重复外，还可以使得修改扩展继承而来的实现比较简单。

构造器

父类默认构造器

通过前面我们知道子类可以继承父类的属性和方法，除了那些private的外还有一样是子类继承不了的---构造器。对于构造器而言，它只能够被调用，而不能被继承。 调用父类的构造方法我们使用super()即可。

对于子类而已,其构造器的正确初始化是非常重要的,而且当且仅当只有一个方法可以保证这点：在构造器中调用父类构造器来完成初始化，而父类构造器具有执行父类初始化所需要的所有知识和能力。

    public class Person {
        protected String name;
        protected int age;
        protected String sex;
    
        Person() {
            System.out.println("Person Constrctor...");
        }
    }
    
    public class Husband extends Person {
        private Wife wife;
    
        Husband() {
            System.out.println("Husband Constructor...");
        }
    
        public static void main(String[] args) {
            Husband husband = new Husband();
        }
    }

运行结果如下：

    Person Constrctor...
    Husband Constructor...

通过这个示例可以看出，构建过程是从父类“向外”扩散的，也就是从父类开始向子类一级一级地完成构建。而且我们并没有显示的引用父类的构造器，这就是java的聪明之处：编译器会默认给子类调用父类的构造器。

指定父类构造器

但是，这个默认调用父类的构造器是有前提的：父类有默认构造器。如果父类没有默认构造器，我们就要必须显示的使用super()来调用父类构造器，否则编译器会报错：无法找到符合父类形式的构造器。

    
    public class Person {
        protected String name;
        protected int age;
        protected String sex;
    
        Person(String name) {
            System.out.println("Person Constrctor-----" + name);
        }
    }
    
    public class Husband extends Person {
        private Wife wife;
    
        Husband() {
            super("chenssy");
            System.out.println("Husband Constructor...");
        }
    
        public static void main(String[] args) {
            Husband husband = new Husband();
        }
    }

运行结果如下：

    
    Person Constrctor-----chenssy
    Husband Constructor...

分析：

对于继承而已，子类会默认调用父类的构造器，但是如果没有默认的父类构造器，子类必须要显示的指定父类的构造器，而且必须是在子类构造器中做的初始化父类构造器。

protected关键字

private访问修饰符，对于封装而言，是最好的选择，但这个只是基于理想的世界，有时候我们需要这样的需求：我们需要将某些事物尽可能地对这个世界隐藏，但是仍然允许子类的成员来访问它们。这个时候就需要使用到protected。

对于protected而言，它指明就类用户而言，他是private，但是对于任何继承与此类的子类而言或者其他任何位于同一个包的类而言，他却是可以访问的。

    public class Person {
        private String name;
        private int age;
        private String sex;
    
        protected String getName() {
            return name;
        }
    
        protected void setName(String name) {
            this.name = name;
        }
    
        public String toString() {
            return "this name is " + name;
        }
    
        /** 省略其他setter、getter方法 **/
    }
    
    public class Husband extends Person {
        private Wife wife;
    
        public String toString() {
            setName("chenssy");    //调用父类的setName();
            return super.toString();    //调用父类的toString()方法
        }
    
        public static void main(String[] args) {
            Husband husband = new Husband();
    
            System.out.println(husband.toString());
        }
    }

运行结果如下：

    this name is chenssy 

分析：

从上面实例来看子类Husband可以明显地调用父类Person的setName()函数。尽管可以使用protected访问修饰符来限制父类属性和方法的访问权限，但是最好的方式还是将属性保持为private，通过protected方法来控制类的继承者的访问权限。

向上转型

在上面的继承中我们谈到继承是is-a的相互关系，猫继承与动物，所以我们可以说猫是动物，或者说猫是动物的一种。这样将猫看做动物就是向上转型。如下：

    public class Person { 
        public void display(){ 
            System.out.println("Play Person..."); 
        }
        static void display(Person person){
            person.display(); 
        } 
    }
    
    public class Husband extends Person{
        public static void main(String[] args) { 
            Husband husband = new Husband();
            Person.display(husband); //向上转型
        } 
    }

通过Person.display(husband)。这句话可以看出husband是person类型。将子类转换成父类，在继承关系上面是向上移动的，所以一般称之为向上转型。由于向上转型是从一个叫专用类型向较通用类型转换，所以它总是安全的，唯一发生变化的可能就是属性和方法的丢失。这就是为什么编译器在“未曾明确表示转型”活“未曾指定特殊标记”的情况下，仍然允许向上转型的原因。

继承存在如下缺陷：

1. 父类变，子类就必须变；
2. 继承破坏了封装，对于父类而言，它的实现细节对与子类来说都是透明的；
3. 继承是一种强耦合关系。

当我们使用继承的时候，需要确信使用继承确实是有效可行的办法。

引用资料

• http://www.cnblogs.com/lwbqqyumidi/p/3509992.html
• http://www.cnblogs.com/chenssy/p/3354884.html