Java06-9 内部类

一、内部类：将java的类定义在其它类中
作用：
1.体现了封装性，内部类可以被private、static等修饰符修饰，
   外部类只能被public、final和abstract修饰，从访问的角度来看，并不能很好的隐藏该类；
2.解决java类单继承的问题，当外部类已经继承了某个类时，内部类还可以拥有自己的父类
 
二、内部类一共有四种：
1.成员内部类
2.静态内部类
3.局部内部类    （定义在方法里，出来方法体用不了）
4.匿名内部类
 
内部类对应的字节码文件的名称为 外部类类名$内部类类名.class
匿名内部类的字节码文件的名称为    外部类类名$序号.class

1.成员内部类
    在成员内部类中可以直接使用外部类中定义的变量和方法
    在成员内部类中可以定义构造方法
    在成员内部类中可以定义成员方法
    在成员内部类中可以定义静态常量
    在成员内部类中不能定义静态变量
    在成员内部类中不能定义静态方法
    在内部类中   外部类类名.this  就可以获取外部类对象
2.静态内部类
   2.1 不能直接使用外部类中的成员变量和成员方法
3.局部内部类
   3.1 由于是定义在方法中的，所以不能被static和访问控制符修饰
   3.2 局部内部类的只能在当前方法使用
   3.3 里面能定义的内容和成员内部类一样
4.匿名内部类，特点是没有类名
{}部分本质上是Object的一个子类
new A(){};    创建的对象是A的子类对象
eg：Object obj = new Object() 创建Object对象；
     Object obj = new Object(){}; 创建Object的子类对象
优势：提高了代码的可读性
缺陷：由于没有类名，匿名内部类中自己独有的变量和方法，无法在类外部使用
        
 一般使用在接口的实现

eg：

interface AA{    
}

class OuterClass extends Object    {    
    //（体现当外部类已继承某个类时，内部类还可以拥有自己的父类）
    class InT extends ArrayList{    
    }
    
    int x;
    static int y;
    
    public void test() {
        this.equals(0);        //（调用Object类）
        new InT().add(0);    //（调用内部类）
        AA x = aa();
    }
    public AA aa() {
        //final int a = 0;
        //3.局部内部类
        class Inner_2 implements AA{    //类里定义方法
            int k;
        //    static int l;    //报错
        }
        return new Inner_2();
    }
    public static void bb() {}    
}

//1.成员内部类
    class Inner{
        int a;
        int x;
        //在成员内部类中不能定义静态变量
    //    static int b;
        //在成员内部类中可以定义静态常量
        final static int c = 10;
        //在成员内部类中可以定义构造方法
        Inner(){    
        }
        //在成员内部类中可以定义成员方法
        public void method() {
            x = 10;        //（此处为内部类的x）
            //在内部类中    外部类类名.this 就可以获取外部类对象
            OuterClass.this.x = 100;    //（此处为外部类的x）
            y = 10;
            aa();
            bb();
        }
        //在成员内部类中不能定义静态方法
    /*    public static void ss() {        
        }
     */
    }
//2.静态内部类
    static class Inner_1{
        int w;
        static int r;
        Inner_1(){    
        }
        public void m() {
        //    x = 10;        //（报错，静态代码块中，不能引用非静态）
        }
        public static void s() {    
        }
    }

    
public class InnerClass {

    public static void main(String[] args) {
        //1.成员内部类要创建对象，通过外部类对象来操作
        OuterClass out = new OuterClass();
        OuterClass.Inner inner = out.new Inner();     //（定义成内部类，需要按照这样创建对象）
        
        //2.静态内部类实例化        new    外部类类名.内部类构造方法
        Inner_1 inner_1 = new OuterClass.Inner_1();
        
        //4.匿名内部类，特点是没有类名
        Object obj = new Object() {
            public void tt() {}        //（该方法不能在类外使用）
            @Override
            public boolean equals(Object obj) {
                // TODO Auto-generated method stub
                return super.equals(obj);
            }
        };        
    //    obj.tt();    //（error，编译期间未创建）
    }
}

class SubObject extends Object{
    @Override
    public boolean equals(Object obj) {
        // TODO Auto-generated method stub
        return super.equals(obj);
    }
}