内部类的定义：
在一个类中定义另一个类，这样的类称为内部类，而包含内部类的类称为外嵌类，所以内部类也是外嵌类的一种成员；
内部类要点：
1、外嵌类的成员变量在内部类中仍然有效，内部类中的方法也可以调用外嵌类中的方法；
2、内部类中不能声明 类变量 和 类方法；
3、外嵌类中可以声明内部类对象；
4、内部类仅供它的外嵌类使用，也就是别的类中不能声明其他类的内部类对象；
内部类的使用：
一个类中通过声明内部类，可以使这个类具有其他类没有的属性和行为；
以下通过 面向抽象编程思想 来实现内部类的演示：
创建 一个抽象类，一个中间类，两个子类（其中一个子类拥有内部类），一个测试类 ；
抽象类代表一个公司，每个子类代表一个部门，每个部门有自己的任务；
如下代码↗：
//抽象类
public abstract class Corporation {
abstract void getFunction(); //设置每个部门的功能
}//中间类
public class middleClass {
void getVariable(Corporation cp){
cp.getFunction(); //上转型对象调用子类重写后的抽象方法getFunction
}
}//销售部门子类，继承抽象类
public class marketDepartment extends Corporation {
//重写方法
void getFunction() {
System.out.println("我是公司的销售部门，负责公司产品的销售");
}
}//管理部门子类，继承抽象类
public class manageDepartment extends Corporation {
//成员变量
int number;
//重写方法
void getFunction() {
System.out.println("我是公司的管理部门，负责管理公司的其他部门");
}
//声明内部类对象，仅限这个类声明
innerClass inc;
//通过外嵌类构造方法完成内部类对象的引用赋值
manageDepartment(){
inc = new innerClass();
number = 10;
}
//声明内部类
class innerClass{
void speak(){
System.out.println("内部类：管理部门特有行为");
//外嵌类的成员变量在内部类中仍然有效
System.out.println("管理部门下有："+number+" 个小组长");
}
}
}
//测试类
public class testClass {
public static void main(String[] args) {
middleClass mc = new middleClass();
mc.getVariable(new marketDepartment());
manageDepartment md = new manageDepartment();
mc.getVariable(md);
//外嵌类调用自己内部类的方法
md.inc.speak();
}
}
以上代码中，管理部门类拥有自己的内部类，使用就拥有了独特的行为；
代码输出结果：
我是公司的销售部门，负责公司产品的销售
我是公司的管理部门，负责管理公司的其他部门
内部类：管理部门特有行为
管理部门下有：10 个小组长
对于内部类还有另外一种声明：static （静态）内部类 ;
static class innerClass{
.....
}
static （静态）内部类 与 内部类的区别：
1、在其他类中可以使用 static 内部类来创建对象，但是内部类不可以；
如以上代码中：
manageDepartment md = new manageDepartment();
//外嵌类调用自己内部类的方法
md.inc.speak();
可以改为：
manageDepartment.innerClassx mdic = new manageDepartment.innerClassx();
mdic.speak();
2、static 内部类中，不可以操作外嵌类的 实例变量 和 实例方法，只能操作 外嵌类的 static 变量 和 static 方法，而内部类则都可以操作；
如以上代码中：
class innerClass{
void speak(){
System.out.println("内部类：管理部门特有行为");
//外嵌类的成员变量在内部类中仍然有效
System.out.println("管理部门下有："+number+" 个小组长");
}
}
改为：static 内部类
static class innerClass{
void speak(){
System.out.println("内部类：管理部门特有行为");
//外嵌类的成员变量在内部类中仍然有效
System.out.println("管理部门下有："+number+" 个小组长");
}
}
那么，number 就会报错，因为 number是外嵌类的实例变量，static内部类是不能操作的；
3、static 关键字只能修饰一般内部类，不能修饰其他类，匿名类虽然是内部类，但也不能修饰 static ；
匿名内部类的定义：
匿名类就是一个子类，由于无类名使用，所以匿名类是不能声明对象的，但是可以通过父类的构造方法创建一个匿名类对象；
例如： Bank是一个一般类，用Bank类创建一个匿名子类，其中的 new Bank() 就是一个匿名类对象：
new Bank(){
匿名类的类体；
};
匿名类要点：
1、匿名类可以继承父类的方法，也可以重写父类的方法；
2、匿名类一定是内部类；
3、和内部类一样，匿名类可以调用外嵌类的成员变量和方法；
4、和内部类一样，匿名类的类体中不能声明 static 变量 和 static 方法 ；
5、匿名类对象的引用通过方法传参可以传递给其父类对象，完成上转型对象的创建；
匿名内部类的使用：
一、和子类有关的匿名类
一个类通过声明匿名类，来代替子类的创建，进而拥有了子类的功能，这样就不用重新创建一个子类源文件；
以下通过 面向抽象编程思想 来实现匿名类的演示：
创建 一个抽象类，一个中间类，三个子类（其中一个子类为匿名类），一个测试类 ；
抽象类代表一个公司，每个子类代表一个部门，每个部门有自己的任务；
如下代码↗：
//抽象类
public abstract class Corporation {
abstract void getFunction(); //设置功能
}//中间类
public class middleClass {
public void getVariable(Corporation cp){
cp.getFunction(); //上转型对象调用子类重写后的抽象方法getFunction
}
}//销售部门子类，继承抽象类
public class marketDepartment extends Corporation {
//重写方法
void getFunction() {
System.out.println("我是公司的销售部门，负责公司产品的销售");
}
}//管理部门子类，继承抽象类
public class manageDepartment extends Corporation {
//重写方法
public void getFunction() {
System.out.println("我是公司的管理部门，负责管理公司的其他部门");
}
}//测试类
public class testClass {
//错误，不能直接在类体中创建
// new testClass(){
// };
public static void main(String[] args) {
//正确，只能在方法中，创建匿名类，不能直接在类体中创建
// new testClass(){
// };
middleClass mc = new middleClass();
mc.getVariable(new marketDepartment());
mc.getVariable(new manageDepartment());
//创建 抽象类Corporation 的匿名类
mc.getVariable(new Corporation(){
//匿名类重写父类的抽象方法，继承其他方法
void getFunction() {
System.out.println("匿名类：我是公司新加的人事部门，负责公司员工的调动与招聘");
}
});
//匿名类结束
}
}
以上代码中，测试类中创建了抽象类的匿名类，增加了一个部门子类，而不是通过重新创建一个子类源文件来实现；
代码输出结果：
我是公司的销售部门，负责公司产品的销售
我是公司的管理部门，负责管理公司的其他部门
匿名类：我是公司新加的人事部门，负责公司员工的调动与招聘
二、和接口有关的匿名类
一个接口通过声明匿名类，可以代替实现类的创建，进而拥有了实现类的功能，这样就不用重新创建一个实现类源文件，与第一点是一个道理的，只是关注点不同（一个是类，一个是接口）；
以下通过 面向接口编程思想 来实现匿名类的演示：
创建 一个接口，一个中间类，三个接口实现类（其中一个实现类为匿名类），一个测试类 ；
接口代表一个公司，每个实现类代表一个部门，每个部门有自己的任务；
如下代码↗：
//接口
public interface Corporation_Interface {
void getFunction(); //设置功能
}//中间类
public class middleClass {
//和接口有关的匿名类
public void getVariable(Corporation_Interface cpi) {
cpi.getFunction(); // 接口变量cpi调用实现类重写后的抽象方法getFunction
}
}//实现类
public class marketDepartment implements Corporation_Interface {
//重写方法
public void getFunction() {
System.out.println("我是公司的销售部门，负责公司产品的销售");
}
}//实现类
public class manageDepartment implements Corporation_Interface {
//重写方法
public void getFunction() {
System.out.println("我是公司的管理部门，负责管理公司的其他部门");
}
}//测试类
public class testClass {
public static void main(String[] args) {
middleClass mc = new middleClass();
mc.getVariable(new marketDepartment());
mc.getVariable(new manageDepartment());
//创建 接口Corporation_Interface 的匿名类
mc.getVariable(new Corporation_Interface(){
//接口匿名类重写接口的抽象方法
public void getFunction() {
System.out.println("接口匿名类：我是公司新加的人事部门，负责公司员工的调动与招聘");
}
});
//接口匿名类结束
}
}
以上代码中，测试类中创建了接口的匿名类，增加了一个部门实现类，而不是通过重新创建一个实现类源文件；
代码输出结果：
我是公司的销售部门，负责公司产品的销售
我是公司的管理部门，负责管理公司的其他部门
接口匿名类：我是公司新加的人事部门，负责公司员工的调动与招聘
