Java继承是面向对象的最显著的一个特征。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力

在多个类中存在相同属性和行为时，将这些内容单独抽取到一个类中，那么多个类就不需再次定义这些类和属性，只要继承那个类就行了

在继承的关系里，被继承的类称为父类、超类或者基类，而继承的类就被称为子类。子类继承了父类的所有属性（包括private成员，并不可访问）和方法，通过继承可以对对象描述更加清晰，提高代码的复用性。不仅如此，子类还可以根据自己的独特性，扩展属性和方法。

如何实现

通过 extends 关键字让类与类之间产生继承关系。语法：public calss 子类名 extends 父类名{}

1
public calss Cat extends Animal{}

例:
创建一个Animal(动物)类

1
2
3
4
5
6
7
8
9
10
public class Animal {

    public void fun1(){
        System.out.println("Animal fun1 ... ");
    }
    
    public void fun2(){
        System.out.println("Animal fun2 ... ");
    }
}

创建一个Cat(猫)类，然后让Cat类继承自Animal

1
2
3
public class Cat extends Animal {

}

这样就实现了继承，Cat就是Animal的子类

就这样实现了一个继承貌似也没有什么特别的意义，继承的意义在于让子类和父类可以产生差异，我们来详细的看看怎样让子类和父类产生差异的，主要有两种方法

第一种方法，直接在子类加方法

直接在子类中添加新的方法和成员变量。这意味着父类的成员变量或方法不能满足子类的需要，因此需要添加新的来满足子类的需求，以上面的Cat为例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class Cat extends Animal {
	
    //新增方法
    public void skill(){
        System.out.println("猫会抓鱼");
    }
    
    public static void main(String[] args) {
        Cat c = new Cat();
        c.fun1();
        c.skill();
    }
}

打印结果：
Animal fun1 ... 
猫会抓鱼

上例方法中猫的技能在Animal类中没有方法能满足，所以添加了一个新的方法满足了需求，既能调用父类的方法，有能调用自己特有的扩展方法

第二种方法，覆盖(overriding)父类的方法，还可以被叫做重写

overriding的作用不是要添加父类没有的方法，而是覆盖父类的方法，（前提是父类方法访问权限不是private，且子类方法权限大于等于父类方法），这里会涉及到几个访问权限修饰符的知识点，不懂可以特别研究下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class Cat extends Animal {
	
    /**
     * 子类重写父类的方法
     */
    @Override
    public void fun2() {
        System.out.println("Cat fun2 ... ");
    }
    
    public static void main(String[] args) {
        Cat c = new Cat();
        c.fun1();
        c.fun2();
    }
}

打印结果：
Animal fun1 ... 
Cat fun2 ...

这里对上述代码有两个点需要进行一下描述：
1、大家也看见了fun2()方法上有一个@Override，@Override表示下面出现的方法会出现重写操作，由编译器检查，如果达不到重写的条件，就会报错。一定程度上增加了代码的安全性和健壮性，可有可无，为了可读性高，留下更好
2、覆盖的方法必须与父类定义完全相同，注意这里是方法名和返回值及参数都要相等，拿参数来说，如果参数变了，那么这就不能叫覆盖（重写）了，而是“重载”，这里不深入重载的研究了，不过重写的方法修饰符是可以改变的，不过还是得遵循（子类方法权限大于等于父类方法）定律

好，回到上面的例子，这里打印的是Animal fun1 ...和Cat fun2 ...，说明fun1()由于继承的关系执行的是父类的方法，如果Cat里面没有fun2()方法的话肯定也会执行父类里面的fun2()方法，但这里由于子类（Cat）覆盖了父类的fun2()方法，所以执行到了Cat.fun2();最终打印Cat fun2 ...，这就表明overriding成功了

继承后的子类运行顺序

子类构造器中的this的调用 → 父类成员变量初始化 → 父类构造方法 → 子类变量初始化 → 子类构造方法
究其原因，是子类因为继承特性，所以拥有了父类的数据，也就是成员变量，而子类在写这些数据时，必须先知道父类的如何定义或者初始化的 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class Animal {
	
    public Animal(){
        System.out.println("这是动物类");
    }
}

public class Cat extends Animal {

    public Cat(){
        System.out.println("这是猫类");
    }
    
    public static void main(String[] args) {
        Cat c = new Cat();
    }
}

打印结果：
这是动物类
这是猫类

可见就算是没有构造方法，创建了Cat对象后，也是先调用的父类方法，后调用子类方法

总结：
1、子类重写父类的方法，必须同父类方法相同
2、子类重写父类的方法，子类方法权限需大于等于父类方法
3、子类继承父类后调用的运行顺序依次是：父类成员变量初始化 → 父类构造方法 → 子类变量初始化 → 子类构造方法