包：文件夹
        作用：就是用来区分同名的.class文件。
        格式：
                package 包名;
                注意：多级包中间用.隔开， 包名一般是公司的域名反写（没有www）
        注意事项：
                1、package语句必须是程序的第一条可执行语句。
                2、一个java文件中，package语句只能有一个。
                3、如果不写package，表示默认无包名。

        带包的类如何编译和运行：
                编译： javac -d . 类名.java
                运行： java 包名.类名

        不同包下类之间的访问：
                第一种方式：
                        通过 包名.类名的 形式调用。

                第二种方式：
                        可以通过 导包 实现。
                        格式：
                                import 包名.类名;
                                注意：用谁就导入谁，不要写 .* 的形式。
                面试题：
                        package，import，class之间有无顺序关系？
                                有。
                                从上到下： package  --》 import  --》 class
                                注意：
                                        一个java文件中，package语句只能有一个，而import，class可以也多个（class一般一个java文件中只会写一个）。


权限修饰符：
        private：只能在本类中被使用。
                记忆：强调的是给 自己 使用。

        默认：本类，同包下的类。
                记忆：强调的是给 同包下类的 使用。

        protected：本类，同包下的类，不同包下的子类。
                记忆：强调的是给 子类 使用。

        public：公共的，给大家使用。
                记忆：强调的是给 大家 使用。

        总结：
                以后写代码，成员变量全部用private修饰，其他（类，构造方法，成员方法）全部用public修饰。
                有种特殊情况，工具类的构造方法用private修饰。

        注意：
                被public修饰的类叫公共类（顶级类），一个java文件中，公共类只能有一个，
                并且公共类名必须和java文件名一致。


内部类：
        概述：类里边还有一个类，里边那个类就是内部类。
        特点：
                1、内部类可以直接使用外部类的成员，包括私有。
                2、外部类如果想使用内部类的成员，必须创建对象。
                        格式：
                                外部类名.内部类名 对象名 = 外部类对象.内部类对象;
                                Outer.Inner oi = new Outer().new Inner();
        分类：
                成员内部类；
                        概述：定义在外部类的成员位置的类，就叫成员内部类。
                                  简单记忆：定义在成员位置。
                                 
                        成员内部类：
                                加私有：为了安全考虑。
                                        可以在外部类中提供一个公共的访问方法。
                                        class Outer {
                                                private String name;

                                                private class Inner {
                                                        public void show() {
                                                                System.out.println("内部类的show");
                                                        }
                                                }

                                                public void print() {
                                                        Inner i = new Inner();
                                                        i.show();
                                                }
                                        }
                               
                                加静态：是为了方便调用。
                                        创建对象的格式：
                                                外部类名.内部类名 对象名 = 外部类.内部类对象;
                                                Outer.Inner oi = new Outer.Inner();
                                        注意：
                                                如果内部类中有静态方法，那么这个内部类也必须加静态。

               
                                面试题：       
                                        在内部类的成员方法中，如何使用局部变量，内部类的成员变量，以及外部类的成员变量？
                                                局部变量：直接用。
                                                内部类的成员变量：通过 this. 的形式调用。
                                                外部类的成员变量：通过 外部类名.this. 的形式调用。
                                       
                                        内部类之所以能使用外部类的成员，是因为内部类能获取到外部类的引用： 外部类名.this
                                       


                局部内部类：
                        概述：定义在局部位置。
                        问：局部内部类在访问它所在方法中的局部变量时，必须用final修饰,为什么?
                                因为局部变量的生命周期是依赖于方法，方法调用完毕后，局部变量就释放了，如果此时局部内部类对象还在使用局部变量，就会报错，所以该局部变量必须加final修饰，就是为了延长局部变量的生命周期，但是JDK1.8取消了这个事情，所以我觉得这是一个Bug。

                        匿名内部类：
                                概述：没有名字的（局部）内部类。
                                前提：必须得有一个类（一般是抽象类）或者接口。
                                格式：
                                        new 类名或者接口名 () {
                                                重写类或者接口中的所有抽象方法;
                                        };
                                理解：
                                        其实匿名内部类就是实现了接口（或者继承了类）的匿名的子类对象。

                                什么时候使用匿名内部类？
                                        1、匿名内部类只针对重写一个抽象方法。
                                        2、当我们看到一个方法的形参的数据类型是一个接口或者抽象类的时候，
                                           就可以考虑使用匿名内部类。(实际开发中用到的非常多)

看一遍加深印象