十分钟“手撕”内部类+static在内部类的使用

前言：

由于写内部类代码中运用了很多static的知识，所以在代码中书写了大量通俗易懂的关于static使用方法，以及为什么会报错，该怎么调整。耐心看完不仅能熟悉内部类，还会对static有不一样的收获。

一、什么是内部类

内部类 就是 写在外部类内的类。

比如：下列代码中，OutClass是外部类，InnerClass是内部类。

public class OutClass {
// 成员位置定义：未被static修饰 --->实例内部类
    public class InnerClass1{
    }
// 成员位置定义：被static修饰 ---> 静态内部类
    static class InnerClass2{
    }
public void method(){
// 方法中也可以定义内部类 ---> 局部内部类：几乎不用
    class InnerClass5{
    }
}
}

1. 成员内部类(普通内部类：未被static修饰的成员内部类 和 静态内部类：被static修饰的成员内部类)

2. 局部内部类(不谈修饰符)、匿名内部类 

二、实例内部类

 定义：未被static修饰的成员内部类。

package demo;

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

    class InnerClass{
        public int data1=100;
        public int data4=4;
        private int data5=5;
        public static int data6=6;

        public void test(){
            System.out.println("InnerClass.test()");
        /*同个类（OutClass）里面，
        static修饰的变量可以使用，
        同时private修饰的也可以使用。*/

            /*
            若外部类与内部类有同名的，则优先访问内部（就近原则）
            如果非要访问外部类，则添加-》外部类名.this.
             */
            System.out.println("外部类data1："+OutClass.this.data1);
            System.out.println(data2);
            System.out.println(data3);
            System.out.println(data4);
            System.out.println(data5);
            System.out.println(data6);
        }
    }
}

public class Test {
    public static void main(String[] args) {
        OutClass out=new OutClass();
        /* InnerClass可以理解为OutClass里面的一个成员属性，
         和data1同一个级别，需要通过外部类类型调用内部类类型
         这是实例内部类，所以需要通过外部类对象out来new一个内部类对象*/
        OutClass.InnerClass innerClass= out.new InnerClass();
        innerClass.test();
       /* Test和OutClass（InnerClass）是不同的类，
        而且main方法也是由static修饰的，
        所以非static和private类权限修饰的变量或方法不能访问。*/
        System.out.println(out.data1);
        System.out.println(out.data2);//报错
        System.out.println(out.data3);
        System.out.println(innerClass.data4);
        System.out.println(innerClass.data5);//报错
        System.out.println(innerClass.data6);
    }
}

 【注意事项】

1. 外部类中的任何成员都可以在实例内部类方法中直接访问

2. 实例内部类所处的位置与外部类成员位置相同，因此也受public、private等访问限定符的约束

3. 在实例内部类方法中访问同名的成员时，优先访问自己的，如果要访问外部类同名的成员，必须：外部类名称.this.同名成员来访问

4. 实例内部类对象必须在先有外部类对象前提下才能创建

5. 实例内部类的非静态方法中包含了一个指向外部类对象的引用

6. 外部类中，不能直接访问实例内部类中的成员，如果要访问必须先要创建内部类的对象。

三、静态内部类

被static修饰的内部成员类称为静态内部类。 

package demo2;

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

    static class InnerClass{
        public int data4=4;
        private int data5=5;
        public static int data6=6;

        public void test(){
            System.out.println("InnerClass.test()");
            /*由于InnerClass是static修饰的，所以data1不能被访问
            若要访问，在main方法里面访问*/
            //System.out.println(data1);

            /* static修饰的类不能访问非static修饰的，
            因为内部类是静态的，外部类是非静态的，
            两者不能访问，所以不能访问data2 */

            System.out.println(data2);//报错

            System.out.println(data3);
            System.out.println(data4);
            System.out.println(data5);
            System.out.println(data6);
        }
    }
}
public class Test {
    public static void main(String[] args) {
        OutClass.InnerClass innerClass=new OutClass.InnerClass();
        innerClass.test();
        //在main方法访问data1,实例化外部类OutClass
        OutClass outClass=new OutClass();
        System.out.println(outClass.data1);
    }
}

 【注意事项】

1. 在静态内部类中只能访问外部类中的静态成员

如果确实想访问，我们该如何做？

答：在main方法书写，详细看上述代码，

2. 创建静态内部类对象时，不需要先创建外部类对象（所以用的比实例代码块多）

四、局部内部类

public class OutClass {
    int a = 10;
public void method(){
    int b = 10;
// 局部内部类：定义在方法体内部
// 不能被public、static等访问限定符修饰
class InnerClass{
public void methodInnerClass(){
    System.out.println(a);
    System.out.println(b);
}
}
// 只能在该方法体内部使用，其他位置都不能用
    InnerClass innerClass = new InnerClass();
    innerClass.methodInnerClass();
}
public static void main(String[] args) {
    // OutClass.InnerClass innerClass = null; 编译失败
}
}

 【注意事项】

1. 局部内部类只能在所定义的方法体内部使用

2. 不能被public、static等修饰符修饰

3. 编译器也有自己独立的字节码文件，命名格式：外部类名字$数字内部类名字.class

4. 几乎不会使用

五、 匿名内部类

不需要接收new出来的对象的内部类

package demo3;

import java.util.Objects;

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

    public void test(){
        System.out.println("OutClass.test()");
    }

}

public class Test {
    public static void main(String[] args) {
        OutClass outClass=new OutClass();
        System.out.println(outClass.data1);
        outClass.test();

        /* 匿名内部类：没有对象来接收，
        只能只用一次，相当于一次性 */
        System.out.println(new OutClass().data1);
        new OutClass().test();
    }

}

同时：局部内部类也可以运用在接口上面

package demo3;

interface ITestable{
    void test();
}


public class Test {
    public static void main(String[] args) {
        /*相当于一个类实现了这个接口，并重写了test方法
        这里没有对象接收，并不算实例化，接口不能实例化*/
        new ITestable() {
            @Override
            public void test() {
                System.out.println("匿名内部类test()");
            }
        }.test();
    }
}

 又或者可以这样写：（test（）运用了动态绑定）

package demo3;

interface ITestable{
    void test();
}

public class Test {
    public static void main(String[] args) {
        ITestable it=new ITestable() {
            @Override
            public void test() {
                System.out.println("test()..");
            }
        };
        it.test();
    }
}

若想要根据原理也可以：（test（）用到了动态绑定）

package demo3;

interface ITestable{
    void test();
}

class ITE implements ITestable{
    @Override
    public void test() {
        System.out.println("test()..");
    }
}
public class Test2 {
    public static void main(String[] args) {
        ITestable it=new ITE();
        it.test();
    }
}