c++与java在嵌套类方面的比较

原址：http://blog.csdn.net/a450828540/article/details/8993160

c++与java都允许类的嵌套，不过在机制和使用方法上还是有较大不同的

一、C++的嵌套类

C++的嵌套类可以在封装类的私有、公有、保护部分定义，当然这些访问控制也做用于嵌套类上。

虽然嵌套类在封装类内部定义，但它是一个独立的类，基本上与封装类不相关。它的成员不属于封装类，同样，封装类的成员也不属于该嵌套类。嵌套类的出现只是告诉封装类有一个这样的类型成员供其使用。并且，封装类对嵌套类成员的访问没有任何特权，嵌套类对封装类成员的访问也同样如此，它们都遵循普通类所具有的标号访问控制。

不过也有特例：   嵌套类可以直接访问封装类的静态成员、类型名（ typedef ）和枚举值（enum）。

[cpp] view plain copy

1. #include <iostream>  
2. using namespace std;  
3.   
4. class X{  
5.     class Y{  
6.         int m;  
7.       public:  
8.         Y(int t){ m=t; }  
9.     }  
10.   
11.   public:  
12.     X(){}  
13. }  
14.   
15. int main () {  
16.     X::Y y(5);                        //使用“：：”调用  
17.     return 0;  
18. }   

如上代码所示是将成员函数都定义为内联函数了，若不想定义为内联，在外部定义函数是应该使用作用域操作符 ：：

例如：

[cpp] view plain copy

1. X：：Y：：Y（）｛  
2.   
3.  your code；  
4.   
5. ｝  

嵌套类的定义也可位于封装类之外，定义时也要如上使用作用域操作符

注意事项：

1. 封装类无法直接访问嵌套类私有成员，若想直接访问，必须在嵌套类中使封装类成为其友元。
2. 嵌套类无法直接访问封装类私有成员，若想直接访问，必须在封装类中使嵌套类成为其友元。
3. 嵌套类可以直接访问封装类的静态成员、类型名（ typedef ）和枚举值（enum）。
4. 若嵌套类想访问封装类的非静态成员，必须通过封装类的一个对象作为载体才行。

二、java的嵌套类

1、静态嵌套类：

C++的嵌套类与java中的静态嵌套类“类似”。

[cpp] view plain copy

1. //java  
2.   
3. class X{  
4.     static class Y{                                        //非public  
5.         private int a;  
6.         public Y(int m){ a=m; }  
7.         public void printY(){   
8.           system.out.println( "xxxxxxxxx");  
9.         }  
10.     }  
11.   
12.     private Y yref;  
13.     public X(){}  
14.     Y get_yref(){ return yref; }  
15. }  
16.   
17. class test{  
18.      public static void main( String[] args) {  
19.       X x=new X();   
20.       x.get_yref().printY();                               //因为非public所以要先获取对象  

[cpp] view plain copy

1. //java  
2.   
3. class X{  
4.     public static class Y{                                        //public  
5.         private int a;  
6.         public Y(int m){ a=m; }  
7.         public void printY(){   
8.           system.out.println( "xxxxxxxxx");  
9.         }  
10.     }  
11.       
12.     private Y yref;  
13.     public X(){}  
14.     Y get_yref(){ return yref; }  
15. }  
16.   
17. class test{  
18.      public static void main( String[] args) {  
19.       X.Y x=new X.Y();                                            /public直接使用成员操作符“.”来调用  
20.       x.printY();   

静态嵌套类与C++嵌套类类似，可以直接访问封装类的static成员，但是，如要访问非静态成员就要使用一个封装类的对象作为载体。此外java中嵌套类可以直接访问封装类中的私有成员。

2.非静态嵌套类：内部类

内部类允许我们直接访问封装类的所有成员，不论静态成员还是非静态，不论private还是protected更别说public。

请看如下代码：

[cpp] view plain copy

1. //java  
2.   
3. class X{  
4.     private int a;  
5.     private static int b=30;  
6.       
7.     public class Y{                            //内部类，非静态  
8.       private int m;  
9.       private int n;  
10.       public Y(){  
11.         m = a;                                 //访问private成员  
12.         n = b;                                 //访问静态私有成员  
13.       }  
14.     }  
15.   
16.     public X(int n) { a = n; }  
17. }  
18.   
19. class test {  
20.     public static void main ( String[] args) {  
21.       X x=new X.Y();  
22.       // X.Y y = new X.Y()                      //错的！！！  
23.       X.Y y= x.new Y();                         //这样才对  
24.     }  
25. }  

接下来说一下名字冲突的情况下以前缀避免冲突：

[cpp] view plain copy

1. //java  
2.   
3. class X{  
4.     private int m;  
5.     private static int n=300;  
6.       
7.     public class Y{  
8.       private int m;  
9.       private int n;  
10.       public Y(){  
11.         this.m = X.this.m;            //此处留意  
12.         this.n = X.this.n;  
13.       ｝  
14.     }  
15.       
16.     public  X(){}  
17. }  

java的接口也可以包含嵌套的接口或者类，当接口包含了一个类时，这个类会被隐式的声明为public和static

最后，如果有多重嵌套例如：x（ y（ z() ））可以在z中使用x.前缀访问x成员，还有，内部类不允许有静态成员。

java还可以有匿名内部类，另开一篇再写把。