内部类
定义：将一个类定义在另一个类的里面，里面那个类就称为内部类（内置类，嵌套类）。
访问特点：
- 内部类可以直接访问外部类中的成员，包括私有成员。
- 而外部类要访问内部类中的成员必须要建立内部类的对象。
用法：
一般用于类的设计。分析事物时，发现该事物描述中还有事物，而且这个事物还在访问被描述事物的内容，这时就将里面的事物定义成内部类。
细节：
Example 1：为什么内部类能直接访问外部类的成员呢？是因为内部持有了外部类的引用-->外部类.this。
class Outer
{
int num = 3;
class Inner
{
int num = 4;
void show()
{
int num = 5;
System.out.println(num); //打印5
System.out.println(this.num); //打印4，或者可写为Inner.this.num
System.out.println(Outer.this.num); //打印3
}
}
public void method()
{
new Inner().show();
}
}
class Demo
{
public static void main(String[] args)
{
new Outer().method();
}
}
成员内部类
定义：内部类定义在成员位置上。
特点：
- 可以被private static成员修饰符修饰。
- 被static修饰的内部类只能访问外部类中的静态成员。
Example 1：内部类和其成员都是非静态的
class Outer
{
private int num = 3;
class Inner
{
void show()
{
System.out.println("show run..."+num);
}
}
public void method()
{
Inner in = new Inner();
in.show();
}
}
class Demo
{
public static void main(String[] args)
{
//直接访问外部类中的内部类中的成员
Outer.Inner in = new Outer().new Inner(); //不常用，因为一般都将内部类封装了
in.show();
}
}
Example 2：内部类为静态，其成员为非静态的
class Outer
{
private static int num = 3;
static class Inner
{
void show()
{
System.out.println("show run..."+num);
}
}
public void method()
{
Inner in = new Inner();
in.show();
}
}
class Demo
{
public static void main(String[] args)
{
//如果内部类是静态的，相当于一个外部类
Outer.Inner in = new Outer.Inner();//不需要再创建Outer对象
in.show();
}
}
Example 3：内部类和其成员都为静态
class Outer
{
private static int num = 3;
static class Inner
{
static void show()
{
System.out.println("show run..."+num);
}
}
public void method()
{
Inner.show();
}
}
class Demo
{
public static void main(String[] args)
{
Outer.Inner.show();//不需要再创建Outer和Inner对象
}
}
如果内部类中定义了静态成员，则该内部类也必须是静态的。
如果类中的静态函数想访问内部类，则该内部类必须是静态的。
局部内部类
定义：内部类定义在局部位置上。
特点：
- 也可以直接访问外部类中的成员。
- 同时可以访问所在局部中的局部变量，但必须是被final修饰的。
Example 1：示例
class Outer
{
int num = 3;
void method()
{
int x = 9;
final int y = 8;
class Inner
{
void show()
{
System.out.println("show..."+num);//可以直接访问外部类中的成员。
System.out.println("show..."+x); //编译错误，从内部类中访问所在局部中的局部变量x，需要被声明为最终类型
System.out.println("show..."+y); //可以访问所在局部中的局部变量，但必须是被final修饰的。
}
}
Inner in = new Inner();
in.show();
}
//method()方法外不能访问Inner
}
class Demo
{
public static void main(String[] args)
{
new Outer().method();
}
}
Example 2：为什么局部变量需要被final修饰，局部内部类才可访问？
class Outer
{
int num = 3;
Object method()//若method函数有参数int y，如果想在内部类Inner中访问，也需要写为final int y
{
int x = 9;
class Inner
{
void show()
{
System.out.println("show..."+x);
}
}
Object in = new Inner();
return in;
}
}
class Demo
{
public static void main(String[] args)
{
Outer out = new Outer();
Object obj = out.method();
}
}
method函数执行完就出栈了，x便不存在了，而obj对象仍然存在，于是访问不了x，因此需把x声明为常量。
实质上是，java把局部内部类对象要访问的final型局部变量，复制过来变成该内部类对象中的一个成员变量，这样即使栈中局部变量（含final）已死亡，但由于它是final的，其值是不会发生改变的，因而内部类对象在局部变量死亡后，照样可以访问自己内部维护的一个值跟局部变量一样的成员变量，从而解决这个问题。
注意：java8中匿名/局部内部类访问局部变量时，局部变量已经可以不用加final了，但其实这个局部变量还是final的（表现为对该值初始化后不能再赋值了），只不过不用显式的加上而已，推测可能是编译机制发生了改变。
匿名内部类
定义：局部内部类的简化写法。
前提：内部类必须继承或实现一个外部类或者接口。
格式：new 外部类名或者接口名(){覆盖类或者接口中的代码，也可以自定义内容}
简单理解：就是建立一个带内容的外部类或者接口的子类匿名对象。
Example 1：匿名类中重写一个函数
abstract class Demo
{
abstract void show();
}
class Outer
{
int num = 4;
/*
class Inner extends Demo
{
void show()
{
System.out.println("show..."+num);
}
}
*/
public void method()
{
//new Inner().show();
new Demo()//new了Demo类的子类对象
{
void show()
{
System.out.println("show..."+num);
}
}.show();
}
}
class Demo
{
public static void main(String[] args)
{
new Outer().method();
}
}
Example 2：匿名类中重写两个函数
interface Demo
{
void show1();
void show1();
}
class Outer
{
int num = 4;
public void method()
{
Demo demo = new Demo() //类似于多态，父类引用指向了子类对象
{
public void show1()
{
System.out.println("show1..."+num);
}
public void show2()
{
System.out.println("show2..."+num);
}
}
demo.show1();
demo.show2();
}
}
应用：当函数参数是接口类型时，而且接口中的方法不超过三个，可以用匿名内部类作为实际参数进行传递。
/*---以前的写法----*/
interface Inter
{
void show1();
void show2();
}
class InterImpl implements Inter
{
public void show1(){}
public void show2(){}
}
class Demo
{
public static void main(String[] args)
{
show(new InterImpl());
}
public static void show(Inter in)
{
in.show1();
in.show2();
}
}
/*---可以改为以下写法----*/
interface Inter
{
void show1();
void show2();
}
class Demo
{
public static void main(String[] args)
{
show(new Inter()
{
public void show1(){}
public void show2(){}
});
}
public static void show(Inter in)
{
in.show1();
in.show2();
}
}
细节：
class Outer
{
void method()
{
new Object()
{
public void show()
{
System.out.println("show run");
}
}.show();//创建的Object的子类对象，调用的子类对象的方法
/*
Object obj = new Object(){
public void show()
{
System.out.println("show run");
}
};
obj.show(); //编译错误，在java.lang.Object里找不到show()方法，因为匿名内部类这个子类对象已经被向上转型为了Object类型，这样就不能使用子类特有的方法了，只能调用父类或接口中存在的方法。
*/
}
}
class Demo
{
public static void main(String[] args)
{
new Outer().method();
}
}