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