目录

一、成员内部类

概念

成员内部类对象的产生

外部类的内部: 语法就和普通类一样。

外部类的外部: 前提是内部类对于外部的这个类可见的。

成员内部类代码示例

二、静态内部类

概念

静态内部类对象的产生

外部类的内部: 就和普通类的用法相同

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

静态内部类代码示例

三、方法内部类(局部内部类)— 类比局部变量

概念

方法内部类代码示例

四、匿名内部类(lambda表达式的前身。函数式编程)

概念

匿名内部类代码示例

概念

直接定义在类中，不加static定义的内部类 - 成员方法或属性。成员内部类必须依赖外部类的存在而存在，必须先有外部类对象才能产生成员内部类。

成员内部类对象的产生

外部类的内部: 语法就和普通类一样。

Inner in = new Inner0;

外部类的外部: 前提是内部类对于外部的这个类可见的。

Outter.Inner in = new Outter().new Inner0;

new Outter() 产生了外部类对象， 然后通过此对象来构造内部类对象 => 当产生内部类对象时，构造这个内部类的外部类对象就会被编译器传入内部类。

内部类和外部类可以方便的访问彼此的私有域。
内部类访问外部类的私有域直接访问(内部类中隐藏了一个外部类对象)。

成员方法能访问静态域，不能定义静态属性。
对于成员内部类来说，能否定义一个静态变量？                                                                            答:不能，成员内部类必须要依赖外部类，若成员内部类有静态属性，没有外部类对象也能访问。

class Inner {
   private static int test = 10;//报错
}

对于外部类来说，能否在外部类的静态方法中使用成员内部类?                                                    答: 不能，相当于在静态方法中调用成员变量。
比如:在外部类的main中创建内部类对象

public static void main(String[] args) {
    Inner inner = new Inner();//报错
}

成员内部类代码示例

public class Outter {
    private String msg = "outter类中的msg属性";
    // 心脏和发动机都属于私有内部类，对外部完全隐藏，只是在类的内部来使用
    // ---------------------------
    class Inner {
        private int num = 10;
        private String msg = "内部类的msg属性";
        public void test() {
            // 直接访问外部类的msg属性
            // 此处直接访问了外部类的私有成员变量msg，成员变量必须通过对象访问
            System.out.println(Outter.this.msg);
        }
    }
    // ---------------------------
    public void fun() {
        // 通过内部类对象访问内部类的私有属性
        Inner inner = new Inner();
        inner.test();
    }

    public static void main(String[] args) {

    }
}

二、静态内部类

概念

定义在类中，使用static修饰的内部类就是静态内部类。静态内部类不需要依赖外部类对象!

静态内部类对象的产生

外部类的内部: 就和普通类的用法相同

//成员方法创建成员内部类对象 inner
public void test(){
   Inner inner = new Inner();
}

//静态方法创建成员内部类对象 inner
public static void main(String[] args) {
   Inner inner = new Inner();
}

为何成员方法和静态方法都能创建成员内部类对象?
答：类比类中静态变量,没有类的对象就能使用，类的静态方法可以调用，成员方法也可以。

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

Outter1. Inner inner = new outter1. Inner() ;       //此时不需要产生外部类对象

静态内部类就是一个普通的类，只是套在了一个类的内部而已。
静态内部类能否拥有成员变量?  能否访问外部类的成员变量?
答：普通类能否定义自己的成员变量?静态内部类可以存在成员域。不能，外部类的成员变量有对象才能访问，此时内部类就没有外部类对象，因此无法直接访问。

静态内部类代码示例

//静态内部类的示范
public class Outter1 {
    private static int test = 100;
    private String msg = "外部类的成员变量";
    //静态内部类，就是一个普通类，只是把他套在Outter1里
     static class Inner{
        static int num = 10;
        int age = 3;
        public void fun(){
//            System.out.println(msg);//程序错误
            System.out.println(new Outter1().msg);//可以通过new外部类对象来访问成员域
            System.out.println(test);
        }
    }

    //成员方法创建成员内部类对象 inner
    public void test(){
        Inner inner = new Inner();
    }

    //静态方法创建成员内部类对象 inner
    public static void main(String[] args) {
        Inner inner = new Inner();
        inner.fun();
    }
}

成员内部类可以访问外部类的成员域和静态域，但是不能拥有静态域。
静态内部类可以拥有成员域，但是不能直接访问外部类的成员域，可以通过new-个外部类对象来访问静态域，随便访问。

三、方法内部类(局部内部类)— 类比局部变量 概念

直接定义在方法内部的类，不允许使用任何访问修饰符，对外部完全隐藏(出了这个方法，这个类就没了)。
方法内部类无法定义static域，除此之外和成员内部类的用法基本相同。
方法内部类中若使用了方法的形参，该形参为隐式的final声明(JDK8之后，JDK8之前，方法内部类若使用了形参，形参必须使用final声明)

方法内部类代码示例

//方法内部类示例
public class Outter2 {
    private int age = 10;
    //在方法内部嵌套一个内部类
    public void fun(int num){
        //方法内部类，不能出现任何访问修饰符private public和static
        class Inner{
            public void test(){
                System.out.println(age);
                System.out.println(num);
//                //以下两行报错
//                num++;
//                System.out.println(num);//从内部类引用的本地变量必须是最终变量或实际上的最终变量
            }
        }
        //此时Inner使用num这个变量,num就变成了隐式的final，值不能修改
//        num ++;
        System.out.println(num);

        //创建方法内部类对象
        Inner inner = new Inner();
        //调用方法内部类的test方法
        inner.test();
    }
    public static void main(String[] args) {
        Outter2 outter2 = new Outter2();
        outter2.fun(20);
    }
}

//执行结果
//20
//10
//20

四、匿名内部类(lambda表达式的前身。函数式编程) 概念

匿名内部类遵从方法内部的所有要求，匿名内部类默认会继承一个类(普通类和抽象类都可以，一般是继承抽象类或者实现接口)或实现一个接口。

匿名内部类代码示例

//匿名内部类
public class Outter3 {
    public static void fun(IMessage msg){
        msg.printMsg();
    }

    public static void main(String[] args) {
        fun(new IMessage() {
            //这就是一个匿名内部类
            //等同于创建了一个类实现了Imessage接口，创建该类的对象
            @Override
            public void printMsg() {
                System.out.println("匿名内部类的用法");
            }
        });
//        IMessage msg = new IMessageImpl();
//        fun(msg);
    }
}
interface IMessage{
    //定义抽象方法
    void printMsg();
}
class IMessageImpl implements IMessage{
    @Override
    public void printMsg() {
        System.out.println("普通用法");
    }
}

---

本节完^_^