静态内部类与非静态内部类的区别

了解static关键字

1.static修饰表示静态的，在类加载时JVM会把它放到方法区，被本类以及本类中所有实例所公用。随着类的产生而产生，随着类的销毁而销毁。
2.优先于对象的存在，对象是我们手动通过new关键字创建出来的。
3.satic修饰的成员被该类型的所有对象所共享。根据该类创建出来的任何对象，都可以访问static成员。 分析:表面上通过对象去访问static成员,其本质依然使用类名访问,和对象没有任何关系(通过反编译可以看到)。
4.直接使用类名访问static成员 ，因为static修饰的成员直接属于类，不属于对象，所以可以直接使用类名访问static成员。

什么是内部类

定义在一个类内部的类叫内部类，包含内部类的类称为外部类。具体可以看我另一篇关于内部类的介绍，虽然全是抄的。2333333

静态内部类和非静态内部类的区别

我们先通过一段代码来看：

/**
 * <Description><br>
 *
 * @author DaShi<br>
 * @version 1.0<br>
 * @taskId <br>
 * @CreateDate 2018/12/12 19:07 <br>
 */
public class OutClassTest {
    int a = 100;
    static int b = 200;
    void out(){
        System.out.println("外部类非静态方法");
    }
    static void outstatic(){
        System.out.println("外部类静态方法");
    }
    public class InnerClass{
        //非静态内部类不能有静态成员（方法、属性）
        //static void inner(){}
        // static int i=1;
        void InnerMethod(){
            System.out.println("这是非静态内部类!");
            //调用外部类的非静态成员
            System.out.println("外部类非静态成员a的值：" + a);
            //调用外部类静态成员
            System.out.println("外部类静态成员b的值:" + b);

            //调用外部类非静态方法
            out();
            //调用外部类静态方法
            outstatic();
        }
    }
    public static class InnerstaticClass{
        //静态内部类能有静态成员（方法、属性）
        static void innerstatic(){}
        static int i=1;
        // 静态内部类也可以定义非静态成员变量
        public int m=0;
        void InnerstaticMethod(){
            System.out.println("这是静态内部类");
            //静态内部类不能直接访问外部类的非静态成员
            //  System.out.println(a);
            //  out();
            //但可以通过new外部类对象来访问外部类非静态成员
            System.out.println(new OutClassTest().a);
            System.out.println(b);
            outstatic();
        }
    }
    public static void main(String args[]){
        OutClassTest a=new OutClassTest();
        //创建静态内部类
        OutClassTest.InnerstaticClass innerstaticClass = new OutClassTest.InnerstaticClass();
        //创建非静态内部类
        OutClassTest.InnerClass InnerClass = a.new InnerClass();
        innerstaticClass.InnerstaticMethod();
        InnerClass.InnerMethod();
    }
}

运行结果： image.png

发现了没有，其实区别很简单

1. 非静态内部类不能有静态成员（方法、属性），但是静态内部类的方法和变量可以是静态的也可以是非静态的，静态的方法可以在外层通过静态类调用，而非静态的方法必须要创建类的对象之后才能调用。
2. 非静态内部类可以访问外部类的所有成员，无论静态还是非静态。但是静态内部类只能访问外部类的静态成员，无法访问非静态成员。
3. 创建对象时，静态内部类只需要new 外部类.内部静态类名()创建；而非静态内部类需要创建外部类对象，再由外部类对象.new 内部非静态类名()创建。
4. 还有一点，我们再看输出结果，这个代码不是按顺序执行的，是静态内部类先执行的！

如果内部类的变量与外部类重名了怎么区分

/**
 * <Description><br>
 *
 * @author DaShi<br>
 * @version 1.0<br>
 * @taskId <br>
 * @CreateDate 2018/12/12 19:07 <br>
 */
public class OutClassTest {
    static int b = 1;
    public class InnerClass{
        int b = 2000000;
        void InnerMethod(){
            System.out.println("这是非静态内部类!");
            //通过this关键字访问非静态内部类成员变量
            System.out.println("通过this关键字访问非静态内部类成员b的值：" + this.b);
            //默认访问非静态内部类成员变量
            System.out.println("默认访问非静态内部类成员变量b的值：" + b);
            //通过外部类.this访问外部类成员变量
            System.out.println("通过外部类.this访问外部类成员b的值:" + OutClassTest.this.b);
            //通过外部类.变量名关键字访问外部类成员b的值
            System.out.println("通过外部类.变量名访问外部类成员b的值：" + OutClassTest.b);
        }
    }
    public static class InnerstaticClass{
        static int b = 3000000;
        void InnerstaticMethod(){
            System.out.println("这是静态内部类");
            //默认访问静态内部类成员变量
            System.out.println("默认访问静态内部类成员变量b的值：" + b);
            //通过外部类.this访问内部类成员变量
            System.out.println("通过this关键字访问内部类成员b的值:" + this.b );
            //通过外部类.变量名访问外部类成员b的值
            System.out.println("通过外部类.变量名访问外部类成员b的值：" + OutClassTest.b);
        }
    }
    public static void main(String args[]){
        OutClassTest a=new OutClassTest();
        //创建静态内部类
        OutClassTest.InnerstaticClass innerstaticClass = new OutClassTest.InnerstaticClass();
        //创建非静态内部类
        OutClassTest.InnerClass InnerClass = a.new InnerClass();
        innerstaticClass.InnerstaticMethod();
        InnerClass.InnerMethod();

    }
}

运行结果： image.png

好啦！今天的学习就到这里啦！