内部类分类

1. 普通内部类
2. 静态内部类
3. 局部内部类
4. 匿名局部内部类（匿名内部类）

普通内部类

/**
 * 内部类的好处
 * 1.内部类可以访问外部类的私有变量
 * 2.内部类修饰符为private,使得内部类只能在外部类中使用，可以进一步封装功能
 * 3.内部类不能有静态数据，因为要先创建外部类对象才能再创建内部类
 */
public class Outer {

    private String name = "kevinlsui";

    public void sayHello(){
        System.out.println("i am Outer");
    }


    private class Inner{
        private  String name = "jack";
        public void sayHello(){
            System.out.println("I am Inner");
        }
        public void sayName(){
            String name = "haha";
            System.out.println("name:"+name);//1.先找局部变量，2.再找当前类属性，3.外部类属性
            System.out.println("name:"+this.name);
            System.out.println("name:"+Outer.this.name);
        }
    }

    public void haha(){
        Inner inner = new Inner();
        inner.name = "xiugai";
        inner.sayName();

    }

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

        //内部类实例化
        Outer.Inner inner = outer.new Inner();
        inner.sayHello();

        //内部类使用外部类的private属性
        //inner.sayName();

        //如果内部类的访问修饰符为private,则只能在此类当中使用，不能再外部使用


        //使用各种属性，
        inner.sayName();

        //外部类也是可以使用内部类私有变量的
        outer.haha();
    }
}

静态内部类

/**                                                                                                                                             
 * 静态内部类                                                                                   
 * 1、静态的，不需要外部类的对象来实例化内部类  
 * 附：只有内部类才可以使用static修饰，一般类不用此修饰符      
 * 2.使用外部类的属性，必须是静态的                                                                       
 */                                                                                        
public class OuterStatic {                                                                 
    private  static String name = "outer";                                                 
    public static class InnerStatic{                                                       
        //private String name = "inner";//不一定要静态，因为内部类的方法不是静态的，会创建对象                       
        public void say(){                                                                 

            System.out.println("111："+name);                                               


        }                                                                                  
    }                                                                                      

    public static void main(String[] args) {                                               
        //创建对象，2种方式                                                                        
        OuterStatic.InnerStatic innerStatic = new OuterStatic.InnerStatic();               
        //InnerStatic innerStatic = new InnerStatic();                                     

       //只能使用外部类的静态变量。自己内部无所谓                                                              
        innerStatic.say();                                                                 
    }                                                                                      
}                                                                                          

局部内部类

/**
 * 
 */
public class Outer2 {
    public void say(){

        final String name = "kevinlsui";

        class Inner{
           public void sayHello(){
                System.out.println("ceshi:"+name);
            }
        }
        //1.方法内部使用 2.传参数只能使用final（引用类型，可以修改其值）
        Inner inner = new Inner();
        inner.sayHello();
    }

    public static void main(String[] args) {
        new Outer2().say();
    }
}

匿名局部内部类

/**
 * 
 */
public class Test1 {
    public static void main(String[] args) {
        new Thread (){
            @Override
            public void run() {
                System.out.println("匿名内部类");
            }
        }
    }
}