java的内部类

java的内部类

---

java的内部类分为四种：成员内部类，静态内部类，方法内部类，匿名内部类

成员内部类

• 内部类定义在外部类的内部，相当于外部类的一个成员变量的位置，内部类可以使用任意访问控制符，如public，protected，private等
• 内部类可以访问既可以访问自身的数据域，也可以访问创建它的外围类对象的数据域。内部类总有一个隐式引用，指向创建它的外部类对象。
• 定义了成员内部类后，必须使用外部类对象来创建内部类对象，而不能直接去 new 一个内部类对象，即：内部类 对象名 = 外部类对象.new 内部类( )
• 注意：成员内部类中不能存在任何 static 的变量和方法,可以定义常量，即非静态内部类中不能定义静态域或方法

public class Outer{
        private int age = 99;
        String name = "Coco";
        public class Inner{
            String name = "Jayden";
            public void show(){
                System.out.println(Outer.this.name);
                System.out.println(name);
                System.out.println(age);
            }
        }
        public Inner getInnerClass(){
            return new Inner();
        }
        public static void main(String[] args){
            Outer o = new Outer();
            Inner in = o.new Inner();
            in.show();
        }
    }

---

静态内部类

• 内部类添加static字段不会产生对外部类的引用。
• 外部类使用静态方式生成并返回内部类了，该内部类必须是静态内部类。
• 创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名 = new 内部类();
• 静态内部类只能访问外部类的静态成员，不能访问非静态成员
• 创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名 = new 内部类()

public class Outer{
            private int age = 99;
            static String name = "Coco";
            public static class Inner{
                String name = "Jayden";
                public void show(){
                    System.out.println(Outer.name);
                    System.out.println(name);                  
                }
            }
            public static void main(String[] args){
                Inner i = new Inner();
                i.show();
            }
        }

---

方法内部类

• 可以把方法内部类当一个局部变量，该局部变量不能有 public，protected，private 以及 static 修饰符
• 只能访问方法中定义的 final 类型的局部变量,如果局部变量不是final类型的话，可能出现局部变量消亡，而内部类对象还存在，导致内部类访问一个不存在的局部变量。同时，因为局部内部类并不是直接调用方法传进来的参数，而是内部类将传进来的参数通过自己的构造器备份到了自己的内部，如果外面传进来的变量被篡改的话,会导致内部类得到的值不一致。所以为了使内部类内外的数据一致，需要用final修饰外面传进来的变量。

        public class Outer{
            public void Show(){
                final int a = 25;
                int b = 13;
                class Inner{
                    int c = 2;
                    public void print(){
                        System.out.println("访问外部类:" + a);
                        System.out.println("访问内部类:" + c);
                    }
                }
                Inner i = new Inner();
                i.print();
            }
            public static void main(String[] args){
                Outer o = new Outer();
                o.show();
            }
        } 

匿名内部类

• 匿名内部类仅能被使用一次，创建匿名内部类时它会立即创建一个该类的实例（通过直接new生成实例）。
• 匿名内部类必须是继承一个类的子类或者是一个接口
• 匿名内部类中不能定义构造方法，需要用利用构造代码块取代构造方法
• 匿名内部类中不能存在任何的静态成员变量和静态方法
• 匿名内部类不能是抽象的,它必须要实现继承的类或者实现的接口的所有抽象方法

  public class OuterClass {
            public InnerClass getInnerClass(final int  num,String str2){
                return new InnerClass(){
                    int number = num + 3;
                    public int getNumber(){
                        return number;
                    }
                };        /* 注意：分号不能省 */
            }
            public static void main(String[] args) {
                OuterClass out = new OuterClass();
                InnerClass inner = out.getInnerClass(2, "chenssy");
                System.out.println(inner.getNumber());
            }
        }
        interface InnerClass {
            int getNumber();
        }