04_java基础_继承、抽象、多态

------- android培训、java培训、.net培训、IOS培训 期待与您交流！ -------

继承

继承的初衷是为了提高代码的复用，我们可以把不同对象所具有的共同属性提取出来封装到一个类中，作为其他类的父类。当某个类需要使用这些共性方法的时候，只需要从父类继承过来就可以了，不用再在新类中去书写。A继承B，B是父类，A是子类。继承的关键字是extends。

什么时候定义继承？
必须保证类与类之间有所属(is a)关系。 
比如，苹果是水果中一种。狗是犬科中一种。

在Java中继承的体现：
Java允许单继承。不直接支持多继承，将多继承进行其他方式的体现。
单继承：一个子类只能有一个父类。
多继承：一个子类可以有多个父类。

继承如何使用？

多继承：

<pre name="code" class="java">class Fu1{void show1(){}}class Fu2{void show2(){}}//多继承。class Zi extends Fu1,Fu2{}Zi z = new Zi();//子类继承了父类，子类就有了父类的方法。z.show1();z.show2();

多重继承：

class A{}class B extends A{}class C extends B{}

多重继承，形成了继承体系。
学习继承体系时，应该首先参阅顶层类中的内容。
了解这个体系的基本功能。

使用这个体系功能，需要创建最子类的对象。

看顶层，建底层。

Super和this：

子父类中定义了一模一样的成员变量。
都存在于子类对象中。
如何在子类中直接访问同名的父类中的变量呢？
通过关键字 super来完成。

super和this的用法很相似。
this：代表的是本类的对象的引用。
super：代表的是父类的内存空间。

但是，父类中私有的内容子类不可以直接访问。

class Fu{int num = 3;}class Zi extends Fu{int num = 4;void show(){System.out.println("zi num="+this.num);//4System.out.println("fu num="+super.num);//3}}class ExtendsDemo {public static void main(String[] args) {Zi z = new Zi();z.show();}}

如果子类中定义了和父类一样的函数，那么运行时，运行的是子类的函数。这种事继承关系中的另一个特性：覆盖或者叫重写或者叫复写。

复写什么情况下使用？

当父类的函数功能已经不能满足子类需要的时候，可以复写父类的函数。也就是对父类的函数进行升级。

复写的注意事项：

当复写父类方法时，子类实现的方法权限必须大于等于父类该方法的权限。

写法上必须要一模一样，比如函数的返回类型，函数名，参数列表都要一样，才能达到复写的效果。

子父类中构造函数的特点：

如果父类中有空参的构造函数，那么子类中所有的构造函数中，第一行都有一个隐式的super（）。原因是，子类继承父类是要使用父类中的内容的，而只有将父类初始化才能更方便的使用父类中的内容。

如果父类中没有空参的构造函数，那么子类的构造函数中必须显式地使用super（加参数）来指定使用父类的哪个构造函数来初始化父类。

如果子类构造函数中第一行用this调用了本类的一个构造函数，那么原来隐式的super（）就没有了，原因是this（）或者super（）只能定义在构造函数的第一行。

父类构造函数的第一行是不是也是隐式的super？

是的，只要是构造函数，第一行默认的都是super（）。Java中Object是所有的类的父类。

抽象

抽象类：在描述事物时，没有足够的信息描述一个事物，这时该事物就是抽象事物。

描述狗,行为：吼叫。
描述狼，行为：吼叫。
发现他们之间有共性，可以进行向上抽取。
当然是抽取它们的所属共性类型：犬科。
犬科这类事物：都具备吼叫行为,但是具体怎么叫，是不确定的，是由具体的子类来明确的。
这时在描述犬科时，发现了有些功能不具体，这些不具体的功能，需要在类中标识出来，通过java中的关键字abstract(抽象)。
定义了抽象函数的类也必须被abstract关键字修饰，被abstract关键字修饰的类是抽象类。

抽象类和抽象方法都要用abstract修饰。

抽象类不能创建实例，因为抽象类没有实际意义。

子类只有在复写了父类的抽象方法后，子类才可以实例化对象，否则子类还是抽象类。

抽象类一定是父类，因为抽象类某些类的共性组成的，而这些共性来自于子类。

抽象类也有构造函数，但是不能给自己初始化，只能给自己的子类初始化。

抽象类和普通类之间的比较：

相同之处：

都是用来描述事物的。

都可以定义属性和方法。

不同之处：

一般类描述的事物是具体的，抽象类描述的事物是不具体的。

抽象类可以多定义一种成员：抽象函数。

一般类可以实例化对象，抽象类不能实例化对象。

抽象类也可以不定义抽象方法，而此时将该类定义为抽象类的目的是为了不让该类初始化。

不能和abstract共同存在的关键字：final，private，static。

接口

抽象类中可以定义抽象方法，当一个抽象类中的方法全是抽象的时候，这个抽象类就可以用接口来体现。

定义接口的关键字：interface。

实现接口的关键字：implements

接口中的变量修饰符固定：public static final

接口中的方法修饰符固定：public abstract

接口的特点：

接口和抽象类一样，不能创建对象。因为接口和抽象方法一样，没有实际意义。

子类必须复写接口中所有的方法之后，该子类才可以实例化。不然子类就是一个抽象类。

定义一个接口：

interface Demo//定义一个名称为Demo的接口。{public static final int NUM = 3;public abstract void show1();public abstract void show2();}

实现接口的类必须复写掉接口中所有的方法：

class DemoImpl implements Demo//子类实现Demo接口。{//重写接口中的方法。public void show1(){}public void show2(){}}

接口重要性的体现：

接口的出现可以用多实现代替多继承，解决多继承的弊端。

其实核心原因就是在于多继承父类中方法有主体，而导致调用运行时，不确定运行哪个主体内容。
为什么多实现就解决了呢？
因为接口中的功能都没有方法体，由子类来明确。

多继承的弊端：

当一个类继承了多个父类之后，如果多个父类中定义了名字相同的实例变量，那么子类在调用该实例变量的时候将产生歧义，无法确定要使用哪一个父类的变量。

当一个类继承了多个父类之后，如果多个父类中定义了相同的方法，而子类中有没有对其进行复写，那么在子类调用该方法的时候同样会产生歧义。

多实现演示：

interface A{void show1();}interface B{void show2();}class C implements A,B// 多实现。同时实现多个接口。{public void show1(){}public void show2(){}}

写到这里，我想到如果某个子类实现了两个接口，而两个接口中又定义了相同的变量，那么多实现是不是也有多继承的弊端呢？

于是我写了如下测试代码：

interface A {public static final int a = 1;}interface B {//public static final int a = 1;}class C implements A,B{public C(){System.out.println(a);}}

如果上面代码中接口B中哪一行代码不注释掉的话，Eclipse是报错的。还有要注意的就是，抽象类中定义变量是不一定要用到static final关键字的，而接口中只要定义变量，必然使用这两个修饰符。

定义一个类的时候，既可以继承，又可以实现。

class Fu{public void show(){}}interface Inter{pulbic void show1();}class Zi extends Fu implements Inter{public void show1(){}}

子类通过继承父类来获取子类的基本功能，如果子类还需要扩展其他的功能，就可以通过接口来实现。

类与类之间是继承(is a)关系，类与接口之间是实现(like a)关系，接口与接口之间是继承关系，而且可以多继承。

interface InterA{void show1();}interface InterAA{void show11();}interface InterB extends InterA,InterAA//接口的多继承。{void show2();}class Test implements InterB{public void show1(){}public void show2(){}public void show11(){}}class InterfaceDemo {public static void main(String[] args) {DemoImpl d = new DemoImpl();d.show1();d.show2();}}

接口的实现问题：

interface Inter{//定义四种显示功能。public void show1();public void show2();public void show3();public void show4();}//定义子类，要使用第一种显示方式。class InterImpl1 implements Inter{//覆盖show1方法。public void show1(){System.out.println("show1 run");}//为了让该类实例化。还需要覆盖其他三个方法，虽然该类用不上。public void show2(){}public void show3(){}public void show4(){}}//另一个子类需要使用显示3方法。class InterImpl3 implements Inter{//覆盖show3方法。public void show3(){System.out.println("show3 run");}//为了让该类实例化。还需要覆盖其他三个方法，虽然该类用不上。public void show2(){}public void show1(){}public void show4(){}}

但是：

为了使用接口中的部分方法。而覆盖了全部的方法，而且每一个子类都要这么做，复用性差。

将这些不用的方法都单独抽取到一个独立的类中。
让这个类去实现接口，并覆盖接口中的所有方法。

这个类知道这些方法的具体实现内容吗？不知道。
所以只能为了后期子类创建对象方便，而进行空实现。
而这时，这个类创建对象有意义吗？没有意义。这个类创建对象就不需要，直接将其抽象化。
这就是没有抽象方法的抽象类。

这样就可以在使用其中某一个方法的时候不实现其他无关的方法。

效果如下：

abstract class InterImpl implements Inter{//实现Inter接口中的所有方法。public void show1(){}public void show2(){}public void show3(){}public void show4(){}}//如果有子类去使用显示1方法。让子类继承InterImpl实现类就可以了。class InterImpl11 extends InterImpl{public void show1(){System.out.println("show1 run");}}class InterImpl33 extends InterImpl{public void show3(){System.out.println("show3 run");}}

多态

多态的体现：

父类的引用或者接口的引用指向了自己的子类对象。
Dog d = new Dog();//Dog对象的类型是Dog类型。
Animal a = new Dog();//Dog对象的类型右边是Dog类型，左边Animal类型。

多态是如何提高程序的可扩展性的：

这样的好处是，程序的已知流程在没有派生类的时候就可以写好，以后要有新的功能，只要再写个派生类就可以了。举个例子，在电脑上显示图片，基本上要有读文件，解析文件，显示图形三个步骤，这些步骤可以写在基类中，然后具体的如何读文件，如何解析文件，如何显示，就交给派生类去做。

多态的弊端：

通过父类引用操作子类对象时，只能使用父类中已有的方法，不能操作子类特有的方法。

多态的前提：

1，必须有关系：继承，实现。
2，通常都有重写操作。

那么使用多态创建的对象如何调用子类的方法：

对该对象进行向下转型

Animal a = new Dog();//这一步骤也叫向上转型。

这里Animal是Dog的父类。

向下转型方法：

强制类型转换

Dog d = (Dog)a

但是向下转型是要注意，类型转换是否正确，比如上面的a对象，如果对其进行向下转型应该转成Dog类型，如果进行如下转换就会出ClassCastException异常。

所以为了避免这个问题，需要在向下转型前，做类型的判断。
判断类型用的是关键字 instanceof

if(a instanceof Cat)//a指向的对象的类型是Cat类型。{//将a转型Cat类型。Cat c = (Cat)a;}else if(a instanceof Dog){Dog d = (Dog)a;}

多态中，成员调用的特点。

1，成员变量。
当子父类中出现同名的成员变量时。
多态调用该变量时：
编译时期：参考的是引用型变量所属的类中是否有被调用的成员变量。没有，编译失败。
运行时期：也是调用引用型变量所属的类中的成员变量。
简单记：编译和运行都参考等号的左边。
编译运行看左边。

2，成员函数。
编译，参考左边，如果没有，编译失败。
运行，参考右边的对象所属的类。
编译看左边，运行看右边。

对于成员函数是动态绑定到对象上。

3，静态函数。
编译和运行都参考左边。
静态函数是静态的绑定到类上。

（这些都是可以理解的，没必要死记硬背）

------- android培训、java培训、.net培训、 IOS培训 期待与您交流！ -------