笔记
笔记
HTML篇
***************************************************************************************************************
【第一章】HTML基础
·基本框架:
<html> ---文档标签
<head> ---头部标签
<title></title>---导航栏标题标签
</head>
<body> ---主体标签
</body>
</html>
·特殊符号标签:
空格
< 小于号(“<”)
> 大于号(“>”)
" 引号
© 版权符号
<p></p> 段落标签
<hr/> 分割线标签
<br/> 换行标签
<b></b> 加粗标签
<s></s> 删除线标签
<u></u> 下划线标签
<em></em>或<i></i> 字体斜体标签
<small></small> 字体缩小标签
<h1></h1>-<h6></h6> 标题标签 (h1最大，h6最小)
·图像标签 <img/>
属性：
src="" 图像的路径地址 （目录+文件名+格式）
alt="" 图像加载错误时提示文字
title="" 鼠标悬停图片上方提示文字
width="" 图像宽度
height="" 图像高度
<img src="../../图像.png">图像路径返回上一级
·超链接标签 <a></a>
属性：
href=" " 链接路径 （目录+文件名+格式）
name=" " 锚链接标记
target=" "链接到那个窗口打开
_self ---自身页面跳转 (默认)
_blank ---新建页面跳转
<a href="#"> </a> ---刷新自身页面
锚链接创建步骤：
1、在乙位置做标记: <a name="名字">乙位置</a>
2、在甲位置跳转:
1.本页面跳转 <a href="名字">甲位置</a>, 从本页的甲位置跳转到本页中标记的乙位置
2.跨页面跳转 <a href="b页面.html#名字">甲位置</a> （B页面.html + #标记名）, 从a页面的甲位置跳转到b本页中标记的乙位置
---------------------------------------------------------------------------------------------------------------
【第二章】列表、表格与框架
·无序列表 <ul></ul>
<ul> ---声明无序列表
<li>橘子</li> ---声明无序列表项
</ul>
属性：
type=" "
值： "disc " 实心圆（默认值）
"circle" 空心圆
"square" 实体方心
"none " 无符号
内容编辑状态（适用于所有标签）
contentEditable="true" 可编辑
"false" 不可编辑（默认）
·有序列表 <ol></ol>
<ol> ---声明有序列表
<li></li>--声明有序列表项
</ol>
属性：
type=" "
值： " 1 " 数字（默认值）
"a/A" 小写/大写字母
"i/I" 小写/大写罗马数字
start=" " 有序列表符号开始值（只能用数字，包含设置值）
内容编辑状态（适用于所有标签）
contentEditable="true" 可编辑
"false" 不可编辑（默认）
·定义列表 <dl></dl>
<dl></dl> ---声明定义列表
<dt></dt> ---声明定义列表项
<dd></dd> ---定义列表项内容
内容编辑状态（适用于所有标签）
contentEditable="true" 可编辑
"false" 不可编辑（默认）
定义列表代码结构：
<dl>
<dt>111</dt>
<dd>222</dd>
<dt>111</dt>
<dd>222</dd>
</dl>
·表格 <table></table>
<table> ---表格标签
<tr> ---行标签
<td>第1个单元格的内容</td>---单元格标签
<td>第2个单元格的内容</td>
</tr>
</table>
属性:
border=" " ---表格边框（“0”无【默认】，“1”有）
width= " " ---表格宽度
height=" " ---表格高度
表格或单元格水平对齐方式：
align="left" 左对齐 （默认）
"center" 居中对齐
"right " 右对齐
单元格垂直对齐方式：
valign="top" 顶端对齐
"middle" 居中对齐（默认）
"bottom" 底端对齐
"baseline"基线对齐
表格背景颜色 <table style="background-color:red"></table>
列样式 <col>
列组样式 <colgroup></colgroup>
例：
<colgroup style="background-color:#ff0000"> ---列样式
<col> ---第一列样式
<col> ---第二列样式
</colgroup>
横是行，竖是列，跨列删身后，跨行删身下
rowspan="行数" ---跨行
colspan="列数" ---跨列
·内联框架 <iframe></iframe>
属性：
src ="引用页面.html" 引用地址
name="" 名字
frameborder="" 框架边框 （“0”无边框 “1”有边框【默认】）
scrolling="" 是否有滚动条 （“yes”有【默认】 “no”无 “auto”自动）
noresize="" 禁止调整框架窗口大小
width="" 框架宽度
height="" 框架高度
<a href="引用页面.html" target="标记名字" frameborder="0">显示文字</a> ---框架超链接
代码结构：
<a href="百度.html" target="clj">百度</a>
<iframe src="首页.html" name="clj" frameborder="0" scrolling="no" width="300" height="300">
</iframe>
· 集合框架 <frameset></frameset>
<frameset>
cols="" 框架集合列的数目和尺寸 （例: "20%,*"）
rows="" 框架集合行的数目和尺寸
<frame></frame> 框架标签
</frameset>
---------------------------------------------------------------------------------------------------------------
【第三章】表单
·表单<form></form>
属性：
method="" 表单提交方式 （路径+页面+格式）
action="" 表单提交到的页面
属性取值范围：
method=" " ---表单提交方式
常用值: get ---地址栏提交方式（默认）
post ---表单提交
action="xxx.html" ---表单提交到的页面
enctype="multipart/form-data" ---文件域编码属性
表单元素标签 <input type="表单元素"/>
表单元素:
"text" 文本框
"password" 密码框
"submit" 提交按钮
"reset" 重置按钮
"radio" 单选按钮 (注:名字相同为一组，一组只能选择一个)
"checkbox" 多选按钮
"file" 文件域 （配合form表单中的enctype文件域编码属性使用）
"image" 图片提交按钮
"button" 普通按钮
"hidden" 隐藏域
表单元素类型标签属性:
name="name" ---元素标示名字
value="" ---元素初始值
size="21" ---初始宽度 （默认“20”像素）
maxlength="16" ---输入的最大字符数
checked="checked" ---按钮默认被选中 （注：也适用于多选按钮）
autofocus="autofocus" ---让元素在页面打开时自动获取焦点
placeholder="请输入账号" ---对用户输入进行提示
readonly="readonly" ---只读
disabled="disabled" ---禁用
·点击内容按钮或文本框被选中：
<input type="text" id="bj"> ---标记
<label for="bj"></label>---点击内容按钮被选中(id不能重复)
好处：1.增强鼠标可用性。
2.自动将焦点转移到与该标注相关的表单元素上。
·多行文本域 <textarea></textarea>
<textarea>文本域内容</textarea>
属性：
name="" ---标识名字
cols="" ---列数
rows="" ---行数
value="" ---初始值
·下拉列表框 <select></select>
属性：
name=" " ---列表框标识名称
size=" " ---显示的行数 （默认“1”行）
<option></option> ---选项
selected="selected" ---列表框默认选择项
代码结构：
<select name="列表框名称" size="2">
<option value="选项的值"> 显示内容 </option>
<option value="选项的" selected="selected" >显示内容 </option>
</select>
·文件域代码结构：
<form enctype="multipart/form-data">
<input type="file" name="" value=""/>
</form>
·域标签：
<fieldset> ---域标签
<legend></legend> ---域标题标签
</fieldset>
---------------------------------------------------------------------------------------------------------------
【第四章】初始CSS（CSS:层叠样式表）
·CSS基本语法：
选择器{
声明1； ---声明=属性：值；
声明2；
}
样式标签 <style type="text/css"> </style>
(注：样式标签必须写在head标签内。)
·CSS选择器（优先级）：
ID选择器 > 类选择器 > 标签选择器
标签选择器：
标签名{
声明1；
声明2；
}
<标签名> </标签名>
类选择器：
.类名称{
声明1；
声明2；
}
<标签名 calss="类名称"> </标签名>
ID选择器：
#ID名称{
声明1；
声明2；
}
<标签名 ID="ID名称"> </标签名>
·HTML中引入CSS样式
行内样式：
<p style="color:red"> </h1>
内部样式：
<style type="text/css">
选择器{
声明；（声明=属性:值;）
}
</style>
外部样式：
1、链接外部样式表（优先级选用）：
<link/> ---外部链接标签
href="xxx.css" ---文件路径
type="text/css" ---文件类型
rel="stylesheet" ---页面与文档被链接的关系
例:<link href="xxx.css" type="text/css" rel="stylesheet"/>
2、导入式：
<style type="text/css">
@import "样式表文件名.css";
</style>
CSS样式优先级：行内样式>内部样式>外部样式（就近原则）
·CSS复合选择器
后代选择器(空格隔开)：
p a{
color:red;
font-size:20px;
}
（注：外层的标签写在外面，内层的标签写在里面，在CSS选择器中通过嵌套的方式，之间用空格隔开，内层的标签单独实现效果）
交集选择器（连续写）：
p#id{
color:red;
font-size:20px;
}
（注：两个选择器直接构成，第一个必须是标签选择器，第二个必须是类选择器或ID选择器
，选择器之间不能有空格必须连续写，即可实现各自元素范围的交集效果
）
并集选择器（逗号隔开）
：
a,#id{
color:red;
font-size:20px;
}
(注：多个选择器通过逗号连接，同时声明风格实现相同样式)
---------------------------------------------------------------------------------------------------------------
【第五章】CSS美化网页元素
<span></span>标签
---设置样式，突出显示文字。
·字体样式：
font-family:"楷体";
---设置字体类型
font-size:20px;
---设置字体大小 单 位：px（像素）、em(当前一个字体的尺寸)
font-style
:italic;
---设置字体风格 常用值：normal（正常）、italic（斜体）、oblique（倾斜体）
font-weight
:bold; ---设置字体粗细 常用值：normal（正常）、bold（粗的）、bolder（更粗的）、lighter（细的）、取值：100-900
font:italic bold 36px "宋体";
---声明中设置所有字体属性
设置顺序：字体风格→字体粗细→字体大小→字体类型
·文本样式：
color:#06B; ---设置文本颜色 （例:0066BB简写为：06B）
text-align:right; ---设置元素水平对齐方式 常用值：left（左）、cneter（中）、right（右）、justify（两端对齐）
text-indent:2em; ---设置首行文本缩进 单 位：em(当前一个字体的尺寸)、px（像素）
line-height:20px; ---设置文本行高
text-decoration:underline; ---设置文本的装饰 常用值：none(标准)、underline（下划线）、line-through（删除线）、overline（上划线）、blink（闪烁）
vertical-align:middle; ---设置垂直对齐方式 常用值：top（上）、middle（中）、bottom（下）
·超链接伪类：
标签名:伪类名{
color:red;
}
伪类名：a:link
---未单击访问时超链接样式
a:visited
---单击访问后超链接样式
a:hover ---鼠标悬浮超链接上方样式
a:active
---鼠标单击未释放的超链接样式
设置伪类的顺序: a:link > a:visited > a:hover > a:active
text-decoration:none; ---超链接去除下划线
·设置鼠标形状
：
标签名{
cursor:pointer;
}
常用值：default
---默认光标
pointer
---超链接的指针
wait
---指示程序正在忙
help ---指示可用的帮助
text ---指示文本
crosshair ---鼠标呈现十字状
·网页背景：
background-color:#ff0000; ---背景颜色
background-image:rul(图片路径) ---背景图像
background-repeat:repeat; ---背景重复方式 常用值：repeat（沿水平和垂直两个方向平铺
）、no-repeat（不平铺，即只显示一次
）、repeat-x（只沿水平方向平铺
）、repeat-y（只沿垂直方向平铺
）
background-position:x% y%; ---背景定位 常用值：Xpx（水平） Ypx（垂直
）、X% Y%（百分比表示背景的位置）、X方向关键词（left、center、right）、Y方向关键词（top、middle、bottom）
background:#red url(../image/image.png) 205px 10px no-repeat;
---设置背景
设置顺序:背景颜色 > 背景图像 > 背景定位 > 背景重复方式
·列表样式：
list-style-type:none; ---列表样式类型 常用值：none（无标记符号）、disc（实心圆【默认】）、circle（空心圆）、square（实体正方形）、decimal（数字）
list-style-image:url(image.gif);
---列表样式图像
list-style-position:inside; ---列表样式定位 常用值：inside（文本根据符号对齐）、outside（文本不根据符号对齐）
list-style:circle outside url(image/arrow-right.gif); ---列表样式 顺序：类型 > 定位 > 图像
---------------------------------------------------------------------------------------------------------------
【第六章】盒子模型
<div> ---盒子模型标签
网页内容…
</div>
css样式：div{
width:200px;
height:280px;
}
·边框样式：
border-top-color:#f00; ---上边框颜色
border-right-color:#f00; ---右边框颜色
border-bottom-color:#f00; ---下边框颜色
border-left-color
:#f00; ---左边框颜色
border-color:#f00; ---四个边框为同一颜色
border-color:#f00 #3f6; ---上下边框的颜色为:#f00 左右边框的颜色为:#3f6
border-color:#f00 #0b0 #00f; ---上边框的颜色为:#f00 左右边框的颜色为:#0b0 下边框的颜色为:#00f
border-color:#f00 #0f0 #00f #fff; ---分别是上、右、下、左边框的颜色
border-width:10px; ---边框粗细 常用值:thin(细)、medium(不细不粗)、
thick(粗
)、像素值
border-style:none; ---边框样式 常用值:none（
无）、hidden（
无）、dotted（
点状）、dashed（
虚线）、
solid（
实线）、
double（双线）
border:9px #F00 dashed; ---
边框 顺序:粗细、颜色、样式
·外边距
margin:10px; ---外边距 (ps: margin:0px auto; 居中网页居中对齐
)
margin-top:10px; ---上外边距
margin-right:10px; ---右外边距
margin-bottom:10px; ---下外边距
margin-left:10px; ---左外边距
·内边距
padding:10px; ---内边距
padding-top:10px; ---上内边距
padding-right:10px; ---右内边距
padding-bottom:10px; ---下内边距
padding-left:10px; ---左内边距
---------------------------------------------------------------------------------------------------------------
【第七章】浮动
float ----元素浮动 常用值:left(左浮动)、right(右浮动)、none(不浮动，默认)
clear ----清除浮动
常用值:left(左侧不允许浮动)、right(右侧不允许浮动)、both(两侧不允许浮动)、none(允许浮动，默认)
overflow ----溢出处理
常用值:visible(内容不会被修剪，会呈现在盒子之外)、hidde(内容会被修剪，并且其余内容是不可见的
)、
scroll(内容会被修剪，但是浏览器会显示滚动条以便查看其余内容)、
auto(如果内容被修剪，则浏览器会显示滚动条以便查看其余的内容)
---------------------------------------------------------------------------------------------------------------
【第八章】定位
position:static; ----元素定位
常用值:static(默认值，没有定位)、relative(相对定位)、absolute(绝对定位
)、fixed(固定定位)
偏移设置:top、right、bottom、left
z-index:0; ----调整元素定位时重叠层的上下位置
属性值:整数，默认值为0 z-index值大的层位于其值小的层上方
opacity:x ----元素透明度 属性值:x值为0~1，值越小越透明
filter:alpha(opacity=x) ----元素透明度 属性值:x值为0~100，值越小越透明
Java篇
***************************************************************************************************************
【第一章】JAVA基本框架
程序：为了让计算机执行某些操作或解决某个问题，而编写的一系列有序指令的集合。
·JAVA程序框架
public class 类名{ ---外层框架（类名同文件名）
public static void main(String[] args){ ---Java入口程序框架
System.out.println("输出的内容"); ---输出指令
}
}
main入口四要素：返回值类型 方法名 参数 方法体
println ---输出信息并执行换行
print ---输出信息不执行换行
\n ---换行符
\t ---制表符(8个空格)
//注释内容 ---单行注释
/*
*注释内容 ---多行注释
*/
---------------------------------------------------------------------------------------------------------------
【第二章】变量、数据类型和运算符
·变量
变量是存储数据的一个单元。
语法：
方法一：
int money=1000; ---数据类型 变量名=数值; //声明变量并赋值
方法二：
int money; ---数据类型 变量名; //声明变量
money=1000; ---变量名=数值; //赋值
·数据类型
char ---字符型（单个字符 如:‘男’）
int ---整 型（整数）
double ---双精度（小数）
String ---字符串（一串字符 如:"我是Java"）
boolean ---布尔型 返回值：true真、false 假
变量名命名规则：
首字母：字母、下划线‘_’、‘$’符号
其余部分：数字、字母、下划线‘_’、‘$’符号
·运算符
语法：
赋值运算符：=（变量名=表达式;（右→左）
算数运算符：+（加）、-（减）、*（乘）、/（除）、 %（余）
类型自动转换：
在某种条件下，系统自动完成类型转换
两种类型兼容（如：int和double兼容）
目标类型大于源类型（如：double型大于int型）
对于表达式：如果一个操作数为double型，则整个表达式提升为double型。
类型强制转换：类型 变量名=（类型名）表达式;
如：int a=20;
double b=9.8;
int zh=(int)(a+b);
System.out.println(zh);
i++; //先执行在加1
++i; //先加1再执行
数值交换代码实例：
public class Test {
public static void main(String[] args) {
/*
* 题目：
* A默认输出的是3，B默认输出的是6，利用类型转换将A输出为6，B输出为3，实现两个数值的交换。
* 效果如下：
* 转换前 A：3 B：6
* 转换后 A：6 B：3
* */
//声明变量
int a=3;//声明变量A并赋值
int b=6;//声明变量B并赋值
int c;//声明一个空变量
//输出转换前结果
System.out.println("转换前A："+a);
System.out.println("转换前B："+b);
//进行数据转换
c=a;
a=b;
b=c;
//输出转换后结果
System.out.println("转换后A："+a);
System.out.println("转换后B："+b);
}
}
---------------------------------------------------------------------------------------------------------------
【第三章】选择结构
·关系运算符
>（大于）、<（小于）、==（等于）、!=（不等于）、>=（大于等于）、<=（小于等于）
·逻辑运算符
*******************************************************************
* 运算符 * 表达式 * 说明 *
* &（且） * 条件1&条件2 * 前者条件为真时，仍然执行后者条件 *
* |（或） * 条件1|条件2 * 前者条件为假时，仍然执行后者条件 *
* && * 条件1&&条件2 * 仅仅两个条件为真，结果为真 *
* || * 条件1||条件2 * 只要两个条件一个为真，结果为真 *
* !（非） * ！条件 * 条件为真时，结果为假。 *
* * * 条件为假时，结果为真。 *
*******************************************************************
·基本if选择结构
if(条件){
//语句
}
·if-else选择结构
if(条件){
//语句1
}else{
//语句2
}
·多重if选择结构
if(条件){
//语句1
}else if(条件){
//语句2
}else{
//语句3
}
·switch结构
switch(条件)
{
case 1:
语句;
break;
case 2:
语句;
break;
default:
语句;
break;
}
·运算符优先级
最高的优先级：小括号，即()
最低的优先级：赋值运算符，即=
优先级顺序：! > 算术运算符 > 比较运算符 > && > ||
·接收数据功能
语法:
import java.util.Scanner;
Scanner input=new Scanner(System.in); //声明接收数据功能
int a=input.nextInt(); //接收输入的内容
例:
import java.util.Scanner;
public class Boolean {
public static void main(String[] args){
Scanner input=new Scanner(System.in);
System.out.print("请输入姓名："); //提示用户输入
String name=input.nextInt() //接收数据
}
}
sr.equals("y") ---字符串型String比较
System.out.print("请输入第一个数值："); //判断是不是数值
if (input.hasNextDouble()) {
a = input.nextDouble();
} else {
System.out.println("您输入的不是一个数值");
}
---------------------------------------------------------------------------------------------------------------
【第四章】循环结构（一）
·while循环
语法：
while(循环条件){
循环操作
}
特点：先判断，再执行。
·do-while循环
语法：
do{
循环操作
}while(循环条件);
特点：先执行，再判断。
---------------------------------------------------------------------------------------------------------------
【第五章】循环结构（二）
·for循环结构
语法：
for(表达式1;表达式2;表达式3){ // 表达式1(参数初始化);表达式2（条件判断）;表达式3(更新循环变量)
循环操作;
}
for (类型 变量名 : 源数据变量名) { //循环遍历（数组。集合）
System.out.println(源数据变量名);
}
·跳转语句
break; //跳出循环（用于do-while、while、for中时，可跳出循环而执行循环后面的语句）
continue; //跳过本次循环
return; //结束程序
---------------------------------------------------------------------------------------------------------------
【第六章】数组
数组是一个变量，存储相同数据类型的一组数据，数组的下标从0开始。
·语法
声明数组：
方法一：
数据类型 数组名[];
方法二：
数据类型[] 数组名;
声明数组并分配空间：
数据类型[] 数组名 = new 数据类型[大小];
赋值：
数组名[下标] = 数据;
声明数组批量赋值：
数据类型[] 数组名 = new 数据类型[]{1,2,3,4,5};
·使用数组步骤
1、声明数组 int[]a;
2、分配空间 a=new int[5];
3、赋值 a[0]=80;
4、处理数据 a[0]=a[0]*10;
·排序输出：
import java.util.Arrays; // 声明排序功能类包
public class Test{
public static void main(String[] args) {
int [] a=new int[]{3,5,4,1,2}; // 声明数组并赋值
Arrays.sort(a); // 声明排序功能
//循环输出进行1-5升序排列输出
for(int i= 0; i<a.length; i++){
System.out.print(a[i]+"，"); // 循环输出打印
}
}
}
生成随机数
int max = 9999;//最大值
int min = 1000;//最小值
int a=(Math.random()*个数);//生成随机数
例：
System.out.print("产生的随机数是：");
for (int i = 0; i <= 9; i++) {
int a=(int) (Math.random()*9);
System.out.print(a+" ");
}
---------------------------------------------------------------------------------------------------------------
【第七章】类和对象
·对象同时具有属性和方法两种特性。
属性：所有对象的公共特征，作用：区分各个对象
方法：所有对象的公共操作
·类和对象的区别？
类是对象的抽象，对象是类的具体实例。
类是抽象的，不占用内存，而对象是具体的，占有内存空间。
例如：类就是水果，对象就是苹果。
·Java类模板
public class 类名{
//定义属性部分
属性1的类型 属性1;
属性2的类型 属性2;
//定义方法部分
方法1;
方法2;
}
·定义一个类的步骤
1.定义类名
public class 类名{
}
2.编写类的属性
String name;
3.编写类的方法
public String 方法名(){
return "姓名："+name";
}
·如何创建和使用对象
1.使用new创建类的一个对象
类名 对象名=new 类名(); Yuntuschool luoyang=new Yuntuschool();
2.给类的属性赋值：
对象名.属性=值; luoyang.name="洛阳";
3.调用类的方法：
对象名.方法名(); System.out.println(luoyang.方法名());
---------------------------------------------------------------------------------------------------------------
【第八章】类的方法（一）
·语法
public 返回值类型 方法名(){
//方法体
}
·返回值类型
void //无返回值
return //有返回值(String int double char boolean)
在同一个类中调用方法可直接调用，在另一个类调用方法要先创建一个类对象然后通过(对象名.方法名)调用方法。
import 包名.类名; //调用类
package 包名; //声明包
import 包名; //导入包
·JavaDoc注释
JavaDoc注释用于注释类
语法：
/**
* 测试类
* @author 阿华
* @time 2017-5-8
*/
---------------------------------------------------------------------------------------------------------------
【第九章】类的方法（二）
·定义带参数的方法
访问修饰符 返回值类型 方法名(形参1,形参2,形参...){
方法的主体
return 返回值;
}
·调用带参数的方法
对象名.方法名(实参1,实参2,实参...);
实参的名字可以形参和不一样，但是类型、数量、顺序都要与形参一一对应。
---------------------------------------------------------------------------------------------------------------
【第十章】字符串
·方法
.equals() 将此字符串与指定的对象比较。返回类型为boolean型
.length() 确定字符串长度。返回类型int型
.equalsIgnoreCase("") 将此 String 与另一个 String 比较，不区分大小写。返回类型为boolean型
.toUpperCase().equals("") 将此 String 中的所有字符都转换为大写。返回类型为String类型
.toLowerCase().equals("") 将此 String 中的所有字符都转换为小写。返回类型为String类型
.concat() 将指定字符串连接到此字符串的结尾。返回类型为String类型
.split() String类提供了split()方法，将一个字符串分割为多个子字符串，返回类型为String类型数组。
·字符串常用提取方法
·搜索第一个出现的字符ch（或字符串value） 返回类型为String类型
public int indexOf(int ch)
public int indexOf(String value)
·搜索最后一个出现的字符ch（或字符串value）返回类型为int类型
public int IastIndexOf(int ch)
public int IastIndexOf(String value)
（返回出现第一个匹配的位置，如果没有找到字符串或字符，则返回-1）
·提取从索引位置开始的字符串，返回类型为String类型
public String substring(int index)
·提取beginindex和endindex之间的字符串部分
public String substring(int beginindex,int endindex)
beginindex: 字符串的位置从0开始算(包含当前位置)；
endindex: (不包含当前位置)
·去除两端的空格 返回类型为String类型
public String trim()
·StringBuffer类（String增强版）
·StringBuffer声明：
StringBuffer sb=new StringBuffer(); //创建StringBuffer对象
StringBuffer sb=new StringBuffer("aaa"); //创建一个变量存储字符串
·StringBuffer使用：
sb.toString(); //转化为String类型
sb.append("**"); //追加字符串
sb.insert (1, "**"); //插入字符串
---------------------------------------------------------------------------------------------------------------
【第十一章】抽象和封装
Java语言的三大特性：封装、继承、多态
·类图
------------------------
| 类名 |
|------------------------|
|+属性名:类型 |
|------------------------|
|+方法名(参数):返回值类型|
------------------------
+public 公共
-private 私有
参数：名字:类型,名字:类型
·构造函数
访问修饰符 构造方法名(参数){//构造方法名与类名相同
//初始化代码
}
系统会提供默认的无参构造方法，如果自己写了一个自定义构造方法系统将不再提供默认无参构造方法。
添加构造函数快捷键：
有参：Shift+Alt+S,选择Generate ... using Fields
无参：Shift+Alt+S,选择Generate ... Superclass
方法重载特征：方法名相同；
参数项不相同；
与返回值、访问修饰符无关；
·封装
将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问
封装的步骤：
1.修改属性的可见性 → 设为private
2.创建公有的getter(获取)/setter(设置)方法 → 用于属性的读写
3.在getter/setter方法中加入属性控制语句
→ 对属性值的合法性进行判断
添加getter/setter方法的快捷键：Shift+Alt+S,选择Generate ... and Setters
·static关键字
使用static定义变量：
static final String NAME="张三";
static:静态
final:常量(常量名大写,用final修饰的变量成为常量，其值固定不变)
使用static定义方法：
static void print(){}
Penguin.print();//用类名.方法名()调用
·使用面向对象的思想开发程序的好处：
1.客户和软件设计开发人员之间、软件设计开发人员内部交流更加顺畅
2.
提高软件设计和开发效率
·
从现实世界抽象出类：
1.找出名词确定类、属性
2.找出动词确定方法
3.
剔除与业务无关的属性和方法
·static修饰与非static修饰的区别：
-------------------------------------------------------------
| |static非private修饰 |非static、private修饰|
|---------------|-----------------------|---------------------|
|属性 |类属性、类变量 |实例属性、实例变量 |
|---------------|-----------------------|---------------------|
|方法 |类方法 |实例方法 |
|---------------|-----------------------|---------------------|
|调用方式 |类名.属性 |对象.属性 |
| |类名.方法()
|对象.方法() |
| |对象.属性 | |
| |对象.方法() | |
|---------------|-----------------------|---------------------|
|归属 |类 |单个对象 |
-------------------------------------------------------------
注：static可以修饰属性、方法、静态块
---------------------------------------------------------------------------------------------------------------
【第十二章】继承
一个父类可以有很多子类，但是一个子类只能有一个父类，子类与父类是is-a关系
·优点：方便修改代码，减少代码量
·如何使用继承
1、编写父类
class Pet {
//公共的属性和方法
}
2、编写子类，继承父类(只能继承一个父类)
class Dog extends Pet {//子类 extends 父类
//子类特有的属性和方法
}
·子类访问父类成员
（1）使用super关键字，super代表父类对象。
（2）在子类构造方法中调用且必须是第一句。
（3）不可以访问父类中定义为private的属性和方法。
·访问父类构造方法
super();//调用父类的无参构造
super(name); //调用父类的带参构造 super(属性1,属性2,属性3...)
·访问父类属性
super.name;
·访问父类方法
super.print();//super.方法名 调用父类的方法
·不能被继承的父类成员
1、private成员
2、子类与父类不在同包，
使用默认访问权限的成员
3、构造方法
访问修饰符protected： 可以修饰属性和方法， 本类、同包、子类可以访问。
·访问修饰符
|访问修饰符 |本类 |同包|子类|其他|
|private |√ | | | |
|默认(friendly)|√ |√ | | |
|protected |√ |√ |√ | |
|public |√ |√ |√ |√ |
private 私有的、friendly 友好的、protected 受保护、public 公开
·多重继承关系的初始化顺序
父类属性→父类构造
方法
→子类属性
→子类构造
方法
符合is-a关系的设计使用继承，继承是代码重用的一种方式
，将子类共有的属性和行为放到父类中
·方法重写规则：
1.方法名相同
2.参数列表相同
3.返回值类型相同或者是其子类
4.访问权限不能严于父类
·方法重载与方法重写区别：
| |位置 |方法名 |参数表 |返回值 |访问修饰符 |
|方法重写 |子类 |相同 |相同 |相同或是其子类 |不能比父类更严格|
|方法重载 |同类 |相同 |不相同 |无关 |无关 |
·抽象类
1.抽象类不能实例化
2.抽象类中不一定有抽象方法，但抽象方法必须在抽象类中，
3.抽象方法必须在每个子类中重写
4.“子类重写”正好解决抽象方法的实例化问题
5.非抽象类必须重写父类的所有抽象方法
定义一个抽象类：
public abstract class A{
}
·抽象方法
1.抽象方法没有方法体
2.抽象方法必须在抽象类里
3.抽象方法必须在子类中被实现，除非子类是抽象类
定义一个抽象方法：
public abstract void print();
final 最终的，其值是固定不变的
---------------------------------------------------------------------------------------------------------------
【第十三章】多态
同一个引用类型，使用不同的实例而执行不同操作
好处:多态可以减少类中代码量，提高代码的可扩展性和可维护性
·使用多态实现思路
1.编写父类
编写子类，子类重写父类方法
2.运行时，使用父类的类型，子类的对象
实现多态的两个要素
：子类重写父类方法、使用父类的类型,子类的对象
·实现多态的两种形式
1.将父类作为方法形参实现
2.将父类作为方法返回值实现
·向上转型(子类转换为父类，自动进行类型转换
)
Pet pet = new Dog(); 自动类型转换
·向下转型(父类转换为子类，结合instanceof运算符进行强制类型转换)
Pet p = new Dog("欧欧", "雪娜瑞");
Dog d = (Dog)p;//将父类p转换为Dog类
Penguin png = (Penguin) pet;//×父类必须指向真实的子类类型
·instanceof运算符
用来在运行时指出对象是否是特定类的一个实例
语法：
对象 instanceof 类或接口
注：instanceof通常和强制类型转换结合使用
---------------------------------------------------------------------------------------------------------------
【第十四章】接口
·使用接口步骤：
1.编写接口(interface)：
public interface Usb{
public void lianjie();//所有方法都是抽象方法
}
2.实现接口(implements)：
public class Upan implements Usb {//多个接口使用,分隔
public void lianjie() {
System.out.println("已连接USB");
}
}
3.使用接口：
Usb u = new Upan();
u.lianjie();
·接口特性：
1、
接口不可以被实例化
2、子类必须实现接口的所有方法
3、子类可以实现多个接口
4、
接口中的变量都是静态常量
5、接口中所有方法都是抽象的公共的
抽象类利于代码复用，接口利于代码维护
实现类和接口是has-a的关系
·接口比抽象类更好的特性：
1.可以被多继承
2.设计和实现完全分离
3.更自然的使用多态
4.更容易搭建程序框架
5.更容易更换实现
·面向接口编程：
程序设计时面向接口的约定(方法+名称)而不考虑具体实现
---------------------------------------------------------------------------------------------------------------
【第十五章】异常
异常是指在程序的运行过程中所发生的不正常的事件，它会中断正在运行的程序
input.hasNextInt(); //判断下一个接收的值是否是整数
System.exit(1); //终止程序
·异常处理：
通过5个关键字来实现：try、catch、 finally、throw、throws
------------------------------------------------------------------------
| 捕获异常 | 声明异常 | 抛出异常 |
|--------------------------------|-----------------------|-------------|
| try→ 执行可能产生 | throws | throw
|
| 异常的代码
| ↓ | ↓ |
| | 声明方法可能要 |手动抛出异常 |
| | 抛出的各种异常 | |
|--------------------------------| | |
| catch→ 捕获异常
| | |
|--------------------------------| | |
| finally→
无论是否发生异常，代 | | |
|
码总能执行
| | | ------------------------------------------------------------------------
·捕获异常
try {
// 代码段(此处不会产生异常)
} catch (异常类型1 ex) {
// 对异常进行处理的代码段
} catch (异常类型2 ex) {
// 对异常进行处理的代码段
return;
} finally {
}
//代码段
finally:
1、是否发生异常都执行
2、System.exit(1);情况下不执行
System.err.println();//打印错误信息
e.printStackTrace();
//调用方法输出异常信息
·异常对象常用的方法
-----------------------------------------------------------------------------------
| 方法名 | 说 明 |
|-----------------------|-----------------------------------------------------------|
|void printStackTrace() |输出异常的堆栈信息 |
|String getMessage() |返回异常信息描述字符串，
是printStackTrace()输出信息的一部分|
-----------------------------------------------------------------------------------
·常见的异常类型
-----------------------------------------------------------------------
| 异 常 类 型 | 说 明 |
|-------------------------------|---------------------------------------|
|Exception |异常层次结构的父类 |
|ArithmeticException |算术错误情形，如以零作除数 |
|ArrayIndexOutOfBoundsException |数组下标越界 |
|NullPointerException |尝试访问 null 对象成员 |
|ClassNotFoundException |不能加载所需的类 |
|IllegalArgumentException |方法接收到非法参数 |
|ClassCastException |对象强制类型转换出错 |
|NumberFormatException |数字格式转换异常，如把"abc"转换成数字 |
|InputMismatchException |输入的数据类型与所需类型不匹配异常 |
-----------------------------------------------------------------------
·抛出异常
public static void a() throws Exception {//多个
异常逗号隔开
//可能出现异常的代码
}
throw new Exception("");//自定义手动抛出异常
·面试题：
·try-catch块中存在return语句，是否还执行finally块，如果执行，说出执行顺序
答：是，try-catch-finally执行顺序：
1.执行try{}块
2.如果try{}块有异常产生，执行catch{}块
3.无论有没有异常都要执行finally{}块，这里可以看出只要finally中有return，必然返回finally{}中的return
·try-catch- finally块中，finally块唯一不执行的情况是什么？
答：当你在捕获到异常的处理代码里加上：System.exit();时不执行
·说出5个常见的运行时异常
答：见上面异常类型
·
throw与throws的区别是什么？
答：throw是语句抛出异常，throws是方法可能抛出异常的声明。
·开源日志记录工具log4j
日志(log)：
主要用来记录系统运行中一些重要操作信息
便于监视系统运行情况，帮助用户提前发现和避开可能出现的问题，或者出现问题后根据日志找到原因
日志分类：
SQL日志、异常日志、业务日志
log4j是一个非常优秀的开源日志记录工具：
控制日志的输出级别
控制日志信息输送的目的地是控制台、文件等
控制每一条日志的输出格式
控制日志输出级别：
fatal:致命的
↓
error:错误消息
↓
warn:警告信息
↓
info:一般消息
↓
debug:调试消息
↓
自定义
使用log4j记录日志步骤：
1.在项目中加入log4j的JAR文件
2.创建log4j.properties文件
3.配置日志信息：
1、输出级别
2、日志输出目的地Appender
3、日志布局类型Layout
4、转换模式ConversionPattern
4.使用log4j记录日志信息：
private static Logger logger=Logger.getLogger（类名.class）
logger.输出级别("错误描述")
---------------------------------------------------------------------------------------------------------------
【第十六章】集合框架
Java集合框架提供了一套性能优良、使用方便的接口和类位于java.util包中
·接口
Collection Map
↑ ↑
----------------------- ---------------
| | | |
List Set HashMap HashMap
↑ ↑
----------- -------
| | | |
ArrayList LinkedList
HashSet
TreeSet
集合接口：
Collection 接口存储一组不唯一，无序的对象
List 接口存储一组不唯一，有序（插入顺序）的对象
Set 接口存储一组唯一，无序的对象
Map 接口存储一组键值对象，提供key到value的映射
集合实现类：
ArrayList 实现了长度可变的数组，在内存中分配连续的空间。遍历元素和随机访问元素的效率比较高 LinkedList 采用链表存储方式。插入、删除元素率比较高
·List接口
·ArrayList集合类
创建ArrayList集合对象：
ArrayList<存储元素的数据类型> 对象名 = new ArrayList<存储元素的数据类型>();
·List接口常用方法
----------------------------------------------------------------------------------------------------------
| 方法名 | 说明 |
|-------------------------------|--------------------------------------------------------------------------|
|boolean add(Object o) |在列表的末尾顺序添加元素，
起始索引位置从0开始 |
|void add(int index,Object o) |在指定的索引位置添加元素。
索引位置必须介于0和列表中元素个数之间 |
|int size() |获取列表中的元素个数 |
|Object get(int index) |获取指定索引位置处的元素,取出的元素是Object类型,使用前需要进行强制类型转换|
|boolean contains(Object o) |判断列表中是否存在指定元素 |
|boolean remove(Object o) |从列表中删除元素 |
|Object remove(int index) |从列表中删除指定位置元素，
起始索引位置从0开始 |
----------------------------------------------------------------------------------------------------------
·LinkedList集合类
·LinkedList的特殊方法
------------------------------------------------------------------------------
| 方法名 | 说明 |
|-------------------------------|----------------------------------------------|
|void addFirst(Object o) |在列表的首部添加元素 |
|void addLast(Object o) |在列表的末尾添加元素 |
|Object getFirst() |返回列表中的第一个元素 |
|Object getLast() |返回列表中的最后一个元素 |
|Object removeFirst() |删除并返回列表中的第一个元素 |
|Object removeLast() |删除并返回列表中的最后一个元素 |
------------------------------------------------------------------------------
·集合框架的好处：
1.容量自增长。
2.提供有用的数据结构和算法，从而减少编程工作。
3.提高了程序速度和质量，因为它提供了高性能的数据结构和算法。
4.允许不同API之间的互操作，API之间可以来回传递集合。
5.可以方便地扩展或改写集合。
·Map接口
专门处理键值映射数据的存储，可以根据键实现对值的操作
·Map接口常用方法
-------------------------------------------------------------------------------------
| 方法名 | 说明 |
|----------------------------------|--------------------------------------------------|
|Object put(Object key,Object val) |以“键-值对”的方式进行存储 |
|Object get(Object key) |根据键返回相关联的值,如果不存在指定的键，返回null |
|Object remove (Object key) |删除由指定的键映射的“键-值对” |
|int size() |返回元素个数 |
|Set keySet () |返回键的集合 |
|Collection values () |返回值的集合 |
|boolean containsKey(Object key) |如果存在由指定的键映射的“键-值对”,返回true |
-------------------------------------------------------------------------------------
·迭代器
通过迭代器Iterator实现遍历
获取Iterator：Collection 接口的iterate()方法
Iterator的方法：
boolean hasNext() //判断是否存在下一个可访问的元素
Object next() //返回要访问的下一个元素
实例：
Iterator<String> it=names.iterator();//获取迭代器
while (it.hasNext()) {//判断是否拥有下一个元素
String name=it.next();
System.out.println(name);
}
for each(
增强型for循环）
语法：
for(元素类型t 元素变量x : 遍历数组或集合对象){
}
·遍历HashMap集合的方法
//声明并创建HashMap对象
Map<Integer, String> map=new HashMap<Integer, String>();
//存储数据
map.put(1, "张三");
map.put(2, "李四");
map.put(3, "王五");
//遍历集合
//方法一：values()获取所有值
Collection<String> c=map.values();
for (String string : c) {
System.out.println(c);
}
//方法二：keyset()获取所有键
Set<Integer> s=map.keySet();
for (Integer integer : s) {
String name=map.get(integer);
System.out.println(name);
}
//方法三：entrySet()获取键值映射的set图
Set<Entry<Integer, String>> s=map.entrySet();
for (Entry<Integer, String> entry : s) {
System.out.println(entry.getKey()+" "+entry.getValue());
}
·泛型集合
好处：类型安全、消除强制类型转换、提高性能
//创建泛型
class Dog<T> {
//属性
private T name;
//方法
......
}
//使用泛型
Dog<String> d=new Dog<String>("多多");//<类型>内指定的数据类型
---------------------------------------------------------------------------------------------------------------
【第十七章】JDBC(Java数据库连接)
JDBC用于与数据库建立连接、执行SQL语句、处理结果的Java API,集成在java.sql和javax.sql包中。
·JDBC使用步骤
1.加载MySQL驱动程序
Class.forName("com.mysql.jdbc.Driver");
2.建立数据库连接Connection
Connection conn=DriverManager.getConnection("jdbc:mysql://localhost:3306/myschool? characterEncoding=utf-8","root","123456");
3.创建statement/PreparedStatement对象，用来发送sql语句，并得到返回的结果
PreparedStatement pstate=conn.prepareStatement("SELECT * FROM student where id =?");
pstate.setInt(1, 10);
ResultSet rs=pstate.executeQuery();
4.处理结果
while(rs.next()){
String sno=rs.getString("sno");
String sname=rs.getString("sname");
int age=rs.getInt("sage");
String sex=rs.getString("ssex");
System.out.println("学号:"+sno+",姓名:"+sname+"，年龄:"+age+"，性别:"+sex);
}
5.释放资源
释放资源顺序: ResultSet → Statement → Connection
rs.close();
pstate.close();
conn.close();
·DriverManager类
作用：依据数据库的不同，管理JDBC驱动
·Driver接口
加载MySql驱动：Class.forName("com.mysql.jdbc.Driver");
加载Oracle驱动：Class.forName("oracle.jdbc.driver.OracleDriver");
·Connection接口
作用：负责连接数据库并担任传送数据的任务
·连接MySql数据库
Connection conn = DriverManager.getConnection("jdbc:mysql://主机名:端口号/数据库名?参数名=参数 值,"user","password");
其他参数：
localhost:3306 本地主机地址
useUnicode=true 是否使用Unicode字符集,如果参数characterEncoding设置为gb2312或gbk本参数值必须设置为true
characterEncoding=utf8 当useUnicode设置为true时，指定字符编码
·常用方法
-----------------------------------------------------------------------
| 方法名 说 明 |
|-----------------------------------------------------------------------|
|createStatement() 创建向数据库发送sql的statement对象 |
|-----------------------------------------------------------------------|
|prepareStatement(sql) 创建向数据库发送预编译sql的PrepareSatement对象|
-----------------------------------------------------------------------
·Statement接口
作用：由 Connection 产生、负责执行SQL语句
·常用方法
-------------------------------------------------------------------------------
| 方法名 说 明 |
|-------------------------------------------------------------------------------|
|ResultSet executeQuery(String sql) 执行SQL查询并获取到ResultSet对象（结果集）|
|-------------------------------------------------------------------------------|
|int executeUpdate(String sql) 执行插入、删除、更新操作，返回更新的行数 |
|-------------------------------------------------------------------------------|
|boolean execute(String sql) 执行任意SQL语句,然后获得一个布尔值，表示是|
| 否返回ResultSet（结果集） |
-------------------------------------------------------------------------------
·PreparedStatement接口
作用：继承自Statement接口，由preparedStatement创建用于发送含有一个或多个参数的SQL语句，比Statement效率更高, 并且可以防止SQL注入，一般都使用PreparedStatement。
语法：
一个“?”代表设置一个通配符，下标从1开始
PreparedStatement pstate=prepareStatement(sql语句);
pstate.setString(参数下标, 参数值);
示例：
PreparedStatement pstate=null;
pstate=conn.prepareStatement("SELECT * FROM `user` WHERE zhanghao=? AND mima=?;");
pstate.setString(1, "zhangsan");
pstate.setString(2, "123456");
·ResultSet接口
作用：负责保存Statement执行后所产生的查询结果
·常用方法
-----------------------------------------------------------------------------
| 方法名 说 明 |
|-----------------------------------------------------------------------------|
|boolean next() 将光标从当前位置向下移动一行 |
|-----------------------------------------------------------------------------|
|boolean previous() 游标从当前位置向上移动一行 |
|-----------------------------------------------------------------------------|
|boolean first() 查找结果集中的第一行，找到返回true |
|-----------------------------------------------------------------------------|
|void close() 关闭ResultSet对象 |
|-----------------------------------------------------------------------------|
|int getInt(int colIndex) 以int形式获取结果集当前行指定列号值 |
|-----------------------------------------------------------------------------|
|int getInt(String colName) 以int形式获取结果集当前行指定列名值 |
|-----------------------------------------------------------------------------|
|float getFloat(int colIndex) 以float形式获取结果集当前行指定列号值 |
|-----------------------------------------------------------------------------|
|float getFloat(String colName) 以float形式获取结果集当前行指定列名值 |
|-----------------------------------------------------------------------------|
|String getString(int colIndex) 以String 形式获取结果集当前行指定列号值 |
|-----------------------------------------------------------------------------|
|String getString(String colName) 以String形式获取结果集当前行指定列名值 |
-----------------------------------------------------------------------------
---------------------------------------------------------------------------------------------------------------
【第十八章】DAO设计模式
DAO(Data Access Object,数据访问对象)是属于J2EE体系架构中数据层的操作,主要的功能是用于进行数据操作的,使用 DAO设计模式可以简化大量代码，增强程序的可移植性。
·数据持久化
将程序中的数据在瞬时状态和持久状态间转换的机制即为数据持久化
实现方式：数据库、普通文件、XML文件
·程序代码高耦合的影响：
1.可读性差
2.不利于后期修改和维护
3.不利于代码复用
·DAO设计模式组成部分：
·DAO接口
接口中定义了所有的用户操作，如添加记录、删除记录及查询记录等。需要子类实现。
·DAO实现类
DAO实现类实现了DAO接口，并实现了接口中定义的所有方法。
·实体类
主要由属性setter,getter方法组成，类中的属性与表中的字段相对应，每一个实体类的对象都表示表中的每一条记录
·数据库连接和关闭工具类
主要功能是连接数据库并获得连接对象，以及关闭数据库。
·DAO设计模式的优势：
1.隔离了数据访问代码和业务逻辑代码
2.隔离了不同数据库实现
·包命名规范
实体类包：xxx.xxx.entity
DAO接口类包：xxx.xxx.dao
DAO接口实现类包：xxx.xxx.dao.impl
SERVICE接口类包：xxx.xxx.service
SERVICE接口实现类包：xxx.xxx.service.impl
·软件系统三层架构
用户请求
↓
表示层（UI）
↓
业务逻辑层（BLL）
↓
数据访问层（DAL）
↓
数据库
·分层原则
封装性原则：每个层次向外公开接口，但是隐藏内部细节
顺序访问原则：下一层为上一层服务，但不使用上层的服务分层结构中，不同层之间通过实体类传输数据
SQL篇
***************************************************************************************************************
【第一章】基本操作
数据库（Database,简称DB）
作用: 保存、管理数据
MySQL:关系型数据库
DBMS:数据库管理系统
特点：
免费、开源数据库
小巧、功能齐全
使用便捷
可运行于Windows或Linux操作系统
可适用于中小型甚至大型网站应用
MySQL默认端口号:3360
SQLyog特点:易用
、简洁、
图形化
·使用DOS命令连接数据库
连接数据库语句: mysql -h 服务器主机地址 –u用户名 -p用户密码
·命令行操作数据库
创建数据库 CREATE DATABASE [IF NOT EXISTS] 数据库名;
删除数据库 DORP DATABASE [IF EXISTS] 数据库名;
查看数据库 SHOW DATABASES;
使用数据库 USE 数据库名;
·结构化查询语句分类:
---------------------------------------------------------------------------------------------
| 名称 解释 命令 |
|---------------------------------------------------------------------------------------------|
|DDL
（数据定义语言) 定义和管理数据对象，
如数据库，数据表等 CREATE、DROP、ALTER |
|DML
（数据操作语言） 用于操作数据库对象中所包含的数据 INSERT、UPDATE、DELETE |
|DQL
（数据查询语言） 用于查询数据库数据 SELECT |
|DCL
（数据控制语言） 用来管理数据库的语言，包括管理权限及数据更改 GRANT、COMMIT、ROLLBACK|
---------------------------------------------------------------------------------------------
·创建数据表(属于DLL一种)
语法：
CREATE TABLE [IF NOT EXISTS ] 表名 (
字段名1 列类型 [属性] [索引] [注释],
字段名2 列类型 [属性] [索引] [注释]
)[表类型] [表字符集] [注释];
·数据值和列类型
列类型分为：数值类型、
字符串类型、
日期和时间型、
NULL值
·数值类型
-------------------------------------------------------------------------
| 类型 说明 取值范围 存储需求|
|-------------------------------------------------------------------------|
|tinyint 非常小的数据 有负值： -2(7次方) ~ 2(7次方)-1 1字节 |
|
无负号值：0 ~ 2(8次方)-1 |
|-------------------------------------------------------------------------|
|int 标准整数 有负值： -2(31次方) ~ 2(31次方)-1 |
| 无负号值：0 ~ 2(32次方)-1 4字节 |
|-------------------------------------------------------------------------|
|double 双精度浮点数 ±2.2250738585072014e -308 8字节 |
-------------------------------------------------------------------------
·字符串类型
----------------------------------------------------------------------------------
| 类型 说明 最大长度 |
|----------------------------------------------------------------------------------|
|char[(M)] 固定长字符串，检索快但费空间,0 <= M <= 255 M字节 |
|varchar[(M)] 可变字符串
0 <= M <= 65535 M+1 字节 |
|text 文本串 2(16次方)–1字节|
----------------------------------------------------------------------------------
·日期和时间型数值类型
----------------------------------------------------------------------------------
| 类型 说明 取值范围 |
|DATETIME YY-MM-DD hh:mm:ss 1000-01-01 00:00:00 至
9999-12-31 23:59:59 |
----------------------------------------------------------------------------------
·NULL值
理解为“没有值”或“未知值”
不要用NULL进行算术运算，结果仍为NULL
MySQL中，0或NULL都意味着为假，1为真
·数据字段属性
PRIMARY KEY：主键（一张表只能出现一个主键）
UNSIGNED：
无符号的
声明该数据列不允许负数
ZEROFILL：0填充的，
不足位数的用0来填充，如 int(3),5则为 005
ATUO_INCREMENT：自增的，通常用于设置主键，且为整数类型，每添加一条数据，自动在上一个记录数上加1（删除不 影响数据增长），可定义起始值
DEFAULT：
默认的
，用于设置默认值
。
COMMENT '注释内容注释':注释
·修改表
修改表名: ALTER TABLE 旧表名 RENAME AS 新表名
添加字段: ALTER TABLE 表名 ADD 字段名 列类型 [ 属性 ]
修改字段: ALTER TABLE 表名 CHANGE 旧字段名 新字段名 类型 [ 属性 ]
删除字段
: ALTER TABLE 表名 DROP 字段名
·删除数据表:
语法：
DROP TABLE [ IF EXISTS ] 表名
注：IF EXISTS 为可选，判断是否存在该数据表
如删除不存在的数据表会抛出错误
·数据库数据管理
数据库意义
：数据存储
、数据管理
管理数据库数据方法：
1、通过SQLyog等管理工具管理数据库数据
2、
通过DML语句管理数据库数据
·DML(数据操作语言)
用于操作数据库对象中所包含的数据
·添加数据（INSERT）
INSERT INTO 表名 [字段1,字段2,字段3] VALUES (“值1”,“值2”,“值3”)
·修改数据（UPDATE）
UPDATE 表名 SET column_name = value [column_name2 = value2] [where condition];
·删除数据
·DELETE命令
语法：
DELETE FROM 表名 [where condition];
·TRUNCATE命令
用于完全清空表数据,但表结构、索引、约束等不变
语法：
TRUNCATE [TABLE] table_name
注意：
区别于DELETE命令
相同:
都能删除数据、不删除表结构，但TRUNCATE速度更快
不同:
1、
使用TRUNCATE TABLE重新设置AUTO_INCREMENT计数器
2、使用TRUNCATE TABLE不会对事务有影响
---------------------------------------------------------------------------------------------------------------
【第二章】使用DQL命令查询数据
·SELECT语法
：
SELECT [ALL | DISTINCT] { * | table.* } FROM table_name [ as table_ alias ]
[left|out|inner join table_name2] #联合查询
[WHERE … ] #指定结果需满足的条件
[GROUP BY …] #指定结果按照哪几个字段来分组
[HAVING …] #过滤分组的记录必须满足的次要条件
[ORDER BY… ] #指定查询记录按一个或者多个条件排序
[ LIMIT { [ offset,] row_count | row_count ,offset }]; #指定查询的记录从哪条至哪条
·指定查询字段：查询表中所有的数据列结果，采用“*”符号（效率低，不推荐）
·AS子句作用
可给数据列名取一个新别名
可给表名取一个新别名
可把经计算或总结的结果用另外一个新值来代替
·DISTINCT关键字
根据一个范围值来检索
·作用
去掉SELECT查询返回的记录结果中重复（所有返回列的值都相同）的记录，只返回一条
·NULL空值条件查询
NULL代表“无值”
区别于零值0和空符串“”
只能出现在定义允许为NULL的字段
须使用 IS NULL 或 IS NOT NULL 比较操作符去比较
·BETWEEN AND范围查询
根据一个范围值来检索
·语法
SELECT 字段列1，字段2 ,..FROM 表名 WHERE 字段x BETWEEN 值1 AND 值2
·IN
在WHERE子句中使用IN自定义进行范围查询
·语法
SELECT 字段列1，字段2 , FROM 表名 WHERE 字段x IN ( 值1,值2)
查询的字段x的值，至少与括号中的一个值相同
多个值之间用英文逗号隔开
·LIKE模糊查询
WHERE子句中，LIKE关键字模糊查询
与“%”一起使用，表示匹配0或任意多个字符
与“_”一起使用，表示匹配单个字符
---------------------------------------------------------------------------------------------------------------
【第三章】索引
索引是数据库中个用来提高查询性能最常用的工具
索引分类：普通索引、唯一索引、主键索引、全文索引、删除索引、禁用索引
使用以下操作符会使用索引
> < >= <= <> in between like 注意使用like用索引时不能使用通配符开始 否则无效
普通索引 直接创建，没有唯一性之类的限制
语法：create index 索引名 on 表名 (列名[（length）])
唯一索引 ：创建和普通基本相似、索引列所出现的值具有唯一性
语法：create unique index 索引名 on 表名 (列名[（length）])
创表附带索引：语法：create table 表名([...],unique index[索引名] （列名[(length)]）)
主键索引：是一种特殊的唯一索引
语法：create table 表名 （[...],primary key(列名)）
ps:当建立主键时，主键索引会自动建立，不必重复设置，一张表只有一个主键，所以只有一个主键索引
删除索引：drop index 索引名 on 表名
禁用索引：alter table 表名 disable keys
启用索引：alter table 表名 enable keys
存储引擎分为： Myisam 和 innodb
myisam 不支持外键，事务 一边插入一边建立索引
innodb 支持 外键 事务
因此 myisam表在大批量数据导入时，为提高效率应先禁用索引然后在开启
最合适索引的列，是出现在where子句中的列，或链接字句（on）中指定的列，而不是出现在select后的列
索引的值越多不同，效果越好
使用短索引不仅可以节省空间而且会使查询更快捷
JavaScript、jQuery篇
***************************************************************************************************************
【第一章】JavaScript基础
JavaScript组成：ECMAScript（类似于W3C标准）、DOM（文档对象模型）、BOM（浏览器对象模型）
·基本结构
<script type="text/javascript">
document.write("Hello world")
</script>
document.write(); //输出
·引用方式
·使用<script></script>标签
·外部js文件
<script src="test.js" language="javascript"></script>
·直接在HTML标签中使用
<input type="button" value="点我有反应？" onclick="javascript:alert('呦！不错！')"/>
·变量
先声明再赋值：
同时声明同时赋值：
不声明直接赋值：
·数据类型
undefined //变量没有初始值，将被赋值undefined
null //空值，与undefined相等
number //整数 浮点型（小数）
boolean //true和false
string //单引号或双引号括起来的文本
·String对象
·属性
字符串对象.length
·方法
charAt(index) //返回在指定位置的字符
indexOf() //查找字符在字符串中首次出现的位置(找到1，没找到-1)
substring(index1,index2)//返回位于指定索引index1和index2之间的字符串,包括index1的字符不包括index2的字符
split(str) //将字符串分割为字符串数组
typeof() //提取变量类型
typeof返回值：
undefined //变量被声明后，但未被赋值
string //用单引号或双引号来声明的字符串
boolean //true和false
number //整数或浮点
object //JavaScript中的对象，数组和null
·数组
1.创建数组
var 数组名=new Array(size); //new声明数组关键字 size表示数组可存放的元素总数
2.为数组元素赋值
直接声明赋值：
var a=new Array('a','b','c');
声明并分配空间再赋值：
var a=new Array(3);
a[0]='a';
a[1]='b';
a[2]='c';
·常用属性：
length //设置或返回数组中元素的数目
·常用方法：
join() //数组字符通过分隔符进行分隔
sort() //对数组排序
push() //向数组尾部添加一个或多个元素，并返回新的长度
·运算符
算数运算符：+ - * / % ++ --
赋值运算符：=
比较运算符：> < >= <= == !=
逻辑运算符：&& || ！
·输入/输出
alert("文本"); //提示框
prompt("文本","默认值");//输入框
·函数
定义函数：
function 函数名(var1,var2,...){
//JS语句
return 返回值;
}
调用函数：
函数名();
常用系统函数：
parseInt() //将字符串转换为整数
parseFloat() //将字符串转换为小数
isNaN() //检查参数是否是非数字 返回类型boolean
----------------------------------------------------------------------------------------------------------------
【第二章】JavaScript对象
·Window对象（浏览器中打开的窗口）
常用属性：
history 有关客户访问过的URL信息
location 跳转到指定的URL页面
语法：对象名.属性名="属性值";
常用方法：
prompt() 输入框
alert() 提示框
confirm() 确定框
close() 关闭当前浏览器窗口
setTimeout("a()",3000) 在指定的毫秒后调用一次函数或表达式
setInterval("a()",3000) 在指定的毫秒后调用多次函数或表达式
open("弹出的Url","窗口名称","窗口特征") 打开指定的浏览器窗口加载指定的URL页面
窗口特征：
height、width 窗口文档显示区的高度、宽度。以像素计。
left、top 窗口文档显示区的 x、y 坐标。以像素计。
resieable=yes|no|1|0 窗口是否可调节尺寸。默认是 yes。
status=yes|no|1|0 是否添加状态栏。默认是 yes。
scrollbars=yes|no|1|0 是否显示滚动条。默认是 yes。
titlebar=yes|no|1|0 是否显示标题栏。默认是 yes。
location=yes|no|1|0 是否显示地址字段。默认是 yes。
menubar=yes|no|1|0 是否显示菜单栏。默认是 yes。
toolbar=yes|no|1|0 是否显示浏览器的工具栏。默认是 yes。
fullscreen=yes|no|1|0 是否使用全屏模式显示浏览器。默认是no。
常用事件：
onload 页面或图像加载完成
onmouseover 鼠标移到某元素之上
onclick 单击某个对象
onkeydown 某个键盘按键被按下
cnchange 域的内容被改变
·history对象（用户访问过的URL信息）
常用属性：
length 返回浏览器历史列表中的URL数量
常用方法：
back() 加载history列表中的前一个URL页面。
forward() 加载history列表中的下一个URL页面。
go() 加载history列表中的某个具体页面。
·location对象（当前的URL信息）
常用属性：
host 返回主机名和当前URL的端口号。
hostname 返回当前URL的主机名。
href 返回完整的URL。
常用方法：
reload() 重新加载当前文档(刷新)。
replace("URL") 用新的文档替换当前文档。
·Document对象(从脚本中对HTML页面中的所有元素进行访问)
常用属性：
referrer 返回载入当前文档的文档的URL。
URL 返回当前文档的URL。
常用方法：
getElementById() 返回对拥有指定id的第一个对象的引用。（对象ID唯一）
getElementById().innerText 返回对拥有指定id标签内部文本信息 .innerHTML包含标签的文本信息
getElementsByName() 返回带有指定名称的对象集合。（相同name属性）
getElementsByTagName() 返回带有指定标签名的对象集合。（相同元素）
write 向文档写HTML表达式或JavaScript代码。
·复选框属性
checked属性值：
选中：true
未选中：false
·JavaScript内置对象
·Math对象（用于执行的常用的数学任务，包含了若干个数字常量和函数）
常用方法
方法 说明 示例
cell() 对数进行上舍入 Math.cell(25.5);返回26
Math.floor(-25.5);返回-25
floor() 对数进行下舍入 Math.floor(25.5);返回25
Math.cell(-25.5);返回-26
round() 把数四舍五入为最近的数 Math.cell(25.5);返回26
Math.cell(-25.5);返回-26
random()返回0-1之间的随机数 Math.random();例如：
0.6273608814137365
parseInt(Math.random()*100);//生成100个随机整数
parseInt(Math.random()*数量)+初始值;//带有初始值的随机数
parseInt(Math.random()*数量)*倍数;//生成随机倍数
·Date对象（用于操作日期和时间）
语法：
var 日期对象=new Date(参数)
参数格式：MM DD,YYYY,hh:mm:ss（月 日,年,时:分:秒）
示例：
var today=new Date(); //返回当前日期和时间
var tdate=nre Date("september 1,2013,14:58:12"); //自定义日期和时间
常用方法：
setFullYear() 从 Date 对象返回年份其值介于 四位数字 之间。
getMonth() 从 Date 对象返回月份其值介于 0 - 11 之间。
getDate() 从 Date 对象返回一个月中的某一天 其值介于(1 - 31)之间。
getDay() 从 Date 对象返回一周中的某一天 其值介于(0 - 6)之间。
getHours() 返回 Date 对象的小时其值介于 0 - 23 之间。
getMinutes() 返回 Date 对象的分钟其值介于 0 - 59 之间。
getSeconds() 返回 Date 对象的秒数其值介于 0 - 59 之间。
getTime() 返回 1970 年 1 月 1 日至今的毫秒数。
·清除函数
语法：
clearTimeout() //清除延时调用函数
clearInterval() //清除循环调用函数
示例：
var qchs=setTimeout("shijian()",1000);
clearTimeout(qchs);
----------------------------------------------------------------------------------------------------------------
【第三章】JQuery基础
·导入jquery库
<script type="text/javascript" src="jquery-1.12.3.js"></script>
·基本语法
基本框架：
$(document).ready(function(){
//jQuery代码
});
简写版：
$(function(){});
语法：
$(selector).action();
工程函数 $() //将DOM对象转换为JQuery对象
选择器 (selector) //获取需要操作的DOM元素
方法 .action() //执行对元素的操作
常用方法：
$(selector).css("属性","属性值") //为元素设置CSS样式
$("元素").addClass(class) //为相同样式的元素添加指定的类样式(一次性添加多个类名用空格隔开)
$(selector).next().css("属性","属性值") //为下一个元素添加样式
·节点类型
元素节点：文档中所有元素 <h2></h2>
文本节点：元素节点内的文本内容 <p>哈哈哈</p>
属性节点：元素节点的子节点 <p title="提示">哈哈哈</p>
·JS(DOM)对象转成JQuery对象
语法：
$(DOM对象)
实例：
var js=document.getElementById("xz"); //获取DOM对象
var $jq=$(js); //将DOM对象转换为JQuery对象
·JQuery对象转成JS(DOM)对象
方法一：JQuery对象是一个数组，可以通过[index]的方法，来得到相应的DOM对象。
实例：
var $jq=$("#xz");//获取JQuery对象
var js=$jq[0]; //将JQuery对象转换为DOM对象
<input type="checkbox" id="xz"/> //检测这个checkbox是否被选中
方法二：JQuery本身提供，通过.get(index)方法得到相应的DOM对象
实例：
var $jq=$("#xz"); //获取JQuery对象
var js=$jq.get(0); //将JQuery对象转换为DOM对象（$jq.get()[0]也行）
<input type="checkbox" id="xz"/> //检测这个checkbox是否被选中
----------------------------------------------------------------------------------------------------------------
【第四章】选择器
·基本语法：
$("选择器").css("属性","属性值");
·基本选择器
标签选择器（根据给定的元素名匹配所有元素）示例：$("h2") //设置所有h2标签的样式
类选择器（根据给定的类匹配元素）示例：$(".title") //设置所有class为title的样式
ID选择器（根据给定的ID匹配一个元素）示例：$("#title") //设置所有ID为title的样式
并集选择器（将每一个选择器匹配到的元素合并后一起返回）示例：$("div,p,.title") //设置所有div,p和类名为title 的样式
交集选择器（匹配指定class或id的某元素或元素集合）示例：$("h2.title") //设置类名为title的h2样式
全局选择器（匹配所有元素）示例：$("*") //设置所有样式
·层次选择器
后代选择器（在给定的祖先元素下匹配所有的后代元素）示例：$("p a") //设置p标签后边所有a标签的后代的样式
子选择器（在给定的父元素下匹配所有的子元素）示例：$("p>a") //设置p标签后边的a标签的子样式
相邻选择器（匹配所有紧接在 prev 元素后的 next 元素）示例：$("a+p") //设置a标签后边近邻的p标签的样式
同辈选择器（匹配 prev 元素之后的所有 siblings 元素）示例：$("strong~a") //设置从strong开始后边同一级的a标签 样式
·属性选择器
$("[name]") //设置含有name属性的元素（匹配包含给定属性的元素）
$("[href='#']") //设置href属性值为#的元素（匹配给定的属性是某个特定值的元素）
$("[href!='#']") //设置href属性值不为#的元素（匹配所有不含有指定的属性，或者属性不等于特定值的元素）
$("[href^='en']") //设置href属性以en的开头的元素（匹配给定的属性是以某些值开始的元素）
$("[href$='.jpg']") //设置href属性值以.jpg结尾的元素（匹配给定的属性是以某些值结尾的元素）
$("[href*='txt']") //设置href属性值含txt的元素（匹配给定的属性是以包含某些值的元素）
$("li[id][titlt=新闻要点]") //设置含有ID属性和title属性为新闻要点的<li>元素（复合属性选择器，同时满足多个条 件时使用）
·过滤选择器
:first //只设置第一个元素的样式
:last //只设置最后一个元素的样式
:odd //设置奇数（2,4,6...）的元素的样式(index从0开始)
:even //设置偶数（1,3,5...）的元素的样式(index从0开始)
:gt(index) //设置所有大于index的元素(index从0开始)
:lt(index) //设置所有小于index的元素(index从0开始)
:eq(index) //设置等于index的元素(index从0开始)
:not(选择器)//去除所有与选择器匹配的元素
:header //匹配标题标签元素(h1-h6)
:focus //匹配当前获取焦点的元素
:visible //匹配所有可见的元素
:hidden //匹配所有隐藏的元素
·显示/隐藏
$("p:hidden").show(); //获取隐藏的p标签使其显示
$("p:visible").hide(); //获取显示的p标签使其隐藏
$("ul").toggle(); //可见元素切换为隐藏,隐藏元素切换为可见。
---------------------------------------------------------------------------------------------------------------- 【第五章】事件和动画
·鼠标事件
$().click(function) //鼠标点击事件
$().dblclick(function) //鼠标双击事件
$().mouseover(function) //鼠标悬停事件
$().mouseout(function) //鼠标离开事件
·键盘事件
$().keydown(function) //当键盘被按下时执行事件
$().keypress(function) //当内容被修改时执行事件
$().keyup(function) //当键盘被松开时执行事件
$().event.keyCode(function(event){}) //返回按下键盘指定键位的键值
·表单事件
$().focus(function) //被选元素获取焦点事件
$().blur(function) //被选元素失去焦点事件
·绑定事件
$().bind("事件类型","处理函数") //绑定单个事件
$().bind({"事件类型":function(){},"事件类型":function(){}}) //绑定多个事件(逗号隔开)
$().unbind("事件类型","处理函数")//取消绑定事件
·复合事件
$().hover(function(){},function(){}) //鼠标光标悬停事件
$().toggle( //鼠标连击事件
function(){}, //第一次点击触发
function(){}, //第二次点击触发
function(){} //第三次点击触发
);
·动画效果
$().hide("1000"); //隐藏元素
$().show("1000"); //显示元素
$().slideUp("1000"); //通过高度变化向下增大来动态显示元素
$().slideDown("1000"); //通过高度变化向上减小来动态显示元素
$().fadeIn("1000"); //实现元素的淡入效果
$().fadeOut("1000"); //实现元素的淡出效果
$().fadeToggle("1000"); //淡入淡出效果的切换
----------------------------------------------------------------------------------------------------------------
【第六章】jQuery操作DOM
·DOM操作分类
DOM Core、HTML-DOM、CSS-DOM
·CSS类
$().addClass("class") //追加类样式(多个类名用空格隔开)
$().removeClass("class") //移除类样式
$().toggleClass("class") //切换类样式
$().css({"":"","":""}) //同时设置多个CSS样式（逗号隔开）
·HTML
$().html(value) //获取或设置第一个匹配元素的HTML标签和文本内容
$().text(value) //获取或设置HTML文本内容
$().val(value) //获取或设置HTML元素value属性值
addClass() 向匹配的元素添加指定的类名。
attr() 设置或返回匹配元素的属性和值。
hasClass() 检查匹配的元素是否拥有指定的类。
html() 设置或返回匹配的元素集合中的 HTML 内容。
removeAttr() 从所有匹配的元素中移除指定的属性。
removeClass() 从所有匹配的元素中删除全部或者指定的类。
toggleClass() 从匹配的元素中添加或删除一个类。
val() 设置或返回匹配元素的值。
Java高级特性篇
***************************************************************************************************************
【第一章】IO流
file构造方法：
File(File parent, String child)
根据 parent 抽象路径名和child路径名字符串创建一个新 File 实例。
File(String pathname) ：常用
通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。
File(String parent, String child)
根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。
File(URI uri)
通过将给定的 file: URI 转换为一个抽象路径名来创建一个新的 File 实例。
方法：
canExecute()是否是可执行性文件，如目录及任何文件
createNewFile（）新建文件
canWrite（）是否允许写入
canRead（）是否允许读取
delete（）删除文件
exists（）判断目录文件是否存在
getAbsolutePath()//获取文件的绝对路径
getAbsolutePath（）//获取文件的对象
isDirectory();//是否为目录
isFile();//是否为文件
isHidden();//是否为隐藏文件
length();//获取文件的长度
lastModified（）；//文件最后修改的毫秒数
mkdir（）//创建一个文件夹
mkdir()//创建多个文件夹及父目录
setReadOnly();//设置文件为只读
renameTo（）；//重命名
字节流输出：
FIleoutputStream类构造方法 字节输入流：
FileoutputStream（File name）；
FileoutputStream（String path）；常用
带有缓冲区的字节流：
bufferedinputStream 带缓存字节输入流
bufferedoutputstream 带缓存字节输出流
方法：
close();//关闭释放资源
read();//读取一个字节内容的
read(byte[]);//读取字节的个数 ，读取byte【】数组的长度的字节
read（byte[],off, len）;//读取一个byte[]数组，从off开始，len长度
available();//文件的读取的下一个内容的长度
字节输入流：
FIleintputStream类构造方法 字符输出：
FIleintputStream（File name）；
FIleintputStream(File path, boolean append）；当append为true时追加字符，为false时覆盖原字符，默认为false
FIleintputStream（String name）；
FIleintputStream（String path,boolean append）；常用当append为true时追加字符，为false时覆盖原字符，默认为false
方法：
String转换为byte数组，String a=“jdljf”;a.getBytes();
close();//关闭释放资源
flush();//写入后，必须进行强制刷新，将缓存中的数据强制写入文件
write();//一次写入一个字节
write(byte[])；//写入byte数组的内容
write(byte[],int off,int len);//选择一个byte数组，从数组off开始，len结束
字符流 输入流(不带缓冲区)：
FileReader类（以char类型的数组读取）
构造方法：
FileReader（String path）通过路径：常用
FileReader（File name）通过file类型的对象
方法：
Read（）读取一个字符
read（char[] c）读取一个字符数组长度的字符
read（char []c,off ,len）读取一个字符数组长度的字符,从off开始，len个长度
InputStreamReader类，多用于字节流转换字符流
InputStreamReader（inputStream f）;
BufferedReader类，带缓冲区的字符输入流；
BufferedReader（Reader in）使用默认缓冲区
BufferedReader（Reader in，int size）使用自定义缓冲区
方法：
readLine（）；读取缓冲区中一行的数据
FIlewrite 字符输出流：
FIlewrite (String path)
FIlewrite (String path,boolean append)append为true时，为追加，默认为false覆盖原数据
Filewrite(File name)
Filewrite(File name,boolean append)append为true时，为追加，默认为false覆盖原数据
BufferedWriter类 带缓存的字符输出流：
BufferedWriter（Writer out）使用默认缓存的输出流
BufferedWriter（Writer out,int size）使用自定义缓存的输出流
方法：
newLine（）加入换行符
flush（）强制刷新，将缓存区的内容输入到文件中
write（）写入文件
OutputStreamReader类用于将字节流转换为字符流
OutputStreamReader（outputStream in）构造函数
二进制流（注意：以什么类型的输出，就以什么类型输入）：
DatainputStream（InputStream in）
常用方法:
readUTF();//以utf格式输入
readInt();//以int类型输入
readDouble();//以double类型输入
readChar();；//以char类型输入
DataOutputStream（OutputStream out）
常用方法:
writeUTF();//以utf格式输出
writeInt();//以int类型输出
writeDouble();//以double类型输出
writeChar();；//以char类型输出
序列化（将对象的属性存储到文件中）ps：对象类必须实现Serializable接口
ObjectInputStream（InputStream in）
常用方法：
WriteObject(对象名)；
反序列化
ObjectOutputStream（OutputStream out）
在同时序列化多个对象时需要使用ArrayList集合和hasmap
【第二章】Thread多线程
-------------------------------------------------------------------------------------------------
进程状态：
创建——start——就绪——运行——终止 or 阻塞（如果阻塞，阻塞解除——就绪状态）
进程阻塞常用thread方法：
thread.join 合并进程
thread.yield 暂停自己进程 ，让出
sleep 休眠进程
线程的基本信息：
Thread.currentThread();静态方法，表示当前线程
线程名.setName()设置进程的名称，也可以在构造方法中设置进程名
getName（）获取进程的名称
isAlive（）判断线程的运行状态
优先级（概率不是绝对的路径，优先级越高的执行的越多，并不是优先级越高越先执行）：
MAX_PRIORITY(表示10)最大优先级
NORM_PRIORITY(表示5 默认)自定义优先级
MIN_PRIORITY(表示1)最小的优先级
setPriorty()设置优先级
线程安全（并发）：多用于多个线程访问同一个对象，使用synchronized关键字
1.同步方法：public synchronized void test(){};
当多个线程访问时，只允许一个线程访问，其他线程处于等待状态
2.同步块，synchronized（只能为引用类型“”类.class|接口|对象|this）{}
java单例对象；
双重检查doublechecking：提高效率，
if（null==instance）{//作用：提高效率，当该类已经被实例化时，直接返回该对象，不在进行创建
synchronized（类名.class）{
if(null==instance){//作用：安全
instance=new 本类；
}
}
}
1，懒汉法：1.构造器私有化
2.声明私有的静态属性，（该类的对象）
3.创建对象并提供访问属性的静态方法
2.饿汉法：
1.构造器私有化
2.声明私有的惊天属性，同时创建对象
3.对外提供访问属性的方法
3.使用内部类
java生产者消费者模式： 1.信号灯法
方法Object类方法：
wait（）线程等待，释放锁，sleep 不释放所
notify()唤醒单个线程notifyAll唤醒所有线程
当生产者生产时，停止消费者线程，当生产完成后通知消费者消费，
当消费者消费时，停止生产者线程，当消费完成后通知生产者生产（通过一个boolean类型的变量进行判断 等于true时进行生产，false进行消费 切记输出不要放在if语句里，if语句只放停止当前进程）
2.管城法：（待看 ）
线程任务调度（指定时间调度指定线程）：
Timer t=new Timer();
t.schedule(new TimerTask() {
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("开始。。。。。。。。。");
}
}, 2000);
}
schedule方法参数：
1.timertask 对象（timertask是runnable的子类重写run方法）可以使用匿名内部类，
2.什么时间执行（通常通过new Time(System.currentTimeMillis()+1000)获取当前时间）
3.每隔多长时间执行一次
【第二章】面向网络编程
-------------------------------------------------------------------------------------------------
inetAddreess 类（无法new对象，只能通过InetAddress.getLocalHost创建对象）：封装计算机的ip地址和dns 没有端口
静态方法获取对象：
InetAddress.getLocalHost();//获取当前主机名InetAddress对象
InetAddress.getByname("www.163.com");//通过域名获取InetAddress对象
InetAddress.getByname("223.87.1.58")//通过ip地址获取InetAddress对象
方法：
getHostAddress)返回ip地址
getHostName()返回域名|本基金计算机名
InetSocketAddress类封装端口：
1.创建对象：
InetSocketAddress（String hostname,int port）（默认ip地址为空）
InetSocketAddress（inetAddress addr,int port）
InetSocketAddress is=new InetSocketAddress(InetAddress.getLocalHost(),2222);常用
InetSocketAddress is=new InetSocketAddress(InetAddress.getName(“127.0.0.1”),2222);常用
2.方法：
getHostName();//返回域名|主机名
getPort();//返回端口
getAddress();//返回IP地址
uri 统一资源
url 统一资源定位器
url uri组成部分
1.协议
2.域名|主机名
3.端口号
4资源文件名
URl创建：
1.URL（String spec）绝对路径构建
2.URL(URL context,String spec)相对路径构建
方法：
getProtocol()//获取协议
getHost()//获取域名
getPort();//获取端口
getFile();//获取资源
getPath();//获取相对路劲
getRef();//获取锚点
getQuery()//获取参数 当存在锚点时 获取不到参数
获取url中的源码：返回类型为InputStream
url.openStream();
因为直接使用字符流接受是会造成乱码和空间不足，因此大多数使用字节流转字符流进行接受
UDP ：以数据为中心 面向连接， 不安全，数据可能丢失，效率高
信息在发送时封装为数据包：
一、类 DatagramSocket 数据封装包Datagrampacket
1.客户端：
1.创建客户端 DatagramSocket类
DatagramSocket client=new DatagramSocket(6666);
2.准备数据 字节数组
String mse=“你好”;
byte[] date=mse.getBytes();
3.打包，DatagramPacket+服务器地址 既端口
DatagramPacket d=new DatagramPacket(date,date.length,new InetSocketAddress("localhost",8888));
4.发送
client.send(d);
5.释放资源
client.close();
2.服务器端：
1.创建服务端，datagramsocket类+指定端口
DatagramSocket server=new DatagramSocket(8888);
2.准备接受容器 字节数组，封装DatagramPacket
byte[] content=new byte[1024];
DatagramPacket peacket=new DatagramPacket(content, content.length);
3.包，接受数据
server.receive(peacket);
4.分析数据
byte[] data=peacket.getData();
int length=data.length;
System.out.println(new String(data,0,length)+1);
5.释放资源
server.close();
TCP：客户端
//声明套接字
Socket socket=new Socket("localhost",8888);
//获取套接字输入/输出流
OutputStream os=socket.getOutputStream();
//处理输入输出流
outputStreamWriter.write(content);
服务器端：
//声明创建serverSocket
ServerSocket server=new ServerSocket(8888);
//获取socket对象
Socket accept = server.accept();
//获取输入/输入流
InputStream inputStream = accept.getInputStream();
//处理信息
int read = inputStream.read(content);
Java web篇
***************************************************************************************************************
【第一章】动态网页基础
·B/S架构
B/S(Browser/Server)即浏览器/服务器模式，采用请求/响应模式进行交互。
用户 → 浏览器 → 应用服务器 → 数据库服务器
B/S模式工作原理：
1.用户输入网址
2.发送客户端的请求信息
3.访问/返回应用服务器和数据库服务器
4.返回从服务端检索到的信息
·URL（统一资源定位器）
URL的组成：
http://lacalhost:8080/news/index.html
协议部分://主机IP地址:端口号/项目资源地址=项目+(路径)+访问文件(文件名+格式)
·Tomcat服务器
Tomcat是由Apache开发的一个Web应用服务器，JSP/Servlet容器。
Tomcat目录结构：
/bin - 脚本存放目录(如启动、关闭脚本) *.sh文件用于Unix系统; *.bat文件用于Windows系统
/conf - 配置文件目录
server.xml：配置整个服务器信息。例如修改端口号，添加虚拟主机等
web.xml：部署描述符文件，这个文件中注册了很多MIME类型，即文档类型
/logs - 默认日志目录，记录了Tomcat启动和关闭的信息
/webapps - webapp运行的目录
/work - 运行时生成的文件
/temp - 存放Tomcat的临时文件，这个目录下的东西可以在停止Tomcat后删除
/lib - Tomcat的类库即JAR包
配置Tomcat端口号并设置字符集：
通过配置文件server.xml修改Tomcat端口号，设置字符集
<Connector port="端口号" protocol="HTTP/1.1" connectionTimeout="20000"
redirectPort="8443" URIEncoding="UTF-8"/>
·web项目的目录结构
/ :Web应用的根目录，该目录文件客户端都可访问（JSP、HTML等）
/WEB-INF :存放应用使用的各种资源，该目录及其子目录客户端都是不可访问的
/WEB-IND/classes :存放Web项目的Class文件
/WEB-INF/lib :存放Web应用使用的JAR文件
·配置默认访问页面
通过配置文件web.xml修改访问起始页，假如在web应用下存在一个index.jsp文件，输入http://loacalhost:8080/news地址 时，web容器会默认调用index.jsp页面。
<welcome-file-list>
<welcome-file>文件名.jsp</welcome-file>
</welcome-file-list>
·创建、部署、发布项目流程：
1. 编写Web应用的代码
2. 在webapps目录下创建应用文件目录
3. 将创建的页面复制到应用目录下
4. 启动Tomcat进行访问
·什么是JSP(Java Server Pages)
JSP是一种动态网页开发技术,它使用JSP标签在HTML网页中插入Java代码。
·执行过程
1、翻译阶段
2、编译阶段
3、执行阶段
·脚本程序的声明
脚本程序可以包含任意量的Java语句、变量、方法或表达式，只要它们在脚本语言中是有效的。
语法：
<% 代码片段 %>
注：任何文本、HTML标签、JSP元素必须写在脚本程序的外面。
·JSP的声明
一个声明语句可以声明一个或多个变量、方法，供后面的Java代码使用。在JSP文件中，您必须先声明这些变量和方法然后 才能使用它们。
<%! 方法 %>
·JSP表达式
<%= 表达式 %>
·HTML注释
<!-- 注释内容 -->
·JSP注释
<%-- 注释内容 --%>
·JSP脚本注释
<% //单行注释 %>
<% /*单行注释*/ %>
·指令
JSP指令用来设置与整个JSP页面相关的属性。
语法：
<%@page 属性1="属性值1" 属性2="属性值2"%>
常用属性：
-----------------------------------------------------------------------------
| 属性 描述 默认值 |
2 | language 指定JSP页面使用的脚本语言 java |
| import 通过该属性来引入脚本语言中使用到的类文件 无 |
| contentType 指定JSP页面所采用的编码格式 text/html、ISO-8859-1 |
-----------------------------------------------------------------------------
·JSP页面元素
静态内容（HTML代码）、指令、小脚本、表达式、声明、注释
·运行Web
程序时常犯
的错误
1.未启动
Tomcat 2.未部署
Web应用 3.URL输入
错误 4.目录不能被引用
-------------------------------------------------------------------------------------------------
第二章：
本章重点：request response session
内置对象：内置对象时web容器创建的一组对象 （不需要导包直接使用，不用声明声明和创建）
jsp九大内置对象：out(输出) request（请求） response（响应）session （回话）application（全局） page （页面）pagecontext（页面上下文） exception（异常） config（配置）
request作用域：在一个服务器请求范围内有效
page作用域：在一个页面范围内有效，通过pageContext对象访问（转发延长page作用域，不能跨页面传值）
session作用域：当前一次对话（一次对话包含多个请求，不能跨浏览器）
application作用域 ：面对当前整个web服务器
request常用方法：
void setCharacterEncoding("utf-8")设置传送的编码格式
String getParameter(String name);接受指定元素的单个数据
String getParameterValues(String name)；接受指定元素的多个数据
void setAttribute("key", "value");以key/value的形式保存对象值（作用域仅限于一次请求）
Cookie[] getCookies()接受所有的cookie
Object getAttribute("key");通过key获取对象值（在获取值时，需要用到强转ps:强转int不可以，只能强转为Integer）
RequestDispatcher getRequestDispatcher（String path） 返回一个RequestDispatcher对象
解决post方式乱码的方法：
post方法提交数据一定要写设置编码格式
request.setCharacterEncoding("utf-8");设置传送的编码格式
解决get方乱码方法：
方法一：
在接受数据时，通过实例化String对象进行转码
String user=request.getParameter("user");
String user1=new String(user.getBytes("ISO-8859-1"),"UTF-8");解决get方法乱码问题（不建议使用）
方法二：
在tomcat配置文件（conf.xml）添加URIEncoding=“UTF-8”（推荐使用）
<Connector port="8080" protocol="HTTP/1.1"
connectionTimeout="20000"
redirectPort="8443" URIEncoding="UTF-8"/>
转发的作用：
在服务器端，将请求发送给服务器上的其他资源以共同完成一次请求的处理
RequestDispatcher rd=request.getRequestDispatcher("chenggong.jsp");//转发地址
rd.forward(request, response);
response内置对象方法：
页面的重定向：
使用方式：response.方法名();
void sendRedirect(String location)客户端将重新发送请求到指定的url
转发和重定向的异同：
相同： 页面跳转
不同： 1.转发在服务器端完成的;重定向是在客户端完成的
2.转发的速度快;重定向速度慢
3.转发的是同一次请求;重定向是两次不同请求
4.转发不会执行转发后的代码;重定向会执行重定向之后的代码
5.转发地址栏没有变化;重定向地址栏有变化
6.转发必须是在同一台服务器下完成;重定向可以在不同的服务器下完成
通过地址栏传输数据(注意在传输多个值时不要带空格)：
<a href="xxx.jsp?key=value&&key1=value2&&……"></a>
会话session；（tomcat下默认session有效期三十分钟）
一个会话就是在一段时间内，一个客户端与web服务器的一连串相关的交互过程
session存储在服务器端，sessionid是通过cookie存储在客户端
非活动时间（客户端与服务器端没有进行交互的时间）1
session常用方法（如何使用：session.方法名（））：
String getid() 获取sessionid
void setMaxInactiveInterval(int interval) 设定session的非活动时间 以秒为单位
int getMaxInactiveInterval()获取session的有效非活动时间 以秒为单位
void invalidate（） 设置session对象失效
void setAttribute（String key，Object value）以key/value的形式保存对象值
Object getAttribute（String key）通过key获取对象值（在获取值时，需要用到强转）
void removeAttribute（String key） 从session 中删除指定名称（key）所对应的对象
设置session的失效时间的两种方法：
1.invalidate（）作用域为本页面的session
2.通过tomcat中设置session的失效时间
配置项目的web.xml或tomcat目录下的/conf/web.xml文件，单位是分钟
（作用域为整个项目）
<session-config>
<session-timeout>10</session-timeout>
</session-config>
session回话缺点：占用服务器内存，增加服务器负荷
不跨平台
include指令：引入文件避免代码冗余
使用方式：
<%@ include file="file_path"%>
session与窗口的关系：
1.每一个session对象都与一个浏览器窗口对应，重新开启一个浏览器窗口，可以创建一个session对象
2.通过超链接打开的新窗口，新窗口的session与其父窗口的session相同
4 cookie禁用后，session是否能使用（摘录网络内容，供大家参考）
URL重写
表单提交隐藏域
cookie禁用后，session能否使用的问题
sessionid是存储在cookie中的，解决方案如下：
Session URL重写，保证在客户端禁用或不支持COOKIE时，仍然可以使用Session
session机制。session机制是一种服务器端的机制，服务器使用一种类似于散列表的结构（也可能就是使用散列表）来保存信息。
详细代码如下：
//进主页的session会用到最后
request.getSession();
String url1=response.encodeURL("/day07/SessionDemo1");//这个方法会自动的在URL上面加上session的id号(如果 cookie被禁用的话，如果cookie没有被禁用，就不会加session的id号)
String url2=response.encodeURL("/day07/SessionDemo2");
out.write("<a href='"+url1+"'>购买</a></br>");
out.write("<a href='"+url2+"'>结账</a>");
上面URL的效果：
<a href="/day07/SessionDemo1;jsessionid=572FCD20D16825556EAAD9E8B1D3984D">购买</a></br>
<a href="/day07/SessionDemo2;jsessionid=572FCD20D16825556EAAD9E8B1D3984D">结账</a>
浏览器第一次访问服务器的时候，cookie带值，当浏览器第二次访问服务器时，服务器会向浏览器去要cookie，如果浏览器没有禁用cookie，那么服务器就得到浏览器相应的值，但是如果浏览器禁用了cooki会查看URL上是否带有拥有session的id的cookie。
第三章
application(全局)：实现用户之间的数据共享
如何使用:application.方法：
常用方法：
void setAttribute(String key,Object value) 以key/value的形式保存对象值
Object getAttribute(String key) 通过key获取对象值
String getRealPath(String path) 返回相对路径的真实路径
application失效：服务器重启
page(页面):
声明当前页面没有实际操作
pagecontext(页面上下文):
如何使用:pagecontext.方法：
void setAttribute(String key,Object value) 以key/value的形式保存对象值
Object getAttribute(String key) 通过key获取对象值
void include（String filePath） 引入文件
cookie：web服务器保存在客户端的一系列文本（默认存储机制：当cookie没有设置有效期时，cookie会在浏览器关闭时失效）
cookie常用方法：
void setMaxAge(int expiry) 设置cookie的有效期，以秒为单位
void setValue(Sring value) 在cookie创建后，对cookie进行赋值
String getName() 获取cookie的名称
String getValue() 获取cookie的值
int getMaxAge() 获取cookie的有效时间，以秒为单位
一个网站项目cookie内容的大小限制，个数限制：
IE6.0 IE7.0/8.0 Opera FF Safari Chrome
cookie个数： 每个域为20个 每个域为50个 每个域为30个 每个域为50个 没有个数限制 每个域为53个
cookie总大小： 4095个字节 4095个字节 4096个字节 4097个字节 4097个字节 4097个字节
作用：对特定对象的追踪
实现各种个性化服务
简化登录
安全性能：
容易泄露
cookie工作流程：
客户端→服务端→response携带cookie发送到客户端→客户端接受并存储cookie
cookie对象：
Cookie Newcookie=new Cookie(String key,String value);
设置cookie有限期
Newcookie.setMax(24*60*60);
写入cookie；
response.addCookie(NewCookie);
读取cookie：
Cookie[] cookies=request.getCookies();//获取所有cookie
session和cookie的区别：
session cookie
在服务器端保存用户信息 在客户端保存用户信息
session中保存的是Object类型 cookie保存的是String类型
随回话的结束而将其存储的 cookie可以长期保存在客户端
数据销毁
保存重要信息 保存不重要的用户信息
javabean：
javabean的优势：
解决代码重复编写，减少代码冗余
功能区分明确
提高了代码的维护性
javabean从功能上可以分为：
封装数据（实体类）
封装业务
js代码：
open（String page_url,打开位置)在制定位置打开网页
css代码（隔行换色）：
tr:nth-child(2n){
background-color:#fff;
}
第四章：
执行步骤：
1、创建数据库(基字符集=utf-8)、创建表、添加数据
2、导包、导入工具类(BaseDao) ps:修改数据库及帐密
3、创建实体类
3.1私有属性
3.2get、set对外方法
3.3有参构造、无参构造、有参构造(去除id)
4、数据访问层
4.1接口(interface)
4.2实现类(Class) extends BaseDao implements 4.1接口
4.2.1 编写sql语句
4.2.2 将通配符需要的参数封装成Object集合类型 ps:注意顺序别混乱
4.2.3 执行sql语句
( executeQuery()/executeUpdate() ),并得到返回的结果
4.2.4 处理结果
5、业务逻辑层
5.1接口(interface)
5.2实现类(Class) implements 5.1接口
6、编写测试类(Test)
7、表示层
7.1html代码
7.2JavaWeb代码
7.3JS/JQ代码
//1.编写sql语句
//2 将通配符需要的参数封装成Object集合类型/ps:注意顺序别混乱
//3 执行sql语句 ( executeQuery()/executeUpdate() ),并得到返回的结果
//4 处理结果
第五章：
JNDI概念：Java Naming and Directory Interface，Java命名和目录接口
作用：通过名称将资源与服务进行关联
JNDI的作用与优点：
1、在应用与Java对象或资源之间建立松耦合的逻辑关联，简化应用对于资源的配置及维护工作
2、可以在更大范围、不同应用之间共享资源
实现步骤：
1、发布信息：修改Tomcat\conf\context.xml文件
<Environment name="tjndi" value="hello JNDI" type="java.lang.String" />
2、获取资源：使用lookup()进行查找
// javax.naming.Context提供了查找JNDI 的接口
Context ctx = new InitialContext();
// java:comp/env/为前缀 +名称
String testjndi = (String) ctx.lookup("java:comp/env/tjndi");
传统数据库连接方式的不足：
1、需要经常与数据库建立连接，在访问结束后必须关闭连接释放资源
2、当并发访问数量较大时，执行速度受到极大影响
3、系统的安全性和稳定性相对较差
javax.sql.DataSource接口的实现类的作用：
1、负责管理与数据库的连接
2、以连接池的形式对数据库连接进行管理
使用连接池实现数据库连接的步骤：
1、配置context.xml文件
2、配置web.xml文件(在web.xml中配置<resource-ref>)
3、添加数据库驱动文件(把数据库驱动jar文件，加入到Tomcat的lib中)
4、进行代码编写，查找并获取数据源
<Context>
<Resource name="jdbc/news" auth="Container" type="javax.sql.DataSource"
maxActive="100" maxIdle="30" maxWait="10000" username="newsu"
password="123456" driverClassName="com.mysql.jdbc.Driver"
url="jdbc:mysql://127.0.0.1:3306/newsmanagersystem?
useUnicode=true&characterEncoding=utf-8" />
</Context>
属性名称 说明
name 指定Resource的JNDI名称
auth 指定管理Resource的Manager
type 指定Resource所属的Java类
maxActive 指定连接池中处于活动状态的数据库连接的最大数目
maxIdle 指定连接池中处于空闲状态的数据库连接的最大数目
maxWait 指定连接池中的连接处于空闲的最长时间
三层模式的划分：
表示层：与用户交互、收集数据、展示结果
业务逻辑层：根据业务需要控制执行过程，进行事务管理
数据访问层：提供与业务无关的数据访问操作
分层开发的优势：1、职责清晰 2、无损替换 3、复用代码 4、降低了依赖程度
第六章：
分页显示的步骤：1、确定每页显示的数据数量 2、确定分页显示所需的总页数 3、编写SQL查询语句，实现数据查询 4、在JSP页面中进行分页显示设置
PageUtil分页工具类：1、当前页码 2、页面大小，即每页显示记录数 3、记录总数 4、总页数 5、每页新闻集合
获取总记录数：select count(1) from 表名
根据每页显示记录数计算出总页数：总页数=(记录总数%页面大小==0)?(记录总数/页面大小):((记录总数/页面大小)+1);
select * from 表名 limit ?,?
第一个？指的是：起始行的下标 = (当前页页码 - 1) * 每页显示的数据量
第二个？指的是：每页显示的数据量
Commons-FileUpload组件
Commons是Apache开放源代码组织的一个Java子项目，其中的FileUpload是用来处理HTTP文件上传的子项目
Commons-FileUpload组件特点：
1、使用简单：可以方便地嵌入到JSP文件中，编写少量代码即可完成文件的上传功能
2、能够全程控制上传内容
3、能够对上传文件的大小、类型进行控制
环境准备：commons-fileupload-1.2.2.jar和commons-io-2.4.jar
设置表单的enctype属性：<form enctype="multipart/form-data" method="post">
在表单中使用File控件选择文件：<input type="file" name="nfile" />
上传文件时form标签的method属性必须设置为"post"，不能设置为"get"
ServletFileUpload类的常用方法
方法名称 方法描述
void setSizeMax(long sizeMax) 设置请求信息实体内容的最大允许的字节数
List parseRequest(HttpServletRequest req)解析form表单中的每个字符的数据，返回一个FileItem对象集合
boolean isMultipartContent(HttpServletRequest req)判断请求信息中的内容 是否是multipart/form-data类型
void setHeaderEncoding(String encoding) 设置转换时所使用的字符集编码
FileItem接口的常用方法
方法名称 方法描述
boolean isFormField() 判断FileItem对象封装的数据类型(普通表单字段返回true，文件表单字段返回false)
String getName() 获得文件上传字段中的文件名(普通表单字段返回null)
String getFieldName( ) 返回表单字段元素的name属性值
void write( ) 将FileItem对象中保存的主体内容保存到指定的文件中
String getString( ) 将FileItem对象中保存的主体内容以一个字符串返回。其重载方法public String getString(String encoding)中的参数用指定的字符集编码方式
long getSize( ) 返回单个上传文件的字节数
FileItemFactory接口 实现类：DiskFileItemFactory
方法名称 方法描述
void setSizeThreshold(int sizeThreshold) 设置内存缓冲区的大小
void setRepositoryPath(String path) 设置临时文件存放的目录
编写上传文件处理页的实现步骤
1、创建FileItemFactory对象
2、创建ServletFileUpload对象
3、解析form表单提交的所有表单元素数据
3.1、如果是普通表单元素
3.1.1、获取该元素的名和值使用
3.2、如果是文件数据
3.2.1、获取文件名的等参数
3.2.2、保存文件数据到服务器
浙公网安备 33010602011771号