ITeye博客

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

小驴变黑马 · 2014-04-03 03:09 · 编程语言 · Markdown

---------------------- 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培训、期待与您交流! ----------------------

评论(0)

暂无评论。

评论功能维护中,当前仅展示历史评论。