【Android入坑系列教程】41.内部类---面向对象

pansong291

上篇：40.static关键字---面向对象
下篇：42.类的继承（一）---面向对象

注意：如果你的回复只是“感谢分享”、“辛苦了”之类的与教程内容无关的字眼，还请不要回复本帖，谢谢合作！！！
注意：如果你的回复只是“感谢分享”、“辛苦了”之类的与教程内容无关的字眼，还请不要回复本帖，谢谢合作！！！
注意：如果你的回复只是“感谢分享”、“辛苦了”之类的与教程内容无关的字眼，还请不要回复本帖，谢谢合作！！！

在一个类内部定义类，这就是嵌套类（nested classes），也叫内部类、内置类。读者
以后不要死抠这些名称术语，不同的书籍有不同的翻译风格，你只要知道怎么回事就行了。
我曾经碰到一个学员为了弄清楚方法与函数的区别（因为有的书叫方法，有的书叫函数，反
而把他给弄糊涂了），翻阅了大量的书籍，都没有搞清楚这两者的区别，其实是同一个事务
的两种不同叫法，因为他思考方式的问题，反而在他那变得复杂了。嵌套类可以直接访问嵌
套它的类的成员，包括private成员，但是，嵌套类的成员却不能被嵌套它的类直接访问。

类中定义的内部类
在类中直接定义的嵌套类的使用范围，仅限于这个的类的内部，也就是说，A类里定义
了一个B类，那么B为A所知，却不被A的外面所知。内部类的定义和普通类的定义没什么区别，
它可以直接访问和引用它的外部类的所有变量和方法，就像外部类中的其他非 static 成员的
功能一样，和外部类不同的是，内部类可以声明为 private 或 protected。
下面的程序说明了如何定义和使用一个内部类。名为 Outer 的类定义了一个实例变量
outer_i，一个test()方法，和一个名为 Inner 的内部类。
class Outer
{
    int outer_i = 100;
    void test()
    {
        Inner in = new Inner();
        in.display();
    }
    class Inner
    {
        void display()
        {
            System.out.println("display: outer_i = " + outer_i);
        }
    }
}
class InnerClassDemo
{
    public static void main(String[] args)
    {
        Outer outer = new Outer();
        outer.test();
    }
}
打印结果如下：
display: outer_i = 100
在程序中，内部类 Inner 定义在 Outer 类的范围之内。因此，在 Inner 类之内的display()
方法可以直接访问 Outer 类的变量 outer_i。其实,在内部类对象保存了一个对外部类对象的
引用，当内部类的成员方法中访问某一变量时，如果在该方法和内部类中都没有定义过这个
变量，调用就会被传递给内部类中保存的那个外部类对象的引用，通过那个外部类对象的引
用去调用这个变量，在内部类中调用外部类的方法也是一样的道理。上面的程序代码在内存
中的布局，如图3.21所示：

指点迷津：
内部类使得程序代码更为紧凑，程序更具模块化。建议读者先自己试试如何将上面的
Inner 类改写成 Outer 类的外部去实现，如果你试图这样做了，并感觉到有些棘手的话，你就
非常容易明白作者下面的结论了：当一个类中的程序代码要用到另外一个类的实例对象，而
另外一个类中的程序代码又要访问第一个类中的成员，将另外一个类做成第一个类的内部
类，程序代码就要容易编写得多，这样的情况在实际应用中非常之多!
一个内部类可以访问它的外部类的成员，但是反过来就不成立了。内部类的成员只有在
内部类的范围之内是可知的，并不能被外部类使用。例如：
class Outer
{
    int outer_i = 100;
    void test()
    {
        Inner inner = new Inner();
        inner.display();
    }
    class Inner
    {
        int y = 10;
        void display()
        {
            System.out.println("display: outer_i = " + outer_i);
        }
    }
    void showy()
    {
        System.out.println(y);
    }
}
编译器会报如下错误：

这里，y是作为 Inner 的一个实例变量来声明的，对于该类的外部它就是不可知的，因此
不能被showy()使用。
如果用 static 修饰一个内部类，这个类就相当于是一个外部定义的类，所以 static
的内部类中可声明 static 成员，但是，非 static 的内部类中的成员是不能声明为 static
的。static 的内部类不能再使用外层封装类的非 static 的成员变量，这个道理不难想像！
所以 static 嵌套类很少使用。
我们把前面程序中的 Inner 内部类声明为 static，来看看会出现什么样的错误：
class Outer
{
    int outer_i = 100;
    void test()
    {
        Inner in = new Inner();
        in.display();
    }
    static class Inner
    {
        void display()
        {
            System.out.println("display: outer_i = " + outer_i);
        }
    }
}
class InnerClassDemo
{
    public static void main(String[] args)
    {
        Outer outer = new Outer();
        outer.test();
    }
}
编译器报错：

这段信息表明 Outer 类的非静态成员变量outer_i不能被一个静态内部类的成员调用。
如果函数的局部变量（函数的形参也是局部变量），内部类的成员变量，外部类的成员
变量重名，我们应该按下面的程序代码所使用的方式来明确指定我们真正要访问的变量。
public class Outer
{
    private int size;
    public class Inner
    {
        private int size;
        public void doStuff( int size)
        {
            size++; // 引用的是 doStuff 函数的形参
            this.size++; //引用的是 Inner 类中的成员变量
            Outer.this.size++; // 引用的 Outer 类中的成员变量
        }
    }
}
这些同名变量在内存中的分配情况如图3.22所示：


内部类如何被外部引用
内部类也可以通过创建对象从外部类之外被调用，只要将内部类声明为 public 即可，
请看下面的程序：
class Outer
{
    private int size=10;
    public class Inner
    {
        public void doStuff()
        {
            System.out.println(++size);
        }
    }
}
public class TestInner
{
    public static void main(String[] args)
    {
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner();
        inner.doStuff();
    }
}
程序中，内部类 Inner 被声明为 public，在外部就可以创建其外部类 Outer 的实例对象，
再通过 Outer 类的实例对象创建 Inner 类的实例对象，我们就可以使用 Inner 类的实例对象来
调用内部类 Inner 中的方法了。

方法中定义的内部类
嵌套类并非只能在类里定义，也可以在几个程序块的范围之内定义内部类。例如，在方
法中，或甚至在 for 循环体内部，都可以定义嵌套类，如下面的程序所示：
class Outer
{
    int outer_i = 100;
    void test()
    {
        for(int i=0; i<5; i++)
        {
            class Inner
            {
                void display()
                {
                    System.out.println("display: outer_i = " + outer_i);
                }
            }
            Inner inner = new Inner();
            inner.display();
        }
    }
}
class InnerClassDemo
{
    public static void main(String args[])
    {
        Outer outer = new Outer();
        outer.test();
    }
}
该程序的这个版本的输出如下所示。
display: outer_x = 100
display: outer_x = 100
display: outer_x = 100
display: outer_x = 100
display: outer_x = 100
在方法中定义的内部类只能访问方法中的 final 类型的局部变量，因为用 final 定义的
局部变量相当于是一个常量，它的生命周期超出方法运行的生命周期。如：
class InOut
{
    String str= new String("Between");
    public void amethod(final int iArgs)
    {
        int it315;
        class Bicycle
        {
            public void sayHello()
            {
                System.out.println(str);
                System.out.println(iArgs);
            } // End of bicycle class
        }
    } // End of amethod
}
在内部类中的 sayHello 方法中，我们可以访问变量 iArgs 和 str，但不能访问 it315。

上篇：40.static关键字---面向对象
下篇：42.类的继承（一）---面向对象

11695411

楼主是个好人，这个教程也不错。

无限苦肉盖神

不太全，没有具体去说怎么使用成员内部类

泡泡茶壶

继续学习