第06章面向对象(下)

/*****************
***第六章面向对象(下)
*******知识点:
**************1.内部类
******************1.1 内部类基础
******************1.2 内部类分类和应用
**************2.闭包和回调
******************2.1 基础
******************2.2 深入和应用
**************3.装箱和拆箱
******************3.1 装箱
******************3.2 拆箱

*/

public class test6{
    public static void main(String[] args){
        showDemo("1.内部类");
        demoInnerClass();
        
        showDemo("2.闭包和回调");
        demoCallBack();
        
        showDemo("3.装箱和拆箱");
        demoPackAndUnpack();
    }
    
    /*
    *1.内部类
    */
    public static void demoInnerClass(){
        /**1.1 内部类基础**/
        //什么是内部类————可以将一个类的定义放在另一个类或者一个方法里面，这个类称为内部类
        
        
        /**1.2 内部类分类和应用**/
        //由上面的定义可以得到  内部类分类有：成员内部类、局部内部类、匿名内部类、静态内部类
        
        //成员内部类
        //定义————一个类是另一个类的成员 属于对象成员
        //1.成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员）
        //2.当成员内部类拥有和外部类同名的成员变量或者方法时，会发生隐藏现象，
        //  即默认情况下访问的是成员内部类的成员。如果要访问外部类的同名成员，
        //  需要以下面的形式进行访问：
        //                            1.外部类.this.成员变量
        //                            2.外部类.this.成员方法
        //3.在外部类中如果要访问成员内部类的成员，必须先创建一个成员内部类的对象，
        //  再通过指向这个对象的引用来访问
        //4.如果要创建成员内部类的对象，前提是必须存在一个外部类的对象
        /*
        class demoMemberInnerClass{
            private int i,j = 0;
            public demoMemberInnerClass(int i){
                this.i = i ;
                getDrawInstance().drawShape();   //外部类调用内部类方法时必须创建内部类对象才能调用内部类方法
                System.out.println("外部类成员i:" + this.i); //外部类成员i
            }
            private Draw getDrawInstance(){
                return new Draw();
            }
            class Draw{
                public int i = 3;
                public void drawShape(){
                    System.out.println("demoMemberInnerClass的私有成员j为:" + j);  //可以直接访问外部类成员(包括私有)
                    System.out.println("Draw的私有成员i为:" + i);    //因为i同名，故访问的是内部类i
                    System.out.println("demoMemberInnerClass的私有成员i为:" + demoMemberInnerClass.this.i);    //i同名,需要访问外部类i 的格式为 外部类.this.成员变量  同名的方法同理可得
                    System.out.println("调用demoMemberInnerClass的私有方法获取Draw的私有成员i为:" + getDrawInstance().returnDrawI());   //可以直接访问外部类方法(包括私有)
                }
                public int returnDrawI(){
                    return this.i;
                }
            }
        }
        
        public class testdemoMemberInnerClass{
            public static void main(String[] args){
                //第一种创建内部类方法
                demoMemberInnerClass dmic =  new demoMemberInnerClass();
                demoMemberInnerClass.Draw draw = dmic.new Draw();
                
                //第二种创建内部类方法
                demoMemberInnerClass.Draw draw1 = dmic.getDrawInstance();
                                
                //无论那种方法在创建内部类之前必须存在一个外部类对象  
                //个人比较喜欢第二种 但第二种中的getDrawInstance()需要为public权限
            }
        }
        */
        
        //局部内部类
        //定义————定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内
        //1.局部内部类就像是方法里面的一个局部变量一样，是不能有public、protected、private以及static修饰符的
        //2.只能访问局部final变量
        /*
        class demoInnerClass{
            demoInnerClass(){
                class demoPartInnerClass{
                    int  i = 0;
                }
                
                return new demoInnerClass();
            }
        }
        //用得很少。不推荐使用
        */
        
        
        //匿名内部类
        //定义————没有名字的内部类   一般用于代码比较简短的监听事件中
        //1.匿名内部类是唯一一种没有构造器的类。正因为其没有构造器，
        //  所以匿名内部类的使用范围非常有限，大部分匿名内部类用于接口回调(常见监听器)
        //2.匿名内部类也是不能有访问修饰符和static修饰符的
        //3.只能访问局部final变量
        
        /*
          scan_bt.setOnClickListener(new OnClickListener() {
            public void onClick(View v) {
                // TODO Auto-generated method stub
                 
            }
            });//scan_bt 为Button对象
        */
        
        //静态内部类
        //定义————静态内部类也是定义在另一个类里面的类，只不过在类的前面多了一个关键字static
        //1.静态内部类是不需要依赖于外部类的
        //2.静态内部类不能使用外部类的非static成员变量或者方法
        /*3.静态内部类属于外部类类成员不属于外部类对象成员
        class demoStaticInnerClass{
            class Bean1{
                public int I = 0;
                public Bean1(){
                    System.out.println("Bean1类的I：" + this.I);
                }
            }
         
            static class Bean2{
                   public int J = 1;
                   public Bean2(){
                    System.out.println("Bean2类的J：" + this.J);
                }
            }

         
            class Bean{
                class Bean3{
                   public int K = 2;
                   public Bean3(){
                    System.out.println("Bean中Bean3类的K：" + this.K);
                }
                }
            }
        }
        
        public class testdemoStaticInnerClass{
            public static void main(String[] args){
                //初始化Bean1
                demoStaticInnerClass ds = new demoStaticInnerClass();
                demoStaticInnerClass.Bean1 ds_bean1 = ds.new Bean1();
                
                //初始化Bean2
                demoStaticInnerClass.Bean2 ds_bean2 =  new demoStaticInnerClass.Bean2();
                
                //初始化Bean3
                demoStaticInnerClass.Bean.Bean3 ds_bean3 = ds.new Bean().new Bean3();
            }
        
        }
        
        //创建静态内部类对象的一般形式为：外部类类名.内部类类名 xxx = new 外部类类名.内部类类名()
        //创建成员内部类对象的一般形式为：外部类类名.内部类类名 xxx = 外部类对象名.new 内部类类名()    
        */
            
    }
    
    /*
    *2.闭包和回调
    */
    public static void demoCallBack(){
        /**2.1 基础**/
        //闭包定义————是一种能被调用的对象，用于保存创建它的作用域的信息
        //回调定义————允许客户类通过内部类引用来调用其外部类的方法
        
        /**2.2 深入和应用**/
        /*
        interface     Teacherable{
            void work() ;
        }    

        class Programmer{
            private String name;
            public Programmer() { this.name = "无名氏";}
            public Programmer(String name) { this.name = name ;}
            public String getName(){return this.name ;}
            public void work(){System.out.println("程序员" + name +"正在敲代码");}
        }

        class TeachProgrammer extends Programmer implements Teacherable{
            TeachProgrammer(){}
            TeachProgrammer(String name){ super(name);}
            private void teach(){System.out.println("程序员" + getName() +"正在教课"); }
            private class Closure implements Teacherable{
                public void work(){
                    teach();//内部类调用外部类teach()方法
                }
            }
            public Teacherable getTeacherableInstance(){
                return new Closure();
            }
        }
        
        public class demoCallBack{
            public static void main(String[] args){
                TeachProgrammer tp = new TeachProgrammer();
                tp.work();//直接调用父类的work方法
                tp.getTeacherableInstance().work();
                //表面上调用的是Closure的work方法，实际上是回调TeachableProgrammer的teach方法
            }
        }
        
        //需结合内部类应用知识。本质上就是内部类调用外部类的成员和方法
        */
    }
    
    /*
    *3.装箱和拆箱
    */
    public static void demoPackAndUnpack(){
        /**3.1 装箱**/
        //定义————简单来说装箱就是自动将基本数据类型转换成包装器类型
        //应用
        Integer i_Integer1 =  new Integer(10);
        Integer i_Integer2 =  10;//装箱 需要是Java SE5之后
        System.out.println("i_Integer1值为：" + i_Integer1.toString());
        System.out.println("i_Integer2值为：" + i_Integer2.toString());
        System.out.println("i_Integer1.equals(i_Integer2):" + i_Integer1.equals(i_Integer2));//返回true
        System.out.println("i_Integer1==i_Integer2):" + (i_Integer1 == i_Integer2));//返回false
        
        //总结：
        //1.上诉返回不同的原因是由于Integer类重写了equals()方法，
        //    对比的是对象指向的内容  故返回 true  == 对比的是对象指向的地址  故返回false
        //2. 再来分析来equals()和 == 的关系：
        //        2.1 对于==，如果作用于基本数据类型的变量，则直接比较其存储的 “值”是否相等；
        //            如果作用于引用类型的变量，则比较的是所指向的对象的地址
        //        2.2 对于equals方法，注意：equals方法不能作用于基本数据类型的变量
        //            如果没有对equals方法进行重写，则比较的是引用类型的变量所指向的对象的地址
        //            诸如String、Date等类对equals方法进行了重写的话，比较的是所指向的对象的内容。
        
        
        
        
        /**3.2 拆箱**/
        //定义————简单来说拆箱就是自动将包装器类型转换成基本数据类型
        //应用
        int i_a = i_Integer2;  //拆箱
        System.out.println("i_a值为：" + i_a);
        
        //思考：
        //1.自动装箱实现原理————Integer i_Integer2 = 10; 等同于  Integer i_Integer2 = Integer.valueOf(10);
        //2.自动拆箱实现原理————int i_a = i_Integer2;   等同于    int i_a = i_Integer2.intValue(); 
        //3.对比两种方式:
        //   Integer i_Integer1 =  new Integer(10); 和 Integer i_Integer2 =  10;
        //   1.前者不会出发自动装箱的过程 后者会
        //     2.从执行效率和资源占用上来说。在一般情况下后者要优于前者(不绝对)
    }
    /*
    *    抽取打印演示函数  用于打印演示功能提示
    */    
    public static void showDemo(String demoStr){
        System.out.println("演示:" + demoStr);
    }
}