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

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

一、C++的嵌套类

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

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

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

#include <iostream>
using namespace std;

class X{
    class Y{
        int m;
      public:
        Y(int t){ m=t; }
    }

  public:
    X(){}
}

int main () {
    X::Y y(5);                        //使用“：：”调用
    return 0;
} 

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

例如：

X：：Y：：Y（）｛

 your code；

｝

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

注意事项：

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

二、java的嵌套类

1、静态嵌套类：

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

//java

class X{
    static class Y{                                        //非public
        private int a;
        public Y(int m){ a=m; }
        public void printY(){ 
          system.out.println( "xxxxxxxxx");
        }
    }

    private Y yref;
    public X(){}
    Y get_yref(){ return yref; }
}

class test{
     public static void main( String[] args) {
      X x=new X(); 
      x.get_yref().printY();                               //因为非public所以要先获取对象

//java

class X{
    public static class Y{                                        //public
        private int a;
        public Y(int m){ a=m; }
        public void printY(){ 
          system.out.println( "xxxxxxxxx");
        }
    }
    
    private Y yref;
    public X(){}
    Y get_yref(){ return yref; }
}

class test{
     public static void main( String[] args) {
      X.Y x=new X.Y();                                            /public直接使用成员操作符“.”来调用
      x.printY(); 

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

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

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

请看如下代码：

//java

class X{
    private int a;
    private static int b=30;
    
    public class Y{                            //内部类，非静态
      private int m;
      private int n;
      public Y(){
        m = a;                                 //访问private成员
        n = b;                                 //访问静态私有成员
      }
    }

    public X(int n) { a = n; }
}

class test {
    public static void main ( String[] args) {
      X x=new X.Y();
      // X.Y y = new X.Y()                      //错的！！！
      X.Y y= x.new Y();                         //这样才对
    }
}

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

//java

class X{
    private int m;
    private static int n=300;
    
    public class Y{
      private int m;
      private int n;
      public Y(){
        this.m = X.this.m;            //此处留意
        this.n = X.this.n;
      ｝
    }
    
    public  X(){}
}

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

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

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