Java 内部类的意义？什么是内部类？ Java编程思想一书中，如此描述：可以将一个类的定义放在另一个类的定义内部，这就

什么是内部类？

Java编程思想一书中，如此描述：可以将一个类的定义放在另一个类的定义内部，这就是内部类。

内部类的几种形式

先看一下内部类的几种形式：内部类可以分为成员内部类、局部内部类、静态内部类、匿名内部类

1.成员内部类

public class OuterClass {
    //成员变量
    private String outerName;
    //成员方法
    public void display() {
        System.out.println("OuterClass display");
        System.out.println(outerName);
    }

    //成员内部类（也叫非静态内部类）
    public class InnerClass {
        private String innerName;
        public void display(){
            System.out.println("InnerClass display");
            System.out.println(innerName);
        }

        public InnerClass() {
            innerName = "inner class";
        }
    }

    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        outerClass.display();
        //成员内部类用要通过外部类的对象来构造内部类，另一方面来说内部类持有外部类的引用
        OuterClass.InnerClass innerClass =outerClass.new InnerClass();
        innerClass.display();
    }
}

//输出
OuterClass display
null
InnerClass display
inner class

2.局部内部类

public class OuterClass1 {
    //成员变量
    private String outerName;
    //成员方法
    public void display() {
        class InnerClass {
            public void print() {
                System.out.println("method inner class");
            }
        }
        InnerClass innerClass = new InnerClass();
        innerClass.print();
    }
    
    public static void main(String[] args) {
        OuterClass1 outerClass = new OuterClass1();
        outerClass.display();
    }
}
//输出
method inner class

3.静态内部类

public class OuterClass2 {
    //成员变量
    private String outerName;
    //成员方法
    public void display() {
        System.out.println("OuterClass display");
        System.out.println(outerName);
    }

    //静态内部类
    public static class InnerClass {
        private String innerName;
        public void display(){
            System.out.println("InnerClass display");
            System.out.println(innerName);
        }

        public InnerClass() {
            innerName = "inner class";
        }
    }

    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        outerClass.display();
        //静态内部类不需要外部类的对象来创建，和局部内部类做对比
        InnerClass innerClass = new InnerClass();
        innerClass.display();
    }
}
//输出
OuterClass display
null
InnerClass display
inner class

4.匿名内部类

//定义一个接口
public interface MyInterface {
    public void testMethod();
}
//定义实现类
public class TestClass implements MyInterface{
    @Override
    public void testMethod() {

    }
}
//使用
public class OuterClass3 {
    public static void main(String[] args) {
        //实现类
        MyInterface testClass = new TestClass();
        testClass.testMethod();
        //匿名内部类
        MyInterface myInterface = new MyInterface() {
            @Override
            public void testMethod() {

            }
        };
        myInterface.testMethod();
    }
}

为什么要使用内部类：

个人觉得内部类的特点就是两个，其他的说明都是基于这两点：

体现封装性，保护程序内部实现不暴漏给外部
可以实现多重继承，来解决java不能多继承父类这一弊端。

4种内部类的相关特性：

一.成员内部类

一个类中直接定义的内部类，成员内部类与普通类的成员没什么区别，可以与普通成员一样进行修饰和限制。成员内部类不能含有static的变量和方法。

二.局部内部类

在方法中定义的内部类称为局部内部类。与局部变量类似，局部内部类不能有访问说明符，因为它不是外围类的一部分，但是它可以访问当前代码块内的常量，和此外围类所有的成员。

局部内部类只能在定义该内部类的方法内实例化，不可以在此方法外对其实例化。
局部内部类对象不能使用该内部类所在方法的非final局部变量。

三、静态内部类

　　如果你不需要内部类对象与其外围类对象之间有联系，那你可以将内部类声明为static。这通常称为嵌套类（nested class）。想要理解static应用于内部类时的含义，你就必须记住，普通的内部类对象隐含地保存了一个引用，指向创建它的外围类对象。然而，当内部类是static的时，就不是这样了。嵌套类意味着：

要创建嵌套类的对象，并不需要其外围类的对象。
不能从嵌套类的对象中访问非静态的外围类对象。

四、匿名内部类

匿名内部类不能有构造方法。
匿名内部类不能定义任何静态成员、方法和类。
匿名内部类不能是public,protected,private,static。
只能创建匿名内部类的一个实例。
一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。
因匿名内部类为局部内部类，所以局部内部类的所有限制都对其生效。

匿名内部类通常作为接口的匿名实现来存在。

总结：

个人觉得内部类算是一个java的陈旧机制，因为当初设计java的时候，是早期阶段。java很多特性也避免不了语言的不成熟性，当然内部类也有很多优点，在list的实现中，通过匿名类来实现迭代器机制，可以有效地帮助程序员熟悉匿名类的重要性。