9）Java内部类（Inner Class）

内部类：不可以有静态数据，静态方法或者又一个静态内部类

内部类的优点：隐藏类的细节，内部类可以声明为私有。内部类可以访问外部类的对象（包括private）

静态内部类：可以有静态数据，静态方法或者又一个静态内部类

局部内部类：定义在一个方法或者一个代码块中的类，作用域为相应代码块

匿名内部类：该类没有名字，一般直接写为（new 接口（..））并返回一个实现了某接口的对象。

 

为什么需要内部类？
     典型的情况是，内部类继承自某个类或实现某个接口，内部类的代码操作创建其的外围类的对象。所以你可以认为内部类提供了某种进入其外围类的窗口。

使用内部类最吸引人的原因是：
     每个内部类都能独立地继承自一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。如果没有内部类提供的可以继承多个具体的或抽象的类的能力，一些设计与编程问题就很难解决。从这个角度看，内部类使得多重继承的解决方案变得完整。接口解决了部分问题，而内部类有效地实现了“多重继承”。

[java] view plaincopy

  1. public interface Contents {
  2. int value();
  3. }
  4. public interface Destination {
  5. String readLabel();
  6. }
  7. public class Goods {
  8. private class Content implements Contents {
  9. private int i = 11;
  10. public int value() {
  11. return i;
  12. }
  13. }
  14. protected class GDestination implements Destination {
  15. private String label;
  16. private GDestination(String whereTo) {
  17. label = whereTo;
  18. }
  19. public String readLabel() {
  20. return label;
  21. }
  22. }
  23. public Destination dest(String s) {
  24. return new GDestination(s);
  25. }
  26. public Contents cont() {
  27. return new Content();
  28. }
  29. }
  30. class TestGoods {
  31. public static void main(String[] args) {
  32. Goods p = new Goods();
  33. Contents c = p.cont();
  34. Destination d = p.dest("Beijing");
  35. }
  36. }

在这个例子里类Content和GDestination被定义在了类Goods内部，并且分别有着protected和private修饰符来控制访问级别。Content代表着Goods的内容，而GDestination代表着Goods的目的地。它们分别实现了两个接口Content和Destination。在后面的main方法里，直接用 Contents c和Destination d进行操作，你甚至连这两个内部类的名字都没有看见！这样，内部类的第一个好处就体现出来了 隐藏你不想让别人知道的操作，也即封装性。

同时，我们也发现了在外部类作用范围之外得到内部类对象的第一个方法，那就是利用其外部类的方法创建并返回。上例中的cont()和dest()方法就是这么做的。那么还有没有别的方法呢？当然有，其语法格式如下：

outerObject=new outerClass(Constructor Parameters);

outerClass.innerClass innerObject=outerObject.new InnerClass(Constructor Parameters);

注意在创建非静态内部类对象时，一定要先创建起相应的外部类对象。至于原因，也就引出了我们下一个话题 非静态内部类对象有着指向其外部类对象的引用，对刚才的例子稍作修改：

[java] view plaincopy

  1. public class Goods {
  2. private int valueRate = 2;
  3. private class Content implements Contents {
  4. private int i = 11 * valueRate;
  5. public int value() {
  6. return i;
  7. }
  8. }
  9. protected class GDestination implements Destination {
  10. private String label;
  11. private GDestination(String whereTo) {
  12. label = whereTo;
  13. }
  14. public String readLabel() {
  15. return label;
  16. }
  17. }
  18. public Destination dest(String s) {
  19. return new GDestination(s);
  20. }
  21. public Contents cont() {
  22. return new Content();
  23. }
  24. }

在这里我们给Goods类增加了一个private成员变量valueRate，意义是货物的价值系数，在内部类Content的方法value()计算价值时把它乘上。我们发现，value()可以访问valueRate，这也是内部类的第二个好处 一个内部类对象可以访问创建它的外部类对象的内容，甚至包括私有变量！这是一个非常有用的特性，为我们在设计时提供了更多的思路和捷径。要想实现这个功能，内部类对象就必须有指向外部类对象的引用。Java编译器在创建内部类对象时，隐式的把其外部类对象的引用也传了进去并一直保存着。这样就使得内部类对象始终可以访问其外部类对象，同时这也是为什么在外部类作用范围之外向要创建内部类对象必须先创建其外部类对象的原因。

有人会问，如果内部类里的一个成员变量与外部类的一个成员变量同名，也即外部类的同名成员变量被屏蔽了，怎么办？没事，Java里用如下格式表达外部类的引用：

outerClass.this

有了它，我们就不怕这种屏蔽的情况了。

静态内部类

和普通的类一样，内部类也可以有静态的。不过和非静态内部类相比，区别就在于静态内部类没有了指向外部的引用。这实际上和C++中的嵌套类很相像了，Java内部类与C++嵌套类最大的不同就在于是否有指向外部的引用这一点上，当然从设计的角度以及以它一些细节来讲还有区别。

除此之外，在任何非静态内部类中，都不能有静态数据，静态方法或者又一个静态内部类（内部类的嵌套可以不止一层）。不过静态内部类中却可以拥有这一切。这也算是两者的第二个区别吧。

局部内部类

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

[java] view plaincopy

  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中我们定义了一个内部类，最后由这个方法返回这个内部类的对象。如果我们在用一个内部类的时候仅需要创建它的一个对象并创给外部，就可以这样做。当然，定义在方法中的内部类可以使设计多样化，用途绝不仅仅在这一点。

下面有一个更怪的例子：

[java] view plaincopy

  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和其他类一样同时被编译，只不过它由它自己的作用域，超出了这个范围就无效，除此之外它和其他内部类并没有区别。

匿名内部类

匿名类是不能有名称的类，所以没办法引用它们。必须在创建时，作为new语句的一部分来声明它们。这就要采用另一种形式的new语句，如下所示： new <类或接口> <类的主体> 这种形式的new语句声明一个新的匿名类，它对一个给定的类进行扩展，或者实现一个给定的接口。它还创建那个类的一个新实例，并把它作为语句的结果而返回。

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

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

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

[java] view plaincopy

  1. public class Goods3 {
  2. public Contents cont() {
  3. return new Contents() {  //Contents是接口
  4. private int i = 11;
  5. public int value() {
  6. return i;
  7. }
  8. };
  9. }
  10. }

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

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

[java] view plaincopy

  1. frame.addWindowListener(new WindowAdapter(){
  2. public void windowClosing(WindowEvent e){
  3. System.exit(0);
  4. }
  5. });

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

时间： 2024-11-05 11:31:28

9）Java内部类（Inner Class）的相关文章

Java内部类

本文是<Java核心技术 卷1>中第六章接口与内部类中关于内部类的阅读总结. Java中的内部类(inner class)是定义在另一个类内部的类.那么内部类有什么用呢?这里主要由三个内部类存在的原因: 内部类方法可以访问该类定义所在的作用域中的数据,包括私有的数据.即,如果类A中定义了类B,那么类B可以访问类A中的数据,甚至是私有数据,但类A不能访问类B中的私有数据: 内部类可以对同一个包中的其他类隐藏起来.在一个包中,定义一个类时,即使不加上访问权限关键词,这个类也是包内其他类可访问的,不

Java内部类：局部内部类（三）

Java内部类分为4个部分进行阐述,分别为概览.成员内部类.局部内部类和匿名内部类. 在本文中是Java内部类的局部内部类,主要讲局部内部类的概念和在使用局部内部的过程中,需要注意的一个细节. 1.局部内部类的概念 在一个类的方法内部定义另外一个类,那么另外一个类就称作为局部内部类. class OutterClass { void test() { class InnerClass//局部内部类 { } } } 在上述代码中,InnerClass定义在OutterClass的test方法的内部

Java内部类：匿名内部类（四）

Java内部类分为4个部分进行阐述,分别为概览.成员内部类.局部内部类和匿名内部类. 在本文中是Java内部类的匿名内部类,主要讲述匿名内部类的概念.匿名内部类的好处.匿名内部类的使用前提.和匿名内部类的应用场景. 1.匿名内部类的概念 没有类名的类就称作为匿名内部类 2.匿名内部类的好处 简化书写 3.匿名内部类的使用前提 必须存在继承或者实现关系才能使用 4.匿名内部类的应用场景 匿名内部类一般是用于实参 示例代码: package com.rk.innerclass; public cla

Java内部类小程序（成员内部类，静态内部类，匿名内部类）

1 /** 2 * 测试java内部类(成员内部类,静态内部类,匿名内部类) 3 * 局部内部类不常用,就不写了. 4 * @package :java05 5 * @author shaobn 6 * @Describe : 7 * @Time: 2015-9-6 下午8:32:38 8 */ 9 public class TestInner { 10 11 /** 12 * @author shaobn 13 * @Describe : 14 * @param args 15 * @Time

Java内部类的使用小结

内部类是指在一个外部类的内部再定义一个类.类名不需要和文件夹相同. *内部类可以是静态static的,也可用public,default,protected和private修饰.(而外部顶级类即类名和文件名相同的只能使用public和default). 注意:内部类是一个编译时的概念,一旦编译成功,就会成为完全不同的两类.对于一个名为outer的外部类和其内部定义的名为inner的内部类.编译完成后出现outer.class和outer$inner.class两类.所以内部类的成员变量/方法名可

java内部类和匿名内部类

内部类即是包含在类里面的又一个类. java内部类分为: 成员内部类.静态嵌套类.方法内部类.匿名内部类 . 内部类的共性 (1).内部类仍然是一个独立的类,在编译之后内部类会被编译成独立的.class文件,但是前面冠以外部类的类名和$符号 . (2).内部类不能用普通的方式访问.内部类是外部类的一个成员,因此内部类可以自由地访问外部类的成员变量,无论是否是private的 . (3).内部类声明成静态的,就不能随便的访问外部类的成员变量了,此时内部类只能访问外部类的静态成员变量 . 成员内部类

Java内部类的继承

Java内部类的构造器必须连接到指向其外围类对象的引用(构造内部类必须给它一个外部类对象的引用,内部类依赖于外部类对象),所以在继承内部类的时候,需要在导出类的构造器中手动加入对基类构造器的调用. 因为,在导出类实例化时,并不存在一个外围类对象,以让导出类的实例去连接到它. 所以,我们需要创建一个外围类,然后用一个特定的语法来表明内部类与外围类的关系. 在下例子中,需要给导出类InheritInner一个来自内部类的外围类中的引用.普通的继承,只需在导出类构造器中加入super();,而内部类则

【转】Java 内部类种类及使用解析

Java 内部类种类及使用解析 内部类Inner Class 将相关的类组织在一起,从而降低了命名空间的混乱. 一个内部类可以定义在另一个类里,可以定义在函数里,甚至可以作为一个表达式的一部分. Java中的内部类共分为四种: 静态内部类static inner class (also called nested class) 成员内部类member inner class 局部内部类local inner class 匿名内部类anonymous inner class 静态内部类Static

Java内部类学习总结

目录 目录 概述 非静态内部类 从外部类的非静态方法中实例化内部类 从外部类的静态方法中实例化内部类 内部类的this引用 静态内部类 从外部类的非静态方法中实例化静态内部类 从外部类静态方法中实例化静态内部类 匿名内部类 方法内部类 概述 最近学习python,发现python是支持多继承的,这让我想起Java是通过内部类实现的这套机制.这篇文章不是讲如何通过内部类实现多继承,而是总结一下内部类的类型和使用方法. Java内部类分为: 非静态内部类 静态内部类 局部内部类 匿名内部类 内部类在

[转] Java内部类详解

作者:海子 出处:http://www.cnblogs.com/dolphin0520/ 本博客中未标明转载的文章归作者海子和博客园共有,欢迎转载,但未经作者同意必须保留此段声明,且在文章页面明显位置给出原文连接,否则保留追究法律责任的权利. Java内部类详解 说起内部类这个词,想必很多人都不陌生,但是又会觉得不熟悉.原因是平时编写代码时可能用到的场景不多,用得最多的是在有事件监听的情况下,并且即使用到也很少去总结内部类的用法.今天我们就来一探究竟.下面是本文的目录大纲: 一.内部类基础 二.