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

来源：互联网发布：海拉淘宝店编辑：程序博客网时间：2024/06/15 06:03

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

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

一、C++的嵌套类

C++的嵌套类可以在封装类的私有、公有、保护部分定义，当然这些访问控制也做用于嵌套类上。
虽然嵌套类在封装类内部定义，但它是一个独立的类，基本上与封装类不相关。它的成员不属于封装类，同样，封装类的成员也不属于该嵌套类。嵌套类的出现只是告诉封装类有一个这样的类型成员供其使用。并且，封装类对嵌套类成员的访问没有任何特权，嵌套类对封装类成员的访问也同样如此，它们都遵循普通类所具有的标号访问控制。
不过也有特例：   嵌套类可以直接访问封装类的静态成员、类型名（ typedef ）和枚举值（enum）。
[cpp] view plaincopy
#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;
}

如上代码所示是将成员函数都定义为内联函数了，若不想定义为内联，在外部定义函数是应该使用作用域操作符：：
例如：
[cpp] view plaincopy
X：：Y：：Y（）｛

your code；

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

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

二、java的嵌套类

1、静态嵌套类：

C++的嵌套类与java中的静态嵌套类“类似”。
[cpp] view plaincopy
//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所以要先获取对象

[cpp] view plaincopy
//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。

请看如下代码：

[cpp] view plaincopy

//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(); //这样才对
}
}

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

[cpp] view plaincopy

//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还可以有匿名内部类，另开一篇再写把。

0 0