4.类与异常

1：内部类
内部类分别有:1,成员内部类2,静态内部类3,局部内部类4,匿名内部类
(1)成员内部类
A：定义,:在一个外部类中有成员变量和成员方法,那么成员内部类就是把整个一个类当成了外部类的成员对待了
B: 访问方式:内部类访问外部类,内部类可以直接访问外部类,包括私有成员,因为内部类拥有外部类的引用是类名.this
   外部类访问内部类,外部类访问外部类的成员,必须要建立内部类的对象
   格式:外部类名.内部类名 = 外部类对象.内部类对象;
Outer.Inner oi = new Outer().new Inner();//outer代表外部类,Inner代表内部类
C:存放位置:在外部类里,在外部类的成员方法外.
D:修饰符:final、abstract、public、private、protected和static等,那么被static修饰的就是下面所说的
静态内部类.
(2)静态内部类
A：定义,就是在成员内部类的基础上加上static
B：格式:外部类名.内部类名 = 外部类名.内部类对象;
       Outer.Inner oi = new Outer.Inner();
        C:存放位置:和成员内部类一样,就是多了个static
(3)局部内部类
A：定义,在外部类成员方法中定义的内部类,他更像局部变量
B: 注意:
  第一:方法内部类只能在定义该内部类的方法内实例化，不可以在此方法外对其实例化。
  第二:方法内部类对象不能使用该内部类所在方法的非final局部变量。因为方法的局部变量位于栈上，
       只存在于该方法的生命期内。当一个方法结束，其栈结构被删除，局部变量成为历史。
       但是该方法结束之后，在方法内创建的内部类对象可能仍然存在于堆中！
       例如，如果对它的引用被传递到其他某些代码，并存储在一个成员变量内。
       正因为不能保证局部变量的存活期和方法内部类对象的一样长，所以内部类对象不能使用它们。
  第三:方法内部类的修饰符。与成员内部类不同，方法内部类更像一个局部变量。可以用于修饰方法内部类
       的只有final和abstract。
           第四:静态方法内的方法内部类。静态方法是没有this引用的，因此在静态方法内的内部类遭受同样的待遇，
       即：只能访问外部类的静态成员。
(4)匿名内部类：没有名字的内部类。它是内部类的简化写法。
A：前提：内部类可以继承或实现一个外部类或者接口。
B：格式为：new 外部类名或者接口名(){覆盖类或者接口中的代码，(也可以自定义内容。)}
C：简单理解：就是建立一个带内容的外部类或者接口的子类匿名对象。
D: a,继承式的匿名内部类
  b,接口式(也可以叫实现式的,名字无所谓)的匿名内部类
  c,参数式的匿名内部类
多加一句:我的理解,其实与其说是匿名内部类,我个人认为说是匿名对象更确切一点(个人理解,仅供参考);


interface Inter {
public abstract void show1();
public abstract void show2();
}

//有名字的内部类
class Outer {
public void method(){
class Inner implements Inter {
public void show1(){
System.out.println("show1");
}


public void show2(){
System.out.println("show1");
}
}
}
public void show() {
Inter in = new Inner();//父类引用指向子类对象
in.show1();
in.show2();


}
}


//匿名内部类(重点,android里面用的多,awt的监听器用的多)
class Outer {
public void method() {
//匿名内部类对象调用方法
new Inter() {
public void show1() {
System.out.println("show1");
}


public void show2() {
System.out.println("show1");
}
}.show1();


new Inter() {
public void show1() {
System.out.println("show1");
}


public void show2(){
System.out.println("show1");
}
}.show2();
//匿名内部类对象的另一种调用方式,父类引用指向子类对象
Inter in = new Inter() {
public void show1() {
System.out.println("show1");
}


public void show2() {
System.out.println("show1");
}
};
in.show1();
in.show2();
}
}


(5)什么时候使用匿名内部类呢？
A：通常在使用方法是接口类型参数，并该接口中的方法不超过三个时，
  可以将匿名内部类作为参数传递。


2：异常
(1)就是程序运行过程中，遇到了问题，这就叫异常。
(2)异常的体系
Throwable 其实应该分三种
Error
通常出现重大问题如：运行的类不存在或者内存溢出等。
   不编写针对代码对其处理。
Exception 
除了 RuntimeException 和其所有子类,其他所有的异常类都是在编译的时候必须要处理的
要么try,要么抛
RuntimeException
RuntimeException 和其所有的子类,都不会在编译的时候报异常,而是在运行时报异常,这时候我们
就需要回头看看我们的代码是否有问题,比如角标越界,空指针等


(3)Throwable
A：getMessage() ：返回此 throwable 的详细消息字符串。
class Throwable {
String detailMessage;
Throwable(){}


Throwable(String message) {
this.detailMessage = message;
}


public String getMessage() {
return detailMessage;
}
}
B：toString()：获取异常类名和异常信息，返回字符串。
C：printStackTrace()：获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。
(4)处理异常处理方式：
A：try...catch...finally
格式：
try {
需要检测的代码；
}
catch(异常类  变量) {
异常处理代码；
}
...
finally {
一定会执行的代码；//释放资源,但是1.7版本后不用finally也可以释放资源
}
可以有下面三种搭配形式：
**try...catch(...)
**try...finally
**try...catch(...)...finally


B：抛出 throws throw
throws:用于标识函数暴露出的异常。thorws用在函数上，后面跟异常类名(可以由多个，用,隔开)。


throw:用于抛出异常对象。throw用在函数内，后面跟异常对象。


C：到底用谁？
**你能处理，建议处理。try...catch...finally
**你处理不了，抛出。


D：自定义异常
自定义类继承Exception或者其子类(RuntimeException)


class MyException extends Exception{
MyException(){}


MyException(Stirng message){
super(message); //将信息传递给父类,调用父类封装好的构造方法
}
}


class Student {
public void giveAge(int age) throws MyException {
if(age>40 || age<0) {
//throw new MyExcetpion("建议不学了");
MyExcepiont my = new MyExcetpion("建议不学了");
throw my;
}
else {
System.out.println("可以学习Java");
}
}
}
E：RuntimeException和Exception
区别：RuntimeException就是要你改代码的。你可以不处理。