内部类介绍

内部类：面向对象程序设计中，一个类的内部定义另一个类，里面的类称为内部类。

特点：
1、内部类可以直接访问外部类中的成员，包括私有成员。
2、外部类访问内部类中成员必须建立内部类对象。
3、内部类不为同一包的其他类所见，具有很好的封装性

表现形式：
⒈成员内部类
⒉静态内部类
⒊局部内部类
⒋匿名内部类

成员内部类：

/**
 * 成员内部类
 * @author Administrator
 *
 */
public class Outer1 {
    //外部类成员变量
    private int num = 4;

    //内部类
    public class Inner1{
        //如果内部类不是静态内部类，就不能有静态声明
//      private static String str;      
        public void getNum(){
            //内部类直接访问外部类的成员变量，原因就是内部类持有外部类的引用  外部类.this
            System.out.println(num);
            //等价于
            System.out.println(Outer1.this.num);

        }


    }

    /**
     * 外部类成员方法访问内部类
     */
    public void showInner(){
        //需要new内部类对象
        Inner1 inner = new Inner1();
        inner.getNum();
    }

}

class Test1{
    public static void main(String[] args) {
        //成员内部类对象，第一种访问形式
        Outer1.Inner1 oi1= new Outer1().new Inner1();
        oi1.getNum();

        //第二种访问形式，调用外部类方法，而该方法中new了内部类对象
        Outer1 outer = new Outer1();
        outer.showInner();
    }
}

静态内部类：

package com.java.inner;
/**
 * 静态内部类
 * @author Administrator
 *
 */
public class Outer2 {
    //静态成员变量
    private static int num = 5;

    //内部类
    static class Inner2{

        public void getNum(){
            //内部类直接访问外部类的成员变量
            System.out.println(num);
        }

        static void show(){
            System.out.println(num);
        }
    }

    /**
     * 外部类成员方法范围内部类
     */
    public void showInner(){
        //需要new内部类对象
        Inner2 inner = new Inner2();
        inner.getNum();
    }

}

class Test2{
    public static void main(String[] args) {
        //静态内部类对象，相当于外部类
        //访问静态内部类的非静态成员，依然需要内部类对象
        Outer2.Inner2 oi2= new Outer2.Inner2();
        oi2.getNum();

        //第二种访问形式，调用外部类方法，而该方法中new了内部类对象
        Outer2 outer = new Outer2();
        outer.showInner();

        //访问静态内部类的静态成员
        Outer2.Inner2.show();
    }
}

局部内部类：

package com.java.inner;

/**
 * 局部内部类
 */
public class Outer3 {

    int num = 7;

    // 在方法内定义内部类
    public void outerMethod() {

        // 定义局部变量
        final int x = 3;

        class Inner3 {

            public void innerShow() {

                System.out.println(num);

                // 访问局部变量x时，编译期间报错 必需将x声明为final
                System.out.println(x);

            }

        }
        // 在outerMethod的方法内new内部类对象，并调用方法
        new Inner3().innerShow();
    }
}

class Test3 {
    public static void main(String[] args) {

        Outer3 outer = new Outer3();
        outer.outerMethod();

    }
}

匿名内部类(内部类的简写格式)：
前提：内部类必须继承或实现一个对外部类或接口
应用：某些方法可以用匿名内部类作为参数传递（多态应用的一种）

package com.java.inner;

/**
 * 定义一个接口
 */
interface Demo{
    public void show();
}

/**
 * 匿名内部类
 * @author Administrator
 */
public class Outer4 {

    int num = 4;
    public void outerMethod(){
        //匿名内部类（实质就是Demo的子类对象）
        new Demo(){

            @Override
            public void show() {
                System.out.println(num);

            }
        }.show();//匿名内部类调用对象
    }
}

class Test4{
    public static void main(String[] args) {
        Outer4 outer = new Outer4();
        outer.outerMethod();
    }   
}