package包：就是文件夹，将字节码(.class)进行分类存放
        包的写法
                package 包名;
        包的注意事项
                A:package语句必须是程序的第一条可执行的代码
                B:package语句在一个java文件中只能有一个
                C:如果没有package，默认表示无包名
       
        带包的类的编译和运行
                编译：
                        javac -d . 类名.java
                运行
                        (当前路径下，不要跑到包里面去运行) java 类的全路径名
        不同包下类之间的访问
                1)类的全路径名 变量名 = new 类的全路径名();
                2)package和class之间 加入一个"import 包;"然后 ，就可以直接访问不同包下的类了

权限修饰符的访问权限
                                本类         同一个包下(子类和无关类)        不同包下(子类)        不同包下(无关类)
                private         Y               
                默认                Y                Y
                protected        Y                Y                                Y
                public                Y                Y                                Y                Y

                private: 是为本类准备的
                默认：是为同一个包下的类准备的
                protected：是为子类准备的 无论子类在任何地方
                public： 为所有类准备的
       
               
        类：public
        成员变量：private
        构造方法：public   （当定义一个工具类的时候 可以用private）
        成员方法：public
        接口中的成员变量：public static final
        接口中的成员方法：public abstract


内部类：类内部的类就叫做内部类
        外部类访问内部类里面的内容 ，必须创建内部类的对象来访问
        内部类访问外部类的内容， 直接访问 包括私有
       
        面试题：
                要求：使用已知的变量，在控制台输出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);
                                        System.out.println(this.num);
                                        System.out.println(Outer.this.num);
                                }
                        }
                }
                class InnerClassTest {
                        public static void main(String[] args) {
                                Outer.Inner oi = new Outer().new Inner();
                                oi.show();
                        }       
                }
       
        局部内部类访问局部变量，局部变量前面必须加final修饰， 为什么？ 因为生命周期的问题
                因为当调用这个方法时,局部变量如果没有用final修饰,他的生命周期和方法的生命周期是一样的,
                当方法弹栈,这个局部变量也会消失,那么如果局部内部类对象还没有马上消失想用这个局部变量,就没有了,
                如果用final修饰会在类加载的时候进入常量池,即使方法弹栈,常量池的常量还在,也可以继续使用
                jdk1.8可以不写final 因为jdk1.8默认给出了final

        匿名内部类：
                前提：有一个接口或者抽象类 或者 普通的类让你实现或者继承
                格式：
                        new 接口名或者抽象类名(){
                                重写方法;
                        };
                本质：就是接口或者抽象类或者普通类的一个子类对象
                应用：1）匿名内部类可以重写多个方法吗？可以！ 但是一般开发中就让其重写一个方法
                      2）当我们看到一个方法的参数类型是抽象类或者接口的时候， 我们调用这个方法的时候，可以考虑
                        用匿名内部类来实现
               
        有水平的面试题：
                class Test2_NoNameInnerClass {
                        public static void main(String[] args) {
                                Outer.method().show();        //要求在控制台输出”HelloWorld”
                        }
                }
                interface Inter {
                        void show();
                }
                class Outer {
                        //补齐代码
                }

                答案：
                        public static Inter method() {
                                return new Inter() {
                                        public void show() {
                                                System.out.println("show");
                                        }
                                };
                        }
                 
               

.................................