JavaEE知识点总结

***********************************day01_面向对象【阶段一知识回顾、继承】******************************************
1:代码块(理解)
    (1)用{}括起来的代码。
    (2)分类：
        A:局部代码块
            用于限定变量的生命周期，及早释放，提高内存利用率。
        B:构造代码块
            把多个构造方法中相同的代码可以放到这里，每个构造方法执行前，首先执行构造代码块。
        C:静态代码块
            对类的数据进行初始化，仅仅只执行一次。
    (3)静态代码块,构造代码块,构造方法的顺序问题?
        静态代码块 > 构造代码块 > 构造方法
    
2:继承(掌握)
    (1)把多个类中相同的成员给提取出来定义到一个独立的类中。然后让这多个类和该独立的类产生一个关系，
       这多个类就具备了这些内容。这个关系叫继承。
    (2)Java中如何表示继承呢?格式是什么呢?
        A:用关键字extends表示
        B:格式：
            class 子类名 extends 父类名 {}
    (3)继承的好处：
        A:提高了代码的复用性
        B:提高了代码的维护性
        C:让类与类产生了一个关系，是多态的前提
    (4)继承的弊端：
        A:让类的耦合性增强。这样某个类的改变，就会影响其他和该类相关的类。
            原则：低耦合，高内聚。
            耦合：类与类的关系
            内聚：自己完成某件事情的能力
        B:打破了封装性
    (5)Java中继承的特点
        A:Java中类只支持单继承
        B:Java中可以多层(重)继承(继承体系)
    (6)继承的注意事项：
        A:子类不能继承父类的私有成员
        B:子类不能继承父类的构造方法，但是可以通过super去访问
        C:不要为了部分功能而去继承
    (7)什么时候使用继承呢?
        A:继承体现的是：is a的关系。
        B:采用假设法
    (8)Java继承中的成员关系
        A:成员变量
            a:子类的成员变量名称和父类中的成员变量名称不一样，这个太简单
            b:子类的成员变量名称和父类中的成员变量名称一样，这个怎么访问呢?
                子类的方法访问变量的查找顺序：
                    在子类方法的局部范围找，有就使用。
                    在子类的成员范围找，有就使用。
                    在父类的成员范围找，有就使用。
                    找不到，就报错。
        B:构造方法
            a:子类的构造方法默认会去访问父类的无参构造方法
                是为了子类访问父类数据的初始化
            b:父类中如果没有无参构造方法，怎么办?
                子类通过super去明确调用带参构造
                子类通过this调用本身的其他构造，但是一定会有一个去访问了父类的构造
                让父类提供无参构造
        C:成员方法
            a:子类的成员方法和父类中的成员方法名称不一样，这个太简单
            b:子类的成员方法和父类中的成员方法名称一样，这个怎么访问呢?
                通过子类对象访问一个方法的查找顺序：
                    在子类中找，有就使用
                    在父类中找，有就使用
                    找不到，就报错
    (9)两个面试题：
        A:Override和Overload的区别?Overload是否可以改变返回值类型?
        B:this和super的区别和各自的作用?
    (10)数据初始化的面试题
        A:一个类的初始化过程
        B:子父类的构造执行过程
        C:分层初始化    

***********************************day02_面向对象【继承、this、super】******************************************
1:this关键字(掌握)
    (1)代表当前类的引用对象
        记住：哪个对象调用方法，该方法内部的this就代表那个对象
    (2)this的应用场景：
        A:解决了局部变量隐藏成员变量的问题
        B:其实this还有其他的应用，明天讲解。
        
    this和super的区别?
            分别是什么呢?
                this代表本类对应的引用。
                super代表父类存储空间的标识(可以理解为父类引用,可以操作父类的成员)

            怎么用呢?
                A:调用成员变量
                    this.成员变量 调用本类的成员变量
                    super.成员变量 调用父类的成员变量
                B:调用构造方法
                    this(...)    调用本类的构造方法
                    super(...)    调用父类的构造方法
                C:调用成员方法
                    this.成员方法 调用本类的成员方法
                    super.成员方法 调用父类的成员方法

3:抽象类(掌握)
    (1)把多个共性的东西提取到一个类中，这是继承的做法。
       但是呢，这多个共性的东西，在有些时候，方法声明一样，但是方法体。
       也就是说，方法声明一样，但是每个具体的对象在具体实现的时候内容不一样。
       所以，我们在定义这些共性的方法的时候，就不能给出具体的方法体。
       而一个没有具体的方法体的方法是抽象的方法。
       在一个类中如果有抽象方法，该类必须定义为抽象类。
    (2)抽象类的特点
        A:抽象类和抽象方法必须用关键字abstract修饰
        B:抽象类中不一定有抽象方法,但是有抽象方法的类一定是抽象类
        C:抽象类不能实例化
        D:抽象类的子类
            a:是一个抽象类。
            b:是一个具体类。这个类必须重写抽象类中的所有抽象方法。
    (3)抽象类的成员特点：
        A:成员变量
            有变量，有常量
        B:构造方法
            有构造方法
        C:成员方法
            有抽象，有非抽象
    (4)抽象类的练习
        A:猫狗案例练习
        B:老师案例练习
        C:学生案例练习
        D:员工案例练习
    (5)抽象类的几个小问题
        A:抽象类有构造方法，不能实例化，那么构造方法有什么用?
            用于子类访问父类数据的初始化
        B:一个类如果没有抽象方法,却定义为了抽象类，有什么用?
            为了不让创建对象
        C:abstract不能和哪些关键字共存
            a:final    冲突
            b:private 冲突
            c:static 无意义        
        
        
***********************************day03_面向对象【接口、多态】******************************************        
1:接口(掌握)
    (1)回顾猫狗案例，它们仅仅提供一些基本功能。
       比如：猫钻火圈，狗跳高等功能，不是动物本身就具备的，
       是在后面的培养中训练出来的，这种额外的功能，java提供了接口表示。
    (2)接口的特点：
        A:接口用关键字interface修饰
            interface 接口名 {}
        B:类实现接口用implements修饰
            class 类名 implements 接口名 {}
        C:接口不能实例化
        D:接口的实现类
            a:是一个抽象类。
            b:是一个具体类，这个类必须重写接口中的所有抽象方法。
    (3)接口的成员特点：
        A:成员变量
            只能是常量
            默认修饰符：public static final
        B:构造方法
            没有构造方法
        C:成员方法
            只能是抽象的
            默认修饰符：public abstract
    (4)类与类,类与接口,接口与接口
        A:类与类
            继承关系，只能单继承，可以多层继承
        B:类与接口
            实现关系，可以单实现，也可以多实现。
            还可以在继承一个类的同时，实现多个接口
        C:接口与接口
            继承关系，可以单继承，也可以多继承
    (5)抽象类和接口的区别：
            A:成员区别
                抽象类：
                    成员变量：可以变量，也可以常量
                    构造方法：有
                    成员方法：可以抽象，也可以非抽象
                接口：
                    成员变量：只可以常量
                    成员方法：只可以抽象
                    
            B:关系区别
                类与类
                    继承，单继承
                类与接口
                    实现，单实现，多实现
                接口与接口
                    继承，单继承，多继承
                    
            C:设计理念区别
                抽象类 被继承体现的是：”is a”的关系。抽象类中定义的是该继承体系的共性功能。
                接口被实现体现的是：”like a”的关系。接口中定义的是该继承体系的扩展功能。
    (6)练习：
        A:猫狗案例，加入跳高功能
        B:老师和学生案例，加入抽烟功能0        
        
2:多态(掌握)
    (1)同一个对象在不同时刻体现出来的不同状态。
    (2)多态的前提：
        A:有继承或者实现关系。
        B:有方法重写。
        C:有父类或者父接口引用指向子类对象。
        
        多态的分类：
            a:具体类多态
                class Fu {}
                class Zi extends Fu {}
                
                Fu f = new Zi();
                
            b:抽象类多态
                abstract class Fu {}
                class Zi extends Fu {}
                
                Fu f = new Zi();
            c:接口多态
                interface Fu {}
                class Zi implements Fu {}
                
                Fu f = new Zi();
    (3)多态中的成员访问特点
        A:成员变量
            编译看左边，运行看左边
        B:构造方法
            子类的构造都会默认访问父类构造
        C:成员方法
            编译看左边，运行看右边
        D:静态方法
            编译看左边，运行看左边
            
        为什么?
            因为成员方法有重写。
    (4)多态的好处：
        A:提高代码的维护性(继承体现)
        B:提高代码的扩展性(多态体现)
    (5)多态的弊端：
        父不能使用子的特有功能。
        
        现象：
            子可以当作父使用，父不能当作子使用。
    (6)多态中的转型
        A:向上转型
            从子到父
        B:向下转型
            从父到子
    (7)孔子装爹的案例帮助大家理解多态
    (8)多态的练习
        A:猫狗案例
        B:老师和学生案例        
        
        
***********************************day04_面向对象【static、final、包、访问修饰符、内部类】******************************************                        
1:static关键字(理解)
    (1)静态的意思。可以修饰成员变量和成员方法。
    (2)静态的特点：
        A:随着类的加载而加载
        B:优先与对象存在
        C:被类的所有对象共享
            这其实也是我们判断该不该使用静态的依据。
            举例：饮水机和水杯的问题思考
        D:可以通过类名调用
            既可以通过对象名调用，也可以通过类名调用，建议通过类名调用。
    (3)静态的内存图
        静态的内容在方法区的静态区
    (4)静态的注意事项；
        A:在静态方法中没有this对象
        B:静态只能访问静态(代码测试过)
    (5)静态变量和成员变量的区别
        A:所属不同
            静态变量：属于类，类变量
            成员变量：属于对象，对象变量，实例变量
        B:内存位置不同
            静态变量：方法区的静态区
            成员变量：堆内存
        C:生命周期不同
            静态变量：静态变量是随着类的加载而加载，随着类的消失而消失
            成员变量：成员变量是随着对象的创建而存在，随着对象的消失而消失
        D:调用不同
            静态变量：可以通过对象名调用，也可以通过类名调用
            成员变量：只能通过对象名调用
    (6)main方法是静态的
        public:权限最大
        static:不用创建对象调用
        void:返回值给jvm没有意义
        main:就是一个常见的名称。
        String[] args:可以接收数据，提供程序的灵活性
            格式：java MainDemo hello world java
                  java MainDemo 10 20 30    

2:final关键字(掌握)
    (1)是最终的意思，可以修饰类，方法，变量。
    (2)特点：
        A:它修饰的类，不能被继承。
        B:它修饰的方法，不能被重写。
        C:它修饰的变量，是一个常量。
    (3)面试相关：
        A:局部变量
            a:基本类型 值不能发生改变
            b:引用类型 地址值不能发生改变，但是对象的内容是可以改变的
        B:初始化时机
            a:只能初始化一次。
            b:常见的给值
                定义的时候。(推荐)
                构造方法中。                  

3:包(理解)
    (1)其实就是文件夹
    (2)作用：
        A:区分同名的类
        B:对类进行分类管理
            a:按照功能分
            b:按照模块分
    (3)包的定义(掌握)
        package 包名;
        多级包用.分开。
    (4)注意事项：(掌握)
        A:package语句必须在文件中的第一条有效语句
        B:在一个java文件中，只能有一个package
        C:如果没有package，默认就是无包名
    (5)带包的编译和运行
        A:手动式
        B:自动式(掌握)
            javac -d . HelloWorld.java
            
4:导包(掌握)
    (1)我们多次使用一个带包的类，非常的麻烦，这个时候，Java就提供了一个关键字import。
    (2)格式：
        import 包名...类名;
        另一种：
            import 包名...*;(不建议)
    (3)package,import,class的顺序
        package > import > class
    
5:权限修饰符(掌握)
    (1)权限修饰符
                    本类    同一个包下    不同包下的子类    不同包下的无关类
        private        Y
        默认        Y        Y
        protected    Y        Y            Y
        public        Y        Y            Y                Y
    (2)这四种权限修饰符在任意时刻只能出现一种。
        public class Demo {}        

6:常见的修饰符(理解)
    (1)分类：
        权限修饰符：private,默认,protected,public
        状态修饰符：static,final
        抽象修饰符：abstract
    (2)常见的类及其组成的修饰
        类：
            默认,public,final,abstract
            
            常用的：public
        
        成员变量：
            private,默认,protected,public,static,final
            
            常用的：private
            
        构造方法：
            private,默认,protected,public
            
            常用的：public
        
        成员方法：
            private,默认,protected,public,static,final,abstract
            
            常用的：public
    (3)另外比较常见的：
        public static final int X = 10;
        public static void show() {}
        public final void show() {}
        public abstract void show();

7:内部类(理解)
    (1)把类定义在另一个类的内部，该类就被称为内部类。
        举例：把类B定义在类A中，类B就被称为内部类。
    (2)内部类的访问规则
        A:可以直接访问外部类的成员，包括私有
        B:外部类要想访问内部类成员，必须创建对象
    (3)内部类的分类
        A:成员内部类
        B:局部内部类
    (4)成员内部类
        A:private 为了数据的安全性
        B:static 为了访问的方便性
        
        成员内部类不是静态的：
            外部类名.内部类名 对象名 = new 外部类名.new 内部类名();
        成员内部类是静态的：
            外部类名.内部类名 对象名 = new 外部类名.内部类名();
    (5)成员内部类的面试题(填空)
        30,20,10
        
        class Outer {
            public int num = 10;
            
            class Inner {
                public int num = 20;
                
                public viod show() {
                    int num  = 30;
                    
                    System.out.println(num);
                    System.out.println(this.num);
                    System.out.println(Outer.this.num);
                }
            }
        }
    (6)局部内部类
        A:局部内部类访问局部变量必须加final修饰。
        B:为什么呢?
            因为局部变量使用完毕就消失，而堆内存的数据并不会立即消失。
            所以，堆内存还是用该变量，而改变量已经没有了。
            为了让该值还存在，就加final修饰。
            通过反编译工具我们看到了，加入final后，堆内存直接存储的是值，而不是变量名。
    (7)匿名内部类(掌握)
        A:是局部内部类的简化形式
        B:前提
            存在一个类或者接口
        C:格式:
            new 类名或者接口名() {
                重写方法;
            }
        D:本质：
            其实是继承该类或者实现接口的子类匿名对象
    (8)匿名内部类在开发中的使用
        我们在开发的时候，会看到抽象类，或者接口作为参数。
        而这个时候，我们知道实际需要的是一个子类对象。
        如果该方法仅仅调用一次，我们就可以使用匿名内部类的格式简化。
        
        interface Person {
            public abstract void study();
        }
        
        class PersonDemo {
            public void method(Person p) {
                p.study();
            }
        }
        
        class PersonTest {
            public static void main(String[] args) {
                PersonDemo pd = new PersonDemo();
                pd.method(new Person() {
                    public void study() {
                        System.out.println("好好学习，天天向上");
                    }
                });
            }
        }
        
    (9)匿名内部类的面试题(补齐代码)
        interface Inter {
            void show();
        }
        
        class Outer {
            //补齐代码
            public static Inter method() {
                return new Inter() {
                    public void show() {
                        System.out.println("HelloWorld");
                    }    
                };
            }
        }
        
        class OuterDemo {
            public static void main(String[] args) {
                Outer.method().show(); //"HelloWorld"
            }
        }                
                

***********************************day05_异常【Object、异常】******************************************                        
1、:Object类(掌握)
    (1)Object是类层次结构的根类，所有的类都直接或者间接的继承自Object类。
    (2)Object类的构造方法有一个，并且是无参构造
        这其实就是理解当时我们说过，子类构造方法默认访问父类的构造是无参构造
    (3)要掌握的方法：
        A:toString()
            返回对象的字符串表示，默认是由类的全路径+'@'+哈希值的十六进制表示。
            这个表示其实是没有意义的，一般子类都会重写该方法。
            如何重写呢?过程我也讲解过了，基本上就是要求信息简单明了。
            但是最终还是自动生成。
        B:equals()
            比较两个对象是否相同。默认情况下，比较的是地址值是否相同。
            而比较地址值是没有意义的，所以，一般子类也会重写该方法。
            重写过程，我也详细的讲解和分析了。
            但是最终还是自动生成。
    (4)要了解的方法：
        A:hashCode() 返回对象的哈希值。不是实际地址值，可以理解为地址值。
        B:getClass() 返回对象的字节码文件对象，反射中我们会详细讲解    
        C:finalize() 用于垃圾回收，在不确定的时间
        D:clone() 可以实现对象的克隆，包括成员变量的数据复制，但是它和两个引用指向同一个对象是有区别的。
    (5)两个注意问题；
        A:直接输出一个对象名称，其实默认调用了该对象的toString()方法。
        B:面试题 
            ==和equals()的区别?
            A:==
                基本类型：比较的是值是否相同
                引用类型：比较的是地址值是否相同
            B:equals()
                只能比较引用类型。默认情况下，比较的是地址值是否相同。
                但是，我们可以根据自己的需要重写该方法。

2:异常(理解)
    (1)程序出现的不正常的情况。
    (2)异常的体系
        Throwable
            |--Error    严重问题，我们不处理。
            |--Exception
                |--RuntimeException    运行期异常，我们需要修正代码
                |--非RuntimeException 编译期异常，必须处理的，否则程序编译不通过
    (3)异常的处理：
        A:JVM的默认处理
            把异常的名称,原因,位置等信息输出在控制台，但是呢程序不能继续执行了。
        B:自己处理
            a:try...catch...finally
                自己编写处理代码,后面的程序可以继续执行
            b:throws
                把自己处理不了的，在方法上声明，告诉调用者，这里有问题
    (4)面试题
        A:编译期异常和运行期异常的区别?
            编译期异常 必须要处理的，否则编译不通过
            运行期异常 可以不处理，也可以处理
        B:throw和throws是的区别
            throw:
                在方法体中,后面跟的是异常对象名,并且只能是一个
                throw抛出的是一个异常对象，说明这里肯定有一个异常产生了
            throws:
                在方法声明上,后面跟的是异常的类名,可以是多个
                throws是声明方法有异常，是一种可能性，这个异常并不一定会产生
    (5)finally关键字及其面试题
        A:finally用于释放资源，它的代码永远会执行。特殊情况：在执行到finally之前jvm退出了 （System.exit(0)）
        B:面试题
            a:final,finally,finalize的区别?
            b:如果在catch里面有return,请问finally还执行吗?如果执行,在return前还是后
                会，前。
                
                实际上在中间。这个上课我们讲过
        C:异常处理的变形
            try...catch...finally
            try...catch...
            try...catch...catch...
            try...catch...catch...fianlly
            try...finally
    (6)自定义异常
        继承自Exception或者RuntimeException,只需要提供无参构造和一个带参构造即可
    (7)异常的注意实现
        A:父的方法有异常抛出,子的重写方法在抛出异常的时候必须要小于等于父的异常 
        B:父的方法没有异常抛出,子的重写方法不能有异常抛出
        C:父的方法抛出多个异常,子的重写方法必须比父少或者小        
        
                
***********************************day06_常用API【Date、DateFormat、Calendar、Math、System、包装类、正则表达式】******************************************    
1:Date/DateFormat(掌握)
    (1)Date是日期类，可以精确到毫秒。
        A:构造方法
            Date()
            Date(long time)
        B:成员方法
            getTime()
            setTime(long time)
        C:日期和毫秒值的相互转换
        案例：你来到这个世界多少天了?
    (2)DateFormat针对日期进行格式化和针对字符串进行解析的类，但是是抽象类，所以使用其子类SimpleDateFormat
        A:SimpleDateFormat(String pattern) 给定模式
            yyyy-MM-dd HH:mm:ss
        B:日期和字符串的转换
            a:Date -- String
                format()
                
            b:String -- Date
                parse()
        C:案例：
            制作了一个针对日期操作的工具类。

2:Calendar(掌握)
    (1)日历类，封装了所有的日历字段值，通过统一的方法根据传入不同的日历字段可以获取值。
    (2)如何得到一个日历对象呢?
        Calendar rightNow = Calendar.getInstance();
        本质返回的是子类对象
    (3)成员方法
        A:根据日历字段得到对应的值
        B:根据日历字段和一个正负数确定是添加还是减去对应日历字段的值
        C:设置日历对象的年月日
    (4)案例：
        计算任意一年的2月份有多少天?    

3:Math(掌握)
    (1)针对数学运算进行操作的类
    (2)常见方法(自己补齐)
        A:绝对值
        B:向上取整
        C:向下取整
        D:两个数据中的大值
        E:a的b次幂
        F:随机数
        G:四舍五入
        H:正平方根
    (3)案例：
        A:猜数字小游戏
        B:获取任意范围的随机数    

4:System(掌握)
    (1)系统类,提供了一些有用的字段和方法
    (2)成员方法(自己补齐)
        A:运行垃圾回收器
        B:退出jvm
        C:获取当前时间的毫秒值
        D:数组复制    

5:Random(理解)
    (1)用于产生随机数的类
    (2)构造方法:
        A:Random() 默认种子，每次产生的随机数不同
        B:Random(long seed) 指定种子，每次种子相同，随机数就相同
    (3)成员方法:
        A:int nextInt() 返回int范围内的随机数
        B:int nextInt(int n) 返回[0,n)范围内的随机数    

6:BigInteger(理解)
    (1)针对大整数的运算
    (2)构造方法    
        A:BigInteger(String s)
    (3)成员方法(自己补齐)
        A:加
        B:减
        C:乘
        D:除
        E:商和余数

7:BigDecimal(理解)
    (1)浮点数据做运算，会丢失精度。所以，针对浮点数据的操作建议采用BigDecimal。(金融相关的项目)
    (2)构造方法
        A:BigDecimal(String s)
    (3)成员方法：
        A:加
        B:减
        C:乘
        D:除
        E:自己保留小数几位        

8:正则表达式(理解)
    (1)就是符合一定规则的字符串
    (2)常见规则
        A:字符
            x 字符 x。举例：'a'表示字符a
            \\ 反斜线字符。
            \n 新行（换行）符 ('\u000A') 
            \r 回车符 ('\u000D')
            
        B:字符类
            [abc] a、b 或 c（简单类） 
            [^abc] 任何字符，除了 a、b 或 c（否定） 
            [a-zA-Z] a到 z 或 A到 Z，两头的字母包括在内（范围） 
            [0-9] 0到9的字符都包括
            
        C:预定义字符类
            . 任何字符。我的就是.字符本身，怎么表示呢? \.
            \d 数字：[0-9]
            \w 单词字符：[a-zA-Z_0-9]
                在正则表达式里面组成单词的东西必须有这些东西组成

        D:边界匹配器
            ^ 行的开头 
            $ 行的结尾 
            \b 单词边界
                就是不是单词字符的地方。
                举例：hello world?haha;xixi
            
        E:Greedy 数量词 
            X? X，一次或一次也没有
            X* X，零次或多次
            X+ X，一次或多次
            X{n} X，恰好 n 次 
            X{n,} X，至少 n 次 
            X{n,m} X，至少 n 次，但是不超过 m 次 
    (3)常见功能：(分别用的是谁呢?)
        A:判断功能
            String类的public boolean matches(String regex)
        B:分割功能
            String类的public String[] split(String regex)
        C:替换功能
            String类的public String replaceAll(String regex,String replacement)
        D:获取功能
            Pattern和Matcher
                Pattern p = Pattern.compile("a*b");
                Matcher m = p.matcher("aaaaab");
                
                find():查找存不存在
                group():获取刚才查找过的数据
    (4)案例
        A:判断电话号码和邮箱
        B:按照不同的规则分割数据
        C:把论坛中的数字替换为*
        D:获取字符串中由3个字符组成的单词

9:Integer(掌握)
    (1)为了让基本类型的数据进行更多的操作，Java就为每种基本类型提供了对应的包装类类型
        byte         Byte
        short        Short
        int            Integer
        long        Long
        float        Float
        double        Double
        char        Character
        boolean        Boolean
    (2)Integer的构造方法
        A:Integer i = new Integer(100);
        B:Integer i = new Integer("100");
            注意：这里的字符串必须是由数字字符组成
    (3)String和int的相互转换
        A:String -- int
            Integer.parseInt("100");
        B:int -- String
            String.valueOf(100);
    (4)其他的功能(了解)
        进制转换
    (5)JDK5的新特性
        自动装箱    基本类型--引用类型
        自动拆箱    引用类型--基本类型
        
        把下面的这个代码理解即可：
            Integer i = 100;
            i += 200;
    (6)面试题
        -128到127之间的数据缓冲池问题

10:Character(了解)
    (1)Character构造方法    
        Character ch = new Character('a');
    (2)要掌握的方法：(自己补齐)
        A:判断给定的字符是否是大写
        B:判断给定的字符是否是小写
        C:判断给定的字符是否是数字字符
        D:把给定的字符转成大写
        E:把给定的字符转成小写
    (3)案例：
        统计字符串中大写，小写及数字字符出现的次数        

        
***********************************day07~day09集合【Collection集合体系、迭代器、增强for、泛型, LinkedList、HashSet、LinkedHashSet, Map、可变参数、Collections、properties】******************************************    
1:对象数组(掌握)
    (1)数组既可以存储基本数据类型，也可以存储引用类型。它存储引用类型的时候的数组就叫对象数组。
    (2)案例：
        用数组存储5个学生对象，并遍历数组。

2:集合(Collection)(掌握)
    (1)集合的由来?
        我们学习的是Java -- 面向对象 -- 操作很多对象 -- 存储 -- 容器(数组和StringBuffer) -- 数组
        而数组的长度固定，所以不适合做变化的需求，Java就提供了集合供我们使用。
    (2)集合和数组的区别?
        A:长度区别
            数组固定
            集合可变
        B:内容区别
            数组可以是基本类型，也可以是引用类型
            集合只能是引用类型
        C:元素内容
            数组只能存储同一种类型
            集合可以存储不同类型(其实集合一般存储的也是同一种类型)
    (3)集合的继承体系结构?
        由于需求不同，Java就提供了不同的集合类。这多个集合类的数据结构不同，但是它们都是要提供存储和遍历功能的，
        我们把它们的共性不断的向上提取，最终就形成了集合的继承体系结构图。
        
        Collection
            |--List
                |--ArrayList
                |--Vector
                |--LinkedList
            |--Set
                |--HashSet
                |--TreeSet
    (4)Collection的功能概述(自己补齐)
        A:添加功能
        B:删除功能
        C:判断功能
        D:获取功能
        E:长度功能
        F:交集(了解)
        G:把集合转数组(了解)
    (5)Collection集合的遍历
        A:把集合转数组(了解)
        B:迭代器(集合专用方式)
    (6)迭代器
        A:是集合的获取元素的方式。
        B:是依赖于集合而存在的。
        C:迭代器的原理和源码。
            a:为什么定义为了一个接口而不是实现类?
            b:看了看迭代器的内部类实现。
    (7)Collection集合的案例(遍历方式 迭代器)
        集合的操作步骤：
            A:创建集合对象
            B:创建元素对象
            C:把元素添加到集合
            D:遍历集合
    
        A:存储字符串并遍历
            import java.util.Collection;
            import java.util.ArrayList;
            import java.util.Iterator;
            
            public class CollectionDemo {
                public static void main(String[] args) {
                    //创建集合对象
                    Collection c = new ArrayList();
                    
                    //创建并添加元素
                    c.add("hello");
                    c.add("world");
                    c.add("java");
                    
                    //遍历集合
                    Iterator it = c.iterator();
                    while(it.hasNext()) {
                        String s =(String) it.next();
                        System.out.println(s);
                    }
                }
            }
        
        B:存储自定义对象并遍历
            public class Student {
                private String name;
                private int age;
                
                public Student(){}
                
                public Student(String name,int age) {
                    this.name = name;
                    this.age = age;
                }
                
                //getXxx()/setXxx()
            }
            
            import java.util.Collection;
            import java.util.ArrayList;
            import java.util.Iterator;
            
            public class StudentDemo {
                public static void main(String[] args) {
                    //创建集合对象
                    Collection c = new ArrayList();
                    
                    //创建学生对象
                    Student s1 = new Student("林青霞",27);
                    Student s2 = new Student("风清扬",30);
                    Student s3 = new Student("刘意",30);
                    Student s4 = new Student("武鑫",25);
                    Student s5 = new Student("刘晓曲",16);
                    
                    //添加元素
                    c.add(s1);
                    c.add(s2);
                    c.add(s3);
                    c.add(s4);
                    c.add(s5);
                    
                    //遍历集合
                    Iterator it = c.iterator();
                    while(it.hasNext()) {
                        Student s = (Student)it.next();
                        System.out.println(s.getName()+"---"+s.getAge());
                    }
                }
            }

3:集合(List)(掌握)
    (1)List是Collection的子接口
        特点：有序(存储顺序和取出顺序一致)，可重复。
    (2)List的特有功能：(自己补齐)
        A:添加功能
        B:删除功能
        C:获取功能
        D:迭代器功能
        E:修改功能
    (3)List集合的特有遍历功能
        A:由size()和get()结合。
        B:代码演示
                    //创建集合对象
                    List list = new ArrayList();
                    
                    //创建并添加元素
                    list.add("hello");
                    list.add("world");
                    list.add("java");
                    
                    //遍历集合
                    Iterator it = list.iterator();
                    while(it.hasNext()) {
                        String s =(String) it.next();
                        System.out.println(s);
                    }
                    System.out.println("----------");
                    
                    for(int x=0; x                         String s =(String) list.get(x);
                        System.out.println(s);
                    }
    (4)列表迭代器的特有功能；(了解)
        可以逆向遍历，但是要先正向遍历，所以无意义，基本不使用。
    (5)并发修改异常
        A:出现的现象
            迭代器遍历集合，集合修改集合元素
        B:原因
            迭代器是依赖于集合的，而集合的改变迭代器并不知道。
        C:解决方案
            a:迭代器遍历，迭代器修改(ListIterator)
                元素添加在刚才迭代的位置
            b:集合遍历，集合修改(size()和get())
                元素添加在集合的末尾
    (6)常见数据结构
        A:栈 先进后出
        B:队列 先进先出
        C:数组 查询快，增删慢
        D:链表 查询慢，增删快
    (7)List的子类特点(面试题)
        ArrayList
            底层数据结构是数组，查询快，增删慢。
            线程不安全，效率高。
        Vector
            底层数据结构是数组，查询快，增删慢。
            线程安全，效率低。
        LinkedList
            底层数据结构是链表，查询慢，增删快。
            线程不安全，效率高。
            
        到底使用谁呢?看需求?
        分析：
            要安全吗?
                要：Vector(即使要，也不使用这个，后面再说)
                不要：ArrayList或者LinkedList
                    查询多；ArrayList
                    增删多：LinkedList
                    
        什么都不知道，就用ArrayList。
    (8)List集合的案例(遍历方式 迭代器和普通for)
        A:存储字符串并遍历
        B:存储自定义对象并遍历    

4:List的子类(掌握)
    (1)List的子类特点
        ArrayList:
            底层数据结构是数组，查询快，增删慢
            线程不安全，效率高
        Vector:
            底层数据结构是数组，查询快，增删慢
            线程安全，效率低
        LinkedList:
            底层数据结构是链表，查询慢，增删快
            线程不安全，效率高
    (2)ArrayList
        A:没有特有功能需要学习
        B:案例
            a:ArrayList存储字符串并遍历
            b:ArrayList存储自定义对象并遍历
    (3)Vector
        A:有特有功能
            a:添加
                public void addElement(E obj)        --    add()
            b:获取
                public E elementAt(int index)        --    get()
                public Enumeration elements()    --  iterator()
        B:案例
            a:Vector存储字符串并遍历
            b:Vector存储自定义对象并遍历
    (4)LinkedList
        A:有特有功能    
            a:添加
                addFirst()
                addLast()
            b:删除
                removeFirst()
                removeLast()
            c:获取
                getFirst()
                getLast()
        B:案例
            a:LinkedList存储字符串并遍历
            b:LinkedList存储自定义对象并遍历
    (5)案例：
        A:去除集合中的多个字符串的重复元素
            如果字符串的内容相同，即为重复元素
        B:去除集合中的多个自定义对象的重复元素
            如果自定义对象的成员变量值都相同，即为重复元素
        C:用LinkedList模拟一个栈数据结构的集合类，并测试。
            你要定义一个集合类，只不过内部可以使用LinkedList来实现。

5:泛型(掌握)
    (1)泛型概述
        是一种把明确类型的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型。
    (2)格式：
        <数据类型>
        注意：该数据类型只能是引用类型。
    (3)好处：
        A:把运行时期的问题提前到了编译期间
        B:避免了强制类型转换
        C:优化了程序设计，解决了黄色警告线问题，让程序更安全
    (4)泛型的前世今生
        A:泛型的由来
            Object类型作为任意类型的时候，在向下转型的时候，会隐含一个转型问题
        B:泛型类
        C:泛型方法
        D:泛型接口
        E:泛型高级通配符
            ?
            ? extends E
            ? super E
    (5)我们在哪里使用呢?
        一般是在集合中使用。
    
6:增强for循环(掌握)
    (1)是for循环的一种
    (2)格式：
        for(元素的数据类型 变量名 : 数组或者Collection集合的对象) {
            使用该变量即可，该变量其实就是数组或者集合中的元素。
        }
    (3)好处：
        简化了数组和集合的遍历
    (4)弊端
        增强for循环的目标不能为null。建议在使用前，先判断是否为null。
     
7:静态导入(了解)
    (1)可以导入到方法级别的导入
    (2)格式：
        import static 包名....类名.方法名;
    (3)注意事项：
        A:方法必须是静态的
        B:如果多个类下有同名的方法，就不好区分了，还得加上前缀。
            所以一般我们并不使用静态导入，但是一定要能够看懂。
    
8:可变参数(掌握)
    (1)如果我们在写方法的时候，参数个数不明确，就应该定义可变参数。
    (2)格式：
        修饰符 返回值类型 方法名(数据类型... 变量) {}
        
        注意：
            A:该变量其实是一个数组名
            B:如果一个方法有多个参数，并且有可变参数，可变参数必须在最后
    (3)Arrays工具类的一个方法
        asList()把数组转成集合。
        注意：这个集合的长度不能改变。

9:Set集合(理解)
    (1)Set集合的特点
        无序,唯一
    (2)HashSet集合(掌握)
        A:底层数据结构是哈希表(是一个元素为链表的数组)
        B:哈希表底层依赖两个方法：hashCode()和equals()
          执行顺序：
            首先比较哈希值是否相同
                相同：继续执行equals()方法
                    返回true：元素重复了，不添加
                    返回false：直接把元素添加到集合
                不同：就直接把元素添加到集合
        C:如何保证元素唯一性的呢?
            由hashCode()和equals()保证的
        D:开发的时候，代码非常的简单，自动生成即可。
        E:HashSet存储字符串并遍历
        F:HashSet存储自定义对象并遍历(对象的成员变量值相同即为同一个元素)
    (3)TreeSet集合
        A:底层数据结构是红黑树(是一个自平衡的二叉树)
        B:保证元素的排序方式
            a:自然排序(元素具备比较性)
                让元素所属的类实现Comparable接口
            b:比较器排序(集合具备比较性)
                让集合构造方法接收Comparator的实现类对象
        C:把我们讲过的代码看一遍即可
    (4)案例：
        A:获取无重复的随机数
        B:键盘录入学生按照总分从高到底输出
        
10:Collection集合总结(掌握)
    Collection
        |--List    有序,可重复
            |--ArrayList
                底层数据结构是数组，查询快，增删慢。
                线程不安全，效率高
            |--Vector
                底层数据结构是数组，查询快，增删慢。
                线程安全，效率低
            |--LinkedList
                底层数据结构是链表，查询慢，增删快。
                线程不安全，效率高
        |--Set    无序,唯一
            |--HashSet
                底层数据结构是哈希表。
                如何保证元素唯一性的呢?
                    依赖两个方法：hashCode()和equals()
                    开发中自动生成这两个方法即可
                |--LinkedHashSet
                    底层数据结构是链表和哈希表
                    由链表保证元素有序
                    由哈希表保证元素唯一
            |--TreeSet
                底层数据结构是红黑树。
                如何保证元素排序的呢?
                    自然排序
                    比较器排序
                如何保证元素唯一性的呢?
                    根据比较的返回值是否是0来决定
                    
11:针对Collection集合我们到底使用谁呢?(掌握)
    唯一吗?
        是：Set
            排序吗?
                是：TreeSet
                否：HashSet
        如果你知道是Set，但是不知道是哪个Set，就用HashSet。
            
        否：List
            要安全吗?
                是：Vector
                否：ArrayList或者LinkedList
                    查询多：ArrayList
                    增删多：LinkedList
        如果你知道是List，但是不知道是哪个List，就用ArrayList。
    
    如果你知道是Collection集合，但是不知道使用谁，就用ArrayList。
    
    如果你知道用集合，就用ArrayList。
    
12:在集合中常见的数据结构(掌握)
    ArrayXxx:底层数据结构是数组，查询快，增删慢
    LinkedXxx:底层数据结构是链表，查询慢，增删快
    HashXxx:底层数据结构是哈希表。依赖两个方法：hashCode()和equals()
    TreeXxx:底层数据结构是二叉树。两种方式排序：自然排序和比较器排序
    
13:Map(掌握)
    (1)将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。 
    (2)Map和Collection的区别?
        A:Map 存储的是键值对形式的元素，键唯一，值可以重复。夫妻对
        B:Collection 存储的是单独出现的元素，子接口Set元素唯一，子接口List元素可重复。光棍
    (3)Map接口功能概述(自己补齐)
        A:添加功能
        B:删除功能
        C:判断功能
        D:获取功能
        E:长度功能
    (4)Map集合的遍历
        A:键找值
            a:获取所有键的集合
            b:遍历键的集合,得到每一个键
            c:根据键到集合中去找值
        
        B:键值对对象找键和值
            a:获取所有的键值对对象的集合
            b:遍历键值对对象的集合，获取每一个键值对对象
            c:根据键值对对象去获取键和值
            
        代码体现：
            Map hm = new HashMap();
            
            hm.put("it002","hello");
            hm.put("it003","world");
            hm.put("it001","java");
            
            //方式1 键找值
            Set set = hm.keySet();
            for(String key : set) {
                String value = hm.get(key);
                System.out.println(key+"---"+value);
            }
            
            //方式2 键值对对象找键和值
            Set> set2 = hm.entrySet();
            for(Map.Entry me : set2) {
                String key = me.getKey();
                String value = me.getValue();
                System.out.println(key+"---"+value);
            }
    (5)HashMap集合的练习
        A:HashMap
        B:HashMap
        C:HashMap
        D:HashMap
    (6)TreeMap集合的练习        
        A:TreeMap
        B:TreeMap
    (7)案例
        A:统计一个字符串中每个字符出现的次数
        B:集合的嵌套遍历
            a:HashMap嵌套HashMap
            b:HashMap嵌套ArrayList
            c:ArrayList嵌套HashMap
            d:多层嵌套
            
14:Collections(理解)    
    (1)是针对集合进行操作的工具类
    (2)面试题：Collection和Collections的区别
        A:Collection 是单列集合的顶层接口，有两个子接口List和Set
        B:Collections 是针对集合进行操作的工具类，可以对集合进行排序和查找等
    (3)常见的几个小方法：
        A:public static void sort(List list)
        B:public static int binarySearch(List list,T key)
        C:public static T max(Collection coll)
        D:public static void reverse(List list)
        E:public static void shuffle(List list)
    (4)案例
        A:ArrayList集合存储自定义对象的排序
        B:模拟斗地主洗牌和发牌
        C:模拟斗地主洗牌和发牌并对牌进行排序

***********************************day10~day12 IO【File、递归】、IO【编码表、字节流、字节缓冲流】、IO【转换流、序列化流、打印流、commons-io】******************************************    
1:File(掌握)
    (1)IO流操作中大部分都是对文件的操作，所以Java就提供了File类供我们来操作文件
    (2)构造方法
        A:File file = new File("e:\\demo\\a.txt");
        B:File file = new File("e:\\demo","a.txt");
        C:File file = new File("e:\\demo");
          File file2 = new File(file,"a.txt");
    (3)File类的功能(自己补齐)
        A:创建功能
        B:删除功能
        C:重命名功能
        D:判断功能
        E:获取功能
        F:高级获取功能
        G:过滤器功能
    (4)案例：
        A:输出指定目录下指定后缀名的文件名称
            a:先获取所有的，在遍历的时候判断，再输出
            b:先判断，再获取，最后直接遍历输出即可
        B:批量修改文件名称    
        
2:递归(理解)
    (1)方法定义中调用方法本身的现象
        举例：老和尚给小和尚讲故事，我们学编程
    (2)递归的注意事项；
        A:要有出口，否则就是死递归
        B:次数不能过多，否则内存溢出
        C:构造方法不能递归使用
    (3)递归的案例：
        A:递归求阶乘
        B:兔子问题
        C:递归输出指定目录下所有指定后缀名的文件绝对路径
        D:递归删除带内容的目录(小心使用)

3:IO流(掌握)
    (1)IO用于在设备间进行数据传输的操作    
    (2)分类：
        A:流向
            输入流    读取数据
            输出流    写出数据
        B:数据类型
            字节流    
                    字节输入流
                    字节输出流
            字符流
                    字符输入流
                    字符输出流
        注意：
            a:如果我们没有明确说明按照什么分，默认按照数据类型分。
            b:除非文件用windows自带的记事本打开我们能够读懂，才采用字符流，否则建议使用字节流。
    (3)FileOutputStream写出数据
        A:操作步骤
            a:创建字节输出流对象
            b:调用write()方法
            c:释放资源
            
        B:代码体现：
            FileOutputStream fos = new FileOutputStream("fos.txt");
            
            fos.write("hello".getBytes());
            
            fos.close();
            
        C:要注意的问题?
            a:创建字节输出流对象做了几件事情?
            b:为什么要close()?
            c:如何实现数据的换行?
            d:如何实现数据的追加写入?
    (4)FileInputStream读取数据
        A:操作步骤
            a:创建字节输入流对象
            b:调用read()方法
            c:释放资源
            
        B:代码体现：
            FileInputStream fis = new FileInputStream("fos.txt");
            
            //方式1
            int by = 0;
            while((by=fis.read())!=-1) {
                System.out.print((char)by);
            }
            
            //方式2
            byte[] bys = new byte[1024];
            int len = 0;
            while((len=fis.read(bys))!=-1) {
                System.out.print(new String(bys,0,len));
            }
            
            fis.close();
    (5)案例：2种实现
        A:复制文本文件
        B:复制图片
        C:复制视频
    (6)字节缓冲区流
        A:BufferedOutputStream
        B:BufferedInputStream
    (7)案例：4种实现
        A:复制文本文件
        B:复制图片
        C:复制视频
        
4:自学字符流
    IO流分类
        字节流：
            InputStream
                FileInputStream
                BufferedInputStream
            OutputStream
                FileOutputStream
                BufferedOutputStream
        
        字符流：
            Reader
                FileReader
                BufferedReader
            Writer
                FileWriter
                BufferedWriter
                
5:字符流(掌握)
    (1)字节流操作中文数据不是特别的方便，所以就出现了转换流。
       转换流的作用就是把字节流转换字符流来使用。
    (2)转换流其实是一个字符流
        字符流 = 字节流 + 编码表
    (3)编码表
        A:就是由字符和对应的数值组成的一张表
        B:常见的编码表
            ASCII
            ISO-8859-1
            GB2312
            GBK
            GB18030
            UTF-8
        C:字符串中的编码问题
            编码
                String -- byte[]
            解码
                byte[] -- String
    (4)IO流中的编码问题
        A:OutputStreamWriter
            OutputStreamWriter(OutputStream os):默认编码，GBK
            OutputStreamWriter(OutputStream os,String charsetName):指定编码。
        B:InputStreamReader
            InputStreamReader(InputStream is):默认编码，GBK
            InputStreamReader(InputStream is,String charsetName):指定编码
        C:编码问题其实很简单
            编码只要一致即可
    (5)字符流
        Reader
            |--InputStreamReader
                |--FileReader
            |--BufferedReader
        Writer
            |--OutputStreamWriter
                |--FileWriter
            |--BufferedWriter
    (6)复制文本文件(5种方式)

6:IO流小结(掌握)
    IO流
        |--字节流
            |--字节输入流
                InputStream
                    int read():一次读取一个字节
                    int read(byte[] bys):一次读取一个字节数组
                
                    |--FileInputStream
                    |--BufferedInputStream
            |--字节输出流
                OutputStream
                    void write(int by):一次写一个字节
                    void write(byte[] bys,int index,int len):一次写一个字节数组的一部分
                    
                    |--FileOutputStream
                    |--BufferedOutputStream
        |--字符流
            |--字符输入流
                Reader
                    int read():一次读取一个字符
                    int read(char[] chs):一次读取一个字符数组
                    
                    |--InputStreamReader
                        |--FileReader
                    |--BufferedReader
                        String readLine():一次读取一个字符串
            |--字符输出流
                Writer
                    void write(int ch):一次写一个字符
                    void write(char[] chs,int index,int len):一次写一个字符数组的一部分
                    
                    |--OutputStreamWriter
                        |--FileWriter
                    |--BufferedWriter
                        void newLine():写一个换行符
                        
                        void write(String line):一次写一个字符串

7:案例(理解 练习一遍)
    A:复制文本文件 5种方式(掌握)
    B:复制图片(二进制流数据) 4种方式(掌握)
    C:把集合中的数据存储到文本文件
    D:把文本文件中的数据读取到集合并遍历集合
    E:复制单级文件夹
    F:复制单级文件夹中指定的文件并修改名称
        回顾一下批量修改名称
    G:复制多级文件夹
    H:键盘录入学生信息按照总分从高到低存储到文本文件
    I:把某个文件中的字符串排序后输出到另一个文本文件中
    J:用Reader模拟BufferedReader的特有功能
    K:模拟LineNumberReader的特有功能    

8:登录注册IO版本案例(掌握)
    要求，对着写一遍。
    
    cn.itcast.pojo User
    cn.itcast.dao UserDao
    cn.itcast.dao.impl UserDaoImpl(实现我不管)
    cn.itcast.game GuessNumber
    cn.itcast.test    UserTest

9:数据操作流(操作基本类型数据的流)(理解)
    (1)可以操作基本类型的数据
    (2)流对象名称    
        DataInputStream
        DataOutputStream

10:内存操作流(理解)
    (1)有些时候我们操作完毕后，未必需要产生一个文件，就可以使用内存操作流。
    (2)三种
        A:ByteArrayInputStream,ByteArrayOutputStream
        B:CharArrayReader,CharArrayWriter
        C:StringReader,StringWriter

11:打印流(掌握)
    (1)字节打印流，字符打印流
    (2)特点：
        A:只操作目的地,不操作数据源
        B:可以操作任意类型的数据
        C:如果启用了自动刷新，在调用println()方法的时候，能够换行并刷新
        D:可以直接操作文件
            问题：哪些流可以直接操作文件呢?
            看API，如果其构造方法能够同时接收File和String类型的参数，一般都是可以直接操作文件的
    (3)复制文本文件
        BufferedReader br = new BufferedReader(new FileReader("a.txt"));
        PrintWriter pw = new PrintWriter(new FileWriter("b.txt"),true);
        
        String line = null;
        while((line=br.readLine())!=null) {
            pw.println(line);
        }
        
        pw.close();
        br.close();
            
12:标准输入输出流(理解)
    (1)System类下面有这样的两个字段
        in 标准输入流
        out 标准输出流
    (2)三种键盘录入方式
        A:main方法的args接收参数
        B:System.in通过BufferedReader进行包装
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        C:Scanner
            Scanner sc = new Scanner(System.in);
    (3)输出语句的原理和如何使用字符流输出数据
        A:原理
            System.out.println("helloworld");
            
            PrintStream ps = System.out;
            ps.println("helloworld");
        B:把System.out用字符缓冲流包装一下使用
            BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

13:随机访问流(理解)
    (1)可以按照文件指针的位置写数据和读数据。
    (2)案例：
        A:写数据
        B:读数据
        C:获取和改变文件指针的位置

14:合并流(理解)
    (1)把多个输入流的数据写到一个输出流中。
    (2)构造方法：
        A:SequenceInputStream(InputStream s1, InputStream s2) 
        B:SequenceInputStream(Enumeration e) 

15:序列化流(理解)
    (1)可以把对象写入文本文件或者在网络中传输
    (2)如何实现序列化呢?
        让被序列化的对象所属类实现序列化接口。
        该接口是一个标记接口。没有功能需要实现。
    (3)注意问题：
        把数据写到文件后，在去修改类会产生一个问题。
        如何解决该问题呢?
            在类文件中，给出一个固定的序列化id值。
            而且，这样也可以解决黄色警告线问题
    (4)面试题：
        什么时候序列化?
        如何实现序列化?
        什么是反序列化?

16:Properties(理解)
    (1)是一个集合类，Hashtable的子类
    (2)特有功能
        A:public Object setProperty(String key,String value)
        B:public String getProperty(String key)
        C:public Set stringPropertyNames()
    (3)和IO流结合的方法
        把键值对形式的文本文件内容加载到集合中
        public void load(Reader reader)
        public void load(InputStream inStream)

        把集合中的数据存储到文本文件中
        public void store(Writer writer,String comments)
        public void store(OutputStream out,String comments)
    (4)案例：
        A:根据给定的文件判断是否有键为"lisi"的，如果有就修改其值为100
        B:写一个程序实现控制猜数字小游戏程序不能玩超过5次

17:NIO(了解)
    (1)JDK4出现的NIO，对以前的IO操作进行了优化，提供了效率。但是大部分我们看到的还是以前的IO
    (2)JDK7的NIO的使用    
        Path:路径
        Paths:通过静态方法返回一个路径
        Files:提供了常见的功能
            复制文本文件
            把集合中的数据写到文本文件    
            

***********************************day13_多线程【Thread、线程创建、synchronized、线程生命周期】******************************************    
1:多线程(理解)
    (1)多线程：一个应用程序有多条执行路径
        进程：正在执行的应用程序
        线程：进程的执行单元，执行路径
        单线程：一个应用程序只有一条执行路径
        多线程：一个应用程序有多条执行路径
        
        多进程的意义?
            提高CPU的使用率
        多线程的意义?
            提高应用程序的使用率
    (2)Java程序的运行原理及JVM的启动是多线程的吗?
        A:Java命令去启动JVM，JVM会启动一个进程，该进程会启动一个主线程。
        B:JVM的启动是多线程的，因为它最低有两个线程启动了，主线程和垃圾回收线程。
    (3)多线程的实现方案(自己补齐步骤及代码    掌握)
        A:继承Thread类
        B:实现Runnable接口
    (4)线程的调度和优先级问题
        A:线程的调度
            a:分时调度
            b:抢占式调度 (Java采用的是该调度方式)
        B:获取和设置线程优先级
            a:默认是5
            b:范围是1-10
    (5)线程的控制(常见方法)
        A:休眠线程
        B:加入线程
        C:礼让线程
        D:后台线程
        E:终止线程(掌握)
    (6)线程的生命周期(参照    线程生命周期图解.bmp)
        A:新建
        B:就绪
        C:运行
        D:阻塞
        E:死亡
    (7)电影院卖票程序的实现
        A:继承Thread类
        B:实现Runnable接口
    (8)电影院卖票程序出问题
        A:为了更符合真实的场景，加入了休眠100毫秒。
        B:卖票问题
            a:同票多次
            b:负数票
    (9)多线程安全问题的原因(也是我们以后判断一个程序是否有线程安全问题的依据)
        A:是否有多线程环境
        B:是否有共享数据
        C:是否有多条语句操作共享数据
    (10)同步解决线程安全问题
        A:同步代码块
            synchronized(对象) {
                需要被同步的代码;
            }
            
            这里的锁对象可以是任意对象。
            
        B:同步方法
            把同步加在方法上。
            
            这里的锁对象是this
            
        C:静态同步方法
            把同步加在方法上。
            
            这里的锁对象是当前类的字节码文件对象(反射再讲字节码文件对象)
    (11)回顾以前的线程安全的类
        A:StringBuffer
        B:Vector
        C:Hashtable
        D:如何把一个线程不安全的集合类变成一个线程安全的集合类
            用Collections工具类的方法即可。

3:多线程(理解)
    (1)JDK5以后的针对线程的锁定操作和释放操作
        Lock锁
    (2)死锁问题的描述和代码体现
    (3)生产者和消费者多线程体现(线程间通信问题)
        以学生作为资源来实现的
        
        资源类：Student
        设置数据类：SetThread(生产者)
        获取数据类：GetThread(消费者)
        测试类：StudentDemo
        
        代码：
            A:最基本的版本，只有一个数据。
            B:改进版本，给出了不同的数据，并加入了同步机制
            C:等待唤醒机制改进该程序，让数据能够实现依次的出现
                wait()
                notify()
                notifyAll() (多生产多消费)
            D:等待唤醒机制的代码优化。把数据及操作都写在了资源类中
    (4)线程组
    (5)线程池
    (6)多线程实现的第三种方案
    (7)多线程的面试题

4:设计模式(理解)
    (1)面试对象的常见设计原则
        单一
        开闭
        里氏
        依赖注入
        接口
        迪米特
    (2)设计模式概述和分类
        A:经验的总结
        B:三类
            创建型
            结构型
            行为型
    (3)改进的设计模式
        A:简单工厂模式
        B:工厂方法模式
        C:单例模式(掌握)
            a:饿汉式
            b:懒汉式
    (4)Runtime
        JDK提供的一个单例模式应用的类。
        还可以调用dos命令。
            
            
***********************************day14_网络编程【Socket网络编程】******************************************    
1:网络编程(理解)
    (1)网络编程：用Java语言实现计算机间数据的信息传递和资源共享
    (2)网络编程模型
    (3)网络编程的三要素
        A:IP地址
            a:点分十进制
            b:IP地址的组成
            c:IP地址的分类
            d:dos命令
            e:InetAddress
        B:端口
            是应用程序的标识。范围：0-65535。其中0-1024不建议使用。
        C:协议
            UDP:数据打包,有限制,不连接,效率高,不可靠
            TCP:建立数据通道,无限制,效率低,可靠
    (3)Socket机制
        A:通信两端都应该有Socket对象
        B:所有的通信都是通过Socket间的IO进行操作的
    (4)UDP协议发送和接收数据(掌握 自己补齐代码)
        发送：
            创建UDP发送端的Socket对象
            创建数据并把数据打包
            发送数据
            释放资源
            
        接收：
            创建UDP接收端的Socket对象
            创建数据包用于接收数据
            接收数据
            解析数据包
            释放资源
    (5)TCP协议发送和接收数据(掌握 自己补齐代码)
        发送：
            创建TCP客户端的Socket对象
            获取输出流，写数据
            释放资源
            
        接收：
            创建TCP服务器端的Socket对象
            监听客户端连接
            获取输入流，读取数据
            释放资源
    (6)案例：
        A:UDP
            a:最基本的UDP协议发送和接收数据
            b:把发送数据改进为键盘录入
            c:一个简易聊天小程序并用多线程改进
        B:TCP
            a:最基本的TCP协议发送和接收数据
            b:服务器给出反馈
            c:客户端键盘录入服务器控制台输出
            d:客户端键盘录入服务器写到文本文件
            e:客户端读取文本文件服务器控制台输出
            f:客户端读取文本文件服务器写到文本文件
            g:上传图片
            h:多线程改进上传文件
            
            
***********************************day15_基础加强【xml】******************************************    
XML的学习目标：
能用XML描述现实中的有层次关系的数据
能使用程序读取到XML中表示的数据（解析Parser）

一、XML是什么？作用是什么？
    1、XML是指可扩展标记语言（eXtensible Markup Language），用户自定义的标签.相对于HTML来讲的。
    2、XML被设计的宗旨是表示数据。HTML是用来显示数据的。目前经常使用的XML版本是1.0
    3、XML除了表示数据外。在实际的企业开发中，主要用XML作为程序的配置文件。

二、XML的基本语法
    1、文档声明：
        作用：用于标识该文档是一个XML文档。不能有，也不能有任何的注释）
        注意事项：声明必须出现在文档的第一行（之前连空行都

        最简单的XML声明：
        声明中的encoding属性：说明解析当前XML文档时所使用的编码。默认是UTF-8
        声明中的standalone属性：说明XML文档是否是独立的。（了解）

    2、元素
        结束标签不能省略
        一个XML文档必须且只能有一个根标签
        XML文档中不会忽略回车和换行及空格
        标签的命名规范：元素(标签)的名称可以包含字母、数字、减号、下划线和英文句点。严格区分大小写。

    3、元素的属性
        元素的属性取值一定要用引号引起来（单引号或双引号）

    4、注释
        与HTML中的注释完全一致：
        注释不能嵌套

    5、CDATA区
        CDATA是Character Data的缩写。
        作用：CDATA区中的东东都是文本。
        语法：
                         
                    文本内容
                    
                    ]]>
    6、特殊字符
        &        &
        <        <   (less than)
        >        >:    (great than)
        "        "
        '        '

    7、处理指令(PI:Processing Instruction)
        处理指令，简称PI(Processing Instruction)。
        作用：用来指挥软件如何解析XML文档。
        语法：必须以“”作为结尾。

三、XML的约束
    1、格式良好的XML文档：符合XML语法的。
    2、有效的XML文档：遵循约束规范的。
    格式良好的不一定是有效的，但有效的必定格式良好。

四、DTD的基本语法（看懂即可）
    1、DTD：Document Type Definition
    2、作用：约束XML的书写规范。
    3、DTD文件保存到磁盘时，必须使用UTF-8编码

    4、如何引入外部的DTD文档来约束当前的XML文档
    DTD文件在本地：
    DTD文件在网络上：

5、DTD的语法细节
    5.1定义元素
        语法：
        使用规则：
            (#PCDATA):指示元素的主体内容只能是普通的文本.(Parsed Character Data)
            EMPTY:指示元素的不能有主体内容。
            ANY:用于指示元素的主体内容为任意类型
            (子元素)：指示元素中包含的子元素
                    如果子元素用逗号分开，说明必须按照声明顺序去编写XML文档
                    如果子元素用“|”分开，说明任选其一。
                    用+、*、？来表示元素出现的次数
    5.2定义元素的属性(attribute)
        语法：                         属性名1 属性值类型 设置说明
                        属性名2 属性值类型 设置说明>
            属性值类型：
                CDATA：说明该属性的取值为一个普通文本
                ENUMERATED (DTD没有此关键字)：
                    语法：
                ID:属性的取值不能重复
            设置说明：
                #REQUIRED：表示该属性必须出现
                #IMPLIED：属性可有可无
                #FIXED:表示属性的取值为一个固定值 语法：#FIXED "固定值"
                直接值：表示属性的取值为该默认值
    5.3定义实体
        关键字ENTITY
        实体的定义分为引用实体和参数实体
        引用实体：
            作用：在DTD中定义，在XML中使用
            语法：
            在XML中使用：&实体名称;
        参数实体：
            作用：在DTD中定义，在DTD中使用
            语法：
            在DTD中使用：%实体名称;
    
                    
五、XML解析方式概述
    1、常用XML的解析方式：DOM和SAX
        DOM:Document Object Model是W3C推荐使用的解析方式
        SAX:Simple API for XML。非官方标准。
    2、常用解析开发包：
        JAXP:SUN推出的实现，能进行DOM和SAX方式解析
        Dom4J
        JDom等

六、JAXP进行DOM解析
    JAXP的API都在JavaSE中。
    org.w3c.dom:提供DOM方式解析XML的标准接口
    org.xml.sax:提供SAX方式解析XML的标准接口
    javax.xml:提供了解析XML文档的类

七、Schema约束(看懂即可)
    1、Schema约束文档本身就是一个XML文档，扩展名为xsd
    2、重点：根据Schema写出XML文档
        难点：XML文档的根元素怎么写？

    a、首先看Schema文档，找到根元素
        
        <书架>
    b、思考：书架来自于哪个名称空间？看Schema文档，targetNamespace就是名称空间。
        用xmlns关键字(xmlns名称空间声明)来声明我的元素来自哪个名称空间（xmlns：xml namespace）

        
        

    c、思考：名称空间与哪个xsd文件对应呢？使用schemaLocation关键字来关联名称空间和xsd的对应关系

        
                             schemaLocation="http://www.itcast.cn book.xsd">

    d、schemaLocation来自哪里？来自一个标准的名称空间（http://www.w3.org/2001/XMLSchema-instance）
        
                             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                    xsi:schemaLocation="http://www.itcast.cn book.xsd">
                

***********************************day16_基础加强【反射、BeanUtils】******************************************    
1:反射(理解)
    (1)类的加载及类加载器
    (2)反射：
        通过字节码文件对象，去使用成员变量，构造方法，成员方法
    (3)反射的使用
        A:通过反射获取构造方法并使用
        B:通过反射获取成员变量并使用
        C:通过反射获取成员方法并使用
    (4)反射案例
        A:通过反射运行配置文件的内容
        B:通过反射越过泛型检查
        C:通过反射给任意的一个对象的任意的属性赋值为指定的值
    (5)动态代理
    
2:设计模式
    (1)装饰设计模式
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        
        Scanner sc = new Scanner(System.in);
    (2)模版设计模式
        
3:JDK新特性
    (1)JDK5(掌握)
        装箱和拆箱
        泛型
        增强for
        静态导入
        可变参数
        枚举
    (2)JDK6(了解)
    (3)JDK7(理解)
        二进制的表现形式
        用_分隔数据
        switch语句可是用字符串
        泛型推断(菱形泛型)
        多catch的使用
        自动释放资源的用法
    (4)JDK8(了解)
        可以去网上了解资料

***********************************day17~19_数据库【sql语句&mysql单表】、数据库【mysql多表】、数据库【mysql多表查询】******************************************    
一、SQL简介
    1、SQL：Structured Query Language结构化查询语言
        他是客户与数据库打交道的通道
    2、SQL是有工业标准的。ANSI
        符合工业标准的SQL，称之为普通话。
        不同的数据库都在SQL工业标准的基础上进行扩展，扩展的部分称之为方言。
    3、验证安装是否成功
        shell>mysql -u root -p
        mysql>SHOW DATABASES;        //显示目前有几个库

二、DDL：数据定义语言 Data Definition Language
    作用：定义数据库或者表结构的。
    操作的对象：数据库或表的结构的。
    关键字：CREATE ALTER DROP
    
    创建一个名称为mydb1的数据库。
        mysql>CREATE DATABASE mydb1;
    查看数据库的创建细节
        mysql>SHOW CREATE DATABASE mydb1;
    创建一个使用gbk字符集的mydb2数据库。
        mysql>CREATE DATABASE mydb2 CHARACTER SET gbk;
    创建一个使用gbk字符集，并带校对规则的mydb3数据库。
        mysql>CREATE DATABASE mydb3 CHARACTER SET gbk COLLATE gbk_chinese_ci;
    查看当前数据库服务器中的所有数据库
        mysql>SHOW DATABASES;
    查看前面创建的mydb2数据库的定义信息
        mysql>SHOW CREATE DATABASE mydb1;
    删除前面创建的mydb3数据库
        mysql>DROP DATABASE mydb3;

    创建表之前一定先选择数据库
        mysql>USE test;
    创建一个员工表
        mysql>CREATE TABLE employee(
            id int,
            name varchar(200),
            gender varchar(10),
            birthday date,
            entry_date date,
            job varchar(200),
            salary float(8,2),
            resume text
        );
    显示当前数据库中的所有表格
        mysql>SHOW TABLES;
    在上面员工表的基本上增加一个image列。
        mysql>ALTER TABLE employee ADD image blob;
    查看表结构的定义
        mysql>DESC employee;
    修改job列，使其长度为60。
        mysql>ALTER TABLE employee MODIFY job varchar(60);
    删除image列。
        mysql>ALTER TABLE employee DROP image;
    表名改为user。
        mysql>RENAME TABLE employee TO user;
    查看表的创建细节
        mysql>SHOW CREATE TABLE user;
    修改表的字符集为gbk
        mysql>ALTER TABLE user CHARACTER SET gbk;
    列名name修改为username
        mysql>ALTER TABLE user CHANGE name username varchar(100);
        
三、DML:Data Manipulation Language 数据操作语言
        作用：操作表中的数据的。
        关键：INSERT UPDATE DELETE
    
    特别注意：日期或字符串、字符要使用单引号引起来。

    查看表中的所有记录
        mysql>SELECT * FROM user;
    使用insert语句向表中插入三个员工的信息。
    建议：  mysql>INSERT INTO user (id,username,gender,birthday,entry_date,job,salary,resume) VALUES (1,'zql','0','1991-09-07','2013-04-12','CTO',10000.00,'beauty');
            mysql>INSERT INTO user VALUES (2,'gfy','1','1987-09-07','2013-04-12','CEO',10000.00,'hand');
            mysql>INSERT INTO user (id,username,gender,birthday,entry_date,job,salary,resume) VALUES (3,'王翔云','1','1989-09-07','2013-04-12','UFO',10000.00,'good boy');

    插入中文时的问题：（编码问题）
        查看数据库目前的各种编码：
        mysql>SHOW VARIABLES LIKE 'character%';
    通知服务器客户端使用的编码字符集
        mysql>SET character_set_client=gbk;
    显示时乱码
        mysql>SET character_set_results=gbk;

    将所有员工薪水修改为5000元。
        mysql>UPDATE user SET salary=5000;
    将姓名为’王翔云’的员工薪水修改为3000元。
        mysql>UPDATE user SET salary=3000 WHERE username='王翔云';
    将姓名为’王翔云’的员工薪水修改为4000元,job改为CMO。
        mysql>UPDATE user SET salary=4000,job='CMO' WHERE username='王翔云';
    将zql的薪水在原有基础上增加1000元。    
        mysql>UPDATE user SET salary=salary+1000 WHERE username='zql';

    删除表中名称为’王翔云’的记录。
        mysql>DELETE FROM user WHERE username='王翔云';
    删除表中所有记录。
        mysql>DELETE FROM user;(一条一条的删除)
    使用TRUNCATE删除表中记录。
        mysql>TRUNCATE user;(摧毁整张表，然后重建表结构)

四、DQL简单的：Data Query Language
    关键字：SELECT

    查询表中所有学生的信息。
        mysql>SELECT * FROM student;(不建议使用)
        mysql>SELECT id,name,chinese,english,math FROM student;
    查询表中所有学生的姓名和对应的英语成绩。
        mysql>SELECT name,english FROM student;
    过滤表中重复数据。
        mysql>SELECT DISTINCT english FROM student;

    SELECT语句支持一些基本的运算

    在所有学生数学分数上加10分特长分。
        mysql>SELECT id,name,math+10 FROM student;
    统计每个学生的总分。
        mysql>SELECT name,chinese+english+math FROM student;
    使用别名表示学生分数。
        mysql>SELECT name AS 姓名,chinese+english+math 总分 FROM student;
    查询姓名为王五的学生成绩
        msyql>SELECT name,english,chinese,math FROM student WHERE name='王五';
    查询英语成绩大于90分的同学
        msyql>SELECT name,english,chinese,math FROM student WHERE english>90;
    查询总分大于200分的所有同学
        mysql>SELECT name,chinese+english+math FROM student WHERE (chinese+english+math)>200;

    WHERE语句支持运算表达式

    查询英语分数在 80－90之间的同学。
        mysql>SELECT * FROM student WHERE english BETWEEN 84 AND 85;
    查询数学分数为89,90,91的同学。
        mysql>SELECT * FROM student WHERE math IN (89,90,91);
    查询所有姓李的学生成绩。
        mysql>SELECT * FROM student WHERE name LIKE '李%';
    查询数学分>80，语文分>80的同学。
        mysql>SELECT * FROM student WHERE math>80 AND chinese>80;
    对数学成绩排序后输出。
        mysql>SELECT * FROM student ORDER BY math;//默认是升序
    对总分排序后输出，然后再按从高到低的顺序输出
        mysql>SELECT name,chinese+english+math FROM student ORDER BY (chinese+english+math) DESC;
    对姓李的学生数学成绩排序输出
        mysql>SELECT name,math FROM student WHERE name LIKE '李%' ORDER BY math;

五、数据完整性
    三个方面：
        1、实体完整性：规定表中的一行在表中是唯一的实体。
        一般是通过定义主键的形式来实现的。
        关键字：PRIMARY KEY
        特点：不能为null，必须唯一
        
        CREATE TABLE SHANG_HAI1(
            id int PRIMARY KEY,
            name varchar(100)
        );
        //实际开发中不建议使用。
        CREATE TABLE shanghai2(
            id int PRIMARY KEY auto_increment,
            name varchar(100)
        );
        insert into shanghai2 (name) values('aa');
        2、域完整性
        指数据库表的列（即字段）必须符合某种特定的数据类型或约束。
        NOT NULL：不能为空
        UNIQUE：必须唯一
        CREATE TABLE shanghai3(
            id int PRIMARY KEY,
            name varchar(100) NOT NULL,
            idnum varchar(100) unique
        );
        
        关于主键：
            （建议）逻辑主键：给编程人员用的。与具体业务无关
            业务主键：用户也可以用。与具体业务有关了。
        
        3、参照完整性（多表设计）    
            一对多
            create table department(
                id int primary key,
                name varchar(100)
            );
            create table employee(
                id int primary key,
                name varchar(100),
                salary float(8,2),
                dept_id int,
                constraint dept_id_fk foreign key(dept_id) references department(id)
            );
            
            多对多
            create table teacher(
                id int primary key,
                name varchar(100),
                salary float(8,2)
            );
            create table student1(
                id int primary key,
                name varchar(100),
                grade varchar(10)
            );
            create table teacher_student1(
                t_id int,
                s_id int,
                primary key(t_id,s_id),
                constraint t_id_fk foreign key(t_id) references teacher(id),
                constraint s_id_fk foreign key(s_id) references student1(id)
            );
            
            一对一
            create table human(
                id int primary key,
                name varchar(100)
            );
            create table idcard(
                id int primary key,
                num varchar(100),
                constraint huanm_id_fk foreign key(id) references human(id)
            );

六、表的复杂查询
    1、连接查询
        1.0连接的基本语法格式：
            from TABLE1 join_type TABLE2 [on (join_condition)][where (query_condition)]
            TABLE1:左表
            TABLE2：右表
            join_type：连接的类型。交叉、内连接、左外连接、右外连接
            on：设置连接条件
            where：对连接查询的结果进步一的筛选
        1.1交叉连接
            select * from CUSTOMER cross join ORDERS;
            或者
            select * from CUSTOMER,ORDERS;
            
            select c.name,o.order_number from CUSTOMER c,ORDERS o;
        1.2内连接：
            隐式内连接：(不使用on关键字，使用where)
                select * from CUSTOMER c,ORDERS o where c.id=o.customer_id;
            显式内连接：(使用on关键字)
                select * from CUSTOMER c inner join ORDERS o on c.id=o.customer_id;
        1.3外连接：
            左外连接：(返回符合连接条件的所有记录，同时还返回左表中其余的所有记录)
                select * from CUSTOMER c left outer join ORDERS o on c.id=o.customer_id;
            右外连接：(返回符合连接条件的所有记录，同时还返回右表中其余的所有记录)
                select * from CUSTOMER c right outer join ORDERS o on c.id=o.customer_id;
    2、子查询（嵌套查询）
        查询“陈冠希”的所有订单信息
        查询“陈冠希”的客户id select id from customer where name='陈冠希';
        查询订单信息：  select * from orders where customer_id=1;
        
        子查询： select * from orders where customer_id=(select id from customer where name='陈冠希');
    3、联合查询
        SELECT * FROM orders WHERE price>200 UNION SELECT * FROM orders WHERE customer_id=1;
        取两条语句的并集，并去除重复的记录。
    4、报表查询（合计函数）（使用原来的test数据库）
        
        统计一个班级共有多少学生？
        select count(*) from student;
        统计数学成绩大于90的学生有多少个？
        select count(*) from student where math>=90;
        统计总分大于250的人数有多少？
        select count(*) from student where (chinese+math+english)>250;
        
        统计一个班级数学总成绩？
        select sum(math) from student;
        统计一个班级语文、英语、数学各科的总成绩
        select sum(chinese),sum(english),sum(math) from student;
        统计一个班级语文、英语、数学的成绩总和
        select sum(chinese+english+math) from student;
        统计一个班级语文成绩平均分
        select sum(chinese)/count(*) from student;
        求一个班级数学平均分？
        select avg(math) from student;
        求一个班级总分平均分
        select avg(chinese+english+math) from student;

    Tips:如果要使用关键字作为表名，要使用`(Esc按键下面的)包围起来。
            对订单表中商品归类后，显示每一类商品的总价
            select product,sum(price) from orders group by product;
            查询购买了几类商品，并且每类总价大于100的商品
            select product,sum(price) from orders group by product having sum(price)>100;
            
七、MySQL的数据库的备份与恢复
    数据库的备份：(不会备份数据库名)
        shell>mysqldump -u root -psorry test>c:/test.sql 
    恢复数据库：(数据库名必须存在)
        方式一：
        shell>mysql -u root -psorry test         
        方式二：
        mysql>USE test;
        mysql>SOURCE c:/test.sql;
        

***********************************day20~22_JDBC【原生JDBC】、JDBC【连接池】、JDBC【事务】******************************************            
一、JDBC概述
        JDBC:Java DataBase Connectivity(Java连接数据库的标准。SUN制定的)
        JDBC和数据库的驱动是什么关系？JDBC是规范，抽象层，数据库驱动是具体的实现。
        JDBC规范由一些抽象类和接口组成，一般放在java.sql.*或javax.sql.*包中（JDK中带）
        
        JDBC编码的步骤
            准备：把数据库的驱动加入到构建路径中
            1、加载驱动程序并注册驱动
            2、获取与数据库的连接
            3、得到代表SQL语句的对象，并发送SQL给数据库
            4、如果有查询结果，得到封装了查询结果的对象
            5、遍历结果
            6、释放占用的资源
    
二、JDBC中常用接口和类的详细讲解
        1、DriverManager
            作用：注册驱动，得到数据库的连接
            注册驱动：
                DriverManager.registDriver(new com.mysql.jdbc.Driver());(不可取)
                原因：1、严重依赖具体的数据库驱动。2、会导致驱动注册2遍。
                替代方案：
            获取数据库的连接：
                static Connection getConnection(String url,String user,String password):
                        url:数据库的连接串。
                            mysql：jdbc:mysql://localhost:3306/day14数据库名或者jdbc:mysql:///day14(连接本地默认端口上的mysql数据库)
                        user:数据库的用户名
                        password:数据库的密码
                static Connection getConnection(String url,Properties info)
                static Connection getConnection(String url)
                
        2、Connection
            所有与数据库交互都必须建立在连接的基础上
        3、Statement
            作用：代表着SQL语句
            常用的方法：
                ResultSet executeQuery(String sql):sql是DQL语句
                int executeUpdate(String sql):sql是DML语句。或者是没有返回结果的DDL也可以。返回值，代表着语句影响到的行数。
                boolean execute(String sql):sql可以是任何的sql语句。如果有结果集返回，返回true。否则返回false。    
                                            
        4、ResultSet
            boolean next():下移一行
            boolean previous():上移一行
            void absolute(int row):第一行的记录就是1
            void beforeFirst():移动到第一行的前面
            void afterLast():移动到最后一行的后面
            
        5、释放资源
        
三、利用JDBC对数据库进行CRUD

四、SQL的注入及防范
    PreparedStatement:(尽量使用它，就不要再使用Statement)
        作用：
        1、预编译SQL语句，数据库执行效率高。
        2、防止SQL注入
        3、支持参数占位符"?"
        
五、事务入门
    TPL：事务控制语句

    start transaction:开启一次事务
    rollback:回滚
    commit：提交事务

    JDBC中与事务有关的方法：
    Connection.setAutoCommit(boolean b)
    Connection.rollback()
    Connection.rollback(Savepoint sp)
    Connection.commit();

六、事务的特性（隔离级别）
        A:原子性。说明事务是一个不可分割的单位。
        C：一致性.事务必须使数据库从一个一致性状态变换到另外一个一致性状态.(比如转账)
        *I：隔离性。一个事务不能被其他事务打扰。
        D：持久性。事务一旦提交，就应该被永久保存起来。

    如果不考虑事务的隔离级别，会出现以下“不正确”的情况：
        脏读：指一个事务读到了另一个事务中未提交的数据。
        不可重复读：针对一条记录的，同一条记录前后不一样
        虚读（幻读）：针对一张表，前后读到的记录条数不一样。

    MySQL中控制事务隔离级别的语句：
        select @@tx_isolation;     //查看当前的事务隔离级别
        set transaction isolation level 你的级别（四种之一）;//设置隔离级别

    隔离级别的分类：
        READ UNCOMMITTED:脏读、不可重复读、虚读都有可能发生。
        READ COMMITTED:能避免脏读，不可重复读、虚读都有可能发生。
        REPEATABLE READ:能避免脏读、不可重复度，虚读都有可能发生。
        SERIALIZABLE:能避免脏读、不可重复度、虚读。

七、数据库连接池原理

八、编写标准的数据库连接池
    实现了javax.sql.DataSource的才是标准的数据库连接池，按照字面意思，一般称之为数据源。
    
    对于一个已知类的某个方法进行功能上的改变有以下三种方式：
    1、定义子类，扩展父类的某个功能。（此处行不通）
    2、利用包装设计模式改写原有的类的功能
        a、编写一个类实现与被改写类（com.mysql.jdbc.Connection）相同的接口
        b、定义一个引用，记住被改写类的实例
        c、定义构造方法，传入被改写类的实例
        d、对于要改写的方法，改写即可
        e、对于不需要改写的方法，调用原有的对象的对应方法
        
        *****包装设计模式
        *****默认适配器设计模式
        
    3、动态代理
        *****基于接口的动态代理
    java.lang.reflect.Proxy
    static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h) 
 
    作用：返回代理类的实例
    参数：loader：类加载器，一般与被代理对象使用同一个
         interfaces：被代理对象所实现的接口
         h：怎么代理
             Object invoke(Object proxy, Method method, Object[] args) ：调用原有类的任何方法，都会经过此方法。
             
九、开源的数据源使用
        DBCP：DataBase Connection Pool
            1、需要的jar：commons-dbcp.jar  commons-pool.jar
            2、把DBCP的配置文件拷贝到构建路径中
            3、
            package cn.itcast.util;

            import java.io.InputStream;
            import java.sql.Connection;
            import java.sql.ResultSet;
            import java.sql.SQLException;
            import java.sql.Statement;
            import java.util.Properties;

            import javax.sql.DataSource;

            import org.apache.commons.dbcp.BasicDataSourceFactory;

            public class DBCPUtil {
                private static DataSource ds;
                static{
                    try {
                        InputStream in = DBCPUtil.class.getClassLoader().getResourceAsStream("dbcpconfig.properties");
                        Properties props = new Properties();
                        props.load(in);
                        ds = BasicDataSourceFactory.createDataSource(props);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
                public static Connection getConnection(){
                    try {
                        return ds.getConnection();
                    } catch (SQLException e) {
                        throw new RuntimeException(e);
                    }
                }
                public static void release(ResultSet rs,Statement stmt,Connection conn){
                    if(rs!=null){
                        try {
                            rs.close();
                        } catch (SQLException e) {
                            e.printStackTrace();
                        }
                        rs = null;
                    }
                    if(stmt!=null){
                        try {
                            stmt.close();
                        } catch (SQLException e) {
                            e.printStackTrace();
                        }
                        stmt = null;
                    }
                    if(conn!=null){
                        try {
                            conn.close();
                        } catch (SQLException e) {
                            e.printStackTrace();
                        }
                        conn = null;
                    }
                }
            }

        C3P0：是一个机器人的代号
            拷贝jar包

十、DBUtil框架的使用（DBAssist一样的）
十一、DBUtil框架中的所有结果处理器
        ArrayHandler    将结果集中的第一条记录封装到一个Object[]数组中，数组中的每一个元素就是这条记录中的每一个字段的值
        ArrayListHandler    将结果集中的每一条记录都封装到一个Object[]数组中，将这些数组在封装到List集合中。
        BeanHandler    将结果集中第一条记录封装到一个指定的javaBean中。
        BeanListHandler    将结果集中每一条记录封装到指定的javaBean中，将这些javaBean在封装到List集合中
        ColumnListHandler    将结果集中指定的列的字段值，封装到一个List集合中
        KeyedHandler    将结果集中每一条记录封装到Map,在将这个map集合做为另一个Map的value,另一个Map集合的key是指定的字段的值。
        MapHandler    将结果集中第一条记录封装到了Map集合中，key就是字段名称，value就是字段值
        MapListHandler    将结果集中每一条记录封装到了Map集合中，key就是字段名称，value就是字段值，在将这些Map封装到List集合中。
        ScalarHandler    它是用于单个数据。例如select count(*) from 表操作。
        
十二、ThreadLocal类
十三、多表的增删改查
        一对多
        多对多
        一对一