public class OuterClass
   {
　　 private double d1 = 1.0;

　　 private class InnerOne
    {
　　 double methoda()
        {
        return d1;
         }
  　　}
　 }
上面的例子算是内部类的实现 ，谁能具体说说，最好举例说下内部类的实现要注意的问题

内部类分为: 成员内部类、静态嵌套类、方法内部类、匿名内部类。

(1)、内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号。
(2)、内部类不能用普通的方式访问。内部类是外部类的一个成员，因此内部类可以自由地访问外部类的成员变量，无论是否是private的。
(3)、内部类声明成静态的，就不能随便的访问外部类的成员变量，仍然是只能访问外部类的静态成员变量。

成员内部类
class Outer
{
　　class Inner{}
}


方法内部类

把类放在方法内
class Outer
{
　　public void doSomething()
       {
　　        class Inner
               {
　　                public void seeOuter()
                       {


                　　}
　　         }
　　}
}


(1)、方法内部类只能在定义该内部类的方法内实例化，不可以在此方法外对其实例化。
(2)、方法内部类对象不能使用该内部类所在方法的非final局部变量。



匿名内部类

A、继承式的匿名内部类

　　public class Car
       {
　　         public void drive()
                {
　　                    System.out.println("Driving a car!");
　　         }
　　         public static void main(String[] args)
                {
　　                  Car car = new Car(){
　　                         public void drive()
                                {
　　                                 System.out.println("Driving anther car!");
　　                         }
　　                  };
　　                  car.drive();
　　          }
　　}



B、接口式的匿名内部类。
　　interface Vehicle
       {
　　           public void drive();
　　}
　　class Test
       {
　　           public static void main(String[] args)
                  {
　　                    Vehicle v = new Vehicle(){
　　                             public void drive()
                                    {
　　                                    System.out.println("Driving a car!");
　　                             }
　　                    };
　　                    v.drive();
　　            }
　　}



C、参数式的匿名内部类

       class Bar
       {
　　        void doStuff(Foo f){}
　　}
　　interface Foo
       {
　　        void foo();
　　}
　　class Test
       {
　　        static void go()
               {
　　                Bar b = new Bar();
　　                b.doStuff(new Foo(){
　　                         public void foo()
                                {
                                 　　System.out.println("foofy");
　　                         }
　　                });
　　         }
　　}


静态嵌套类

静态内部类中可以定义静态或者非静态的成员

       class Outer
       {
　　        static class Inner{}
　　}
　　class Test
       {
　　        public static void main(String[] args)
               {
　　                  Outer.Inner n = new Outer.Inner();
　　        }
　　}

单的说，内部类就是将一个类的定义放到另一个类的定义内部。内部类分为：成员内部类、局部内部类、静态内部类、匿名内部类。



　　成员内部类：作为外部类的一个成员存在，与外部类的属性、方法并列。



　　优点：一方面，内部类作为外部类的成员，可以访问外部类的私有成员或属性。（即使声明为private，但是对于处于其内部的内部类还是可见的。）另一方面，可以内部类定义在外部类不可访问的属性。这样就在外部类中实现了比外部类private还要小的额访问权限。



　　注意：



　　内部类是一个编译时的概念，一旦编译成功，就会成为完全不同的两个类。



　　对于一个名为Outer的外部类和其内部定义的名为Inner的内部类。编译完成后出现Outer.class 和 Outer$Inner.class 两个类



　　当Outer是一个private类时，外部类对于其外部访问是私有的，所以就无法建立外部类对象，进而也无法建立内部类对象。