摘要：
内部类 它仅用于创建此类的一个对象。通常，作为方法参数，它隐式继承父类或实现接口限制：因为构造方法的名称与类名相同，而匿名类没有类名，所以匿名类不能有构造方法。
内部类（inner class）是定义在另一个类中的类
内部类的好处：
|--1.隐藏机制:内部类封装性更好，隐藏在一个类之中，同一包中的其他类也不能访问
|--2.内部类可以访问外围类的私有数据
成员内部类
member inner class
可以访问外部类的所有成员变量和方法（无论静态、非静态)
自身没有静态成员
|--外部类里面创建成员内部类的实例：this.new Innerclass();
|--在外部类之外创建内部类的实例：new Outerclass().new Innerclass();
|--在内部类里访问外部类的成员：Outerclass.this.member
class Hero {
void callHorse() {
// 自己使用自己的成员内部类
System.out.print("吕布");
this.new Horse().show();
}
// 成员内部类
class Horse {
public void show() {
System.out.println("---赤兔---");
}
}
}
public class InnerClassMember {
public static void main(String[] args) {
Hero h = new Hero();
h.callHorse();
// 创建一个类的内部类
Hero.Horse horse = new Hero().new Horse();
horse.show();
}
}
吕布---赤兔---
---赤兔---
静态内部类
static inner class (nested class)
使用内部类只是为了把一个类隐藏在另外一个类的内部，并不需要内部类引用外围对象，可以将内部类声明为static。
生成静态内部类对象的方式为：
OuterClass.InnerClass inner = new OuterClass.InnerClass();// 里面的类不用new
|--成员内部类没有静态成员；
|--静态内部类只能访问外围类的静态成员
局部内部类
local inner class
在方法中定义、使用
不能被public, protected, private和static修饰(像局部变量一样)
只能访问方法中定义的final类型的局部变量(初始化之后便不能更改)
import java.util.*;
// 以集合排序需要实现Comparator接口为例
public class TestInnerClassLocal {
public static void main(String[] args) {
class InnerComparator implements Comparator<Integer> {
@Override
public int compare(Integer o1, Integer o2) {
return o2 - o1;
}
}
// 需要先定义局部内部类，再使用
InnerComparator com = new InnerComparator();
List<Integer> lst = new ArrayList<>();
Collections.addAll(lst, 2, 3, 5, 1, 4);
Collections.sort(lst, com);
System.out.println(lst);
}
}
[5, 4, 3, 2, 1]
匿名内部类
anonymous inner class
没有名字的局部内部类。
用于只创建这个类的一个对象的场合（不必命名），通常是作为方法的参数
隐式地继承了一个父类或者实现了一个接口
限制：由于构造方法的名字与类名相同，而匿名类没有类名，所以，匿名类不能有构造方法。
综合代码：
import java.util.Date;
class OutClass {
private static String field_Static = "外围类：静态变量";
private String field_Common = "外围类：普通变量";
private static void methodStatic() {
System.out.println("外围类：静态方法");
}
private void methodCommon() {
System.out.println("外围类：普通方法");
}
// 成员内部类
class InnerClassMember {
// Err:
// private static String inner_fieldStatic = "内部类：静态变量";
private String inner_fieldCommon = "|---内部类：普通变量";
// Err:
// private static void innerMethodStatic() {}
private void innerMethodCommon() {
System.out.println("|---内部类：普通方法");
}
public void methodInner() {
// 变量·外
System.out.println(OutClass.this.field_Common);
System.out.println(field_Static);
// 变量·内
System.out.println(inner_fieldCommon);
// 方法·外
methodStatic();
OutClass.this.methodCommon();
// 方法·内
innerMethodCommon();
}
}
// 静态内部类
static class InnerClassStatic {
private static String inner_fieldStatic = "|---静态内部类：静态变量";
private String inner_fieldCommon = "|---静态内部类：普通变量";
private static void innerMethodStatic() {
System.out.println("|---静态内部类：静态方法");
}
private void innerMethodCommon() {
System.out.println("|---静态内部类：普通方法");
}
public void methodInner() {
// 变量·外
System.out.println(OutClass.field_Static);
// 变量·内
System.out.println(inner_fieldCommon);
System.out.println(inner_fieldStatic);
// 方法·外
OutClass.methodStatic();
// 方法·内
innerMethodStatic();
innerMethodCommon();
}
}
// 局部內部類
public void method4InnerClassLocal() {
String localField = "局部变量";
final String localFieldFinal = "局部变量(final)";
// ↑Java 8中不用加final，但局部内部类中不能修改其值
// 局部内部类
class InnerClassLocal {
public void localClassM() {
// Err: System.out.println(localField);
System.out.println(localFieldFinal);
System.out.println(field_Common);
System.out.println(field_Static);
methodCommon();
methodStatic();
}
}
InnerClassLocal _local_in_c = new InnerClassLocal();
_local_in_c.localClassM();
}
// --------------------
public void testAnonymousClass() {
// 匿名内部类
PrintDate(new Date() {
public long getTime() {
System.out.println(field_Common);
System.out.println(field_Static);
methodCommon();
methodStatic();
return 10086;
}
});
}
private void PrintDate(Date dt) {
System.out.println(dt.getTime());
}
}
public class InnerClassTest1 {
public static void main(String[] args) {
System.out.println("===↓↓↓成员内部类===================");
OutClass.InnerClassMember ic = new OutClass().new InnerClassMember();
ic.methodInner();
System.out.println("===↓↓↓静态内部类===================");
OutClass.InnerClassStatic ics = new OutClass.InnerClassStatic();
ics.methodInner();
System.out.println("===↓↓↓局部内部类===================");
OutClass oc = new OutClass();
oc.method4InnerClassLocal();
System.out.println("===↓↓↓匿名内部类===================");
oc.testAnonymousClass();
}
}
===↓↓↓成员内部类===================
外围类：普通变量
外围类：静态变量
|---内部类：普通变量
外围类：静态方法
外围类：普通方法
|---内部类：普通方法
===↓↓↓静态内部类===================
外围类：静态变量
|---静态内部类：普通变量
|---静态内部类：静态变量
外围类：静态方法
|---静态内部类：静态方法
|---静态内部类：普通方法
===↓↓↓局部内部类===================
局部变量(final)
外围类：普通变量
外围类：静态变量
外围类：普通方法
外围类：静态方法
===↓↓↓匿名内部类===================
外围类：普通变量
外围类：静态变量
外围类：普通方法
外围类：静态方法
10086
对比和总结
面试题
面试题：
1、静态内部类和成员内部类有什么不同？（美团）
2、Anonymous Inner Class (匿名内部类)是否可以继承其它类，是否可以implements(实现)interface(接口)?
3、补全代码：
interface Inter {
public void show();
}
class Outer {
public static Inter method() {// 返回值是接口的方法
// 补全代码↓↓↓
return
// 补全代码↑↑↑
}
}
public class OuterDemo {
public static void main(String[] args) {
Outer.method().show();
}
}