嵌套类与内部类在java中使用的很广泛,为了避免难以理解,这里用了几个小例子,说明它的用法。
嵌套类与内部类的结构如下图
静态嵌套类
静态嵌套类,是一种在类之外声明的嵌套类,由于是静态的,所以不经过初始化,就可以通过类名,直接调用。
1 class out1{ 2 private static String name = "xingoo"; 3 static class info{ 4 void print(){ 5 System.out.println("name:"+name); 6 } 7 } 8 }
使用样例
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
package testClass; class out1{ private static String name = "xingoo"; static class info{ void print(){ System.out.println("name:"+name); } } } class out2{ private static String name = "xingoo test 2"; static class info{ String name = "inner infomation!"; void printInner(){ System.out.println("name:"+name); } void printOuter(){ System.out.println("name:"+out2.name); } } } /** * 静态嵌套类 * @author xingoo * */ public class test1 { public static void main(String[] args){ //创建对象时,以xxx.yyy这种格式创建 out1.info oi = new out1.info(); oi.print(); out2.info oi2 = new out2.info(); oi2.printInner(); oi2.printOuter(); } }
成员内部类
成员内部类,即该类作为另一个类的成员,因此只有引用另一个类,才能创建这个类。
1 class outer{ 2 private String name = "xingoo"; 3 class inner{ 4 void print(){ 5 System.out.println(name); 6 } 7 } 8 }
通常也用于隐藏的实现某个接口,如下面所示,第一种是传统的实现方式,第二种是隐藏了实现接口的实现方式。
1 interface Printer{ 2 void print(String name); 3 } 4 class outerImpl1 implements Printer{ 5 @Override 6 public void print(String name) { 7 System.out.println(name); 8 } 9 } 10 class outerImpl2{ 11 private class inner implements Printer{ 12 @Override 13 public void print(String name) { 14 System.out.println(name); 15 } 16 } 17 public Printer getPrinter(){ 18 return new inner(); 19 } 20 }
使用样例
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
package testClass; /** * 简单测试成员内部类 * @author xingoo * */ class outer{ private String name = "xingoo"; class inner{ void print(){ System.out.println(name); } } } interface Printer{ void print(String name); } class outerImpl1 implements Printer{ @Override public void print(String name) { System.out.println(name); } } class outerImpl2{ private class inner implements Printer{ @Override public void print(String name) { System.out.println(name); } } public Printer getPrinter(){ return new inner(); } } /** * 成员内部类 * @author xingoo * */ public class test2 { public static void main(String[] args){ //创建一个外部类的对象,通过调用这个对象的new方法创建其内部类的对象 outer o = new outer(); outer.inner i = o.new inner(); i.print(); //内部类实现接口隐藏 Printer out1 = new outerImpl1(); out1.print("xingoo test1"); outerImpl1 out1trans = (outerImpl1)out1;//支持向下转换 Printer out2 = (new outerImpl2()).getPrinter(); out2.print("xingoo test2"); //无法向下转换,因为inner是private类型的,这样就实现了接口的隐藏 } }
局部内部类
局部类的声明之作用与某个代码块内,因此如果某个声明的类仅仅被一段程序所使用,其他地方再也用不到,就可以用这种实现方式。·
1 interface Logger{ 2 public void log(String message); 3 } 4 public class test3 { 5 6 String startTime = (new Date()).toString(); 7 /** 8 * 局部内部类,从定义上来讲,不属于任何其他的类,因为是声明在这个类内部的。与匿名内部类不同的就是它有名字。 9 * @return 10 */ 11 public Logger getLogger(){ 12 //由于LoggerImpl只在 getLogger内部使用,因此把它定义在函数内部,相对来说更安全一些 13 class LoggerImpl implements Logger{ 14 @Override 15 public void log(String message) { 16 System.out.println(startTime + ":" + message); 17 } 18 } 19 return new LoggerImpl(); 20 } 21 22 public static void main(String[] args){ 23 test3 test = new test3(); 24 Logger logger = test.getLogger(); 25 logger.log("hello xingoo!"); 26 } 27 }
匿名内部类
在使用new创建对象时,直接在后面创建它的实现类。
1 abstract class Printable{ 2 public void print(String name){ 3 4 } 5 } 6 /** 7 * 就是跟在new创建对象之后,直接定义它的类实现 8 * @author Administrator 9 */ 10 public class test4 { 11 public static void main(String[] args){ 12 Printable printer = new Printable(){ 13 public void print(String name){ 14 System.out.println(name); 15 } 16 };//注意因为这其实是一个new语法,因此要加上分号; 17 printer.print("hello!xingoo!"); 18 } 19 }
参考资料:《JAVA 7程序设计》