内部类、匿名内部类

一、内部类访问特点：
1，内部类可以直接访问外部类中的成员。
2，外部类要访问内部类，必须建立内部类的对象。
一般用于类的设计。

分析事物时，发现该事物描述中还有事物，而且这个事物还在访问被描述事物的内容。
这时就是还有的事物定义成内部类来描述。

二、***好处：将内部类定义在外部类中（定义在外部类的成员位置），方便内部类访问外部类中的成员。

三、内部类可以存放在局部位置上。
      内部类在局部位置上只能访问局部中被final修饰的局部变量。

例：

class Outer
{
    private static int num = 31;

    class Inner// 内部类。
    {
        void show()
        {
            System.out.println("show run..."+num);
        }
        /*static void function()//***如果内部类中定义了静态成员，该内部类也必须是静态的。
        {
            System.out.println("function run ...."+num);
        }
        */
    }

    public void method()
    {
        Inner in = new Inner();
        in.show();
    }
}


class InnerClassDemo
{
    public static void main(String[] args) 
    {
//        Outer out = new Outer();
//        out.method();
        //直接访问外部类中的内部类中的成员。（这种格式不多见，内部类一般被封装起来）
//        Outer.Inner in = new Outer().new Inner();
//        in.show();

        //如果内部类是静态的。相当于一个外部类（外部类一创建，static的内部类就加载进内存了。）
//        Outer.Inner in = new Outer.Inner();
//        in.show();

        //如果内部类是静态的，成员也是静态的。（不需要对象，直接调用。）
//        Outer.Inner.function();
        
    }
}

 四、匿名内部类

匿名内部类就是内部类的简写格式，其实就是一个匿名子类对象。

1.前提：内部类必须继承或者实现一个外部类或者接口。

2.格式：new 父类or接口(){子类内容}

例：

abstract class Demo
{
    abstract void show();
}

class Outer
{
    int num = 4;
    /*
    class Inner extends Demo //传统格式
    {
        void show()
        {
            System.out.println("show ..."+num);
        }
    }
    */
    public void method()
    {
        //new Inner().show();
        new Demo() //匿名内部类。简写格式：直接new对象+复写
        {
            void show()
            {
                System.out.println("show ........"+num);
            }
        }.show(); //调用方法很特殊 也说明了匿名内部类其实就是一个子类对象。
        或者

        Demo demo = new Demo()
        {
            void show()
            {
                System.out.println("show ........"+num);
            }
        }
　　　　 demo.show(); //通过父类对象来调用
    }
}


class InnerClassDemo4 
{
    public static void main(String[] args) 
    {
        new Outer().method();
    }
}

3.通常的使用场景

当函数参数是接口类型时，而且接口中的方法不超过三个。可以用匿名内部类作为实际参数进行传递

例：

class InnerClassDemo5 
{
    interface Inner
    {

　　　　　　void show1();
　　　　　　void show2();

    }
    public static void main(String[] args) 
    {
        /*
        show(new Inter()
        {
            public void show1(){}
            public void show2(){}
        });
        */

    }

　　public static void show(Inter in)
    {
        in.show1();
        in.show2();
    }
}