黑马程序员技术交流社区

标题: 匿名内部类 异常 [打印本页]

作者: wws1214    时间: 2015-7-10 08:37
标题: 匿名内部类 异常
匿名内部类 异常

1、内部类的访问规则:
        1)内部类可以直接访问外部类中的成员,包括私有。
        之所以可以直接访问外部类中的成员,是因为内部类中持有了一个外部类的引用,格式 外部类名.this
        2)外部类要访问内部类,必须建立内部类的对象。


2、访问格式:
        当内部类定义在外部类的成员位置上,而且非私有,可以在外部其他类中。
        可以直接建立内部类对象。
   格式:
        创建内部类对象:外部类.内部类 wn=new 外部类().new 内部类();
        Outer.Inner OI=new Outer().new Inner();

3、当内部类在成员位置上,就可以被成员修饰符所修饰
   比如,private:将内部类在外部类中进行封装。
        static;内部类就具备static的特性。
        当内部类被static修饰后,只能直接访问外部类中的static成员。出现了访问局限。
        在外部其他类中,如何直接访问静态内部类的非静态成员呢?
   格式:
        new Outer.Inner().function();

        在外部其他类中,如何直接访问静态内部类的静态成员呢?
   格式:
        Outer.Inner.function();

4、注意:当内部类中定义了静态成员,该内部类必须是静态
         当外部类中的静态方法访问内部类时,内部类也必须是static的

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

   匿名内部类:
        1)匿名内部类其实就是内部类的简写格式
        2)定义匿名内部类的前题:
             内部类必须是继承一个或者实现接口
        3)匿名内部类的格式:new 父类或者接口(){定义子类的内容}
        4)其实匿名内部类就是一个匿名子类对象。而且这个对象是带内容的
实例
abstract class Demo
{
        abstract void show();
}
class Outer
{
        int x=3;
/*匿名及没有名字
        class Inner extends Demo
        {
                void show(){s.o.tln(x);}
        }
*/

        void function
        {
                //new Inner().show();
                //匿名内部类
                new Demo()  //注;Demo d = new Demo() { }
                {
                        void show(){s.o.tln(x);}
                }.show();//这里实现了调用
        }
}
--main
new Outer().function();


=>练习
abstract interface inter
{
        abstract void method();
}

class Test
{
        //此处补足代码,通过匿名内部类实现
}
class InnerClassTest
{
        public static void main(String[] args)
        {
                Test.function().method();
        }
}

解析:Test.function().method();
        1)Test.function():Test类中有一个静态的方法function.
        2).method():function这个方法运算后的结果是一个对象。而且是一个inter类型的对象。
        因为只有是inter类型的对象,才可以调用method方法

-----------------------------------
         
6、异常概况
        异常:就是程序在运行时出现不正常情况。
        异常由来:问题也是现实生活中一个具体的事物,也可以通过java的类的形式进行描述。并封装成对象。
                其实就是java对不正常情况进行描述后的对象体现。

对于问题的划分:两种:一种是严重的问题,一种是非严重的问题,

对于严重的:java通过Error类进行描述
        对于Error一般不编写针对性的代码对其进行处罚
对于非严重的:java通过Exception类进行描述
        对于Exception可以编写针对性的处理方法进行处理

        无论Error还是Exception都具有一些共性内容
        比如:不正常情况的信息,引发原因等。
       

7、ArithmeticException 运算异常

8、处理方式
   try   -》需要被检验的代码
   catch(Exception e)-》异常处理的代码
        {
                s.o.p(e.getMessage());
                s.o.p(e.toString());//异常名称、异常出现的位置
                e.printStackTrace();//异常名称、异常信息、异常出现的位置
        }
   finally  -》一定会执行的代码

9、throws Exception//在功能上通过throws的关键字声明了该功能有可能会出现的问题

10、对多异常的处理
        1)声明异常时,建议声明更为具体的异常。这样处理的可以更具体
        2)对方声明几个异常,就对应有几个继承关系。父类异常catch块放在最下面

11、自定义异常
        因为项目中会出现特有的问题,
        而这些问题并没被java所描述并封装对象.
        所以对于这些特有的问题可以按照java的对问题封装的思想,
        将特有的问题进行自定义的异常封装。

    需求:根据程序的要求,定义非法数据或其他方面未异常

        当在函数内部出现了throw抛出异常对象,那么就必须要给对应的处理动作。要么在内部try-catch处理
        要么在函数上声明让调用者处理
        一般情况下,函数内出现异常,函数上需要声明


        如何定义异常信息呢?
        因为父类中已经把异常信息的操作都完成了,
        所以子类只要在构造中,将异常信息传递给父类通过super语句
        那么就可以直接通过getMassage方法获得自定义的异常信息
       
        自定义异常:
        必须是自定义继承Exception。

        为什么要继承exception?
        异常体系有一个特点:因为异常类和异常对象都被抛出。
        他们都具备可抛型。这个可抛型是Throwable这个体系中独有特点

        只要throwable体系中的类和对象才可以被throws和throw操作



class FushuException extends Exception
{
        FushuException(String msg)
        {
                super(msg);
        }
}
class Demo
{
        int div(int a,int b) throws FushuException
        {
                if(b<0)
                        throw new FushuException();//通过throw关键字抛出一个自定义异常对象。
                return a/b;
        }       
}

13、throws和throw的区别
        1)位置上
        throws使用在函数上
        throw使用在函数内
        2)结构上
        throws后面跟着异常类。可以跟对个,用逗号隔开
        throw后跟着的异常对象

14、RuntimeException运行时异常
        如果在函数内抛出该异常,函数上可以不用声明,编译一样通过。
        如果在函数上声明了该异常,调用者可以不用进行处理。编译一样通过。

        之所以不用再函数声明,是因为不需要让调用者处理。
        当该异常发生,希望程序停止,因为在运行时,出现了无法继续运算的情况,希望停止程序后,对代码进行修正。

15、对于异常分两种
        1)编译时被检测的异常
       
        2)编译时不被检测的异常
       
作者: 耀阳圣尊    时间: 2015-7-10 09:18
总结的很不错{:3_64:}




欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2