理解java中的内部类

1、内部类定义

内部类：将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。内部类也是一种封装（保护性）
内部类类比现实生活中的汽车与发动机、人和心脏。
注意：

• 内部类和外部类可以方便的互相访问彼此的private域。
• 内部类可以直接访问外部类的私有属性，但外部类要访问内部类的私有属性，必须创建内部类对象，再通过创建的内部类对象访问。
• 内部类是一个相对独立的个体，与外部类不是is a关系（人体和心脏）

// 内部类和外部类可以方便的互相访问彼此的private域，人和心脏
public class Outter {
    private String msg="outter类中的mag属性";
    // ===================================================
    // 内部类：心脏发动机都属于私有内部类，对外部完全隐藏，只在类内部使用
    class Inter{
        private int num=10;
        public void test(){
            // 直接访问外部类的msg私有属性
            System.out.println(msg); // outter类中的mag属性
        }
    }
    //====================================
    // 在外部类定义一个方法
    public void fun(){
        // 通过内部类对象访问内部类的私有属性
        Inter inter = new Inter();
        // 访问inter类的私有属性
        System.out.println(inter.num); // 10
        inter.test();
    }
    public static void main(String[] args) {
        Outter outter=new Outter();
        outter.fun();
    }
}

运行结果：10
outter类中的mag属性

内部类一般分为四种成员内部类、静态内部类、方法内部类和匿名内部类

2、成员内部类

成员内部类：直接定义在类中不加任何修饰符（static）定义的类
成员内部类可以类比成员方法/属性，成员方法能访问静态域，不能拥有静态域。
注意

• 成员内部类必须依赖于外部类。
• 成员内部类能否定义一个静态变量？不能，成员内部类必须依赖于外部类，若成员内部类有静态属性，没有外部类也能访问。
  成员内部类对象的创建有两种：
• 1.外部类的内部创建
  和使用其他普通类没什么区别

内部类名称 引用 = new 内部类();
Inter inter = new Inter();

• 2.外部类的外部创建
  在外部类的外部创建内部类对象-内部类要对外部可见（访问权限问题）

外部类名称.内部类 引用=new 外部类().new 内部类();
Outter.Inter in=new Outter().new Inter()

3、静态内部类（类比静态方法）

静态内部类：定义在类中，用static修饰的内部类
注意

• 与成员内部类的区别：静态内部类不需要依赖外部类对象！
• 静态内部类不可以使用任何外部类的非static类（包括属性和方法），但可以存在自己的成员变量。
• 静态内部类就是普通类，只是套在了类的内部而已
• 成员内部类可以访问外部类的成员域和静态域，但不能拥有静态域；静态内部类可以拥有成员域，但不能直接访问外部类的成员域，静态域，随便访问。静态方法能访问静态域不能访问成员域
  创建静态内部类对象有两种方式
• 1.外部类的内部

// test成员方法
    public void test(){
        Inner inner=new Inner();
    }
    // main静态方法
    public static void main(String[] args) {
        Inner inner=new Inner();

    }

• 2.外部类的外部
  外部类.内部类 引用 = new 外部类.内部类();
  

4、方法内部类（类比静态方法）

方法内部类： 直接定义在方法内部的类，不允许使用任何访问修饰符，对外部完全隐藏，出了方法就没有了。
注意：

• 方法内部类无法定义static域，除此之外和成员内部类的使用相同
• 方法内部类若使用了方法的形参，该形参为隐式的final声明

// 方法内部类
public class MthodClass {
    public void fun(int num){
        // Inner方法内部类，不能出现任何修饰符
        class Inner{
            public  void test(){
                System.out.println(num); // 10
            }
        }
        // 此时Inner没有使用num这个变量
        //num++;
        //System.out.println(num);
        // 此时Inner使用num变量，num就变为隐式的final，值不能被修改
        System.out.println(num);
    }
    public static void main(String[] args) {
        MthodClass mthodClass=new MthodClass();
        mthodClass.fun(10);
    }
}

4、匿名内部类（Lambda表达式的前身-函数式编程）

匿名内部类是方法内部类的特殊，不写类名称。
匿名内部类遵从方法内部类的所有要求
匿名内部类默认会继承一个类或实现一个接口。