黑马程序员-面向对象（下）--内部类和异常

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

1.内部类

1.1内部类定义

将一个类定义在另一个类的里面，对里面那个类就称为内部类（内置类，嵌套类）

1.2内部类访问特点

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

1.2.2当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中，可以直接建立内部类对象

a：当内部类为非静态时，其它外部类访问格式：外部类.内部类名 变量名 = new外部类().new内部类();

如：Outer.Inner oi = new Outer().new Inner();

b：当内部类为静态时，其它外部类访问格式：外部类.内部类名 变量名 = new外部类().内部类();
如：Outer.Inner oi = new Outer().Inner();
注：当内部类中定义了静态成员，该内部类必须是静态的。

1.3内部类的位置

1.3.1内部类定义在成员位置上

可以被priavate static成员修饰符修饰。

被static修饰的内部类只能访问外部类中的静态成员。

/* 	 * 内部类的访问规则 
	 * 1，内部类可以直接访问外部类中的成员，包括私有 
	 *     之所以可以直接访问外部类的成员，是因为内部类中持有了外部类的引用。外部类.this 
	 * 2，外部类要访问内部类，必须建立内部类对象。 
	 */  
	public class InnerClassDemo {  
	  
	    public static void main(String[] args) {  
	        // Outer o=new Outer();  
	        // o.method();  
	        // 直接访问内部类的成员。  
	        Outer.Iner in = new Outer().new Iner();  
	        in.function();  
	    }  
	}  
	  
	class Outer {  
	    private int x = 3;  
	  
	    // 内部类可以私有化  
	    class Iner {  
	        int x = 4;  
	  
	        public void function() {  
.	            int x = 6;  
	            System.out.println("inner" + x);// 这里打印6，内部有的不往外找了  
	            System.out.println("inner" + this.x);// 这里打印4;  
	            System.out.println("inner" + Outer.this.x);// 这里打印6  
	        }  
	    }  
	  
	    public void method() {  
	        Iner i = new Iner();  
	        i.function();  
	    }  
	}

1.3.2内部类可定义在局部位置上

可以 直接访问外部类中的成员

同时可以访问所在局部中的局部变量，但必须是被final修饰的

public class InnerClassDemo {  
 	    public static void main(String[] args) {  
 	         Outer o=new Outer();  
 	         o.method(7);  
 	         o.method(6);  
 	    }  
 	}  
 	/* 
 	 * 内部类定义在局部时 
 	 * 1，不可以被成员修饰符修饰 
 	 * 2，可以直接访问外部类中的成员，因为还持有外部类的引用。 
 	 *       但是不可以访问他所在的局部中的变量。只能访问被final修饰的局部变量 
 	 * 
 	 */  
 	class Outer {  
 	    int x = 3;  
 	    
 	    void method(final int a) {  
 	      final int y=4;  
 	        /** 
 	         * 此时不能被静态私有修饰，因为修饰符只能修饰成员，现在Inner在局部了，所以不能 
 	         * @author Administrator 
 	         */  
 	        class Inner {  
 	            /** 
 	             * 这里也不能用static修饰 
 	             */  
 	            void function() {  
 	                System.out.println(Outer.this.x);  
 	                System.out.println(y);//加final  
 	                System.out.println(a);//加final  
 	            }  
 	        }  
 	        new Inner().function();  
 	    }  
 	}

1.4匿名内部类

前提:内部类可以继承或实现一个外部类或者接口

格式：new 外部类名或者接口名(){覆盖类或者接口中的代码，(也可以自定义内容。)}

简单理解：就是建立一个带内容的外部类或者接口的子类匿名对象

public class InnerClassDemo {  
 	    public static void main(String[] args) {  
 	        new Outer().function();  
 	    }  
 	}  
 	  
 	class Outer {  
 	    int x = 3;  
 	  
 	    /* 
 	     * class Inner extends AbsDemo{ void show(){ System.out.println("show:"+x); 
 	     * } } 
 	     */  
 	    // 对上面的代码简化  
 	    public void function() {  
 	        // new Inner().show();  
 	        /* 
 	         * 整体是一个对象，是AbsDemo的一个子类对象，只有之类才能复写方法。 
 	         */  
 	        new AbsDemo() {// 匿名内部类  
 	  
 	            @Override  
 	            void show() {// 复写方法  
 	                // TODO Auto-generated method stub  
 	                System.out.println("x:" + x);  
 	            }  
 	  
 	        }.show();  
 	    }  
 	}  
 	  
 	abstract class AbsDemo {  
 	    abstract void show();  
 	} 

2.异常

2.1异常体系：

Throwable
       |--Error  通常出现量大问题如：运行的类不存在或者内存溢出等，不编写针对代码对其处理
       |--Exception 出现的一般情况异常，可以通过try catch finally处理
           |--RuntimeException 运行时异常（编译不检测）。在编译时，不需要处理，编译器不停止。该异常发生，建议不处理，让程序停止，需要对代码进行修正

2.2异常的处理方式

2.2.1通过throw throws抛出异常不做处理

throws用于标识函数暴露出的异常

throw用于抛出异常对象

throws与throw的区别：

thorws用在函数上，后面跟异常类名

throw用在函数内，后面跟异常对象

2.2.2通过try catch进行捕获处理

异常处理的语句：
try
{  
  需要被检测的代码；
}
catch
{
   处理异常的代码；
}
finally
{
   一定会执行的代码； 
}
注意 1.finaly中定义的通常是关闭资源代码，因为资源必须要释放。2.finally只有一种情况不会执行，当执行到System.exit(0)时，finally不会执行。如果在filnally前有return，也会先执行finally再执行return。3.一个try可以对应多个catch，如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面。（先抓小，后抓大）

2.3异常细节

1.RuntimeException以及其子类如果在函数中被throw抛出，可以不用在函数上声明。

2.一个方法被覆盖时，覆盖它的方法必须抛出相同的异常或异常的子类类，不能抛出比父类大的异常。

3.如果父类抛出多个异常，那么重写（覆盖）方法必须抛出那些异常的一个子集，不能抛出新的异常。如果父类或接口无异常抛出，子类覆盖时出现的异常，只能try，不能抛。

2.4自定义异常

定义类继承Exception或者RuntimeException。

1.为了让自定义类具备可抛性。2.让该类具备操作异常的共性方法。

当要定义自定义异常的信息时，可以使用父类已经定义好的功能。将异常信息传递给父类的构造函数。
class MyException extends Exception
{
MyException(String message)
{
     super(message);
  }
}

以毕老师讲课例子说明异常的一般使用：

  /*毕老师用电脑讲课 
 	开始思考上课中出现的问题：如：电脑蓝屏、电脑冒烟 
 	描述问题，封装成对象 
 	可当冒烟发生后，出现讲课无法继续。 
 	出现了讲师的问题：课程计划无法完成 
 	*/  
 	//自定义蓝屏异常  
 	class LanPingException extends Exception  
 	{  
 	    LanPingException(String messgae)  
 	    {  
 	        super(messgae);  
 	    }  
 	}  
 	//自定义冒烟异常  
 	class MaoYanException extends Exception  
 	{  
 	    MaoYanException(String messgae)  
 	    {  
 	        super(messgae);  
 	    }  
 	}  
 	//自定义课时无法继续异常  
 	class NoPlanExceptioon extends Exception  
 	{  
 	    NoPlanExceptioon(String messgae)  
 	    {  
 	        super(messgae);  
 	    }  
 	}  
 	  
 	class Computer  
 	{  
 	    //state为1时，正常；为2时，蓝屏；为3时，冒烟  
 	    private int state = 3;  
 	  
 	    public void run()throws LanPingException,MaoYanException  
 	    {  
 	        if (state ==2)  
 	            throw new LanPingException("蓝屏了");  
 	        if (state ==3)  
 	            throw new MaoYanException("冒烟了");  
 	  
 	        System.out.println("run");  
 	    }  
 	    //重启，恢复蓝屏异常  
 	    public void reset()  
 	    {  
 	        state = 1;  
 	        System.out.println("reset");  
 	    }  
 	}  
 	//创建教师类  
 	class Teacher  
 	{  
 	    private String name;  
 	    Computer comp;//讲课要用电脑，初始化老师时就产生这个  
 	    Teacher(String name)  
 	    {  
 	        this.name = name;  
 	        comp = new Computer();  
 	    }  
 	    //定义上课方法  
 	    public void prelect()throws NoPlanExceptioon//冒烟了就不要抛MaoYanException了，因为这个异常老师解决不了，直接抛出老师熟悉的异常  
 	    {  
 	        try  
 	        {  
 	            comp.run();  
 	        }  
 	        catch (LanPingException l)  
 	        {  
 	            comp.reset();  
 	        }  
 	        catch (MaoYanException m)//注意这里  
 	        {  
 	            test();  
 	            throw new NoPlanExceptioon("课时无法继续" + m.getMessage());//再次抛出异常，抛给熟悉该异常的人  
 	        }  
 	        System.out.println("讲课");  
 	    }  
 	    public void test()  
 	    {  
 	        System.out.println("练习");  
 	    }  
 	}  
 	//测试  
 	class ExceptionTest  
 	{  
 	    public static void main(String[] args)   
 	    {  
 	        Teacher t = new Teacher("毕老师");  
 	        try  
 	        {  
 	            t.prelect();  
 	        }  
 	        catch (NoPlanExceptioon n)  
 	        {  
 	            System.out.println(n.toString());  
 	            System.out.println("换老师或放假");  
 	        }  
 	          
 	    }  
 	}