一个类中包含着另外一个类，里面的类被称为内部类，外面的称为外部类
1.成员内部类
和成员变量或者成员方法平级的内部类
语法：
访问权限修饰符 class 外部类类名{
//成员变量
//成员方法
访问权限修饰符 class 内部类类名 {
//内部类的类体
}
}
特点；
a.实例化对象的语法
Out out = new Out();
Out.In in = out.new In();
b。成员内部类四种访问权限修饰符都可以使用（一般类只能使用public和default）
c.成员内部类编译生成的class文件的格式：外部类类名$内部类类名，例如：Out$In.class
/**
*成员内部类
*/
class InnerClassDemo01
{
public static void main(String[] args)
{
//实例化一个外部类对象
Outter out = new Outter();
out.display()
//实例化一个内部类的对象
//Outter.Inner中的Outter是为了表明生成的内部类对象存在于哪个外部类当中
Outter.Inner in = out.new Inner();
in.show();
}
}
/*
语法：
访问权限修饰符 class 外部类类名{
//成员变量
//成员方法
访问权限修饰符 class 内部类类名 {
//内部类的类体
}
}
*/
//外部类
class Outter
{
//成员变量
int n1 = 10;
int number = 30;
//成员方法
public void display() {
//实例化一个内部类对象
Inner in = new Inner();
in.show();
}
//成员内部类
class Inner
{
//内部类成员变量
int n2 = 20;
int number = 40;
//内部类成员方法
public void show() {
System.out.println("内部类show");
int number = 50;
//变量名称不相同的情况下，直接进行访问
System.out.println(n1);//10
System.out.println(n2);//20
//变量名称相同的情况下
System.out.println(number);//内部类成员方法中的局部变量50
System.out.println(this.number);//内部类的成员变量40
System.out.println(Outter.this.number);//外部类的成员变量30
}
}
}
2.局部内部类
是和局部变量平级，存在于方法中的内部类
语法：
访问权限修饰符 class 外部类类名{
//成员变量
//成员方法
访问权限修饰符 返回值类型 方法名（参数列表） {
class 内部类类名 {
//内部类的类体
}
}
}
特点：
a.局部内部类具有和局部变量相同的作用域
b.和局部变量类似，不能使用访问权限修饰符进行修饰
c.编译生成的class文件的格式：外部类类名$编号内部类类名 ，例如：Out$1In.class,Out$2In.class,
d。局部内部类如果要访问和他平级的局部变量，这个局部变量必须是一个常量
e.如果需要往外部类的方法中传入参数，外部类的方法形参必须使用final修饰
/**
*局部内部类
*/
class InnerClassDemo02
{
public static void main(String[] args)
{
//实例化一个外部类对象
Outter out = new Outter();
out.display(10);
}
}
/*
语法：
访问权限修饰符 class 外部类类名{
//成员变量
//成员方法
访问权限修饰符 返回值类型 方法名（参数列表） {
访问权限修饰符 class 内部类类名 {
//内部类的类体
}
}
}
*/
class Outter
{
//外部类成员变量
int num = 10;
//外部类成员方法
//如果需要往外部类的方法中传入参数，外部类的方法形参必须使用final修饰
public void display(final int x) {
//x = 20;
//局部变量
/*
在JDK1.7之前，当在局部内部类中访问与其平级的局部变量时，要求这个局部变量必须是常量（使用final修饰）
在JDK1.8之后，可以不使用final进行修饰，但是这个局部变量默认是一个常量
*/
//int num = 20;
int number = 20;
//局部内部类
class Inner
{
//内部类成员变量
int num = 30;
//内部类成员方法
public void show() {
System.out.println("局部内部类show");
int num = 40;
//访问几个变量
System.out.println(num);//40
System.out.println(this.num);//30
System.out.println(Outter.this.num);//10
//当所有变量命名相同的情况下，在局部内部类中无法访问与局部内部类平级的局部变量
//如果非要访问的话，使用不同的命名
System.out.println(number);
//number = 30;
}
}
//实例化一个内部类对象
Inner in= new Inner();
in.show();
}
}
3.静态内部类
使用static修饰的成员内部类被称为静态内部类
语法：
访问权限修饰符 class 外部类类名{
//成员变量
//成员方法
访问权限修饰符 static class 内部类类名 {
//内部类的类体
}
}
特点：
a.实例化内部类对象的格式：Out.In in = new Out.In();
b.静态内部类类似于静态成员变量，可以使用访问权限修饰符进行访问
c.静态内部类编译生成的class文件的格式：外部类类名$内部类类名，例如：Out$In.class
d.在静态内部类中只能访问外部类中的静态成员变量
e.在静态内部类中也可以写静态成员变量
/**
*静态内部类
*/
class InnerClassDemo03
{
public static void main(String[] args)
{
//实例化一个外部类对象
Outter out = new Outter();
out.display();
//实例化一个内部类对象
//因为内部类被静态化，我们将Outter.Inner当做一个整体，直接new出内部类的对象
//无需实例化外部类对象就可以直接实例化内部类对象
Outter.Inner in = new Outter.Inner();
in.show();
}
}
/*
语法：
访问权限修饰符 class 外部类类名{
//成员变量
//成员方法
访问权限修饰符 static class 内部类类名 {
//内部类的类体
}
}
*/
class Outter
{
//成员变量
//int num = 10;
static int num = 30;
//静态内部类
//静态内部类类似于静态变量，可以使用访问权限修饰符进行访问
static class Inner
{
static int age = 20;
//内部类成员变量
int num = 20;
//内部类成员方法
public void show() {
System.out.println("内部类show");
//访问变量
System.out.println(num);//20
//System.out.println(Outter.this.num);//错误: 无法从静态上下文中引用非静态 变量 this
//访问外部类的成员变量时，对于命名相同的情况下，使用外部类类名.外部类成员变量名称
System.out.println(Outter.num);
}
}
//外部类成员方法
public void display() {
//实例化一个内部类对象
Inner in = new Inner();
in.show();
}
}
4.私有内部类
被private修饰的成员内部类
语法：
访问权限修饰符 class 外部类类名{
//成员变量
//成员方法
private class 内部类类名 {
//内部类的类体
}
}
/**
*私有内部类
*/
class InnerClassDemo04
{
public static void main(String[] args)
{
//实例化一个外部类对象
Outter out = new Outter();
out.display();
//实例化一个内部类对象
//Outter.Inner in = out.new Inner();
//in.show();
}
}
/*
语法：
访问权限修饰符 class 外部类类名{
//成员变量
//成员方法
private class 内部类类名 {
//内部类的类体
}
}
*/
class Outter
{
//私有成员变量
private int age = 10;
//私有内部类：如果一个内部类只希望被外部类中方法操作的话
private class Inner
{
//内部类成员方法
public void show() {
}
}
//外部类成员方法
public void display() {
//实例化一个内部类对象
Inner in = new Inner();
in.show();
}
}
5.匿名内部类（重要）
没有名字的内部类
正因为没有名字，所以匿名内部类只能使用一次，通常用来简化代码，匿名内部类使用的前提条件：必须继承一个父类或者实现一个接口
特点：
a.匿名内部类没有名字
b.匿名内部类其实是指定类的子类或者指定接口的实现类
c.编译生成class文件的格式：测试类类名$编号，例如：InnerClassDemo05$1.class
/**
*匿名内部类
*/
class InnerClassDemo05
{
public static void main(String[] args)
{
//常规用法
/*
Child c = new Child();
c.eat();
*/
//使用匿名内部类简化上面的继承代码
Person p = new Person() {
@Override
public void eat() {
System.out.println("eating");
}
};
p.eat();
/*
Cat c = new Cat();
c.run();
*/
//使用匿名内部类简化上面的实现接口代码
Animal a = new Animal() {
@Override
public void run() {
System.out.println("eating");
}
};
a.run();
}
}
//1.继承
abstract class Person
{
public abstract void eat();
}
/*
class Child extends Person
{
@Override
public void eat() {
System.out.println("eating");
}
}
*/
//2.接口
interface Animal
{
public void run();
}
/*
class Cat implements Animal
{
@Override
public void run() {
System.out.println("runing");
}
}
*/
