内部类

内部类

---

内部类是指在一个类体之内再定义一个类，在这样的情况下，外面的类称为“外部类”，里面的类称为“内部类”。

注意：内部类是一个编译时的概念，一旦编译成功，就会成为完全不同的两类。对于一个名为outer的外部类和其内部定义的名为inner的内部类。编译完成后出现outer.class和outer$inner.class两类。所以内部类的成员变量/方法名可以和外部类的相同。

引入内部类的原因主要有以下几个方面：

• 内部类能够隐藏起来，不为同一包的其他类访问；
• 内部类可以访问其所在的外部类的所有属性；
• 在回调方法处理中，匿名内部类尤为敏捷，特别是事件处理经常使用；

Static Nested Class 和 Inner Class的不同？

  Nested Class （一般是C++的说法），Inner Class (一般是JAVA的说法)。Java内部类与C++嵌套类最大的不同就在于是否有指向外部的引用上。注： 静态内部类（Inner Class）意味着1创建一个static内部类的对象，不需要一个外部类对象，2不能从一个static内部类的一个对象访问一个外部类对象

内部类分为以下几种类型：

1、成员内部类

成员内部类，就是作为外部类的成员，可以直接使用外部类的所有成员和方法，即使是private的。同时外部类要访问内部类的所有成员变量/方法，则需要通过内部类的对象来获取。

要注意的是，成员内部类不能含有static的变量和方法。因为成员内部类需要先创建了外部类，才能创建它自己的，了解这一点，就可以明白更多事情，在此省略更多的细节了。

public class Outer { //定义一个外部类

    private String name; //外部类的私有属性

    public void printOuter() {//外部类的方法
        Inner  inner = new Inner(); //声明内部类的对象

        inner.discribe = "Java";//用内部类的对象访问内部类的私有成员
        inner.printInner();//用内部类的对象访问内部类的方法

        System.out.println("name : " + name);
    }

    private class Inner {//声明一个成员内部类
        private String  discribe; //内部类的私有属性

        public void printInner() {
            name = discribe; //访问外部类的私有成员
            System.out.println("name : " + name);
            System.out.println("discribe : " + discribe);
        }
    }
}

2、局部内部类

局部内部类是指内部类定义在方法和作用域内。

public class Outer { //定义一个外部类

    private String name; //外部类的私有属性

    public void printOuter() {//外部类的方法  

        String mothod = "printOuter";//方法里的局部变量

        //定义一个方法内部类
        class Inner { //方法内部类不能加访问权限修饰符

            private String  discribe = mothod;

            public void printInner() {
                name = discribe; //访问外部类的私有成员
                System.out.println("Inner name : " + name);
                System.out.println("Inner discribe : " + discribe);
            }
        }

        new Inner().printInner();
        System.out.println("Outer  name : " + name);

        /**
         * 方法内部类只能在定义该内部类的方法内实例化，不可以在此方法外对其实例化。
         */
    }


    public void printAnother() {//外部类的方法    
        String mothod = "printAnother";//方法里的局部变量

        if (name == null) {
            //定义一个if作用域内部类
            class Inner { //方法内部类不能加访问权限修饰符
                private String  discribe = mothod;

                public void printInner() {
                    name = discribe; //访问外部类的私有成员
                    System.out.println("Inner name : " + name);
                    System.out.println("Inner discribe : " + discribe);
                }
            }

            new Inner().printInner();
        }

        System.out.println("Outer  name : " + name);
    }
}

局部内部类也像别的类一样进行编译，但只是作用域不同而已，只在该方法或条件的作用域内才能使用，退出这些作用域后无法引用的。

3、匿名内部类（Anonymous Inner Class）

匿名内部类也叫匿名类，有时候我为了免去给内部类命名，便倾向于使用匿名类，因为它没有名字。例如：

Button button = (Button) findViewById(R.id.login);

button.setOnClickListener(new OnClickListener() { //匿名类开始
    @Override 
    public void onClick(View v) { 
        new Thread() { //匿名类
            @Override 
            public void run() {  } 
        }.start(); 
    } 
}); 

有关匿名内部类的面试题：

1、Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)？

答：匿名的内部类是没有名字的内部类。不能extends(继承) 其它类，但一个内部类可以作为一个接口，由另一个内部类实现；

我的理解是匿名类它本身已经默认继承了父类( new 父类名或接口名 () { 类体; } ;)，故不可在继承其它类。至于“但一个内部类可以作为一个接口，由另一个内部类实现” 没搞懂， 求大神讲解.....

2、Static Nested Class 和 Inner Class的不同？
答：Nested Class （一般是C++的说法），Inner Class (一般是JAVA的说法)。Java内部类与C++嵌套类最大的不同就在于是否有指向外部的引用上。注： 静态内部类（Inner Class）意味着1创建一个static内部类的对象，不需要一个外部类对象，2不能从一个static内部类的一个对象访问一个外部类对象

4、静态内部类

静态内部类，就是用static修饰的内部类。声明为static的内部类，不需要内部类对象和外部类对象之间的联系，就是说我们可以直接引用outer.inner，即不需要创建外部类，也不需要创建内部类。

嵌套类和普通的内部类还有一个区别：普通内部类不能有static数据和static属性，也不能包含嵌套类，但嵌套类可以。而嵌套类不能声明为private，一般声明为public，方便调用。

从技术上讲，嵌套内部类不属于内部类。因为内部类与外部类共享一种特殊关系，更确切地说是对实例的共享关系。而嵌套内部类则没有上述关系。它只是位置在另一个类的内部，因此也被称为顶级嵌套类。

public class Outer { //定义一个外部类

    private static String name; //外部类的静态私有属性

    //定义一个静态内部类,此类只属于Outer这个类而不属于Outer类的对象
    static class Inner { 
        private String  discribe = name;//只能访问静态成员

        public void printInner() {
            System.out.println("Inner name : " + name);
            System.out.println("Inner discribe : " + discribe);
        }
    }

    public void printOuter() {//外部类的方法  
        String mothod = "printOuter";//方法里的局部变量
        name = mothod;
        new Outer.Inner().printInner();
        System.out.println("Outer  name : " + name);
    }
}