嵌套类是指被定义在另外一个类的内部的类。java
嵌套类存在的目的是：只是为它的外部类提供服务；多线程
outer.java里面定义了一个内部类inner，运行时，一旦编译成功，就会生成两个彻底不一样的.class文件，分别是outer.class和outer$inner.class。ide
嵌套类分为四种：静态成员类，非静态成员类（成员内部类），匿名类，局部类。测试
内部类：非静态成员类（成员内部类），匿名类，局部类。spa
1.静态内部类
1 public class Outer { 2 3 public static String name = "Joe"; 4 private String password = "0806"; 5 6 //静态内部类 7 public static class inner{ 8 public static void print1(){ 9 System.out.println(name); 10 //调用外部类的静态方法 11 outerPrint(); 12 } 13 public void print2(){ 14 System.out.println(name); 15 } 16 } 17 18 public static void outerPrint(){ 19 System.out.println("Outer static method!"); 20 } 21 22 public static void main(String[] args){ 23 //静态内部类的静态方法调用 24 Outer.inner.print1(); 25 //静态内部类的非静态方法调用 26 Outer.inner inner = new Outer.inner(); 27 inner.print2(); 28 } 29 }
输出结果：线程
Joe
Outer static method!
Joecode
经过这个例子能够看出：对象
♥ 静态内部类中能够有静态方法，也能够有非静态方法；blog
♥ 静态内部类只能访问其外围类的静态成员和静态方法；继承
♥ 和普通的类同样，要访问静态内部类的静态方法，能够直接“.”出来，不须要一个实例；
♥ 要访问静态内部类的非静态方法，必须拿到一个静态内部类的实例对象；
♥ 实例化静态内部类：外围类.内部类 xxx = new 外围类.内部类();
能够把静态内部类看做普通的类，只是碰巧被声明在另外一个类的内部而已；若是静态内部类被声明为私有的，那么它就只能在外围类的内部才能够访问。
非静态成员类（成员内部类）
成员内部类是最多见的内部类，就是在外部类的基础上按照通常定义类的方式定义类，举个例子：
1 public class Outer { 2 3 public static String name = "Joe"; 4 private String password = "0806"; 5 6 //私有成员内部类 7 private class PrivateInner{ 8 public void print1(){ 9 System.out.println("private " + name); 10 System.out.println("public " + password); 11 //调用外部类的静态方法 12 outerPrint(); 13 } 14 } 15 //公有的成员内部类 16 public class PublicInner{ 17 public void print2(){ 18 String password = "0810"; 19 System.out.println("public " + name); 20 System.out.println("public " + password); 21 //调用外部类的静态方法 22 outerPrint(); 23 } 24 } 25 public static void outerPrint(){ 26 System.out.println("Outer static method!"); 27 } 28 29 public static void main(String[] args){ 30 Outer outer = new Outer(); 31 Outer.outerPrint(); 32 //实例化私有成员内部类 33 Outer.PrivateInner privateInner = outer.new PrivateInner(); 34 privateInner.print1(); 35 //实例化公有成员内部类 36 Outer.PublicInner publicInner = outer.new PublicInner(); 37 publicInner.print2(); 38 } 39 }
输出结果：
Outer static method!
private Joe
public 0806
Outer static method!
public Joe
public 0810
Outer static method!
经过这个例子能够看出：
♥ 成员内部类是依附其外围类而存在的，若是要产生一个成员内部类，必须有一个其外围类的实例；
♥ 成员内部类不能够定义静态方法和静态属性；
♥ 声明为private的成员内部类，只对其外围类可见；声明为public的成员内部类，其余非外围类对其可见；
♥ 成员内部类能够访问外围类的私有属性，若是成员内部类的属性和其外围类的属性重名，则以成员内部类的属性值为准；
♥ 实例化成员内部类：外围类.内部类 xxx = 外围类.new 内部类();
匿名内部类
在多线程的模块中代码，大量使用了匿名内部类，以下：
1 public class Outer { 2 //匿名接口 3 interface Inner{ 4 int getNumber(); 5 } 6 //使用匿名接口 7 public Inner getInner(final int num,String str){ 8 return new Inner() { 9 @Override 10 public int getNumber() { 11 System.out.println(str); 12 return num; 13 } 14 }; /* 注意：分号不能省 */ 15 } 16 //测试 17 public static void main(String[] args){ 18 Outer outer = new Outer(); 19 Inner inner = outer.getInner(4,"nihao"); 20 System.out.println(inner.getNumber()); 21 } 22 }
输出结果：
nihao 4
经过这个例子能够看出：
❤ 匿名内部类没有修饰符；
❤ 当所在方法的形参须要被匿名内部类使用时，该形参必须为final，由于：内部类在编译时会生成一个独立的.class文件，改文件并不在它的外围类中，内部类将传过来的参数经过本身的构造器备份到了本身的内部，这样本身内部方法的调用其实是本身的属性，而不是外围类方法的参数；简单理解就是：拷贝引用，为了不引用值发生改变，例如被外围类的方法修改等，而致使内部类获得的值不一致，因而用final修饰让该引用不可变；
❤ 匿名内部类没有构造方法，由于它连名字都没有；
❤ new 匿名内部类；这个类必须先存在；
局部内部类
局部内部类：是指内部类定义在方法和做用域内。
看个例子：
1 public class Outer { 2 private void internalTracking(boolean b) { 3 if (b) { 4 //局部内部类 5 class TrackingSlip { 6 private String id; 7 TrackingSlip(String s) { 8 id = s; 9 } 10 String getSlip() { 11 return id; 12 } 13 } 14 TrackingSlip ts = new TrackingSlip("slip"); 15 String s = ts.getSlip(); 16 } 17 } 18 19 public void track() { 20 //调用方法（含有局部内部类） 21 internalTracking(true); 22 System.out.println("......."); 23 } 24 25 public static void main(String[] args) { 26 Outer p = new Outer(); 27 p.track(); 28 } 29 }
局部内部类也会像其余类同样编译，只是做用域不一样而已，只有在该方法或者做用域内才能用，超出做用域或者方法就不可引用。
❤ 局部内部类没有访问修饰符；
❤ 局部内部类要访问外围类的对象或者变量，那么这个变量或者对象必须是final修饰的；
内部类的好处
❤ Java运行实现多个接口，但不容许继承多个类，使用内部类能够解决Java不容许多个继承的问题。在一个类的内部定义一个内部类，让这个内部类继承某个原有的类，而这个内部类又能够访问外围类的属性和方法，这样就至关于多个继承了；
❤ 有效的对外隐藏了本身，增长了本身的私密性；
❤ 使用内部类可让类与类之间的联系更加紧密；
❤ 有些类知道只会在某个地方使用只使用一次，为这种类建立一个外部类显然没有必要，因此这种就写个内部类用用就能够了；