android 面试（基础篇 6）

20.Java内部类

    将一个类的定义放在另外一个类的内部，这就是内部类。内部类从表面看非常容易理解。

    1）为啥要使用内部类呢？

        在《Think in java》中有这样的一句话：使用内部类最吸引人的原因是：每个内部类都

        能继承一个接口实现，所以无论外围类是否已经继承了某个接口实现，对于内部类都没

        有影响。我们在程序设计过程中有时候会存在一些使用接口很难解决的问题，这个时候

        我们可以利用内部类提供的，可以继承多个具体或者抽象类的能力来解决这些问题。可

        以这样说，接口只是解决了部分问题，而内部类使得多重继承的解决方案更加完整。

public interface Father {}public interface Mother {}public class Son implements Father, Mother {}public class Daughter implements Father{    class Mother_ implements Mother{            }}

        在上面的例子中我们确实看不出来使用内部类的优势，但是如果Father和Mother不是接口，而

        是抽象类或者具体类呢？这个时候我们只能使用内部类才能实现多重继承。其实使用内部类的

        最大优点就在于他能够非常好的解决多重继承的问题，但是如果我们不需要解决多重继承的问

        题，我们自然可以使用其他的编码方法。但是使用内部类还能够为我们带来如下特性：

        （1）内部类可以用多个实例，每个实例都有自己的状态信息，并且与其他外围对象的信息相互

        独立。

        （2）再单个外围类中可以让多个内部类以不同的方式实现同一个借口，或者继承同一个类。

        （3）创建内部类对象的时候并不依赖于外围类对象的创建。

        （4）内部类没有令人迷惑的“is-a”关系他是一个独立的实体。

        （5）内部类提供了更好的封装，除了改外味蕾，其他类都不能访问。

    2）内部类的基础

        

 public class OuterClass {    private String name ;    private int age;    /**省略getter和setter方法**/        public class InnerClass{        public InnerClass(){            name = "chenssy";            age = 23;        }                public void display(){            System.out.println("name：" + getName() +"   ;age：" + getAge());        }    }        public static void main(String[] args) {        OuterClass outerClass = new OuterClass();        OuterClass.InnerClass innerClass = outerClass.new InnerClass();        innerClass.display();    }}--------------Output：name：chenssy   ;age：23

        上面的例子中，我们可以看到内部类InnerClass可以对外围类OuterClass的属性进行无缝访问

        尽管他是private修饰的。这是因为当我们在创建某个外围类的内部类对象的时候，此时内部类

        对象必定会补货一个纸箱那个外围类对象的引用，只有我们在访问外围类的成员是，就会用这

        个引用来选择外围类的成员。另外我们如果引用内部类我们需要之梦这个对象的类型如：

        OuterClass.InnerClass。同时如果我们需要创建某个内部类对象，必须要利用外部类的对象通过

        .new来创建内部类： OuterClass.InnerClass innerClass = outerClass.new InnerClass();。同时

        如果我们需要生成对外部类对象的引用，可以使用OuterClassName.this，这样就能够产生一个正

        确引用外部类的引用了。当然这点实在编译期就知晓了，没有任何运行时的成本。

        到这里了我们需要明确一点，内部类是个编译时的概念，一旦编译成功后，它就与外围类属于两个

        完全不同的类（当然他们之间还是有联系的）。对于一个名为OuterClass的外围类和一个名为

        InnerClass的内部类，在编译成功后，会出现这样两个class文件：OuterClass.class和

        OuterClass$InnerClass.class。
        

        在Java中内部类主要分为成员内部类、局部内部类、匿名内部类、静态内部类。

    3)成员内部类

        成员内部类也是最普通的内部类，它是外围类的一个成员，所以他是可以无限制的访问外围类的所有 

        成员属性和方法，尽管是private的，但是外围类要访问内部类的成员属性和方法则需要通过内部类实

        例来访问。在成员内部类中要注意两点，第一：成员内部类中不能存在任何static的变量和方法；

        第二：成员内部类是依附于外围类的，所以只有先创建了外围类才能够创建内部类。下面上例子：

 public class OuterClass {    private String str;        public void outerDisplay(){        System.out.println("outerClass...");    }        public class InnerClass{        public void innerDisplay(){            //使用外围内的属性            str = "chenssy...";            System.out.println(str);            //使用外围内的方法            outerDisplay();        }    }        /*推荐使用getxxx()来获取成员内部类，尤其是该内部类的构造函数无参数时 */    public InnerClass getInnerClass(){        return new InnerClass();    }        public static void main(String[] args) {        OuterClass outer = new OuterClass();        OuterClass.InnerClass inner = outer.getInnerClass();        inner.innerDisplay();    }}--------------------chenssy...outerClass...

    4）局部内部类

        有这样一种内部类，它是嵌套在方法和作用于内的，对于这个类的使用主要是应用与解决比较

        复杂的问题，想创建一个类来辅助我们的解决方案，到那时又不希望这个类是公共可用的，所以

        就产生了局部内部类，局部内部类和成员内部类一样被编译，只是它的作用域发生了改变，它

        只能在该方法和属性中被使用，出了该方法和属性就会失效。 

        对于局部内部类实在是想不出什么好例子，所以就引用《Think in java》中的经典例子了。

 // 定义在方法中

public class Parcel5 {    public Destionation destionation(String str){        class PDestionation implements Destionation{            private String label;            private PDestionation(String whereTo){                label = whereTo;            }            public String readLabel(){                return label;            }        }        return new PDestionation(str);    }        public static void main(String[] args) {        Parcel5 parcel5 = new Parcel5();        Destionation d = parcel5.destionation("chenssy");    }}

//定义在作用域中

public class Parcel6 {    private void internalTracking(boolean b){        if(b){            class TrackingSlip{                private String id;                TrackingSlip(String s) {                    id = s;                }                String getSlip(){                    return id;                }            }            TrackingSlip ts = new TrackingSlip("chenssy");            String string = ts.getSlip();        }    }        public void track(){        internalTracking(true);    }        public static void main(String[] args) {        Parcel6 parcel6 = new Parcel6();        parcel6.track();    }}

    5）匿名内部类

        先看一段代码：

 public class OuterClass {    public InnerClass getInnerClass(final int num,String str2){        return new InnerClass(){            int number = num + 3;            public int getNumber(){                return number;            }        };        /* 注意：分号不能省 */    }        public static void main(String[] args) {        OuterClass out = new OuterClass();        InnerClass inner = out.getInnerClass(2, "chenssy");        System.out.println(inner.getNumber());    }}interface InnerClass {    int getNumber();}

        这里我们就需要看清几个地方：

        （1） 匿名内部类是没有访问修饰符的。

        （2） new 匿名内部类，这个类首先是要存在的。如果我们将那个InnerClass接口注释掉，就会

                出现编译出错。

        （3） 注意getInnerClass()方法的形参，第一个形参是用final修饰的，而第二个却没有。同时我们

                也发现第二个形参在匿名内部类中没有使用过，所以当所在方法的形参需要被匿名内部类使用，

                那么这个形参就必须为final。

        （4） 匿名内部类是没有构造方法的。因为它连名字都没有何来构造方法。

    6）静态内部类

       在java提高篇-----关键字static中提到Static可以修饰成员变量、方法、代码块，其他它还可以修饰内

        部类，使用static修饰的内部类我们称之为静态内部类，不过我们更喜欢称之为嵌套内部类。静态内部

        类与非静态内部类之间存在一个最大的区别，我们知道非静态内部类在编译完成之后会隐含地保存着

        一个引用，该引用是指向创建它的外围内，但是静态内部类却没有。没有这个引用就意味着：

        （1）它的创建是不需要依赖于外围类的。

        （2）它不能使用任何外围类的非static成员变量和方法。

        下面这个例子充分展现了静态内部类和非静态内部类的区别：

 public class OuterClass {    private String sex;    public static String name = "chenssy";        /**     *静态内部类     */    static class InnerClass1{        /* 在静态内部类中可以存在静态成员 */        public static String _name1 = "chenssy_static";                public void display(){            /*              * 静态内部类只能访问外围类的静态成员变量和方法             * 不能访问外围类的非静态成员变量和方法             */            System.out.println("OutClass name :" + name);        }    }        /**     * 非静态内部类     */    class InnerClass2{        /* 非静态内部类中不能存在静态成员 */        public String _name2 = "chenssy_inner";        /* 非静态内部类中可以调用外围类的任何成员,不管是静态的还是非静态的 */        public void display(){            System.out.println("OuterClass name：" + name);        }    }        /**     * @desc 外围类方法     * @author chenssy     * @data 2013-10-25     * @return void     */    public void display(){        /* 外围类访问静态内部类：内部类. */        System.out.println(InnerClass1._name1);        /* 静态内部类 可以直接创建实例不需要依赖于外围类 */        new InnerClass1().display();                /* 非静态内部的创建需要依赖于外围类 */        OuterClass.InnerClass2 inner2 = new OuterClass().new InnerClass2();        /* 方位非静态内部类的成员需要使用非静态内部类的实例 */        System.out.println(inner2._name2);        inner2.display();    }        public static void main(String[] args) {        OuterClass outer = new OuterClass();        outer.display();    }}----------------Output:chenssy_staticOutClass name :chenssychenssy_innerOuterClass name：chenssy