目录

内部类

1.成员内部类*常用

(1). 内部类和外部类之间可访问彼此的private域（通过创建对象访问）

(2).内部类的使用方法/规则

2.静态内部类 *常用

   创建对象：

      外部类的内部创建：

      外部类的外部创建：

总结：

3.方法内部类

4.匿名内部类-Lambda表达式的前身

​​​​​​​

内部类

        所谓内部类，就是将类结构的定义套在另一个类的内部。

1.成员内部类*常用

（类比成员方法）

直接定义在类中，不加任何修饰符（static）定义的类，就是成员内部类

(1). 内部类和外部类之间可访问彼此的private域（通过创建对象访问）

public class Outter {

    private String msg = "outter类中的msg属性";

    //私有内部类对外部完全隐藏，只是在类的内部来使用

    //-------------------------------

    private class Inner{

        private int num = 10;

        //直接访问外部类的msg属性

        public void test(){

            System.out.println(msg);

        }

    }

    //-------------------------------

    public void fun(){

        //通过内部类对象访问内部类的私有属性

        Inner inner = new Inner();

        //访问内部类私有属性

        System.out.println(inner.num );

        inner.test();

    }





    public static void main(String[] args) {

        Outter outter = new Outter();

        outter.fun();

    }

}

(2).内部类的使用方法/规则

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

2. 内部类是一个相对独立的实体，与外部不是is-a关系

3. 内部类可以直接访问外部类的元素和方法（包括私有域）

          外部类必须通过内部类的对象来访问内部类的元素和方法（包括私有域）

    4.成员内部类对象的创建

            外部类的内部创建

                内部类名称 内部类引用 = new 内部类（）；

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

                （创建方法：外部类名称.内部类 引用 = new 外部类（）.new 内部类（））

                成员内部类要依靠外部类才能产生所以要先创建外部对象

     5.使用内部类可以曲线实现多继承

class A {

    int numA = 10;

}





class B {

    int numB = 20;

}





public class E {

    class C extends A {

    }





    class D extends B {

    }





    public void test() {

        C c = new C();

        D d = new D();

        System.out.println(c.numA);

        System.out.println(d.numB);

    }





    public static void main(String[] args) {

        E e = new E();

        e.test();

    }

}

    6.【成员方法能访问静态域  不能拥有静态域（无法定义静态变量）；静态方法能访问静态域   不能访问成员域】

        对于成员内部类，不呢定义一个静态属性的，因为成员内部类必须要依赖于外部类，若成员内部类有静态方属性，那么没有外部类对象也能被访问了。

        对于外部类来说，不能在外部类的静态方法中使用成员内部类。比如在外部类的main方法中创建内部类对象；

2.静态内部类 *常用

（类比静态变量）

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

   创建对象：

      外部类的内部创建：

(类比类中静态变量，没有类的对象就能使用，类的静态方法可以调用，成员方法也可以)

public class Outter1 {

    //静态内部类

    static class Inner {





    }





    public void test() {

        Inner inner = new Inner();

    }





    public static void main(String[] args) {

        Inner inner = new Inner();

    }

}

      外部类的外部创建：

外部类.内部类 引用 = new 外部类.内部类(); 此时不需要产生外部对象。

public class Test {

    public static void main(String[] args) {

        Outter1.Inner inner = new Outter1.Inner();

    }

}

    静态内部类就是一个普通的类，只是套在一个类的内部而已；静态内部类可以拥有自己的成员变量，不能直接访问外部类的成员变量，可以直接访问静态变量

总结：

           成员内部类可以访问外部类的成员域和静态域，但是不能拥有静态域。   

           静态内部类可以拥有成员域，但是不能直接访问外部类的成员域，静态域，随便访问。

3.方法内部类

    直接定义在方法内部的类，不允许使用任何访问修饰符，对外部完全隐藏(出了这个方法，这个类就没了)

public void fun(int num){

    //方法内部类不能出现任何访问修饰符和static

    class Inner{

        //若此处使用了方法的形参num那么num必须声明为final

    }

}

    无法定义static域，除此之外和成员内部类的用法基本相同

    方法内部类中若使用了方法的形参，该形参为隐式的final声明(在JDK8之后，8之前，方法内部类若使用了形参，形参必须使用final声明)。

4.匿名内部类-Lambda表达式的前身

匿名内部类是方法内部类的特殊版本，直接不写类名称。

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

//匿名内部类代码示例

public class Outter3 {

    public static void fun(Imessage msg) {

        msg.printMsg();

    }





    public static void main(String[] args) {

        //普通方法

        Imessage msg = new IMessageImpl();

        fun(msg);

        //匿名内部类方法

        fun(new Imessage() {

            @Override

            public void printMsg() {

                System.out.println("匿名内部类");

            }

        });

    }

}





interface Imessage {

    void printMsg();

}





//普通用法,之前方式的接口传参使用

class IMessageImpl implements Imessage {

    @Override

    public void printMsg() {

        System.out.println("普通用法");

    }

}