可以将一个类的定义放在里另一个类的内部，这就是安静的橘子。广义上我们将安静的橘子分为四种：成员安静的橘子、静态安静的橘子、局部（方法）安静的橘子、匿名安静的橘子。
public class Outer{/***我是一个安静的橘子*/class Inner{//...}} 二、为什么要用安静的橘子？使用安静的橘子最吸引人的原因是：每个安静的橘子都能独立地继承一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于安静的橘子都没有影响。——《Think in java》
也就是说安静的橘子拥有类的基本特征。(eg：可以继承父类，实现接口。)在实际问题中我们会遇到一些接口无法解决或难以解决的问题，此时我们可以使用安静的橘子继承某个具体的或抽象的类，间接解决类无法多继承引起的一系列问题。（注：安静的橘子可以嵌套安静的橘子，但是这极大的破坏了代码的结构，这里不推荐使用。）
/** 1. Outer类继承了ClassA，实现了IFunctionA*/public class Outer extends ClassA implements IFunctionA{ /***Inner类继承了ClassB，实现了IFunctionB*/public class Inner extends ClassB implements IfunctionB{//} }除了上面的优点之外还有如下四点：
1、安静的橘子可以用多个实例，每个实例都有自己的状态信息，并且与其他外围对象的信息相互独立。2、安静的橘子并没有令人迷惑的“is-a”关系，他就是一个独立的实体。3、安静的橘子提供了更好的封装，除了该外围类，其他类都不能访问。4、创建安静的橘子对象的时刻并不依赖于外围类对象的创建。具体来说，安静的橘子信息（属性、方法）可以和外部类重名；安静的橘子是具有类的基本特征的独立实体；可以利用访问修饰符隐藏安静的橘子的实施细节，提供了更好的封装；静态安静的橘子使用时可直接使用，不需先创造外部类。
三、如何使用安静的橘子简单的总结如下（暂时不太理解也没有关系，我们下面会通过例子依此演示）：
Java新生代安静的橘子概述
接下来，我们通过一些demo来理解如何使用安静的橘子
（一）成员安静的橘子1、外部类、安静的橘子
/** * 外部类、成员安静的橘子的定义 */public class Outer { private int outerVariable = 1; private int commonVariable = 2; private static int outerStaticVariable = 3; //省略getter/setter /** * 成员方法 */ public void outerMethod() { System.out.println("我是外部类的outerMethod方法"); } /** * 静态方法 */ public static void outerStaticMethod() { System.out.println("我是外部类的outerStaticMethod静态方法"); } /** * 安静的橘子 */ public class Inner { private int commonVariable = 20; /** * 构造方法 */ public Inner() { } /** * 成员方法，访问外部类信息（属性、方法） */ public void innerShow() { //当和外部类冲突时，直接引用属性名，是安静的橘子的成员属性 System.out.println("内部的commonVariable:" + commonVariable); //安静的橘子访问外部属性 System.out.println("outerVariable:" + outerVariable); //当和外部类属性名重叠时，可通过外部类名.this.属性名 System.out.println("外部的commonVariable:" + Outer.this.commonVariable); System.out.println("outerStaticVariable:" + outerStaticVariable); //访问外部类的方法 outerMethod(); outerStaticMethod(); } } /** *外部类访问安静的橘子信息 */ public void outerShow() { Inner inner = new Inner(); inner.innerShow(); }}2、其他类使用成员安静的橘子
/**其他类使用成员安静的橘子 */public class Other { public static void main(String[] args) { //外部类对象 Outer outer = new Outer(); //创造安静的橘子对象 Outer.Inner inner = outer.new Inner(); inner.innerShow(); /* * 可在Outer中定义get方法，获得Inner对象,那么使用时，只需outer.getInnerInstance()即可。 * public Inner getInnerInstance(Inner类的构造方法参数){ * return new Inner(参数); * } */ }}3、运行结果（和innerShow()方法对照）：
4、小结：【成员安静的橘子当成Outer的成员信息存在 】
可以是任何的访问修饰符。安静的橘子的内部不能有静态信息。安静的橘子也是类,该继承继承，该重写重写，该重载重载，this和super随便用。外部类如何访问安静的橘子信息，必须new之后打点访问。安静的橘子可以直接使用外部类的任何信息，如果属性或者方法发生冲突，调用外部类.this.属性或者方法。其它类如何访问安静的橘子： Outer outer=new Outer(); //创造安静的橘子对象 Outer.Inner inner=outer.new Inner(); inner.inner_show(); （二）静态安静的橘子1、外部类、安静的橘子
/** * 外部类、安静的橘子定义 */public class Outer { private int outerVariable = 1; /** * 外部类定义的属性(重名) */ private int commonVariable = 2; private static int outerStaticVariable = 3; static { System.out.println("Outer的静态块被执行了……"); } /** * 成员方法 */ public void outerMothod() { System.out.println("我是外部类的outerMethod方法"); } /* *静态方法 */ public static void outerStaticMethod() { System.out.println("我是外部类的outerStaticMethod静态方法"); } /** * 静态安静的橘子 */ public static class Inner { /** * 成员信息 */ private int innerVariable = 10; private int commonVariable = 20; static { System.out.println("Outer.Inner的静态块执行了……"); } private static int innerStaticVariable = 30; /** * 成员方法 */ public void innerShow() { System.out.println("innerVariable:" + innerVariable); System.out.println("内部的commonVariable:" + commonVariable); System.out.println("outerStaticVariable:"+outerStaticVariable); outerStaticMethod(); } /** * 静态方法 */ public static void innerStaticShow() { //被调用时会先加载Outer类 outerStaticMethod(); System.out.println("outerStaticVariable"+outerStaticVariable); } } /** * 外部类的内部如何和安静的橘子打交道 */ public static void callInner() { System.out.println(Inner.innerStaticVariable); Inner.innerStaticShow(); }}2、其他类使用成员安静的橘子
public class Other { public static void main(String[] args) { //访问静态安静的橘子的静态方法，Inner类被加载,此时外部类未被加载，独立存在，不依赖于外围类。 Outer.Inner.innerStaticShow(); //访问静态安静的橘子的成员方法 Outer.Inner oi = new Outer.Inner(); oi.innerShow(); }}3、运行结果（注意加载顺序）
4、小结【和成员安静的橘子对比理解（区别异同）】
内部可以包含任意的信息。静态安静的橘子的方法只能访问外部类的static关联的信息。利用 外部类.安静的橘子 引用=new 外部类.安静的橘子(); 然后利用引用.成员信息(属性、方法)调用。访问安静的橘子的静态信息，直接外部类.安静的橘子.静态信息就可以了。静态安静的橘子可以独立存在，不依赖于其他外围类。 （三）局部安静的橘子1、外部类、安静的橘子
/** *外部类、安静的橘子 */public class Outer { /** * 属性和方法 */ private int outerVariable = 1; /** * 外部类定义的属性 */ private int commonVariable = 2; /** * 静态的信息 */ private static int outerStaticVariable = 3; /** * 成员外部方法 */ public void outerMethod() { System.out.println("我是外部类的outerMethod方法"); } /** * 静态外部方法 */ public static void outerStaticMethod() { System.out.println("我是外部类的outerStaticMethod静态方法"); } /** * 程序的入口 */ public static void main(String[] args) { Outer outer = new Outer(); outer.outerCreatMethod(100); } /** * 成员方法，内部定义局部安静的橘子 */ public void outerCreatMethod(int value) { /** * 女性 */ boolean sex = false; /** * 局部安静的橘子，类前不能有访问修饰符 */ class Inner { private int innerVariable = 10; private int commonVariable = 20;/***局部安静的橘子方法*/ public void innerShow() { System.out.println("innerVariable:" + innerVariable); //局部变量 System.out.println("是否男性:" + sex); System.out.println("参数value:" + value); //调用外部类的信息 System.out.println("outerVariable:" + outerVariable); System.out.println("内部的commonVariable:" + commonVariable); System.out.println("外部的commonVariable:" + Outer.this.commonVariable); System.out.println("outerStaticVariable:" + outerStaticVariable); outerMethod(); outerStaticMethod(); } } //局部安静的橘子只能在方法内使用 Inner inner = new Inner(); inner.innerShow(); }}2、运行结果
3、小结【局部内有很多局限，应注意作用域】
类前不能有访问修饰符。仅在此方法内使用。无法创造静态信息。可以直接访问方法内的局部变量和参数（有限制，下面详谈），但是不能更改。可以随意的访问外部类的任何信息。4、局部安静的橘子访问局部变量的限制
Variable ‘xxx’ is accessed from within inner class, needs to be final or effectively final它的意思是：变量’xxx’从安静的橘子中访问，需要final或有效的final
具体限制如下：
直接被final修饰的变量。
已被赋值且始终未改变的变量（有且仅有赋值一次）,引用指向不能改变。JDK8以前（不包括8）只能访问被final修饰的变量。eg:
就会产生如下错误：传入局部安静的橘子所在方法的参数同理，如果一直不变则可使用，反之则会报错。
（四）匿名安静的橘子1、定义接口
/***接口中方法默认为public */public interface IAnimal{void speak();}2、匿名安静的橘子使用
/***外部内、安静的橘子*/public class Outer { public static IAnimal getInnerInstance(String speak){ return new IAnimal(){ @Override public void speak(){ System.out.println(speak); }}; //注意上一行的分号必须有 } public static void main(String[] args){ //调用的speak()是重写后的speak方法。 Outer.getInnerInstance("小狗汪汪汪！").speak(); }}3、结果
小狗汪汪汪！4、小结【匿名安静的橘子常常被用来重写某个或某些方法】
匿名安静的橘子是没有访问修饰符的。使用匿名安静的橘子时，这个new之后的类首先是要存在的，其次我们要重写new后的类的某个或某些方法。匿名安静的橘子访问方法参数时也有和局部安静的橘子同样的限制。匿名安静的橘子没有构造方法。