成員內部類

定義：

  一個類定義在另外一個類的內部。

訪問方式：

方式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();
    }
}