一、介绍
面向对象程序设计中，可以在一个类的内部定义另一个类。嵌套类分为两种，即静态嵌套类和非静态嵌套类。静态嵌套类使用很少，最重要的是非静态嵌套类，也即是被称作为内部类(inner)。内部类是JAVA语言的主要附加部分。内部类几乎可以处于一个类内部任何位置，可以与实例变量处于同一级，或处于方法之内，甚至是一个表达式的一部分。
内部类的共性编辑
(1)内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号 。
(2)内部类不能用普通的方式访问。内部类是外部类的一个成员，因此内部类可以自由地访问外部类的成员变量，无论是否是private的 。
(3)内部类声明成静态的，就不能随便的访问外部类的成员变量了，此时内部类只能访问外部类的静态成员变量 。
二、知识点介绍
1、成员内部类
2、局部内部类
3、静态内部类
4、匿名内部类
三、上课对应视频的说明文档
1、成员内部类
成员内部类是最普通的内部类，它的定义为位于另一个类的内部，形如下面的形式：
class Circle {
double radius = 0;
public Circle(double radius) {
this.radius = radius;
}
class Draw { //内部类
public void drawSahpe() {
System.out.println("drawshape");
}
}
}
这样看起来，类Draw像是类Circle的一个成员，Circle称为外部类。成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员）。
class Circle {
private double radius = 0;
public static int count =1;
public Circle(double radius) {
this.radius = radius;
}
class Draw { //内部类
public void drawSahpe() {
System.out.println(radius); //外部类的private成员
System.out.println(count); //外部类的静态成员
}
}
}
不过要注意的是，当成员内部类拥有和外部类同名的成员变量或者方法时，会发生隐藏现象，即默认情况下访问的是成员内部类的成员。如果要访问外部类的同名成员，需要以下面的形式进行访问：
外部类.this.成员变量
外部类.this.成员方法
虽然成员内部类可以无条件地访问外部类的成员，而外部类想访问成员内部类的成员却不是这么随心所欲了。在外部类中如果要访问成员内部类的成员，必须先创建一个成员内部类的对象，再通过指向这个对象的引用来访问：
class Circle {
private double radius = 0;
public Circle(double radius) {
this.radius = radius;
getDrawInstance().drawSahpe(); //必须先创建成员内部类的对象，再进行访问
}
private Draw getDrawInstance() {
return new Draw();
}
class Draw { //内部类
public void drawSahpe() {
System.out.println(radius); //外部类的private成员
}
}
}
成员内部类是依附外部类而存在的，也就是说，如果要创建成员内部类的对象，前提是必须存在一个外部类的对象。创建成员内部类对象的一般方式如下：
public class Test {
public static void main(String[] args) {
//第一种方式：
Outter outter = new Outter();
Outter.Inner inner = outter.new Inner(); //必须通过Outter对象来创建
//第二种方式：
Outter.Inner inner1 = outter.getInnerInstance();
}
}
class Outter {
private Inner inner = null;
public Outter() {
}
public Inner getInnerInstance() {
if(inner == null)
inner = new Inner();
return inner;
}
//内部类
class Inner {
public Inner() {
}
}
}
内部类可以拥有private访问权限、protected访问权限、public访问权限及包访问权限。比如上面的例子，如果成员内部类Inner用private修饰，则只能在外部类的内部访问，如果用public修饰，则任何地方都能访问；如果用protected修饰，则只能在同一个包下或者继承外部类的情况下访问；如果是默认访问权限，则只能在同一个包下访问。这一点和外部类有一点不一样，外部类只能被public和包访问两种权限修饰。我个人是这么理解的，由于成员内部类看起来像是外部类的一个成员，所以可以像类的成员一样拥有多种权限修饰。
2、局部内部类
局部内部类是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内。
class People{
public People() {
}
}
class Man{
public Man(){
}
public People getWoman(){
class Woman extends People{ //局部内部类
int age =0;
}
return new Woman();//返回局部内部类对象
}
}
注意，局部内部类就像是方法里面的一个局部变量一样，是不能有public、protected、private以及static修饰符的。
3、静态内部类
静态内部类也是定义在另一个类里面的类，只不过在类的前面多了一个关键字static。静态内部类是不需要依赖于外部类的，这点和类的静态成员属性有点类似，并且它不能使用外部类的非static成员变量或者方法，这点很好理解，因为在没有外部类的对象的情况下，可以创建静态内部类的对象，如果允许访问外部类的非static成员就会产生矛盾，因为外部类的非static成员必须依附于具体的对象。
public class Test {
public static void main(String[] args) {
//产生静态内部类对象
Outter.Inner inner = new Outter.Inner();
}
}
class Outter {
public Outter() {
}
//静态内部类
static class Inner {
public Inner() {
}
}
}
综合案例：
public class Inner {
private int num = 3;
class Limian{
public void show(){
//内部类可以访问外部类的私有变量
System.out.println(num);
}
}
//局部内部类
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();
}
}
class StaticTest{
private static int num1 = 4;
//内部类用静态变量修饰
public static class Test{
public static void show(){
//静态内部类访问外部变量必须用static修饰
System.out.println(num1);
}
}
}
class InnerDemo{
public static void main (String[] args){
//非静态内部类创建方法
Inner.Limian l = new Inner().new Limian();
l.show();
//静态内部类创建方式
StaticTest.Test t = new StaticTest.Test();
//调用方法一
t.show();
//调用方法二
StaticTest.Test.show();
//局部内部类的方法调用
Inner i = new Inner();
i.method();
}
}
4、内部类的实际使用——匿名内部类
（1）匿名内部类概念
内部类是为了应对更为复杂的类间关系。我们在完成计算机语言相对底层的位置才会涉及，日常业务中很难遇到，这里不做赘述。
最常用到的内部类就是匿名内部类，是局部内部类的一种。
匿名内部类有两个步骤：
a.临时定义一个类型的子类
b.定义后即刻创建刚刚定义的这个类的对象
（2）匿名内部类作用与格式
作用：匿名内部类是创建某个类型子类对象的快捷方式。
格式：
new 父类或接口(){
//进行方法重写
};
代码示例：
//已经存在的父类：
public abstract class Person{
public abstract void eat();
}
//定义并创建该父类的子类对象，并用多态的方式赋值给父类引用变量
Person p = new Person(){
public void eat() {
System.out.println(“我吃了”);
}
};
//调用eat方法
p.eat();
使用匿名对象的方式，将定义子类与创建子类对象两个步骤由一个格式一次完成，。虽然是两个步骤，但是两个步骤是连在一起完成的。
匿名内部类如果不定义变量引用，则也是匿名对象。代码如下：
new Person(){
public void eat() {
System.out.println(“我吃了”);
}
}.eat();
/*
* 定义Fly接口
*/
public interface Fly {
public abstract void open();
public abstract void fly();
public abstract void close();
}
public class YanZi implements Fly{
@Override
public void open() {
System.out.println("张开小翅膀");
}
@Override
public void fly() {
System.out.println("能飞3000米高空");
}
@Override
public void close() {
System.out.println("关闭小翅膀，安全着陆");
}
//一个类中可以定义多个类，但只能有一个类public的
class Person()
}
}
/*
* 匿名内部类
*
* new 父类/接口(){
* //重写需要重写的方法
* };
*/
public class Test {
public static void main(String[] args) {
Fly yz = new YanZi();
yz.open();
yz.fly();
yz.close();
new YanZi().open();
System.out.println("-------------------");
//实现类对象赋值给父接口
Fly fj = new Fly(){
@Override
public void open() {
System.out.println("不需要张开翅膀，一直都是张开状态");
}
@Override
public void fly() {
System.out.println("喷气式助力飞行！");
}
@Override
public void close() {
System.out.println("不需要关闭翅膀，得哪撞哪");
}
};
fj.open();
fj.fly();
fj.close();
System.out.println("-----------------------------");
//实现类对象直接以匿名对象的方式调用方法
new Fly() {
@Override
public void open() {
System.out.println("小翅膀");
}
@Override
public void fly() {
System.out.println("乱飞");
}
@Override
public void close() {
System.out.println("各种撞树");
}
}.fly();
}
}