面对对象-内部类

成员内部类:

public class OuterClass {
    //外部类的成员
    private String name="zhangsan";
    private int num=10;
    //外部类的方法
    public void outerMethod(){
//        System.out.println(a);//外部类不能访问内部类的成员
    }
    //内部类
    public class InnerClass{
        //内部类的成员
        private int num=20;
        private int a=30;
        //内部类的方法
        public void innerMethod(){
            System.out.println("OuterClass--->name="+name);//内部类可以访问外部类的成员
            System.out.println("OuterClass--->num="+OuterClass.this.num);//外部类的成员
            System.out.println("InnerClass--->num="+this.num);//内部类的成员
        }
    }
    
    public static void main(String[] args) {
        /*
         * 创建内部类的实例:
         * 外部类.内部类 对象名 = new 外部类().new 内部类();
         */
        OuterClass.InnerClass innerClass = new OuterClass().new InnerClass();
        innerClass.innerMethod();
        
    }

 

静态内部类:使用static修饰的内部类。静态内部只能访问外部的静态成员。

public class OuterClass2 {
    //外部类的成员
    private static String name="zhangsan";
    private static int num=10;
    //外部类的方法
    public void outerMethod(){
//        System.out.println(a);//外部类不能访问内部类的成员
    }
    //内部类
    public static class InnerClass{
        //内部类的成员
        private int num=20;
        private int a=30;
        //内部类的方法
        public void innerMethod(){
            System.out.println("OuterClass--->name="+name);//内部类可以访问外部类的成员
            System.out.println("OuterClass--->num="+OuterClass2.num);//外部类的成员
            System.out.println("InnerClass--->num="+this.num);//内部类的成员
        }
    }
    
    public static void main(String[] args) {
        /*
         * 创建静态内部类的实例:
         * 外部类.内部类 对象名 = new 外部类.内部类();
         */
        OuterClass2.InnerClass innerClass = new OuterClass2.InnerClass();
        innerClass.innerMethod();
        
    }
    
}

 

方法内部类:在方法中定义的内部类。如果方法内部类中需要访问方法中局部变量，该局部变量必须使用final修饰

public class OuterClass3 {
    // 外部类的成员
    private String name = "zhangsan";
    private int num = 10;

    // 外部类的方法
    public void outerMethod(){
            //方法内部类
        class InnerClass{
            //内部类的成员
            private final int num=20;
            private int a=30;
            //内部类的方法
            public void innerMethod(){
                System.out.println("OuterClass--->name="+name);//内部类可以访问外部类的成员
                System.out.println("OuterClass--->num="+OuterClass3.this.num);//外部类的成员
                System.out.println("InnerClass--->num="+num);//内部类的成员
            }
        }
        InnerClass innerClass = new InnerClass();
        innerClass.innerMethod();
    }

    public static void main(String[] args) {
        OuterClass3 outerClass = new OuterClass3();
        outerClass.outerMethod();
     }

}

 

匿名内部类Anonymous
可以实现一个接口，或者继承一个父类
只能实现一个接口
适合创建那种只需要一次使用的类，不能重复使用。比较常见的是在图形界面编程GUI里用得到。
匿名内部类要使用外部类的局部变量，必须使用final修饰该局部变量

public class TestAnonymous {
    public static void main(String[] args) {
        //实现一个接口的匿名内部类
        /*
         *  class MyClass implements MyInterface{
         *      public void test(){
         *          ..
         *      }
         *  }
         *  MyClass myClass = new MyClass();
         *  myClass.test();
         */
        new MyInterface() {
            public void test() {
                System.out.println("测试匿名内部的test方法....");
            }
        }.test();
        /*
         * 继承的匿名类。
         * class MyThread extends Thread{
         *      public void run(){
         *      .... 
         *   }
         * }
         * MyThread myThread = new MyThread();
         * myThread.start();
         */
        new Thread(){
            public void run() {
                System.out.println("Thread....run方法...");
            }
        }.start();
    }
}