JQuery、JSON、AJAX、XML、IO流、多线程、反射核心知识点详解

JQuery

一、什么是JQuery

    JQuery是JavaScript的一个框架，对js的封装，使得js简单易学

    优点：

        1、不用考虑浏览器兼容性问题

        2、jquery拥有强大的选择器，简化了js代码

        3、jquery提供了很多系统函数，直接调用

二、版本

        1.x版本：兼容ie678，使用最为广泛的，官方只做bug维护，功能不再新增。

        2.x版本：不兼容ie678，很少人使用，官方只做bug维护，功能不再新增。

        3.x版本：不兼容ie678，只支持最新的浏览器。除非特殊要求，一般不会使用3.x版本的.

        注：jquery版本不是向下兼容的

三、怎么使用jquery

    1、在官网上下载一个jquery核心js，放入到项目中

    2、在网页中映入jquery核心js，代码如下：

        <script type=”text/javascript” src=”js/jquery-2.1.1.min.js“></script>

四、jquery核心函数

    jQuery()            $();

    jQuery === $

五、初始化函数

    js版：window.onload = function () {}

    jQuery版：jQuery(function(){});

               $(function() {});

               $(document).ready(function () {})

               $().ready(function () {});

   注：jQuery初始化函数比JavaScript初始化函数优先级要高

六、选择器

    1、基本选择器

        id                      $(“#”)

        class                   $(“.”)

        标签                     $(“标签名”)

        通配符                   $(“*”)

    2、层级选择器

        后代                      $(“ul li“)

        子代                      $(“ul > li“)

        同级别后面第一个            $(“div + p“)

        同级别后面所有              $(“div ~ p“)

    3、伪类选择器

        第一个p标签              $(“p:first“)

        最后一个p标签             $(“p:last”)

        偶数行，从零开始           $(“table tr:even”)

        奇数行，从零开始           $(“table tr:odd“)

        第三行，从零开始           $(table tr:eq(2))

        大于第三行，从零开始        $(table gt:eq(2))

        小于第三行，从零开始        $(table lt:eq(2))

    4、表单选择器

        属性选择器               $(“input[name=username]”)

        单选框与复选框被选中的     $(“input:checked”)

        下拉框被选中的            $(“select option:selected”)

七、循环函数

    $().each(function(i,element)){

    //循环体

    }

    参数i：表示循环的下标，从零开始，变量名自定义，参数可选

    参数element：表示循环出来的元素，变量名自定义，参数可选，在循环体中可以使用this关键字代替

八、操作属性

    attr()                  设置/获取网页元素属性，操作html标签原生属性

    removeAttr()            删除网页元素属性，操作html原生属性

    prop()                  设置/获取网页元素属性，属性不显示，不适合操作html标签原生属性

    removeProp()              删除网页元素属性，属性不显示，不适合操作html标签原生属性

    addClass()                添加class属性

    removeClass()             删除class属性

    toggleClass()             切换class属性

    html()                  设置/获取网页元素中间html代码

    text()                  设置/获取网页元素中间纯文本

    val()                   设置/获取网页元素的value值

九、操作css

    CSS()                   设置网页元素的css样式，css属性名如果是多个单词，使用-或者驼峰命名

                            例如：font-size    fontSize

    height()                设置/获取网页元素高度

    width()                 设置/获取网页元素宽度

    innerHeight()           设置/获取网页元素内部高度，内部高度 = div高度 + 内边距高度

    innerWidth()            设置/获取网页元素内部宽度，内部高度 = div宽度 + 内边距宽度

    outerHeight()           设置/获取网页元素外部高度，外部高度 = div高度 + 内边距高度 + 上下边框

    outerWidth()            设置/获取网页元素外部高度，外部高度 = div宽度 + 内边距宽度 + 左右边框

    offset()                获取网页元素的坐标，top表示顶点位置，left表示左边位置

    position()              获取网页元素的定位坐标，top表示顶点位置，left表示左边位置

    scrollTop()             设置/获取网页元素纵向滚动条偏移量

    scrollLeft()            设置/获取网页元素横向滚动条偏移量

十、文档处理

    append()                内部插入，向尾部追加内容，从右边添加到左边

    appendTo()              内部插入，向尾部追加内容，从左边添加到右边

    prepend()               内部插入，向头部追加内容，从右边添加到左边

    prependTo()             内部插入，向头部追加内容，从左边添加到右边

    remove()                删除本身标签

    empty()                 清空标签下的内容，标签本身不删除

    clone()                 标签本身复制一份

    before()                外部插入，向元素前面插入，从右边添加到左边

    insertBefore()          外部插入，向元素前面插入，从左边添加到右边

    after()                 外部插入，向元素后面插入，从右边添加到左边

    insertAfter()           外部插入，向元素后面插入，从左边添加到右边

    wrap()                  给元素添加包裹

    unwrap()                移除元素的包裹

    wrapAll()               外部包裹，把多个相同元素包裹在一起

    warpInner()             内部包裹，把每个标签内部内容进行包裹，被原标签包裹。

    replaceWith()           替换，右边替换左边

    replaceAll()            替换，左边替换右边

十一、事件

    click()                 单机事件

    dblclick()              双击事件

    change()                改变事件

    focus()                 获取焦点事件

    blur()                  失去焦点事件

    …

十二、效果（了解）

    show()                  显示

    hide()                  隐藏

    toggle()                切换  显示/隐藏

    slideDown(time)         根据设定时间滑入，时间单位：毫秒

    slideUp(time)           根据设定时间滑入，时间单位：毫秒

    slideToggle(time)       根据设定时间切换 滑入/滑出 时间单位：毫秒

    fadeIn(time)            根据设定时间淡入，时间单位：毫秒

    fadeOut(time)           根据设定时间淡出，时间单位：毫秒

    fadeToggle(time)        根据设定时间切换 淡入/淡出， 时间单位：毫秒

JSON

一、什么是json

    json是一种数据格式，前后端通讯的数据传输格式，一堆的字符串。json数据格式与计算机语言无关，Java、JavaScript

    C++都是支持json数据的

二、数据格式有哪些

    1、自定义拼串

        1|刘备|男|1999-08-16|成都，2|曹操|男|1999-08-16|许昌，3|孙权|男|1999-01-11|建宁

        优点：内容短，传输效率高

        缺点：没有扩展性，无法支持多表，可读性差，解析差，容易出错

    2、xml

        <persons>

            <person id=”1″ name=”刘备” sex=”男” birthday=”1999-08-16″ address=”成都” />

            <person id=”1″ name=”曹操” sex=”男” birthday=”1999-08-16″ address=”成都” />

            <person id=”1″ name=”孙权” sex=”男” birthday=”1999-08-16″ address=”成都” />

        </persons>

        <classes>

            <class id=”1″ name=”QF2111″>

                <student id=”1″ name=”张三” sex=”男”>

                <student id=”2″ name=”张三” sex=”男”>

            </class>

            <class id=”2″ name=”QF2112″>

                <student id=”1″ name=”张三” sex=”男”>

                <student id=”2″ name=”张三” sex=”男”>

            </class>

        </classes>

        优点：扩展性强，能支持多表，可读性好，解析容易，不容易出错

        缺点：内容过长，传输效率低

    3、json

    [

        {“id”:”1″,”name”:”刘备”,”sex“:”男”,”birthday“:”1999-08-16″,”address“:”成都”},

        {“id”:”2″,”name”:”刘备”,”sex“:”男”,”birthday“:”1999-08-16″,”address“:”成都”},

        {“id”:”3″,”name”:”刘备”,”sex“:”男”,”birthday“:”1999-08-16″,”address“:”成都”}

    ]

    [

        {“id”:”1″,”name”:”QF2111″,”students”:[

                                                {“id”:”1″,”name”:”张三”,”sex“:”男”},

                                                {“id”:”2″,”name”:”李四”,”sex”:”男”}

                                             ]},

        {“id”:”2″,”name”:”QF2112″,”students”:[

                                                     {“id”:”3″,”name”:”张三”,”sex”:”男”},

                                                     {“id”:”4″,”name”:”李四”,”sex”:”男”}

                                              ]}

    ]

    优点：扩展性强，能支持多表,解析容易，不容易出错,内容较短

    缺点：可读性不高

4、json的版本

    jackson                 国外                  spring框架默认使用

    Fastjson                阿里                  属于第三方jar

AJAX

一、什么是AJAX

    ajax全称：Asynchronous (异步) Javascript And Xml                 异步的JavaScript与XML

    web1.0              浏览信息

    web2.0              网页交互    比如：电商、邮件、游戏         ajax推动web2.0主要技术

    html静态网页获取动态数据，就要用到ajax

*****二、ajax的创建步骤

    1、创建ajax核心对象XMLHttpRequest

     var req = new XMLHttpRequest();

    2、 第二步：连接服务器         请求servlet

          第一个参数：提交方式          取值：get/post

          第二个参数：访问后端url

          第三个参数：boolean值 ，是否异步请求，true为异步，false为同步

    3、发送请求

    req.send();

    4、指定回调函数，接收返回值

    req.onreadystatechange = function () {

                    //什么时候拿返回结果，俩个判断条件，1、http状态200 2、ajax状态等于4，

                    if(req.status == 200 &amp;&amp; req.readyState == 4){

                        var json = req.responseText;

                        var jsonObj = JSON.parse(json);//js解析json

                      }

                }

三、http状态

    ajax获取http状态：req.status

    1.X     通知  接收到请求，并准备执行

    2.X     请求成功，并完全返回结果

    3.X     重定向错误

    4.X     客户端

    5.X     服务器端错误

*****四、ajax状态

    ajax获取本身状态：req.readyState

    0表示：未初始化状态，XMLHttpRequest被创建，但没有进行初始化，没有调用open函数

    1表示：初始化状态，对象已建立，调用了open函数，但没有发生请求，没有调用send函数

    2表示：发生状态，XMLHttpRequest调用了send函数，但是没有得到响应

    3表示：接收状态，已经接收部分数据，但req.responseText没有完全接收完毕

    4表示：完成状态，完全接收数据

五、js解析json

    js解析json字符串有俩种方式，分别如下：

        eval()                  早期

        JSON.parse()            后期，推荐使用

    eval()与JSON.parse()的区别

        1、eval()可以解析不规则的json字符串

            JSON.parse()无法解析不规则的json字符串

        2、eval()无法排出恶意连接，并且会解析执行，安全性低

            JSON.parse()会排出恶意连接，不会解析，安全性高

            强烈推荐JSON.parse()

六、js解析xml

    xml内容：<prompt code=”0″ info=”用户名已存在！” />

    var xml = req.responseText;

    var parser = new DOMParser();   //创建xml对象

    var xmlDoc = parser.parseFromString(xml,”text/xml”);    //创建xml文档对象

    var span = document.getElementsByClassName(“prompt“)[0];    //获取prompt标签对象

    var code = xmlDoc.getElementsByTagName(“prompt“)[0].getAttribute(“code“);   //获取prompt标签中的code属性

    var info = xmlDoc.getElementsByTagName(“prompt“)[0].getAttribute(“info“);   //获取prompt标签中的info属性

七、jQuery使用ajax

    jQuery的ajax 是对 js的ajax的封装，常用如下：

    1、$.ajax()      推荐使用

        type        提交方式，取值get/post

        url         请求地址

        data        请求参数，表单参数

        async       是否为异步请求，true为异步（默认），false是同步

        success     请求成功后的回调函数

        dataType    服务器返回的数据格式类型，取值：json、xml、text（默认）、HTML、JavaScript

        error       请求失败后的回调函数

    2、$.post()      是$.ajax()简洁版，固定提交方式是post

        第一个参数：请求地址

        第二个参数：请求参数，表单参数

        第三个参数：请求成功后的回调函数

        第四个参数：服务器返回的数据格式类型，取值：json、xml、text（默认）、HTML、JavaScript

    3、$.get()      是$.ajax()简洁版，固定提交方式是get

        第一个参数：请求地址

        第二个参数：请求参数，表单参数

        第三个参数：请求成功后的回调函数

        第四个参数：服务器返回的数据格式类型，取值：json、xml、text（默认）、HTML、JavaScript

    4、$.getJSON()   是$.ajax()简洁版，固定提交方式是get，数据传输格式固定为json

        第一个参数：请求地址

        第二个参数：请求参数，表单参数

        第三个参数：请求成功后的回调函数

    jQuery ajax推荐使用1、2

XML

一、什么是xml

    xml是一种数据格式，一堆的字符串，因xml可读性好，一般也作为配置文件，xml与计算机语言无关，Java、JavaScript

    C++都是支持xml的

二、xml格式

        <persons>

            <person id=”1″ name=”刘备” sex=”男” birthday=”1999-08-16″ address=”成都” />

            <person id=”1″ name=”曹操” sex=”男” birthday=”1999-08-16″ address=”成都” />

            <person id=”1″ name=”孙权” sex=”男” birthday=”1999-08-16″ address=”成都” />

        </persons>

        <classes>

            <class id=”1″ name=”QF2111″>

                <student id=”1″ name=”张三” sex=”男”>

                <student id=”2″ name=”张三” sex=”男”>

            </class>

            <class id=”2″ name=”QF2112″>

                <student id=”1″ name=”张三” sex=”男”>

                <student id=”2″ name=”张三” sex=”男”>

            </class>

        </classes>

        优点：扩展性强，能支持多表，可读性好，解析容易，不容易出错

        缺点：内容过长，传输效率低

三、xml解析技术

    dom4j.jar

IO流

一、什么是IO流

    File：操作系统硬盘中的文件，比如：.txt、.doc、jpg

    流：与文件内容或者网络传输内容称为IO流，在java.io包下，流是有方向的，有输出流与输入流

二、File类

    1、什么是File类

        在Java中File代表一个文件或文件夹

    2、构造方法

            File(String path)                   根据路径创建文件或文件夹

        new File(File parent,String child);     在父目录下，创建子文件或文件夹

        new File(String parentPath,String child)在父目录下，创建子文件或文件夹

    3、常用属性

        File.pathSeparator      路径分隔符

        File.separator          文件分隔符

    4、常用方法

        createNewFile()         创建一个新文件，文件已存在返回false，否则返回true，不会覆盖

        mkdir()                 创建一个单层目录，目录已存在返回false，否则返回true，不会覆盖

        mkdirs()                创建一个多层目录，目录已存在返回false，否则返回true，不会覆盖

        exists()                判断文件或文件夹是否存在，存在返回true，不存在返回false

        delete()                删除文件或文件夹，删除文件夹只能删除空文件夹，删除多层文件夹，

                                只会删除最底层的文件夹，不会删除全部

        listFiles()             获取指定目录下的所有文件与文件夹

        getName()               获取文件名

        getPath()               文件路径

        getParent()             文件父目录

        length()                文件大小

        isFile()                判断是否是一个文件，如果是返回true，否则返回false

        isDirectory             判断是否是一个文件夹，如果是返回true，否则返回false

        isHidden                判断是否是一个隐藏文件，如果是返回true，否则返回false

*****三、IO流的分类

    1、按流的类型来分

        字节流 byte        字节输入流       InputStream         以字节的形式读取

                          字节输出流       OutputStream        以字节的形式写入

        字符流 char        字符输入流       Reader              以字符的形式读取

                          字符输出流       Writer              以字符的形式写入

    2、按读写的分类

        输入流             字节输入流       InputStream         以字节的形式读取

                          字符输入流       Reader              以字符的形式读取

        输出流             字节输出流       OutputStream         以字节的形式写入

                          字符输出流       Writer              以字符的形式写入

*****四、文件流

    1、文件流的类

    FileOutputStream        继承OutputStream      文件字节输出流     以字节的形式写入文件

    FileInputStream         继承InputStream       文件字节输入流     以字节的形式读取文件

    FileWriter              继承Writer            文件字符输出流     以字符的形式写入文件

    FileReader              继承Reader            文件字符输入流     以字符的形式读取文件

    2、文件流的作用

        文件流用来操作硬盘中文件内容，依赖File类

*****五、字节流与字符流

   1、字节流按字节大小读取，字符流是按字符个数读取

   2、字节流可以读取任何文件，字符流只能读取文本文件

   3、字符流的底层是字节流

   注：读写文本建议使用字符流，其他文件使用字节流

debug

1、设置断点

2、使用debug模式运行

3、F8是下一步执行

4、F9是执行到下一断点，如果没有下一个断点就会执行完毕

*****六、字符流与字节流的转换

    1、OutputStreamWriter        继承Writer        本身是一个字符流        字符流通向字节流的桥梁

        写入的内容是字符，自动转成字节形式写入

    2、InputStreamReader         继承Reader        本身是一个字符流        字节流通向字符流的桥梁

        写入的内容是读取，自动转成字节形式读取

七、RandomAccessFile（随机读写文件）

    RandomAccessFile可以随机读写文件，底层是以字节形式写入与读取

八、缓冲流

    1、缓冲流的分类

        BufferedInputStream       字节缓冲输入流         缓冲区默认大小是8kb      字节读取

        BufferedOutputStream      字节缓冲输出流         缓冲区默认大小是8kb      字节写入

        BufferedReader            字符缓冲输入流         缓冲区默认大小是8kb      字符读取

        BufferedWriter            字节缓冲输出流         缓冲区默认大小是8kb      字符写入

    2、缓冲流的作用

        缓冲流是用来提高读写效率，减少IO读写保护硬盘，先把内容写入到缓冲区（数据结构），缓冲区写满后，再同步到

        文件中，如果缓冲区没有写满，通过close()方法进行同步

        注：如果一个文件需要持续的写入或读取，建议使用缓冲流

九、数据流

    1、什么是数据流

        数据流一般用于网络传输，针对数据类型传输的流，数据流只有字节流

    2、数据流的类

        DataInputStream         数据字节输入流             读取

        DataOutputStream        数据字节输出流             写入

十、对象流

    1、什么是对象流

        对象流可以把对象写入到硬盘中，然后可以从硬盘中读取，是java创建对象的一种方式

    2、对象流的类

        ObjectInputStream       对象输入流          把对象从硬盘读取到内存中    java创建对象的一种

        ObjectOutputStream      对象输出流       序列化         把对象从内存写入到硬盘中

        注：1、被写入的对象必须实现java.io.Serializable接口，否则会报错，这是一个空接口

           2、被写入的对象属性一旦赋值，那么属性的类型也必须实现java.io.Serializable接口

           以下系统类都已实现java.io.Serializable接口

                八大基本数据类型包装

                String

                Date

                集合类（List、Set、Map）

十一、属性文件(.properties)

    .properties文件是一个属性文件，可以用来做配置文件

    spring boot框架使用的就是.properties文件做配置文件

多线程

一、什么是线程

    线程是程序最小执行单位，独立可运行的调度单元，是CPU最小执行单位，CPU就是用来处理线程的，在一个程序

    中不同的线程完成不同的任务，称为多线程，软件最小执行单位就是线程。

二、程序、进程、线程

    程序：一段静态代码

    进程：进程就是程序一次正常的运行过程，从代码的加载到最后一句代码的运行，整个过程就是进程的生命周期

    线程：线程是进程中独立、可调配的单元，最小的执行单位

    1、程序与进程的关系

        一个程序一般产生一个进程，但是也可以产生多个进程，一个进程只能属于一个程序

    2、进程与线程的关系

        一个进程拥有多个线程，一个线程只能属于一个进程

    注：一个程序至少有一个线程，这个线程称为主线程，其他都是子线程，Java应用程序的main方法，就是主线程

        有程序一不定有进程，有进程一定有程序

        有进程至少有一个线程，有线程一定有进程

*****三、线程的创建

    1、继承Thread类

        Thread th = new Thread();

        th.start();    //启动线程

    2、实现Runnable接口

        Thread th = new Thread(new Runnable());

        th.start();   //启动线程

    3、两种创建方式的区别

        a、Thread类本身实现了Runnable接口，Runnable接口是线程的根接口

        b、使用Runnable接口创建线程，还是要依赖Thread类，因为Runnable接口没有start()方法

        c、一个类要继承线程，又要继承其他类，这个时候用Runnable接口，因为类是单继承，

           如果一个类只继承线程类，就使用Thread类

*****四、线程的生命周期

    1、创建：线程对象被构造

    2、启动(就绪)：线程对象调用start()方法，排队申请CPU资源

    3、运行：CPU处理线程，进入run()方法

    4、中断：遇到sleep()方法

    5、死亡：运行完run()方法，线程就会死亡

    线程生命周期过程

    情况一：创建—>启动—>运行—>死亡

    情况二：创建—>启动—>运行—>中断—>就绪—>运行—>中断—>就绪—>…—>死亡

    情况二比较多

*****五、线程状态

    1、新建(NEW)：线程对象被构造，没有调用start()方法

    2、运行(RUNNABLE)：从调用了start()方法到线程运行run()方法都处于这个状态

    3、阻塞(BLOCKED)：线程遇到同步锁，其他线程在锁外面等待，处理这个状态

    4、等待(WAITING)：无时间等待，线程遇到了wait()方法

    5、等待(TIME_WAITING)：有时间的等待，线程遇到了sleep(long millis)、wait(long millis)方法

    6、死亡(TERMINATED)：线程运行完run()方法，线程已经死亡

*****六、程序的主线程

    主线程是程序的入口与闭口，主线程一旦死亡，程序就会终止，进程就会消失。

    主线程代码执行完毕，子线程没有执行完毕，主线程不会死亡，等待子线程执行完毕之后，主线程才会死亡

七、线程的休眠与中断休眠

    线程休眠：Thread.sleep(long millis)            时间单位是毫秒

    中断休眠：interrupt()

    注：sleep()是有时间的等待，一般不会使用interrupt()方法进行唤醒，时间到了自动唤醒，强制唤醒sleep()

        方法会抛出InterruptedException异常

        保证线程执行优先级 = 书写顺序 + 线程优先级

八、线程常用方法

    Thread类

        构造方法

            Thread()                       无参构造，创建一个线程对象

            Thread(String name)            创建一个线程对象，并且设置线程名称

            Thread(Runnable target)        根据Runnable对象创建线程

            Thread(Runnable target, String name)    根据Runnable对象创建线程，并且设置线程名称

        常用方法

            start()                  启动线程

            sleep(long millis)       静态方法，线程休眠，有等待时间

            interrupt()              中断线程的sleep

            getState()               获取线程状态

            stop()                   停止线程，杀死线程，已过时

            setPriority(int newPriority) 设置线程的优先级，最小是1，最大10，默认是5

            getPriority()            获取线程的优先级，最小是1，最大10，默认是5

            setName(String name)     设置线程的名称

            getName()                获取线程的名称

            currentThread()          静态方法，获取当前正在执行的线程

            yield()                  静态方法，当前线程把CPU资源让给优先级相同的其他线程，其他线程包括本身

            join()                   把多个线程连接在一起，第一个线程执行完毕，第二个线程才会被执行，

                                     把线程异步变成同步

        常用属性

            State                   静态属性，枚举类型，线程的状态

            MAX_PRIORITY            静态属性，线程最高优先级，值为10

            MIN_PRIORITY            静态属性，线程最低优先级，值为1

            NORM_PRIORITY           静态属性，线程默认优先级，值为5

    Runnable接口

        常用方法

            run()                 线程被CPU执行，自动进入此方法，此方法执行完毕，线程死亡

    Object类

        常用方法

            wait()                 线程无时间等待，只能通过其他线程唤醒

            wait(long timeout)     线程有时间等待，可以通过其他线程唤醒或者指定时间已过，时间单位：毫秒

            notify()               随机唤醒一个等待的线程

            notifyAll()            唤醒所有的等待线程

九、线程同步

    *****1、什么是线程不安全

        多个线程操作同一个对象的同一个全局属性，就会造成线程不安全。

        线程不安全，必须满足以下三个条件：

            a、必须是同一个对象

            b、必须改变同一个全局属性

            c、必须是多个线程操作

    *****2、同步锁(synchronized)作用

        在方法上增加synchronized关键字，就是给此方法增加一把同步锁，同步锁只允许一个线程进入此方法，

        其他线程在此方法外阻塞，线程进入方法后，这个方法就被锁住，只有等待此线程执行完方法，其他线程

        才能进入此方法。

        总结：同一个时刻只允许一个线程进入方法

十、线程安全与不安全的对象

    线程安全对象                   线程不安全对象

    StringBuffer                   StringBuilder

    HashTable                      HashMap

    Vector                           ArrayList

    线程安全对象：对象创建比较费时，消耗内存大，执行效率低，安全性高，重量级对象

    线程不安全对象：对象创建比快，消耗内存小，执行效率高，安全性低，轻量级对象

    局部变量建议使用线程不安全对象

    全局变量建议使用线程安全对象

十一、线程的等待与恢复

    wait()                 线程无时间等待，只能通过其他线程唤醒

    wait(long timeout)     线程有时间等待，可以通过其他线程唤醒或者指定时间已过，时间单位：毫秒

    notify()               随机唤醒一个等待的线程

    notifyAll()            唤醒所有的等待线程

    wait()方法不稳定，必须结合同步锁使用

*****十二、sleep()与wait()区别

    1、sleep()方法是Thread类的，wait()是Object类

    2、sleep()方法不需要结合同步锁，wait()方法一定要结合同步锁

    3、sleep()放弃CPU资源，但不会释放同步锁

       wait()放弃CPU资源，并且释放同步锁

    4、sleep()方法必须给出唤醒时间，是有时间的等待，也可以通过interrupt()方法强制唤醒，并且会抛出异常

       wait()方法给出唤醒时间，是有时间的等待，不给出唤醒时间，是无时间等待，可以使用notify()

       或notifyAll()进行唤醒，唤醒不会抛出异常

*****十三、单例模式

    1、什么是单例模式

        一个类只能有一个对象，称为单例模式

    2、单例模式的优缺点

        优点：只创建一个对象，节约内存，提高执行效率

        缺点：多线程操作单例，会造成线程不安全

    3、单例模式种类

        1、懒汉模式

        2、饿汉模式

        3、枚举

        4、双重检查

        5、静态内部类

        效率由高到底排列：

            静态内部类 > 饿汉模式 > 枚举 > 双重检查 > 懒汉模式

*****十四、synchronized使用注意事项

    1、动态方法的 synchronized，锁的是当前对象

    2、静态方法的 synchronized，锁的是当前类的字节码

    3、sleep 让出 CPU 资源，不会释放同步锁

    4、wait 让出 CPU 资源，并且释放同步锁

    5、同步锁必须锁同样的东西才会有效

    6、synchronized方法会互相影响，线程进入一个对象的synchronized方法后，

       其他相同类型的synchronized方法无法进入，大大的影响效率，但可以保证线程安全

*****十五、线程的七种同步方式

    1、同步方法，使用synchronized关键字修饰方法

    2、同步代码块，使用synchronized关键字修饰语句块，synchronized必须锁一个公共变量，

       这个公共变量必须是引用类型，可以是当前对象或者类的字节码

    3、特殊域变量，使用volatile修饰变量，能保证获取此变量的最新值，保证变量的可见性，

       是一种无锁机制

    4、重入锁，JDK提供的第三方锁，不受wait()方法的影响，java.util.concurrent.locks.ReentrantLock

       lock()     获取锁

       unlock()   释放锁

    5、线程变量(ThreadLocal)，把全局变量写成局部变量，交个ThreadLocal管理，set方法赋值，get方法取值

       单例对象多例属性

    6、变量的原子性实现线程同步，把变量的赋值过程(读取、修改、写入)看成一个整体，要么一起成功，要么一起失败

    7、阻塞队列，队列是数据结构的一种，特点是：先进先出，后进后出

*****十六、volatile与synchronized区别

    变量赋值线程安全必须保证俩个方面：一是变量的可见性，二是变量的原子性

    volatile关键字只保证了变量的可见性，没有原子性，他是一种无锁机制，不能保证线程安全，

    但是不会造成线程阻塞，是轻量级的

    synchronized关键字保证了可见性和原子性，它是一种有锁机制，可以保证线程安全，

    会造成线程阻塞，是重量级的

    volatile只能修饰变量

    synchronized修饰方法和代码块

    volatile效率会比synchronized高

十七、守护线程

    3、守护线程的创建

        Thread daemon = new Thread();

        daemon.setDaemon(true);

    4、什么是GC

        GC是垃圾回收机制，JDK启动时，会启动一个守护线程，轮询JVM中的对象，发现对象超出作用域，

        没有被引用，就会被回收，使用的分析算法有：可达性分析法、引用计数法、标记清除法等

十八、线程池（pool）

    1、什么是线程池

        多个线程绑定在一起统一管理，形成线程池，线程池统一管理线程的创建、使用、回收

    2、线程池的分类

        在JDK中提供了四个线程池，通过java.util.concurrent.Executors类创建，分别如下：

        a、可缓存的线程池，任务超时会新增新的线程

            ExecutorService service =  Executors.newCachedThreadPool();

        b、固定大小的线程池，执行任务平均分配

            ExecutorService service =  Executors.newFixedThreadPool(5);

        c、固定大小的线程池，支持定时任务

            ScheduledExecutorService service =  Executors.newScheduledThreadPool(5);

        d、单线程池

            ExecutorService service = Executors.newSingleThreadExecutor()

反射

一、什么是反射

    在Java中通过类的字节码反射出类中的信息，包括：类、包、属性、方法、继承、实现、构造等

    反射在JDK中java.lang与java.lang.reflect包下

    作用：代码的通用性与扩展性

二、Class类

    1、什么是Class类

        在反射中Class类代表一个类或接口，其实就是字节码，在Java数据类型中称为类类型

    *****2、Java数据类型有哪些

        a、基本数据类型(八种)

        b、引用数据类型

            Ⅰ、类

            Ⅱ、接口

            Ⅲ、类类型(Class)

            Ⅳ、枚举

            Ⅴ、注解

            Ⅵ、数组

    3、类类型获取方式

        Class cla = 类名.class

        Class cla = 对象名.getClass();         getClass()是Object类的方法

        Class cla = Class.forName(“类的完整路径”)

    4、Class类的常用方法

            getSimpleName()         获取类名

            getName()               获取类的完整路径

            newInstance             创建新的对象，默认调用无参构造

            getSuperclass()         获取父类的类类型

            getInterfaces()         获取父接口的类类型

三、Filed类

    1、什么是Filed类

        在Java反射中Filed类代表类中的一个属性，可以通过类类型获取

    2、获取Field对象

        cla.getDeclaredField(String name)       根据属性名获取本类中的单个属性

        cla.getDeclaredFields()                 获取本类所有属性

        cla.getField(String name)               根据属性名获取父类或父接口中的public属性

        cla.getFields()                         获取父类或父接口中的所有public属性

    3、Field类常用方法

        getName()                               获取属性名

        getType()                               获取属性数据类型

        getModifiers()                          获取属性的访问修饰符

        setAccessible(boolean flag)             设置变量是否能访问，为true允许访问

                                                为false部允许访问，默认为false(属性默认只能访问public修饰的)

        set(Object obj,Object value)            设置属性值，静态属性，第一个参数为null

        get(Object obj)                         获取属性值，静态属性，参数为null

四、Method类

    1、什么是Method

        在Java反射中Method类代表类中的一个方法，可以通过类类型获取

    2、获取Method对象

        cla.getDeclaredMethod(String name,Class<?>…parameterTypes)

            根据方法名与参数列表获取本类中指定方法

        cla.getDeclaredMethod()

            获取本类中的所有方法

        cla.getMethod(String name,Class<?>…parameterTypes)

            根据方法名与参数列表获取指定public方法，包括：本类、父类、父接口

        cla.getMethod()

            获取类中所有public方法包括：本类、父类、父接口

    3、Method类常用方法

        getName()           获取方法名

        getModifiers()      获取方法的修饰符

        getReturnType()     获取返回值类型

        getParameterCount() 获取参数列表个数

        getParameterTypes() 获取参数列表类型

        getExceptionTypes() 获取异常类型

        setAccessible(boolean flag) 设置方法是否能访问，为true允许访问

                                    为false不允许访问，默认false

        invoke(Object obj,Object…args)    执行方法，第一个参数：调用对象

                                                    第二个参数：方法的参数值

                                            执行静态方法，第一个参数为null

五、Constructor类

    1、什么是Constructor类

        在Java反射中Constructor类表示类中的一个构造方法，可以通过类类型获取

    2、获取Constructor对象

        cla.getConstructor(Class<?>…parameterTypes)   根据参数列表获取指定的构造方法

        cla.getConstructors()                           获取类中的所有构造方法

    3、Constructor类常用方法

        getName()                       获取构造方法名

        getModifiers()                  获取构方法的修饰符

        getParameterCount()             获取参数列表的个数

        getParameterTypes()             获取参数列表类型

        getExceptionTypes()             获取异常类型

        newInstance(Object…parameter) 调用指定的构造方法创建对象

六、java中T的使用

    1、什么是T

        T是一个关键字，泛型与Object很像，可以接收任何引用类型，而且不需要强制装换，

        比Object强制转换成其他类型效率高

    2、T的定义

        a、定义在类名上，整个类有效,静态方法不能使用

            public class 类名<T> {

            }

        b、定义在方法上，整个方法有效，适用于任何方法，定义<T>必须写在返回值之前

            public <T> T 方法名{

            }

七、克隆

    1、java中变量的赋值都是栈内存赋值，基本数据类型是值赋值，引用数据类型是指针赋值，

       基本数据类型变量更改，不会影响其他变量，引用数据类型变量更改，会影响其他赋值的变量，

        其中有九个引用数据类型是值赋值，更改不会影响其他变量，分别如下：

        八大基本数据类型的包装类 + String

    2、什么是对象克隆

        对象的克隆只针对引用数据类型，基本数据类型没有克隆，对象克隆是重新分配一片新的内存空间，

        把对象的内容复制到新的内存空间，克隆的对象不会相互影响，是Java创建对象的一种方式

    *****3、java创建对象的方式

        a、new +构造

        b、反序列化

        c、反射

        d、克隆

    *****4、对象克隆方式

        a、浅度克隆：只会克隆对象本身，对象的属性不会克隆

        b、深度克隆：会克隆对象本身，对象属性也会克隆

    5、对象克隆的步骤

        a、克隆对象的类必须实现java.lang.Cloneable接口

        b、重写clone()方法

        c、在clone()方法中，使用super关键字调用Object中的clone()方法，返回自身对象

八、Object类中的方法

    1、反射

        getClass()              获取对象的类类型

    2、克隆

        clone()                 对象的克隆

    3、线程

        wait()                  线程等待

        notify()                随机唤醒一个等待线程

        notifyAll()             唤醒全部等待的线程

    4、对象比较

        equals()                比较俩个对象内容是否相同

        hashCode()              获取对象的哈希码

    5、GC

        finalize()              对象回收之前最后调用的方法

    6、String

        toString()              对象字符串表示

九、注解

    1、注解的作用

        用来做配置信息，可以替代xml配置文件

    2、如何创建注解

        @Documented

        @Target

        @Retention

        public @interface 注解名{

        }

        创建注解时，必须写上@Documented、@Target、@Retention这三个注解

        @Documented             表示一个文档注解，空注解

        @Target                 表示这个注解写在什么地方，使用ElementType枚举来指定，取值如下

                                TYPE                           作用在类上

                                FIELD                          作用在属性上

                                METHOD                         作用在方法上

                                PARAMETER                      作用在参数上

                                CONSTRUCTOR                    作用在构造方法上

                                ANNOTATION_TYPE                作用在注解上

                                PACKAGE                        作用在包上

        @Retention              表示注解的生命周期范围，使用RetentionPolicy枚举来取值

                                SOURCE                          在源码中有效

                                CLASS                           在字节码中有效

                                RUNTIME                         在运行时有效