Java学习--内部类（一）

Java学习--内部类(一)

一. 内部类的定义和特点

class Outer{
    privite int num = 5;

    class Inner{
        public void Display(){
            System.out.println(num);
        }
    }

    public void method(）{
        Inner i = new Inner();
        i.Display();
    }
}

这里写了一个类Outer，它有一个私有变量，一个成员方法method(),和一个内部类Inner。在内部类Inner中访问了外部类Outer的私有变量。内部类是这样定义的： 
把类定义在其他类的内部，这个类就被称为内部类，比如上例中的Inner。 
内部类的访问特点是: 
内部类可以直接访问外部类的成员,比如上例中的num，包括私有;外部类要访问内部类的成员，必须创建内部类对象。 
内部类的分类：
* 成员内部类
* 局部内部类

二. 成员内部类

首先说一下成员内部类和局部内部类的区别。

class Outer{
    privite int num = 5;
    // 成员位置
    class Inner{
    }

    public void method(）{
        //局部位置
        class Inner2{
    }
}

成员位置:在成员位置定义的类，被称为成员内部类,如 class Inner。 
局部位置:在局部位置定义的类，被称为局部内部类,如class Inner2。
如何访问成员内部类的成员呢？这里直接给出答案： 外部类名.内部类名 对象名 = 外部类对象.内部类对象

class Outer{
    privite int num = 5;

    class Inner {
        public void Display() {
            System.out.println(num);
        }
    }
}
class InnerDemo{
    public static void main(String[] args) {
        // 需要访问Inner类Display方法
        Outer.Inner oi = new Outer().new Inner();
        oi.show();
    }
}

对于成员内部类，必须通过一级一级的类进行访问。

成员内部类的修饰符private和static。
private是为了数据的安全性。当内部类里的成员变量和方法不想让外部类或者其他人访问时,将内部类声明为private即可。这时的就要将内部类的实例化放在外部类中。

class Computer {
        private class Cpu {
            public void operator() {
                System.out.println("更改CPU");
            }
        }

        public void method() {
            if(管理者) {
                Cpu c = new Cpu();
                c.operator();
            }
        }
    }

这样当我们要访问内部类Cpu中的operator方法时，因为不是任何一个人都可以更改cpu，就将内部类声明为私有的,我们也不能通过上面讲的外部类名.内部类名 对象名 = 外部类对象.内部类对象来访问，因为这个成员内部类是private,私有的，不允许外部类的对象来访问这个private的Cpu类。这时就可以通过在Computer内部声明一个成员方法来实现内部类的实例化，在Computer类的内部来访问这个私有的内部类。 
static是为了方便访问数据。这里需要注意的是静态内部类访问的外部类数据必须是静态类型的。

class Outer {
    private static int num = 10;

    public static class Inner {
        public void show() {
            System.out.println(num);
        }       
    }
    public static void show2() {
        System.out.println(num2);
    }
}

这里要访问内部类里的show方法就外部类名.内部类名 对象名 = new 外部类名.内部类名(),即Outer.Inner o = new Outer.Inner(),因为内部类就是相当于一个成员方法，所以这里外部类Outer不需要实例化就可以直接调用.Inner(),即new Outer.Inner();当我们要访问show2()方法时，直接Outer.Inner.show2(),因为都是静态的。

三. 局部内部类

局部内部类的定义在上面已经说过。

class Outer {
    private int num = 10;

    public void method() {
        class Inner {
            public void show() {
                System.out.println(num);
            }
        }

        Inner i = new Inner();
        i.show();
    }
}

class InnerDemo {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}

在上例中可以看出：
* 局部内部类可以直接访问外部类的成员
* 在局部位置，可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能
局部内部类还有一个重要的特点需要知道。那就是局部内部类访问局部变量时,局部变量需要用final关键字修饰。

class Outer{

    private int num = 10;
　　Object method() {
        final int num2 = 20;
        class Inner {
            public void show() {
                System.out.println(num);
                System.out.println(num2);
            }
        }

        Inner i = new Inner();
        return i;
    }
}

final关键字表示最终类型。如果不加final关键字,当函数执行完毕后,局部变量就消失了，但类产生的对象i是在堆上,这样对象就访问了一个不存在的变量。这是编译不通过的。这种矛盾是由局部内部类可以访问局部变量但是局部内部类对象和局部变量的生命周期不同而引起的。