OCJP之inner class

更新中。。。错误、或者不妥之处，请高手指教、点评，先谢了!

1. non-static InnerClass

1.1 从OuterClass引用non-static InnerClass

1.1.1语法：

    必须先new出outerObj

    然后通过outerObj将innerObj NEW出来

    OuterClassName.InnerClassName innerObj = outerObj.new InnerClass()

1.1.2 规则：

  1） innerClass可以随意访问它的outerClass所有变量/方法，包括私有变量/方法，如同innerClass自己的变量/方法；

      因为non-static InnerClass有个隐式的指针，指向它的OuterClass;

  2)  non-static InnerClass内部不能再有static的属性、方法、类

1.2 从non-static InnerClass引用OuterClass

1.2.1语法：

    OuterClass.this

1.3non-static InnerClass示例代码:

public class NonStaticInnerClzTest {        public static void main(String[] args) {                //Create OuterObj first; this is the pre-condition to new a non-static innerObj;        OuterClass outerObj = new OuterClass();                //User new keyword to create a innerClass Obj;        OuterClass.InnerClass innerObj = outerObj.new InnerClass();                OuterClass outerObj2 = innerObj.getOuterClass();        System.out.println("from outerObj "+outerObj2.getId());    }}class OuterClass{    private int id;    public int getId(){        return id;    }        class InnerClass{        OuterClass getOuterClass(){            //InnerClass can access any field/method in OuterClass, including private;            System.out.println("from innerClass "+ ++id);            //this keyword can be used to reference to OuterClass;            return OuterClass.this;        }    }}

2 static InnerClass

2.1 语法

    OuterClass.InnerClass innerObj = new OuterClass.InnerClass()

2.2 规则

    1) 静态内部类里，可以有静态的属性/方法/类

    2)静态内部类，只能访问它外部类静态的方法/属性

2.3 static InnerClass示例代码

package com.ocjp.innerClz;public class StaticInnerClz {    public static void main(String[] args) {        new Tire.Wheel().go();        //静态内部类,声明时通过OuterClass,而不是外部类对象        //OuterClass.InnerClass innerObj = new OutClass.InnderClass();        Tire.Wheel tw = new Tire.Wheel();        tw.go();    }}class Tire{    private static int x = 6;    private String name;    static class Wheel{        void go(){            System.out.println("static inner class "+x++);            //static innerClass can only access its OuterClass Static field;//            System.out.println("name "+name);        }    }}

3 Anonymouse InnerClass匿名内部类

3.1 语法

    内部类似乎多用于，实现接口或者抽象类，应该还是多态，所以，应用时，主要是是通过接口或者抽象类来实例化对象

3.2 规则

    内部类要引用外部的属性，必须用final关键字，否则会报编译错误；

3.3 Anonymouse InnerClass示例代码一

//这是一道考题，参数有点怪，都用了i，其实完全可以用不同的参数

abstract class Base{    public Base(int i){        System.out.println("Base contructor: i= "+i);    }        public abstract void f();}public class AnonymousConstructor{    //内部类要引用方法的的参数，必须用final关键字，否则会报编译错误；    public static Base getBase(final int i){        //匿名内部类,继承了抽象类Base;要实现抽象类的未实现的方法;        return new Base(i){//            int i;            //匿名类构造器；            {System.out.println("child contrustor"+i);}                        @Override            public void f() {                System.out.println("f().......");            }                    };        }    public static void main(String[] args) {        Base b = getBase(11);        b.f();    }}

3.4 Anonymouse InnerClass示例代码二

//这段代码经典一些

public class AnonymousClass {    private String name = "Angela";    public static void main(String[] args) {        AnonymousClass outerObj = new AnonymousClass();        outerObj.go(20);    }        void go(final int age){        //通过内部匿名类,实现接口;        BaseDao dao = new BaseDao(){            @Override            public void accessOracle() {                System.out.println(name);                System.out.println(age);                System.out.println("implmented by anonymous inner class");                            }};                    //调用方法;        dao.accessOracle();    }}

4 方法中使用内部类

4.1 语法

    内部类似乎多用于，实现接口或者抽象类，应该还是多态，所以，应用时，主要是是通过接口或者抽象类来实例化对象

4.2 规则

    内部类要引用方法中的变量，必须用final关键字，否则会报编译错误；

    内部类可以自由的应用外部类的变量，包括私有的

    方法中的内部类不能加权限修饰符号，但可以加abastract 或者 final来修饰----我认为，方法的中内部类，基本上可以当成方法的局部变量...即使不加修饰，一个非抽象内部类，可以理解成隐式的声明为final，有点类似于接口里的方法，总是陷式地声明为public

4.3 方法中使用内部类示例代码一

public class MethodWInnerClz {        public static void main(String[] args) {        OuterClassHavingMethod outerObj = new OuterClassHavingMethod();        outerObj.setName("Angela");    }}class OuterClassHavingMethod{        public String name;    String getName(){        return name;    }    void setName(final String str){        this.name = str;        class InnerClass{            void printName(){                System.out.println("from InnerClass to access OuterClass field: "+name);                //To be accessed by InnerClass, method param must be final;                System.out.println("from InnerClass to access its method parm: "+str);            }        }        new InnerClass().printName();            }}