静态嵌套类（Static Nested Class）和内部类（Inner Class）的区别

可以在一个类的内部定义另一个类, 这种类称为嵌套类(nested classes),它有两种类型: 
静态嵌套类和非静态嵌套类.静态嵌套类使用很少, 最重要的是非静态嵌套类, 也即是被称作为
内部类(inner).嵌套类从JDK1.1开始引入.其中inner类又可分为三种: 
(1) 在一个类(外部类)中直接定义的内部类；
(2) 在一个方法(外部类的方法)中定义的内部类;
(3) 匿名内部类.

一、什么是静态嵌套类？
直接在外部类里面定义的静态类

public class StaticTest
{
   private static String name = "gugu";
   private String num = "001";

   static class Person //静态嵌套类
   {
     private String address = "China";
     public String mail = "xxxxxx.com";//内部类公有成员

     public void display()
     {
       //System.out.println(num);//不能直接访问外部类的非静态成员
       System.out.println(name);//只能直接访问外部类的静态成员
       System.out.println("Inner " + address);//访问本内部类成员。
     }
   }

   public void printInfo()
   {
     Person person = new Person();
     person.display();

     //System.out.println(mail);//不可访问
     //System.out.println(address);//不可访问

     System.out.println(person.address);//可以访问内部类的私有成员
     System.out.println(person.mail);//可以访问内部类的公有成员

   }

   public static void main(String[] args)
   {
     StaticTest staticTest = new StaticTest();
     staticTest.printInfo();
   }
}

1.在静态嵌套类内部, 不能访问外部类的非静态成员, 这是由Java语法中"静态方法不能直接访问非静态成员"所限定.若想访问外部类的变量, 必须通过其它方法解决, 由于这个原因, 静态嵌套类使用很少.
2.外部类访问内部类的的成员有些特别, 不能直接访问, 但可以通过内部类实例来访问, 这是因为静态嵌套内的所有成员和方法默认为静态的了.同时注意, 内部静态类Person只在类StaticTest 范围内可见, 若在其它类中引用或初始化, 均是错误的.

二、什么是内部类？

内部类分为①定义在外部类的内部类②定义在方法里面的内部类③匿名内部类

特点：内部类可以直接访问外部类的成员，包括私有。
外部类要访问内部类的成员，必须创建对象

1.内部类生成外部的引用  外部类名.this
2.局部内部类只能在其所在的方法内访问
3.成员内部类私有 paivate, 其他类调用不能直接创建对象（类似私有成员变量），在外部类写一个方法，访问，类似于setXX,getXX访问私有成员,且只在外部类的范围内可见

（一）定义在外部类的内部类

class Outer {

    public String outer__public_name = "外部类public";
    private String outer_private_name = "外部类private";
    public int a =100;
    private class InnerOne  // 私有的内部类 起
    {
        public String innerone_public_name = "内部类1public";
        private String innerone_private_name = "内部类1private";

        public void display() {
            System.out.println(" Outer_outer__public_name:" + outer__public_name);
            System.out.println(Outer.this.a);

        }

        private void display2() {
            System.out.println(" Outer_outer_private_name:" + outer_private_name);
        }

    }// 私有的内部类 止

    public InnerOne getInnerOne() {
        // 即使是对外公开的方法,外部类也无法调用
        return new InnerOne();
    }

    class InnerTwo //内部类 起
    {
        InnerOne innerx = getInnerOne();// 可以访问

        public void show() {
            //System.out.println(innerone_public_name); // 不可访问Innter的y成员
            //System.out.println(innerone_private_name);   // 不可直接访问Inner的任何成员和方法
            innerx.display();// 可以访问
            innerx.display2();// 可以访问
            System.out.println(innerx.innerone_public_name);// 可以访问
            System.out.println(innerx.innerone_private_name);// 可以访问
        }
    }//内部类 止

    void test() {
        InnerOne inner = new InnerOne();// 可以访问
        inner.display();
        inner.display2();
        // System.out.println("Inner y:" + inner_y); // 不能访问内部内变量
        System.out.println("Inner y:" + inner.innerone_public_name);// 可以访问
        System.out.println("Inner z:" + inner.innerone_private_name);// 可以访问

        InnerTwo innerTwo = new InnerTwo();
        innerTwo.show();
    }
}

public class test {
    public static void main(String args[]) {
        Outer outer = new Outer();
        // Outer.InnerOne a=outer.getInnerOne();
        // InnerOne类是私有的,外部类不能访问, 如果InnerOne类是public ,则可以.
        outer.test();
    }
}

内部类InnerOne及InnterTwo只在类Outer的作用域内是可知的, 如果类Outer外的任何代码尝试初始化类Inner或使用它, 编译就不会通过.同时, 内部类的变量成员只在内部内内部可见, 若外部类或同层次的内部类需要访问, 需采用示例程序
中的方法, 不可直接访问内部类的变量.

(二)方法中定义的内部类

package com.guxilong;


public class test {
    int out_x = 100;

    public void test() {//方法内部的内部类
        class Inner {
            String inner_x = "x";

            void display() {
                System.out.println(out_x);
            }
        }
        Inner inner = new Inner();
        inner.display();
    }

    public void showStr(String str) {
        // public String str1 = "test Inner";
        // 不可定义, 只允许final修饰
        // static String str4 = "static Str";
        // 不可定义, 只允许final修饰
        String str2 = "test Inner";
        final String str3 = "final Str";
        class InnerTwo {
            public void testPrint() {
                System.out.println(out_x);
                // 可直接访问外部类的变量
                // System.out.println(str2); // 不可访问本方法内部的非final变量
                System.out.println(str3); // 只可访问本方法的final型变量成员
            }
        }
        InnerTwo innerTwo = new InnerTwo();
        innerTwo.testPrint();
    }

    public void use() {
        // Inner innerObj = new Inner();//此时Inner己不可见了
        // System.out.println(Inner.x);//此时Inner己不可见了
    }

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

从上面的例程我们可以看出定义在方法内部的内部类的可见性更小, 它只在方法内部
可见, 在外部类(及外部类的其它方法中)中都不可见了.同时, 它有一个特点, 就是方法内的内部类连本方法的成员变量都不可访问, 它只能访问本方法的final型成员.同时另一个需引起注意的是方法内部定义成员, 只允许final修饰或不加修饰符, 其它像static等均不可用. 

（三）匿名内部类

本质:是一个继承了该类或者实现了该接口的子类匿名对象

 new Inter() {

      Public void print(){

      Sysotem.out.println.(“print”);

      }

    }.print();

PS:匿名内部类只针对重写一个方法时使用

多个方法的话可以用多态来解决。

内部类调用外部定义的对象，那么其参数引用是final类型的

参考：https://blog.youkuaiyun.com/machinecat0898/article/details/80071242