黑马程序员——继承、抽象、多态、异常

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

继承：

1、继承提高了代码的复用性，扩展性。2、让类与类之间产生了关系，有了这个才有多态的特性。3、Java语言中只支持单继承，但是支持多层继承。创建子类对象使用功能时，如果子类访问出现非私有成员变量时，子类要访问本类的需要用 this，子类要访问父类的 使用 super。

public class OO3 {public static void main(String[] args){new Zi().printAge();}}class Zi extends Fu{int age = 4;public void printAge(){System.out.println(this.age);System.out.println(super.age);}}class Fu{int age = 3;}

继承的特性：重写（保存父类的原有功能 ，让子类定义一个同父类方法名（参数列表）一致的方法，易扩展）。如果子类觉得父类的方法不能够满足我的需求，可以创建一个 同名同参 函数，使用子类对象调用子类方法时，就是调用子类覆写后的方法。

public class OO5{public static void main(String[] args) {new Zi4().print();}}class Zi4 extends Fu4{public void print(){System.out.println("我覆写了父类的方法");}}class Fu4{public void print(){System.out.println("我是父类的特有方法");}}

子类中构造函数：在对子类进行初始化时，父类的构造函数也会运行，那是因为子类的构造函数第一行默认有一条隐藏的super()；

为什么子类一定要访问父类的构造函数呢？因为父类中的数据子类可以直接获取，所以子类在初始化的时候，需要先看父类是如何对这些数据进行初始化的。

总结：子类所有的构造函数，默认都会访问父类中的空参构造函数。我们也可以手动设置super。（子类实例化过程）：下面程序会给你答案的。

abstract（抽象），抽象方法一定要在抽象类中，但是抽象类里面不一定需要有抽象方法。

特点：①抽象方法一定在抽象类中

特点：②抽象方法和类 都需要被 sbstract 修饰

特点：③抽象类 不能用 new 创建对象

特点：④抽象类必须由子类覆写。（父类属于抽象类，就算没有抽线方法也需要子类去继承）

注意：由于继承的覆写特性，如果父类的某一些方法不想让子类覆写的话，可以添加关键字 final。

如果变量被修饰以后，那该变量就是常量。

使用抽象方法：完成一段程序运行的时间，使用模版技术完成。当出现不确定部分，又无法定义主题，就可以使用抽象方法。

/**使用抽象方法：完成一段程序运行的时间，使用模版技术完成。  * */public class getRuntime{public static void main(String[] args) {new OrderRunTime().runTime();//创建子类对象，由于是继承关系，子类完全可以使用父类的所以的方法。}}/**子类继承了父类，需要覆写掉里面的抽象方法。 * */class OrderRunTime extends Runtime{public void order(){for(int i=1; i<1000; i++){System.out.println("当前数字" + i);}}}/**创建一个模版模版程序， * 程序开始时间    和  程序结束相减就是程序运行时间 * 但是具体需要运行的程序，我并不知道是什么，所以我就将该段程序设置为抽象的。 * 必须让子类来覆写。  * */abstract class Runtime{public void runTime(){long start = System.currentTimeMillis();order();long end = System.currentTimeMillis();System.out.println("该程序共耗时：" + (end - start) + "毫秒");}abstract public void order();}

接口：初期我们可以将接口简单的理解为一个特殊的抽象类。抽象类里面可以有自己具体的方法，而接口呢，里面则全部都是抽象方法。

接口里面的：常量：public static final（可以不写，因为Java会自动添加，书写是为了方便阅读）方法：public  abstract（同前面一样）

定义类使用 class ！定义接口使用　interface　！

类与类之间 属于 继承关系(extends) ，而 接口 与  类 之间 属于 实现关系(implements)，但 接口 与 接口之间 属于  继承关系(extends)。

特点①：接口是对外暴露的规则

特点②：接口是程序的功能

特点③：接口可以用来多实现（Java只支持单继承的缺陷，使用接口可以弥补一下这个缺点儿）

特点④：接口 与  类 之间 属于 实现关系(implements)，但 接口 与 接口之间 属于  继承关系(extends)。

接口简单理解，就是一个扩展功能，基本功能定义在类中，扩展功能定义在接口中。

多态：事物的多种表现形态。

多态的表现：父类的引用指向了子类。    Fu zi  = new Zi();

多态的前提：

①必须子类与子类具有关系 

②存在覆写方法

多态的好处和弊端：

①大大的提高了程序扩展性。 

②多态的弊端：提高了扩展性，但是只能使用父类的引用，访问父类中的成员。

对同一类型进行抽取出大类型，从而操作抽取出的大类型，控制整个类型。

多态成员函数特点：在编译时期，参阅引用型变量所属类中是否有调用方法；如果有则编译通过，如果没有则编译失败。在运行时期：参阅对象的类中是否有调用方法。

总结多态成员函数：编译看左边，运行看右边。

多态成员变量和静态成员特点：无论编译还是运行，都是看左边。

（所以，在多态中方法存在覆写，而属性和静态成员是没有办法覆写的）

分析 电脑，USB设备，USB接口　之间的关系。并写出具体的关系代码：

//定义一个规则，如果要给电脑添加功能就必须满足这2个要求interface USB{public void insert();public void extract();}//将USB集成到电脑，如果以后有USB设备的话，就可以在电脑上面直接使用class Computer{public void run(){System.out.println("电脑运行起来了");}public void userUSB(USB usb)//控制USB一个接口大类型，就控制了所有的USB设备，启动USB设备{if(usb!=null){usb.insert();}}public void closeUsb(USB usb)//关闭USB设备{usb.extract();}public void close(){System.out.println("电脑关机了");}}class Fan implements USB//必须要有 开启和关闭功能{public void insert(){System.out.println("USB风扇转起来！");}public void extract(){System.out.println("USB风扇不转了");}}class Mouse implements USB//必须要有 开启和关闭功能{public void insert(){System.out.println("USB鼠标可以使用了");}public void extract(){System.out.println("USB鼠标不能使用了");}}public class OO6{public static void main(String[] args){Computer cpt = new Computer();Fan fan = new Fan();Mouse mouse = new Mouse();cpt.run();cpt.userUSB(fan);cpt.userUSB(mouse);cpt.closeUsb(fan);cpt.closeUsb(mouse);cpt.close();}}

异常：程序运行时出现的不正常。

Error致命性错误：这种错误Java进行了描述，一般不对Error 异常做针对性的写代码

Exception一般性错误：这种错误Exception Java也进行了描述， 可以对其写针对性处理异常的代码。

RuntimeException：不需要声明就可直接抛出（停止程序）

异常体系特点：

①异常体系的类和对象都具有可抛性

②这是Throwable独有的。

异常处理方式：

try

{

可能会有异常的代码

}

catch(异常类  变量)

{

出现异常后，处理异常的代码

}

finally

{

一定会执行的代码

}

只有一种情况finally不会被执行，也就是在之前已经 运行了 System.exit(0)

对多异常处理：

1、声明异常时，建议声明更为具体的异常，这样更为具体。

2、对方声明几个异常，就对应几个catch块

3、如果多个catch块中有继承关系，父类应该在最下面

建议：在所对应的catch代码块中，不能简单的只写输出语句。

自定义异常：自定义类直接继承Exception就拥有了异常功能。

当在函数内部使用  （throw 异常类） 抛出异常时，需要在函数上声明 该异常  （throws  异常类），如果继承的是 RuntimeException 就不需要在函数上声明异常。

throw　和　　throws 的区别：

thorw：使用在函数内，后面跟的是一个异常对象

throws：使用在函数上，后面跟的是一个或多个异常类

异常在子父类覆盖的体现：

①子类在覆盖父类时，父类抛出异常，子类覆盖方法只能抛父类异常或父类异常的子异常。

②父类抛多个异常，那么子类覆盖该方法时，只能抛父类异常子集

③父类和接口没有抛异常，子类也不能抛异常（如果子类发生异常时，必须使用 try 进行处理）

总结：父类抛异常子类就可以父类异常或者父类异常的子异常，父类没有抛异常，子类必须自己 try 处理解决异常。

异常的好处：

①、将问题进行封装。

②、将正常流程代码和处理代码相分离，方便阅读

异常的处理原则：

①处理的2种方式，要么try 要么 throws

②调用到抛出异常的功能时，抛出几个异常就对应几个 catch  语句。

③注意：当处理多个异常时，父类异常必须放最下面。

④catch 内部必须定义具体的解决代码，不能简单的写输出语句。

在程序运行时，难免会出现一个异常错误。例如，下面的数组角标越界，发生这种情况以后，系统给出的提示用户不一定看得懂，所以这里就进行处理。

添加异常处理代码：