黑马程序员技术交流社区

标题: java内部类 [打印本页]

作者: 影响力147753321    时间: 2013-5-26 09:37
标题: java内部类
是怎么理解的。要详细点的
作者: 王林涛    时间: 2013-5-26 10:04
内部类分为: 成员内部类、静态嵌套类、方法内部类、匿名内部类。
(1)、内部类仍然是一个独立的类,在编译之后内部类会被编译成独立的.class文件,但是前面冠以外部类的类名和$符号。
(2)、内部类不能用普通的方式访问。内部类是外部类的一个成员,因此内部类可以自由地访问外部类的成员变量,无论是否是private的。
(3)、内部类声明成静态的,就不能随便的访问外部类的成员变量了,此时内部类只能访问外部类的静态成员变量。

成员内部类: 举例
class Outer {
class Inner{}
}
编译上述代码会产生两个文件:Outer.class和Outer$Inner.class。

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

匿名内部类:

匿名内部类就是没有名字的内部类。什么情况下需要使用匿名内部类?如果满足下面的一些条件,使用匿名内部类是比较合适的:
·只用到类的一个实例。
·类在定义后马上用到。
·类非常小(SUN公司推荐是在4行代码以下)
·给类命名并不会导致你的代码更容易被理解。
在使用匿名内部类时,要记住以下几个原则:
·匿名内部类不能有构造方法。
·匿名内部类不能定义任何静态成员、静态方法。
·匿名内部类不能是public,protected,private,static。
·只能创建匿名内部类的一个实例。
·一个匿名内部类一定是在new的后面,用其隐含实现一个接口或实现一个类。
·因匿名内部类为局部内部类,所以局部内部类的所有限制都对其生效
作者: student    时间: 2013-5-26 10:33

1. 定义:将一个类定义在另一个类的内部,在内部的类就成为内部类(内置类、嵌套类)。一个类的内部可以定义多个内部类,内部类的例子如下:

  1. class Outer {
  2.         //内部类
  3.         class Inner {}
  4. }
复制代码

2.  内部类和外部类之间的访问规则
(1)内部类可以访问外部类的成员,包括外部类的private成员。
(2) 外部类要访问内部类,必须建立内部类对象。

3.  创建内部类语法格式
格式:外部类名.内部类名 变量名=外部类对象.内部类对象,例子如下:

  1. class Outer {
  2.         //内部类
  3.         class Inner { }
  4. }

  5. public class InnerClass {
  6.         public static void main(String[] args) {

  7.                 //创建内部类对象
  8.                 Outer.Inner in = new Outer().new Inner();
  9.         }
  10. }
复制代码
4. 内部类访问外部类的同名成员变量
如果内部类和外部类有同名成员变量,在内部类中如何访问外部类的成员变量呢?例子如下:
之所以内部类可以访问外部类的成员,是因为内部类持有外部类的引用(引用格式为:外部类名.this)。
  1. class Outer {
  2.         private int num = 8;//外部类成员变量

  3.         //内部类
  4.         class Inner {
  5.                 private int num = 5;//内部类成员变量

  6.                 public void function() {
  7.                         //内部类中访问外部类成员变量
  8.                         System.out.println(Outer.this.num);
  9.                 }
  10.         }
  11. }

  12. public class InnerClass {
  13.         public static void main(String[] args) {

  14.                 //创建内部类对象
  15.                 Outer.Inner in = new Outer().new Inner();
  16.                 in.function();// 输出结果:8
  17.         }
  18. }
复制代码

5. 静态内部类

类名前有static关键字的内部类就是静态内部类,

当内部类定义成static时,只能访问外部类中断静态成员。如何直接访问静态内部类的非静态成员呢?例子如下:

  1. class Outer {
  2.         //静态内部类
  3.         static class Inner {
  4.                 public void function() {
  5.                         System.out.println("Inner Class");
  6.                 }
  7.         }
  8. }

  9. public class InnerClass {
  10.         public static void main(String[] args) {

  11.                 //访问内部类的非静态成员方法
  12.                 new Outer.Inner().function();
  13.         }
  14. }
复制代码

如何访问内部类发静态成员呢?例子如下:

  1. class Outer {
  2.         //静态内部类
  3.         static class Inner {
  4.                 //内部类的静态成员方法
  5.                 public static void function() {
  6.                         System.out.println("Inner Class");
  7.                 }
  8.         }
  9. }

  10. public class InnerClass {
  11.         public static void main(String[] args) {

  12.                 //访问静态内部类的静态成员方法
  13.                 Outer.Inner.function();
  14.         }
  15. }
复制代码
注意:当内部类出现静态成员时,该内部类必须是静态的,否则编译出错。

6. 匿名内部类
匿名内部类:没有名字的内部类。匿名内部类其实就是内部类的简写格式。


定义匿名内部类前提:内部类必须继承一个类或是实现接口。
下面通过非匿名内部类匿名内部类的对比,讲解如何创建匿名内部类对象。

非匿名内部类例子:

  1. abstract class AbsClass {
  2.         public abstract void show();
  3. }

  4. class Outer {
  5.         class Inner extends AbsClass {
  6.                 public void show() {
  7.                         System.out.println("Inner show()");
  8.                 }
  9.         }
  10. }
复制代码

匿名内部类例子:将上面的非匿名内部类,改写为匿名内部类,格式为:
new 父类或接口() { 定义子类的内容 },例子如下:

  1. //抽象类
  2. abstract class AbsClass {
  3.         abstract void show();
  4. }

  5. class Outer {
  6.         public void function() {
  7.                 // 匿名内部类
  8.                 new AbsClass() {

  9.                         // 覆盖抽象类的方法
  10.                         void show() {
  11.                                 System.out.println("匿名内部类show方法");
  12.                         }
  13.                 }.show();
  14.         }
  15. }
复制代码
其实,匿名内部类,就是一个匿名子类对象。







作者: First    时间: 2013-5-26 11:51
  1. /**
  2. 内部类访问规则
  3.                 //成员内部类。将一个类定义在另一个类的里面,对里面那个类就称为内部类(内置类,嵌套类)。
  4. 1.内部类可以直接访问外部类中的成员,包括私有成员,
  5.         之所以可以直接访问外部类中的成员,是因为内部类中持有了一个外部类的引用,
  6.         格式为        外部类名.this.成员;
  7. 2.外部类要访问内部类中的成员必须要建立内部类的对象。

  8. 访问格式:
  9. 1.        当内部类定义在外部类的成员位置上,而且非私有,可以在 外部类的其他类(不是该外部类) 中。
  10.         可以自己建立内部类对象。
  11.         格式:
  12.                 外部类名.内部类名        变量名 = 外部类对象.内部类对象;
  13.                 Outer.Inner in = new Outer().new Inner();

  14. 2.  当内部类在成员位置上,就可以被成员修饰符修饰。
  15.          比如:private,将内部类在外部类进行封装。
  16.                static:内部类就具备了static的特性。
  17.                    当内部类被static修饰后,只能直接访问外部类中的static成员。
  18.                    出现访问局限。

  19.                 在外部其他类中,如何直接访问static内部类的非静态成员呢?
  20.                 new Outer.Inner().function();

  21.                 在外部其他类中,如何直接访问static内部类的静态成员呢?

  22.                 Outer.Inner.function();

  23.         注意:1当内部类中定义了静态成员,该内部类必须是static。//??? 个人理解:
  24.                                 当内部类定义了static的成员是,就意味着@1 = Outer.Inner.function(); 是
  25.                                 可以正确执行的,但是该内部类却不是static,则意味着 @2 = Outer.Inner   是
  26.                                 错误的,因此@1和@2是矛盾的。因此必须符合注意1。
  27.                   2当外部类中的静态方法访问内部类时,内部类也必须是static。
  28.                   //疑问:static main 可以访问非静态的成员,为何内部类就不行?
  29.                                  //个人理解:内部类 创建对象时,依赖外部类的数据。
  30.                                  因此该方法可以以
  31.                                  //new Outer().new Inner2().show(); 正常运行。

  32.                   3 非static 的内部类 创建对象时,依赖外部类的数据。
  33. */

  34. //下面是一个静态内部类的例子。

  35. class Outer{
  36.          
  37.          private static int x = 3;
  38.          int y;

  39.         // Outer(int y){
  40.         //         this.y = y;
  41.         // }

  42.          static class Inner{   
  43.                 // int z = y;  编译通不过。
  44.                  int z = x;  //而static的内部类 可以用 new Outer.Inner() 来创建对象。而此时 y 并不存在,x存在,
  45.                  //所以static 内部类里面的成员 只能访问外部类中static 的成员。
  46.                   static void function(){
  47.                          //在该方法中可以用 new Outer().x   
  48.                          //但是不能用Outer.this.x   因为访问该方法的未必是对象,可以是类,
  49.                          //所以this是不能用的。
  50.                          System.out.println("innner :"+ x);//在内部类中访问外部类。
  51.                  }
  52.          }

  53.          class Inner2
  54.          {
  55.                  void show(){
  56.                          System.out.println("inner2 show" + y);//因为要要的成员变量 y, 所以内部类Inner2
  57.                          //必须在 new Outer() 对象后才能 创建对象。 即非static 的内部类 创建对象时,
  58.                          //依赖外部类的数据。
  59.                  }
  60.          }

  61.          public static void method(){
  62.                  Inner.function();
  63.                  new Outer().new Inner2().show();//疑问:static main 可以访问非静态的成员,为何内部类就不行?
  64.                                                          //个人理解:内部类像成员变量一样只有在new 出对象是才会存在于
  65.                                                          //内存中,即加载内部类。因此该方法可以以
  66.                                                          //new Outer().new Inner2().show(); 正常运行。
  67.          }
  68. }


  69. class  InnerClassDemo{
  70.          public static void main(String[] args) {
  71.                
  72.                  new Outer.Inner().function();//直接访问内部类中的成员。
  73.                 Outer.method();
  74.          }
  75. }
复制代码





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