内部类又称嵌套类。内部类是指在外部类的内部再定义一个类，内部类可以是静态的，也可以用public、default、protected和private修饰。
内部类划分
-
静态内部类
静态内部类不能访问外部类的非静态成员变量 - 非静态内部类
非静态内部类能访问外部类的一切成员，包括私有成员。外部类不能直接访问内部类的成员，但可以通过内部类的实例访问内部类的私有成员。-
成员内部类
成员内部类不能含有static的变量和方法。因为成员内部类需要先创建了外部类，才能创建它自己的。
成员内部类不能有static修饰的成员，但是却允许定义常量。
-
成员内部类
public class OuterClass {
private String name;
static class StaticInerCls{
private String name;
}
class InerCls{
private String name;
private static int id; //不允许，会报错
private static final int TYPE = 0; //允许
}
}
-
局部内部类
指内部类定义在方法体内，只能在该方法或条件的作用域内才能使用，退出这作用域就无法引用。
局部类不仅可以访问外部类的所有成员，还可以访问方法体的局部变量，但必须是final修饰的局部变量。
为什么要final呢？这是作用域的问题。在方法执行结束后，局部变量就被销毁了，而在方法中new的局部内部类，还会持有方法的引用。这样就导致外部对象可能访问了一个不存在的变量，因此需要用final进行修饰。
而final进行修饰过的局部变量，在局部内部类中使用，实际上是对该局部变量进行了copy，将其拷贝到局部内部类中，后续使用持续维护这个对象在生命周期内，所以可以继续访问。 -
匿名内部类
为了免去给内部类命名，或者只想使用一次，就可以选择使用匿名内部类。
内部类的四大作用
- 可以很好的实现隐藏
一般非内部类是没有private、protected权限，而内部类有，因此可以将一些实现进行隐藏。 - 内部类拥有外部类所有元素的访问权限（包括private）
静态内部类只能访问外部类的静态元素。 - 间接的实现了外部类的多继承
Java只能单继承，但是可以实现多个接口。但是使用接口有时会有诸多不便，比如实现一个接口就必须实现它里面所有的方法，否则类必须声明为抽象类。
而内部类可以通过让多个内部类分别继承多个其他类，使外部类可以同时获取多个其他类的属性，从而间接的实现多继承。
public interface Contents {
int value();
}
public interface Destination {
String readLabel();
}
public class Goods {
// 内部类
private class Content implements Contents {
private int i = 11;
public int value() {
return i;
}
}
// 内部类
protected class GDestination implements Destination {
private String label;
private GDestination(String whereTo) {
label = whereTo;
}
public String readLabel() {
return label;
}
}
public Destination dest(String s) {
return new GDestination(s);
}
public Contents cont() {
return new Content();
}
}
class TestGoods {
public static void main(String[] args) {
Goods p = new Goods();
// 间接实现类的多继承，
Contents c = p.cont();
Destination d = p.dest("Beijing");
}
}
- 可以避免修改接口而实现同一个类中两种同名方法的调用
假设一个类继承一个类，同时还实现了一个接口。此时如果继承的类和接口有两个同名的方法怎么办？
因此，可以使用内部类来实现接口，就可以让外部类有效的避免该问题。
// 接口
public interface Incrementable{
void increment();
}
// 类
public class MyIncrement {
public void increment(){
System.out.println("Other increment()");
}
static void f(MyIncrement f){
f.increment();
}
}
// 继承类和接口
public class Callee2 extends MyIncrement implements Incrementable{
public void increment(){
//代码
// 此时就无法区分这个方法是属于覆盖MyIncrement这里的方法呢？
// 还是Incrementable这里的方法
}
}
// ********************内部类继承接口来解决***********
public class Callee2 extends MyIncrement{
private int i=0;
private void incr() {
i++;
System.out.println(i);
}
private class Closure implements Incrementable {
public void increment(){
incr();
}
}
Incrementable getCallbackReference() {
return new Closure();
}
}
