day09内部类 异常

内部类:当描述事物时,事物的内部类还有事务,该事物用内部类来描述。

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

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

    在外部其他类中,如何直接访问static内部类的静态成员呢
    outer.inner.function();

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

class outer
{
    int x=3;
    
    static class inter
    {
        static void function()
        {
            System.out.println("inner ;"+outer.this.x);
        }
    }
    void method()
    {
        inter in = new inter;
        in.function();
    }
}


class test 
{
    public static void main(String[] args)
    {
        outer out = new outer();
        out.method();
        //直接访问内部类中的成员;
        //outer.inner in = new outer().new inner();
        //in.function();
    }
}

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

 

class outer
{
    int x=3;
    
    
    void method()
    {
        final int x=34;
        class inter
        {    
             void function()
            {
                System.out.println("inner ;"+x);
            }
        new inner().function();
        }
    }
}

 


匿名内部类;
1,匿名内部类其实就是内部类的简写格式。
2,定义匿名内部类的前提
内部类必须是继承一个类或者实现一个接口
3,匿名内部类的格式: new 父类或者接口(){定义子类的内容}
4,其实匿名内部类就是一个匿名子类对象,而且这个对象有点胖,可以理解为带内容的对象

 

abstract class AbsDemo
{
    abstract void show();
}

class outer
{
    int x=2;
    
    /*
    class inner extends AbsDemo 
    {
        void show()
        {
            System.out.println("show :"+x);
        }
    }
    */
    
    public void function()
    {
        //new inner().show();
        
        new AbsDemo()//匿名类  
        {
            void show()
            {        
                System.out.println("show  :"+x);
            }
        }.show();
    }
}

 

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

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

对于严重的,java通过error类进行描述。
对于error一般不编写针对性的代码对其进行处理

对于非严重的,java通过exception类进行描述
对于exception可以通过针对性的处理方式进行处理。

无论error后者exception都具有一些共性内容。
比如不正常情况的信息,引发原因等。

Throwable
|--Error

|--Exception

2异常的处理

java提高了特有的语句进行处理。
try
{
需要被检测的代码
}
catch(异常类 变量)
{
处理异常代码:(处理方式)
}
finally
{
一定会执行的语句
}

class Demo
{
    int div(int a,int b)
    {
        return a/b;
    }
}

class ExceptionDemo
{
    public static void main(String[] args)
    {
        Demo d = new Demo();
        try
        {
            int x = d.div(4,0);
            System.out.println("x="+x);
        }
        catch(Exception e)
        {    
            System.out.println("除零了");
        }
        System.out.println("over");
    }
}

 对于多异常的处理:
1,声明异常时,建议声明更为具体的异常,这样处理可以更为具体
2,对方声明几个异常,就对应几个catch快
    如果多个catch块中的异常出现继承关系,父类异常catch块放在最下面。

class Demo
{
    int div(int a,int b)throws ArithmeticException,ArrayIndexOutOfBoundsException
    {
        int[] arr = new int[a];
        System.out.println(arr[4]);
        return a/b;
    }
}
class ExceptionDemo
{
    public static void main(String[] args)
    {
        Demo d = new Demo();
        try
        {
            int x = d.div(4,0);
            System.out.println("x="+x);
        }
        
        catch(ArithmeticException e)
        {    
            System.out.println(e.toString());
        }
        catch(ArrayIndexOutOfBoundsException e)
        {    
            System.out.println(e.toString());
        }
        catch(Exception e)
        {    
            System.out.println(e.toString());
        }
        System.out.println("over");
    }
}

 自定义异常;

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

自定义异常:
必须是自定义类继承Exception。

/*
需求:在本程序中,对于除数是-1,也视为是错误的是无法进行运算的。
那么就需要对这个问题进行自定义描述、

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

一般情况在,函数内出现异常,函数上需要声明。
*/
class fushuException extends Exception
{
    fushuException()
    {
        super();
    }    
    
    fushuException(String msg)
    {
        super(msg);
    }
}


class Demo
{
    int div(int a,int b)throws fushuException
    {
        if(b<0)
        throw new fushuException("dd");//手动通过throw关键字抛出一个自定义异常对象。
        return a/b;
    }
}

class test
{
     public static void main(String[] args)
    {
        Demo d = new Demo();
        try
        {
            int x = d.div(4,-3);
            System.out.println("x="+x);
        }

 继承Exception原因:
异常体系有一个特点:因为异常类和异常对象都被抛出、
他们都具备可抛性,这个可泡性是Throwable这个体系中情有独钟的特点。

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

throw和throws的区别:
1,throws使用在函数上。 throw使用在函数内。
2,throws后面跟的异常类,可以跟多个,用逗号隔开。
throw 后跟的是异常对象。



Excepion 中有一个特殊的子类异常RuntimeException运行时异常。

如果函数内容抛出异常,函数上可以不用声明,编译一样通过。

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

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

自定义异常时:如果该异常的发生,无法再继续进行运算,
就让自定义异常继承RuntimeException。

对于异常分两种:
1,编译时被检测的异常。

2,编译时不被检测的异常(运行时异常。RuntimeException以及其子类)


finally代码块:定义一定执行的代码。
主要释放资源。
异常在子类覆盖中的体现:
1,子类再覆盖父类时,如果父类的方法抛出异常,那么子类的覆盖方法,只能抛出父类的异常或者该异常的子类或者不抛。
2,如果父类方法抛出多个异常,那么子类在覆盖该方法是,只能抛出父类异常的子集。
3,如果父类或者接口的方法中没有异常抛出,那么子类再覆盖方法是,也不可以抛出异常。
    如果子类方法发生异常。就必须要进行try处理,绝对不能抛。

posted on 2016-06-28 09:10  青春的梦想付诸行动  阅读(255)  评论(0编辑  收藏  举报

导航