1.1 面向对象的理解：
从世界观的角度可以认为：面向对象的基本哲学是认为世界是由各种各样具有自己的运动规律和内部状态的对象所组成的；不同对象之间的相互作用和通讯构成了完整的现实世界。因此，人们应当按照现实世界这个本来面貌来理解世界，直接通过对象及其相互关系来反映世界。这样建立起来的系统才能符合现实世界的本来面目。
从方法学的角度可以认为：面向对象的方法是面向对象的世界观在开发方法中的直接运用。它强调系统的结构应该直接与现实世界的结构相对应，应该围绕现实世界中的对象来构造系统，而不是围绕功能来构造系统。
1.2 面向对象的特点：
a.它本身就是一种符合人们思考习惯思想；
b.将复杂事情简化；
c.角色上的转变，执行者--->指挥者；
d.可维护性好。
1.3 类和对象之间的关系
类：是对事物的描述。
对象：是该类事物具体的实体。
1.4 面向对象的基本概念：面向对象=对象+类+继承+消息
a.对象：在面向对象的系统中，对戏那个是基本的运行时的实体，它包括数据属性，也包括作用于数据的操作。所以一个对象把属性和行为密封成一个整体。从程序设计者的角度来看，对象是一个程序模块；从用户的角度来看，对象为他们提供了所希望的行为。在对象内的操作通常叫做方法。
b.类：一个类定义了一组大体上相似的对象。一个类所包含的方法和数据描述一组对象的共同行为属性。把一组对象的共同特性加以抽象并存储在一个类中的能力，是面向对象的技术最重要的一点；是否建立了一个丰富的类库是衡量一个面向对象程序设计语言成熟与否的重要标志。
c.继承：类之间的继承关系是现实世界中遗传关系的直接模拟，他表示类之间的内在联系以及对属性和操作的共享，即子类可以沿用父类的某些特征。当然，子类也可以具有自己独立的属性和操作。继承性数面向对象程序设计语言的最主要的特点，是其他语言所没有的。
d.消息：对象之间进行通信的一种构造叫做消息。当一个消息发送给某个对象时，包含要求接收对象去执行某些活动的信息。接收到消息的对象经过解释，然后予以响应。这种通信机制叫做消息传递，发送消息的对象不需要知道接收消息的对象如何请求予以响应。
1.5 成员变量和局部变量的区别
a.定义的位置：局部变量定义在函数中，语句内； 成员变量定义在类中；
b.内存中的位置：成员变量存储在栈内存中； 成员变量存储在堆内存中；
c.初始化值：局部变量没有默认初始化值，必须赋值才可以使用； 成员变量有默认初始化值；
d.生命周期：局部变量一旦作用区域结束，就立即被释放； 成员变量也称为实例（对象）变量，随着对象的出现而出现，随着对象的被回收而释放；
1.7 匿名对象的作用
a.匿名对象（没有名字的对象），可以作为实际参数进行传递。
b.匿名对象另一个使用：当对对象的方法仅进行一次调用的时候，可以简化成匿名对象完成。
1.8 封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
封装原则：将不需要对外提供的内容都隐藏起来； 把属性都隐蔽，提供公共方法对其访问。
好处：
a.将变化隔离
b.便于使用
c.提高重用性
d.提高安全性
1.9 private 关键字 私有
让成员变量私有化，也就是说，访问权限变到最低，私有只在本类中有效。
通常将类中的成员变量私有化，对外提供方法进行访问，提供的目的是对成员数据进行控制，让其具备可控性。
定义set get方法对成员变量进行访问。
注意：私有仅仅是封装的表现形式之一。 私有只能修饰成员
1.10 构造函数：
特点：a.函数名与类名相同 b.不用定义返回值类型 c.没有具体的返回值。
作用：给对象进行初始化。
注意：a.默认构造函数的特点。 b.多个构造函数是以重载的形式存在的。
构造函数在对象创建时就已经被调用了
如果一个类中没有定义过构造函数，编译器在编译时，就给类添加一个默认的构造函数（空的构造函数）。一旦在类中明确了自定义的构造函数时，该默认构造函数就没有了。
当一个类中有多个构造函数时，它们是以重载形式体现的。
构造函数和一般函数的区别：
构造函数用于对象初始化。初始化动作只能执行一次。而一般函数可以被执行多次。
1.11 this：代表的是对象，其实就是一个对象的引用。
哪个对象调用了this所在的函数，this就代表哪个对象。
this的使用之一：当成员变量和局部变量同名时，可以用this来区分
this的使用之二：使用this（参数列表）的方式就可以实现构造函数之间的调用。
注意：构造函数之间调用时，this语句只能定义在构造函数的第一行。构造函数里面只能调用一次构造函数
1.12 静态关键字：static
a.修饰符，修饰成员（成员变量，成员函数）；
特点：
a.被静态修饰的内容可以实现被所有对象共享；
b.静态数据随着类的加载而加载，随着类的消失而消失，生命周期过长，优先于对象存在；
c.静态数据因为所属于类，又多了一种调用方式，出了可以被对象调用以外，还可以直接被类名所调用。
什么时候用静态呢？
变量：当类中的属性的数据是所有对象都共享的，就用static修饰。
方法：当方法中没有访问过非静态数据时，该方法用static修饰
使用注意
静态方法只能访问静态成员，不能访问非静态成员
静态方法中不可以写this，super关键字
主函数是静态的
1.13 成员变量和静态变量的区别？
a.生命周期：
成员变量又叫实例变量，是随着对象的出现（消失）而出现（消失）。
静态变量又叫类变量，是随着类的加载（消失）而出现（消失）。
b.内存中的存储位置：
成员变量存储在内存的对象区
静态变量存储在方法区的静态区中。
c.存储的数据特点：
成员变量存储的数据数据对象的特有数据；
静态变量存储的数据是对象的共享数据
d.调用方式：
成员变量，只能被对象所调用
静态变量，能被对象调用，也可以被类调用。
1.14 强制不让其他类创建该对象，把该类私有化，当类中成员都是静态时，记得将构造函数私有化，因为创建对象是没有意义的。
设计模式：就是解决问题行之有效的方法，是一种思想。
单例设计模式：解决问题就是保证一个类在内存中只有一个对象。
如何保证一个类在内存中的对象唯一性？
a.不让其他程序创建该类对象。
b.在本类中自己定义一个本类对象
c.对外还提供一个获取该对象的方法。
分为：饿汉式 懒汉式
2.1 继承：
好处：1.提高了代码的复用性；
2.让类与类之间产生了关系，为多态特征提供了前提。
子类可以直接访问父类中的非私有的成员，间接访问私有成员，通过方法的形式。
Java中继承的特点：
Java中只支持单继承。并不直接支持多继承。
单继承：一个子类只能有一个父类
多继承：一个子类可以有多个父类。不直接支持，通过改良
Java中还支持多层继承。
class A{}
class B extends A{}
class C extends B{}
继承层次多了，就形成了继承体系。 体系就是不断向上抽取而来的。
在使用一个体系的时候，先参阅最顶层类，了解体系的最基本功能。
使用时，创建该体系最底层的类的对象。
看顶层，用底层
2.2 继承中子父类成员的特点：
a.成员变量；
super：代表的就是父类。
super的用法和this很相似
用法super.父类成员。super(实际参数)；
this：代表的是本类型对象的引用。
super：代表的是父类的内存空间。
子类中的super作用为了给父类中的成员变量初始化
字父类中出项同名成员变量时用super区分出父类变量。但是这种情况很少出现
b.成员函数；
当子父类中出现一模一样的函数时。
出现了另一个函数特性：覆盖 或 复写、重写。
overload（重载）：只关注本类中同名函数的参数列表，不关注返回值类型。
override（覆盖）：子父类中函数出现一模一样的函数，才会覆盖
覆盖的应用：保留父类功能声明，建立子类功能内容，这就是覆盖；
覆盖注意事项：
●子类覆盖父类方式，必须要保证子类方法权限大于等于父类方法权限。
●静态只能覆盖静态，或者被静态覆盖。
c.构造函数
子类的实例化过程：子类中的所有构造函数中第一行都有一条默认的隐式语句super();
super():用来调用父类中的空参数的构造函数。
为什么子类中都有默认super语句呢？
因为子类对象中会存在父类中的属性数据，必须要子类对象初始化时，先执行父类的初始化动作，看看父类是如何对自己的属性数据进行初始化的。
所以呢。子类的所有构造函数默认第一行（因为初始化动作要先执行，所以定义在第一行）都有一条默认的super()语句。
如果父类中没有定义空参数的构造函数，子类构造函数必须通过super或this语句指定要访问的父类的构造函数。
2.3 final关键字：
a.修饰符，修饰类，方法，各种变量。
b.final修饰类不可以被继承。
c.final修饰的方法不可以被覆盖。
d.final修饰的变量是一个常量，只能赋值一次。
对固定不变的值进行名称定义，提高其阅读性，
final修饰的常量 命名规则 所有字母都大写，多个单词，单词间用_连接。
2.4 抽象：
类是用来描述事物，当没有足够的信息去描述一个事物时，这个描述就是抽象的。
抽象类的特点：
a.抽象方法只有声明，没有方法体。
b.抽象方法一定定义在抽象类中，都需要被abstract关键字修饰。
c.抽象类不可以用new创建对象。
d.抽象类必须有自己的子类覆盖了所有的抽象方法后，该子类才可以被实例化，否则，该子类还是一个抽象类。
2.5 如果一个抽象类的方法都是抽象的，这时可以将抽象类用另一种形式来体现，就是接口
接口定义的关键字就是 interface
接口中成员的定义：
常见成员有两种：1.全局常量； 2.抽象方法。
接口的好处：是将多继承进行改良，用多实现进行体现。
一个类只能继承一个类，但是一个类可以实现多个接口。
一个类继承类的同时，还可以实现多个接口。
接口的出现避免了单继承的局限性。
2.6 接口与抽象类的区别：
共性：
抽象类和接口都是不断向上抽取而来的；
区别：
1.抽象类中可以定义抽象方法，也可以定义非抽象方法，非抽象方法可以直接提供给子类使用；
接口只能定义抽象方法。
2.类与类之间是继承关系，is a关系。
类与接口之间是实现关系，like a关系
3.类与类之间只能单继承。
类与接口之间可以多实现
3.1 多态：多种形态。
对象的多态性。
class 动物{}
class 猫 extends 动物{}
猫 x=new 猫();
动物 y =new 猫();//猫这个实体具备着两种形态，一个是猫另一个是动物。这就是多态性。
多态在程序中的体现：父类或者接口的引用指向了自己的子类对象。
动物 y= new 猫();//向上转型（类型提升），子类对象提升为父类型。
提升的好处：就是提高了扩展性。隐藏了子类型。
提升的局限性：只能使用父类中的方法。如果子类有覆盖，运行的是子类的内容。
猫 c=(猫)y;//向下转型(强制类型转换),好处：可以使用具体子类型的特有方法。
向下转型需要注意：父类型向下转成子类型，因为子类型不唯一，所以，需要进行判断。
判断用：instanceof关键字
对象 instanceof 类or接口...
记住：对于子父类型转换动作，自始自终都是子类对象在做着类型的转换而已。
多态的前提：
a.必须有继承或者实现的关系。
b.通常都有覆盖的操作。
多态的好处：
提高了程序的扩展性； 在思想上也有不同，以前面对一个对象调用，对象多了调用麻烦。
相当于指挥一批对象做事情，将复杂事情简单化。
多态的弊端：
多态的出现，虽然可以让前期的程序使用后期的内容。
不可以使用子类特有的内容。
3.2 多态调用时的特性:
a.成员变量：
多态调用时，对于成员变量，无论是编译还是运行，结果只参考引用型变量所属的类中的成员变量。参考等号左边。
b.成员方法：
多态调用时，对于成员函数
编译时，参考引用型变量所属的类中是否有被调用的方法。有，编译通过，没有，编译报错。
运行时，参考的是对象所属的类中是否有调用的方法。
简单说：编译看左边，运行看右边.
c.静态函数：
简单说：编译和运行都看左边。
3.3 object：所有类的超类。
所有对象都具备的方法定义在该类中。
3.4 getClass(); Class c1 = p1.getClass();//获取person对象所属的字节码文件对象。这个对象的类型Class.
3.5 内部类：将类定义在另一个类的内部，内部类的就称为内部类。
内部类编译后，在内部类的class文件前有一个$符号
访问方式：内部类可以直接访问外部类中的成员。
外部类要访问内部类中的成员，必须要创建内部类中的对象。
注意：当内部类中定义可静态成员，该内部类必须被静态修饰。
非静态内部类能直接访问外部成员的原因，是他持有一个外部成员的索引this
3.6 内部类定义在局部中，只能访问被final修饰的局部变量。
3.7 匿名内部类：
匿名内部类的形式。
其实就是对内部类进行简化书写。
必须有前提：
内部类必须继承或者实现类或接口。
格式：
new 父类名或者接口名(){定义内部类的内容;}
匿名内部类其实就是一个子类匿名对象。
----------------------
android培训 、 java培训 、 期待与您交流！ ----------------------
详细请查看：www.itheima.com
1.2 面向对象的特点：
a.它本身就是一种符合人们思考习惯思想；
b.将复杂事情简化；
c.角色上的转变，执行者--->指挥者；
d.可维护性好。
1.3 类和对象之间的关系
类：是对事物的描述。
对象：是该类事物具体的实体。
1.4 面向对象的基本概念：面向对象=对象+类+继承+消息
a.对象：在面向对象的系统中，对戏那个是基本的运行时的实体，它包括数据属性，也包括作用于数据的操作。所以一个对象把属性和行为密封成一个整体。从程序设计者的角度来看，对象是一个程序模块；从用户的角度来看，对象为他们提供了所希望的行为。在对象内的操作通常叫做方法。
b.类：一个类定义了一组大体上相似的对象。一个类所包含的方法和数据描述一组对象的共同行为属性。把一组对象的共同特性加以抽象并存储在一个类中的能力，是面向对象的技术最重要的一点；是否建立了一个丰富的类库是衡量一个面向对象程序设计语言成熟与否的重要标志。
c.继承：类之间的继承关系是现实世界中遗传关系的直接模拟，他表示类之间的内在联系以及对属性和操作的共享，即子类可以沿用父类的某些特征。当然，子类也可以具有自己独立的属性和操作。继承性数面向对象程序设计语言的最主要的特点，是其他语言所没有的。
d.消息：对象之间进行通信的一种构造叫做消息。当一个消息发送给某个对象时，包含要求接收对象去执行某些活动的信息。接收到消息的对象经过解释，然后予以响应。这种通信机制叫做消息传递，发送消息的对象不需要知道接收消息的对象如何请求予以响应。
1.5 成员变量和局部变量的区别
a.定义的位置：局部变量定义在函数中，语句内； 成员变量定义在类中；
b.内存中的位置：成员变量存储在栈内存中； 成员变量存储在堆内存中；
c.初始化值：局部变量没有默认初始化值，必须赋值才可以使用； 成员变量有默认初始化值；
d.生命周期：局部变量一旦作用区域结束，就立即被释放； 成员变量也称为实例（对象）变量，随着对象的出现而出现，随着对象的被回收而释放；
1.6 面向对象的特征：
•封装(encapsulation)
•继承(inheritance)
•多态(polymorphism)
1.7 匿名对象的作用
a.匿名对象（没有名字的对象），可以作为实际参数进行传递。
b.匿名对象另一个使用：当对对象的方法仅进行一次调用的时候，可以简化成匿名对象完成。
1.8 封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
封装原则：将不需要对外提供的内容都隐藏起来； 把属性都隐蔽，提供公共方法对其访问。
好处：
a.将变化隔离
b.便于使用
c.提高重用性
d.提高安全性
1.9 private 关键字 私有
让成员变量私有化，也就是说，访问权限变到最低，私有只在本类中有效。
通常将类中的成员变量私有化，对外提供方法进行访问，提供的目的是对成员数据进行控制，让其具备可控性。
定义set get方法对成员变量进行访问。
注意：私有仅仅是封装的表现形式之一。 私有只能修饰成员
1.10 构造函数：
特点：a.函数名与类名相同 b.不用定义返回值类型 c.没有具体的返回值。
作用：给对象进行初始化。
注意：a.默认构造函数的特点。 b.多个构造函数是以重载的形式存在的。
构造函数在对象创建时就已经被调用了
如果一个类中没有定义过构造函数，编译器在编译时，就给类添加一个默认的构造函数（空的构造函数）。一旦在类中明确了自定义的构造函数时，该默认构造函数就没有了。
当一个类中有多个构造函数时，它们是以重载形式体现的。
构造函数和一般函数的区别：
构造函数用于对象初始化。初始化动作只能执行一次。而一般函数可以被执行多次。
1.11 this：代表的是对象，其实就是一个对象的引用。
哪个对象调用了this所在的函数，this就代表哪个对象。
this的使用之一：当成员变量和局部变量同名时，可以用this来区分
this的使用之二：使用this（参数列表）的方式就可以实现构造函数之间的调用。
注意：构造函数之间调用时，this语句只能定义在构造函数的第一行。构造函数里面只能调用一次构造函数
1.12 静态关键字：static
a.修饰符，修饰成员（成员变量，成员函数）；
特点：
a.被静态修饰的内容可以实现被所有对象共享；
b.静态数据随着类的加载而加载，随着类的消失而消失，生命周期过长，优先于对象存在；
c.静态数据因为所属于类，又多了一种调用方式，出了可以被对象调用以外，还可以直接被类名所调用。
什么时候用静态呢？
变量：当类中的属性的数据是所有对象都共享的，就用static修饰。
方法：当方法中没有访问过非静态数据时，该方法用static修饰
使用注意
静态方法只能访问静态成员，不能访问非静态成员
静态方法中不可以写this，super关键字
主函数是静态的
1.13 成员变量和静态变量的区别？
a.生命周期：
成员变量又叫实例变量，是随着对象的出现（消失）而出现（消失）。
静态变量又叫类变量，是随着类的加载（消失）而出现（消失）。
b.内存中的存储位置：
成员变量存储在内存的对象区
静态变量存储在方法区的静态区中。
c.存储的数据特点：
成员变量存储的数据数据对象的特有数据；
静态变量存储的数据是对象的共享数据
d.调用方式：
成员变量，只能被对象所调用
静态变量，能被对象调用，也可以被类调用。
1.14 强制不让其他类创建该对象，把该类私有化，当类中成员都是静态时，记得将构造函数私有化，因为创建对象是没有意义的。
设计模式：就是解决问题行之有效的方法，是一种思想。
单例设计模式：解决问题就是保证一个类在内存中只有一个对象。
如何保证一个类在内存中的对象唯一性？
a.不让其他程序创建该类对象。
b.在本类中自己定义一个本类对象
c.对外还提供一个获取该对象的方法。
分为：饿汉式 懒汉式
2.1 继承：
好处：1.提高了代码的复用性；
2.让类与类之间产生了关系，为多态特征提供了前提。
子类可以直接访问父类中的非私有的成员，间接访问私有成员，通过方法的形式。
Java中继承的特点：
Java中只支持单继承。并不直接支持多继承。
单继承：一个子类只能有一个父类
多继承：一个子类可以有多个父类。不直接支持，通过改良
Java中还支持多层继承。
class A{}
class B extends A{}
class C extends B{}
继承层次多了，就形成了继承体系。 体系就是不断向上抽取而来的。
在使用一个体系的时候，先参阅最顶层类，了解体系的最基本功能。
使用时，创建该体系最底层的类的对象。
看顶层，用底层
2.2 继承中子父类成员的特点：
a.成员变量；
super：代表的就是父类。
super的用法和this很相似
用法super.父类成员。super(实际参数)；
this：代表的是本类型对象的引用。
super：代表的是父类的内存空间。
子类中的super作用为了给父类中的成员变量初始化
字父类中出项同名成员变量时用super区分出父类变量。但是这种情况很少出现
b.成员函数；
当子父类中出现一模一样的函数时。
出现了另一个函数特性：覆盖 或 复写、重写。
overload（重载）：只关注本类中同名函数的参数列表，不关注返回值类型。
override（覆盖）：子父类中函数出现一模一样的函数，才会覆盖
覆盖的应用：保留父类功能声明，建立子类功能内容，这就是覆盖；
覆盖注意事项：
●子类覆盖父类方式，必须要保证子类方法权限大于等于父类方法权限。
●静态只能覆盖静态，或者被静态覆盖。
c.构造函数
子类的实例化过程：子类中的所有构造函数中第一行都有一条默认的隐式语句super();
super():用来调用父类中的空参数的构造函数。
为什么子类中都有默认super语句呢？
因为子类对象中会存在父类中的属性数据，必须要子类对象初始化时，先执行父类的初始化动作，看看父类是如何对自己的属性数据进行初始化的。
所以呢。子类的所有构造函数默认第一行（因为初始化动作要先执行，所以定义在第一行）都有一条默认的super()语句。
如果父类中没有定义空参数的构造函数，子类构造函数必须通过super或this语句指定要访问的父类的构造函数。
2.3 final关键字：
a.修饰符，修饰类，方法，各种变量。
b.final修饰类不可以被继承。
c.final修饰的方法不可以被覆盖。
d.final修饰的变量是一个常量，只能赋值一次。
对固定不变的值进行名称定义，提高其阅读性，
final修饰的常量 命名规则 所有字母都大写，多个单词，单词间用_连接。
2.4 抽象：
类是用来描述事物，当没有足够的信息去描述一个事物时，这个描述就是抽象的。
抽象类的特点：
a.抽象方法只有声明，没有方法体。
b.抽象方法一定定义在抽象类中，都需要被abstract关键字修饰。
c.抽象类不可以用new创建对象。
d.抽象类必须有自己的子类覆盖了所有的抽象方法后，该子类才可以被实例化，否则，该子类还是一个抽象类。
2.5 如果一个抽象类的方法都是抽象的，这时可以将抽象类用另一种形式来体现，就是接口
接口定义的关键字就是 interface
接口中成员的定义：
常见成员有两种：1.全局常量； 2.抽象方法。
接口的好处：是将多继承进行改良，用多实现进行体现。
一个类只能继承一个类，但是一个类可以实现多个接口。
一个类继承类的同时，还可以实现多个接口。
接口的出现避免了单继承的局限性。
2.6 接口与抽象类的区别：
共性：
抽象类和接口都是不断向上抽取而来的；
区别：
1.抽象类中可以定义抽象方法，也可以定义非抽象方法，非抽象方法可以直接提供给子类使用；
接口只能定义抽象方法。
2.类与类之间是继承关系，is a关系。
类与接口之间是实现关系，like a关系
3.类与类之间只能单继承。
类与接口之间可以多实现
3.1 多态：多种形态。
对象的多态性。
class 动物{}
class 猫 extends 动物{}
猫 x=new 猫();
动物 y =new 猫();//猫这个实体具备着两种形态，一个是猫另一个是动物。这就是多态性。
多态在程序中的体现：父类或者接口的引用指向了自己的子类对象。
动物 y= new 猫();//向上转型（类型提升），子类对象提升为父类型。
提升的好处：就是提高了扩展性。隐藏了子类型。
提升的局限性：只能使用父类中的方法。如果子类有覆盖，运行的是子类的内容。
猫 c=(猫)y;//向下转型(强制类型转换),好处：可以使用具体子类型的特有方法。
向下转型需要注意：父类型向下转成子类型，因为子类型不唯一，所以，需要进行判断。
判断用：instanceof关键字
对象 instanceof 类or接口...
记住：对于子父类型转换动作，自始自终都是子类对象在做着类型的转换而已。
多态的前提：
a.必须有继承或者实现的关系。
b.通常都有覆盖的操作。
多态的好处：
提高了程序的扩展性； 在思想上也有不同，以前面对一个对象调用，对象多了调用麻烦。
相当于指挥一批对象做事情，将复杂事情简单化。
多态的弊端：
多态的出现，虽然可以让前期的程序使用后期的内容。
不可以使用子类特有的内容。
3.2 多态调用时的特性:
a.成员变量：
多态调用时，对于成员变量，无论是编译还是运行，结果只参考引用型变量所属的类中的成员变量。参考等号左边。
b.成员方法：
多态调用时，对于成员函数
编译时，参考引用型变量所属的类中是否有被调用的方法。有，编译通过，没有，编译报错。
运行时，参考的是对象所属的类中是否有调用的方法。
简单说：编译看左边，运行看右边.
c.静态函数：
简单说：编译和运行都看左边。
3.3 object：所有类的超类。
所有对象都具备的方法定义在该类中。
3.4 getClass(); Class c1 = p1.getClass();//获取person对象所属的字节码文件对象。这个对象的类型Class.
3.5 内部类：将类定义在另一个类的内部，内部类的就称为内部类。
内部类编译后，在内部类的class文件前有一个$符号
访问方式：内部类可以直接访问外部类中的成员。
外部类要访问内部类中的成员，必须要创建内部类中的对象。
注意：当内部类中定义可静态成员，该内部类必须被静态修饰。
非静态内部类能直接访问外部成员的原因，是他持有一个外部成员的索引this
3.6 内部类定义在局部中，只能访问被final修饰的局部变量。
3.7 匿名内部类：
匿名内部类的形式。
其实就是对内部类进行简化书写。
必须有前提：
内部类必须继承或者实现类或接口。
格式：
new 父类名或者接口名(){定义内部类的内容;}
匿名内部类其实就是一个子类匿名对象。