一、内部类
1、将一个类定义在另一个类的里面，对里面那个类就成为内部类（内置类，嵌套类）
2、访问特点、访问规则：
(1)、内部类可以直接访问外部类中的成员，包括私有成员
(2)、而外部类要访问内部类中的成员必须要建立内部类的对象
(3)、之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用， 格式类名.this
(4)、外部类.内部类 变量名 = new 外部类().new 内部类();
例子1：
class Outer
{
int x = 3;
//内部类可以被私有修饰！ private class Inner
class Inner//内部类:可以直接访问外部类的成员
{
int x = 4;
void function()
{
int x = 6;
//System.out.println("inner :"+x);//结果是6；内部有就不出去找了
//System.out.println("inner :"+this.x);//this.x//结果：4
System.out.println("inner :"+Outer.this.x);//结果是，3
}
}
void method()
{
System.out.println(x);
Inner in = new Inner();//外部类要访问内部类，必须建立对象，才能访问内部类
in.function();
}
}
public class InnerClassDemo
{
public static void main(String[] args)
{
//Outer out = new Outer();
//out.method();
//直接访问内部类中的成员
Outer.Inner in = new Outer().new Inner();//格式：就面试用
in.function();
}
}
二、静态内部类
1、当内部类在成员位置上时，就可以被成员修饰符所修饰
(1)、private：将内部类在外部类中进行封装
(2)、static：内部类就具备了静态的特性，当内部类别static修饰后，只能直接访问外部类中的static成员，出现了访问局限
(3)、访问被static 修饰的内部类，访问非静态 new 外部类.内部类().方法
(3)、访问被static 修饰的内部类，访问静态 new 外部类.内部类.方法
2、访问格式
(1)、当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中，可以直接建立内部类对象
(2)、外部类.内部类 变量名 = new 外部类().new 内部类();
3、主意：
(1)、当内部类中定义了静态成员，该内部类必须是static
(2)、当外部类中的静态方法，访问内部类时，内部类也必须是 static
例子2：
class Body
{
private class XinZang//私有了，外部不能访问；必须提供访问心脏的方法才能访问
{
//隐藏了
}
public void show()//提供心脏访问方式
{
new XinZang();
}
}
*/
class Outer1
{
private static int x = 3;
static class Inner1//静态内部类(共享数据)//内部类中有静态方法，类必须也是静态
{
//void function()//非静态方法
static void function()//静态方法
{
System.out.println("inner :"+x);
}
}
class Inner2
{
void show()
{
System.out.println("Innet2 show");
}
}
public static void method()
{
Inner1.function();//静态方法访问静态成员
//new Inner2().show();//出错
//必须把class Inner2改成静态内部类，才能访问他的非静态方法show
}
}
public class InnerClassDemo2
{
public static void main(String[] args)
{
//Outer1.Inner1.function();
//类调用 对象调用
//new Outer1.Inner1().function();//Inner1是static的，可用类访问；方法functin不是静态，用对象调用
//Outer.Inner in = new Outer().new Inner();//格式：就面试用
//in.function();
//Outer1.method();//静态方法可以直接访问静态变量，function会运行//结果：inner：3
}
}
三、内部类定义原则
1、类是用来描述事物的，当描述事物时，事物的内部还有事物，该事物用内部类来描述，因为内部事物在使用外部事物的内容。
2、隐藏内部类，提供相应接口
3、内部类定义在局部，时
(1)、不可以被成员修饰符修饰
(2)、可以直接访问外部类中的成员，因为还持有外部类中的引用，但是不可以访问它所在的局部的变量，只能访问被final修饰的局部变量。
例子3：
class Outer3
{
int x = 3;
void method(final int a)
{
//a++;//出错，因为此时a被锁住，不能改变
final int y = 4;//局部变量
class Inner3//局部，不能定义成static，private型，因为这两个是修饰成员的
{
void function()//他若是静态，类必须也是静态，所以也不能用static,private修饰
{
System.out.println(a);
}
}
new Inner3().function();
}
}
public class InnerClassDemo3
{
public static void main(String[] args)
{
//new Outer3().method();
Outer3 out = new Outer3();
out.method(7);//结果：7； 执行完，出栈，释放内存
out.method(8);//结果：8； 所以不会出错
}
}
四、匿名内部类
1、匿名内部类其实就是内部类的简写格式
2、定义匿名内部类的前提
(1)、内部类必须是继承一个类或者实现接口
3、匿名内部类的格式：new 父类或者接口(){定义子类的内容}
4、其实匿名内部类就是一个匿名子类对象，而且这个对象有点胖。可以理解为带内容的对象；
5、匿名内部类中定义的方法最好不要超过三个；
例子
abstract class AbsDemo
{
abstract void show();
}
class Outer4
{
int x = 3;
//简化：
public void function()//建立方法，通过建立对象访问内部类
{
//AbsDemo a = new Inner();//多态：父类引用指向子类对象
//Inner in = new Inner();
//in.show();
//in.abc();//简化内部类不能实现
//new Inner4().show();
AbsDemo d = new AbsDemo()
{
//里面可以定义变量，和方法；但是尽量不要写太多，匿名内部类就是为了简化
//int num = 9;
void show()
{
System.out.println("x="+x);
}
void abc()
{
System.out.println("haha");
}
};
d.show();
//d.abc();//因为只能使用父类方法,编译失败
}
}
public class InnerClassDemo4
{
public static void main(String[] args)
{
new Outer4().function();
}
}
