内部类

含义：定义在类内部的类。

分类：成员内部类（静态、非静态）、匿名内部类、局部内部类（少见，了解即可）。

特点：四个修饰符随意用，class文件是“外部类￥内部类.class”。

成员内部类

位置：类中方法外。

A:非静态内部类

特性：内部类可直接访问外部类成员，外部类不可直接访问内部类非静态成员。

不能有静态方法/代码块/属性。

外部类静态方法/代码块不可访问非静态内部类。

实例：

package com.itcode.demo2;  

/**      
 * @author: 成都码到功成学员  
 * @Description:  
 *  非静态内部类 
 */  
public class TestOI {  
    public static void main(String[] args) {  
        // 访问非静态内部类的方式。  
        Outer.Inter oi = new Outer().new Inter();  
        oi.show();  
    }  
}  
class Outer {  
    private int a=10;  
    // 内部类  
    class Inter{  
        private int a =20;  
        public void show() {  
            int a = 30;  
            System.out.println("外部类成员变量："+Outer.this.a);  
            System.out.println("内部类成员变量："+this.a);  
            System.out.println("内部类局部变量："+a);  
        }  
    }  
}

效果：

B:静态内部类

格式：static class Inter{}

核心理解：可以把它看做外部类的一个静态成员。

实例：

package com.itcode.demo2;  

/**      
 * @author: 成都码到功成学员  
 * @Description:  
 *  静态内部类 
 */  
class Outer2 {  
    // 静态内部类  
    static class Inter{  

    }  


}  
public class TestOI2 {  
    public static void main(String[] args) {  
        /* 
         * 访问静态内部类的方式。 
         * 关于下面Inter为什么不用再new，是因为Inter加静态，直接在方法区拿来用。 
         */  
        Outer2.Inter oi = new Outer2.Inter();  

    }  
}

匿名内部类

没有名字仅仅调用一次的类。

匿名内部类是一个隐式的继承某类或实现某该接口的子类匿名对象

使用场景：比如增加窗口关闭监听，键盘按下监听。

记住:没有修饰符和构造方法.

package com.itcode.demo2;  

/**      
 * @author: 成都码到功成学员  
 * @Description:  
 *  匿名内部类的使用 
 */  
interface Oi3{  
    void name();  
}  
public class TestOI3{  
    public static void main(String[] args) {  
        Oi3 o = new Oi3() {  
            @Override // 重写  
            public void name() {  
                System.out.println("成都码到功成");  
            }  
        };  
        o.name();// 调用  
    }  
}

另外一个示例（典型的监听窗口关闭的测试类）：

this.addWindowListener(new WindowAdapter() {  
    @Override  
    public void windowClosing(WindowEvent e) {  
        // TODO Auto-generated method stub  
        System.exit(0);  
    }  
});

局部内部类

定义在方法内部,要访问必须在方法内部先访问它.

然后调用这个方法才可能访问。

实例:

package com.itcode.demo2;  

/**      
 * @author: 成都码到功成学员  
 * @Description:  
 *  局部内部类的使用 
 */  

public class TestOI4{  
    public void show(){  
        //局部内部类，作用域仅限于此方法  
        class OITest4{  
            public void show(){  
                System.out.println("局部内部类");  
            }  
        }  
        //访问局部内部类  
        OITest4 ot = new OITest4();  
        ot.show();  
    }  
    public static void main(String[] args) {  
        TestOI4 t4 = new TestOI4();  
        t4.show();  
    }  
}

内部类综合演示

示例:

class Outer{  
    int a = 10;  
    class Inner{//成员内部类  
        int a =20;  
        public void show(){  
            int a = 30;  
            System.out.println(a);//30  
            System.out.println(this.a);//20  
            System.out.println(Outer.this.a);//10  
        }  
    }  
    static int b =1;  
    static class Inner2{//静态内部类  
        int b=2;  
        public void show(){  
            int b =3;  
            System.out.println(b);//3  
            System.out.println(this.b);// 2  
            System.out.println(Outer.b);// 1  
        }  
    }  
    public void show(){  
        class Inner3{// 局部内部类，范围仅限于局部（方法）内。  
            public void eat(){  
                System.out.println("eat");  
            }  
        }  
        Inner3 i = new Inner3();//访问局部内部类，注意：必须先建立类再访问  
        i.eat();  
        System.out.println("局部内部类");  
    }  
}  
public class TestInner extends Thread{  
    public static void main(String[] args){  
        //访问成员内部类  
        Outer.Inner oi = new Outer().new Inner();  
        oi.show();  
        // 访问静态内部类  
        Outer.Inner2 oi2 = new Outer.Inner2();  
        oi2.show();  
        // 访问局部内部类  
        Outer a =new Outer();  
        a.show();  
        // 匿名内部类  
        Thread t = new TestInner(){  
            public void run(){  
                System.out.println("匿名内部类方法");  
            }  
        };  
        t.run();//访问匿名内部类  
    }  

}

效果: