黑马程序员_内部类与异常

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

                                                       内部类
将一个类定义在另一个类的里面，对里面那个 类就称为内部类（内置类，嵌套类）。
内部类的访问规则:
 1.内部类可以直接访问外部类中的成员.包括私有.
  之所以可以直接访问外部类中的成员.是因为内部类中持有了一个外部类的引用.格式: 外部类名.this
 2.外部类要访问内部类.必须要建立内部类对象.

访问格式:
 1.当内部类定义在外部类的成员位置上.而且非私有,可以在外部类其他类中
 可以直接建立内部类对象.
 格式
  外部类名.内部类名 变量名=new外部类对象.new内部类对象
  Outer.Inner in=new Outer().new Inner();
 2.当内部类在成员位置上,就可以被成员修饰符所修饰.
  比如,private:将内部类在外部类中进行封装.
   static:内部类就具备static的特性
   当内部类被static修饰后.只能直接访问外部类中的static成员.出来了访问局限.

   在外部类其它类中如何直接访问static内部类的非静态成员呢?
   new Outer.Inner().function();

   在外部其它类中,如何直接访问static内部类的静态成员呢?
   uter.Inner.function();

  注意:当内部类中定义了静态成员.该内不类必须是static.
*/

示例:

 

class Outer//外部类
{
 private int x=3;//外部成员变量
 class Inner//内部类
 {
  int x=4;//内部成员变量
  void function()
  {
   int x=5;//内部局部成员变量.
   System.out.println(Outer.this.x);
  }
 }
 //定义一个方法建立内部类对象.
 void method()
 {
  Inner in=new Inner();
  in.function();
 }
}
class InnerClassDemo
{
 public static void main(String[] args) 
 {
  Outer out = new Outer();
  out.method();
  /*
  Outer.Inner in=new Outer().new Inner();//直接建立内部类对象.
  in.function();//调用function()方法
  */
 }
}

内部类定义在局部时，
 1，不可以被成员修饰符修饰
 2，可以直接访问外部类中的成员，因为还持有外部类中的引用。
  但是不可以访问它所在的局部中的变量。只能访问被final修饰的局部变量。

class Outer//外部类
{
 int x = 3;//成员变量
 void method(final int a)
 {
  final int y = 4;//被final修饰的常量
  class Inner//局部内部类
  {
   void function()
   {
    //只能方法被final修饰的常量因为.
    //因为一常量在常量池比方法存在的时间长.
    System.out.println(y);
   }
  }
  //如果放在上面编译失败.因为虚拟机还不知道有内部类Inner呢.
  new Inner().function();
 }
}
class  InnerClassDemo3
{
 public static void main(String[] args) 
 {
  Outer out = new Outer();
  out.method(7);
  out.method(8);
 }
} 

匿名内部类:
1，匿名内部类其实就是内部类的简写格式。
2，定义匿名内部类的前提：
 内部类必须是继承一个类或者实现接口。
3，匿名内部类的格式：  new 父类或者接口(){定义子类的内容}
4，其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。 可以理解为带内容的对象。
5，匿名内部类中定义的方法最好不要超过3个。
示例:

abstract class AbsDemo//父类
{
 abstract void show(); 
}
class Outer外部类
{
 int x = 3;
 public void function()
 {
  //匿名内部类
  AbsDemo d = new AbsDemo()
  {
   int num = 9;
   void show()
   {
    System.out.println("num==="+num);
   }
   void abc()
   {
    System.out.println("haha");
   }
  };
  d.show();
  //d.abc();//编译失败;
 }
}
class InnerClassDemo4 
{
 public static void main(String[] args) 
 {
  new Outer().function();
 }
}

 

异常：

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

异常由来：

问题也是现实生活中一个具体的事物，也可以通过java的类的形式进行描述。并封装成对象。
   其实就是java对不正常情况进行描述后的对象体现。
对于问题的划分：两种：一种是严重的问题，一种非严重的问题。
对于严重的，java通过Error类进行描述。
 对于Error一般不编写针对性的代码对其进行处理。
对与非严重的，java通过Exception类进行描述。
 对于Exception可以使用针对性的处理方式进行处理。
无论Error或者Exception都具有一些共性内容。
比如：不正常情况的信息，引发原因等。
异常体系：
 Throwable
  |--Error
  |--Exception
   |--RuntimeException

异常体系的特点：

异常体系中的所有类以及建立的对象都具备可抛性。
    也就是说可以被throw和throws关键字所操作。
    只有异常体系具备这个特点。

异常有两种：
 1.编译时被检测异常
  该异常在编译时，如果没有处理(没有抛也没有try)，编译失败。
  该异常被标识，代表这可以被处理。
 2.运行时异常(编译时不检测)
  在编译时，不需要处理，编译器不检查。
  该异常的发生，建议不处理，让程序停止。需要对代码进行修正。

异常处理语句：
 try
 {
  需要被检测的代码；
 }
 catch ()
 {
  处理异常的代码；
 }
 finally
 {
  一定会执行的代码；
 }
有三个结合格式：
1. try
 {
  
 }
 catch ()
 {

 }
2. try
 {
  
 }
 finally
 {
 
 }
3. try
 {
  
 }
 catch ()
 {
 }
 finally
 {
 
 }
注意：
 1，finally中定义的通常是 关闭资源代码。因为资源必须释放。
 2，finally只有一种情况不会执行。当执行到System.exit(0);fianlly不会执行。
异常的处理:
java 提供了特有的语句进行处理:
 try
 {
  需要被检测的代码；
 }
 catch(异常类 变量)
 {
  处理异常的代码；(处理方式)
 }
 finally
 {
  一定会执行的语句；
 }
对捕获到的异常对象进行常见方法操作:
  String getMessage()：获取异常信息。
 在函数上声明异常。
 便于提高安全性，让调用出进行处理。不处理编译失败。
 对多异常的处理:
 1，声明异常时，建议声明更为具体的异常。这样处理的可以更具体。
 2，对方声明几个异常，就对应有几个catch块。不要定义多余的catch块。
  如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面。
 建立在进行catch处理时，catch中一定要定义具体处理方式。
 不要简单定义一句 e.printStackTrace(),
 也不要简单的就书写一条输出语句。

自定义异常:
 因为项目中会出现特有的问题，
 而这些问题并未被java所描述并封装对象。
 所以对于这些特有的问题可以按照java的对问题封装的思想。
 将特有的问题。进行自定义的异常封装。
 当在函数内部出现了throw抛出异常对象，那么就必须要给对应的处理动作。
 要么在内部try catch处理。
 要么在函数上声明让调用者处理。
 一般情况在，函数内出现异常，函数上需要声明。
 发现打印的结果中只有异常的名称，却没有异常的信息。
 因为自定义的异常并未定义信息。
如何定义异常信息呢？
 因为父类中已经把异常信息的操作都完成了。
 所以子类只要在构造时，将异常信息传递给父类通过super语句。
 那么就可以直接通过getMessage方法获取自定义的异常信息。

自定义异常：
 必须是自定义类继承Exception。
继承Exception原因：
 异常体系有一个特点：因为异常类和异常对象都被抛出。
 他们都具备可抛性。这个可抛性是Throwable这个体系中独有特点。
 只有这个体系中的类和对象才可以被throws和throw操作。
throw和throws的用法：
 throw定义在函数内，用于抛出异常对象。
 throws定义在函数上，用于抛出异常类，可以抛出多个用逗号隔开。
 当函数内容有throw抛出异常对象，并未进行try处理。必须要在函数上声明，都在编译失败。
 注意，RuntimeException除外。也就说，函数内如果抛出的RuntimeExcpetion异常，函数上可以不用声明。
异常的好处：
 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();
  }
异常示例:
毕老师用电脑上课

假如出现了问题.比如冒烟.蓝屏.

class LanPingException extends Exception//自定义蓝屏异常.因为可以处理集成Exception
{
 LanPingException(String Message)//覆盖父类的方法
 {
  super(Message);//因为父类有赋值方法.直接用就OK了
 }
}
class MaoYanException extends Exception//自定义冒烟
{
 MaoYanException(String Message)
 {
  super(Message);
 }
}
class NoPlanException extends Exception//课时计划完不成.讲师的异常
{
 NoPlanException(String Message)
 {
  super(Message);
 }
}
class Computer//电脑类
{
 private int count=3;//定义一个变量为1的时候正常.2的时候代表蓝屏.3.冒烟
 void run()throws LanPingException,MaoYanException//run电脑启动
 {
  if(count==2)
   throw new LanPingException("蓝屏");//抛出蓝屏异常,不在这里处理是因为电脑自身处理不了
  if(count==3)
   throw new MaoYanException("冒烟");

  System.out.println("电脑启动");
 }
 void reset()//电脑重启.重启之后count变量为1.电脑正常运行
 {
  System.out.println("电脑从启");
  count=1;
 }
}
class Teachar//讲师类.毕老师
{
 private String name;//将名字设为私有
 private Computer comp;//电脑类私有
 Teachar(String name)
 {
  this.name=name;//用构造函数.将name和电脑computer初始化
  comp=new Computer();
 }

 void prelect()throws NoPlanException
 {
  try//因为电脑处理不了异常.所以在这里try
  {
   comp.run();
  }
  catch (LanPingException e)
  {
   comp.reset();//蓝屏之后调用从启方法
  }
  catch (MaoYanException e)
  {
   test();//冒烟之后启动自习.因为解决不了.所以抛给张老师
   throw new NoPlanException("课程无法继续"+e.getMessage());
  }

  System.out.println("讲课");
 }
 void test()
 {
  System.out.println("自习");
 }
}
class ExceptionTest
{
 public static void main(String[] args)//主函数.也代表Boss
 {
  Teachar t=new Teachar("毕老师");//创建Teachar对象并让毕老师讲课
  try
  {
   t.prelect();//因为电脑冒烟了.毕老师蒙圈了.问题交给boss张老师来处理
  }
  catch (NoPlanException e)
  {
   System.out.println(e.toString());
   System.out.println("换老师或者放假");
  }
 
 }
}

示例2:
/*
有一个圆形和长方形。
都可以获取面积。对于面积如果出现非法的数值，视为是获取面积出现问题。
问题通过异常来表示。
现有对这个程序进行基本设计。
*/

class NoValueException extends RuntimeException//自定义异常继承了并RuntimeException
{
 NoValueException(String message)
 {
  super(message);
 }
}

interface Shape//定义一个接口.共性方法面积抽象的
{
 void getArea();
}
class Rec implements Shape//长方形实现Shape接口
{
 private int len,wid;//将长宽私有化
 Rec(int len ,int wid)//用构造函数将长宽初始化.因为继承了RuntimeException所以在方法上不用抛了
 {
  if(len<=0 || wid<=0)//判断长和宽是否出现负数如果是.就抛NoValueException异常
   throw new NoValueException("出现非法值");
  this.len = len;//
  this.wid = wid;
 }
 public void getArea()//覆盖接口中的方法求面积 长乘宽
 {
  System.out.println(len*wid);
 }
}
class Circle implements Shape//圆
{
 private int radius;
 public static final double PI = 3.14;//给园定义一个final修饰的常量

 Circle(int radius)//给圆进行初始化.并且判断是否半径为负数
 {
  if(radius<=0)
   throw new NoValueException("非法");
  this.radius = radius;
 }
 public void getArea()//覆盖接口的方法求面积.
 {
  System.out.println(radius*radius*PI);
 }
}
class  ExceptionTest1
{
 public static void main(String[] args) 
 {  
  Rec r = new Rec(3,4);//创建Rec对象
  r.getArea();//求面积方法
  Circle c = new Circle(-8);
  System.out.println("over"); 
 }
}

 

 

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