【Java笔记】内部类 - 成员内部类、 静态内部类、方法内部类、匿名内部类的详解

1.成员内部类

class Outer{
    private String message = "Outer的消息";
    //成员内部类    
    class Inner{
        private String message ="Inner的消息";
        //4.static final 属性 => 常量
        private static final int VALUE =2;
        //成员方法
        public void print(){     
            //1.成员内部类可以直接访问外部类的成员属性，访问方法Outer.this.外部类的成员属性
            System.out.println("Inner print:" + message);//内部类中没有message这个属性时隐性地指Outer中的.
            System.out.println("Inner print:" + Outer.this.message);
        }
        //3. 不能有静态属性和方法
        /*
        public static void print(int a){
            System.out.println("====static====");
        }
        */
    }
    //5.外部类使用内部类的对象
    //(5.1)在外部类内部实例化内部类的对象
    public void print(){
        System.out.println("Outer print：");
        Inner inner = new Inner();
        inner.print();
    }
    //(5.2) 通过外部类的构造方法或者方法传入内部类的对象  
    public void print(Inner inner){
        System.out.println("== Outer print：");
        inner.print();
    }
}
public class TestInner{
    public static void main(String[] args){
        Outer outer = new Outer();
        //2.内部类实例化
        Outer.Inner inner = outer.new Inner();
        outer.print(inner);
        System.out.println("Outer:"+ outer);
    }
}

总结：

（1）成员内部类可以直接访问外部类的成员属性，访问方法Outer.this.外部类的成员属性

（2）成员内部类是依附于外围类的，所以只有先创建了外围类才能够创建内部类

         成员内部类实例化：

         外部类.内部类 内部类对象 = new 外部类().new 内部类();
         Outter.Inner in = new Outter().new Inner();

（3）成员内部类中不能存在任何static的变量和方法，可以使用static final修饰属性，即常量
（4）外部类使用内部类的对象，可以在外部类内部实例化内部类的对象，也可以通过外部类的构造方法或者方法传入内部类的对象  。

2. 静态内部类

class Outer{
    private static String message = "Outer的消息";
    //静态内部类
    //1. static 修饰类
    static class Inner{    
        public void print(){
            System.out.println(message);//2. 静态内部类不能访问外部类的非静态属性和方法    
            System.out.println("static Inner 的消息");
        }
        public static void print(int a){
            System.out.println(a);
        }
    }
    public void print(){
        Inner inner = new Inner();
    }
}
public class TestInner2{
    public static void main(String[] args){
        //3. 静态内部类使用：
        //外部类.内部类  对象名 =  new 外部类.内部类();
        Outer.Inner inner  = new Outer.Inner();
        inner.print(); 
    }

}

总结：  

（1） 静态内部类的创建是不需要依赖于外围类，可以直接创建

          静态内部类使用：
          外部类.内部类  对象名 =  new 外部类.内部类();
          Outer.Inner inner  = new Outer.Inner();
（2）静态内部类不可以使用任何外围类的非static成员变量和方法，而内部类则都可以

3.方法内部类

class Outer{
    private static int num;
    public void display(int args){
        //方法内部类-局部内部类
        final int a =10;
        int b = a;//如果还是想要修改10这个值，可以使用临时变量
        class Inner{
            public void print(){
                num++;//可以访问
                System.out.println("Outer的成员属性num="+num);
                System.out.println("Outer的成员方法参数args="+args);
                System.out.println("局部变量：a="+a);//2.JDK8之前a必须被final修饰，JDK8 隐式添加final
            }
        }
        new Inner().print();  //1.对外隐藏，只能在这个方法中访问，其他地方是不允许访问的。
    } 
}
public class TestInner3{
    public static void main(String[] args){
        Outer outer = new Outer();
        outer.display(100);
    }
}

总结：

（1）局部内类不允许使用访问权限修饰符 public private protected 均不允许
（2） 局部内部类对外完全隐藏，除了创建这个类的方法可以访问它其他的地方是不允许访问的。
（3） 局部内部类要想使用方法形参，该形  参必须用final声明(JDK8形参变为隐式final声明)

4. 匿名内部类

//2. 必须继承一个抽象类或者实现一个接口
interface Chat{
   //public  
    void sendMessage();
}
public class TestInner4{
    public static void main(String[] args){
        //1.没有类名,没有构造方法,没有访问修饰符
        /*
        Chat chat =  new Chat() {
              public void sendMessage(){
                  System.out.println("匿名内部类的方法执行");
              }
        };
        chat.sendMessage();
        */
        int a = 10; //final
        new Chat() {
            public void sendMessage(){
                System.out.println("匿名内部类的方法执行");
                System.out.println(a);
            }
        }.sendMessage();   
    }  
}

总结：

（1）匿名内部类是没有访问修饰符的。
（2）匿名内部类必须继承一个抽象类或者实现一个接口
（3）匿名内部类中不能存在任何静态成员或方法
（4）匿名内部类是没有构造方法的，因为它没有类名。
（5）与局部内部相同，匿名内部类也可以引用方法形参。此形参也必须声明为 final