将一个类的定义放在另一个类的定义内部，这就是内部类。
内部类是个很有用的特性，它允许你把一些逻辑相关的类组织在一起，并控制内部的类的可视性。
一. 创建内部类
public class A{
class B{
B(){
System.out.println("B class");
}
B getInstance() {
System.out.println("return a new B");
return new B();
}
}
public static void main(String[] args){
System.out.println("closing class ");
A a=new A();
A.B b=A.new B();
b=b.getInstance();
//如果上面没有创建外部类对象，那么就不能这样
//A a =new A();这是因为在没有创建外部类对象的时候，不能创建内部类对象（这个情况除了嵌套类之外），构建内部类的对象时，需要指向一个外部类对象的引用。
}
}
静态内部类可以直接创建对象new A.B();
如果内部类不是静态的，那就得这样
A a = new A();
A.B b = a.new B();
- 链接到外部类
--
（1）.使用static声明的内部类
class Outer{ // 定义外部类
private static String info = "hello world" ; // 定义外部类的私有属性
static class Inner{ // 使用static定义内部类为外部类
public void print(){ // 定义内部类的方法
System.out.println(info) ; // 直接访问外部类的私有属性 ，静态内部类访问的外部变量必须用static修饰
}
}
public void fun(){ // 定义外部类的方法
new Inner().print() ; // 通过内部类的实例化对象调用方法
}
};
public class InnerClassDemo{
public static void main(String args[]){
new Outer.Inner().print() ; // 调用外部类的fun()方法
}
}
（2）.不使用statc声明的个内部类
class Outer{ // 定义外部类
private String info = "hello world" ; // 定义外部类的私有属性
class Inner{ // 定义内部类
public void print(){ // 定义内部类的方法
System.out.println(info) ; // 直接访问外部类的私有属性
}
}
public void fun(){ // 定义外部类的方法
new Inner().print() ; // 通过内部类的实例化对象调用方法
}
}
public class InnerClassDemo{
public static void main(String args[]){
Outer out = new Outer() ; // 外部类实例化对象
Outer.Inner in = out.new Inner() ; // 实例化内部类对象
in.print() ; // 调用内部类的方法
}
}
（3）.在方法中定义内部类
class Outer{ // 定义外部类
private String info = "hello world" ; // 定义外部类的私有属性
public void fun(final int temp){ // 定义外部类的方法
class Inner{ // 在方法中定义的内部类
public void print(){ // 定义内部类的方法
System.out.println("类中的属性：" + info) ; // 直接访问外部类的私有属性
System.out.println("方法中的参数：" + temp) ;
}
}
new Inner().print() ; // 通过内部类的实例化对象调用方法
}
}
public class InnerClassDemo{
public static void main(String args[]){
new Outer().fun(30) ; // 调用外部类的方法
}
}
从上面的三个例子可以看出：内部类自动拥有对其外围类所有成员的访问权。
这是因为当某个外围类的对象创建了一个内部类对象时，此内部类对象必定会秘密的捕获一个指向那个外围类对象的引用。然后，在你访问此外围类的成员时，就是用那个引用来选择外围类的成员。
三. 使用.this与.new
（1） .new只出现在构造方法之前用来生成对象
即：Student a = new Student();
（2）.this (当在一个类中要明确指出使用对象自己的的变量或函数时就应该加上this引用。)
1、当全局变量跟局部变量重名时，表示使用全局变量（此时this指代本类对象）
class A{
String name;
void setName(String name){
this.name = name;
}
}
2、构造方法相互调用，此时this指代本类类名
注意this只能放在构造方法第一句
class B{
String name;
B(){
this("name");//会自动调用带String参数的构造方法
}
B(String name){
this.name = name;
}
}
3、用this生成类对象的引用
class A{
class B{
A getA(){
return A.this //生成对外部类对象的引用
}
}
}
四. 内部类与向上转型
interface method{
int add();
}
public class Text{
A a = new A();
B b = new B();
C c = new C();
//加private修饰的内部类A，只能外部类Text访问
private class A implements method{
public int add() {
return 1;
}
}
//子类和包访问权限
protected class B implements method{
public int add() {
return 2;
}
}
class C implements method{
public int add() {
return 3;
}
}
public static void main(String[] args) {
Text main = new Text();
method m1 = main.new A(); //向上转型
method m2 = main.new B();
method m3 = main.new C();
System.out.println(m1.add());
System.out.println(m2.add());
System.out.println(m3.add());
}
}
上面的代码实现了接口，完全隔绝了实现与接口的依赖，完全隐藏了实现的细节。
五. 在方法和作用域内的内部类
就相当于在方法里定义了一个结构体，把类想成结构体就可以了。只不过它是临时的，创建并使用后就自动销毁了，不会留下任何东西。
特点：
1、此类只能在方法内部使用，外部完全不可见。
2、使用方法跟外部类一模一样：声明对象、初始化、操作。
3、类对象生命周期仅在方法被执行到执行完毕的一段时间，在方法执行完毕后就会销毁。
4、除此之外跟普通的类没什么区别。
public class Text2{
private void isStudent(boolean b){
if(b){
//在作用域内定义内部类
class Student{
private String name;
Student(String s){
name=s;
}
String getName(){return name;}
}
Student stu=new Student("ZhangSan");
String s= stu.getName();
}
//Out of Scope,Can't use it here!已出了if(b)的作用域,这儿不能再引用内部类
}
public void check(){
isStudent(true);
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Text2 p=new Text2();
p.check();
}
}
六. 匿名内部类
匿名内部类也就是没有名字的内部类
正因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写
但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口
实例1:不使用匿名内部类来实现抽象方法
abstract class Person {
public abstract void eat();
}
class Child extends Person {
public void eat() {
System.out.println("eat something");
}
}
public class Demo {
public static void main(String[] args) {
Person p = new Child();
p.eat();
}
}
运行结果：eat something
可以看到，我们用Child继承了Person类，然后实现了Child的一个实例，将其向上转型为Person类的引用
但是，如果此处的Child类只使用一次，那么将其编写为独立的一个类岂不是很麻烦？
这个时候就引入了匿名内部类
实例2：匿名内部类的基本实现
abstract class Person {
public abstract void eat();
}
public class Demo {
public static void main(String[] args) {
Person p = new Person() {
public void eat() {
System.out.println("eat something");
}
};
p.eat();
}
}
运行结果：eat something
可以看到，我们直接将抽象类Person中的方法在大括号中实现了
这样便可以省略一个类的书写
并且，匿名内部类还能用于接口上
实例3：在接口上使用匿名内部类
interface Person {
public void eat();
}
public class Demo {
public static void main(String[] args) {
Person p = new Person() {
public void eat() {
System.out.println("eat something");
}
};
p.eat();
}
}
运行结果：eat something
由上面的例子可以看出，只要一个类是抽象的或是一个接口，那么其子类中的方法都可以使用匿名内部类来实现
最常用的情况就是在多线程的实现上，因为要实现多线程必须继承Thread类或是继承Runnable接口
实例4：Thread类的匿名内部类实现
public class Demo {
public static void main(String[] args) {
Thread t = new Thread() {
public void run() {
for (int i = 1; i <= 5; i++) {
System.out.print(i + " ");
}
}
};
t.start();
}
}
运行结果：1 2 3 4 5
实例5：Runnable接口的匿名内部类实现
public class Demo {
public static void main(String[] args) {
Runnable r = new Runnable() {
public void run() {
for (int i = 1; i <= 5; i++) {
System.out.print(i + " ");
}
}
};
Thread t = new Thread(r);
t.start();
}
}
运行结果：1 2 3 4 5
七. 静态内部类
和普通的类一样，内部类也可以有静态的。不过和非静态内部类相比，区别就在于静态内部类没有了指向外部的引用。
除此之外，在任何非静态内部类中，都不能有静态数据，静态方法或者又一个静态内部类（内部类的嵌套可以不止一层）。不过静态内部类中却可以拥有这一切。这也算是两者的第二个区别吧。
静态的含义是该内部类可以像其他静态成员一样，没有外部类对象时，也能够访问它。静态内部类不能访问外部类的成员和方法。
public class Outer{
static class Inner{
}
public static void main(String[] args){
Outer.Inner n = new Outer.Inner();
}
}
八.局部内部类
即在方法中定义的内部类，与局部变量类似，在局部内部类前不加修饰符public或private，其范围为定义它的代码块。
注意：局部内部类中不可定义静态变量，可以访问外部类的局部变量(即方法内的变量)
public class Text3{
//局部内部类
public void method(){
int num2 = 44;
class JuIn{
public void zhanshi(){
/*
* 按理说局部内部类访问局部变量,局部变量应该用final修饰,但是不用final修饰也是可以访问的,
* 这是因为在JDK8以下必须用final修饰,不然会报错,
* Cannot refer to a non-final variable a inside an inner class defined in a different method,
* 但是在JDK8之后就不会出现这种状况
* */
System.out.print(num2);
}
}
System.out.println("访问局部变量"+num2);
//在局部创建内部类对象
JuIn ji = new JuIn();
ji.zhanshi();
}
}
在类外不可直接生成局部内部类（保证局部内部类对外是不可见的）。要想使用局部内部类时需要生成对象，对象调用方法，在方法中才能调用其局部内部类。通过内部类和接口达到一个强制的弱耦合，用局部内部类来实现接口，并在方法中返回接口类型，使局部内部类不可见，屏蔽实现类的可见性。
九.内部类标识符
内部类是一个编译时的概念，一旦编译成功，就会成为完全不同的两类。对于一个名为outer的外部类和其内部定义的名为inner的内部类。编译完成后出现outer.class和outer$inner.class两类。所以内部类的成员变量/方法名可以和外部类的相同。
如果内部类是匿名的，编译器会简单的产生一个数字作为标识符，如果内部类是嵌套在别的内部类之中，只需要将它们的名字加在外围类标识符与“$”的后面。
（至于闭包与回调，以后再看。）
