Java内部类详解

内部类

含义：一个类里面声明一个类

    分类：
    	1.成员内部类
    		特点：可以调用外部类中所有的属性
    	2.静态内部类
    		特点：只能到调用外部类的静态属性
    	3.接口内部类
    		注意：接口内部类底层就是静态内部类
    	4.局部内部类
    	5.匿名内部类

内部类的应用场景1：
如果一个类的对象只在另外一个类中使用，
就可以考虑把该类变成成员内部类或者静态内部类，
如果内部类要用到外部类的所有属性就把该类变成成员内部类，
如果内部类只用到外部类的静态属性就把给类变成静态内部类

    内部类的应用场景2：
    	如果一个类的对象只在另外一个类的方法中使用，就可以考虑把该类变成局部内部类，一般不使用这种设计思想
    
    内部类的应用场景3：
    	如果一个类的对象只在接口中使用，就可以考虑把该类变成接口内部类，一般不使用这种设计思想
    
    内部类的应用场景4：
    	抽象类子类的对象或者是接口实现类对象只使用到一次，就可以考虑使用匿名内部类

成员内部类

理解

成员内部类，和实例属性 实例方法 动态代码块 构造器 是同一级别的事物，实例级别内容。

定义

//外部类
public class Foo {
    //内部类：成员内部类
    class Boo{
    }
}

成员内部类成分

//外部类
public class Foo {
    //内部类：成员内部类
    class Boo{
        int age; // OK 实例属性
        static int name; //ERROR  不能定义静态属性
        // OK 普通代码块
        {       
            
        }
        // ERROR 不可以定义
        static {
            
        }
        //OK 构造器
        public Boo(){
            
        }
        //OK 实例方法
        public void m1(){
            
        }
        // ERROR 报错不可定义静态方法
        public static void m2(){
            
        }
    }
}

不可以定义 static 相关内容，除此都可以。

成员访问规则

内部类访问外部

可以访问 实例信息和静态信息（全部），如果内部类访问外部类的同名属性默认，就近原则，通过 外部类名.this.xxx 可以强制区分外部类属性。

//外部类
public class Foo {
    int fmoney;
    static int fheight;
    public void f1(){

    }
    public static  void f2(){

    }
    //内部类：成员内部类
    class Boo{
        int age; //实例属性
        public void m1(){ //实例方法
            System.out.println( fmoney ); //OK 可直接访问
            System.out.println( fheight); //OK 可直接访问
            f1();                         //OK 可直接访问
            f2();                         //OK 可直接访问
        }
    }

}

外部类访问内部

这个简单呀，当一个类使用即可，先创建对象，再访问实例属性和实例方法。

//外部类
public class Foo {
    int fmoney;
    static int fheight;
    public void f1(){
        Boo boo = new Boo();   // 1 创建对象
        boo.m1();              // 2 对象来访问即可
    }
    public static  void f2(){
    }
    //内部类：成员内部类
    class Boo{
        int age; //实例属性
        public void m1(){ //实例方法
        }
    }
}

其他位置访问内部类

1. 需要创建对象然后使用

    public static void main(String[] args) {
        //分开来写
        Foo foo = new Foo();
        Foo.Boo boo1=  foo.new Boo();
        //一步到位
        Foo.Boo boo2 = new Foo().new Boo();
        boo2.xx();
    }

1. 通过对象引用调用属性和方法。

内 部类单独使用，声明类型的时候需要带外部类名一起声明。比如 Foo.Boo

小细节

内部类也会生成单独的字节码文件，只是这个文件名规则为： 外部类名+$+内部类名.class

成员内部类使用案例

package case2;

public class Car {
    //名字
    String brand;
    public Car(String brand){
        this.brand=brand;
    }
    //汽车行驶方法 需要发动机提供动力
    public void run(){
        System.out.println(brand+"启动");
        Engine engine = new Engine();
        engine.zhuan();
    }
    //引擎，对外不公开，专门为外部类设计，为外部类提供服务
    private class Engine {
        public void zhuan(){
            System.out.println("发动机运行");
        }
    }
}
package case2;
// 内部类使用案例
public class TestCar {

    public static void main(String[] args) {
        Car car = new Car("宝马");
        car.run();
    }
}

静态内部类

理解

静态内部类，和静态属性 静态方法 静态代码块 是同一级别的事物，是类级别内容。

定义

public class Foo {
    //静态内部类
    static class Boo{
        
    }
}

定义成分

public class Foo {
    static class Boo{
        int age ;           // 实例属性  OK 
        static int money;   // 静态方法  OK 
                            // 构造器 OK 
        public Boo(){
            
        }
                            // 实例方法 OK 
        public void m1(){}
                            // 静态方法 OK 
        public static void m2(){}
                            // 普通代码块OK 
        {
            
        }
                           // 静态代码块 OK 
        static {
        }
    }
}

从定义成分上看，几乎等价与一个普通外部类

成员访问规则

内部类访问外部类

只能访问到静态内容（静态属性 静态方法）

外部类访问内部类

就是一个普通类的访问方式：

1. 通过类名访问静态属性和方法
2. 通过对象访问实例属性和方法

其他位置访问内部类

就是一个普通类的访问方式：

1. 通过类名访问静态属性和方法
2. 通过对象访问实例属性和方法

方法内部类

理解

方法内部类，定义外部类的方法中，和方法的局部变量同级别。

定义

public class Foo {
    public void f1(){
        int age = 10;
        //方法内部类
        class Boo{
            
        }
    }
}

定义成分

 public  void f1(){
        int age = 10;
         // 内部类
         class Boo{
             //实例属性 OK
             int age;    
            
            // 构造器 OK 
            public Boo(){
                
            }
            // 动态代码块 OK 
            {
                 
            }
            public void m1(){ // 实例方法 OK
                
            }
        }
    }

只能定义实例相关信息，不可定义静态内容，且不可添加访问权限。

成员访问规则

内部类访问外部类

可以直接访问静态和实例的信息。

外部类访问内部类

就是一个普通类的访问方式：

1. 通过对象访问实例属性和方法 ，只能在内部类所在方法中使用

细节面试题

局部内部类访问 所在方法的 局部变量，要求这个变量是final修饰的，在JDK7必须强制声明为final,JDK8中无需声明，但是编译器依然要求它是一个final。

为什么呢？ 需要延长局部变量的生命周期，保证对象使用该变量时，它是存在的，通过final 修饰的变量进入常量池，会一直保存。

匿名内部类

理解

添加访问权限。

成员访问规则

内部类访问外部类

可以直接访问静态和实例的信息。

外部类访问内部类

就是一个普通类的访问方式：

1. 通过对象访问实例属性和方法 ，只能在内部类所在方法中使用

细节面试题

局部内部类访问 所在方法的 局部变量，要求这个变量是final修饰的，在JDK7必须强制声明为final,JDK8中无需声明，但是编译器依然要求它是一个final。

为什么呢？ 需要延长局部变量的生命周期，保证对象使用该变量时，它是存在的，通过final 修饰的变量进入常量池，会一直保存。

匿名内部类

理解

没有名字的内部类，是一种特殊的局部内部类。它是把类的定义和对象创建合二为一。匿名内部类只能创建一次对象。匿名内部类必须是某个接口的实现类或者是某个类的子类。