黑马程序员技术交流社区

标题: 内部类的实现疑问 [打印本页]

作者: 化小东 时间: 2012-12-11 23:23
标题: 内部类的实现疑问
public class OuterClass
{
　　 private double d1 = 1.0;

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

作者: xjandrew 时间: 2012-12-16 10:13
内部类分为: 成员内部类、静态嵌套类、方法内部类、匿名内部类。

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

作者: 孙辉辉 时间: 2012-12-16 17:05
单的说，内部类就是将一个类的定义放到另一个类的定义内部。内部类分为：成员内部类、局部内部类、静态内部类、匿名内部类。

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

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

　　注意：

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

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

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

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2