内部类与外部类最全面分析

内部类与外部类

一、内部类

1、成员内部类

（用法和成员方法差不多）
1、private可用内部类的声明；
2、内部类与外部类可以互相访问彼此的私有域，内部类访问外部类的私有域可以直接访问（成员内部类的内部有隐藏的外部类对象），外部类访问内部类的私有域必须通过内部类对象访问。

class Outter{
    //成员变量
    private int age = 18;
    private String name = "张三";
    //成员内部类
    class Inner{
        private String msg = "hello Inner Class";
        public void test(){
            System.out.println(msg);
            //可以访问外部类的私有域
            System.out.println(age);
        }
    }
    //外部类成员方法
    public void fun(){
        //创建内部类对象
        Inner inner = new Inner();
        System.out.println(inner.msg);
    }
}

3、内部类可以变相的解决Java单继承局限；

class A {
    protected int age = 18;
}
class B {
    protected String msg = "hello life";
}

public class Inherit {
    public static void main(String[] args) {
        Inherit inherit = new Inherit();
        inherit.fun();
    }
    class InnerClassA extends A{}
    class InnerClassB extends B{}
    public void fun(){
        InnerClassA a = new InnerClassA();
        InnerClassB b = new InnerClassB();
        System.out.println(a.age);
        System.out.println(b.msg);
    }
}

4、内部类可以对外部隐藏（private InnerClass）；

    private class InnerClassA extends A{}
    private class InnerClassB extends B{}

2、静态内部类

1、定义：定义在外部类的内部使用static修饰
2、注意：静态内部类无需外部类对象产生就能使用，不能访问外部类的成员域，能访问静态域，静态内部类可以有自己的成员域。

class Outter{
    static int age = 19;
    String name = "张三";
    //静态内部类
    static class Inner{
        public void test(){
            System.out.println(age);
            System.out.println(name);//报错代码
        }
    }

3、与成员内部类的区别
成员内部类：必须要有外部类对象（成员方法），成员内部类能访问外部的静态域，不能拥有静态域。
静态内部类：不依赖外部类对象（静态方法），静态内部类能拥有成员域，不能访问外部类的成员域。

3、方法内部类

1、定义：定义在方法内部
2、注意：
（1）对外部完全隐藏，因此方法内部类不能有任何访问修饰；
（2）若使用方法的形参，只能用不能改（形参的隐式final声明）。
a：方法内部类没有访问形参时，这个形参可以在方法中随意修改；
b：方法内部类使用了形参，这个形参必须被声明为final。

public class Inherit {
    private int age =19;
    public void fun(int age){
        int finalAge = age;
        class Inner{
            void fun(){
                System.out.println(finalAge);
            }
        }
        age = 20;
    }

4、匿名内部类

1、定义：也是定义在方法中，类都没有名字。经常用于多线程部分。
2、注意：
（1）必须继承一个接口类或者实现一个接口；
（2）没有构造方法。

//定义了一个实现IMessage接口的类，只是这个类没有名字，只能用这一次就销毁了
interface IMessage{
    void fun();
}
public class NoNameClass {
    public static void main(String[] args) {
        //声明接口对象
        IMessage msg = new IMessage() {
            //匿名内部类
            @Override
            public void fun() {
                System.out.println("hello life");
            }
        };
        msg.fun();
    }
}

二、内部类与外部类的关系

1、成员内部类的创建需要依赖外部类对象，在没有外部类实例之前无法创建成员内部类对象；

2、内部类与外部类相对独立；

3、私有属性的互相访问；

4、创建内部类的语法；

（1）在外部类内部创建内部类对象（以上文中显示）；
（2）在外部类外部创建内部类对象；

class Test{
    public static void main(String[] args) {
        Outter.Inner inner = new Outter.Inner();
    }
}

5、在内部类的内部使用隐藏的外部类对象（隐藏的this）

class Outter{
    private int age = 19;
    class Inner{
        private String msg = "hello life";
        public void test(){
            System.out.println(msg);
            //可以访问外部类的私有域
            System.out.println(Outter.this.age);
        }
    }