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();
        
    }
}