Java基础

1.http://www.csdn.net
2.http://www.cnblogs.com

生活中程序:完成某些事物的既定方式或者过程，或者完成某些事物的步骤和顺序。
计算机程序:为了让计算机执行某些操作或者解决某个问题而编写的一些列的有序的指令的集合。

高级语言:更符合人的习惯的编程语言.如:JAVA,C#,VB,C
低级语言:也叫底层语言，更符合计算机的语言的习惯.如：汇编语言

JAVA是95年推出的高级语言。

JAVA技术平台:
1.JAVASE(java标准版):主要用来开发桌面程序。
2.JAVAEE(java企业版):主要用来开发网络程序和企业级应用程序。
3.JAVAME(java微型版):主要用来做嵌入式开发。

准备工作:
JDK:编译和运行的环境,相当于一个小型操作系统。
1.配置环境变量
1）安装jdk(jdk-7u25-windows-i586.exe)
2) 找到jdk安装路径的bin目录
3) “计算机”右击属性—>高级系统配置->环境变量->系统变量->path双击->在变量值中按end键->在最后加英文的分号，再把刚才bin目录的路径粘贴
4) 测试 cmd->javac

编写程序:
1.编写程序
2.编译源程序(命令:javac 类名.java) 生成class文件(字节码文件)
3.运行(命令:java 类名):把class文件转化为cpu可以识别的机器码

public class 类名{
public static void main(String[] args){
//代码
}
}
注意:
1.类名第一个字符大写,不能为数字开头
2.类名前面必须加class关键字
3.类中中所有定义的成员都是一对大括号{}
4.main方法的java程序的入口，每个java程序必须有且只有一个main方法.
5.main方法必须声明为public,必须加static，返回类型为void
6.java程序严格区分大小写

输出内容并换行
System.out.println("输出的内容");

输出内容不换行
System.out.print("输出的内容");

：换行符,相当于键盘的Enter键
：制表符,相当于键盘的tab键
//: 单行注释，java编译器忽略该代码
/* 注释内容 */:多行注释

新建项目:
1.file-new-java project

第二章:
包
作用:
1.避免命名冲突
2.便于组织相关的类，便于管理

定义一个包:
package 包名;

使用包:
import 包名;

变量:数据或者的对象的代号或者别名。
数据类型:
1. int：整数(-2的31次方到2的31次方)
2. double:双精度
3. char:单个字符
4. String:字符串
5. boolean:真或者假是或者否

变量的定义和使用:
1. 单独声明:
数据类型变量名=值;
如: String address="湖南长沙";

2. 先声明后赋值:
数据类型变量名;
变量名=值;
如： String address;
address="湖南长沙";
注意:
1.变量必须先赋值后使用。
2.变量名不能重复。
3.变量命名规则:
1)必须以字母，下划线，$符号开头
2)变量名中可以包含数字，字符，下划线，$符号。
3)变量名中间不能出现空格。
4)不能出现java关键字

输入：
1. 导包
import java.util.Scanner;
2. 创建对象
Scanner input=new Scanner(System.in);
3. 接收值
String 变量名=input.next();//接收String
int 变量名=input.nextInt();//接收int
double 变量名=input.nextDouble();//接收double

赋值运算符: =
算数运算符:+ - * / %
关系运算符:> >= < <= != ==
逻辑运算符:&&(并且) ||(或者) ！(取反)
& |
最高的优先级：小括号，即( )
最低的优先级：赋值运算符，即=
优先级顺序：！>算术运算符>比较运算符>&&>||

注意:
int reuslt=age++; 先赋值再自加
int result=++age; 先自加再赋值

类型转化规则:
1.在表达式中，如果一个操作数为double类型，则整个表达式结果
提升为double类型
2.满足自动类型转换条件
两种数据类型一定要兼容
目标类型要大于原类型
3.强制转换
(数据类型)值；

boolean:
只有2中结果：true或者false

if(表达式)//注意：表达式必须返回true或者false
{
//表达式为真代码
}

if(表达式){
//表达式为真的代码
}else{
//表达式为假的代码
}

注意:字符串比较必须用equals
字符串1.equals(字符串2)

switch(变量){
case 值1：
//代码
break;
case 值2：
//代码
break;
....
default:
//代码
break;
}
注意：
1）变量的类型:整数(int) char(字符)
2）case后面的常量必须不一样

if结构和switch结构区别:
相同点:
1)都是用来处理多分支条件的结构

不同点:
1)只能处理等值条件判断的情况，而且条件必须是整型变量或字符型变量,条件课枚举
2)没有switch选择结构的限制，特别适合某个变量处于某个连续区间时的情况

循环:
while(循环条件){
循环操作
}
注:当循环条件为true是，执行循环操作
先判断后执行

do{
//循环操作
}while(循环条件);

区别:
while:先判断后执行；条件不满足时一次都不会执行
do...while:先执行后判断；条件不满足时至少会执行一次

for(初始值;循环条件;循环变量更新){
//循环操作
}

循环的流程:
for(1;2;3){
4
}

1->2->4->3->2->4->3->2->....
注意：循环次数确定的情况下可以使用for循环

break:跳出整个循环
continue:跳出当次循环进入下次循环

数组:内存中一块连续的空间。
特点:
1.数据类型必须一致
2.大小固定
1.定义数组:
数据类型[] 数组名=new 数据类型[长度];
如:
double[] score=new double[5];

2.定义数组
数据类型[] 数组名={值1,值2,值3...};
如:
double[] score={1.2,2.4,5};
注意:声明和赋值不能分开写
如下就是一种错误:
double[] score;
score={1,2,3};

3.定义数组
数据类型[] 数组名=new 数据类型[]{值1,值2,值3...};
如:
double[] score=new socre[]{1,7,9,20};
注意:中括号中不要声明数组长度

访问数组：
数据名[下标]

注意:数组不能越界(ArrayIndexOutOfBoundsException)

获取数组长度: 数组名.length

程序运行时我们大概可以认为给内存分配2快空间:
1.栈空间，空间小，存储速度快，存放基本数据类型
2.堆空间，空间大，存储速度慢，存放引用类型

数据类型：
1.基本数据类型(值类型)
int double char boolean

2.引用数据类型
String 数组类

基本数据赋值:复制的是对应的值
引用数据类型赋值:赋值的是地址

属性:对象具有各项静态特征。
方法:对象执行的动作。
对象：用来描述客观事物的一个实体，由一组属性和方法构成
类:是具有共同的属性和动作的一类对象的集合。

类一般是泛指，表示一类事物，对象是具体。
类是对象的抽象，对象是类的具体。

1.定义一个类:
class 类名{

}

2.创建对象
类名对象名=new 类名();

3.给属性赋值
对象名.属性名=值；

4.调用方法(动作)
对象名.动作名();

定义一个方法(语法):
访问修饰符返回类型方法名(参数列表){
//代码
}

1)无参数无返回类型
public void 方法名(){
//代码
}
2)无参数有返回类型
public 返回值数据类型方法名(){
//代码
return 值;
}

注意:
如果两个方法在同一个类中,不需要创建对象,可以直接调用方法

变量声明的位置决定变量作用域
成员变量(全局变量)：声明在类里面方法外边的变量，作用域是整个类中有效，编译器默认会给一个初始值
局部变量：声明在方法里面或者代码块里面的变量，作用域是当前方法或者代码块有效，编译器不会给默认值

带参数方法:
1)带参数无返回类型
public void 方法名(数据类型变量名1,参数类型变量名2,...)
{
//代码
}

2)带参数有返回类型
public 数据类型方法名(数据类型变量名1,参数类型变量名2,...){
//代码
return 值;
}
调用:
对象名.方法名(值1，值2,...)

注意:方法参数列表的参数和调用者的参数列表必须数据类型一致，个数一致。

字符串:
定义字符串:
String str="值";
String str=new String("值");

常用方法:
字符串1.length() 获取字符串的长度
字符串1.equals(字符串2) 比较两个字符串是否相同，相同返回true,否则返回false
注:==是判断地址是否相等 equals是判断值是否相等

字符串1.equalsIgnoreCase(字符2) 比较两个字符串值是否相等并且忽略大小写

字符串1.toLowerCase() 全部转化为小写
字符串1.toUpperCase() 全部转化为大写
字符串1.concat(字符串2) 拼接2个字符串
字符串1.indexOf("字符串2") 查找字符串2首次出现的位置,没找到返回-1
字符串1.lastIndexOf("字符串2") 查找字符串2最后出现的位置,没找到返回-1
字符串1.substring(beginIndex) 从某个位置截取一直截取到最后
字符串1.substring(beginIndex,endIndex) 从beginIndex截取到endIndex(包含开始位置，不包含结束位置)
字符串1.trim() 去前后空格

String 不可变字符串
StringBuffer 可变字符串
StringBuffer sb=new StringBuffer("字符串");

sb.append("字符串"); 追加字符串
sb.insert(index,字符串); 在某个位置插入字符串

数据库
存储数据方式:
1.脑记忆:容易丢失，数据不精确，没办法存储海量数据。
2.纸张保存:检索和保管麻烦，没办法保存海量数据。
3.内存:没办法持久的的保存
4.硬盘:海量数据时，数据管理管理相对麻烦，数据的一致性，准确
性得不到保证。

数据库:存储数据的仓库.
Oracle数据库:产品免费，服务收费，大型数据库，用来存储海量数据。
SQLServer:微软的产品，有各种版本，易用性强和windows以及net等相关微软产品完美结合，适用于中小企业.
DB2:ibm产品，现在较少使用.
mysql:开源,和php可以完美结合.

Mysql:是一个小型关系型数据库管理系统，开发者为瑞典的mysql ab
公司,后来被sun公司收购，最后被oracle公司收购.
特点:
1.代码开源，基本免费
2.可以处理拥有千万记录的大型数据的能力
3.可移植性高，安装简单
4.支持常见的sql规范

登录数据库:
开始菜单->cmd->输入命令:
mysql -u root -p
输入密码：

常用命令:
1.查看所有数据库
show databases;

系统数据库:
information_schema:mysql元数据存放基础数据
mysql:存放配置信息包含用户信息，权限等等
performance_schema:保存mysql运行数据，包含日志信息等等.
test:测试数据库，空的

2.创建数据库
create database 数据库名;

3.查看数据库的字符集
show create database 数据名;

4.修改数据库的字符集
alter database 数据库名字 default character set gbk;

注意:创建数据库的同时指定字符集
create database 数据库 default character set gbk;

5.删除数据库
drop database 数据名;

客户端工具:HeidiSQL

建表:
数据类型:
int 整数
char(大小) 固定字符
varchar(大小) 可变字符
float 单精度小数
double 双精度小数

主键:唯一标识一个实体(唯一标识一条记录), 不允许为空不能重复.

员工编号员工姓名性别省份中号工资家庭地址
E001 张三男 234234234 5000 xxxx

建表语法:
create table 表名(
字段名数据类型(大小) [primary key|not null],
字段名数据类型(大小),
...
);

查看表结构:
desc 表名;

修改表名:
alter table 原始表名 rename to 新表名

添加新列:
alter table 表名 add column 字段名数据类型 [约束]

修改列:
alter table 表名 change column 原始字段新字段(大小)

删除列:
alter table 表名 drop column 列名;

-- 插入数据
insert into 表名(字段1,字段2,...)values(值1,值2,...)

insert into tb_emp(empId,empName,empSex,salary,address)
values('E0001','刘德华','男',5000,'湖南长沙');
insert into tb_emp(empId,empName,empSex,salary,address)
values('E0002','张学友','男',3000,'湖南株洲');
insert into tb_emp(empId,empName,empSex,salary,address)
values('E0003','郭富城','男',9000,'湖南长沙');
insert into tb_emp(empId,empName,empSex,salary,address)
values('E0004','黎明','女',2000,'湖南湘潭');
insert into tb_emp(empId,empName,empSex,salary,address)
values('E0006','黎明2','女',2000,'湖南湘潭');

insert into tb_emp(empId,empName,empSex,salary)
values('E0008','莫某','女',3000);

-- 更新数据
update 表名 set 字段1=值1,字段2=值2,... where 条件

update tb_emp set empName='张柏芝', empSex='女',salary=9000,address='中国香港'
where empId='E0005'
-- 注意:主键一般不能更新

-- 给每个人工资加200
update tb_emp set salary=salary+200
-- 给所有男员工减200
update tb_emp set salary=salary-200 where empSex='男' and
salary>5000
-- 给工资低于5000的员工以及女员工加薪1000
update tb_emp set salary=salary+1000 where empSex='女' or
salary<5000
-- 更新所有没有地址的记录，家庭地址为"地址不详"
update tb_emp set address='地址不详' where address is null

update tb_emp set address='地址不详' where address='null'

--删除记录
delete from 表名 where 条件
delete from tb_emp where empId='E0006'

------------------------------------------------------------------------------
-- 查询
-- 1.查询emp表所有列
select empid,empname,empsex,salary,address from tb_emp;
select * from tb_emp; -- *代表所有列,尽量少用*

-- 2.查询emp中某些列(编号,姓名,薪水)
select empid,empname,salary from tb_emp;

-- 3.给查询列别名
select empid 员工编号,empname as 员工姓名,salary as
员工薪水 from tb_emp;

-- 4.查询空列
select * from tb_emp where address is null;
update tb_emp set address=NULL where address='地址不详';

-- 5.查询时合并列 concat(列或者常量，列或者常量,....)
select empId,concat(empname,'(',empSex,')') myname,
empSex,address from tb_emp;

-- 6.取前面几列 limit(开始索引,数量)
-- 如:取前面3条记录
select * from tb_emp limit 0,3;

-- 7. 升序(asc 默认) 降序(desc)
-- 按照工资的升序排列
select * from tb_emp order by salary asc;
-- 按照工资的降序排列
select * from tb_emp order by salary desc;
-- 查男员工的工资，并且按照降序排列
select * from tb_emp where empSex='男' order by
salary desc;

-- 8.模糊查询(%匹配一个或者多个字符,_匹配一个字符)
-- 1）查询所有刘姓员工
select * from tb_emp where empname like '刘%';
-- 2）查询名字里包含刘的员工
select * from tb_emp where empname like '%刘%';
-- 3）查询姓名中刘结尾的员工
select * from tb_emp where empname like '%刘';
-- 4) 查询姓刘，但名字只包含一个字的员工
select * from tb_emp where empname like '刘_';

-- 9 模糊查找某个范围 between 起始值 and 结束值
select * from tb_emp where salary>=4200 and salary<=6000;
select * from tb_emp where salary between 4200 and 6000;

-- 10 模糊查询 in
select * from tb_emp where address='湖南长沙' or
address='湖南湘潭' or address='中国香港';

select * from tb_emp where address in('湖南长沙',
'湖南湘潭','中国香港');

-- 查询语法
select 字段名[*] from 表名
[where 条件]
[group by 分组字段]
[having 条件]
[order by 排序字段 desc|asc]

-- 常用函数
select concat('a','b','c') val;
select concat_ws('-','a','b','c') val;
select lower('ABC');
select upper('abc');
select left('abcdefg',4) val; -- 从左边开始截取多个字符
select right('abcefg',2) val; -- 从右边开始截取多个字符
select position('c' in 'abdefcg') val;-- 查找某个字符第一次出现的位置
select reverse('abcd') as val; -- 反转字符串
select trim(' a b ') as val; -- 取出前后空格

-- 日期函数
-- 1. adddate(date_add)同义词
select adddate('2016-10-17',30) val;
select date_add('2016-10-17',interval 30 day) val;

-- 2.curdate() 返回系统当前日期
select curdate() now

-- 3. DATEDIFF(expr,expr2) 返回两个日期间的天数
DATEDIFF() 返回起始时间 expr和结束时间expr2之间的天数。

select datediff('2016-10-20','2016-10-1') val;

select * from tb_emp where
datediff(born,adddate(curdate(),-30))>=0

-- 4. extract 获取日期的某一个部分
SELECT extract(year FROM curdate()) val;-- 获取年份
select extract(month from curdate()) val; -- 获取月份
select extract(day from curdate()) val; -- 获取天

select * from tb_emp where extract(month from born)=8

-- 聚合函数(特点：返回单行单列)
-- 查询最低工资
select min(salary) 最低工资 from tb_emp;
-- 查询最高工资
select max(salary) 最高工资 from tb_emp;
-- 查询平均薪水
select avg(salary) 平均薪水 from tb_emp;
-- 计数
select count(*) 总员工 from tb_emp where empsex=
'男';

-- 分组（group by 分组字段）
-- 每个部分有多少人
select depName,count(*) num from tb_emp group by depName;
-- 每个部门最高工资和最低工资
select depname,count(*),max(salary),min(salary) from tb_emp
group by depname;

-- 注意：分组查询的查询字段必须是分组字段或者是聚合函数

select depname,count(*) from tb_emp where empsex='男'
group by depname;

select depname,count(*) num from tb_emp where empsex='男'
group by depname having num<2;

select address,avg(salary) avgMoney from tb_emp
group by address having avgMoney<4500 order by
avgMoney asc

注意：where 先筛选后分组
having 分组后的筛选

多表查询:
关系型数据库:采用关系模型来组织数据的数据库.简单来说关系型
数据库就是二维表格模型以及其关系的数据组织。
一条记录就是一个实体。
主键:唯一标示一条记录，不能重复，不能为空。一个表只能有一个主键，但主键可以由多个字段组成。

外键:表的外键是引用另外一种表的主键，外键可以有重复的，保证
数据的一致性和完整性，一个表可以多个外键。

学生信息表
stuId(pk) stuName sex address classId(fk)
S001 张三男长沙 4
S002 ...

班级信息表
classId(pk) className
1 java13
2 java14
3 java15
4 java16
5 java17
6 java18

科目信息表
projectId(pk) project
1 英语
2 计算机
3 物理
4 美术

选修课信息表
id(pk) stuId(fk) projectId(fk)
1 S001 1
2 S001 3
3 S001 4
4 S0。2 1
5 S002 2

try{
可能出现异常的代码
}catch(异常类型){
异常处理的代码
}finally{
无论是否出现异常都会执行的代码
}

JDBC:JAVA数据库连接技术的简称。提供对数据库进行操作的接口或者类。

增删改代码见项目.

this:对当前对象的引用。
this.属性名:引用当前对象的成员变量。

构造函数:
特点:构造函数在对象创建的时候，由系统调用，提供对成员的初始化。
语法:
访问修饰符类名(参数列表){
//初始化代码
}
语法特点:与类同名,没有返回类型，可以重载。
注意:当用户没有提供构造函数时，系统会默认提供一个无参构造函数，当用户显示提供构造函数了，系统将不提供任何构造函数。

重载:在同一个类中，方法名相同参数列表不同（参数个数，参数类型），与返回类型无关。

静态成员和非静态成员:
语法:静态成员通过类名访问，非静态成员通过对象名去访问。
加载时机:静态成员在类加载时加载，非静态成员在对象创建时加载.
共享方式:静态成员是所有对象所共享的，非静态成员没创建一个对象就有一个新的实例。

访问修饰符:
public:共有的，任意地方都可以访问

protected:受保护的，只能在当前类以及子类访问.
private:私有的，只能在当前类访问
默认为default当前包。

继承:是从一个类扩展出一个新类的过程。
语法:
class 子类[派生类] extends 父类[基类]{
//代码
}
特点:
1.子类会继承父类所有的成员，除构造函数。
2.继承必须满足is-a的关系。
3.继承必须具备单根性
注意:创建子类对象的时候，首先调用父类无参构造函数,再调用其本身的构造函数。也可以通过super关键字指定调用父类的某个构造函数（在构造函数中super关键字必须放到第一行）。

super:对父类的引用
1.指定系统调用父类的某个构造函数，但必须放在第一行
2.指定调用父类的方法或者属性，在子类中无位置要求

重写:在继承中,为了满足子类的需求，父类的方法在子类中重新实现。
注意:重写的方法返回类型，参数列表必须父类方法一致。访问修饰的权限必须和父类方法一样或者更高。

向上转型:父类的引用指向子类的对象
1.通过父类的引用可以调用继承的的方法和重写的方法。
2.通过父类无法调用子类特有的方法。

instanceof：判断两个类型是否兼容。（是该类型或者派生于该类型）

final关键字:
1. 修饰类
final class 类名{}
修饰类的时候，表示这个类是终极类(密封类),不允许派生子类。
2. 修饰方法
访问修饰符 final 返回类型方法名(参数列表){}
修饰方法的时候,表示这个方法为终极方法，子类不能对其重写。
3. 修饰变量
fianl 变量类型变量名=值;
修饰变量时候，标示这个变量是一个常量，一经赋值不能修改。
(1.要么在声明的时候赋值 2.要么在构造函数中赋值)

抽象类:用abstract修饰的类为抽象类.抽象类是一个不完整的类，不能创建其对象。
抽象方法:用abstract修饰的方法，抽象方法只有方法的声明，没有
方法的主体。子类必须对其重写。
注意:一个类中有一个抽象方法，那么这个类一定是抽象类，抽象类中不一定有抽象方法。

接口:
定义接口:
访问修饰符 interface 接口名{
抽象成员或者常量;
}

实现接口
class 类名 implements 接口1,接口2,...{
//实现父类抽象成员
}

抽象类和接口的区别:
不同点:
1.语法角度看关键字不一样，抽象类用abstract修饰,接口用interface修饰,子类继承的时候抽象用extends关键字,接口用于implements关键字.
2.接口中只能出现抽象成员和常量,抽象类中抽象成员和非抽象成员都可以出现。
3.接口可以多接口实现，但抽象类只能单一继承。
4.接口和子类体现是一种can-do关系，是一种契约，一种约定.而抽象类体现的是一种is-a关系。
相同点:
1.抽象类和接口都不能被实例化.
2.抽象类和接口都可以包含抽象成员，并且子类中都必须实现其抽象成员。

HTML(Hyper Text Markup Language):超文本标记语言
浏览器:用来解析和显示html语言工具.
页面结构:
<html>
<head>...</head>
<body>...</body>
</html>

<title>标签: 显示网页的标题

标题标签:
<h1>...<h6>

段落标签:
<p>...</p>

换行标签:
<br/>

水平线标签:
<hr/>

加粗标签:
<strong>...</strong>

斜体标签:
<em>...</em>

特殊符号:
空格  
大于 >
小于 <
双引号 "
版权符号 ©

图片标签:
<img src="路径" title="鼠标悬停时提示的文字" alt="图片替代的文字" width="宽度" height="高度"/>

超链接:
1.页面间的链接
<a href="网页路径" target="目标窗口">显示的文字</a>
target值:
_self:在当前窗口打开(默认)
_blank:在新窗口打开
2.锚链接
1）本页锚链接
1.设置锚标记 <a name="锚标记">锚名称</a>
2.跳转 <a href="#锚标记">文字</a>
2)其他页
1.设置锚标记 <a name="锚标记">锚名称</a>
2.跳转 <a href="网页名称#锚标记">文字</a>
3.功能性链接
1.邮箱:<a href="mailto:邮箱地址">文字</a>
2.启动QQ:<a href="tencent://message/?uin=317180466">QQ联系</a>

列表标签:
1.无序列表
<ul type="类型">
<li>...</li>
<li>...</li>
...
</ul>
类型: disc(默认)实心圆 circle空心圆 square正方体
2.有序列表
<ol type="类型">
<li>...</li>
<li>...</li>
...
</ol>
类型:1数字 a|A字母 i|I:罗马数字
3.图文混排
<dl>
<dt></dt>
<dd></dd>
</dl>

表单标签:
<form action="表单提交后的链接" method="post|get">
...表单元素
</form>

input标签:
<input type="类型" name="名字"/>

type:text(文本框)
如:<input type="text" value="默认值" readonly="readonly"/>

password(密码框)

checkbox(复选框)

radio(单选框)
如：默认选中
<input type="radio" checked="checked" >男

button(普通按钮,不能提交表单)

reset(重置按钮) 重置表单

submit(表单提交按钮，提交表单)

文本域:
<textarea rows="高度" cols="宽度"></textarea>

下拉框:
<select name="名称">
<option>初中</option>
<option>初中</option>
<option>高中</option>
<option selected="selected">本科</option>
</select>

disabled="disabled" 禁用
readonly="readonly" 只读

行级标签:<span> <input> <a> <textarea> <select>...
块级标签(独占一行):
<div> <p> <table> <ul> <ol> <h1>...<h6> <br>

<span>，<div>:内容容器

表格:<table>
行:<tr>
单元格:<td>
单元格属性:
合并列:<td colspan="数字"></td>
合并行:<td rowspan="数字"></td>

框架集:
<frameset rows="宽度(可以是像素或者百分比),*" frameborder="1">
<frame src="top.html"/>
<frameset cols="160,*">
<frame src="menu.html" />
<frame name="rightFrame" />
</frameset>
</frameset>

框架集一般用于后台。

CSS：层叠样式表（Cascading Style Sheet）
作用：用来定位元素和美化页面。
基本语法:
1.标签选择器
标签名{
属性名:值;
属性名:值;
...
}

2.类选择器
.类名{
属性名:值;
属性名:值;
...
}

调用:
<元素名 class="类名"></元素名>

3.ID选择器
#id名称{
属性名:值;
属性名:值;
...
}
调用:
<元素名 id="id名称"></元素名>

优先级:ID选择器>类选择器>标签选择器
----------------------------------------------
外部样式表:CSS代码保存在扩展名为.css的样式表中

内部样式表：CSS代码写在<head>的<style>标签中
优点：方便在同页面中修改样式
缺点：不利于在多页面间共享复用代码及维护，对内容与样式的分离也不够彻底

行内样式表:直接写在元素的style属性中。
优点:直观明了，便于修改
缺点:不利于在多页面间共享复用代码及维护，对内容与样式的分离也不够彻底，在开发过程中不建议大家使用。

使用原则，就近原则。

后代选择器:
选择器1 选择器2{
属性：值;
属性: 值;
...
}

并集选择器:
选择器1,选择器2{
属性:值;
属性:值;
...
}

字体样式:
font:字体风格字体粗细字体大小字体类型;
font-family 设置字体类型
font-size 设置字体大小
font-style 设置字体风格
font-weight 设置字体粗细

文本样式:
color 字体颜色
text-align 水平对其方式
text-indent 首行缩进
line-height 设置字体行高
text-decoration 设置文本的修饰

伪类样式:
标签名:伪类名{
属性:值;
...
}
如:
a:link{
/*未单击访问时候的样式*/
}
a:hover{
/*鼠标悬浮上去的样式*/
}
a:visited{
/*单击访问后的样式*/
}
a:active{
/*鼠标单击未释放的超链接样式*/
}
----------------------------------------------
Javascript:是一种基于对象和事件驱动的，并具有安全性能的脚本语言。
好处:
1.表单验证，减轻服务器的压力
2.制作一些动态效果
javascript组成:
ECMAScript,DOM,BOM

首先导入标签:
<script type="text/javascript">
//javascript代码
</script>
可以放到文档的任意地方。

基本语法:
1.定义变量
var 变量名;
变量名=值;

var 变量名=值;
2.数据类型
number:代表数字类型(包括整数和小数)
string:表示字符串
boolean:表示true或者false;
undefined:变量没有赋值时候为undefined
null:表示一个空对象

typeof(值):获取值的数据类型。

3.string类型:
属性:length 获取字符串长度
方法:charAt(index) 获取置顶位置的字符
indexOf(str) 返回字符串第一次出现的位置，没找到返回-1
substring(start,end) 截取某个范围的字符串(包括start,不包括end)
split(str):通过分割字符返回字符串数组；

4.定义数组
var 数组名=new Array([大小]);

属性:
length:获取数组的长度
方法:
push:向数组末尾添加一个或者更多的元素，并返回数组的长度

5.
alert("消息"); 弹出消息
prompt("标题信息","文本框默认值")

6.函数
parseInt("字符串") 将字符串转换为整型数字
parseFloat("字符串") 将字符串转换为浮点型数字
isNaN(值) 判断是否是一个非数字,如果不是数字返回true

7.定义函数
function 函数名(参数列表){
代码
}

JQuery：是现在最流行的javascript程序库,它是对javascript对象
和函数的封装.
优势：
体积小，压缩后只有100KB左右
强大的选择器
出色的DOM封装
可靠的事件处理机制
出色的浏览器兼容性
使用隐式迭代简化编程
丰富的插件支持

使用:
1.导入jquery文件
2.$(function(){ 代码 });
$(function(){ 代码 })和window.onload区别:
window.onload必须等待网页中所有的内容加载完毕后
（包括图片、flash、视频等）才能执行。
$(function(){ 代码 }):网页中所有DOM文档结构绘制完毕后
即刻执行，可能与DOM元素关联的内容（图片、flash、视频等）
并没有加载完

选择器:
1.基本选择器
1)标签选择器(getElementsByTagName)
$("标签名").doWork(); 根据标签名获取一组jquery对象.
2)ID选择器(getElementById)
$("#id名").dowWork(); 根据ID名获取一个jquery对象
3)类选择器
$(".类名").dowWork(); 根据class类名获取一组jquery对象
2.并集选择器(s可能是标签、Id、类)
$("s1,s2,s3...").doWork(); 根据每个匹配的元素合并一起获取一组
jquery对象.
3.交集选择器
$("element.class").doWork()或者$("element#id名").doWork()
匹配指定的class或者id的某元素的集合.
4.全局选择器
$("*").doWork(); 匹配所有元素.
5.后代选择器(s可能是标签、Id、类)
$("s1 s2").doWork(); 获取s1里面所有s2的元素(深层迭代)
6.子选择器
$("s1>s2").doWork(); 获取s1里面下s2的子元素(不深层迭代)
7.相邻选择器
$("s1+s2").dowWork();获取s1后面相邻的一个s2元素(中间不能出现其他元素)
8.同辈选择器
$("s1~s2").doWork();获取s1后面所有的s2元素(中间可以有其他元素)
9.属性选择器
1)$("[attr]").doWork(); 获取包含该属性的元素.
2)$("[attr=值]").doWork(); 获取包含该属性值的元素
3)$("[attr!=值]").doWork(); 获取不包含该属性值的元素
4)$("[attr^=值]").doWork(); 获取包含改属性并且以该值开头的元素。
5)$("[attr$=值]").doWork(); 获取包含改属性并且以该值结尾的元素。
6)$("[attr*=值]").doWork(); 获取包含改属性并且包含该值的元素。
10.基本过滤选择器
1)获取第一个元素
$("s1:frist") 获取第一个元素
$("s1:last") 获取最后一个元素
$("s1:even") 获取所有偶数元素(索引从0开始)
$("s1:odd") 获取所有奇数元素(索引从0开始)
$("s1:eq(index)") 获取索引等于index的元素
$("s1:gt(index)") 获取索引大于index的元素(不包含index)
$("s1:lt(index)") 获取索引小于index的元素(不包含index)
$("s1:not(s2)") 获取不包含s2的所有元素(不包含index)
$("s1:header") 针对有标题元素h1~h6
$("s1:hidden") 针对s1下面的隐藏的元素
$("s1:visible")针对s1下面所显示的元素

JQuery对象:使用jquery包装DOM后产生的对象。
DOM对象:直接使用javascript获取的节点对象。

jquery对象->dom对象
$("s1").get(0)

dom对象->jquery对象
$(dom对象)

eq(index)和get(index)区别:
相同点：都是通过下标获取某个元素.
不同点:
eq(index)获取的是jquery对象,get(index)获取的是dom对象

点击事件:
$("s1").click(function(){
//代码
});

addClass(类名) 添加类样式
removeClass(类名) 移除样式

---------------------------------------
集合:
Collections:表示集合,提供对集合进行排序和遍历等算法的实现.
Collection接口:
List:有序存储数据，可以有重复的数据
ArrayList:结构和数组相似,栈结构，先进后出，存储空间连续，查找遍历效率高，中间和底部插入数据效率低
LinkedList:链表结构，增加和删除元素效率高，查询效率低
Vector:和ArrayList实现原理和功能一样，线程安全，效率低。长度需增长时，Vector默认增长一倍，ArrayList增长50%。
Set:无序存储数据，不可以有重复数据
HashSet:

Hashtable和HashMap的异同
实现原理、功能相同，可以互用
主要区别
Hashtable继承Dictionary类，HashMap实现Map接口
Hashtable线程安全，HashMap线程非安全
Hashtable不允许null值，HashMap允许null值

装箱:从值类型转化为引用类型的一个过程。隐式装箱
拆箱:从引用类型转化值类型的一个过程。显示拆箱

List接口常用的方法:
1. xx.add(元素) 往集合中添加一个元素
xx.add(index,元素) 往集合指定位置添加一个元素
2. xx.size() 获取集合的长度
3. xx.get(index) 获取指定索引位置的元素
4. xx.contains(元素) 是否包含某个元素，返回一个boolean型
5. xx.remove(index) 根据下标或者元素移除一个元素
xx.remove(元素)

LinkedList特有的方法:
1. xx.addFirst(元素); 往链表的首部添加一个元素
2. xx.addLat(元素); 往链表的尾部添加一个元素
3. xx.getFirst(); 获取首部的元素
4. xx.getLast(); 获取尾部的元素
5. xx.removeFirst(); 移除第一个元素
6. xx.removeLast(); 移除最后一个元素

Map接口专门处理键值映射数据的存储
无序排列(哈希算法)
HashMap:键不能重复，值可以重复。

xx.put(键,值) 往Hash表中添加键值对
xx.get(键) 根据键找值
xx.remove(键) 根据键移除一个键值对
xx.size() 获取键值对的个数
xx.keySet() 获取所有键的集合
xx.values() 获取值的集合
xx.containsKey(键) 是否包含某个键
xx.containsVlue(值) 是否包含某个值

加强型for循环:
for(数据类型变量名:数组或者集合){
}

泛型集合类型更加的安全，效率更高。

异常是指在程序的运行过程中所发生的不正常的事件，它会中断正在运行的程序
java的异常处理机制:
try{
//可能出现异常的代码
}catch(异常类型 ex){
//异常出现处理的代码
}finally{
//无论异常是否发生，都会执行此代码
}

自定义异常:
class 异常类 extends RuntimeException{
}

分层:

客户----->服务员------>厨师--------采购员---->食材市场
客户----->UI层 ----->业务逻辑层-->数据访问层--->数据库
(web层，界面层)

UI层:信息的显示或者信息录入。
业务逻辑层：进行业务逻辑的处理，比如产生单号，税费的计算...
数据访问层: 对数据库的增删改查。

一张表对应一个实体类
一张表中的字段对一个一个实体类中的属性。

文件流：
1.根据流向分类:
1)输出流:用来写数据的，是由程序(内存)----->外界设备
2)输入流:用来读数据的，是由外界设备----->程序(内存)

2.根据流数据的格式分类
1)字节流:处理声音，图像，图片等二进制的数据的流。
2)字符流:处理文本数据的流

3.根据数据对象来分类
1)高级流:所有内存中的流都是高级流
2)低级流:所有外界设备中的流都是低级流。

静态网页生成
器。

1.建库建表
news表
nid(新闻编号) author(作者) indate(日期) content(内容)
2.插入5条记录
3.创建一个静态模板

JSP:

1.动态网站和静态网站的区别?
1)动态网站有在服务器执行的代码，会根据参数，时间，空间，用户的不同返回不同的结果或者页面。
2)动态网站具有交互性，根据用户的需求动态改变和显示内容。
3)动态网站可以自动更新，无需修改html页面，可以动态修改页面内容。

2.C/S(Client/Server)和B/S(Browser/Server)区别:
1)cs需要安装客户端，在程序维护升级的时候相对麻烦，bs是通过浏览器访问，升级维护简单。
2)cs一般用于局域网，客户群相对固定和简单，安全性也高。

URL:统一资源定位符(uniform resource locator)
http://www.baidu.com/index.html
http:协议名称
www.baidu.com:域名(实际上就是一个IP)
index.html:项目资源地址

Tomcat服务器:
配置服务器:
1.右击"计算机"->"属性"->"高级系统配置"->"高级"选项卡->"环境变量配置"->xx用户变量->新建->
变量名"JAVA_HOME"
变量值:[jdk的安装路径]:例如:C:Program Files (x86)Javajdk1.7.0_25
2.测试：
1.启动服务器:D:apache-tomcat-7.0.53instartup.bat
2.打开浏览器:http://localhost:8080/
看到一只猫就成功啦...

Tomcat服务器目录:
bin:存放各种平台下用于启动和停止tomcat的脚本文件.
conf:存放tomcat服务器的各种配置文件.
lib:存放tomcat服务器所需的各种jar文件.
logs:存放tomcat的日志文件.
temp:存放运行的时候的一些临时文件.
work:存放tomcat把jsp生成的servlet存放到此目录.
webapps:当web程序发布时，默认情况下会将web程序文件放到该目录。

修改端口：
1.找到conf目录下的server.xml文件
2.找到节点:
<Connector port="8080" protocol="HTTP/1.1"
connectionTimeout="20000"
redirectPort="8443" />
修改端口（8000以上）

部署一个自己的网页：
1.在x:apache-tomcat-7.0.53webapps文件夹下新建一个文件夹，放入我们的静态页面
2.http://ip:端口号/文件夹名/页面名

修改默认页面:
1.在网页所在的文件夹下面新建一个WEB-INF文件夹
2.在conf目录下复制web.xml文件到WEB-INF的文件夹中
3.修改web.xml文件
<welcome-file-list>
<welcome-file>abc.html</welcome-file>
<welcome-file>index.htm</welcome-file>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>

JSP:(Java Server Page)
JSP是SUN公司开发的一种基于服务器的动态的Web开发技术.

Page指令:
<%@ page language="页面使用的语言" contentType="text/html; charset=UTF-8" pageEncoding="编码格式"%>

JSP页面元素(页面的组成):
1.Html静态文本
2.指令:以“<%@ ” 开始，以“%> ” 结束
3.小脚本:<%Java代码 %>
4.表达式:<%=Java表达式 %>
5.声明:<%! 方法 %>
6.注释:

<%-- 客户端不能查看到 --%>

表单提交方式get和post区别:
1.get地址栏会显示表单提交信息，安全性低，而且长度会收到限制
不能传递对象，对seo不友好.
2.使用起来非常的方便，特别是查询，而且便于添加书签。

JSP内置对象:由Web容器自动创建的一组对象，无需用户去实例化，直接去使用
(out,request,response,session,application)

1.out
out.println("内容"); 在jsp页面上输出内容

2.request:封装了客户端的请求信息.
request.getParameter("表单元素名称"); 根据表单元素名称获取元素的值
request.getParameterValues("表单元素名称");根据表单元素名称获取元素的一组值。
request.setCharacterEncoding("UTF-8");utf-8编码

解决中文乱码问题:
方式一:(每个参数都必须转换)
String name=request.getParameter("name");
name=new String(name.getBytes("ISO-8859-1"),"UTF-8");

方式二:(当次请求有效)
request.setCharacterEncoding("UTF-8");

方式三:(整个项目有效)
在Tomcat目录结构confserver.xml中设置字符集
<Connector port="8080" protocol="HTTP/1.1" connectionTimeout="20000"
redirectPort="8443" URIEncoding="UTF-8"/>

response:封装了服务端的响应信息.

页面跳转:
1.转发
request.getRequestDispatcher("新页面").forward(request, response);
转发是在服务器端发挥作用，直接在服务器端进行跳转，客户单浏览器地址不变。
2.重定向
response.sendRedirect("新页面");
重定向是在客户端发挥作用，通过新请求的地址实现跳转，地址栏中地址改变。

session:
http协议:是无状态协议，每次请求响应后客户端和服务器没任何关系。

会话:在一段时间内，同一个浏览器对服务器之间的请求和响应.
session.getId():获取sessionId，唯一标示此会话。
session.setMaxInactiveInterval(秒);设置session的有效期
session.getMaxInactiveInterval();获取session的有效期
session.invalidate();设置当前session失效

设置Session失效方式:
1.手动设置失效：invalidate()
2.超时失效
通过setMaxInactiveInterval( )方法,单位是秒
3.通过设置项目的web.xml或Tomcat目录/conf/web.xml 文件，单位是分钟
<session-config>
<session-timeout>30</session-timeout>
</session-config>

Session值是保存在服务器,默认时间30分钟。

Cookie:
1.临时cookie:浏览器关闭，cookie生命周期结束。
2.永久cookie:通过setMaxAge设置时间，可以长达几年甚至几十年。
一般用来保存个人的非敏感性信息。

四大作用域:
Page作用域:他的作用范围在当前jsp里面，在一个jsp页面有效.
赋值:pageContext.setAttribute("键",obj);
取值:pageContext.getAttribute("键");

Reqeust作用域:指从http请求发起，到服务器处理结束，返回响应的
整个过程。(在一个请求响应中有效)
赋值:request.setAttribute("键",obj);
取值:request.getAttribute("键");

Session作用域:作用范围在当前会话。
赋值:s
2ession.setAttribute("键",obj);
取值:session.getAttribute("键");

Application作用域:从服务器启动到服务停止。
赋值:application.setAttribute("键",obj);
取值:application.getAttribute("键");

Servlet:
1)servlet是sun公司基于java技术的一种开发动态资源的规范，以接口的形式出现，最终实现类和服务器有关，在服务器运行，由web容器管理.
2)servlet是一个特殊的java类,可以接收客户端的请求并响应,遵循http协议。

1.实现servlet接口+web.xml配置文件
2.继承GenericServlet类+web.xml配置文件
3.继承HttpServlet类+web.xml配置文件

Servlet生命周期:
1.第一次通过浏览器访问servlet时，服务器会根据请求的路径，在web.xml文件中查找相对应的servlet名称和全路径，通过反射产生对象。
2.调用init方法为servlet做初始化工作(每个servlet只会调用一次init方法)
3.调用doGet或者doPost方法为浏览器做成响应.(通过service方法分配)
4.第二次访问相同的servlet，直接从服务器端servlet实例对象集合中获取相对应的对象。（不需要经过第1,2步）,同一个servlet实例，在服务器端只有一个。
5.服务器重新部署，销毁servlet实例的时候调用destroy方法。

El表达式(Expression Language):用于替代jsp里复杂的代码，el的语法非常简单，最大的特点使用起来方便，无需类型转化。
语法:
获取普通变量
${变量名}

获取实体值
${对象名.属性名}
${对象名["属性名"]}
注意：当属性名包含一些特殊时：
${对象名.属性名} 错误
${对象名["属性名"]} 正确

获取集合值
${对象名[索引].属性名}
${对象名[索引]["属性名"]}

默认的作用域权限:
page>request>session>application

隐式对象的作用域:
属性范围 el表达式
page pageScope
request requestScope
session sessionScope
application applicationScope

JSP标准标签库（JavaServerPages Standard Tag Library）
1.提供一组标准标签
2.可用于编写各种动态 JSP 页面

一:通用标签
1.<c:out>用来显示数据对象(字符串，表达式...)的内容和结果.
<c:out value="显示的内容" escapeXml="是否转义"></c:out>
2.<c:set>用来设置jsp内置对象中的值。
1)给jsp范围内变量赋值
<c:set var="变量名" value="值" scope="域" ></c:set>
2)给实体变量赋值
<c:set target="实体" property="实体属性" value="值" ></c:set>
例如:<c:set target="${list[1]}" property="depName" value="发钱部" ></c:set>
3.remove：删除指定范围内的变量
<c:remove var="变量" scope="scope"/>

二:条件标签
<c:if test="${sessionScope.name eq '刘德华' }">
....
</c:if>

1.设计模式:解决某一类问题的一种特定的解决方案。
一共23设计模式。
创建模式(5种) ：负责对象创建
工厂模式;建造模式;原始模型模式;单例模式

结构模式(7种) ：处理类与对象间的组合
适配器;桥梁模式;合成模式;装饰模式;门面模式; 代理模式;享元模式

行为模式(11种) ：类与对象交互中的职责分配
命令模式；观察者模式；策略模式…

一:单例模式:有且只有一个对象，提供对外访问接口。
例如:
1.简单单例
class Person{
private Person(){}
private static Person ps=null;
public static Person GetPerson(){
if(ps==null)
ps=new Person();
return ps;
}
}
2.静态初始化单例
class Person{
private Person(){}
private static Person ps=new Person();
private static Person GetPerson(){
return ps;
}
}

二:简单工厂:根据传入的参量动态决定创建某一个具体产品。客户只
负责对象的消费，而不负责对象的创建。
这个模式本身很简单而且使用在业务较简单的情况下。一般用于小项目或者具体产品很少扩展的情况（这样工厂类才不用经常更改）。
它由三种角色组成：
抽象产品角色：它一般是具体产品继承的父类或者实现的接口。由接口或者抽象类来实现。
具体产品角色：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。
工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑，根据逻辑不同，产生具体的工厂产品。
----------------------------------------------------------
JSON(JavaScript Object Notation): 是一种轻量级的数据交换格式,JSON采用完全独立于语言的文本格式，易于人阅读和编写，同时也易于机器解析和生成(一般用于提升网络传输速率)。

JSON 数据的书写格式是：名称/值对。
JSON[1] 结构有两种结构：
对象:{"属性1":"值1","属性2":"值2",...}

数组:
[{"属性1":"值1","属性2":"值2",...},{"属性1":"值1","属性2":"值2",...},{"属性1":"值1","属性2":"值2",...},...]

JSON字符串->普通对象
1）var 对象名=eval("("+json字符串+")");

2）导入json2.js
var obj=JSON.parse(json字符串);//json字符串转化为普通对象

普通对象->JOSN字符串
var json=JSON.stringify(对象);//普通对象转化为json字符串

JAVA后台:
1.，使用导入fastjson（fastjson-1.2.9.jar）
1)普通对象->JSON字符串
String msg=JSON.toJSONString(普通对象);//把对象转为json字符串

2)JSON字符串->普通对象
<1>单个对象:
类名对象名=JSON.parseObject(json字符串,类名.class);
<2>对象数组:
List<类名> 对象名=(List<类名>)JSON.parseArray(json字符串,类名.class);

AJAX原理:通过核心对象xmlhttprequest向服务器发送异步请求，提交数据，服务器响应，通过javascript进行页面的局部替换。

进程:每个进程都有独立的的代码和数据空间,一个进程包含1-n多个线程，进程间切换需要较大开销。
线程:同一类线程共享代码和数据空间，每个线程有独立的运行栈,线程切换开销较小。

如果在一个进程中同时运行了多个线程，用来完成不同的工作，则称之为多线程。

线程的创建:
1.继承Thread类
2.实现Runnable接口

1.继承Thread类编写简单，多线程不能共享一个Thread对象，多个线程分别完成自己的任务,并且不能继承其他类。
2.实现Runnable接口可以继承其他类，多个线程可以共享同一个Thread对象，1-n多个线程共同完成一个任务。

1.继承java.util.TimerTask类，并实现run() 方法
class Thread_1 extends TimerTask{
public void run(){
//代码
}
}
2.创建timer对象,调用schedule方法
Timer timer=new Timer();
timer.schedule(对象名, 多久后执行,执行频率);

线程的调度:
1.线程的优先级:线程对象.setPriority(p)来改变线程的优先级
每个线程都具备一定的优先级，当调度线程的时候，会优先考虑级别高的线程(范围是1-10，默认为5).优先级高的线程分配的时间片长或者分配的机会多。
2.Thread.sleep(毫秒);
进入被阻塞的状态，直到经过指定的时间后，才进入可运行状态。

多线程优劣势:

Love馨蕊