内部类

内部类

1.

//内部类一
/*内部类：当B类想要调用A类私有的成员函数时，可以将B类移入A类中作为内部类
访问方式-内部类访问外部类：可直接访问外部类的所有成员和函数,包含私有的
        -外部类访问内部类：外部类必须创建内部类的对象
*/
//内部类的访问方式：内部类在成员位置，可以被修饰符修饰

public class Outer{
    public static void main(String[] args){
        /*A a=new A();
        a.method();*/

        /*直接访问内部类
        A.B a=new A().new B();
        a.print();*/

        /*调用静态内部类的非静态函数
        A.C q=new A.C();
        q.print2();*/
        /*调用非静态类内静态类内的静态函数
        A.C.print3();*/
    }
}

class A{     //外部类
    int num=7;

    class B{
    void print(){
        System.out.println("B method run");
        }

     //static void print4(){}非静态内部类中不允许定义静态成员，但是仅允许定义静态变量
    }   

    static class C{
        void print2(){
            System.out.println("C static class run");
        }

        static void print3(){
            System.out.println("C static method run");
        }
    }

    void method(){  //内部类,内部类必须有自己的所属名字进行标识
        B b=new B();
        b.print();
    }
}

2.

/*内部类能直接访问外部类的原因：
非静态内部类中持有外部类的引用
静态内部类不持有外部类.this，而是直接类明调用
*/
public class Outer2{
    public static void main(String[] args){
        Outer n=new Outer();
        n.show();//num=5BSystem.out.println("run");
    }
}

class Outer{
    int num=3;
    class Inner{
        int num=4;

        void method(){
            int num=5;
            System.out.println("num="+num);//5
            System.out.println("num="+this.num);//4
            System.out.println("num="+Outer.this.num);//3
        }
    }

    void show(){
        new Inner().method();
    }
}

3.

/*内部类在局部位置上,只能访问被final修饰的局部变量*/
public class Outer3{
    public static void main(String[] args) {
        Outer n=new Outer();
        n.method();
        //如果Inner对外提供，那么可以如此截获
        Outer.Inner in=n.getObject();
        in.show();
        //如果Inner被private，可以通过父类型获取
        In i=n.getObject();
        i.show();
    }
}

class Outer{
    int num=3;
    /*
    void method(){
        final int x=10;
        int y=2;
        class Inner extends In{//内部类可以延伸类或者借口
            void show(){
                //System.out.println("y="+y);//访问失败，y的生命周期太短了
                System.out.println("x="+x);
                System.out.println("inner run..."+num);
            }
        }
        new Inner().show();
    }*/
    final int x=10;
    int y=2;
    private class Inner extends In{
        void show(){
            System.out.println("x="+x);
            System.out.println("inner run..."+num);
        }
    }
    public Inner getObject(){
        return new Inner();
    }

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

abstract class In{
    abstract void show();
}

4.

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

abstract class AbsDemo{
    abstract void show();
}

class Outer{
    int num=3;
    /*
    class Inner extends Outer{
        void show(){
            System.out.println("num==="+num);
        }
    }
    */
    public void method(){
        //不想创建子类型，但想创建子类对象
        new AbsDemo(){//AbsDemo的子类对象,一个带着内容的子类对象,相当于new Inner().show()；
                      //匿名内部类：带内容的子类对象 new父类()或者接口{子类的接口}
                      //前提：匿名内部类必须继承父类或者实现接口
            void show(){
                System.out.println("num==="+num);
            }
        }.show();
    }
}

5.

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

interface Inter{
    void show1();
    void show2();
}

class Outer{
    int num=4;

    /*class Inner implements Inter{
        public void show1(){
            System.out.println("show1 run");
        }

        public void show2(){
            System.out.println("show2 run");
        }
    }*/
    public void method(){
        Inter in=new Inter(){//当需要匿名类调用多个方法时，可以为匿名类起个名字然后调用
            public void show1(){
            System.out.println("show1 run");
            }

            public void show2(){
            System.out.println("show2 run");
            }
        };
        in.show1();
        in.show2();
    }
}

6.

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

interface Inter{
    public void show();
}

class Outer{
    public static Inter method(){
        return new Inter(){
            public void show(){
                System.out.println("hahaha");
            }
        };
    }
}

class Outer2{
    //以下两个对象有区别吗？
    new Object(){
         public void show(){

         }
    }.show();//编译通过

    Object in=new Object(){
        public void show(){

        }
    };
    in.show();//编译失败，因为匿名内部类是子类对象，当Object obj指向时，就被提升了Object，而Object类中没有定义show方法，所以编译失败
}