java内部类

一.java内部类：将一个类的定义放在另一个类的定义内部(你可以把逻辑相关的类组织在一起，看起来像是一                         个代码隐藏的机制，就像对一个类中的方法用private等修饰符修饰一样)。

                         

public class Outer{
  private int i=0;
  class Inner{
     public void info(){System.out.println("inner class:"+(++i));}
   }
   public Inner inner(){
      return new Inner();
   }
}

 

 

 

JDK中的迭代器设计模式就采用了内部类的方式。

 

    1.内部类生成对外围类对象的引用：使用外围类名.this的语法来实现

          

public class Outer{
   private int i=0;
   public class Inner{
      public void info(){
         System.out.println("inner class:"+(i++));
      }
   }
   public int add(){return i++;}
   public Outer outer(){
     return Outer.this;
   }
}
  public class Test{
      public void mian(String[] arr){
     Outer o=new Outer();
      o.add();
     o=o.outer();
     System.out.println(o.add());
}
  }

 

 

    2.客户端直接创建内部类：使用.new语法来实现

         

public class Test{
   public void mian(String[] arr){
     Outer o=new Outer();
     Outer.Inner inner=o.new Inner();
     inner.info();
   }
}

 

 

     2.1.可以看出，内部类(除嵌套类)有着访问其外围类的所有成员，方法的访问权。就像上例一样。关于如              何做到的？

当外围类对象创建了一个内部类对象后，此时内部类会秘密捕获一个指向该外围类对象的引用，而这工 作是由编译器来完成的。

关于内部类需要注要的是：在拥有外部类对象之前是不可能创建内部类对象的，否则内部类对象无法拥有指向该外围类对象的引用。当从一个外围类对象衍生出来多个内部类对象时，该外围类对象的资源是被共享的

 

 

    3.内部类与向上转型

当内部类向上转型为基类或接口时，内部类的好处就显而易见了

    

interface Intor{
boolean hasnext();
Object next();
  }
  public class Sequence{
       private Object[] objs;
       private int temp;
       public Sequence(int size){
          objs=new Object[size];
       }
      private class SequenceIntor implements Intor{
        public boolean hasnext(){
          if(temp<=objs.length){
             return true;
          }
          return false;
       }
       public Object next(){
         return obj[temp++];
       }
     }
  }

 

上例是一个简单的迭代器，可以看出此时内部类实现了某个接口，且使用private来修饰，能够很方便的隐藏实现细节。可以完成阻止依赖具体类型的编码。

使用的场景：想创建一个类来辅助你的解决方案，但是有不希望这个类时公共可用的。

 

 

    4.在方法和作用域内的内部类：为了更细粒度访问的内部类，我们可以将类的定义放到方法中或作用域中

 

     4.1.匿名内部类

           

 interface Inner {void info();}
 
 public class Outer{
   private int i=0;
   public int add(){return i++;}
   public Inner inner(){
        return new Inner(){
           public void info(){
              System.out.println("inner class:"+(i++));
           }
        };
    }
  }
  public class Test{
     public void mian(String[] arr){
        Outer o=new Outer();
       o.add();
       Inner e=o.inner();
        e.info();
     }
  }

 

 

  4.2.嵌套类：可将内部类声明为static，这就会使创建的嵌套类的对象，并不需要其外围类的对象；

          注意：不能从嵌套类的对象中访问非静态的外围类对象；                      

                    普通内部类不能有static域，也不能包含嵌套类，嵌套类都可以

 

        

public class Outer{
   private static int i=0;
   public static class Inner{
     public void info(){System.out.println("inner class:"+(i++));}
   }
   public int add(){return i++;}
   public static Inner inner(){
      return new Inner();
    }
}
public class Test{
   public void mian(String[] arr){
     Outer.Inner inner=Outer.inner();
     inner.info();
   }
}

 

此时需要选取static的方法来创建对象和返回内部类的引用。

 

 

     4.3.嵌套类的接口内部类：将内部类定义置于接口定义中，该类会自动变为嵌套类

        

interface Outer{
  class Inner implements Outer{
     private int i=0;
     public void info(){System.out.println("inner class:"+(i++));}
     public int add(){return i++;}
  }
  public int add();
}

public class Test implements Outer{
     public int add(){
       new Inner().info();
       return 0;
    }
}

 

     使用场景：想要创建某些公共代码，使得它们可以被某个接口的所有不同实现所共用。

 

   二.关于为什么需要内部类：

1.为java增加这项基本的语言特性的原因何在？

    1.1.一个显而易见的原因无非是组织代码，并隐藏。在内部类向上转型中，我们明显的感受到。但如                   果仅仅是这样的话(需要一个对接口的引用)。

     1.2. 为什么不通过外围类实现该接口？

                 a).这最大的区别是这种方式不是总能享用到接口带来的方便，假如一个类实现了多个接口，这样                        当我们对一个 对象需要使用不同的面向接口功能时，往往需要强制转换类型。

                b).另一个重要的能力是我们可以变相的实现多继承语法，多个内部类继承不同的类，有共享同一                       个外围类对象资源，这就达到了多重继承的效果

 

 

   文章参考thinking in java