20_内部类

 1.概念

---

 

 2.内部类的作用

 

---

 

 3.原理

---

 

 4.分类

 

---

 

 5.内部类中为什么不能声明静态成员？

 

---

 

 6.成员内部类的修饰符

 

---

 

 7.局部内部类的修饰符

 

---

 

 8.成员内部类

8.1 成员内部类代码实现

package JavaBasicReview;

public class JavaGrammer {
    public static void main(String[] args) {
        //创建外部类,外部类在内部类之前创建，内部类创建后会获取外部类对象的引用
        Outer outer = new Outer();
        outer.getInner();
        System.out.println("====it's Inner======");
        //创建成员内部类,使用内部类之前，外部类会自动创建
        Outer.Inner inner = new Outer().new Inner();
        inner.show();
    }
}


class Outer {
    private int age = 16;

    public Outer() {
        System.out.println("Outer created!");
    }

    //成员内部类
    class Inner {
        private int age = 17;

        public Inner() {
            System.out.println("Inner created！");
        }

        void show() {
            System.out.println("Outer's age:" + Outer.this.age);
            System.out.println("Inner's age:" + this.age);
        }
    }

    void getInner() {
        Inner inner = new Inner();
        System.out.println("Outer's age:" + this.age);
        System.out.println("Inner's age:" + inner.age);
    }
    
}

Outer created!
Inner created！
Outer's age:16
Inner's age:17
====it's Inner======
Outer created!
Inner created！
Outer's age:16
Inner's age:17

---

 9.局部内部类

 

 

 9.1 局部内部类代码实现

package JavaBasicReview;

public class JavaGrammer {
    public static void main(String[] args) {
        //创建外部类对象,外部类在内部类之前创建，内部类创建后会获取外部类对象的引用
        Outer outer = new Outer();
        outer.innerClassMethod("str");
        System.out.println("====it's Inner======");
        //创建局部内部类对象，局部内部类在方法外无法访问


    }
}


class Outer {
    private int age = 16;

    public Outer() {
        System.out.println("Outer created!");
    }

    //局部内部类只能在该方法内部使用
    void innerClassMethod(final String name) {
        //name = "newstr";//如果局部内部类中使用了方法中的变量，那么该变量当且仅当被赋值一次，用[final]修饰

        //局部内部类,不能有任何修饰符
        class Inner {
            private int age = 17;

            public Inner() {
                System.out.println("Inner created！");
            }

            void show() {
                System.out.println("Outer's age:" + Outer.this.age);
                System.out.println("Inner's age:" + this.age);
                System.out.println("method's name:" + name);
            }

        }
        //使用内部类
        Inner inner = new Inner();
        inner.show();
        System.out.println(inner.getClass());
    }
}

Outer created!
Inner created！
Outer's age:16
Inner's age:17
method's name:str
class JavaBasicReview.Outer$1Inner
====it's Inner======

 

---

 

10.匿名内部类

 

 

 10.1 匿名内部类的代码实现

package JavaBasicReview;

public class JavaGrammer {
    public static void main(String[] args) {
        //创建外部类对象,外部类在内部类之前创建，内部类创建后会获取外部类对象的引用
        Outer outer = new Outer();
        outer.innerClassMethod("str");
        System.out.println("====it's Inner======");
        //创建匿名内部类对象，匿名内部类只能在方法内部使用
        //匿名内部类生成的class文件名称：外部类$1.class

    }
}

//Fu类
class Fu {
    int age = 100;

    void show() {
        System.out.println("Fu's show method");
    }
}


class Outer {
    private int age = 16;

    public Outer() {
        System.out.println("Outer created!");
    }

    //匿名内部类只能在该方法中使用，使用场景：如果一个interface或者父类的继承类只在该方法中使用一次，那么可以匿名内部类
    void innerClassMethod(final String name) {
        //name = "newstr";//如果局部内部类中使用了方法中的变量，那么该变量当且仅当被赋值一次，用[final]修饰

        //创建匿名内部类，必须继承或者实现存在，且在定义中不能出现extends和implments
        Fu fu = new Fu() {
            int age = 19;

            void show() {
                System.out.println("Outer's age:" + Outer.this.age);
                System.out.println("Inner's age:" + this.age);
                System.out.println("method's name:" + name);
            }
        };

        //使用匿名内部类
        fu.show();
        System.out.println(fu.getClass());

    }
}

 

---

 

11.静态内部类(嵌套类)

 

11.1静态内部类代码实现

 

package JavaBasicReview;

public class JavaGrammer {
    public static void main(String[] args) {
        //创建静态内部类，静态内部类在类加载时创建，不会提前获取外部类对象的引用
        Outer outer = new Outer();
        outer.show();
        System.out.println("====it's Inner======");
        //创建静态内部类对象,和外部类基本没啥关系，所有外部类不会提前创建
        Outer.StaticInner inner = new Outer.StaticInner();
        inner.show();

    }
}

class Outer {
    private int age = 16;

    public Outer() {
        System.out.println("Outer created!");
    }

    //静态内部类
    /*private*/ static class StaticInner {
        /*static*/ int age = 88;

        public StaticInner() {
            System.out.println("StaticInner created!");
        }

        /*static*/ void show() {
            //不能访问外部类成员，应为静态类优先于外部类对象创建，没有提前获取外部类对象的引用
            //System.out.println("Outer's age:"+ Outer.this.age);
            System.out.println("Inner's age:" + this.age);
        }

    }

    //外部类使用静态内部类
    void show() {
        new StaticInner().show();
    }
}

静态内部类补充知识：

 

 

 

class Outer {
    private int age = 88;

    //成员内部类
    class InnerCY {
        //static int age = 99;//Inner classes cannot have static declarations
        void show() {
            System.out.println("这是成员内部类" + Outer.this.age);
        }
    }

    //静态内部类
    static class InnerStatic {
        static int age = 99;//静态内部类中可以有静态方法
        //静态内部类不会提前获取外部类对象的引用，所有想使用外部类必须创建外部类对象
        void show() {
            System.out.println("这是成员内部类" + new Outer().age);
        }

    }

}