1.API：应用程序编程接口，一些提前写好的供大家使用的一些类和方法。

2. Scanner:1.使用形式：Scanner sc = new Scanner(Systey.in);
                       int i = sc.nextInt();
           2.作用：接收从键盘输入的内容，默认情况下匹配空格。然后可以使用各种next方法将得到的值转换成不同类型。
           3.next和nextline区别：next读取到空格结束，nextline读取一行包括空格。

3.Date：1.有一种无参构造方法和多种有参构造方法（已被弃用）
        2.Date date = new Date();  date代表它被分配的时间，测量到最近的毫秒
        3.date.getDay();  代表星期，周日为0
        4.date.getMonth();  代表月，一月为0
        5.将Date类型转换为String类型：
          SimpleDateFormat  s = new SimpleDateFormat(yyyy年MM月dd日  HH:mm:ss E); 
          String str = s.format(date);
          System.out.println(str);
         //控制台的输出格式为：2019年04月27日 15:18:50 星期六,括号里面的内容还可以为（yyyy-MM-dd HH:mm:ss），输出格式为：2019-01-27 16:03:33
        6.将String类型转换为Date类型：
          SimpleDateFormat s = new SimpleDateFormat(yyyy-MM-dd HH:mm;ss E);
          Date date =s.parse(str);
          System.out.println(date);
          
4.Math:1.Math.abs(参数)  绝对值函数
       2.Math.addExact(参数，参数)  返回两个数相加的和
       3.Math.max(参数，参数)    返回两个数中最大的一个
       4.Math.pow(参数，参数)    返回参数1的参数2次方
       5.Math.random();  返回0-1之间的一个随机数（double）
       6.（int）d*个数+基数：随机生成一个任意数值之间的整数

5.Object：1.Object是所有类的父类，他是一个最顶级的类。
          2.obj.hashCode(); 表示的是对象在内存中的物理地址
          3.obj1=obj;  obj1和obj用的是同一个对象
          4.同一个对象的hashCode一定相同，但hashCode相同的对象不一定是同一个对象
          5.equals（参数） 比较两个对象是否是同一个对象
          6.toString（）  将一个对象转换为字符串

6.String：1.String() 无参构造方法
          2.String(String str) 有一个字符串参数的构造方法
          3.String(char[]ch) 有一个char类型数组参数的构造方法
          4. int length() 求字符串值的字符个数
          5.boolean equals(Object o) 比较两个字符串是否相同
          6.String replace(char old,char new) 字符串替换
          7.char charAt(int index) 返回指定字符串指定位置的字符
          8.boolean endsWith(String s) 比较字符串是否以指定的参数结尾
          9.String valueOf(int i)将基本数据类型转换为字符串
          10.boolean isEmpty() 判别一个字符串值的长度是不是为0
          11.int indexOf(int ch) 用来检查给定的一个字符在当前字符串中第一次出现的下标位置 
          12.String substring(int begin)从指定索引位置截取字符串
          13.split("字符/字母")  根据括号里面的内容将字符串切割

7.==和eauals：1.==既可以比较基本数据类型，也可以比较引用数据类型，比较基本数据类型的时候比较的是值，比较引用数据类型的时候比较的是地址
              2.equals（参数）比较的是字符串的值是否相同


8.包装类：1.概念：基本数据类型对应的引用数据类型
          2.种类： int->Integer
                   char->Character
                   byte->Byte
                   short->Short
                   double->Double
                   long->Long
                   float->Float
                   boolean->Boolean
         3.基本数据类型转换为包装类，以int为例：int i =1; Integer it = new Integer(i);
         4.把包装类转换为基本数据类型，以int为例：int i2 = it.intValue();
         5.把int转换为String类型：int i = 1;
                                  Integer it = new Integer(i);
                                  String str = it.toString();
         6.把String类型转化为int类型：String str="123"(只能是数字)
                                     Integer it = new Integer(str);
                                     int i = it.intValue();
                                     System.out.println(i);
                 
         7.拆箱：包装类自动转化成对应的基本数据类型：Integer i = new Integer(1);
                                                    int a = i;
         8.装箱：基本数据类型自动转换成对应的包装类： Integer b = a;
         9.int转换为String：int a = 1；
                            String s = ""+a;            
        10.String转换为int：int i = Integer.valueof(s);

9.Charcter:1.Character.isLetter(字符型参数)   判断是否是字母
           2.Character.isDidit(字符型参数)    判断是否是数字
           3.Character.toupperCase(字符型参数)   转换为大写
           4.Character.toLowerCase(字符型参数)   转换成小写
           5.Character.isUpperCase(字符型参数)   判断是否是大写

10.异常：1.概念：异常是程序在编译或运行过程中出现的例外，这些例外有的时候可以避免有的却无法避免。
         2.分类
                1.编译期异常：在编译的时候出现的异常，不可避免，必须进行异常处理。
                2.运行期异常：在运行时期出现的异常，可以避免，不需要必须处理。
         3.常见的异常
                1.int[] a={1,2,3};
                  System.out.println(a[4]);
                  数组下标越界异常（运行期异常）  java.lang.ArrayIndexOutOfBoundsException:
                2.SimpleDateFormat  s = new SimpleDateFormat("yyyy-MM-dd HH:mm;ss E");
                  s.parse();
                  解析异常（编译期异常）  java.text.ParseException:
                3.Car c=null;
                  c.run();  调用了某个对象的方法，但是这个对象没有值，是个null
                  空指针异常（运行期异常）   java.lang.NullPointerException
                4.Integer.valueOf("a");
                  数字格式化异常（运行期异常）  java.lang.NumberFormatException:
                5.String s ="a";
                  s.charAt(1);
                  字符串下标越界异常（运行期异常）    java.lang.StringIndexOutOfBoundsException:
                6.int i=1/0;
                  算术异常（运行期异常）  java.lang.ArithmeticException 
        4.异常的作用:增强了程序的容错性和健壮性。
        5.异常的处理
                1.捕获异常，自己处理过了，别人来使用的时候直接可以用。
                  try{
                       产生异常的语句
                 }catch(异常类 对象名){
                       产生异常时执行的语句
                 }finally{
                       不管有没有出现异常，都会执行  
                 }
                2.抛出异常，谁用谁处理
                 [修饰符]返回值类型 方法名（[参数列表]） throws 异常1，异常2
       6.自定义异常
                1.继承自Exception的自定义异常，编译期异常，必须要进行处理。
                2.写法
                      1.先自定义一个继承自Exception的类，里面包含一个无参的和一个有参的构造函数。
                      2.主函数里面：try{
                                       throw new 自定义的异常类名([参数列表])；
                                   }catch(自定义异常名 对象名){
                                       e.printStackTrace();
                                   }
                3.继承自RuntimeException的自定义异常，运行期异常，不需要进行处理。
                4.写法
                      1.同上
                      2.在主函数里：throw new 自定义的异常类名（[参数列表]）


11.throw和throws的区别：throws用在方法上，可以抛出多个。throw用在方法内部，一次抛出一个。

12.集合 1.概念：集合有时候又称容器，它是一个对象，能将具有相同性质的多个元素汇聚成一个整体。
        2.集合和数组的区别：
                         1.数组一经创建长度确定，集合的长度可以改变。
                         2.数组里面可以存放任意数据类型，集合里面只能存放引用数据类型。
                 
        3.框架的结构：见day16笔记
        4.collectio接口的方法：
                         1.集合中是否包含指定的所有集合元素boolean containAll(Collection<> c)
                         2.向集合中添加指定集合的所有元素 boolean addAll(Collection<> c)
                         3.从集合移除指定集合包含的元素  boolean removeAll(Collection<> c)
                         4.移除集合中所有元素        void clear()
                         5.保留集合中指定的元素      boolean retainAll(Collection<> c)
                         6.返回集合元素的个数        int size()
                         7.判断集合是否为空          boolean isEmpty()
                         8.判断集合中是否包含指定元素  boolean contains(Object o)
                         9.向集合中添加指定元素        booLean add(E elemet) 
                         10.从集合中移除指定元素       boolean remove(Object o)
                         11.返回在集合元素上进行迭代的迭代器  Iterator<E> iterator()
        5.list接口：
                   1.特点：list是一个有序的集合，可以包含重复元素。
                   2.接口方法:
                            1.返回集合中指定位置的元素  E get(int index) 
                            2.返回指定对象在集合中的索引位置  int indexOf(Object o)
                            3.从集合中截取子集合     list<E> sublist(int from,int to)
                            4.移除集合中指定位置的元素  E remove（int index）
                            5.查看集合中的元素，增强for循环
                                                  for(Object obj:list){
                                                        System.out.println(obj);
                                                  }
                            6.查看集合里面元素： while(it.hasNext()){

                                                      Object obj=it.next();
                                                      system.out.println(obj);
                                                  }

        6.set接口：
                  1.特点：set是一个不能包含重复元素的接口
                  2.接口方法：
                            1.集合中是否包含指定元素的所有集合元素  boolean containAll(Collection<> c)
                            2.向集合中添加指定集合的所有元素    boolean addAll(Collection <> c)
                            3.从集合中移除指定集合的包含的元素   boolean removeAll(Collection<> c)
                            4.移除集合中的所有元素     void clear()
                            5.保留集合中指定的元素     boolean retainAll()
                            6.返回集合元素的个数       int size()
                            7.返回在集合元素上进行迭代的迭代器   iterator<E> iterator()
                            8.查看集合中的元素
                                                 for(Object object:set){
                                                       System.out.println(object);
                                                 }
        7.map接口：
                  1.特点：map是一种包含键值对的元素的集合，map中不能包含重复的键，每个键最多可映射到一个值
                  2.接口方法：
                             1.将指定的值与映射中的指定键进行关联  V put(K key,V value)
                             2.返回指定键对应的映射值  V get(Object key)
                             3.如果存在一个键的映射关系，那么移除  V remove(Object key)
                             4.返回此映射中键值映射关系的数量  int size()
                             5.判断映射中是否包含指定的键   boolean containKey(Object k)
                             6.判断映射中是否包含指定的值   boolean containValue(Object v)

     
           
13.HTML 1.概念：用来记录文字，图片，声音，视频，超链接，表单等的.html格式的文件
        2.比较java：他也是一种计算机语言，他是描述网页文档的一种标记语言
        3.HTML语法：
                  1.不区分大小写
                  2.不同标记拥有的属性可能相同，也可能不同。
                  3.标记一般是成对出现的，少数是单独出现的。
                  4.标记是可以相互嵌套的，嵌套原则，不能交叉嵌套，属性不冲突，效果叠加，属性冲突，就近效果
                  5.<起始标记 属性名=属性值 属性名=属性值> </结束标记>
        4.标签：
                1.标题标签：<hn align=left|center|right>标题的内容</hn>,n属于1-6,align是居中方式
                2.段落标签：<p align=left|center|right>内容</p>
                3.换行：<br>
                4.水平线：<hr color=red size=10 width=50px/50%>设置颜色，宽度，长度
                5.内容居中：<center>内容</center>
                6.字体控制标记：<font size=大小 color=颜色 face=字体>文字</font>
                7.粗体：<b></b>
                8.斜体：<i></i>
                9.下划线：<u></u>
                10.删除线：<s></s>
                11.下标：<sub></sub>
                12.上标：<sup></sup>
                13.图片标记：<img src="相对路径和绝对路径" 
                                  alt="图片加载失败时显示的信息" 
                                  title="当鼠标放到图片上时显示的信息"
                                  border=像素值 vspace=像素值 hspace=像素值>
                14.超链接：<a herf="路径">显示到页面的内容</a>
                           1.当前页面 #
                           2.内部链接 本地路径
                           3.外部链接 http://xxxx
                15.书签链接：1.在指定位置添加锚点 <a name="锚点名">
                             2.使用链接跳到该位置： <a herf="#锚点名">页面显示的内容</a>
                16.背景颜色和图片：<body background="图片名" bgcolor="颜色">
                17.表格：<table border="1" cellspacing="0" cellpadding="20" >
                              <caption>表格标题</caption>
                              <tr>
                                   <td></td>
                                   <th>小标题</th>
                              </tr>
                              rowspan 合并行
                              colspan 合并列
                               

                          </table>
               18.表单：<form action="要跳转的地址" method="get|post">
               19.文本框：<input type="text" name="username" placeholder="请输入账号" maxlength="6" size="33">
               20.密码框：< <input type="password" name="password" placeholder="请输入密码">></br>
               21.文件框：<<input type="file" name="photo">
               22.单选框：性别：
                          男：<input type="radio" name="sex" value="男" >
                          女：<input type="radio" name="sex" value="女" checked="checked">
               23.复选框：爱好：
                          抽烟：<input type="checkbox" name="hobby" value="chouyan">
                          喝酒:<input type="checkbox" name="hobby" value="hejiu">
                          烫头：<input type="checkbox" name="hobby" value="tangtou" checked="checked"> 
               24.下拉框：下拉框：省份：
                                 <select name="shengfen">
                                 <option value="真正的值"> 页面显示的内容 </option>
                                 <option value="shanxi">山西 </option>
                                 <option value="henan" selected="selected">河南</option>
                                 </select>
               25.多行文本框：留言：
                             <textarea cols="88" rows="7" name="liuyan" >23 </textarea>
                             <input type="submit" value="提交按钮">
                             <input type="reset" value="重置按钮">
                             <input type="button" value="自定义按钮">


14.CSS  1.概念：CSS是Cascading Style Sheets（级联样式表）的缩写,是一种样式表语言，用于为HTML文档定义布局
        2.css样式的种类：
                      1.行内样式标签：定义在某一个标签里面
                           1.写法<标签名 style="属性名：属性值；属性名：属性值">
                           2.作用范围：只作用于当前标签里面
                      2.内部样式表：定义在head里面
                           1.写法<head>
                                      <style>
                                             选择器{
                                                 属性名：属性值；
                                                 属性名：属性值；
                                                 。。。。。。
                                             }
                                      </style>
                                </head>
                           2.作用范围：作用于当前页面里面，如果内部样式和行内样式的属性重复了，优先使用行内样式。 
                      3.外部样式表：引用一个样式表文件
                           1.编写一个style.css的文件
                           2.在<head>
                               <link rel="stylesheet" type="text/css" href="style.css"/>
                                可引入多个
                               </head>
      3.css的选择器种类：
                      1.标签（标记）选择器
                        标签名{
                           属性名：属性值；
                           属性名：属性值；
                          }

                       作用范围：作用于同一个标签里面


                      2.id选择器 --（id是唯一的 id的值不能重复）
                       #id的值{ 属性名：属性值； }

                       作用范围： 只作用于当前的id里面


                      3. class选择器 类选择器 (class的值是可以重复的)
                       .class的值{属性名：属性值； }

                       作用范围： 作用于class一样的标签里面，class可以有多个是一样的

          
                      4. 通配符选择器 
                       *{属性名：属性值}
                        
                        作用范围：作用于整个页面


                      5.派生选择器
                      外部的标签 里面的标签 里面的标签{ 
                        属性名：属性值；
                      }
                      
                        作用范围：作用于单个标签
           
                      6.伪类选择器
                        ：active 向被激活的元素添加样式
                        ：hover 当鼠标悬浮在元素上方时，向元素添加样式
                        ：link 向未被访问过的链接添加样式
                        ：visited 向已被访问的链接添加样式



15.盒装模型：(布局)
         1.概念：盒状模型用于描述一个为HTML元素形成的矩形盒子，涉及为各个元素调整外边距(margin)、边框(border)、内边距(padding)、和内容的具体操作。
         2.span是横着的，div是竖着的
         3.绝对定位：position的属性值设为absolute,相对于最近的已定位祖先或者body的精确定位
         4.相对定位：position的属性值设为relative，其位置是相对于它在文档中的原始位置计算而来的(left,top)



16.mysql的常用命令
              1.进入mysql:Mysql -u账户 -p密码
              2.退出exit
              3.查看所有的数据库:show databases;
              4.创建数据库:create database if not exists 数据库名；
              5.删除数据库  drop database 数据库名
              6.使用某个数据库 use 数据库名
              7.查看表  show tables;
              8.查看索引  show index from 表名
              9.查看列名  show columns form 表名
              10更改表的信息 Alter table 表名  add|drop|modify|change  column 列名、类型等信息


17mysql语句：1.创建表 Create table 表名（
                       字段名1 数据类型 [约束] [comment 注释]，
                       字段名2 数据类型 [约束]，
                       。。。。
                       字段名n 数据类型[约束]
                       ）；
             2.添加所有列的记录
                       Insert  into 表名 values(值);  值与字段名一一对应；
             3.添加某些列的内容
                       Insert into 表名(字段名1，字段名2，。。)  values(值)； 值与（）l里面的字段一一对应；
             4.查看某张表里面的所有记录；
                       Select  *  from 表名；
             5.修改表里面的数据
                       Update 表名 set 字段名=值，字段名=值，字段名=值 [where 条件条件]
             6.删除某张表的数据
                       Delete from 表名 [where 条件]；
             7.删除表
                       delete table 表名
             8.查找在两个数值之间的数据条件 between>=   and<=
             9.从x开始查y个：limit(x,y)
            10.where和having：where后面不能使用聚合函数，having后面跟聚合函数，一般和group by一起使用
            11.顺序：select xx from xx left join on where
                                                    group by
                                                    having 
                                                    order by
                                                    limit

18.JDBC的连接：
             1.加载驱动
           Class.forName("com.mysql.jdbc.Driver");
         2.建立连接
          jdcb:mysql://ip地址：端口号/数据库的名字
          String url="jdbc:mysql://localhost:3306/java20";
              String user="root";
          String password="root";
          Connection conn=DriverManager.getConnection(url, user, password);
         3.准备sql
          String sql="select * from user";
          PreparedStatement  ps=    conn.prepareStatement(sql);
         4.执行sql
          ResultSet rs=ps.executeQuery();
         5.处理结果
          while(rs.next()){
              每一条记录  u_id ,u_name ,u_age,u_sex,d_id
              int u_id=rs.getInt(1);
              String u_name=rs.getString(2);*/          
              int u_id=rs.getInt("u_id");
              String u_name=rs.getString("u_name"); 
              System.out.println(u_id+";"+u_name);
            }
         6.断开连接，释放资源
          rs.close();
          ps.close();
          conn.close();


19.4.区别：
      1.ArrayList和LinkList的区别：
                  1.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构（了解） 
                  2.对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针（记忆） 
                  3.对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据（记忆）
      2.hashSet和treeSet的区别:
                  1.HashSet实现了Set接口。它和Set一样是无序的、不可重复的。和Set不同的就是，他的底层是HashMap，也就是说HashSet是HaspMap键的集合。
                  2.TreeSet实现了SortedSet接口，可以对元素自然排序，要求集合中的元素必须是可比较的。
      3.haspmap和hashtable以及tree的区别:
                  1.HashMap是一个最常用的Map，它根据键的hashCode值存储数据，根据键可以直接获取它的值，具有很快的访问速度。HashMap最多只允许一条记录的键为null，不允许多条记录的值为null。
                  2.Hashtable与HashMap类似，不同的是：它不允许记录的键或者值为空
                  3.LinkedHashMap保存了记录的插入顺序，在用Iteraor遍历LinkedHashMap时，先得到的记录肯定是先插入的。在遍历的时候会比HashMap慢。有HashMap的全部特性。
                  4.TreeMap能够把它保存的记录根据键排序，默认是按升序排序，也可以指定排序的比较器。当用Iteraor遍历TreeMap时，得到的记录是排过序的。TreeMap的键和值都不能为空。






代码题：1.随机出一个四位数的验证码，要求：4位，包括数子和字母
        2.把字符串里面的小写字母全部转换成大写字母
        3.判断一个字符串里面有几个数字和几个字母
        4.封装两个方法：1.把String转换为Date
                        2.把Date转换为String
        5.计算字符串里面每个字符出现的个数
        6.网页制作
        7.JBDC连接的封装