1. 继承的概念：

　　继承在本职上是特殊——一般的关系。子类继承父类，表明子类是一种特殊的父类，并且具有父类所不具有的一些属性或方法。

2. 继承中的初始化顺序：

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

　　类初始化：

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

　　对象初始化：

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

注意：

　　1. 在对象初始化阶段，属性和方法均针对子类可以从父类继承过来的属性和方法而言，一般而言，都是针对父类中非private而言的。

因为private修饰的为父类所特有的，子类没有继承过来，当new子类时，无须为其分配空间并执行初始化。当然了，父类的构造器子类也是不继承过来的，

但构造器另当别论。

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

3.继承中的修饰符以及属性隐藏

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

具体访问控制表现如下：

　　private修饰的属性或方法为该类所特有，在任何其他类中都不能直接访问；

　　默认不写，这类修饰的属性或方法具有包访问特性，同一个包中的其他类可以访问；

　　protected修饰的属性或方法在同一个中的其他类可以访问，同时对于不在同一个包中的子类中也可以访问；

　　public修饰的属性或方法外部类中都可以直接访问。

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

　　当子类需要改变继承过来的方法时，也就是常说的重写父类的方法。一旦重写后，父类的此方法对子类来说表现为隐藏。以后子类的对象调用此方法时，都是调用子类重写后

的方法，但子类对象中想调用父类原来的此方法时，可以通过如下两种方式：

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

　　2.通过super调用。

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

4.继承中的this和super：

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

　　1.当具多个重载的构造器时，且一个构造器需要调用另外一个构造其，在其第一行使用this（param）形式调用，且只能在第一行；

　　2.当对象中一个方法需要调用本对象中其他方法时，使用this作为主调，也可以不写，实际上默认就是this作为主调；

　　3.当对象属性和方法中的局部变量名称相同时，在该方法中需要显式的使用this作为主调，以表示对象的属性，若不存在此问题，可以不显式的写this。

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

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

 总例：

package com.wen1227;

public class Niao {
    private String name;
    private int age;
    
    public Niao(String name){
        this.name=name;
    }
    public Niao(String name,int age){
        this.name=name;
        this.age=age;
    }
    public String getName(){
        return name;
    }
    public void  setName(String name){
         this.name=name;
    }
    public int getAge(){
        return age;
    }
    public void setAge(int age){
        this.age=age;
    }
    
    
    public void Zou(){
        System.out.println(name+"正在走路");
    }
}

　　创建一个Niao的类给他定义一个name和age的属性写为private私有的。

　　然后这里定义了两个构造函数进行重载，一个有一个参数，一个有两个参数。

　　因为上面定义的属性name和age都是私有的（private），所以后面子类继承的时候无法继承到这些属性，那么就需要在父类中定义一个方法来获取name和age再定义一个方法来改变name和age的内容。

　　最后再定义一个Zou的方法让他输出一个内容。

package com.wen1227;

public class XiQue extends Niao {
    public XiQue(String name){
        super(name);
    }
    public XiQue(String name,int age){
        super(name,age);
    }
    
    public void Zou(){
        super.Zou();
        System.out.println(this.getName()+"feifeifeifeifei"+this.getAge());
    }
}

　　这里定义了一个XiQue作为子类继承了父类Niao的属性， 这里同样也写了两个构造函数来进行重载，但是子类XiQie里面没有name和age的内容，只能调用父类的，所以这里定义的构造函数例就用到了super属性。

　　同样在子类XiQue里面有一个方法Zou，然后写一个super调用父类的Zou属性（从结果上你就会一目了然），只是对Zou的属性进行了修改，这叫重写。

package com.wen1227;

public class Test {

    public static void main(String[] args) {
        XiQue x =new XiQue("张三",3);
        x.Zou();
        Niao n =new Niao("lisi");
        n.Zou();
    }

}

　　最后采用一个main函数调用，先new一个XiQue，让其进行XiQue的Zou，然后new一个Niao，让其进行Niao的Zou，最后输出的结果为

张三正在走路
张三feifeifeifeifei3
lisi正在走路

　　因为先调用了XiQue的，他里面先调用了super.Zou();所以先输出父类的，然后再执行XiQue的System.out.println(this.getName()+"feifeifeifeifei"+this.getAge());最后再执行父类的Zou。 所以是三行，一目了然。

5. 继承与组合：

　　从单纯的实现效果上看，继承和组合都能达到同样的目的。并且都是实现代码复用的有效方式。

　　但在一般性的概念层次中，两者具有较为明显的差别。

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

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

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

Java,extends,继承