【JAVA SE】内部类

内部类

可以分为：成员内部类、静态内部类、局部内部类、匿名内部类。内部类可以降低命名空间的慌乱，定义在类的内部。

1.静态内部类

class StaticInner{
    private static  int a=4;
    
    public static  class Inner{
        
        public void test(){

            System.out.println(a);
        }
    }

public class StaticInnerClassTest {
    public static void main(String[] args) {

        StaticInner.Inner inner=new StaticInner.Inner();
        inner.test();
    }
}

可以看做类的静态成员

语法 public static class Inner{}用static 关键字修饰

static关键字修饰类只能修饰内部类，不能修饰外部类。

内部类编译之后生成单独的class文件

静态内部类访问权限：只能去访问外层的静态的成员量和方法，包括私有的。不能访问外部的非静态成员

生成静态内部类实例的方式、

OuterClass.InnerClass inner=new OuterClass.InnerClass();

2.成员内部类

class  MemberInner{

    private  int a=4;
    public  class Inner2{

        public void dosomething(){

            System.out.println(MemberInner.this.a);
        }
    }
}
public class MemberInnerClassTest {
    public static void main(String[] args) {
        MemberInner.Inner2 inner2=new  MemberInner().new Inner2();
    }
}

一个类声明在另一个类内部，且没有用static修饰，就是一个成员内部类

可以看做是外部类的一个非静态成员

可以访问外部类的所有成员

成员内部类获取实例方式

OuterClass.InnerClass inner=new OuterClass().new InnerClass

这种写法可以这么理解：成员内部类是非静态的，非静态的成员变量属于对象，成员内部类与成员变量一样，所以需要先实例化一个外部类对象

成员内部类访问外部类其他成员变量的方式  OutClass.this.a

3.局部内部类(Local Inner Class)

class  LocalInner{
    public void dosomething(){
         final  int a=4;
        class Inner3{
            public void  test(){

                System.out.println("hello world");
                System.out.println(a);
            }
        }
        new Inner3().test();
    }

public class LocalInnerClassTest {

    public static void main(String[] args) {
        LocalInner localInner=new LocalInner();
        localInner.dosomething();//对于局部内部类，外部无法访问到。可以将局部内部类当成一个局部

//变量去理解，局部变量也是无法从外部去访问的
    }
}

在类的方法中定义的内内部类部类

访问方式 

OuterClass oc=new OuterClass();

oc.doSomething();

访问权限，只能访问方法中声明的final关键字修饰的变量

4.匿名内部类（Anonymous Inner Class）

    非匿名内部类写法

class AnonymousInnerClass extends Date{
    @Autowired
    public String toLocaleString(){
        return "hello";
    }
}
public class AnonymousInnerClassTest {
    public  void print(Date date){
        System.out.println(date.toLocaleString());
    }
    public static void main(String[] args) {
      AnonymousInnerClassTest anonymousInnerClassTest=new AnonymousInnerClassTest();
       anonymousInnerClassTest.print(new AnonymousInnerClass());
    }
}

改成匿名内部类

public class AnonymousInnerClassTest {
    public  void print(Date date){
        System.out.println(date.toLocaleString());
    }
    public static void main(String[] args) {
      AnonymousInnerClassTest anonymousInnerClassTest=new AnonymousInnerClassTest();
       

     anonymousInnerClassTest.print(new Date(){
    @Autowired
    public String toLocaleString(){
        return "hello";
    }
});

}}

当我们调用某个方法时，方法的参数是一个对象的实例或其子类，而我们又不想去专门定义一个类去继承某个类或接口，那么我们可以用匿名内部类的方式实现。匿名内部类隐式的继承了一个类，或者实现了一个接口。