黑马程序员_内部类，异常，自定义异常，RunTimeException, throw和throws

---------------------- <ahref="http://edu.csdn.net"target="blank">ASP.Net+Android+IOS开发</a>、<ahref="http://edu.csdn.net"target="blank">.Net培训</a>、期待与您交流！ ----------------------

                                     黑马程序员_内部类，异常，自定义异常，RunTimeException, throw和throws

内部类：

/*

1内部类可以直接访问外部类的成员，包括私有

         之所以可以直接访问外部类中的成员，是因为内部类中持有一个外部类的引用，格式：外部类名.this

2外部类要访问内部类，必须建立内部类对象。

 

访问格式：

1当内部类定义在外部类的成员位置上，而且非私有，可以在外部类其他类中

可以直接建立内部对象

格式：

         外部类名.内部类名 变量名 =外部类对象.内部类对象；

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

2当内部类在成员位置上，就可以被成员修饰符修饰

         比如private 将内部类在外部类中进行封装

                   static：内部类就具备static的特性

         当内部类被static修饰后，只能直接访问外部类中的static成员

 

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

         newOuter.Inner().function();

         在外部内中,如何 直接访问static内部类中的静态成员？

         Outer.Inner().function();

 

         注意：

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

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

 

当描述事物时，事物的内部还有事物，该事物用内部类来描述

因为内部事物在使用外部事物的内容。

 

class Body

{

private classHeart

         {

         }

         publicvoid show()

         {       

                   newHeart()

         }

}

*/

class Outer

{

         privateint x= 3;

         privateclass Inner//内部类可以被私有

         {

                   //intx =4;

                   voidfunction()

                   {

                            //intx = 6;

                   System.out.println("innner:"+Outer.this.x);

                   }

         }

         voidmethod()

         {

                   Innerin = new Inner();

                   in.function();

         }

}

class InnerClassDemo

{

         publicstatic void main(String[] args)

         {

                   Outerout = new Outer();

                   out.method();

 

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

                   //Outer.Innerin = new Outer().new Inner();

                   //in.function();

         }

}

 

 

 

/*

内部类定义在局部，

1不可以被成员修饰符修饰

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

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

*/

class Outer

{

         intx = 3;

         voidmethod(final int a)

         {

                   finalint y = 4;//内部类

                   classInner//内部类在局部时，不能私有和静态

                   {

                            voidfunction()

                            {

                                     System.out.println(a);

                            }

                   }

                   newInner().function();//非静态必须要对象

         }

}

 

class InnerClassDemo3

{

         publicstatic void main(String[] args)

         {

                   Outerout =new Outer();

out.method(7);//虽然a 被最终定为7  但是是在栈内进行的 当运行完后会被释放所以下面又可以赋值为8

         out.method(8);

         }

}

 

 

异常

/*

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

 

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

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

 

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

对于严重的，java通过Error类进行描述

         对于Error一般不编写针对性的代码对其进行处理

对于不严重的，java通过Exception类进行描述

         对于Exception可以通过使用针对的处理方式进行处理

无论Error或者Exception都具有一些共性内容

比如：不正常情况的信息，引发原因等

Throwable

         |--Error

         |--Exception

 

2异常的处理

java提供了特有的语句进行处理

try

{

         需要被检测的代码

}

catch(异常类 变量)

{

处理异常代码(处理代码)

}

finally

{

一定会执行的语句

}

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

String getMessage():获取异常信息

 

在函数上声明异常

便于提高安全性，让调出来进行处理。不处理编译失败。

 

对多异常的处理。

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

2对方声明几个异常就对应有几个catch块

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

 

建议在进行catch处理时，catch中一定要定义具体处理方式

不要简单定义一句：e.printStack

*/

class Demo

{

         intdiv(int a,int  b)throws Exception//在功能上通过throws的关键字声明了一个功能有可能会出现问题

         {

                   returna/b;

         }

}

class ExceptionDemo

{

         publicstatic void main(String[] args)

         {

                   Demod = new Demo();

                   try

                   {

                            intx = d.div(4,0);

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

                   }

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

                   {

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

                            System.out.println(e.getMessage());//  /by zreo

                            System.out.println(e.toString());//异常名称异常信息

                            e.printStackTrace();//异常名称  异常信息   异常位置

                                                                           //其实jvm默认的异常处理机制，就是在 调用printStackTrace

 

                   }

                            System.out.println("over");

         }

}

/*

因为项目中会出现特有的问题

而这些问题并未被java所描述并封装对象

所以对于这些特有的问题可以按照java的对问题封装的思想

将特有的问题，进行自定义的异常封

 

*/

class Demo

{

         intdiv(int a,int  b)throws Exception//在功能上通过thorws的关键字声明了一个功能有可能会出现问题

         {

                   returna/b;

         }

}

class ExceptionDemo1

{

         publicstatic void main(String[] args)//throws Exception

         {

                   Demod = new Demo();

                   try

                   {

                            intx = d.div(4,0);

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

                   }

                   catch(Exception e)

                   {

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

                   }

                            System.out.println("over");

         }

}

/*

因为项目中会出现特有的问题

而这些问题并未被java所描述并封装对象

所以对于这些特有的问题可以按照java的对问题封装的思想

将特有的问题，进行自定义的异常封装

 

自定义异常

需求：

 

 

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

要么在内部try catch处理

要么在函数上声明让调用者处理

 

一般情况在，函数内出现异常，函数上需要声明

 

发现打印的结果中只有异常名称，却没有异常信息

因为自定义的异常并未定义信息

 

如何定义异常信息？

因为父类中只已经把异常信息操作都完成了

所以子类只要在构造时,将异常信息传递给父类通过super语句

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

 

自定义异常：

必须是自定义类继承Exception

 

继承Exception原因

异常体系有一个特点：因为异常类和异常对象都被抛出

他们都具备可抛性。这个可抛性是Throwable这个体系中独有特点

只有这个体系中的类和对象才可以被throws和throw操作

 

throws和throw的区别

throws使用在函数上

throw使用在函数内

 

throws后面跟的是异常类。可以跟多个。用逗号隔开

*/

 

class FuShuException extends Exception

{

         privateint value;

         FuShuException()

         {

                   super();

         }

         FuShuException(Stringmsg)

         {

                   super(msg);

         }

         FuShuException(Stringmsg,int value)

         {

                   super(msg);

                   this.value= value;

         }

         publicint getValue()

         {

                   returnvalue;

         }

}

class Demo

{

         intdiv(int a,int  b)

         {       

                   if(b<0)

                            thrownew FuShuException("出现了除数是负数的情况—————— / by fushu",b);//手动通过throw关键字抛出一个自定义异常对象。

 

                   returna/b;

         }

}

class ExceptionDemo3

{

         publicstatic void main(String[] args)

         {

                   Demod = new Demo();

                  

                            intx = d.div(4,1);

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

                  

                           

                            System.out.println("over");

         }

}

RunTimeException

/*

Exception中有一个特殊的子类异常RuntimeException   运行异常

 

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

 

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

 

之所以不用在函数上声明，是因为不需要调用者处理

当该异常发生，希望程序停止。因为在运行时，出现了无法继续运算的情况，希望停止程序后

对代码进行修正

 

 

自定义异常时：如果该异常的发生，无法再继续进行运算

就让自定义异常继续RunTimeException

 

 

 

对于异常份两种

1编译时被检测的异常

2编译时不被检测的异常（运行异常 RunTimeException以及其子类）

 

*/

class FuShuException extendsRunTimeException

{

         FuShuException(Stringmsg)

         {

                   super(msg);

         }

}

class Demo

{

         intdiv(int a,int b)//throws ArithmeticException

         {

         if(b<0)

                   thrownew FuShuException("出现了除数为负数了");

         if(b==0)

                   thrownew ArithmeticException("被零除啦");

         }

} 

class ExceptionDemo4

{

         publicstatic void main(String[] args)

         {

                   Demod = new Dmeo();

        

         }

}

 

 

 

 

 

 

 

 

 

 

 

---------------------- <ahref="http://edu.csdn.net"target="blank">ASP.Net+Android+IOS开发</a>、<ahref="http://edu.csdn.net"target="blank">.Net培训</a>、期待与您交流！ ----------------------