黑马程序员——java基础--多态、内部类、异常、包

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流-----

一、多态

1、概述

什么是多态？某一事物在不同时刻表现出来的不同状态。

如：猫可以是猫的类型。猫 m = new猫();同时猫也是动物的一种，也可以把猫称为动物。

多态的好处：提高了代码的可扩展性，前期定义的代码可以使用后期的内容。

多态的弊端：前期定义的内容不能使用后期子类的特有功能。

多态的出现思想上也做着变化

以前是创建对象并指挥对象做事情。有了多态以后，我们可以找到对象的共性类型，直接操作共性类型做事情即可，这样可以指挥一批对象做事情，即通过操作父类或接口实现。

2、多态的体现

1、父类的引用指向了自己子类的对象。 

2、父类的引用也可以接收自己的子类对象。

3、多态的前提

a、类与类之间必须有关系，要么继承，要么实现。

b、存在覆盖。父类中有方法被子类重写。

4、多态的应用

1、向上转型：父类引用指向子类对象。
2、向下转型：强制将父类的引用转成子类类型，以便是父类能够访问子类特有方法。

3、关键字：instanceof  用于类型比较。

注：1、自始至终。都是子类的对象在做着变化。

 2、父类对象不能转成子类类型。

        3、我们能够转换的是父类引用指向了自己的子类对象，该引用可以被提升，也可以被强制转换。

4、多态的实质：我们对类型进行抽取 ，导致了多态的产生，对大类型的操作则导致了我们可以对同一个大类型中的所有小类型都能进行操作。

5、多态的特点

1、成员变量

编译时，参考引用型变量所属的类中是否有调用的成员变量，有则编译通过，没有则编译失败。

运行时，参考引用型变量所属的类是否有调用的成员变量，并运行该所属类中的成员变量。简单的说，编译和运行都参考等号的左边。
2、成员函数（非静态）

编译时，参考引用型变量所属的类中是否有调用的函数，有则编译通过，没有则编译失败。

运行时，参考的是对象所属的类是否有调用的函数，简单的说，编译看左边，运行看右边。
3、静态函数：简单说，编译和运行都看做左边。其实对于静态方法，是不需要对象的。直接用类名调用即可。

6、代码示例

运行结果为:

二、内部类

1、概述 

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

什么时候使用内部类？

当描述事物时，事物的内部还有事物，该事物用内部类来描述。因为内部事物在使用外部事物的内容。当一个类需要直接访问到另一个类中的成员的时候，则把这个类写到那个类的内部，写完后，将这个类进行封装不对外暴露，只对外提供方法来访问这个内部类。如定义一个描述人的类，而手、心脏等都属于人，然它们又有自己的功能描述，这时可以在人这个描述类中，定义一个描述心脏的类，也就是内部类，对外部，人只提供访问手、心脏的方式即可。

        编译时，如果代码中有内部类，生成的class文件中会含有这样的文件：Test$1.class。编译器将会把内部类翻译成用$（美元符号）分隔外部类名和内部类名的常规类文件。这是内部类的一种编译现象。

2、内部类分类

内部类分为：局部内部类和成员内部类。

3、内部类的访问特点

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

              因为内部类中持有了一个外部类的引用，格式：  外部类名.this。

3.2、外部类要访问内部类，必须建立内部类对象。

4、内部类的访问格式

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

         格式：

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

         如：    Outer.Inner name =new Outer().new Inner();

4.2、当内部类在外部类中的成员位置上时，可以被成员修饰符所修饰。比如：

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

        static：内部类就局部static的特性。但是当内部类被static修饰后，只能直接访问外部类中的static成员。出现了访问局限。

4.2.1、在外部其他类中，直接访问static内部类的非静态成员的格式为：

        new 外部类名.内部类名（）.方法名（）；

        如：new  Outer.Inner().function();

4.2.2、在外部其他类中，直接访问static内部类的静态成员格式为：

       外部类名.内部类名.方法名（）；

        如：Outer.Inner.function();

注意：

        1）当内部类中定义了静态成员时，该内部类必须是static的。

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

        3）在实际应用中，内部类通常被定义为private，而很少定义为public。

4.2.3、内部类定义在局部

        内部类定义在外部类中的某个方法中，创建了这个类型的对象时，且仅使用了一次，那么可在这个方法中定义局部类。

        a、不可以被成员修饰符修饰。如public、private、static等修饰符修饰。它的作用域被限定在了声明这个局部类的代码块中

        b、可以直接访问外部类中的成员，因为还持有外部类中的引用。

c、局部内部类访问所在局部中的局部变量时，此局部变量必须被final修饰符所修饰。

代码示例：

运行结果：

5、匿名内部类

特点

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

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

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

              特殊情况：因为所以的类都有一个父类Object，所以在定义时也可以用Object。

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

4、其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖，可以理解为带内容的对象。

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

6、匿名内部类可以直接继承一个外部其他类。

7、当你使用的方法的参数类型是一个接口时，且该接口中的方法不超过三个，此时可以定义一个匿名内部类，将此匿名内部类作为一个参数传入此方法中。

匿名内部类的利与弊

        好处：简化书写

        弊端：1、不能直接调用自己的特有方法、

                    2、不能做强转动作。

                     3、如果继承的父类或接口中有很多方法时，使用匿名内部类阅读性会非常差，且调用会很麻烦。所以匿名内部类中定义的方法有一般不超过3个。

代码示例 ：

运行结果为：

三、异常

1、概述

  1、异常定义：就是程序在运行时出现不正常情况。

   2、异常由来：问题也是现实生活中一个具体的事物，也可以通过java的类的形式进行描述。并封装成对象。其实就是java对不正常情况进行描述后的对象体现。

   3、程序可能出现的错误或问题

                a、用户输入错误导致的异常：如用户不正常使用程序，输入一些非法参数

                b、设备硬件等发生的错误：如硬盘损坏等

                c、物理限制：如存储空间不足等

                d、代码错误：在程序编写的方法可能不正确，返回错误参数等。

2、异常体系

异常的分类

1、严重的问题，java通过Error类进行描述。由于是重大异常程序员一般处理不了所以不编写针对性的代码对其进行处理。

2、非严重的问题，ava通过Exception类进行描述。对于Exception可以使用针对性的处理方式进行处理。。

Java的异常体系

       Throwable

                |---Error  //通常出现重大问题如：运行的类不存在或者内存溢出等。

                |---Exception //运行时出现的一起情况

                            |---RuntimeException    //特殊异常类，抛时不需要声明

         Exception和Error的子类名都是以父类名作为后缀。

异常体系的特点

1、异常体系中的所有类以及建立的对象都具备可抛性。

2、说可以被throw和throws关键字所操作。

3、只有异常体系才具有可抛性。

3、异常的特点

1、编译时被检测异常

      该异常在编译时，如果没有处理(没有抛也没有try)，编译失败。该异常被标识，代表着可以被处理。

2、运行时异常(编译时不检测)

       在编译时，不需要处理，编译器不检查。该异常的发生，建议不处理，让程序停止。需要对代码进行修正。如：RuntimeException以及其子类。

4、异常的处理语句

 4.1、异常的语句

try

{

需要被检测的代码。

}

catch（异常类  变量）

{

处理异常的代码；（处理方式）

}

 finally

{

 一定会执行的语句；

}

共有三种结合格式：

a、

try

{

}

catch ()

{

}

b、

try

{

}

finally

{

} 

c、

try

{

}

catch ()

{

}

finally

{

} 

注意：

        1）finally中定义的通常是关闭资源代码。因为资源必须释放。

        2）如果在一个功能中，定义了一些必须要执行的代码，可以用try{}finally{}的方式，将一定执行的代码放在finally代码块中。

        3）finally只有一种情况不会执行。当执行到System.exit(0);fianlly不会执行。

4.2、throw和throws的用法

throw定义在函数内，用于抛出异常对象。

throws定义在函数上，用于抛出异常类，可以抛出多个用逗号隔开。

当函数内容有throw抛出异常对象，并未进行try处理。必须要在函数上声明，否则编译失败。

注意：函数内如果抛出的RuntimeExcpetion异常，函数上可以不用声明。

4.3、对抛出信息的处理

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

当出现异常后，若调用者无法处理可以将异常进行转换成其他异常处理。

一般情况下，函数内出现异常，函数上需要声明。在功能上通过throws的关键字声明了该功能有可能会出现异常类型。

 RuntimeException 异常

1） 如果在函数内抛出该异常，函数上可以不用声明，编译一样通过。

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

 因为不需要让调用者处理。当该异常发生，程序就会停止。可以对代码进行修正。

4.4、处理异常的常用方法

String getMessage（）；//获取异常的信息。返回字符串。

toString（）；//获取异常类名和异常信息，返回字符串。

printStackTrace();//获取异常类名和异常信息，以及异常出现在程序中的位置.返回值void.

                                //其实JVM默认的异常处理机制，就是在调用printStackTrace方法，打印异常的堆栈的跟踪信息。

printStackTrace(PrintStream s)//通常用该方法将异常内容保存在日志文件中，以便查阅。

5、自定义异常

有的时候有些异常java中未进行描述，或者描述的语句不易识别，这时就可以自定义异常，自定义类需要继承Exception或者RuntimeException。

继承Exception或者RuntimeException以后，自定义类才具有了可抛性和调用操作异常的共性方法。

自定义异常信息的方法

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

代码示例：

运行结果为：

6、异常的优点和处理

优点：

1、将问题进行封装。

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

原则：

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

2、调用到抛出异常的功能时，抛出几个，就处理几个。一个try可以对应多个catch。

3、多个catch时，父类的catch放到最下面。否则编译会报错，因为其余的catch语句执行不到。

4、catch内，需要定义针对性的处理方式。不要简单的定义printStackTrace，输出语句。也不要不写。当捕获到的异常，本功能处理不了时，可以继续在catch中抛出。

5、当捕获到异常，但是本功能处理不了时，可以继续在catch抛出。

6、若该异常处理不了，并且并不属于该功能出现的异常可以将异常转换后，再抛出和本功能相关的异常。

7、或者异常可以处理，当需要将异常产生的和本功能相关的问题提供出去。让调用者知道并处理，也可以将捕获到的异常处理后转换新的异常。

7、异常的特点

1、若问题能在内部解决就不需要声明。

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

3、在子父类覆盖时：

    a,子类抛出的异常必须是父类的异常的子类或者子集。

    b,如果父类或者接口没有异常抛出时，子类覆盖出现异常，只能try不能抛。

具体事例可参阅上面的代码。

四、包

1、定义

包其实就是文件夹。在包中，我们通常存放的是类文件，因为我们在编写程序时，难免会出现类名相同的情况。为了方便于对类进行管理，java中就有了包的出现，在不同的包中可以有相同的类名，调用的时候连同包名一起调用即可。包也是一种封装形式。

包名的书写规则

1、包名必须写在程序的第一行。

2、类文件的全称：包名.类名。

2、包的作用

1、对子类文件进行分类管理。将一些相关的类放在同一个包中。
2、给类提供多层命名（名称）空间。
3、避免多个类重命名，对于相同的类名，可通过包名将两者区分。
4、包的出现可以将java 的类文件与源文件相分离。

3、包与包之间的访问

1、要访问其它包中的类，需要定义类的全称。包名.类名。

2、包如果不在当前路径，需要使用classpath设定环境变量，为JVM指明路径。

3、被访问的包中的类权限必须是public的。被访问的包中的类的方法也必须是public的。

4、四中访问权限

 publicprotecteddefaultprivate同一类中okokokok同一包中okokok 子类中okok  不同包中ok   

5、关键字import

5.1、导包的原则：用到哪个类，就导哪个类，不要多导。

5.2、导包的作用：可以简化书写。

注：一个程序文件中只有一个package，但可以有多个import。

5.3、导包的注意事项：

在导包时，用到哪个包就写哪个包，尽量不要将包中所有的类全部导入，这样可以节省内存空间，也能提高点效率。

定义包名不要重复。一般我们定义包名是用url的形式。如：package  cn.itheima.Demo

定义包名时，包名都是小写字母。

6、jar包

就是讲包进行压缩，java中用jar这个工具来对包进行压缩。压缩后的后缀名为jar。

jar.exe工具的常用命令

创建jar包    jar  -cvf  mypack.jar packa packb

查看jar包    jar  -tvf  mypack.jar  [>定向文件]

解压缩       jar  -xvf  mypack.jar

自定义jar包的清单文件        jar –cvfm  mypack.jar mf.txt  packa packb

jar包的优点

1、 可以将多个包压缩到一个文件中。方便项目的携带。

2、 方便于使用，只要在classpath设置jar路径，即可以执行jar包中的java程序。

3、 数据库驱动，SSH框架等都是以jar包体现的。

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流-----