黑马学习日记_内部类概述以及异常的处理

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

 

1.内部类

 1.1什么是内部类？

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

   把类1定义到类2内部有什么好处呢？

    如果把类1定义到外面的话，类2要用类1的功能属性什么的是不是要先创建类1的对象然后

    才能调用类1中的东西啊，而把类1定义到类2中的话，要访问类1的内的东西，就不用创建

    对象了。

  内部类访问规则：

   比如说孙悟空是个类，牛魔王也是个类，孙悟空要访问牛魔王的心脏，是不是要先获得牛魔王

   的对象，然后再调用牛魔王的get心脏方法。但是如果孙悟空飞进了牛魔王的肚子里面，是不是

   就能直接访问牛魔王这个类里面的东西啦？包括其私有的东西。这时候孙悟空就是个内部类，

   牛魔王是外部类，孙悟空能直接访问牛魔王的类里的东西，而牛魔王要想访问孙悟空的心脏，是

   不是要先获得孙悟空的对象啊，然后才能访问它的心脏。

 

   内部类访问规则：

   1.内部类可以直接访问外部类成员，包括私有的；之所以能访问是因为省略了 “外部类名.this”

   2.外部类访问内部类需建立内部类对象

 

  内部类访问格式：

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

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

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

  

   部分代码：

   class Outer

   {

    int x=3;

    void method()

    {

      Inter in = new Inter();//外部类访问内部类需建立内部类对象

      in.show();//调用内部类中方法

    }

    class Inter//内部类

    {

     void show()

     {

  //内部类可以直接访问外部类中的成员

  System.out.println("inter"+x);//打印外部类中成员变量x，同下句

  System.out.println("inter"+Outer.this.x);//其实是省略了外部类名.this.

     }

    }

   }

   class InnerClassDemo

   {

    public static void main(String[] args) 

    {

     

    //在外部其他类中直接访问内部类的成员

    //Inner in = new Inner();这样不行，因为如果另一个类中也有一个名为Inner的内部类，

                         //这样写是不是就不知道这个Inner是哪个类中的内部类啦？

       Outer.Inter in = new Outer().new Inter();//所以要这样创建，指出是哪个类的内部类

       in.show(); //创建内部类对象，直接调用它的方法。  

    }

   }

 

 1.2 静态内部类：

  a.成员内部类

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

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

    static:当内部类被static修饰后,它就具备了static的特性，能直接被外部类的类名调用，

        并且只能直接访问外部类中的static成员。出现了访问局限。

 

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

     new Outer.Inner().function();

    因为是静态的了，所以能直接被外部类的类名调用，Outer.Inner()是内部类了，一new就行了。

 

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

    Outer.Inner.function();直接内部类类名调用

 

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

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

   部分代码如下：

   class Outer

   {

    static int x=8;

    static class Inter//当内部类中的方法有静态成员时，内部类也一定为静态

    {

  static void show()//当内部类被static修饰后,只能直接访问外部类中的static成员

 {

System.out.println(x);

 }

    }

    static void show()//当外部类的静态方法访问内部类时，内部类也必须为静态的

    {

 Inter in = new Inter();

 in.show();

 System.out.println("dangligedang ");

    }

   }

   class  OutClassDemo2

   {

public static void main(String[] args) 

{

//当静态内部类种方法为非静态时，要先创建内部类对象，在调用内部类中的非静态方法

 new Outer.Inter().show();

//如果内部类中的方法为静态的，下面这种写法可以。

 Outer.Inter.show();

}

   }

   内部类定义规则：

    当描述事物时，事物的内部还有事物，该事物用内部类来描述。因为内部事务在使用外部

    事物的内容。

 

 b.局部内部类

  内部类定义在局部时，

   1，不可以被成员修饰符修饰，就把局部类当做一个局部变量，它是不需要被修饰符修饰的

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

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

   部分代码：

   class Outer

   {

    int x = 3;

    void method(final int a)

    {

 final int y = 4;

 new Inner().function(); //这句只能放局部内部类下面，从上往下读，读到这还没内部类呢

 class Inner//局部类不能被成员修饰符修饰

 {

  void function()

  {

   System.out.println(x);//能直接访问外部类的成员

   System.out.println(y);//不能直接访问内部类所在局部的变量，除非被final修饰

  }

 }

 new Inner().function(); //创建内部类对象，调用其方法

    }

 

1.3.匿名内部类

  匿名内部类是指没有指定类名的内部类，当某个类不需要重复使用时，就可以把该类定义为匿名内部类，

  由于匿名内部类没有类名所以在程序中你只能使用一次。

 

   匿名内部类:

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

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

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

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

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

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

 

  部分代码：

   abstract class AbsDemo

   {

    abstract void show();

    

   }

   class Outer

   {

    int x = 3;

 

   

 

    public void function()

    {

 //Inner in = new Inner();

 //in.show();

 new AbsDemo()//定义一个匿名内部类

 {

  void show()

  {

System.out.println("这里实现了接口中的方法");

  }

 }.show();//调用内部类中的show()方法。

    }

   }

----------------------------------------------------------------------------------------------------------------------------------------------------

2.异常

 1.什么是异常？

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

     异常由来：问题也是现实生活中一个具体的事物，也可以通过java的类的形式进行描述并封装

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

   

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

   对于严重的，java通过Error类进行描述。对于Error一般不编写针对性的代码对其进行处理。

   对与非严重的，java通过Exception类进行描述。对于Exception可以使用针对性的处理方式进行处理。

   无论Error或者Exception都具有一些共性内容。比如：不正常情况的信息，引发原因等。

   

 2.异常的处理格式：

   try

   {

    需要被检测的代码；

   }

   catch(异常类 变量)

   {

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

   }

   finally

   {

    一定会执行的语句；如关闭资源，IO流什么的

   }

 

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

   Throwable中的方法

    getMessage()获取异常信息，返回字符串。

    toString()获取异常类名和异常信息，返回字符串。     ?

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

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

 

 3.声明异常 throws

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

 

  部分代码：

  class Demo//3.所以这个程序的编写者要考虑到这一点

  {

  //5.所以这时候编写者就要在这声明一下说，这个功能使用时可能会出现问题你在用时要注意一下

   int div(int a,int b)throws Exception//6.通过throws声明该功能可能会出问题，但是我解决

   {         //不了,就抛给了使用者让使用者去处理

return a/b;//4.你写的这个程序中有除法功能,但是别人在用你写的这个功能时，人家往里

//传什么你是不知道的，所以要考虑到使用者有可能往里传除数为0的情况

   }    

  }

  class  ExceptionDemo

  {

   public static void main(String[] args) //throws Exception  8.或抛

   {

Demo d = new Demo();

 //2.但是可处理可不处理,因为你用别人写的div功能时,根本就不知道这个功能会不会发生问题,你怎

 //么处理,你用到的每一个功能会不会有问题你都不知道，你不会都挨个处理一遍吧

try

{

//7.这时候人家给你标出来了这个功能可能会出问题，使用者用时就要注意了，或try或抛

 int x = d.div(4,1);//1.使用者传参数的时候可能会使程序停掉，比如除数为0

 System.out.println("x="+x);

}

catch (Exception e)//Exception e = new ArithmeticException();

{

System.out.println("除零啦");

}  

System.out.println("over");

}

  }

 

 4.多异常处理

  在定义功能的时候，有时会发现这个功能可能出现的问题不止一个。

 

  在进行多异常处理时应注意：

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

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

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

 

  建立在进行catch处理时，catch中一定要定义具体处理方式。不要简单定义一句 e.printStackTrace(),

  也不要简单的就书写一条输出语句。

 

 5.自定义异常

  因为项目中会出现特有的问题，比如在你设计的功能中，除数也不能为负数。而这种情况并没有被

  java所描述，这样的话就要自己定义了。

  所以对于这些特有的问题可以按照java的对问题封装的思想。将特有的问题进行自定义的异常封装。

 

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

  要么在函数上声明让调用者处理。一般情况下，函数内出现异常，函数上需要声明。

 

  如何定义异常信息呢？

   因为父类中已经把异常信息的操作都完成了。所以子类只要在构造时，将异常信息传递给父类通过

   super语句。那么就可以直接通过getMessage方法获取自定义的异常信息。

 

  总之，在自定义异常的时候，那个自定义类，要继承Exception或者其子类。并且通过构造函数自定义

  异常信息，然后通过throw将自定义异常抛出。

   例如：

    class FuShuException extends Exception //自定义异常

    {

 FuShuException(String msg)//通过构造函数自定义异常信息

 {

  super(msg);//因为父类中都定义好了，直接拿来用就行了

 }

    }

 

    class Demo

    {

 int div(int a,int b)throws FuShuException//在函数上声明抛出

 {

  if(b<0)//手动通过throw关键字抛出一个自定义异常对象。

  throw new FuShuException("出现了除数是负数的情况");

  return a/b;

 }

    }

 

    class  ExceptionDemo3

    {

 public static void main(String[] args) 

 {

  Demo d = new Demo();

  try//捕获异常并进行处理

  {

   int x = d.div(4,-9);

   System.out.println("x="+x);  

  }

  catch (FuShuException e)

  {

   System.out.println(e.toString());

  }

 }

    }

 

 

   throw与throws的区别是什么？

    throw用于抛出一个异常类对象，通常用于自定义异常类情况，如throw new MyException().

     并且是在函数内使用。它后面跟的是异常对象。

    throws则是在方法声明时告诉调用者该方法会抛出哪些异常,而异常的捕获处理交给调用者

     去处理。throws使用在函数上，它后面跟的是异常类。可以跟多个，用逗号隔开。

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

 

    注意，RuntimeException除外。也就说，函数内如果抛出的RuntimeExcpetion异常，函数上

    可以不用声明。

   

  6.运行时异常：RuntimeException

   异常有两种：

    编译时被检测异常

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

     这可以被处理。

    运行时异常(编译时不检测 RuntimeException以及其子类)

     在编译时，不需要处理，编译器不检查。该异常的发生，建议不处理，让程序停止。

     需要对代码进行修正

 

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

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

 

   之所以不用在函数声明，是因为不需要让调用者处理。当该异常发生，希望程序停止。因为在

   运行时，出现了无法继续运算的情况，希望停止程序后，对代码进行修正。

 

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

 

   部分代码：

   class Demo

   {

   //3.编写者的意思就是当调用者传入的参数非法时就让程序停下来，这样就没必要把异常抛给调用者了

int div(int a,int b)//throws ArithmeticException4.因为抛的意思就是让调用者知道哪错了，

{                  //然后让调用者去处理

//1.在写这个功能发现调用者可能传入非法参数,这时就抛出一个运行时异常ArithmeticException

 if(b==0)//2.抛这种异常的意思是,你敢传非法参数我就敢让程序停下来,你传对了再继续用

  throw new ArithmeticException ("被零除啦");

 return a/b;

}

   }

   class ExceptionDemo4 

   {

public static void main(String[] args) 

{  

 Demo d = new Demo();

//5.这样调用者就不知道这个功能有异常,他也就不会进行try处理了

 int x = d.div(4,0);//6.这样的话当调用者传除数为0的时候，能编译成功，但是会运行出错

  //调用者想要程序运行成功，这时就必须传一个正确的数了

 System.out.println("x="+x);  

}

   }

 

  异常体系：

   Throwable

    |--Error

    |--Exception

     |--RuntimeException

 

  异常体系的特点：异常体系中的所有类以及建立的对象都具备可抛性。也就是说可以被throw和

      throws关键字所操作。只有异常体系具备这个特点。

      

  异常的好处：

   1，将问题进行封装。

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

 

 

  异常的处理原则：

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

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

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

   4，catch内，需要定义针对性的处理方式。不要简单的定义printStackTrace，输出语句。

    也不要不写。

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

   try

   {

    throw new AException();

   }

   catch (AException e)

   {

    throw e;

   }

 

  如果该异常处理不了，但并不属于该功能出现的异常。

  可以将异常转换后，在抛出和该功能相关的异常。

 

  或者异常可以处理，当需要将异常产生的和本功能相关的问题提供出去，

  当调用者知道。并处理。也可以将捕获异常处理后，转换新的异常。

  try

  {

   throw new AException();

  }

  catch (AException e)

  {

// 对AException处理。

throw new BException();

  }

 

  异常的注意事项：

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

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

     异常或者该异常的子类。

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

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

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

  部分代码：

 

  class Fu
   {
void show()throws AException
{
}
   }


   class Test
   {
void function(Fu f)
{
 try
 {
  f.show();
 }
 catch (AException e)
 {


 }
 
}
   }


   class Zi extends Fu
   {
    void show()throws CException
{
 
}
   }


   class  
   {
public static void main(String[] args) 
{
 Test t = new Test();
 t.function(new Zi());
}
   }

 

 

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