黑马程序员——学习日记之内部类 异常

                                                          ------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一、内部类的简述
1、内部类的概述：分析事物时，发现该事物描述中还有事物，而且这个事物还在访问被描述事物的内容。这时就用到内部类来描述。
简单的说:把类定义在另一个类的内部。
2、内部类访问特点 
(1)、内部类可以直接访问外部类中的成员。
(2)、外部类要访问内部类，必须建立内部类的对象。
3、内部类的分类
(1)、内部类在成员位置上
根据修饰符不同
(1).1、public:格式 外部类名.内部类名  变量名 = new 外部类().new 内部类();
(1).2、static:
(1).2.1 访问静态内部类中的非静态成员。
外部类名.内部类名  变量名 = new 外部类名.内部类名();
(1).2.2 访问静态内部类中的静态成员。
外部类名.内部类名.静态成员;
注：
1，非静态内部类中，不允许定义静态成员，只可以定义被final修饰的static常量。
2，外部类的静态方法要访问内部类，需要创建内部类的对象，一定要注意，该内部类必须被静态修饰。
否则，只能通过外部类对象.内部类对象的方式访问。

代码体现

 //内部类定义在成员位置上时
 class Demo2
 {
     public static void main(String[] args)
     {
         //创建外部类的对象
         Outer o=new Outer();
         //调用外部类中的方法
         o.run();
         //创建内部类对象
     Outer.Inter oi=new Outer().new Inter();
     //调用内部类中的方法
     oi.show();

     }
 }
 class Outer
 {
     //定义一个成员变量
     int conut=6;
     //定义一个成员方法
     public void run()
     {
         System.out.println("外部运行成功");
     }
     //定义一个内部类
     class Inter
     {
         int conut=8;
         //在内部类中定义一个方法并用调用这三个重名的变量
         public void show()
         {
          int conut=3;
         System.out.println("内部类运行成功"+Outer.this.conut+"......"+this.conut+"......"+conut);
         }
     }
 }

(2)、内部类在局部位置上
1、内部类在局部位置上时，一样可以直接访问外部类中的成员。
2、内部类在局部位置上时，访问局部变量必须加final修饰？
原因:局部变量使用完后，就消失了，生命周期太短，而堆内存中的数据不会立即消失，当堆内存的数据还有用该变量时，
    而变量已经没有了，为了不让该值消失，就用final修饰，用final修饰的变量是一个常量，存储在堆内存当中。

代码体现

 //放在局部位置上时
 class Demo3
 {
     public static void main(String[] args)
     {//创建外部类对象
     Outer o=new Outer();
     //调用show方法
     o.show();

     }
 }
 class Outer
 {
     int in=8;
     public void show()
     {
         final int cn=6;//必须是final修饰
         class Inter
         {
             //在内部类中定义一个方法
             public void run()
             {
                 System.out.println("内部类运行成功");
             }
         }
         //创建内部类对象并调用run方法
         new Inter().run();
     }

 }

4、内部类是可以继承其他类和实现接口的。
如果内部类不需要对外提供，可以通过其继承的父类或者实现的接口，这种公共的类型对外提供。
二、匿名内部类
1、其实就是对1.6的简化书写。
2、原理:匿名内部类其实就是一个子类对象。
3、前提:存在一个类或者接口,这里的类可以是具体类也可以是抽象类。
4、格式:new 类名或者接口名() {重写方法;}
5、通常匿名内部类中的方式不要过多(少于两个)，以免降低阅读性。
代码体现

 //匿名内部类
 //定义一个接口里面包含一个抽象的方法
 interface Test
 {
     void func();
 }
 class Demo4
 {
     public static void main(String[] args)
     {
     //通过主函数调用show，补足代码；通过(匿名内部类)进行show方法参数传递
         new Demo2().show(new Test()
         {
             public void func()
             {
                 System.out.println("调用成功");

             }

         }
         );
     }
     void show(Test t)
     {
         t.func();

     }
 }

第二节:异常机制
一、异常机制的简述
1、异常：是在运行时期发生的不正常情况。
2、异常类：在java中用类的形式对不正常情况进行了描述和封装对象。描述不正常的情况的类，就称为异常类。
3、异常的体系：就是对不同问题用不同类进行描述，例如角标越界，类型转换异常等等，当问题多了，类也就多了，把所有的类的共性进行向上抽取，就形成了异常体系。
4、异常体系的特点：
(1)、异常体系中的所有类以及建立的对象都具备可抛性，用throw和throws关键字所操作，也只有异常体系具备这个特点。
(2)、子类的后缀名都是用其父类名作为后缀，阅读性很强。
二、问题
1、问题的分类
(1)、Error--->一般不可处理的
 特点:是由jvm抛出的严重性的问题，这种问题发生一般不针对性处理。直接修改程序。 
(2)、Exception--->可以处理的
|RuntimeException---------->这个异常类抛出不用声明。
注:Error和Exception都是Trowable的子类
2、异常的两种体现
(1)、编译时被检测异常:只要是Exception和其子类都是，除了特殊子类RuntimeException体系。这种问题一旦出现，希望在编译时就进行检测，让这种问题有对应的处理方式。
 这样的问题都可以针对性的处理。
(2)、运行时异常:就是Exception中的RuntimeException和其子类。这种问题的发生主要是因为调用者的原因导致或者是内部状态的改变导致的。它的目的是让调用着对代码进行修改。
3、throws 和throw的区别 
(1)、在位置上
throws使用在函数上。 
throw使用在函数内。 
(2)、抛出的内容
throws抛出的是异常类，可以抛出多个，用逗号隔开。 
   throw抛出的是异常对象。 

三、异常的处理格式
1、异常处理具体的格式
(1)、try 
{ 
被检测异常的代码。 
} 
catch(异常类 变量)该变量用于接收发生的异常对象 
{ 
处理异常的代码。 
} 
finally 
{ 
一定会被执行的代码。 
} 
2、根据具体的格式，有三种结合的方式
(1)、第一种
try 
{ 
被检测异常的代码。 
} 
catch(异常类 变量)该变量用于接收发生的异常对象 
{ 
处理异常的代码。 
} 
(2)、第二种
catch(异常类 变量)该变量用于接收发生的异常对象 
{ 
处理异常的代码。 
} 
finally 
{ 
一定会被执行的代码。 
} 
(3)、第三种
try 
{ 
被检测异常的代码。 
} 
catch(异常类 变量)该变量用于接收发生的异常对象 
{ 
处理异常的代码。 
} 
finally 
{ 
一定会被执行的代码。 
} 
注：1、finally 代码块内代码是一定被执行的代码，除非是执行到了System.exit(0);
2、finally 中通常定义是关闭资源的代码。
四、对抛出信息的处理
1、处理的方式有两种
(1)、第一种 在内部进行try{}catch(){}处理。
(2)、第二种 在函数上进行异常声明，让调用者进行处理。
注：如果不进行这两种方式处理编译是不会通过的。(除了Exception中的特殊一个子类RuntimeException)
    RuntimeException是运行异常无论在函数内部抛出而不去在函数上声明还是在函数上声明而调用者不处理，编译都可以通过。
五、自定义异常
    1、自定义异常的由来：当我们遇到特有的问题时，并且这些问题在java中并没有描述封装成对象，这时我们可以自定义异常。
2、前提：定义的类继承Exception或者RuntimeException。
3、自定义异常时，在什么情况下该继承谁呢？
(1)、假如异常发生了，无法在继续进行运算了，就继承RuntimeException
(2)、一般情况下都继承Exception(原因异常类和异常对象都被抛出，具备可抛性，并且还能被throws和throw操作)
3、代码体现

 class Demo5
 {
     public static void main(String[] args)
     {
         //定义一个变量
     int sum=1;
     //就假设这个变量正好满足
     if (sum==1)
     {
         try
         {//获取到异常的部分
             throw new NoFoundException("异常出现");
         }
         //对异常进行处理
         catch (NoFoundException nfe)
         {
             System.out.println("异常处理了");
         }
     }
     }
 }
 //自定义异常类
 class NoFoundException extends Exception
 {
     //定义一个属性
     private String str;
     NoFoundException(String s)
     {
         //返回输入的信息
         super(s);
     }
 }

六、异常处理的原则： 
1、函数内容如果抛出需要检测的异常，那么函数上必须要声明，否则必须在函数内用trycatch捕捉，否则编译失败。     
2、如果调用到了声明异常的函数，要么trycatch要么throws，否则编译失败。  
3、当功能的内容可以解决就用catch，解决不了就用throws让调用者解决。(也可以转换抛出)。
4、一个功能可以声明多个异常。
5、对于多个异常声明，必须对应多个catch针对性处理。（在处理时要把父类异常放在最下面）。
七、异常的注意事项
1、子类在覆盖父类方法时，父类的方法如果抛出了异常，那么子类的方法只能抛出父类的异常或者该异常的子类。  
2、如果父类抛出多个异常，那么子类只能抛出父类异常的子集。 
3、如果父类的方法没有抛出异常，那么子类覆盖时绝对不能抛，就只能try{}catch(){}

代码体现

 //自定义异常x类
 class XException extends Exception
 {
 }
 //自定义异常y类
 class YException extends XException
 {
 }
 //自定义异常z类
 class ZException extends Exception
 {
 }
 class Fu
 {
     //假如是父类抛出了异常x类
     void show()throws XException
     {
     }
 }
 class Zi extends Fu
 {
     //子类抛出异常类
     void show()throws ZException
     {
     }
 }
 class Demo6
 {
     //用一个方法既能接收Fu类也能接受Fu的子类
     void function(Fu f)
     {
         try
         {
             //调用有异常的方法
             f.show();
         }
         catch (XException e)
         {
         }
     }
 }
 //编译直接的失败：原因是：子类抛出的是ZException异常，父类无法进行catch处理。
               // 解决的方法是：子类继承父类异常或子集就行了。

第三节：包
一、包的简述：
1、包：其实就是文件夹。
2、包的作用
(1)、对类进行管理。
(2)、给类提供了多层名称空间。
注;类名=包名+类名。
3、包的定义格式
(1)、package 包名。
(2)、多级包用.分开。
4、包的小细节
(1)、package语句只能有一个在java文件中。
(2)、在java文件中没有package,会有一个默认的无包名。
(3)、在java文件中package语句必须放在程序的第一行可执行的代码。
二、导包
1、导包中的一个关键字:import。
2、import关键字
(1)、作用:简化类名书写
(2)、假如相同的类被不同的包导入时，必须明确包名。
(3)、假如多个类存在一个包中的时，建议不要用通配符，用具体的类名导入。
3、导包的两种格式
(1)、import 包名...类名;
(2)、import 包名...*;
4、package,import,class的执行顺序
package > import > class
三、包与包之间的访问
1、包中的类及成员被访问必须用public修饰
2、父类的成员被访问可以给其它包中的子类提供一个特有的权限protected。
四、权限修饰符
1、权限修饰符
位置 |同一类中|同一包中|子类中|不同包中
private  |  o   |        |      |
默认          |  o   |   o    |      |
protected|   o  |   o    |  o   |
public       |  o   |   o    |  o   |   o
注:权限修饰符不能同时出现也就是说在任意时刻只能出现一个。
五、常见的修饰符
1、权限修饰符 private,默认,protected,public
2、状态修饰符 static,final
3、抽象修饰符 abstract


六、jar包
1、jar包的出现：当包越来越多的时候，就将java程序进行封装成一个jar压缩包，可以直接配置到classpath路径下，通过查阅该jar包的api文档就可以使用jar包中的内容。
2、带包的编译和运行
(1)、手动式
(1)、javac编译当前类文件。
(2)、手动建立包对应的文件夹。
(3)、把a步骤的class文件放到b步骤的最终文件夹下。
(4)、通过java命令执行。
注：需要带包名称的执行.
(2)、自动式
(1)、javac编译的时候带上-d。
(2)、通过java命令执行。和手动式一样。