JAVA 学习模块十五： 内部类

1.内部类的定义

/*  
内部类：（内置类，嵌套类）
将一个类定义在另一个类里面，对里面那个类就称为内部类。


内部类的访问特点：
1.内部类可以直接访问外部类中的成员
2.外部类要访问内部类，必须建立内部类的对象


一般用于类的设计。

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

class Outer
{
        private int num = 3;
    class Inner //可以用num
    {
        void show()
        {
            System.out.println(num);
        }
    }
    public void method() //外部类访问内部类
    {
        Inner in = new Inner();
        in.show();
    }

}

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


}

2.内部类的特点

第一种调用内部类方式

class Outer
{
        private int num = 3;
    class Inner //可以用num
    {
        void show()
        {
            System.out.println(num);
        }
    }
    public void method() //外部类访问内部类
    {
        Inner in = new Inner();
        in.show();
    }

}

class InnerOuter
{
    public static void main(String[] args)
    {
        //Outer out = new Outer();
        //out.method();
        Outer.Inner in = new Outer().new Inner();//特定格式
        in.show();
    }


}

2.

/*  
内部类：（内置类，嵌套类）
将一个类定义在另一个类里面，对里面那个类就称为内部类。


内部类的访问特点：
1.内部类可以直接访问外部类中的成员
2.外部类要访问内部类，必须建立内部类的对象


一般用于类的设计。

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

class Outer
{
        private static int num = 3;
    static class Inner //可以用num
    {
        static void show()
        {
            System.out.println(num);
        }
    }
    public void method() //外部类访问内部类
    {
        Inner in = new Inner();
        in.show();
    }

}

class InnerOuter
{
    public static void main(String[] args)
    {
        //Outer out = new Outer();
        //out.method();
        Outer.Inner in = new Outer().new Inner();//特定格式
        in.show();
        //如果内部类是静态的，那就相当于外部类
        //如果内部是静态的，成员是静态的，
        //
        Outer.Inner in = new Outer.Inner();
    }


}

3.

为什么内部类能直接访问外部类中的成员？
因为因为内部类持有外部类的引用。外部类名.this

为什么
class Outer
{
    int num = 3;
    class Inner //可以用num
    {
        int num = 5;
        void show()
        {
            System.out.println(Outer.this.num);// this.num 指5
        }
    }
    public void method() //外部类访问内部类
    {
        new Inner().show();
    }

}

class InnerOuter
{
    public static void main(String[] args)
    {
        new Outer().method();//输出是3
    }


}

4.


/*  
内部类可以放在局部位置上。

内部类在局部位置上只能访问被final修饰的局部变量。
*/

class Outer
{
    int num = 3;
    void method()
    {

        final int x = 9; //必加final

        class Inner
        {
            void show()
            {
                System.out.println(num + x); //jieguo 12
            }
        }
        Inner in = new Inner();
        in.show();
    }

}

class InnerOuter
{
    public static void main(String[] args)
    {
        new Outer().method();//输出是3
    }


}

5.匿名内部类

/*  
匿名内部类：内部类的简写格式

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

匿名内部类其实就是一个匿名子类对象。

格式：  new 父类 or 接口名（）{子类内容
}
*/


abstract class Demo

{
    abstract void show();
}

class Outer
{
    int num = 3;
    /*
    class Inner
    {
        void show()
        {
            System.out.println(num ); //jieguo 12
        }
        }
        */
    public void method()
        {
            //new Inner().show();
            new Demo() //匿名内部类
            {
                void show()
                {
                    System.out.println(num);
                }
            }
        }

}

class InnerOuter
{
    public static void main(String[] args)
    {
        new Outer().method();//输出是3
    }


}