C/C++、Java、Go、Python总结对比20-内部类

内部类顾名思义，就是在函数或者类内部的类，其中c++和java有内部类的概念，python没有内部类的概念。内部类的使用场景一般是需要定义一个类时，但是该类只有当前的类中需要，所以只需要在当前类中定义类即可。

c++的写法

 #include <iostream>
#include <string>

using namespace std;

//定义外部类
class Outer {
public:
    string name;
    static int age;
    void getName() {
        cout << "outer name is " << name << endl;
    }
    void getInnerName() {
        Inner inner;  //实例化内部类
        inner.name = "wan";
        inner.getName();
    }

    //定义内部类
    class Inner {
    public:
        string name;
        void getName() {
            cout << "inner name is " << name << endl;  //具有相同名字的变量，优先访问内部类的成员
        }
        void getOuterAge() {
            cout << "outer name is " << age << endl;  //内部类可直接访问外部类的静态成员
        }
        void getOuterName(Outer outer) {
            cout << "from inner outer name is " << outer.name << endl;  //此处通过传入的已经实例化的参数来访问外部类的非静态成员
        }
    };
};

int main() {
    Outer::Inner *inner = new Outer::Inner();  //通过对象指针来获得内部类，外部不能直接访问内部类
    inner->name = "inner";
    inner->getName();

    Outer outer;  //实例化外部类
    outer.name = "outer";
    outer.getName();
    outer.getInnerName();  //调用实例化内部类的函数，
}

java的写法

 package innerclass;

public class Outer {
    public String name;
    public static int age;

    public void getName() {
        System.out.println("outer name is" + name);
        Inner inner = new Inner();
        inner.name = "inner";
        inner.getOuterName();
    }

    public void getInnerName() {
        Inner inner = new Inner();
        inner.name = "inner";
        inner.getName();
    }

    public void getAnonymousClass() {
        //匿名内部类
        new AnonymousClass() {
            public void getName() {
                System.out.println("AnonymousClass name is AnonymousClass");
            }
        }.getName();
    }

    //定义成员内部类
    class Inner {
        String name;
        public void getName() {
            System.out.println("inner name is "+ name);
        }

        public void getOuterName() {
            System.out.println("from inner outer name is "+ Outer.this.name);
        }
    }

    //定义静态内部类
    static class StaticInner {
        String name;

        public void getName() {
            System.out.println("static inner name is " + name);
        }
    }

    public void getLocalInner() {
        //定义局部内部类
        class LocalInner {
            String name;

            public void getName() {
                System.out.println("local inner name is " + name);
            }
        }

        LocalInner localInner = new LocalInner();
        localInner.name = "localInner";
        localInner.getName();
    }
}

interface AnonymousClass {
    public void getName();
}

package innerclass;

public class Main {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.name = "outer";
        outer.getName();
        outer.getLocalInner();
        outer.getInnerName();
        outer.getAnonymousClass();

        Outer.StaticInner staticInner = new Outer.StaticInner();
        staticInner.name = "staticInner";
        staticInner.getName();


    }
}

python的写法

 class Outer:
    def __init__(self, name=""):
        self.name = name

    def get_name(self):
        print("outer name is "+self.name)

    @classmethod
    def outer_class_method(cls):
        print("outer_class_method")

    # 定义内部类
    class Inner:
        def __init__(self, name):
            self.name = name

        def get_name(self):
            print("inner name is "+self.name)

        def get_outer_name(self):
            Outer.outer_class_method()

    def get_localinner(self):
        # 定义局部内部类
        class LocalInner:
            def __init__(self, name):
                self.name = name

            def get_name(self):
                print("local inner name is "+self.name)


if __name__ == "__main__":
    outer = Outer("wan")
    outer.get_name()

    inner = outer.Inner("inner")
    inner.get_name()
    inner.get_outer_name()

对比总结：

1. 内部类的生态圈最丰富的是java，java有成员内部类，静态内部类，局部内部类和匿名内部类；其次是c++；最后虽然python可以定义成员内部类和局部内部类，但是内部类的使用和在外部定义没有区别，无非是语法不同而已。

2. 需要注意c++和java的外部类和内部类的互相访问方式，外部类访问内部类需要通过实例化内部类才能访问内部类的成员，内部类则可以随意访问外部内的静态成员，内部类访问外部类的非静态成员需要外部类实例化。