黑马程序员——内部类，异常，Object类

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-

一、内部类(Inner Class)
1. 概述

　　内部类(内置类,嵌套类)( inner class )是在其他类中的类。
　　编译时编译器生成 xxxxx$1之类的名字。
　　访问特点: 内部类可以直接访问外部类中的成员,包括私有成员。 而外部类要访问内部类中的成员必须要建立内部类的对象。
如果内部类中有与外部类同名的字段或方法，则可以用：外部类名.this.字段及方法。
　　用static修饰内部类，表明该内部类实际是一种外部类，因为它与外部类的实例无关。有人认为static的类是嵌套类（nested class），不是内部类inner class。
　　static类在使用时：
　　1）实例化static类时，在new前面不需要用对象实例变量；
　　2）static类中不能访问其外部类的非static的字段及方法，只能够访问static成员。
　　3）static方法中不能访问非static的域及方法，也不能够不带前缀地new 一个非static的内部类。

2. 局部类（local class）

　　局部类：方法中定义的类，也称为“方法中的内部类”。
　　1）同局部变量一样，方法中的内部类不能够用 public, private, protected, static修饰，但可以被final或者abstract修饰。
　　2）可以访问其外部类的成员。
　　3）不能够访问该方法的局部变量，除非是final局部变量。

/* * 运行结果：show run 1 ...3           show run 2 ...4           show run 3 ...4           show ... 9,4 */class Outer{    private int num = 3;    private static int num2 = 4;    // 非静态内部类    class Inner{        void show(){            System.out.println("show run 1 ..."+num);        }    }    //静态内部类    static class Inner2{        //非静态方法        void show(){            System.out.println("show run 2 ..."+num2);        }        //静态方法        static void show2(){            System.out.println("show run 3 ..."+num2);        }    }    //外部类的方法    void method(final int y){        final int x = 9;        //局部类，可以访问外部类中的成员，也可以访问局部类中的用final修饰的局部变量        class Inner3{            void show3(){                System.out.println("show ... "+x+","+y);            }        }        Inner3 in3 = new Inner3();        in3.show3();    }}public class InnerClassDemo {    public static void main(String[] args){        //直接访问外部类中的内部类的成员        Outer.Inner in = new Outer().new Inner();        in.show();        //被static修饰的内部类只能访问外部类的静态成员        Outer.Inner2 in2 = new Outer.Inner2();        in2.show();        //可以不用创建内部类对象，直接调用静态内部类的静态方法        Outer.Inner2.show2();        //        new Outer().method(4);    }}

3. 匿名类( anonymous class)

　　匿名类( anonymous class)是一种特殊的内部类，它没有类名，因此在定义类的同时就生成该对象的一个实例。
　　匿名类的使用：
　　1）不取名字，直接用其父类或接口的名字。也就是说，该类是父类的子类，或者实现了一个接口。
　　2）类定义的同时就创建实例，格式:
new 外部类名或接口名（）{覆盖类或者接口中的代码,(也可以自定义内容。)}
　　3）在构造对象时使用父类构造方法不能够定义构造方法，因为它没有名字。如果new对象时，要带参数，则使用父类的构造方法。
　　4）通常使用方法是接口类型参数,并且该接口中的方法不超过三个,可以将匿名内部类作为参数传递。

abstract class Demo{    abstract void show();}class Outer{    int num = 4;    void method(){        //匿名内部类        new Demo(){            void show(){                System.out.println("show ..."+num);            }        }.show();    }}public class AnonymousClassDemo {    public static void main(String[] args){        new Outer().method();    }}

二、异常（Exception）
1. 概述

　　异常（exception ) 又称为例外、差错、违例，对应着Java运行错误处理机制。
　　在一些传统的语言（如C语言）中用if语句来判断是否出现了例外或全程变量ErrNo，但这有几个缺点：a.正常处理与异常处理的代码同样处理，可读性（readability）差；b.每次调用一个方法时都进行错误检查，可维护性（ maintainability ）差；c.错误由谁处理职责不清。
　　Java中处理异常：
　　1）抛出(throw)异常；
　　2）运行时系统在调用栈中查找：从生成异常的方法开始进行回溯，直到找到；
　　3）捕获(catch) 异常的代码。
抛出异常：throw 异常对象；
捕获异常：
　　 try{
　　　　需要被检测异常的代码。
　　}catch(异常类名 异常形式参数名){
　　　　异常处理语句组；
　　}catch(异常类名 异常形式参数名){
　　　　异常处理语句组；
　　}finally{
　　　　异常处理语句组；
　　}
其中，catch语句可以0至多个，可以没有finally语句。try是一个独立的代码块,在其中定义的变量只在该变量块中有效。如果在try以外继续使用,需要在try外建立引用,在try中对其进行初始化。IO,Socket就会遇到。

2.异常类

Java中的异常分为Error(JVM的错误)和 Exception两类。一般所说的异常是指Exception及其子类。异常类是描述不正常情况的类。

　
构造方法：
• public Exception()；
• public Exception(String message)；
• Exception(String message, Throwable cause) ;
方法：
• getMessage()：获取异常信息,返回字符串。
• toString():获取异常类名和异常信息,返回字符串。
• getCause()：返回此异常的原因（尝试加载类时发生错误引发的异常；否则返回 null）
• printStackTrace() ：获取异常类名和异常信息,以及异常出现在程序中的位置,返回值void。
　　Exception分两种：
　　1）编译时被检测异常：即受检的异常（checked Exception)，要求明确进行语法处理，要么捕（catch），要么抛（throws）（在方法的签名后面用throws xxxx来声明）。
　　2）编译时不检测异常(运行时异常）：RuntimeException及其子类，可以不明确处理。
　　在子类中，如果要覆盖父类的一个方法，若父类中的方法声明了throws异常，则子类的方法也可以throws异常，可以抛出子类异常（更具体的异常），但不能抛出更一般的异常。
　　创建用户自定义异常：
　　1) 继承自Exception类或某个子Exception类
　　2) 定义属性和方法，或重载父类的方法
　　对于异常，不仅要进行捕获处理，有时候还需要将此异常进一步传递给调用者，以便让调用者也能感受到这种异常。这时可以在catch语句块或finally语句块中采取以下三种方式：
　　1) 将当前捕获的异常再次抛出： throw e；
　　2) 重新生成一个异常并抛出，如： throw new Exception(“some message”)；
　　3) 重新生成并抛出一个包含了当前异常的信息新异常，如：
throw new Exception(“some message”，e)；可用e.getCause() 来得到内部异常。

throws和throw的区别: 

区别 throws throw 用法 标识函数暴露出的异常类,并且可以抛出多个,用逗号分隔 抛出异常对象 标识位置 在函数上,后面跟异常类名 在函数内,后面跟异常对象 使用情形 需要把出现的问题暴露出来让调用者去处理 在功能方法内部出现某种情况,程序不能继续运行,需要进行跳转时

3.异常处理的原则

1）函数内容如果抛出需要检测的异常,那么函数上必须要声明。 否则,必须在函数内用try/catch捕捉,否则编译失败。
2）如果调用到了声明异常的函数,要么try/catch,要么throws,否则编译失败。
3）什么时候catch,什么时候throws呢? 功能内容可以解决,用catch。 解决不了,用throws告诉调用者,由调用者解决。
4）多异常的处理：
　　1）子类异常要排在父类异常的前面；
　　2）finally语句无论是否有异常都要执行，即使其中有break,return等语句；finally只有一种情况不会执行：当执行到System.exit(0);fianlly不会执行。
　　3）在编译时，finally部分代码生成了多遍；

三、Object类

　　Object类是所有类的直接或间接父类，让所有的类有了一致性。
　　1.Object类的常用方法：
　　1）equals()
　　“==”与equals的区别: “==”以及Object类的equals方法默认都是根据对象的哈希值判断两个对象是否相等。”==”基本类型(byte,short,char,int,long,float,double,boolean)比较的是值，引用类型比较的是引用类型的地址值。equals():比较引用类型，默认比较的是引用类型的地址值是否相同。如果类重写了该方法，那就得按照重写后的规则进行比较。如String,Integer,Date在这些类当中equals有其自身的实现，而不再是比较类在堆内存中的存放地址了。
　　2)getClass()
　　getClass( )方法是final方法，它不能被重载。它返回一个对象在运行时所对应的类的表示。
　　3）toString()
　　toString( )方法用来返回对象的字符串表示。默认返回的内容是“对象所属的类名+@+对象的哈希值(十六进制)”。通过重载toString ( )方法，可以适当地显示对象的信息以进行调试。
　　4)finalize()
　　用于在垃圾收集前清除对象。
　　5)notify()
　　6)notifyAll()
　　7)wait()

class Person{    private int age;    Person(int age){        this.age = age;    }    public int hashCode(){        return age;    }}class Demo1{}public class ObjectDemo {    public static void main(String[] args){        Person p1 = new Person(20);        Person p2 = new Person(20);        Person p3 = p1;        Demo1 d = new Demo1();        System.out.println(p1 == p2); //false        System.out.println(p1.equals(p2)); //false        System.out.println(p1.equals(p3)); //true        System.out.println(p1.equals(d)); //false        System.out.println(p1);        System.out.println(p1.getClass().getName()+"@"+Integer.toHexString(p1.hashCode()));    }}