黑马程序员-Java基础-面向对象—多态、Object类、内部类、异常

第一讲  多态

一、  定义

能够理解为事物存在的多种体现形态。

在java中，当函数的功能内容不肯定时，能够将此方法定义为抽象方法，让其子类去实现。当子类对象不一样时，调用同一个函数名，会执行不一样的函数体，获得不一样的结果，从而体现了多态性。

二、  多态的体现形式

• 父类的引用指向了本身的子类对象：Fu f = new Zi()；
• 父类的引用也能够接受本身的子类对象；

                      

三、  多态的前提条件

• 必须是类与类之间有关系，要么继承，要么实现（接口）；
• 函数之间存在覆盖（重写）；

四、  多态的好处

大大的提升了程序的扩展性。——当子类对象增长时，尽量的少该代码。

五、  多态缺陷

　　提升了扩展性，但只能使用父类的引用访问父类中的成员。父类的引用不能访问子类中的成员。

　　以下，父类的引用an1访问了子类特有方法kanjia()；

　　

六、  子父类类型转换

　　Fu f = new Zi();————类型自动提高，向上转型，将子类型转成父类型。

　　Zi z = (Cat) f ; ————强制将父类的引用转成子类类型，向下转型。

　　注意：不能将父类型对象转成子类型。

七、  多态的应用

创建两个类：基础班学生 和 高级班学生，都有学习、睡觉功能。要求将这两类事物进行抽取。

八、  多态的出现，代码中的特色——多态使用的注意事项

　　1）  多态中非静态成员函数的特色

　　　　编译时期：参阅引用类型变量所属的类中是否有调用的方法，如有，编译经过，不然编译失败。由于：编译时，对象还没被建立，父　　　　　　类和子类尚未创建关系。

　　　　运行时期：参阅对象所属的类中是否有调用的方法，如有，则执行对象所属类中的功能，不然，执行父类中的功能。

　　　　总结：成员函数在多态调用时，编译看左边（引用类型），运行看右边（对象所属的类）。

　　2）  多态中成员变量的特色

　　　　不管编译仍是运行，都参考左边（引用型变量所属的类。若是引用型变量所属的类中没有此成员变量，则编译失败。运行时，也会调用引用型变量所属类中的变量。

　　　　在多态中访问子类变量方法：当须要访问子类中的成员变量时，能够用强制类型转换，将父类型的引用强制转换成子类型：zi x = (zi)y，其中y表明指向子类型的父类型的应用变量

　　3）  多态中，静态成员函数的特色

　　　　不管编译仍是运行，都参考左边（引用型变量所属的类）。

　　　　缘由：非静态方法和静态在内存中存储的位置不一样，非静态方法区中有两个引用（this和super），而静态方法区中只有类名引用.

 

第二讲  Object类

一、  概念

　　Object是全部对象的直接或间接父类。该类中定义的确定是多有对象都具有的功能。

二、  Object类应用

　　Object类中已经提供了对对象是否相同的比较方法equals()，若是自定义类中也有比较相同的功能，没有必要从新定义，只要沿袭父类中的功能，创建本身特有的比较内容便可——这就是覆盖。

 

 

第三讲  内部类

一、  定义

二、  访问规则

　　1）  内部类能够直接访问外部类中的成员，包括私有的，由于此时，内部类处于成员位置上，能够任务是外部类中的一个成员，内部类中持有了一个外部类的引用，格式：Outer.this.x——这里的this表明的是内部类对象。这就是内部类可以直接访问外部类成员的缘由。

　　2）  外部类要访问内部类，就必须创建内部对象：

　　　　Inner inner = new Inner();

　　3）  其余外部类访问内部类的方式

　　　　当内部类定义为非私有，能够在外部其余类中直接创建内部类对象进行访问，格式以下：

　　　　　　Outer.Inner  inner = new Outer().new Inner();

　　　　当内部类在成员位置上时，能够被成员修饰符锁修饰

            如，private修饰：将内部类在外部类进行封装，只能外部类访问；

　　　　Static 修饰：内部类就具有了static的特性。此时，内部类只能访问外部类中的static成员，出现了访问局限。

　　　　外部其余类访问static修饰的内部类非静态成员方法以下：

　　　　————new Outer.Inner().function();——Inner类是Outer类的静态成员，能够直接用类名调用。

           外部其余类直接访问static修饰的内部类的静态成员方法以下：

           ————Outer.Inner.function()；——静态成员能够直接被类名调用。

　　　　注意：当内部类中定义了静态成员，该内部类必须是静态的；当外部类中的静态方法访问内部类时，内部类也必须是静态的。

　　　　——一个大原则：静态只能访问静态成员。

　　内部类在局部位置上时：

　　　　不能被static修饰；

　　　　能够访问外部类中的成员，由于还持有外部类中的引用。可是不能访问它所在的局部中的变量，只能访问被final修饰的局部变量。

以下：a 只有被final修饰后，才能被内部类访问。

以下，内部类被定义在了局部位置上。系统默认给内部类一个外部类的引用Outer.this

　　总结：无论内部类定义在成员位置仍是局部位置上，外部类须要内部类对象才能访问内部类中成员，内部类获得了外部类对象（系统默认提供外部类引用Outer.this）才能访问外部类成员。

三、  匿名内部类

定义：匿名内部类其实就是内部类的简写格式。

定义匿名内部类的前提：内部类必须是继承一个类或者实现接口。

 

第四讲  异常

一、  定义

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

异常由来：问题也是现实生活中的一个具体的事物，也能够经过java类的形式进行描述，并封装成对象，即，对不正常状况进行描述后的对象体现。

异常划分：严重问题 和 非严重问题。

严重问题：java经过Error类进行描述，对于Error通常不编写针对性的代码进行处理。

非严重问题：java经过Exception进行描述，可使用针对性的处理方式进行处理。

其中，Error和Exception同为Throwable的子类。

二、  异常处理

　　异常处理目的：把异常处理掉，让try外面的后续语句继续执行。若不处理，程序就会被停下来，不处理后续语句。

缘由：若是虚拟机调用的程序没有的处理此项异常的功能，该异常会被抛给虚拟机，而虚拟机处理异常的默认机制是：直接把此程序停掉。

异常处理代码格式以下：

处理异常有两种方式：

　　第一种是：向上（向调用者）抛出异常；

　　第二种是：本身内部捕获异常并处理。

三、  多异常处理

　　1）  函数中只要有异常发生，函数就停下了；

　　2）  被调用函数声明了几个异常，调用者就对应有几个catch块，若是多个catch块中的异常出现继承关系，父类异常catch块必须放在最下面；

　　3）  若程序出现了被调用函数所声明之外的异常，最好将此异常抛给虚拟机，将程序停掉；

　　4）  建议进行catch处理时，catch中必定要定义具体的处理方式，而不是简单的打印异常。异常信息能够输出到硬盘中相应的文档中，方便后续异常查找及处理；

四、  自定义异常

　　能够自定义java机制中没有定义的异常。

　　注意：Java不会自动识别自定义异常，因此，须要手动创建自定义异常对象并抛出（java自己定义的异常能够被默认抛出）

　　1）  自定义异常信息

　　　　由于父类中已经把异常信息的操做都完成了，因此子类只要在构造时，将异常信息经过super语句传递给父类，而后就能够直接经过　　getMessage方法获取自定义的异常信息了

　　2）  自定义异常特色

　　　　必须继承Exception。由于：异常体系有一个特色：异常类和异常对象都被抛出，它们都具有可抛性，这是Throwable体系中独有的特色。只有这个体系中的类和对象才能够被throws和throw操做。

五、  Throws和throw的区别

　　1）  Throws使用在函数上；Throw使用在函数内；

　　2）  Throws后面跟着异常类，能够多个，用逗号隔开；Throw后面跟着异常对象；

　　注意：Throw下面不该跟其余语句，由于异常抛出后，下面语句不会再执行。Throw和return做为函数的结束标识。可是系统退出（System.exit(0)）时不会执行。

六、  RuntimeException

定义：函数内抛出异常，则函数上必须声明抛出异常，不然编译不经过，但RuntimeException不须要函数声明抛出。若是函数上声明了该异常，调用者能够不用进行异常处理，编译也能经过。

RuntimeException不须要在函数上声明的缘由是：此异常不须要调用者处理。此类异常发生时，但愿程序中止，由于在程序运行时出现了没法继续运算的状况，但愿中止程序后，对代码进行修正。

七、  异常覆盖时的特色

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

　　1）子类在覆盖父类时，若是父类的方法抛出异常，那么子类的覆盖类方法只能抛出父类的异常或者该异常的子类，或者不抛出异常；

　　2）若是父类方法抛出多个异常，那么子类在覆盖该方法时，只能抛出父类异常的子集；

　　3）若是父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不能够抛出异常。若是子类方法发生了异常，就必需要进行try处理，绝对不能抛出。

 

 

知识点总结

一、  继承类和实现接口

父类中定义了某类事物的通用属性，而接口中每每定义的是某类事物的扩展功能。

二、  Throw 和 throws的用法

　　1）  Throw定义在函数内，用于抛出异常对象；

　　2）  Throws定义在函数上，用于抛出异常类，能够抛出多个，用逗号隔开；

三、  异常分两种：编译时异常 和 运行时异常

　　1）  编译时被检测的异常：函数内被抛出，则函数上必需要声明，且在调用者中必须处理或向外抛出；

　　2）  编译时不被检测的异常（即，运行时异常，RuntimeException）

函数上不须要声明，不须要调用者进行处理。

四、  异常处理中finally块中语句特色

　　1）  finally中定义的一般是：关闭资源代码。由于资源必须被释放。

　　2）  finally只有一种状况不会执行：当执行到System.exit(0);时，finally中的语句不会执行。