包：
        概述：
        作用：
        定义包的格式：
                package 包名;
                多级包用.隔开
        定义包的注意事项：
                1、package语句必须是程序的第一条可执行语句。
                2、package语句在一个java类中只能有一个。
                3、如果不写package，默认表示无包名。

        带包的如何编译和运行：（面试的时候可能会用到，平时不用）
                编译：  javac -d . 类名.java
                运行：        java 包名.类名
        不同包下的类如何互相访问：
                1、类必须是公共类（顶级类）             先这么记忆，不严谨。
                大白话，用public修饰的类。
                2、注意，使用的时候按照如下格式：
                        包名.类名

        导包：import
                格式：import 包名1.包名2.类名; (如果是多级包，各个包间用.隔开)
                注意：最后的类名不要写*，这样效率非常低。（开发中用谁就导入谁）
        面试题：
                package，import，class之间有顺序关系吗？
                        package --》 import --》 class

权限修饰符：
        private：修饰的东西只能在本类中使用。
                         它强调的是只能内类使用。

        默认   ：修饰东西可以在本类，同一个包下的类中被使用。
                         它强调的是同一个包下的类可以使用。

        protected：修饰的东西可以再本类，同一包下的类，不同包下的子类。
                           它强调的是 给子类使用。

        public ：修饰的内容，都能使用，
                     它强调的是 公共的（公开的）。


        权限修饰符：private，默认，protected，public
        状态修饰符：static，final
        抽象修饰符：abstract
        记忆：现在我们写类，构造方法，成员方法全部用public，写成员变量全部用private修饰。
                  如果明确需求，那就按照实际需求来写。


内部类：
        概述：类内部还有一个类，里边的那个类就是内部类，外边的类就是外部类。
        特点：
                1、内部类可以直接访问外部类的成员，包括私有成员。
                2、外部类想使用内部类中的内容，必须创建内部类对象。
                        格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象;
                        示例：Outer.Inner oi = new Outer().new Inner();

        成员内部类私有了，测试类中怎么使用内部类中的方法？
                通过在外部类中提供的公共访问方式。

        静态成员内部类，如何创建对象？
                格式：外部类名.内部类名 对象名 = 外部类名.内部类对象;
                示例：Outer.Inner oi = new Outer.Inner();
        如何使用静态成员内部类中的静态方法？
                通过类名点的形式调用即可。
                示例： Outer.Inner.方法名();

        成员内部类的方法中，如何使用：
                内部类的局部变量：num
                内部类的成员变量：this.num
                外部类的成员变量：Outer.this.num
        记忆：内部类之所以能使用外部类的成员，是因为内部类能拿到外部类的引用：Outer.this

                       
                class Outer{
                        private int num;
                       
                        private class Inner{
                                public void method(){
                                        System.out.println("我是内部类");
                                }
                        }

                        public void print(){   //提供一个公共的访问方法，去使用内部类Inner中的方法
                                Inner i = new Inner();
                                i.method();
                        }
                }


                class Test{
                        public static void main(String[] args){
                                new Outer().print();
                        }
                }


局部内部类：
        局部内部类在访问它所在方法中的局部变量时，必须用final修饰,为什么?
                局部变量因为是在方法中，它的生命周期是跟着方法息息相关的，方法弹栈，局部变量紧跟着就消失了。如果这个时候局部内部类还在使用着这个局部变量，程序就会报错。所以我们要用final来修饰，延长局部变量的生命周期，被final修饰的内容，在常量池中。
                JDK1.8取消了这个事情，所以你认为这个是一个Bug。


匿名内部类：
        概述：就是内部类的一个简写形式。
        前提：要有一个类，或者一个接口。
                  注意：类可以是抽象类，也可以是非抽象类的。
        格式：
                new 父类名或者父接口名 (){
                        重写类中或者接口中的抽象方法;
                };
        本质：
                是一个继承了该类或者实现了该接口的子类的匿名对象。
       
        使用匿名内部类的注意事项：
                1、匿名内部类只针对重写一个方法时使用。
                2、匿名内部类不能向下转型，原因是因为匿名内部类的本质是一个对象，没有类名。

        什么时候使用匿名内部类？
                当我们看到一个方法的形参的数据类型是抽象类或者接口的时候，就可以考虑使用匿名内部类。
                匿名内部类可以作为实际参数进行传递，因为它的本质是一个对象。


                中午：
                        1、练习带包的如何编译和运行
                        2、把上午将的内部类的三个案例练习下，（重点练习最后一个局部内部类。）

                        3、测试类中有个print方法，形参的数据类型是一个抽象类（接口），怎么调用这个方法。
                               
                                public static void print(Animal a){
                                        a.eat();
                                }

包：
        概述：
        作用：
        定义包的格式：
                package 包名;
                多级包用.隔开
        定义包的注意事项：
                1、package语句必须是程序的第一条可执行语句。
                2、package语句在一个java类中只能有一个。
                3、如果不写package，默认表示无包名。

        带包的如何编译和运行：（面试的时候可能会用到，平时不用）
                编译：  javac -d . 类名.java
                运行：        java 包名.类名
        不同包下的类如何互相访问：
                1、类必须是公共类（顶级类）             先这么记忆，不严谨。
                大白话，用public修饰的类。
                2、注意，使用的时候按照如下格式：
                        包名.类名

        导包：import
                格式：import 包名1.包名2.类名; (如果是多级包，各个包间用.隔开)
                注意：最后的类名不要写*，这样效率非常低。（开发中用谁就导入谁）
        面试题：
                package，import，class之间有顺序关系吗？
                        package --》 import --》 class

权限修饰符：
        private：修饰的东西只能在本类中使用。
                         它强调的是只能内类使用。

        默认   ：修饰东西可以在本类，同一个包下的类中被使用。
                         它强调的是同一个包下的类可以使用。

        protected：修饰的东西可以再本类，同一包下的类，不同包下的子类。
                           它强调的是 给子类使用。

        public ：修饰的内容，都能使用，
                     它强调的是 公共的（公开的）。


        权限修饰符：private，默认，protected，public
        状态修饰符：static，final
        抽象修饰符：abstract
        记忆：现在我们写类，构造方法，成员方法全部用public，写成员变量全部用private修饰。
                  如果明确需求，那就按照实际需求来写。


内部类：
        概述：类内部还有一个类，里边的那个类就是内部类，外边的类就是外部类。
        特点：
                1、内部类可以直接访问外部类的成员，包括私有成员。
                2、外部类想使用内部类中的内容，必须创建内部类对象。
                        格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象;
                        示例：Outer.Inner oi = new Outer().new Inner();

        成员内部类私有了，测试类中怎么使用内部类中的方法？
                通过在外部类中提供的公共访问方式。

        静态成员内部类，如何创建对象？
                格式：外部类名.内部类名 对象名 = 外部类名.内部类对象;
                示例：Outer.Inner oi = new Outer.Inner();
        如何使用静态成员内部类中的静态方法？
                通过类名点的形式调用即可。
                示例： Outer.Inner.方法名();

        成员内部类的方法中，如何使用：
                内部类的局部变量：num
                内部类的成员变量：this.num
                外部类的成员变量：Outer.this.num
        记忆：内部类之所以能使用外部类的成员，是因为内部类能拿到外部类的引用：Outer.this

                       
                class Outer{
                        private int num;
                       
                        private class Inner{
                                public void method(){
                                        System.out.println("我是内部类");
                                }
                        }

                        public void print(){   //提供一个公共的访问方法，去使用内部类Inner中的方法
                                Inner i = new Inner();
                                i.method();
                        }
                }


                class Test{
                        public static void main(String[] args){
                                new Outer().print();
                        }
                }


局部内部类：
        局部内部类在访问它所在方法中的局部变量时，必须用final修饰,为什么?
                局部变量因为是在方法中，它的生命周期是跟着方法息息相关的，方法弹栈，局部变量紧跟着就消失了。如果这个时候局部内部类还在使用着这个局部变量，程序就会报错。所以我们要用final来修饰，延长局部变量的生命周期，被final修饰的内容，在常量池中。
                JDK1.8取消了这个事情，所以你认为这个是一个Bug。


匿名内部类：
        概述：就是内部类的一个简写形式。
        前提：要有一个类，或者一个接口。
                  注意：类可以是抽象类，也可以是非抽象类的。
        格式：
                new 父类名或者父接口名 (){
                        重写类中或者接口中的抽象方法;
                };
        本质：
                是一个继承了该类或者实现了该接口的子类的匿名对象。
       
        使用匿名内部类的注意事项：
                1、匿名内部类只针对重写一个方法时使用。
                2、匿名内部类不能向下转型，原因是因为匿名内部类的本质是一个对象，没有类名。

        什么时候使用匿名内部类？
                当我们看到一个方法的形参的数据类型是抽象类或者接口的时候，就可以考虑使用匿名内部类。
                匿名内部类可以作为实际参数进行传递，因为它的本质是一个对象。


                中午：
                        1、练习带包的如何编译和运行
                        2、把上午将的内部类的三个案例练习下，（重点练习最后一个局部内部类。）

                        3、测试类中有个print方法，形参的数据类型是一个抽象类（接口），怎么调用这个方法。
                               
                                public static void print(Animal a){
                                        a.eat();
                                }