Java之内部类

目录

实例内部类

静态内部类

局部内部类

匿名内部类

---

下面将讲解实例内部类，静态内部类，局部内部类和匿名内部类。

实例内部类

实例内部类（也称为非静态内部类）依赖于外部类的实例。这意味着，要创建实例内部类的实例，你必须先创建外部类的实例。实例内部类可以访问外部类的所有成员（包括私有成员），而不需要任何特殊条件。

1.如何获取实例内部类？

   获取实例内部类对象依赖于外部类对象，通过 new 外部类.new 内部类

   或者外部类.new 内部类。

2.在实例内部类中，可以定义被final修饰的静态的成员变量，例如public static final int x=6;

   但是不能定义没有被final修饰的静态的成员变量，例如public static int x=6。

解释：

   因为x被final修饰，此时x为常量，类加载的时候不回家住普通的成员变量，实例内部类中

   又存在static，而static是在类加载的时候创建的。

3.当外部类中的数据成员和内部类中的数据成员一样的时候，如何在内部类中访问外部类中同名的成员，通过    外部类.this.  来进行访问。

class OuterClass {
    //
    public int data1 = 1;
    private int data2 = 2;
    public static int data3 = 3;


    class InnerClass {
        public int data1 = 1111;
        public int data4 = 4;
        private int data5 = 5;

        public static final int data6 = 6;

        public void test() {
            System.out.println(this.data1);
            System.out.println(OuterClass.this.data1);
            System.out.println(data4);
            System.out.println(data5);
            System.out.println("内部类的test方法");
        }
    }

    public void test() {
        System.out.println("外部类的test方法");
        InnerClass innerClass = new InnerClass();
        System.out.println(innerClass.data4);
    }
}


public class Test {
    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        //System.out.println(outerClass.data1);

        //获取实例内部类对象的时候 依赖于外部类对象
        OuterClass.InnerClass innerClass = outerClass.new InnerClass();
        innerClass.test();

        //上面的outerClass.new InnerClass()是new OuterClass().new InnerClass()的简化形式
        OuterClass.InnerClass innerClass2 = new OuterClass().new InnerClass();
        innerClass2.test();
    }
}

静态内部类

静态内部类不依赖于外部类的实例。它类似于外部类中的其他静态成员，可以通过外部类名直接访问（如果它是public或protected的）。

1.如何获取静态内部类对象

   通过new  外部类类名.内部类    的方式来获取。

2.如何在静态内部类中访问外部类的非静态的成员

   通过在内部类中new创建一个外部类对象，然后通过   外部类.成员    的方式来访问。

class OuterClass2 {
    public int data1 = 1;
    private int data2 = 2;
    public static int data3 = 3;


    static class InnerClass {

        //public int data1 = 111;
        public int data4 = 4;
        private int data5 = 5;
        public static int data6 = 6;

        public void test() {
            OuterClass2 outerClass2 = new OuterClass2();
            System.out.println(outerClass2.data1);
            System.out.println(data3);
            System.out.println(data4);
            System.out.println(data5);
            System.out.println(data6);
            System.out.println("内部类的test方法");
        }
    }
}

public class Test1 {

    public static void main(String[] args) {
        OuterClass2.InnerClass innerClass = new OuterClass2.InnerClass();
        innerClass.test();
    }
}

局部内部类

局部内部类是定义在方法、构造器或初始化块内部的类。局部内部类只能在其定义的作用域内被访问，并且不能包含静态成员。局部内部类可以访问其外部类的所有成员以及定义它的方法或构造器中的局部变量（但局部变量必须是final或实际上是final的，从Java 8开始，这个限制放宽，只要局部变量是effectively final即可）。

public void func() {
    class Inner {
        public int data1 = 1;
    }

    Inner inner = new Inner();
    System.out.println(inner.data1);
}

匿名内部类

匿名内部类是没有名称的内部类，它通常用于简化代码。它通常用于实现接口或继承其他类（只能继承非抽象类）的匿名子类。由于它没有名称，因此你不能直接引用它。匿名内部类常用于只使用一次的简单对象。

interface A {
    void test();
}
public class Test2 {
    public static void main(String[] args) {
        int val = 10;
        //val = 100;

        A a = new A(){
            @Override
            public void test() {
                //默认在这里能访问的是 被final修饰的
                System.out.println("值："+ val);
                //在匿名内部类当中 能够访问的是 没有被修改过的数据-->变量的捕获
            }
        };
        a.test();


        System.out.println(val);
    }
}