java中的嵌套类

每天学习一点点

原文地址：java中的嵌套类 作者：毛毛

继续上午的学习，一点一点的学习，一点点的积累，一点点的进步。

java中的嵌套类：在一个类的内部定义另一个类，该类称为嵌套类（嵌套类是另一个类的成员）。

学习网址：http://dev.csdn.net/article/34/34597.shtm

 

嵌套类分为两类：1.静态嵌套类；2.非静态嵌套类（也就是我们经常说的内部类）

1.静态嵌套类

在静态嵌套类内部，不能访问外部类的非静态成员，这是由java语法中“静态方法不能直接访问非静态成员”所限制。静态嵌套类的成员和方法均被默认为静态的，所以外部类不能直接访问内部类的成员，但可以通过内部类来访问。

例子:

public class StaticTest {
    private static String name = "javaJohn";
    private String id = "X001";

    static class Person{
        private String address = "swjtu,chenDu,China";
        public String mail = "josserchai@yahoo.com";//内部类公有成员
        public void display(){
              //System.out.println(id);//不能直接访问外部类的非静态成员
                System.out.println(name);//只能直接访问外部类的静态成员
                System.out.println("Inner "+address);//访问本内部类成员。
        }
    }

    public void printInfo(){
        Person person = new Person();
        person.display();
        //System.out.println(mail);//不可访问
        //System.out.println(address);//不可访问
        System.out.println(person.address);//可以访问内部类的私有成员
        System.out.println(person.mail);//可以访问内部类的公有成员
    }

    public static void main(String[] args) {
        StaticTest staticTest = new StaticTest();
        staticTest.printInfo();
    }
}

2.内部类

1）在外部类中定义内部类

对于内部类，通常在class关键字前不加任何类似于public/private的限定符，加了也不影响。内部类的成员只在内部类中可见，若外部类或同层次的内部类需要访问，不可直接访问，需要通过创建内部类的对象实例调用。

例子：

public class Outer{
        int outer_x = 100;

        class Inner{
           public int y = 10;
           private int z = 9;
           int m = 5;
           public void display(){
               System.out.println("display outer_x:"+ outer_x);
           }
           private void display2(){
               System.out.println("display outer_x:"+ outer_x);
           }
       }

       void test(){
          Inner inner = new Inner();
          inner.display();
          inner.display2();
          //System.out.println("Inner y:" + y);//不能访问内部类变量
          System.out.println("Inner y:" + inner.y);//可以访问
          System.out.println("Inner z:" + inner.z);//可以访问
          System.out.println("Inner m:" + inner.m);//可以访问
          InnerTwo innerTwo = new InnerTwo();
          innerTwo.show();
       }

       class InnerTwo{
          Inner innerx = new Inner();
          public void show(){
             //System.out.println(y);//不可访问Innter的y成员
             //System.out.println(Inner.y);//不可直接访问Inner的任何成员和方法
             innerx.display();//可以访问
             innerx.display2();//可以访问
             System.out.println(innerx.y);//可以访问
             System.out.println(innerx.z);//可以访问
             System.out.println(innerx.m);//可以访问
          }
       }

       public static void main(String args[]){
          Outer outer = new Outer();
          outer.test();
       }
}

 

2）方法中定义内部类

在方法中定义的内部类的可见性更小，只在方法内部可见，在外部类中不可见。方法中的内部类可直接访问外部类的变量，且只能访问本方法的final成员。而且方法内部定义成员，只允许final修饰或不加修饰符，其他像static等均不可用。

例子：

public class FunOuter {
       int out_x = 100;

       public void test(){
          class Inner{
             String x = "x";
             void display(){
                System.out.println(out_x);
             }
          }
          Inner inner = new Inner();
          inner.display();
      }

      public void showStr(String str){
          //public String str1 = "test Inner";//不可定义，只允许final修饰
          //static String str4 = "static Str";//不可定义，只允许final修饰
          String str2 = "test Inner";
          final String str3 = "final Str";
          class InnerTwo{
             public void testPrint(){
                 System.out.println(out_x);//可直接访问外部类的变量
                 //System.out.println(str2);//不可访问本方法内部的非final变量
                 System.out.println(str3);//只可访问本方法的final型变量成员
             }
          }
          InnerTwo innerTwo = new InnerTwo();
          innerTwo.testPrint();
      }

      public void use(){
          //Inner innerObj = new Inner();//此时Inner己不可见了。
          //System.out.println(Inner.x);//此时Inner己不可见了。
      }

      public static void main(String[] args) {
          FunOuter outer = new FunOuter();
          outer.test();
      }
}

3）匿名内部类（通常用在java的事件处理上）

匿名内部类通常出现了方法的形参上，它的用法基本同于上面的内部类，它能够使用它所在的外部类的方法和变量。

 

3.其他问题

通过以上，我们可以清楚地看出内部类的一些使用方法，同时，在许多时候，内部类是在如Java的事件处理、或做为值对象来使用的。同时，我们需注意最后一个问题，那就是，内部类同其它类一样被定义，同样它也可以继承外部其它包的类和实现外部其它地方的接口。同样它也可以继承同一层次的其它的内部类,甚至可以继承外部类本身。