JAVA--成员内部类 局部内部类 匿名类

成员内部类

定义：

  一个类定义在另外一个类的内部。

访问方式：

方式1 ： 在外部类提供一个方法创建内部类的对象进行访问。
方式2： 在其它类中直接访问。 格式： 外部类.内部类  变量名 = new 外部类().new 内部类()

应用场景：

1.内部类可以访问外部类的所用成员；
2.外部类与内部类有同名的成员时，默认访问内部类成员。但是可以用 外部类.this.成员变量名 指定访问外部类成员。
3.当内部类被private修饰时，不能通过其他类直接访问，只能通过方法1.
4.当内部类中的成员变量被static修饰时，该内部类也需要用static修饰。（静态成员的访问并不需要对象的存在。）
5.如果要访问一个静态的内部类，访问方式为：
外部类.内部类 = new 外部类.内部类();

样例代码：

class  Outer              // new Outer.Inner.x
{
    int x = 100;
    static class Inner
    {
          static  int x = 200;
        public void print()
        {                                   //Outer.this.x
            System.out.println("Inner...." + x );
        }

    }
    //访问内部类方式1 ： 在外部类提供一个方法创建内部类的对象进行访问。
    public void instance()
    {
        Inner ee = new Inner();
        ee.print();
        System.out.println("Inner....");
    }

}

class  Demo2
{
    public static void main(String[] args) 
    {
        System.out.println(Outer.Inner.x);
        /*
         Outer ww = new Outer();
         ww.instance();
         */
         //访问内部类方式2： 在其它类中直接访问。 格式： 外部类.内部类  变量名 = new 外部类().new 内部类()
         /*
          Outer.Inner inner = new Outer().new Inner();
         inner.print();
         */
         //静态内部类的访问方式：
         Outer.Inner inner = new Outer.Inner();
         inner.print();

    }
}

局部内部类

定义：

    在一个类的方法内部定义另外一个类。

访问方式:

    方式一：在外部类提供一个方法创建内部类的对象进行访问。

使用注意：

1.如果局部内部类访问一个局部变量时，那么该局部变量必须用final 修饰。

样例代码：

class Outer
{
    int y = 10;
    public void test()
    {
        final int x = 200; 
        class Inner 
        {
            public void print()
            {
                    System.out.println("内部类" + x); // 此时的x为局部变量x 的复制品
            }
        }
        Inner dd = new Inner();
        dd.print();
    }
}

class  Demo2
{
    public static void main(String[] args) 
    {
        //System.out.println(Outer.Inner.x);
        Outer ss = new Outer();
        ss.test();   
    }
}

匿名内部类：

使用前提：

必须存在继承和实现关系。

样例代码：

abstract class Animal
{
    public abstract Animal run();
    public abstract void sleep();
}
class  Outer 
{
    /* 
    public void print()
    {
        class  Dog extends Animal  // 局部内部类
        {
            public void run()
            {
                System.out.println("狗在跑。。。。。");
            }
        }
        Dog  dd = new Dog();
        dd.run();
    }
    */

    //匿名内部类
    public void print(){
        Animal a = new Animal(){   //多态的形式
            //匿名内部类与Animal是继承关系，
            //匿名内部类成员
            public Animal run()
            {
                System.out.println("狗在跑。。。。。");
                return this;
            }
            public void sleep()
            {
                    System.out.println("狗在睡觉睡觉。。。。。");
            }
            public void bite()
            {
                    System.out.println("狗在摇啊摇。。。。。");
            }
        };
        a.run().bite();
        a.sleep();
    }       
}
class Demo1
{
    public static void main(String[] args)
    {
        Outer ss = new Outer();
        ss.print();
    }
}
**************************************

interface  Dao
{
    public abstract void run();
}

/*class Outer 
{
    public void print()
    {
        new Dao(){
           public void run()
            {
               System.out.println("再吃再吃");
            }
        }.run();
    }
}
*/
class Demo3 
{
    public static void main(String[] args) 
    {
         //Outer aa = new Outer();
         test(new  Dao()
        {
             public void run()
            {
               System.out.println("再吃再吃.....");
            }
        }
        );
    }
    public static void test(Dao s)
    {
        s.run();
    }
}