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

嵌套类与内部类在java中使用的很广泛，为了避免难以理解，这里用了几个小例子，说明它的用法。

　　嵌套类与内部类的结构如下图

　　静态嵌套类　　

　　静态嵌套类，是一种在类之外声明的嵌套类，由于是静态的，所以不经过初始化，就可以通过类名，直接调用。

 class out1{
     private static String name = "xingoo";
     static class info{
         void print(){
             System.out.println("name："+name);
         }
     }
 }

　　使用样例

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

　　成员内部类

　　成员内部类，即该类作为另一个类的成员，因此只有引用另一个类，才能创建这个类。

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

　　使用样例

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

　　局部内部类

　　局部类的声明之作用与某个代码块内，因此如果某个声明的类仅仅被一段程序所使用，其他地方再也用不到，就可以用这种实现方式。·

 interface Logger{
     public void log(String message);
 }
 public class test3 {

     String startTime = (new Date()).toString();
     /**
      * 局部内部类，从定义上来讲，不属于任何其他的类，因为是声明在这个类内部的。与匿名内部类不同的就是它有名字。
      * @return
      */
     public Logger getLogger(){
         //由于LoggerImpl只在 getLogger内部使用，因此把它定义在函数内部，相对来说更安全一些
         class LoggerImpl implements Logger{
             @Override
             public void log(String message) {
                 System.out.println(startTime + ":" + message);
             }
         }
         return new LoggerImpl();
     }

     public static void main(String[] args){
         test3 test = new test3();
         Logger logger = test.getLogger();
         logger.log("hello xingoo!");
     }
 }

　　匿名内部类

　　在使用new创建对象时，直接在后面创建它的实现类。

 abstract class Printable{
     public void print(String name){

     }
 }
 /**
  * 就是跟在new创建对象之后，直接定义它的类实现
  * @author Administrator
  */
 public class test4 {
     public static void main(String[] args){
         Printable printer = new Printable(){
             public void print(String name){
                 System.out.println(name);
             }
         };//注意因为这其实是一个new语法，因此要加上分号;
         printer.print("hello!xingoo!");
     }
 }

参考资料：《JAVA 7程序设计》