【java开发系列】—— 嵌套类与内部类

 

嵌套类与内部类在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 }

　　使用样例

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(); } }

View Code

　　成员内部类

　　成员内部类，即该类做为另外一个类的成员，所以只有引用另外一个类，才能建立这个类。

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 }

　　使用样例

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类型的，这样就实现了接口的隐藏
 } }

View Code

　　局部内部类

　　局部类的声明之做用与某个代码块内，所以若是某个声明的类仅仅被一段程序所使用，其余地方再也用不到，就能够用这种实现方式。·

 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程序设计》