javaSE-面向对象-继承

继承的概述

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

l多个类可以称为子类，单独这个类称为父类或者超类。

l子类可以直接访问父类中的非私有的属性和行为。

l通过 extends关键字让类与类之间产生继承关系。

•classSubDemoextendsDemo{}

l继承的出现提高了代码的复用性。

l继承的出现让类与类之间产生了关系，提供了多态的前提。

继承的特点

lJava只支持单继承，不支持多继承，通过另一个方式体现。

•一个类只能有一个父类，不可以有多个父类。

•class SubDemo extends Demo{} //ok

•class SubDemo extendsDemo1,Demo2...//error

lJava支持多层继承(继承体系)

•class A{}

•class B extends A{}

•class C extends B{}

l定义继承需要注意：

•不要仅为了获取其他类中某个功能而去继承

•类与类之间要有所属( " is a ")关系，xx1是xx2的一种。

因为多继承容易出现问题。

两个父类中有相同的方法。子类到底要执行哪一个是不确定的。

所以java不支持多继承，但将这种机制换了另一个种安全的方式来体现，多实现。

多次继承出现的继承体系中，通常看父类中的功能，了解该体系的基本功能，建立子类对象即可使用该体系功能。

/*继承：好处：1，提高了代码的复用性。      2，让类与类之间产生了关系，为多态特征提供了前提。子类可以直接访问父类中的非私有的成员，间接访问私有成员通过方法的形式。Java中继承的特点：Java中只支持单继承。并不直接支持多继承。单继承：一个子类只能有一个父类。 多继承：一个子类可以有多个父类。不直接支持，对其进行改良。 class Fu1{void show(){sop("fu1 show run");}}class Fu2{void show(){sop("fu2 show run");}}class Zi extends Fu1,Fu2//多继承，不支持。{}main(){Zi z = new Zi();z.show();//调用的不确定性。}Java中还支持多层继承。class A{}class B extends A{}class C extends B{}继承层次多了，就形成了继承体系。体系就是不断向上抽取而来的。在使用一个体系的时候，先参阅最顶层类，了解体系的最基本功能。使用时，创建该体系最底层类的对象。看顶层，用底层。什么时候使用继承呢？当一个事物是另一个事物的一种时。当XXX是ZZZ中的一种，这时XXX继承ZZZ。比如猫时猫科中的一种。class Demo{void metho1(){}}class DemoA extends Demo{void method2(){}}class DemoB extends Demo//extends DemoA{void method3(){}}*/class Person{String name;int age;}class Student/*子类 subclasss*/ extends/*继承*/ Person/*supclass父类，超类，基类*/{//String name;//int age;void study(){System.out.println("name="+name+",age="+age);}}class Worker extends Person{//String name;//int age;void work(){}}class ExtendsDemo {public static void main(String[] args) {Student s = new Student();s.name="张三";s.age = 30;s.study();}}

继承中子父类成员的特点

super关键字

lsuper和this的用法相像

lthis代表本类对象的引用

lsuper代表父类的内存空间的标识。

l当子父类出现同名成员时，可以用super进行区分

l子类要调用父类构造函数时，可以使用super语句。

/*继承中子父类成员的特点：1，成员变量。2，成员函数。3，构造函数。super:代表的就是父类。super的用法和this很相似。用法 super.父类成员。  super(实际参数);this:代表的是本类型对象的引用。super：代表的是父类的内存空间。子父类中出现同名成员变量时用super区分出父类变量。但是这种情况很少出现。*///成员变量。class Fu{private int num = 4;public int getNum(){return this.num;}}class Zi extends Fu{private int num = 6;void show(){int num = 8;System.out.println("num="+this.num);System.out.println("num="+super.getNum());}}class ExtendsDemo2 {public static void main(String[] args) {Zi z = new Zi();z.show();}}

函数覆盖(Override)   

l子类中出现与父类一模一样的方法时，会出现覆盖操作，也称为重写或者复写。

l父类中的私有方法不可以被覆盖。

l在子类覆盖方法中，继续使用被覆盖的方法可以通过super.函数名获取。

l覆盖注意事项：

•覆盖时，子类方法权限一定要大于等于父类方法权限

•静态只能覆盖静态。

l覆盖的应用：

•当子类需要父类的功能，而功能主体子类有自己特有内容时，可以复写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容。

/*继承中成员函数的特点。当子父类中出现一模一样的函数时。出现了另一个函数特性：覆盖，复写，重写。overload(重载)：只关注本类中同名函数的参数列表。不关注返回值类型。override(覆盖)：子父类中一模一样的函数，才会覆盖。覆盖注意事项：1，子类覆盖父类方式，必须要保证子类方法权限大于等于父类方法权限。2，静态只能覆盖静态，或者被静态覆盖。*/class Fu{static void show(){System.out.println("fu show run");}}class Zi extends Fu{static void show(){System.out.println("zi show run");}}class ExtendsDemo3 {public static void main(String[] args) {//Zi z = new Zi();//z.show();//NewPhone p = new NewPhone();//p.show();Zi.show();}}/*覆盖的应用：*/class Phone{void call(){}void show(){System.out.println("number");}}class NewPhone extends Phone{/*保留父类功能声明，建立子类功能内容。这就是传说中的覆盖。 */void show(){System.out.println("name");super.show();}}

子类的实例化过程

子类中所有的构造函数默认都会访问父类中空参数的构造函数
因为每一个构造函数的第一行都有一条默认的语句super();
子类会具备父类中的数据，所以要先明确父类是如何对这些数据初始化的。
当父类中没有空参数的构造函数时，子类的构造函数必须通过this或者super语句指定要访问的构造函数。

/*子父类中构造函数的特点：子类的实例化过程：子类的所有构造函数中的第一行都有一条默认的隐式语句 super();super():用来调用父类中的空参数的构造函数。为什么子类中都要有默认super语句呢？因为子类对象中会存储父类中的属性数据，必须要子类对象初始化时，先执行父类的初始化动作，看看父类是如何对自己的属性数据进行初始化的。所以呢，子类的所有构造函数默认第一行(因为初始化动作要先执行，所以定义在第一行)都有一条默认的super()语句。 如果父类中没有定义空参数的构造函数，子类构造函数必须通过super语句或者this语句指定要访问的构造函数。*/class Fu extends Object{//int num=9;//Fu(){}Fu(int x){//super();System.out.println("fu .."+x);}}class Zi extends Fu{Zi(){super(5);//super();System.out.println("zi run");}Zi(int x){this();System.out.println("zi...."+x);}}class ExtendsDemo4 {public static void main(String[] args) {new Zi(5);}}class Demo{}