Day10 --包 匿名内部类

 a.
    包
        概述
            对.class字节码文件进行分类，也就是一个文件夹。
        分类
            * 可按功能划分
            * 可按模块划分
    
        命名规则
            公司域名倒写。
            如：heima.com
            包名就是：com.heima.add
                     com.heima.update
        
        包的定义    
            * package 包名;
            * 建议使用多级包，用.来表示路径的分隔符（.表示路径分隔符，每个.就之前都是一个文件夹而已。）
            
        注意事项
            * package 语句必须是一个程序的第一条可执行语句且只能在一个java文件中出现一次。
            * 如果没有package 默认就是没有包名。
    
        带包的类和编译过程
            * 编译时 
                * javac -d . 文件名.java   
                * 解释：
                     -d  指定存放生成的类文件（.class文件）的位置 也就是告诉虚拟机 我要编译的文件是有包结构的。
                     . 表示 在当前路径下生成一个有层次的包结构
    
            * 运行时 
                * java 包名.HelloWorld
    
        import关键字
            概述
                用于在其他类中使用 import 来导入其他类，能够使用其他包向下的类用的。
            格式
                import 包名;
                注意
                    这种方式导入是类的名称
                    import java.util.*; 中的 * 代表通配符表示到该包下挨个匹配，如果匹配上就导入，可行，但这样不建议写,开发中建议导入具体的包和类。

package import class 在类中有没有顺序（面试题）
    有。
        先 package 只能写第一行，只能是一个 
        再 import 在class上面存在，可以是多个
        最 class 在类中可以有多个，但建议只有一个，因为一个文件，一个类名。



b.
    权限修饰符（四种）
            Y表示 yes    
                            本类可访问                同一个包下的（子类和无关类）可访问            不同包的（子类）可访问        不同包的（无关类）可访问
        private（私有）             Y                
        默认（什么都不写）             Y                                    Y    
        protected(保护)             Y                                    Y                                    Y                
        public（所有）             Y                                    Y                                    Y                    Y
        
        四种权限的访问大小：    public > protected > 默认 > private



    类及其组成所使用的常见修饰符
        * A:修饰符：
            * 权限修饰符：private，默认的，protected，public
            * 状态修饰符：static，final
            * 抽象修饰符：abstract
        * B:类：
            * 权限修饰符：默认修饰符，public
            * 状态修饰符：final
            * 抽象修饰符：abstract
            
            * 用的最多的就是：public
            
        * C:成员变量：
            * 权限修饰符：private，默认的，protected，public
            * 状态修饰符：static，final
            
            * 用的最多的就是：private
            
        * D:构造方法：
            * 权限修饰符：private，默认的，protected，public
        
            * 用的最多的就是：public
            
        * E:成员方法：
            * 权限修饰符：private，默认的，protected，public
            * 状态修饰符：static，final
            * 抽象修饰符：abstract
            
            * 用的最多的就是：public
            
        * F:除此以外的组合规则：
            * 成员变量：public static final
            * 成员方法：
                * public static 
                * public abstract
                * public final



c.
    内部类
        概念
            在类中再定义一个类，这就叫内部类，又称嵌套类。
    
        规则
            1） 嵌套类可以直接访问外部类的成员，包括私有成员。
            2） 外部类不能直接访问内部类成员，需要创建内部类对象后才能访问。内部类的成员只有在内部类的范围内是可知的。
                     * 内部类对象：外部类名.内部类名 对象名 = 外部类对象.内部类对象;
    
            3） 如果一个内部类被 static 修饰，那么这个类就相当于一个外部定义的类，
              所以被 static 修饰的内部类可以声明为static成员，而非static修饰的内部类，是不可以定义为static成员的。
            4） static 中的内部类是不能再使用外层封装类的非 static 的成员变量。
                    * 也就是说在这里  静态只能调用静态，而非静态只能调用非静态，而不能调用静态的。    
                （静态原则：静态只能访问静态，非静态既可以访问静态的，也能访问非静态的。 但这里的内部类是有些不同的：非静态的内部类是不能定义静态成员的。）


        内部类特点
            * 内部类直接可以访问外部类成员，包括私有。
            * 外部类想要访问内部类成员，必须先创建对象。
            * 外部类名.内部类名 对象名 = 外部类对象.内部类对象；

例子中关键代码：
        外部类名.内部类名 变量名 = 外部类对象.内部类对象。 ---创建内部类对象
        变量名.内部类方法名;
        Outer.Inner oi = new Outer().new Inner();
        oi.show();

例子：G:\优快云_Android_\Code\day10 面向对象\02_内部类\Demo1_内部类的概述.java


        私有成员内部类的使用
例子:G:\优快云_Android_\Code\day10 面向对象\02_内部类\Demo2_私有内部类_成员内部类被私有的使用方式.java

例子中关键叙述和代码：
    当内部类没有被私有的时候，可以直接用创建内部类对象的方式去访问。
    当内部类被私有的时候，采用 在外部类中创建方法，在方法中创建内部对象后(内部类 n = new 内部类())调用内部类方法的方式去访问。
        
    class 外部类{
        private int num = 8;
        private class 私有内部类{
            public void show(){
                sop(num);
            }
        }    
        //私有内部类 只有通过在外部类中创建方法，在方法中创建内部类对象后 （内部类对象 n = new 内部类对象()） n.调用内部类show方法的方式才能访问。
            public void haha(){
                私有内部类 c = new 私有内部类();
                c.show();
            }        
    }
    
    main{
        //直接简单创建外部类对象，访问haha方法即可。
        外部类 w = new 外部类();
        w.haha();
    }





        静态成员内部类
            方式一
            //当内部类是静态的使用，创建对象的方式同样也发生了变化。
                //    外部类名.内部类名 c = 外部类名.内部类对象();
                //sOuter.staticInner staticI = sOuter.new staticInner(); 这种形式是对的，但是内部类的对象new必须要放在sOuter前面，才能表示右边是： =new 外部类名.内部类对象()。
                sOuter.staticInner staticI = new sOuter.staticInner();
                staticI.show();
    
            方式二
                因为内部类是静态的，所以内部类中的方法也可以定义为静态的，调用的方式就变成了 一路类名.方法名  即可完成调用。


例子:G:\优快云_Android_\Code\day10 面向对象\02_内部类\Demo3_静态内部类_静态成员内部类的使用方式.java



内部类面试题

        要求：使用已知的变量，在控制台输出30，20，10。

        class Outer {
            public int num = 10;
            class Inner {
                public int num = 20;
                public void show() {
                    int num = 30;
                    System.out.println(num);                //num 采用就近原则直接：num
                    System.out.println(this.num);            //this.num  因为20是内部类的成员，所以直接使用：this.num 就表示为20，因为this是谁使用我，我就代表哪个对象，所以当前this代表内部类对象
                    System.out.println(Outer.this.num);        //Other.this.num  因为要得到的是10，且10又在Outer这个外部类中，所以限定了在这个Outer的外部类中，this.num 就等于是 在外部类Outher下的num,即：Outer.this.name 
                    //（内部类之所以能获得外部类的成员，是因为它能获得到外部类的引用外部类，即；外部类.this）
                }
            }
        }
        class InnerClassTest {
            public static void main(String[] args) {
                Outer.Inner oi = new Outer().new Inner();
                oi.show();
            }    
        }



        局部内部类访问局部变量的问题 【重点】
            概述
                局部内部类访问局部变量，必须用final来修饰。
                解释为什么？
                局部内部类在访问他所在方法中的局部变量必须用final来修饰，为什么？
                    因为当调用这个方法时，局部变量如果没有被final修饰，那么他的生命周期和方法的生命周期是一样的，当方法弹栈时，这个局部变量也会随着消失，那么想要在局部内部类对象还没有消失之前想要使用这个局部变量是不可能的了，因为他随着局部方法的弹栈而消失了，所以    想要继续使用这个局部变量，就将他定义为final，让变量变成常量，因为被final修饰的成员都会进入方法区中的常量池，即使方法弹栈了，但常量池中的这个常量还在，所以还可以继续使用。

                    jdk1.8取消了这种方案，可以不用加final就可以编译通过，我认为这是个1.8之前的这种方案是一种bug;

例子：G:\优快云_Android_\Code\day10 面向对象\02_内部类\Demo4_局部内部类_访问局部变量的问题_面试重点.java
//局部内部类
    class jbOuter {
            final int num =10; //必须用final来修饰，因为被final修饰后变量变常量，进入了方法区中的静态区，也就不随着方法的调用完毕(弹栈)而消失了。
        public void show() {
            class jbInner {
                public void method(){
                    System.out.println("哈哈 ");
                    System.out.println(num);
                }
            }
            
            //步骤1：只能在外部类{方法}中直接创建jbInner对象
            jbInner j = new jbInner();
            j.method();
        }


        /** 步骤2：就不能这样写了，因为局部内部类只能在其方法中进行访问
        public void run(){
            jbInner j = new jbInner();
            j.method();
        }
        */
    }
    
    main{
        jbOuter j = new jbOuter();
        j.show();
    }




d.
    匿名内部类        
        概述
            就是没有名字的内部类，是一种简写的形式。
        前提
            必须存在一个类或接口，这个的类可以是抽象的，也可以是非抽象的。
        格式
            new 类或接口(){
                重写方法；
            }
    
        本质是什么
            是一个继承了该类或实现了该接口的子类的匿名对象。
例子：G:\优快云_Android_\Code\day10 面向对象\03_匿名内部类\Demo1_匿名内部类_概述.java


        匿名内部类重写多个方法调用
例子：G:\优快云_Android_\Code\day10 面向对象\03_匿名内部类\Demo2_匿名内部类_重写多个方法的调用.java            

        匿名内部类在开发中的应用
例子：G:\优快云_Android_\Code\day10 面向对象\03_匿名内部类\Teat1_匿名内部类_在开发中的应用.java

        匿名内部类的面试题
例子：G:\优快云_Android_\Code\day10 面向对象\03_匿名内部类\Test2_匿名内部类的面试题.java