java内部类的作用分析

java内部类的作用分析

 

1.       在创建非静态内部类对象时，一定要先创建起相应的外部类对象，因为内部类对象必须有指向外部类对象的引用，这样内部类才能使用外部类的成员甚至是私有成员。

a)      怎样获得内部类？

                 i.          class Outer{

public class Inner{

….

}

 

public Inner getInner(){

       return new Inner();

}

                     }

                     另一种方法:

                     Outer outer=new Outer();

                     Outer.Inner inner=outer.new Inner();

2.       静态内部类：

和非静态内部类相比，区别就在于静态内部类没有了指向外部类的引用，因此可以直接创建静态内部类而不用先创建外部类对象。

              注意：

a)    在非静态内部类中不可以声明静态成员

b)    因为创建静态类不用先创建外部类对象，因此静态类不能使用外部类的非静态成员和变量。

 

其他：（没总结，直接截下来的）

局部内部类

是的，Java内部类也可以是局部的，它可以定义在一个方法甚至一个代码块之内。

 

1.  public class Goods1 {  

2.      public Destination dest(String s) {  

3.          class GDestination implements Destination {  

4.              private String label;  

5.              private GDestination(String whereTo) {  

6.                  label = whereTo;  

7.              }  

8.              public String readLabel() {  

9.                  return label;  

10.             }  

11.         }  

12.         return new GDestination(s);  

13.     }  

14.     public static void main(String[] args) {  

15.         Goods1 g = new Goods1();  

16.         Destination d = g.dest("Beijing");  

17.     }  

18. }  

上面就是这样一个例子。在方法dest中我们定义了一个内部类，最后由这个方法返回这个内部类的对象。如果我们在用一个内部类的时候仅需要创建它的一个对象并创给外部，就可以这样做。当然，定义在方法中的内部类可以使设计多样化，用途绝不仅仅在这一点。

下面有一个更怪的例子：

1.  public class Goods2 {  

2.      private void internalTracking(boolean b) {  

3.          if (b) {  

4.              class TrackingSlip {  

5.                  private String id;  

6.                  TrackingSlip(String s) {  

7.                      id = s;  

8.                  }  

9.                  String getSlip() {  

10.                     return id;  

11.                 }  

12.             }  

13.             TrackingSlip ts = new TrackingSlip("slip");  

14.             String s = ts.getSlip();  

15.         }  

16.     }  

17.     public void track() {  

18.         internalTracking(true);  

19.     }  

20.     public static void main(String[] args) {  

21.         Goods2 g = new Goods2();  

22.         g.track();  

23.     }  

24. }  

你不能在if之外创建这个内部类的对象，因为这已经超出了它的作用域。不过在编译的时候，内部类TrackingSlip和其他类一样同时被编译，只不过它由它自己的作用域，超出了这个范围就无效，除此之外它和其他内部类并没有区别。

匿名内部类

java的匿名内部类的语法规则看上去有些古怪，不过如同匿名数组一样，当你只需要创建一个类的对象而且用不上它的名字时，使用内部类可以使代码看上去简洁清楚。它的语法规则是这样的：

new interfacename(){......};或 new superclassname(){......};

下面接着前面继续举例子：

1.  public class Goods3 {  

2.      public Contents cont() {  

3.          return new Contents() {  

4.              private int i = 11;  

5.              public int value() {  

6.                  return i;  

7.              }  

8.          };  

9.      }  

10. }  

这里方法cont()使用匿名内部类直接返回了一个实现了接口Contents的类的对象，看上去的确十分简洁。

在java的事件处理的匿名适配器中，匿名内部类被大量的使用。例如在想关闭窗口时加上这样一句代码：

1.  frame.addWindowListener(new WindowAdapter(){  

2.      public void windowClosing(WindowEvent e){  

3.         System.exit(0);  

4.      }  

5.  });   

有一点需要注意的是，匿名内部类由于没有名字，所以它没有构造函数（但是如果这个匿名内部类继承了一个只含有带参数构造函数的父类，创建它的时候必须带上这些参数，并在实现的过程中使用super关键字调用相应的内容）。如果你想要初始化它的成员变量，有下面几种方法：

如果是在一个方法的匿名内部类，可以利用这个方法传进你想要的参数，不过记住，这些参数必须被声明为final。

将匿名内部类改造成有名字的局部内部类，这样它就可以拥有构造函数了。

在这个匿名内部类中使用初始化代码块。

为什么需要内部类？

java内部类有什么好处？为什么需要内部类？

首先举一个简单的例子，如果你想实现一个接口，但是这个接口中的一个方法和你构想的这个类中的一个方法的名称，参数相同，你应该怎么办？这时候，你可以建一个内部类实现这个接口。由于内部类对外部类的所有内容都是可访问的，所以这样做可以完成所有你直接实现这个接口的功能。

不过你可能要质疑，更改一下方法的不就行了吗？

的确，以此作为设计内部类的理由，实在没有说服力。

真正的原因是这样的，java中的内部类和接口加在一起，可以的解决常被C++程序员抱怨java中存在的一个问题没有多继承。实际上，C++的多继承设计起来很复杂，而java通过内部类加上接口，可以很好的实现多继承的效果。