黑马程序员-内部类好异常

来源：互联网发布：淘宝最近没生意编辑：程序博客网时间：2024/05/01 05:17

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

内部类：
其实就是在类中在定义类。

特点：内部类可以直接访问外部类中的成员。是因为内部类都持有一个外部类的引用。外部类名.this
外部了要访问内部类必须要建立内部类的对象。

什么定义内部类呢？
  当分析事物时，事物的内部还有具体的事物，将这个具体的事物用内部类进行描述。

  只要一个类需要直接访问另一个类中的成员。那么就将该类定义成内部类。

定义到内部可以进行封装，通过外部类对外提供公有方法来获取内部类的对象。

  interface Inter
  {
   public void show();
  }
  class Outer
  {
   private int num;
   private class Inner implements Inter
   {
    public void show()
    {
     System.out.println(Outer.this.num);
    }
   }
   public Inter getInstance()
   {
    return new Inner();
   }

  }
  class Main
  {
   public static void main(String[] args)
   {
    Outer out = new Outer();
//    Outer.Inner in = out.new Inner();
//    in.show();
    Inter in = out.getInstance();
    in.show();
   }
  }

作为了解：
内部类定义在外部类的成员位置上。可以使用一些成员修饰符所修饰。

  public private static
  一般内部都会被隐藏，所以都有private修饰。
  如果内部类中定义了静态成员，那么内部类必须是静态的。
  静态内部类只能访问外部类中的静态成员。

  注意：静态内部类是不会持有外部的this引用的。持有的是外部类名。
  class Outer
  {
   static int num = 9;
   static class Inner
   {
    void show()
    {
     System.out.println(Outer.num);
    }
    static void show2(){}
   }
  }

  1,静态内部类的非静态成员show方法的访问。
  Outer.Inner in = new Outer.Inner();
  in.show();
  2,静态内部类的静态成员访问。
  Outer.Inner.show2();

定义内部类定义在局部位置上时：
内部类只能访问局部中被final修饰的局部变量。

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

匿名内部类。
  特点：
   1，其实就是内部类的简写格式。
   2，它就是一个匿名子类对象。这个对象有点胖。

  前提：
   内部类必须继承或者实现一个外部类或者接口。
   建议这个接口中的方法不超过3个。

格式：
new 父类名or接口名(){}

  interface Inter
  {
   void show();
  }
  class Outer
  {
   /*
   class Inner implements Inter
   {
    public void show(){}
   }
   */
   public void method()
   {
    //new Inner().show();
    new Inter()
    {
     public void show(){}
    }.show();
   }
  }
-------------------------------

异常：
在程序运行时期，发生一些不正常情况。
异常的由来：
其实就是java按照面向对象的思想将问题进行描述，并封装成了对象。

不正常情况有两种：
1，严重情况：Error。
2，非严重情况：Exception
这些情况的发生，都有自己的名字，以及一些详细的信息。
这些共性内容进行抽取，就出现了异常体系。

Throwable : 异常体系的特点在于该体系中所有类都具备可抛性，可以被throw 和 throws关键字操作。
  |--Error
   属于程序中的严重性问题，一般是由jvm抛出的。比如 NoClassDefFoundError,OutOfMemoryError
   出现Error一般我们不编写针对性的代码进行处理。因为程序已经没有办法在继续执行。
   需要对程序进行修正。

  |--Exception
   属于程序的可以处理的问题，是可以编写针对性的代码进行处理的。
   该异常属于编译被检测的异常。也就是说函数内如果抛出了该异常，
   该异常没有try或者抛的处理，编译会失败。

   |--RuntimeException
    属于运行时异常，在编译时期是不会检测的。如果函数内抛出该异常，可以不用try和throws。
    也就是可以不需要调用者进行处理，它的出现需要让程序停止，对代码进行修正。
    ArrayIndexOutOfBoundsException NullPointerException

这个体系中的具体问题(子类)在定义名称时，都是父类名字作为后缀。

Throwable中定义了一些操作错误和异常的共性方法：
  1，String getMessage():获取异常的信息。
  2，String toString():覆盖了Object类中的toString方法，建立了异常对象自己特有的字符串表现形式。
       返回的是异常的名字和异常的信息。
  3，void printStackTrace():打印异常的在内存中的信息。包括，异常类名，异常信息，异常出现在代码中的位置。

自定义异常：
在自定义项目中出现的问题，java并没有进行描述，需要自己对问题描述。
将问题描述封装对象，这就是自定义异常。

如何定义呢？
其实很简单，一样是描述事物。
只要让该类继承异常体系即可。这样该了就具备了可抛性。

class MyException extends Exception/*RuntimeException*/
{
  MyException()
  {
   super();
  }
  MyException(String message)
  {
   super(message);
  }
}

class Demo
{
  void show()throws MyException
  {
   throw new MyException();
  }
}

throws和throw的区别：
throws后面抛出的是异常类，可以有多个，用逗号隔开。
throw后面抛出的是异常对象。
注意：throw语句单独存在时，在其下面不可以有任何语句，因为执行不到。
因为return用于结束函数，throw也可以用于结束函数。

  public int div(int a,int b)
  {
   if(b<0)
    throw new RuntimeException("除数为负数，不可以运算。");
   return a/b;
  }

  int[] arr = new int[3];
  int index = 5;
  getElement(arr,index);
  public int getElement(int[] arr,int index)
  {
   if(arr==null)
    throw new NullPointerException("数组实体不存在，操作什么东西");
   if(index<0 || index>=arr.length)
    throw new RuntimeException("index的接收的值是错误的，值是："+index);

return arr[index];
}

异常处理的原则：
1，异常可以throws，可以try.
  如果功能内部发生的异常无法自身进行处理，就throws出去。
  如果可以自身处理，就try。
2，定义功能时，如果发现该功能会出现问题，而且不止一个。
  就将可能发生的问题都用throws标识在函数。标识最具体的问题。
  调用者处理时，有几个异常，就对应几个catch代码块，对异常进行针对性处理。
3，异常的封装。将本层出现的特有问题进行try处理，然后抛出，其他层可以识别的并处理的异常。

  //操作数据库的添加数据方法。
  class NoDataException extends Exception
  {
  }
  public void add()throws NoDataException
  {
   try
   {
    操作数据库的动作。
    throw new SQLException();
   }
   catch (SQLException e)
   {
    处理数据库异常。
    //throw new RuntimeException("数据添加失败");
    throw new NoDataException("没有数据");
   }
  }

4，当子类覆盖父类方法时，如果父类的方法抛出了异常。
  子类只能抛出父类异常的子类或者子集。
  简单说，子类怎么抛都行，就是不能抛出父类超出父类范围的异常。
  如果父类或者接口被覆盖的方法没有抛出异常，
  那么子类在覆盖时，方法中出现异常，就只能try，不能throws。

异常的正对性处理语句：
try
{
  需要被检测的代码。
}
catch (异常类变量)
{
  异常的处理代码。
}
finally
{
  一定会被执行的代码。
  一般定义的就是关闭资源的代码。
  特点：只有当执行到System.exit(0);finally代码块不会执行。

}
语法结构：
1,try和catch结合使用。可以和多个catch结合。
try
{

}
catch ()
{
}

2,try和finally结合使用。
这种组合主要用关闭资源。但是对于出现的异常，并没有catch处理，需要抛出。

异常的基本思想：
问题尽量避免发生，如果避免不了，就需要预先给出处理方式。要么catch，要么throws

---------------------- android培训、java培训、期待与您交流！ ----------------------详细请查看：http://edu.csdn.net/heima