四种内部类详解

内部类就是嵌套在其他类内部的类，共分为四种，分别是：成员内部类、静态内部类、方法内部类、匿名内部类。

1. 成员内部类：

//外部类Outter
public class Outter {
    //外部类的私有属性
    private int age = 20;
    private String name = "xiaoli";
    
    //内部类
    class Inner{
        //内部类的私有属性和方法
        private String msg = "inner class";
        private void test(){
            System.out.println(age);
            System.out.println(msg);
        }
    }
    
    //外部类方法
    public void fun(){
        Inner inner = new Inner();
        System.out.println(inner.msg);
        inner.test();
    }
}

这里我们定义的Inner类就是Outter类的内部类，定义在一个类的内部。
成员内部类就好比是外部类的一个成员方法，可以类比成员方法理解。
成员内部类的相关知识点：
（1）外部类在声明的时候不可以用private，但是内部类可以。 外部类不能是私有的，但是内部类可以是这个外部类所私有的，就好比发动机类就是汽车类的一个私有类。
（2）内部类与外部类可以互相访问私有域。 私有域的意义就是在所在的这个大括号内可以用，那么成员内部类在外部类的大括号中所以，内部类一定可以直接访问外部类的私有域。而外部类在访问内部类的死有余的时候需要先定义一个内部类的对象，通过对象访问。在内部类调用外部类私有域的时候其实是有一个隐藏的this的。

//外部类的私有属性
    private int age = 20;
    private String name = "xiaoli";

    //内部类
    class Inner{
        //内部类的私有属性和方法
        private String msg = "inner class";
        private int age = 18;
        private String name ="xiaozhang";
        private void test(){
            //我们在内部类内部访问外部类私有域通过Outter.this.来访问
            System.out.println(Outter.this.age);
            System.out.println(Outter.this.name);
            //内部类自己的私有域就也可以使用this也可以不用
            System.out.println(this.msg);
            System.out.println(this.age);
            System.out.println(name);
        }
    }

（3）内部类可以变相解决java单继承的局限。

class A{
    protected int age = 18;
}
class B{
    protected String name = "xiaoli";
}
class C{
    protected double score = 99.9;
}

class Outter2 extends A{
    //外部类内部的所有父类都可以各自继承一个父类
    class Inner2 extends B{
    }
    class Inner3 extends C{
    }
}

外部类的所有内部类都可以再继承其他的父类，这样就变相解决了java单继承的局限。
（4）成员内部类的创建需要依赖外部类对象，没有外部类实例之前，无法创建成员内部类对象。 成员属性是需要根据对象来使用的，所以成员内部类也是一样。
（5）内部类与外部类是相互独立的，不是继承关系。 发动机类和汽车类是没有继承关系的。
（6）在外部类的内部创建内部类对象：在外部类的内部创建访问内部类的私有域需要创建对象，那么在外部类的内部创建对象就是：Inner inner = new Inner();
（7）在外部类的外部创建内部类对象：Outter.Inner inner = new Outter().new Inner();
（8）成员内部类不能有静态域。 因为成员内部类依赖对象产生，所以他不可以有自己的静态域，但是它可以访问外部类的静态域。

2. 静态内部类
创建在外部类内部的被static修饰的类。

class StaticOutter{
    int age = 20;
    static String name = "xiaoli";
    //用static修饰的内部类
    static class StaticInner{
        //内部类自己的属性和方法
        int age = 18;
        String name = "xiaozhang";
        public void test(){
            System.out.println(age);
            System.out.println(name);
        }
    }
}

静态内部类无需外部类对象就可以创建，他可以访问外部类的静态域，但是不可以访问外部类的成员域。

当我们访问外部类的成员域时就会报错。

3. 方法内部类
定义在方法内部的类。
（1）但是他对外部完全隐藏，所以不能有任何访问修饰符
（2）若要用方法的形参，只能用，不能改

若方法内部类没有使用方法的形参，那么在方法中这个形参可以任意修改。

若方法内部类使用了这个形参，那么这个形参必须声明为final。

但是我们发现在方法内部类第一张图我们没有将形参用final修饰也可以用，是因为他有一个隐式的final声明。

4. 匿名内部类
经常用在多线程的部分
（1）必须继承一个抽象类或一个方法
（2）没有构造方法

interface IMessage{
    void fun();
}
class NonNameClass{
    public static void main(String[] args) {
        IMessage msg = new IMessage() {
            @Override
            public void fun() {
                System.out.println("hello inner class");
            }
        };
        msg.fun();
    }
}

匿名内部类没有名字，只用一次。