java内部类简单用法

package innerClass;
/**
 * 特点
 * 1：增强封装性，通过把内部类隐藏在外部类的里面，使得其他类不能访问外部类。
 * 2:增强可维护性。
 * 3：内部类可以访问外部的成员。
 * @author Administrator
 *
 */
class InnerClassDemo {
    String str="Out";
    static  String str1="static";
    public static void outstaticStr() {
        System.out.println();
    }
    public void outStr() {
        StaticInner staticInner=new StaticInner();
        staticInner.staticStr();
        String c= StaticInner.strInnerSt;
        String InnerC=Inner.InnerStaticelements;
        System.out.println(str);
        Inner inner =new Inner();
        System.out.println(inner.str);

        inner.innerStr();
    }
    /**
     * 实例内部类
     * @author Administrator
     *1：实例内部类是对象的内部类，把它当成对象看待。不能用static修饰
     *2：实例内部类存在一个外部类的引用
     *3： 实例内部类可以直接访问外部类的成员 用外部类.this的引用访问外部类 ，内部类静态成员直接用外部类.成员访问。
     *4;外部类要创建一个内部类的对象，然后再访问内部类的成员。静态成员直接用内部类.成员。
     *5:实例内部类的静态成员必须是fianl
     */
    public class Inner{
        String str="inner";
        static final String InnerStaticelements="staticInner";

        public  void innerStr()    {
            InnerClassDemo.outstaticStr();
            System.out.println(this.str);
            System.out.println(InnerClassDemo.this.str);

        }
    }
    /**
     *
     * @author Administrator
     * 内部类加上static就是静态内部类
     * 静态内部类没有在堆开辟一个空间存放执行外部类的引用。
     * 静态内部类可以直接访问外部类的静态成员（不需要外部类.外部类成员），通过new 外部类访问外部类的非静态类成员。
     * 静态内部类可以创建非静态的成员。
     *外部类可以通过new 静态内部类的对象访问内部类的非静态成员，通过静态内部类.成员的方式访问内部类静态成员
     */
     static class StaticInner{
        static String strInnerSt="rewre";
        String srt="staticInner";
        public void staticStr() {
            System.out.println(new InnerClassDemo().str);
            System.out.println(str1);
        }
    }
     /**
      * 局部内部类不能设置访问权限private public 等等
      * 局部内部类定义在方法，使用也在方法中
      * 局部内部类不能包含静态变量
      * 通过访问外部的成员，静态的用外部.成员的方式，普通的就是用new 外部内的方式。
      * 外部类不能访问内部类成员
      */
     public  void showLocalInner() {
          class  LocalInner{
             String  local="localInner";
              public  void localMethods(){
                 System.out.println(str);
             }

         }
          System.out.println(new LocalInner().local);
          localMethods();
     }
     /**
      * 匿名类 一般使用在事件开发中，安卓，GUI开发中，只使用一次，。
      * 可以非静态成员通过new的外部类的方式访问外部类的成员,静态成员则通过外部类.的方式访问外部类静态成员
      *
      */
     Runnable run =new Runnable() {

        @Override
        public void run() {
            // TODO Auto-generated method stub
            System.out.println(str);

        }
    };

}

package innerClass;

import innerClass.InnerClassDemo.Inner;

public class TestInnerClass {
    public static void main(String[] args) {
         InnerClassDemo.Inner inner=new InnerClassDemo().new Inner();//其他类访问实例内部类的方式
         inner.innerStr();

         System.out.println(InnerClassDemo.StaticInner.strInnerSt);//在外部可以通过 外部类.内部类.内部类成员访问内部类的静态成员

    }
}

原文地址：https://www.cnblogs.com/shareAndStudy/p/12586861.html