内部类

内部类

定义：

将一个类定义在另一个类里面,里面那个类称为内部类(内置类,嵌套类).

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

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

            

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

当内部类被static修饰后，只能直接访问外部类中的static成员

静态只能访问静态，静态随着类先加载，非静态还没加载。出现了访问局限。

在外部其他类中，如何直接访问static内部类的非static成员呢？

new Outer.Inner().xxx(); 就是不用new Outer.new Inner().xxx();

就是不用new Inner了，因为Inner是静态的，Outer一加载Inner也随之加载，就把Outer.Inner视为一个整体new Outer.inner的对象即可，然后调用xxx方法。

在外部其他类中，如何直接访问static内部类的static成员呢？

Outer.Inner.function();

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

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

 

 

为何定义内部类：

 

内部类不但可以放在成员变量位置，还可以放在局部变量位置

但此时不能用成员成员修饰符static与private修饰了

而且只能访问它所在局部中被final修饰的局部变量。

 

匿名内部类

匿名内部类:

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

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

       内部类必须是继承一个类或者实现接口(没有类名不能new 对象，故要继承）

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

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

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

 

匿名内部类的格式：

new 父类名&接口名(){ 定义子类成员或者覆盖父类方法 }.方法。

 

 

匿名内部类练习：

 

面试

       //1

       new Object(){

           void show(){

              System.out.println("show run");          

           }

       }.show();

       //2

       Object obj = new Object(){

           void show(){

              System.out.println("show run");

           }

       };

       obj.show();

      

       1和2的写法正确吗？有区别吗？说出原因。

       写法是正确，1和2都是在通过匿名内部类建立一个Object类的子类对象。

       区别：

       第一个可是编译通过，并运行。

       第二个编译失败，因为匿名内部类是一个子类对象，当用Object的obj引用指向时，就被提升为了

       Object类型，而编译时检查Object类中是否有show方法，所以编译失败。

 

 

异常

异常：

程序在运行时出现的不正常情况。

 

Java中异常的来源：

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

 

对于问题的划分：两种：一种是严重的问题，一种非严重的问题。

对于严重的，java通过Error类进行描述。(相当于癌症，就在程序中不处理的)

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

对与非严重的，java通过Exception类进行描述。(相当于普通疾病，可治疗)

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

 

 

无论Error或者Exception都具有一些共性内容。所以可以不断的向上抽取。形成了异常体系—Throwable。

--------java.lang.Throwable：

Throwable：可抛出的。

    |--Error：错误.一般不编写针对性的代码进行处理，通常在jvm发生，需对程序代码进行修正。

    |--Exception：异常.可以有针对性的处理方式

 

这个体系中的所有类和对象都具备一个独有的特点；就是可抛性。

可抛性的体现：就是这个体系中的类和对象都可以被throws和throw两个关键字所操作。

 

无论是错误还是异常，它们都有具体的子类体现每一个问题，它们的子类都有一个共性，就是都以父类名才作为子类的后缀名。如ApplicationException, AWTException,

 

异常的处理格式：

try

{

         需要被检测的代码；

}

catch(异常类 变量)

{

         处理异常的代码；(处理方式)

}

finally

{

         一定会执行的语句；

}

 

 

但是变量时用户输入的，你不能知道用户输入什么变量

故在可能出现异常的程序上要异常声明throws提醒可能出现异常

在函数上声明异常。

便于提高安全性，让调用出进行处理。不处理编译失败。

 

 

 

对多异常的处理。

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

2.对方声明几个异常，就对应有几个catch块。不要定义多余的catch块。

 

         若多个catch块中的异常出现继承关系，父类异常catch块放在最下面。

建立在进行catch处理时，catch中一定要定义具体处理方式。

不要简单定义一句e.printStackTrace(),也不要简单的就书写一条输出语句。

 

 

自定义异常：

因为项目中会出现特有的问题，

而这些问题并未被java所描述并封装对象。

所以对于这些特有的问题可以按照java的对问题封装的思想。

将特有的问题。进行自定义的异常封装。

 

 

需求：在本程序中，对于除数是-1，也视为是错误的是无法进行运算的。

那么就需要对这个问题进行自定义的描述。

自定义异常：

 

自定义异常信息：

 

 

 

 

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

继承Exception原因：

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

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

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

 

throw 和throws关键字的区别：

throw用于抛出异常对象，后面跟的是异常对象；throw用在函数内。

throws用于抛出异常类，后面跟的异常类名，可以跟多个，用逗号隔开。throws用在函数上。

通常情况：函数内容如果有throw，抛出异常对象，并没有进行处理，那么函数上一定要声明，否则编译失败。但是也有特殊情况。

 

 

异常分两种：

1：编译时被检查的异常，只要是Exception及其子类都是编译时被检测的异常。

2：运行时异常，其中Exception有一个特殊的子类RuntimeException，以及RuntimeException的子类是运行异常，也就说这个异常是编译时不被检查的异常。

 

编译时被检查的异常和运行时异常的区别：

编译被检查的异常在函数内被抛出，函数必须要声明，否编译失败。

声明的原因：是需要调用者对该异常进行处理。

运行时异常如果在函数内被抛出，在函数上不需要声明。

不声明的原因：不需要调用者处理，运行时异常发生，已经无法再让程序继续运行，所以，不让调用处理的，直接让程序停止，由调用者对代码进行修正。

 

自定义异常时：如果该异常的发生，无法在继续进行运算，

就让自定义异常继承RuntimeException。

 

 

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

通常用于关闭资源。即：无论是否发生异常，资源都必须进行关闭。

System.exit(0); //退出jvm，只有这种情况finally不执行

系统自带语句，类似System.out

 

 

try  catch  finally的几种结合方式：

 

 

 

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

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

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

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

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

 

如果这个异常子类无法处理，已经影响了子类方法的具体运算，这时可以在子类方法中，通过throw抛出RuntimeException异常或者其子类，这样，子类的方法上是不需要throws声明的。

异常要尽量避免，如果避免不了，需要预先给出处理方式。比如家庭备药，比如灭火器。

异常的好处：

         1，将问题进行封装。

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

 

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

                   try

                   {

                            throw new AException();

                   }

                   catch (AException e)

                   {

                            throw e;

                   }

 

如果该异常处理不了，但并不属于该功能出现的异常。可以将异常转换后，在抛出和该功能相关的异常。

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

                   try

                   {

                            throw new AException();

                   }

                   catch (AException e)

                   {

                            // 对AException处理。

                            throw new BException();

                   }

比如:汇款的例子,A向B汇款，系统异常，没汇成功，系统首先把钱存会A 然后告诉A没汇成功，相当于内部简单处理，向外提供一个简单的异常，A只需知道没汇成功的异常，不需要知道系统出什么毛病了，A的到简单异常自己再处理：再汇一次，或和B联系。

 包package

包:在一个文件下不能出现同名文件，Java编译出来的class类文件很多是同名但内容不同的。解决办法就是建立两个文件夹，Java中文件夹就叫包。

作用：

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

2.给类文件提供多层名称空间。

    如果生成的包不在当前目录下，需要最好执行classpath，将包所在父目录定义到classpath变量中即可。

一般在定义包名时，因为包的出现是为了区分重名的类。所以包名要尽量唯一。怎么保证唯一性呢？可以使用url域名来进行包名称的定义。

package pack;

注意：包名的写法规范：所有字母都小写。

package cn.itcast.demo;

类的全名称是 包名.类名

    编译命令：javac –d 位置（.当前路径） java源文件 （就可以自动生成包）

 

总结：

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

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

包与包之间访问可以使用的权限有两种：

1：public

2：protected：只能是不同包中的子类可以使用的权限。

总结java中的四种权限：

    范围       public     protected     default       private

同一个类中       ok             ok              ok          ok

同一包中        ok             ok              ok     

子类            ok            ok

不同包中         ok

一个java文件中不能出现两个及以上的public类及接口

被public修饰的类名必须与java文件名相同（解决：建立连个java文件，装在同一包中）

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

 

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

import packa.*;//这个仅仅是导入了packa当前目录下的所有的类。不包含子包。

import packa.abc.*;//导入了packa包中的子包abc下的当前的所有类。

 

如果导入的两个包中存在着相同名称的类。这时如果用到该类，必须在代码中指定包名。

   packb.Demo b = new Demo();

   packc.Demo c = new Demo();

 

jar ：java的压缩包，主要用于存储类文件，或者配置文件等。

命令格式：jar –cf 包名.jar 包目录 

解压缩：jar –xvf 包名.jar

常见的软件包:

 

java.lang : language java的核心包，Object System  String Throwable jdk1.2版本后，该包中的类自动被导入。

java.awt : 定义的都是用于java图形界面开发的对象。

javax.swing: 提供所有的windows桌面应用程序包括的控件,比如：Frame , Dialog, Table, List等等,就是java的图形界面库。

java.net : 用于java网络编程方面的对象都在该包中。

java.io : input  output 用于操作设备上数据的对象都在该包中。比如：读取硬盘数据，往硬盘写入数据。

java.util : java的工具包，时间对象，集合框架。

java.applet: application+let 客户端java小程序。server+let  -->  servlet 服务端java小程序。