黑马程序员——多态，内部类，异常

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

多态：可以理解为事物存在的多种体现形态。

1.多态的体现

父类的引用也可以接收自己的子类对象。eg:Animal d =new Dog();

2.多态的前提

1).必须是类与类之间有关系，继承或实现

2).存在覆盖。

3.多态的好处

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

4.多态的弊端：

只能使用父类的引用访问父类的成员。

5.多态的应用

6.多态使用注意事项：

在多态中成员函数(非静态)特点：

编译时：参阅引用型变量所属的类中时候有调节的方法。如果有，编译通过，没有，编译失败。

运行时：参阅对象所属的类中时候有调用的方法。

总结：成员函数在调用时，编译看左边，运行看右边。

在多态中成员函数(静态静态)特点：

无论编译还是运行，都是看左边(所属类)。

在多态中成员变量特点，无论编译还是运行，都参考变量所属的类。

接口多态调高了程序的扩展性。

内部类：将一个类定义在另一个类里面，里面那个类就称为内部类。（内置类，嵌套类）

内部类的访问规则：

1.内部类可以直接访问外部类中的成员，包括私有。

之所以可以直接访问外部类的成员，是因为内部类中持有了一个外部类的的引用：格式：外部类名.this

2.外部类要访问内部类的成员，要先建立内部类对象。

访问格式：

1.当内部类定义在外部类成员位置上，且非私有，可以在外部其他类中直接建立内部类对象。

格式：外部类名.内部类名 变量名 = 外部类对象.内部类对象；

eg:Outer.Inner in = new Out().new Inner();

2.当内部类定义在外部类成员位置上，就可以被成员修饰符所修饰。

eg:private：将内部类在外部类进行封装。

   static:内部类具备static的特性。

   当内部类被static修饰后，只能访问外部类中的静态成员，出现了访问局限。

   1).在外部其他类中，如何访问static内部类的非静态成员呢？

eg:new Outer.Inner().function();

   2).在外部其他类中，如何访问static内部类的静态成员呢？

eg:Outer.Inner.function();

注意：当内部类中定义了静态成员，该内部类必须是静态的。

      当外部类中的静态方法访问内部类时，内部类也必须是静态的。

内部类定义在局部时

1.不可以被成员修饰符修饰。

2.可以访问外部类中的成员，因为还持有外部类中的引用。

  但是不可以访问它所在的局部中的变量。只能访问被final修饰的局部变量。

匿名内部类：

1.匿名内部类其实就是内部类的简写格式。

2.定义匿名内部类的前提：

内部类必须继承一个类或者实现接口。

3.匿名内部类的格式：new 父类或者接口(){定义子类的内容}。

4.匿名内部类就是一个匿名子类对象。

5.匿名内部类中定义的方法最好不要超过3个。

异常：就是程序在运行时出现的不正常情况。

异常的由来:问题可以是现实生活中的事物，也可以通过Java类的进行描述，并封装成对象。

其实就是java对不正常情况进行描述后的对象体现。

对问题的划分：一种是严重的问题（Error），一种是非严重的问题（Exception）。

对于Error：一遍不编写针对性的代码进行处理。

对于Exception：可以使用针对性处理方式进行处理。

Error与Exception共性内容：

eg：不正常情况的信息，引发原因等。

异常的处理：

java中提供了特有的语句进行处理。（固定格式）

try

{

//需要被检测的代码，必有

}

catch(异常类 变量)

{

//处理异常的代码，必有

}

finally

{

//一定会执行的语句，可不写

}

对捕获到的异常进行常见方法操作。

String getMessage();//获取异常信息

String toString();//异常名称

e.printStackTrace();//打印异常名称，异常信息，异常出现的位置。

在函数上声明异常：便于提高安全性，让调用处进行处理，不处理会编译失败。

在功能上如果通过throws关键字声明，这表明该功能可能会出现问题。

eg:int div(int a,int b)throws Exception

多异常的处理:

1.声明异常时，建议声明更为具体的异常，这样处理会更具体。

2.对方声明几个异常，就对应几个catch块。不要定义多余的。如果多个catch块中的异常出现继承关系，父类catch块放在最下面。

建议在catch处理时，catch一定要定义具体的处理方式。也不要写简单的输出语句。

自定义异常：必须是自定义类继承Exception。

因为项目中会出现特有的问题，这些问题并没有被java所描述并封装对象。所以对于这些特有的问题可以按照java的对问题封装的思想。将特有的问题，进行自定义异常封装。

当函数内部出现了throw抛出异常对象，就必须给出对应的处理动作。要么在内部try catch处理，要么在函数上声明让调用者处理。一般情况下，函数内出现异常，函数上声明。

手动通过throw关键字抛出一个未定义一场对象。

如何定义自定义异常信息呢？

因为父类已经把异常信息的操作都完成了。所以子类只要构造时，将异常信息通过super语句传递给父类。那么就可以直接通过getMessage方法获取自动以异常信息。

继承Exception原因：

异常体系有一个特点：因为异常类和异常对象都被抛出。

他们都具备可抛性。这个可抛性是Throwable这个体系中独有特点。

这有这个体系中的类和对象才可以被throws和throw操作。

throw和throws的区别：

throws：使用在函数上，后面跟异常类，多个用逗号隔开

throw：使用在函数内，后面跟异常对象

Exception中的特殊子类异常：

RuntimeException类及其子类，在函数内抛出，函数上不用声明。

如果在函数上声明了该异常，调用者可以不用进行处理，编译一样通过。

之所以不用再函数上声明，因为不需要让调用者处理。当异常发生时，希望程序停止。运行时，出现了无法继续运算的情况，希望停止程序后，由程序员对代码修正。

自定义异常时：如果该异常发生，无法继续运算，就让自定义异常继承RuntimeException。

异常分两种：

1.编译时被检测的异常。

2.编译时不被检测的异常（运行时异常）。RuntimeException以及其子类。

dinally代码块：定义一定执行的代码。

通常用于关闭资源。

异常处理语句格式：

1.try{}catch(){}

2.try{}catch(){}finally{}

3.try{}finally{}

catch是用于处理异常。如果没有catch就代表没有处理异常。如果该异常是检测时异常，那么必须声明。

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

1.子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类异常或者该异常的子类。

2.如果父类方法抛出多个异常，那么子类在覆盖该方法时，只能抛出父类异常的子集。

3.如果父类或者接口的方法中，没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常。

如果子类方法发生了异常，就必须要进行try处理，绝对不能抛。

总结：

异常是什么？异常是对问题的描述。将问题进行对象的封装。

异常体系：

Throwable

|--Error

|--Exception

|--RuntimeException

异常体系的特点：异常体系中的所有类以及建立的对象都具备可抛性。即都可以被throw或者throws操作。只有异常体系有这个特点。

throw：函数内，抛出异常对象。

throws:函数上，抛出异常类，多个用逗号隔开。

异常有两种：

1.编译时被异常，如果异常没有处理，编译失败，可以被处理。

2.运行时异常(编译时不检测)，异常发生，建议不处理，让程序停止。

finally有一种情况读不着：之前代码有系统退出System.exit(0);

异常的好处：

1.将问题进行封装。

2.将正常的流程代码和问题处理代码相分离，方便于阅读。

异常的处理原则：

1.处理方式有两种：try 或者 throws。

2.调用到抛出异常功能时，抛出几个就处理几个。

3.多个catch，父类的catch放到最下面。

4.catch内需要定义针对性的处理方式。本功能处理不了时，可继续抛出。

如果该异常不属于该功能出现的异常，转换后抛出。

包（package）：

1.用来对类文件进行分类管理。

2.给类提供多层命名空间。

3.写在程序文件的第一行。

4.类名全称是：包名.类名。

5.包也是一种封装形式。

定义包格式：package 包名；(所有字母小写)

编译时格式：javac -d 

总结：

1.包与包之间进行访问，被访问的包中的类以及类中的成员，需要public修饰。

2.不同包中的子类可以直接访问父类中被protected权限修饰的成员。

包与包之间可以使用的权限只有两种：public  protected。

为了简化类名的书写，使用一个关键字，import(导入).

格式：import 包路径（导入的是包中的类）

建议不要写通配符*，需要包中的哪个类就导入哪个类。

建议定义包名不要重复，可以使用url来完成定义。url是唯一的。

Jar包：java的压缩包。

方便项目的携带。

Tips:

权限总结：

public  protected defaultprivate

同一个类中   ok ok ok ok

同一个包中 ok ok ok

子类 ok ok

不同包中 ok

1.非静态内部类中不可以定义静态成员。内部类中如果定义了静态成员，该类必须被静态。

2.静态方法只能覆盖静态方法。

3.this代表本对象。

4.final特点：

修饰类，变量（成员，静态，局部），函数。

修饰的类不可以被继承

修饰的函数不可以被覆盖。

修饰的变量是一个常量只能赋值一次。

throw单独存在时，下面不要有执行语句。

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