一、不需要实例化的原因
看一个示例：
package com.zhangguo.chapter5.s1;/**动物园*/public class Zoo { public static void main(String[] args) { Animal animal=new Animal(); animal.eat(); /**new谁调谁*/ /**LSP*/ Animal dog=new Dog(); dog.eat(); }}/**动物*/class Animal { /**吃*/ public void eat(){ System.out.println("动物吃东西"); }}class Cat extends Animal{ /**重写吃*/ public void eat(){ System.out.println("猫吃鱼"); }}class Dog extends Animal{ /**重写吃*/ public void eat(){ System.out.println("狗吃骨头"); }} 结果：
问题：
从上面的示例可以看出Animal是抽象的父类，其实现实中并不存在一种叫动物的实际对象，而动物仅仅是一个被抽象的概念。
既然这样，Animal就不应该实例化，只能作为父类，在面向对象中（OOP）充当这种角色的类型有：抽象类，接口。
抽象类与接口是一种比类更加抽象的类型。
一、不能实例化的类型
从上面的概念中可以得知有些类型是不应该实例化的，没有意义。
java中抽象类更利于代码的维护和重用。
1.因为抽象类不能实例化对象，所以必须要有子类来实现它之后才能使用。这样就可以把一些具有相同属性和方法的组件进行抽象，这样更有利于代码和程序的维护。
2.当又有一个具有相似的组件产生时，只需要实现该抽象类就可以获得该抽象类的那些属性和方法。
在面向对象方法中，抽象类主要用来进行类型隐藏。构造出一个固定的一组行为的抽象描述，但是这组行为却能够有任意个可能的具体实现方式。这个抽象描述就是抽象类，而这一组任意个可能的具体实现则表现为所有可能的派生类。模块可以操作一个抽象体。由于模块依赖于一个固定的抽象体，因此它可以是不允许修改的；同时，通过从这个抽象体派生，也可扩展此模块的行为功能。为了能够实现面向对象设计的一个最核心的原则OCP(Open-Closed Principle)，抽象类是其中的关键所在。
(1)、接口
(2)、抽象类
(3)、构造方法的访问权限为私有
package com.zhangguo.chapter5.s1;/** 吃 接口 */interface Ieatable { void eat();}/** 动物 抽象类 */abstract class Animal { /** 吃 抽象方法 */ public abstract void eat();}/** 学生 普通类 */class Student { /** 私有构造方法 */ private Student() { }}public class NoInstance { public static void main(String[] args) { Ieatable obj1 = new Ieatable(); // 错误 不能实例化接口 Animal obj2 = new Animal(); // 错误 不能实例化抽象类 Student obj3 = new Student(); // 错误 不能实例化私有构造方法类 }} 有些语言中静态类也不能实例化，如C#
意义：越抽象，越稳定。抽象的可以定义上层结构，规范顶层设计。抽象不会也不应该随意变化。
二、抽象类
2.1、语法定义
抽象类定义，抽象类前使用abstract关键字修饰，则该类为抽象类。
2.2、用途
a、在某些情况下，某个父类只是知道其子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法
（抽象类约束子类必须有哪些方法，但并不关注子类怎么去实现这些方法。）b、从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为子类的模板，从而避免了子类设计的随意性。
2.3、意义
限制规定子类必须实现某些方法，但不关注实现细节。
2.4、特点
1，抽象方法一定在抽象类中
2，抽象方法和抽象类都必须被abstract关键字修饰
3，抽象类不可以用new创建对象。因为调用抽象方法没意义4，抽象类中的抽象方法要被使用，必须由子类复写起所有的抽象方法后，建立子类对象调用。
如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。
5、抽象方法没有方法体，以分号结束
示例：
package com.zhangguo.chapter5.s2;import java.util.Scanner;/** 动物 */public abstract class Animal { /** 名称 */ public String name; /** 抽象方法，无方法体，必须被子类实现（重写） */ public abstract void eat(); /**测试*/ public static void main(String[] args) { //LSP 里氏替换原则 Animal dog=new Dog(); dog.name="博美"; //int i=1; //Scanner input=new Scanner(System.in); dog.eat(); } /**抽象类中可以有非抽象方法，可以有静态方法*/ public void show(){};}/**抽象类动物（Animal）的子类，必须实现父类未实现的方法*/class Dog extends Animal { //注解 @Override public void eat() { System.out.println(this.name+"狗在吃骨头"); }} 运行结果：
三、接口
接口是一组没有实例的标准与规范。
没有接口的电脑是怎样的？
3.1、为什么需要接口
继承：描述事物的自然属性和行为的复用。
接口：描述事物的社会属性和行为的复用。
1、重要性：在Java语言中， abstract class 和interface 是支持抽象类定义的两种机制。正是由于这两种机制的存在，才赋予了Java强大的 面向对象能力。
2、简单、规范性：如果一个项目比较庞大，那么就需要一个能理清所有业务的架构师来定义一些主要的接口，这些接口不仅告诉开发人员你需要实现那些业务，而且也将命名规范限制住了（防止一些开发人员随便命名导致别的程序员无法看明白）。
3、维护、拓展性：比如你要做一个画板程序，其中里面有一个面板类，主要负责绘画功能，然后你就这样定义了这个类。
4、安全、严密性：接口是实现软件松耦合的重要手段，它描叙了系统对外的所有服务，而不涉及任何具体的实现细节。这样就比较安全、严密一些（一般软件服务商考虑的比较多）。
因为类具有“单根性”，所有的类只能有一个直接父类，通过可以实现一个类有多个父类，可以实现多重继承。
package com.zhangguo.chapter5.s2;/**usb接口*/public interface IUSB { /**未实现的方法，发送数据*/ void sendData();}/**网线接口*/interface IRJ45{ /**未实现的方法，接收数据*/ void receiveData();}/**设备*/class Device{ }/**电脑*//**一个类只能继承一个类，但可以实现多个接口*/class Computer extends Device implements IUSB,IRJ45{ @Override public void receiveData() { System.out.println("接收数据"); } @Override public void sendData() { System.out.println("发送数据"); } interface IA{} interface IB{} /**接口可以继承其它他口*/ interface IC extends IA,IB{} class CC{} /**继承需要写在实现接口前*/ class DD extends CC implements IC {}} 测试：
package com.zhangguo.chapter5.s2;public class ComputerClient { public static void main(String[] args) { Computer ln=new Computer(); ln.sendData(); ln.receiveData(); /**接口是一种类型*/ IUSB usb=new Computer(); /**一个对象可以有多个不同的类型*/ }} 
3.2、接口的特点
1)、接口中的方法可以有参数列表和返回类型，但不能有任何方法体。
2)、接口中可以包含字段，但是会被隐式的声明为static和final。
3)、接口中的字段只是被存储在该接口的静态存储区域内，而不属于该接口。
4)、接口中的方法可以被声明为public或不声明，但结果都会按照public类型处理。
5)、当实现一个接口时，需要将被定义的方法声明为public类型的，否则为默认访问类型，Java编译器不允许这种情况。
6)、如果没有实现接口中所有方法，那么创建的仍然是一个接口。子类必须实现接口中未实现的方法，除非子类也是接口。
7)、扩展一个接口来生成新的接口应使用关键字extends，实现一个接口使用implements。
8)、接口中的方法是抽象方法(abstract)，不能是静态方法(static))、接口的所有方法都是抽象的，而抽象方法是没有static，有static的方法是不能override的，所以这样定义接口才有意义。
接口中的字段是默认为:static final ，通俗说就是常量
四、Final（最终的）
4.1、final修饰类
final修饰的类不允许被继承。
一个类不能既是final的，又是abstract的。因为abstract的主要目的是定义一种约定，让子类去实现这种约定，而final表示该类不能被继承，两者矛盾。
4.2、final修饰方法
final修饰方法，表示该方法不能被子类中的方法覆写Override。不能被重写
4.3、final修饰变量
final成员变量表示常量，只能被赋值一次，赋值后值不再改变。
当final修饰一个原生数据类型时，表示该原生数据类型的值不能发生变化；
如果final修饰一个引用类型时，表示该引用类型不能再指向其他对象了，但该引用所指向的对象的内容是可以发生变化的。
本质上是一回事，因为引用的值是一个地址，final要求值，即地址的值不发生变化。
final修饰一个成员变量（属性），必须要显示初始化。
这里有两种初始化方式，一种是在变量声明的时候初始化；第二种方法是在声明变量的时候不赋初值，但是要在这个变量所在的类的所有的构造函数中对这个变量赋初值。
当函数的参数类型声明为final时，说明该参数是只读型的。
五、内部类
5.1、什么是内部类
内部类是指在一个外部类的内部再定义一个类。内部类作为外部类的一个成员，并且依附于外部类而存在的。内部类可为静态，可用protected和private修饰（而外部类只能使用public和缺省的包访问权限）。内部类主要有以下几类：成员内部类、局部内部类、静态内部类、匿名内部类
示例：
package com.zhangguo.innnerclass;public class InnerDemo2 { public static void main(String[] args) { //实例化的方法一 Box box=new Box(); box.height=286; Box.InBox inbox=box.new InBox(); inbox.show(); //实例化的方法二 Box.InBox box2=new Box().new InBox(); box2.show(); }}//外部类class Box{ //外部类的成员变量 public int height=198; //成员内部类 class InBox{ //内部类的成员 public void show(){ System.out.println("外部类的高度："+height); } }} 结果：
外部类的高度：286外部类的高度：198
从上面的例子不难看出，内部类其实严重破坏了良好的代码结构，但为什么还要使用内部类呢？
因为内部类可以随意使用外部类的成员变量（包括私有）而不用生成外部类的对象，这也是内部类的唯一优点程序编译过后会产生两个.class文件，分别是Out.class和Out＄In.class其中＄代表了上面程序中Out.In中的那个。Out.In in = new Out().new In()可以用来生成内部类的对象，这种方法存在两个小知识点需要注意
1.开头的Out是为了标明需要生成的内部类对象在哪个外部类当中
2.必须先有外部类的对象才能生成内部类的对象，因为内部类的作用就是为了访问外部类中的成员变量
示例：
package com.zhangguo.innnerclass;public class InnerDemo3 { public static void main(String[] args) { new OutBox().new InBox().show(); }}//外部类class OutBox{ //外部类的成员变量 private int height=197; //成员内部类 class InBox{ //内部类的成员变量 private int height=198; //内部类的成员 public void show(){ //内部类的局部变量 int height=199; System.out.println("内部类的局部变量："+height); System.out.println("内部类的成员变量："+this.height); System.out.println("外部类的成员变量："+OutBox.this.height); } }} 结果：
内部类的局部变量：199内部类的成员变量：198外部类的成员变量：197
内部类在没有同名成员变量和局部变量的情况下，内部类会直接访问外部类的成员变量，而无需指定Out.this.属性名
否则，内部类中的局部变量会覆盖外部类的成员变量
而访问内部类本身的成员变量可用this.属性名，访问外部类的成员变量需要使用Out.this.属性名
5.2、内部类的共性
(1)、内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号 。
(2)、内部类不能用普通的方式访问。
(3)、内部类声明成静态的，就不能随便的访问外部类的成员变量了，此时内部类只能访问外部类的静态成员变量 。
(4)、外部类不能直接访问内部类的的成员，但可以通过内部类对象来访问
内部类是外部类的一个成员，因此内部类可以自由地访问外部类的成员变量，无论是否是private的。
因为当某个外围类的对象创建内部类的对象时，此内部类会捕获一个隐式引用，它引用了实例化该内部对象的外围类对象。通过这个指针，可以访问外围类对象的全部状态。
通过反编译内部类的字节码，分析之后主要是通过以下几步做到的：
1 编译器自动为内部类添加一个成员变量， 这个成员变量的类型和外部类的类型相同， 这个成员变量就是指向外部类对象的引用； 2 编译器自动为内部类的构造方法添加一个参数， 参数的类型是外部类的类型， 在构造方法内部使用这个参数为1中添加的成员变量赋值； 3 在调用内部类的构造函数初始化内部类对象时， 会默认传入外部类的引用。5.3、为什么需要内部类
其主要原因有以下几点：
-
内部类方法可以访问该类定义所在的作用域的数据，包括私有的数据
-
内部类可以对同一个包中的其他类隐藏起来,一般的非内部类，是不允许有 private 与protected权限的，但内部类可以
-
可以实现多重继承
-
当想要定义一个回调函数且不想编写大量代码时，使用匿名内部类比较便捷
使用内部类最吸引人的原因是：
每个内部类都能独立地继承自一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。大家都知道Java只能继承一个类，它的多重继承在我们没有学习内部类之前是用接口来实现的。但使用接口有时候有很多不方便的地方。比如我们实现一个接口就必须实现它里面的所有方法。而有了内部类就不一样了。它可以使我们的类继承多个具体类或抽象类。
大家看下面的例子:
package com.zhangguo.innnerclass;public class InnerDemo4 { public static void main(String[] args) { Person person=new Person(); person.bark(); }}abstract class Fruit{ public String name="水果";}abstract class Animal{ public void bark(){ System.out.println("呱呱..."); }}class Person{ class FruitAttr extends Fruit{ } class AnimalAttr extends Animal{ @Override public void bark() { super.bark(); System.out.println(getName()+"嘎嘎..."); } } public String getName(){ return new FruitAttr().name; } public void bark(){ new AnimalAttr().bark(); }} 结果：
呱呱...水果嘎嘎...
5.4、成员内部类
即在一个类中直接定义的内部类， 成员内部类与普通的成员没什么区别，可以与普通成员一样进行修饰和限制。成员内部类不能含有static的变量和方法。
public class Outer { private static int i = 1; private int j = 10; private int k = 20; public static void outer_f1() {} public void outer_f2() {} // 成员内部类中，不能定义静态成员 // 成员内部类中，可以访问外部类的所有成员 class Inner { // static int inner_i = 100;//内部类中不允许定义静态变量 int j = 100; // 内部类和外部类的实例变量可以共存 int inner_i = 1; void inner_f1() { System.out.println(i); // 在内部类中访问内部类自己的变量直接用变量名 System.out.println(j); // 在内部类中访问内部类自己的变量也可以用this.变量名 System.out.println(this.j); // 在内部类中访问外部类中与内部类同名的实例变量用外部类名.this.变量名 System.out.println(Outer.this.j); // 如果内部类中没有与外部类同名的变量，则可以直接用变量名访问外部类变量 System.out.println(k); outer_f1(); outer_f2(); } } // 外部类的非静态方法访问成员内部类 public void outer_f3() { Inner inner = new Inner(); inner.inner_f1(); } // 外部类的静态方法访问成员内部类，与在外部类外部访问成员内部类一样 public static void outer_f4() { // step1 建立外部类对象 Outer out = new Outer(); // step2 根据外部类对象建立内部类对象 Inner inner = out.new Inner(); // step3 访问内部类的方法 inner.inner_f1(); } public static void main(String[] args) { //outer_f4();//该语句的输出结果和下面三条语句的输出结果一样 // 如果要直接创建内部类的对象，不能想当然地认为只需加上外围类Outer的名字， // 就可以按照通常的样子生成内部类的对象，而是必须使用此外围类的一个对象来 // 创建其内部类的一个对象： // Outer.Inner outin = out.new Inner() // 因此，除非你已经有了外围类的一个对象，否则不可能生成内部类的对象。因为此 // 内部类的对象会悄悄地链接到创建它的外围类的对象。如果你用的是静态的内部类， // 那就不需要对其外围类对象的引用。 Outer out = new Outer(); Outer.Inner outin = out.new Inner(); outin.inner_f1(); }} 示例： class Person{ static class MyClass{ double PI=3.14; //允许 } class FruitAttr extends Fruit{ //The field PI cannot be declared static in a non-static inner type, unless initialized with a constant expression //默认情况下内部类的成员不能是静态的，除非内部类也是静态的，或者将成员声明为常量表达式如（static final） //static double PI=3.14; static final double PI=3.14; }} 5.5、局部内部类
在方法中定义的内部类称为局部内部类。与局部变量类似，局部内部类不能有访问说明符，因为它不是外围类的一部分，但是它可以访问当前代码块内的常量，和此外围类所有的成员。
需要注意的是：
(1)、局部内部类只能在定义该内部类的方法内实例化，不可以在此方法外对其实例化。
(2)、局部内部类对象不能使用该内部类所在方法的非final局部变量。
具体原因等下再说
public class Outer { private int s = 100; private int out_i = 1; public void f(final int k) { final int s = 200; int i = 1; final int j = 10; // 定义在方法内部 class Inner { int s = 300;// 可以定义与外部类同名的变量 // static int m = 20;//不可以定义静态变量 Inner(int k) { inner_f(k); } int inner_i = 100; void inner_f(int k) { // 如果内部类没有与外部类同名的变量，在内部类中可以直接访问外部类的实例变量 System.out.println(out_i); // 可以访问外部类的局部变量(即方法内的变量)，但是变量必须是final的 System.out.println(j); // System.out.println(i); // 如果内部类中有与外部类同名的变量，直接用变量名访问的是内部类的变量 System.out.println(s); // 用this.变量名访问的也是内部类变量 System.out.println(this.s); // 用外部类名.this.内部类变量名访问的是外部类变量 System.out.println(Outer.this.s); } } new Inner(k); } public static void main(String[] args) { // 访问局部内部类必须先有外部类对象 Outer out = new Outer(); out.f(3); }} 5.7、静态内部类(嵌套类)
如果你不需要内部类对象与其外围类对象之间有联系，那你可以将内部类声明为static。这通常称为嵌套类（nested class）。想要理解static应用于内部类时的含义，你就必须记住，普通的内部类对象隐含地保存了一个引用，指向创建它的外围类对象。然而，当内部类是static的时，就不是这样了。嵌套类意味着：
1. 要创建嵌套类的对象，并不需要其外围类的对象。
2. 不能从嵌套类的对象中访问非静态的外围类对象。
public class Outer { private static int i = 1; private int j = 10; public static void outer_f1() {} public void outer_f2() {} // 静态内部类可以用public,protected,private修饰 // 静态内部类中可以定义静态或者非静态的成员 private static class Inner { static int inner_i = 100; int inner_j = 200; static void inner_f1() { // 静态内部类只能访问外部类的静态成员(包括静态变量和静态方法) System.out.println("Outer.i" + i); outer_f1(); } void inner_f2() { // 静态内部类不能访问外部类的非静态成员(包括非静态变量和非静态方法) // System.out.println("Outer.i"+j); // outer_f2(); } } public void outer_f3() { // 外部类访问内部类的静态成员：内部类.静态成员 System.out.println(Inner.inner_i); Inner.inner_f1(); // 外部类访问内部类的非静态成员:实例化内部类即可 Inner inner = new Inner(); inner.inner_f2(); } public static void main(String[] args) { new Outer().outer_f3(); }} 生成一个静态内部类不需要外部类成员：这是静态内部类和成员内部类的区别。静态内部类的对象可以直接生成：Outer.Inner in = new Outer.Inner();而不需要通过生成外部类对象来生成。这样实际上使静态内部类成为了一个顶级类(正常情况下，你不能在接口内部放置任何代码，但嵌套类可以作为接口的一部分，因为它是static 的。只是将嵌套类置于接口的命名空间内，这并不违反接口的规则）
5.8、匿名内部类
- 只用到类的一个实例。
- 类在定义后马上用到。
- 类非常小（SUN推荐是在4行代码以下）
- 给类命名并不会导致你的代码更容易被理解。
-
匿名内部类不能有构造方法。
-
匿名内部类不能定义任何静态成员、方法和类。
-
匿名内部类不能是public,protected,private,static。
-
只能创建匿名内部类的一个实例。
-
一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。
-
因匿名内部类为局部内部类，所以局部内部类的所有限制都对其生效。
public class Parcel7 { public Wrapping wrap(int x) { // Base constructor call: return new Wrapping(x) { // Pass constructor argument. public int value() { return super.value() * 47; } }; // Semicolon required } public static void main(String[] args) { Parcel7 p = new Parcel7(); Wrapping w = p.wrap(10); }} public class Parcel8 { // Argument must be final to use inside // anonymous inner class: public Destination dest(final String name, String city) { return new Destination(name, city) { private String label = name; public String getName() { return label; } }; } public static void main(String[] args) { Parcel8 p = new Parcel8(); Destination d = p.dest("Tanzania", "gz"); } abstract class Destination { Destination(String name, String city) { System.out.println(city); } abstract String getName(); }} 匿名内部类也就是没有名字的内部类
正因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写
但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口
示例：
package com.zhangguo.innnerclass;public class InnerDemo5 { public static void main(String[] args) { IFly bird=new Bird(); bird.fly(); IFly pig=new IFly() { @Override public void fly() { System.out.println("猪在飞..."); } }; pig.fly(); Display(new Man(){ @Override public void show() { super.show(); System.out.println("我是一个男人！"); } }); Man woman=new Man(){ @Override public void show() { super.show(); System.out.println("我是一个女人！"); } }; woman.show(); } public static void Display(Man man){ man.show(); }}interface IFly{ void fly();}class Man{ public void show(){ System.out.println("我是一个人"); }} Bird类:
package com.zhangguo.innnerclass;public class Bird implements IFly { @Override public void fly() { System.out.println("鸟在飞..."); }}
结果：
鸟在飞...猪在飞...我是一个人我是一个男人！我是一个人我是一个女人！
实例1:不使用匿名内部类来实现抽象方法
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | abstract class Person { public abstract void eat(); } class Child extends Person { public void eat() { System.out.println( "eat something" ); } } public class Demo { public static void main(String[] args) { Person p = new Child(); p.eat(); } } |
运行结果：eat something
可以看到，我们用Child继承了Person类，然后实现了Child的一个实例，将其向上转型为Person类的引用
但是，如果此处的Child类只使用一次，那么将其编写为独立的一个类岂不是很麻烦？
这个时候就引入了匿名内部类
实例2：匿名内部类的基本实现
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 | abstract class Person { public abstract void eat(); } public class Demo { public static void main(String[] args) { Person p = new Person() { public void eat() { System.out.println( "eat something" ); } }; p.eat(); } } |
运行结果：eat something
可以看到，我们直接将抽象类Person中的方法在大括号中实现了
这样便可以省略一个类的书写
并且，匿名内部类还能用于接口上
实例3：在接口上使用匿名内部类
interface Person { public void eat(); } public class Demo { public static void main(String[] args) { Person p = new Person() { public void eat() { System.out.println( "eat something" ); } }; p.eat(); } } |
运行结果：eat something
由上面的例子可以看出，只要一个类是抽象的或是一个接口，那么其子类中的方法都可以使用匿名内部类来实现
最常用的情况就是在多线程的实现上，因为要实现多线程必须继承Thread类或是继承Runnable接口
实例4：Thread类的匿名内部类实现
public class Demo { public static void main(String[] args) { Thread t = new Thread() { public void run() { for ( int i = 1 ; i <= 5 ; i++) { System.out.print(i + " " ); } } }; t.start(); } } |
运行结果：1 2 3 4 5
实例5：Runnable接口的匿名内部类实现
| 1 2 3 4 5 6 7 8 9 10 11 12 13 | public class Demo { public static void main(String[] args) { Runnable r = new Runnable() { public void run() { for ( int i = 1 ; i <= 5 ; i++) { System.out.print(i + " " ); } } }; Thread t = new Thread(r); t.start(); } } |
运行结果：1 2 3 4 5
5.9、内部类的重载问题
class Egg { private Yolk y; protected class Yolk { public Yolk() { System.out.println("Egg.Yolk()"); } } public Egg() { System.out.println("New Egg()"); y = new Yolk(); }} public class BigEgg extends Egg { public class Yolk { public Yolk() { System.out.println("BigEgg.Yolk()"); } } public static void main(String[] args) { new BigEgg(); } } class Egg2 { protected class Yolk { public Yolk() { System.out.println("Egg2.Yolk()"); } public void f() { System.out.println("Egg2.Yolk.f()"); } } private Yolk y = new Yolk(); public Egg2() { System.out.println("New Egg2()"); } public void insertYolk(Yolk yy) { y = yy; } public void g() { y.f(); }} public class BigEgg2 extends Egg2 { public class Yolk extends Egg2.Yolk { public Yolk() { System.out.println("BigEgg2.Yolk()"); } public void f() { System.out.println("BigEgg2.Yolk.f()"); } } public BigEgg2() { insertYolk(new Yolk()); } public static void main(String[] args) { Egg2 e2 = new BigEgg2(); e2.g(); }} 5.10、内部类的继承问题
class WithInner { class Inner { Inner(){ System.out.println("this is a constructor in WithInner.Inner"); }; }} public class InheritInner extends WithInner.Inner { // ! InheritInner() {} // Won't compile InheritInner(WithInner wi) { wi.super(); System.out.println("this is a constructor in InheritInner"); } public static void main(String[] args) { WithInner wi = new WithInner(); InheritInner ii = new InheritInner(wi); }} 为什么非静态内部类中不能有static修饰的属性，但却可以有常量？
如：
public class InnerClassDemo{ int x; class A{ static int a = 0;//这样写是不合法的. static final int b=0;//这样写是合法的 }} 定义一个静态的域或者方法，要求在静态环境或者顶层环境，即如果加上 static class A变成静态内部类就ok非静态内部类 依赖于一个外部类对象，而静态域/方法是不依赖与对象——仅与类相关（细说了，就是加载静态域时，根本没有外部类对象）因此，非静态内部类中不能定义静态域/方法，编译过不了。
而常量之所以可以（不论有无static），因为java在编译期就确定所有常量，放到所谓的常量池当中。常量的机制和普通变量不一样匿名内部类和局部内部类只能访问final变量
六、视频与示例下载
七、面试题
1、Java中有那些不能实例化的类型？
2、抽象类有何特点？
3、接口有何特点？
八、面向对象综合应用
8.1、面向对象5大设计原则
8.2、设计模式