java内部类

破壳成龙

定义：在一个类中插入另一个类，这个类就是内部类。
一。静态成员类
   类声明中包含static关键字的内部类
public class
Outer{
    public static class Inner1
{
       public Inner1() {
          staticMethod();
       }
    }
   static class Inner2
{
   }
   private static
class Inner3
{
      public static class Inner4 {
      }
   }
   private static void staticMethod() {}
}
。静态成员类可以访问外部类的任意静态字段或静态方法。
。静态成员类不能与外部类重名，向外部类的静态方法一样不能访问，不能直接访问外部类的非静态方法和成员
。静态成员类只能定义于外部类的顶层代码中或者是外部类其他静态成员类的顶层代码中，不能定义在外部类的某个函数中
。可以用OuterClass.InnerClass的方式来引用某个内部类
二。成员类
  上面的内部类去掉static就是成员类
  一个成员类实例必然所属一个外部类实例， 成员类可访问外部类的任一个实例字段和实例函数
。成员类不能与外部类重名
。 不能在成员类中定义static字段、方法和类（static
final形式的常量定义除外）。因为一个成员类 实例  必然与一个外部类实例关联，这个static定义完全可以移到其外部类中去
。成员类不能是接口（interface）。因为成员类必须能被某个外部类实例实例化，而接口是不能实例化的。
。一个成员类实例必然所属于其外部类的一个实例，那么如何在成员类内部获得其所属外部类实例呢？如示例代码所示，采用“OuterClass.this”的形式
。
内部类实例可在其外部类的实例方法中创建，此新创建内部类实例所属的外
部类实例自然就是创建它的外部类实例方法对应的外部类实例。
另外，如示例代码所示，对于给定的一个外部类实例outerClass，可以直接创建其内部类实例，语法形式为：
OuterClass.InnerClass innerClass = outerClass.new InnerClass();。员类的显著特性就是成员类能访问它的外部类实例的任意字段与方法。方便一个类对外提供一个公共接口的实现是成员类的典型应用
例子：
1.可以访问其外部类用private修饰的变量或是方法
    例子：
    class Outer
   {
     [color="#993300"]private String
str="kingtoon";
      class Inner
      {
        void
printInner()
       {
         System.out.println(str);
      
}
      }
    Inner getInner()
    {
       return new
Inner();
    }
}
class InnerClassTest
{
public static void
main(String []args)
{
   Outer outer=new Outer();
   Outer.Inner
inner=outer.getInner();
   inner.printInner();
}
}
2.this关键字
   
“当我们建立一个inner class时，其对象就拥有了与外部类对象之间的一种关系，这是通过一个特殊的this
reference形成的，使得内部类对象可以随意的访问外部类中所有的成员”(包括private变量和方法)。
例子：
class Outer
{
private String str="kingtoon";
class Inner
{
   
String str="hjd";
   void printInner()
   {
    String
str="kingtoon_hjd";
   System.out.println(str);
   
System.out.println(this.str);
   
System.out.println(Outer.this.str);
   }
}
Inner
getInner()
{
   return new Inner();
}
}
class
InnerClassTest
{
public static void main(String []args)
{
   Outer
outer=new Outer();
   Outer.Inner inner=outer.getInner();
   
inner.printInner();
}
}
   3.外部类访问内部类成员变量或其函数的两种方法
      第一种：
     class Outer
    {
      private String str="kingtoon";
      
class Inner
     {
        void printInner()
        {
         
System.out.println(str);
       }
   }
}
class
InnerClassTest
{
public static void main(String []args)
{
   Outer
outer=new Outer();
  Outer.Inner inner= outer.new
Inner();
   inner.printInner();
}
}
    第二种
class Outer
{
private String str="kingtoon";
class Inner
{
   
void printInner()
   {
    System.out.println(str);
   
}
}
Inner getInner()
{
   return new
Inner();
}
}
class InnerClassTest
{
public static void
main(String []args)
{
   Outer outer=new Outer();
  [color="#993300"]Outer.Inner inner=outer.getInner();
   
inner.printInner();
}
}
三。局部类
对一个静态成员类，去掉其声明中的“static”关键字，将其定义移入其外部类
的静态方法或静态初始化代码段中就成为了局部静态成员类。
    对一个成员类，将其定义移入其外部类的实例方法或实例初始化代码中就成为了局部成员类。
局部静态成员类与静态成员类的基本特性相同。例如，都只能访问外部类的静态字段或方法，但不能访问外部  类的实例字段和实例方法等。
。局部静态成员类与静态成员类的基本特性相同。例如，都只能访问外部类的静态字段或方法，但不能访问外部类的实例字段和实例方法等。
局部成员类与成员类的基本特性相同。例如，局部成员类实例必属于其外部类的一个实例，可通过OuterClass.this引用其外部类实例。。在外部类的某方法内部定义内部类，内部类的某方法里只能访问外部类方法里由final声明的变量或参数。例子：
class Outer
{
     void printOuter(final int
n)
     {
     final String
str="kingtoon";
      class Inner
      {
       void
printInner()
       {
        System.out.println(str);
        
System.out.println(n);
       }
      }
     }
}
其实，使用内部类，主要和接口同时使用，可以让java实现多继承。
例如：
interface A
{
void printA();
}
class B
{
void
printB()
{
   System.out.println("b");
}
}
class C extends
B
{
A getA()
{
   return new A()
   {
    public void
printA()
    {
     System.out.println("a");
    }
   
};
}
}
class Interface_extends_inner
{
static void fn1(A
a)
{
     System.out.println("A");
}
static void fn2(B
b)
{
   System.out.println("B");
}
public static void main(String
[]args)
{
  
   C c=new C();
   A a=c.getA();
   
a.printA();
   c.printB();
   fn1(a);//fn1(c.getA());  
   fn2(new B());
}
}
6.内部类可以解决方法同名的情况
例如：
interface Machine
{
void [color="#993300"]run();
}
class Person
{
void [color="#339966"]run()
{
   
System.out.println("现在，我可以跑了");
}
}
class Robot extends
Person
{
private class MachineHeart implements Machine
{
   public
void [color="#993300"]run()
   {
   
System.out.println("机器引擎启动了");
   }
}
MachineHeart
getMachinHeart()
{
   return new MachineHeart();
}
}
class
Fangfatongming_inner
{
public static void main(String [] args)
{
   
Robot robot=new Robot();
   Machine machine=robot.getMachinHeart();
   
machine.[color="#993300"]run();
   robot.[color="#008080"]run();
}
}
四。匿名类
没有类名的局部类就叫做匿名类
  
               
               
               

本文来自ChinaUnix博客，如果查看原文请点：http://blog.chinaunix.net/u2/76927/showart_1168137.html