Java三大特征之继承

作为Java三大特征之一的继承也是很好理解的。

现实世界中的继承无处不在。比如：

动物：哺乳动物、爬行动物

哺乳动物：灵长目、鲸目等。

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。

为什么需要继承？继承的作用？

　　第一好处：继承的本质在于抽象。类是对对象的抽象，继承是对某一批类的抽象。

　　第二好处：为了提高代码的复用性。

在Java中使用继承主要是使用extends关键词：

　　extands的意思是“扩展”。子类是父类的扩展。

【注】JAVA中类只有单继承，没有多继承！ 接口可以多继承！

1、继承

　　1. 继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。

　　2. 继承关系的俩个类，一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示。

            1
            public
            class student extends Person{
2 }

　　3. 子类和父类之间,从意义上讲应该具有"is a"的关系.

            1
            student is a person

            2 dog is a animal

　　4. 类和类之间的继承是单继承

　　　　一个子类只能"直接"继承一个父类,就像是一个人只能有一个亲生父亲

　　　　一个父类可以被多子类继承,就像一个父亲可以有多个孩子

　　　　　　注:java中接口和接口之间,有可以继承,并且是多继承。

　　5. 父类中的属性和方法可以被子类继承

子类中继承了父类中的属性和方法后,在子类中能不能直接使用这些属性和方法,是和这些属性和方法原有的修饰符(public protected default private)相关的。

例如 : 父类中的属性和方法使用public修饰,在子类中继承后"可以直接"使用 父类中的属性和方法使用private修饰,在子类中继承后"不可以直接"使用

注：具体细则在修饰符部分详细说明

父类中的构造器是不能被子类继承的,但是子类的构造器中,会隐式的调用父类中的无参构造器(默认使用 super关键字)。

注:具体细节在super关键字部分详细说明

2、Object类

java中的每一个类都是"直接" 或者 "间接"的继承了Object类.

所以每一个对象都和Object类有"is a"的关系。

从API文档中,可以看到任何一个类最上层的父类都是Object。

(Object类本身除外)AnyClass is a Object。

 在Object类中,提供了一些方法被子类继承,那么就意味着,在java中,任何一个对象都可以调用这些被继承 过来的方法。(因为Object是所以类的父类)

例如:toString方法、equals方法、getClass方法等

注:Object类中的每一个方法之后都会使用到.

3、Super关键字

子类继承父类之后,在子类中可以使用this来表示访问或调用子类中的属性或方法,使用super就表示访问 或调用父类中的属性和方法。

　　1.super的使用

【访问父类中的属性】

             1
            public
            class
             Person{

             2
            protected String name = "zs";
 3}
 4publicclass Student extends Person{
 5private String name = "lisi";
 6publicvoid tes(String name)t{
 7        System.out.println(name);
 8         System.out.println(this.name);
 9         System.out.println(super.name);
10    }
11 }

【调用父类中的方法】

             1
            public
            class
             Person{

             2
            public
            void
             print(){

             3         System.out.println("Person");
 4    }
 5}
 6publicclass Student extends Person{
 7publicvoid print(){
 8         System.out.println("Student");
 9    }
10publicvoid test(){
11        print();
12this.print();
13super.print();
14    }
15 }

【调用父类中的构造器】

            1
            public
            class
             Person{

            2
            }

            3
            public
            class Student extends Person{
4//编译通过,子类构造器中会隐式的调用父类的无参构造器
5//super();6public Student(){
7    }
8 }

父类没有无参构造

             1
            public
            class
             Person{

             2
            protected
             String name;

             3
            public
             Person(String name){

             4
            this.name = name;
 5    }
 6}
 7publicclass Student extends Person{
 8//编译报错,子类构造器中会隐式的调用父类的无参构造器,但是父类中没有无参构造器
 9//super();10public Student(){
11    }
12 }

【显式的调用父类的有参构造器】

             1
            public
            class
             Person{

             2
            protected
             String name;

             3
            public
             Person(String name){

             4
            this.name = name;
 5    }
 6}
 7publicclass Student extends Person{
 8//编译通过,子类构造器中显式的调用父类的有参构造器 9public Student(){
10super("tom");
11    }
12 }

注：不管是显式还是隐式的父类的构造器,super语句一定要出现在子类构造器中第一行代码。所以this和 super不可能同时使用它们调用构造器的功能,因为它们都要出现在第一行代码位置。

【super使用的注意的地方】

　　1. 用super调用父类构造方法，必须是构造方法中的第一个语句。

　　2. super只能出现在子类的方法或者构造方法中。

　　3. super 和 this 不能够同时调用构造方法。（因为this也是在构造方法的第一个语句）

4、方法重写：

方法的重写（override）

　　1. 方法重写只存在于子类和父类(包括直接父类和间接父类)之间。在同一个类中方法只能被重载，不能被重写.

　　2. 静态方法不能重写

　　　　1. 父类的静态方法不能被子类重写为非静态方法 //编译出错

　　　　2. 父类的非静态方法不能被子类重写为静态方法；//编译出错

　　　　3. 子类可以定义与父类的静态方法同名的静态方法(但是这个不是覆盖)

私有方法不能被子类重写，子类继承父类后,是不能直接访问父类中的私有方法的,那么就更谈不上重写了。

注：一般情况下,重写的方法会和父类中的方法的声明完全保持一致,只有方法的实现不同。(也就是大括 号中代码不一样)

为什么要重写？

　　子类继承父类,继承了父类中的方法,但是父类中的方法并不一定能满足子类中的功能需要,所以子类中需 要把方法进行重写。

 总结：

　　方法重写的时候，必须存在继承关系。

　　方法重写的时候，方法名和形式参数 必须跟父类是一致的。

　　方法重写的时候，子类的权限修饰符必须要大于或者等于父类的权限修饰符。( private < protected < public，friendly < public )

　　方法重写的时候，子类的返回值类型必须小于或者等于父类的返回值类型。( 子类 < 父类 ) 数据类型没有 明确的上下级关系

　　方法重写的时候，子类的异常类型要小于或者等于父类的异常类型。

原文：https://www.cnblogs.com/koss/p/14470264.html