自己写的凌乱的笔记

c/s项目(javaSE) client server
b/s项目(javaEE)browaer server


ASP(2002~2003)

b/s对比c/s项目：
c/s对客户机比较高,
注册表：C++ C#中有其他的好处；升级麻烦。

b/s：不需要安装，升级很方便；
缺点：客户的体验差，操作麻烦：发展趋势WEB2.0的技术（ajax）

web服务器 tomcat web logic  WebSphere

http://www.apache.org/

http://tomcat.apache.org/tomcat-9.0-doc/index.html
http://tomcat.apache.org/download-90.cgi
http://tomcat.apache.org/download-60.cgi

推荐版本

j2EE5+tomcat6+JDK1.6


c/s 三层架构
b/s：mvc架构——model（（biz 逻辑层）+数据访问 +dto+entity） view（JSP /html
运行结果）    contller（servlet）


javaEE ==java2E

lib放jar包
web.xml权限的
mp.html欢迎页

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"


JAVA的

http://localhost:8080/
127.0.0.1:8080/web站点
协议  地址  端口 /web site name /目录名 /资源名
报404错误！目标资源没有找或者不存在！

（*jpg）（html）（JSP）（Servlet）

文件夹下拷贝

对象编程java  万物皆对象；
2.java语法：
 class  类(不同类型 可以构造出来的不同的对象)

继承：子类可以使用父类的属性和方法



JAVAEE教程：
javaweb

http://localhost:8080/Wabapp/ap.jsp
地址名称

JAVA EE 5 library 类库
src java源程序
webRoot项目的根目录
index.jsp 资源文件
系统目录

context root  改目录
<welcome-file>ap.jsp</welcome-file>


jsp  java Server pages  简化Servlet

jsp

asp.net

php


Lamp：liunx +apache+mysql+php


jsp：注释 指令 表达式  小脚本 声明 静态内容


jsp指令元素 page指令  页面属性


<%@ page 属性1="属性值"%>
属性：
language jsp的脚本语言 java
import 引用脚本语言使用到类文件 无


/* 实例化对象 */
ObjectReference = new Constructor();
/* 访问其中的变量 */
ObjectReference.variableName;
/* 访问类中的方法 */
ObjectReference.MethodName();

contentType  jsp采用的编码方式 text/html,ISO-8859-1


<!--html注释 客户端可见-->
<%--jsp注释客户端不可见--%>

<h1>JSP页面</h1>
  <hr>
  <!--html注释 客户端可见--></br>
  <%--jsp注释客户端不可见--%>
 
  <%//单行注释
   /*多行注释*/
   
   out.println("欢迎大家学习JAVAEE开发！<br>");
   out.println("欢迎大家学习JAVAEE开发！<br>");
  %>
<%! 声明变量%>

<%!
  int num=100;//声明一个整形的变量
  int add(int x,int y)//实现整形相加
  {
      return x+y;
  }
 
 
 
  %>
  <br>
 
  num=<%=num %><br>
 
 
  10+15=<%=add(10,5)%><br>
 
 
language

include 外文件嵌入 解析页面

taglib指令 自定义标签 jsp启动定制的行为


默认首页



jsp基础语法:

配置JER
集成Tomcat服务器

MyEclipse：

contentType="text/html;
charset=UTF-8"



jsp生命周期

jspService（）方法调用
servlet始终驻留与内存


jsp
<%
date d=new date();
SimpleDateFormat sdf=new SimpleDateFromat("yyyy年MM月dd日")

String s=sdf.format(d);
%>

 今天的时间<%=s%>

游戏引擎api

方法的声明
方法的参数
方法的返回值
方法的调用
方法:
把复用的业务代码抽取出来，形成独立的调用单元
实现比较复杂的逻辑
对具体实现进行隐藏/封装，只需调用关注结果，而不用关注其具体实现
语法：

[访问修饰符] 返回值类型 方法名([形式参数列表]){
    程序代码;
    [return 返回值;]
}
示例：
public void getAge() {
}
方法声明—注意事项:
访问修饰符：表示方法的访问权限，可以省略，建议写上
返回值类型：空返回为void，此时方法体中不需要return语句。若返回其他类型的值，则必须有返回对应类型值的return语句，且return有终止方法的作用，必须位于最后。


方法声明—注意事项:

形式参数(形参)：方法声明时规定的参数类型,数量,顺序
实际参数(实参)：调用方法时实际传递给方法的数据
返回值：方法执行完毕后返回给调用者的数据。

方法调用:

同一个类中
方法名 (形参列表)：
// 静态只能调用静态，非静态既可以调用非静态，还可以调用静态
对象名.方法名(形参列表)：

// 静态调用非静态
注意：不同类中的情况，会在面向对象，类的概念时一起讲解。
注意
被static关键字修饰的方法为静态方法(类和对象会再次讲解)
调用方法的实参列表必须和形参列表严格对应


方法应用
:定义一个静态方法，接收两个数和算术运算符，返回运算结果

定义方法，判断某年是否是闰年，闰年规则：
能被4整除，且不能被100整除
或者能被400整除

方法的重载overload:
定义：同一个类中，方法名相同，参数列表不同

作用：在同一类中，可以产生多个同名方法，从而实现不同的操作。调用时，根据匹配的实参列表，执行相对应的方法


方法的声明
方法的参数：形参，实参
方法的返回值：void，return
方法的调用：同一个类，不同类中


 1.判断形参列表是否相同时，只看形参类型，不看变量名
  2.是否重载与返回值类型无关
  3.形参列表不同：个数不同，顺序不同
  4.多态：重载是多态中的一种情况，静态多态


标识符:

Java标识符命名规则：
由字母、数字、下划线（_）和美元符号（$ 音：dollar）组成。
不能以数字开头。
区分大小写。
不能是Java中的保留字和关键字。

标识符命名习惯：见名知意

请判断以下标识符是否合法：
HelloWord、username2、user_name、_userName、
$abc_123、public、
2UserName、user#Name、Hello  World关键字:Java中有特定含义，专门用途的字符串称为关键字（keyword），关键字全部小写
保留字：没有定义用途，但保留备用。goto、const扩展：编程命名规范:变量名、方法名：首字母小写，其余单词首字母大写
类名、项目名：首字母大写，其余单词首字母大写
包名：全部小写，用英文的.隔开
常量：全部大写，单词之间用_隔开

总体原则：驼峰式，见名知义，便于代码的统一及可读性

Java的数据类型:
数组(array)接口(interface)
类(class)
布尔型（boolean）:

boolean类型表示真假，一般用于逻辑运算、流程控制

boolean类型数据值：true或false，不可以用0、非0数字，大写代替。

示例：
  boolean  b = false;
  boolean c = true;


基本数据类型：
Java中定义了4类/8种基本数据类型
布尔型---- boolean
字符型---- char
整数型---- byte, short, int, long
浮点数型---- float, double

Java中所有的基本数据类型都有固定的存储范围和所占内存空间的大小，而不受具体操作系统的影响，以保证Java程序的可移植性。

Java浮点类型有两种表示形式
十进制形式，必须含有小数点，例如：
3.14       314.0      0.314
科学记数法形式，如：
3.14e2      3.14E2      3E2
Java浮点型默认为double型，如要声明float型，则需在数字后面加f或F，如：
  double  d = 3.14; float  f = 3.14f;

字符类型:char型数据用来表示通常意义上“字符”
char c = ‘A’;  char gender= ‘女';
Java字符采用Unicode编码，每个字符占两个字节，因而可用十六进制编码形式表示(Unicode是全球语言统一编码)
char  c1 = '\u0061';    //相当于a
char c2=97;        //ASCII码，相当于a
Java语言中还可以使用转义字符'\'来将其后的字符转变为其它含义：
char c2 = '\t';


    名称    描述
\n     换行    将光标移到下一行的第一格。
\t     水平制表     将光标移到下一个水平制表位置。
\'      单引号    产生一个单引号。
\"      双引号    产生一个双引号。
\\    斜杠    产生一个斜杠。



数据类型    大小/位    可表示的数值范围
byte(字节型)    8    -128~127
short(短整数)    16    -215 ~ 215-1
int(整数)    32    -231 ~ 231-1
long(长整数)    64    -263~ 263-1
float(单精度)    32    -3.4E38~3.4E38
double(双精度)    64    -1.7E308~1.7E308
char(字符)    16    0-65535
boolean        true/false

基本数据类型—类型转换:自动类型转换：取值范围小的自动转为取值范围大的
byte?short?int?long?float?double
char ? int?long?float?double
short,char不会互相转换
整个表达式的值不足int时，自动提升为int

强制类型转换：取值范围大的强制转为取值范围小的 如：
long l = 100L; int i = (int)l;
注意：有可能造成精度降低或数据溢出，使用时要注意

boolean 类型不能转换成任何其它基本数据类型


jsp内置对象

是web容器创建的一组对象，不使用new关键就是可以内置对象。
<%
 int[] value={60,70,80};
   for(int i:value){
    out.println(i)
   }
%>
九大内置

常使用：
    page  ：       1  作用范围仅限用户请求当前也页面 对page 对象引用通常存储在pagecontext对象中
    



    out：

   void: println() print()  打印
         claer() ：清空缓冲区的内容 如果flush之后调用抛出异常
         clearBuffer():清空缓冲区的内容 如果flush之后不会调用抛出异常
         flush()将缓冲内容输出到客户端
          getBufferSize（）：返回缓冲器以字节数大小 如不设置缓冲区为0
          getRemaining()返回缓冲区还剩下多少可用
          isAutoFlush（）返回缓冲区满时 自动清空还是抛出异常
          close（）关闭输出流




 
    request      2 请求代表用户一次请求 一个http请求的处理肯需要多个Servlet合作

      String getParameter（String name）返回name指定名称参数值   







    response
    session      3  同一浏览器对服务器多次访问 httpSession接口实现的
    application  4  服务器启动到关闭整段时间


page pageconte
exxeption config


百度网盘：  http://pan.baidu.com/share/link?shareid=427617690&uk=3979517138#list/path=%2FJava%2F%E6%AF%95%E5%90%91%E4%B8%9C-JAVA%E5%9F%BA%E7%A1%80%E5%BC%80%E5%8F%91%E8%A7%86%E9%A2%91


 java字符串大写转小写，小写转大写

String test="ABC34cccddee";
    System.out.println(test.toUpperCase());//小写转大写

 

 String test="ABC34cccddee";
    System.out.println(test.toLowerCase());小写转大写

链接：https://pan.baidu.com/s/1qY8nASO 密码：k9g2
链接：http://pan.baidu.com/s/1nvobfuD 密码：bw2l
链接：http://pan.baidu.com/s/1slHFasl 密码：n11d
链接：http://pan.baidu.com/s/1nvJOR2p 密码：0myz


2、 分配空间

简单地说，就是指定数组中最多可存储多少个元素

语法：  数组名 = new  数据类型 [ 数组长度 ];

其中，数组长度就是数组中能存放元素的个数，如：

话说，我们也可以将上面的两个步骤合并，在声明数组的同时为它分配空间，如：

3、 赋值

分配空间后就可以向数组中放数据了，数组中元素都是通过下标来访问的，例如向 scores 数组中存放学生成绩

4、 处理数组中数据

我们可以对赋值后的数组进行操作和处理，如获取并输出数组中元素的值

在 Java 中还提供了另外一种直接创建数组的方式，它将声明数组、分配空间和赋值合并完成，如

它等价于：




JSP Java Server Pages
是为了简化动态网页开发而发明的技术
运行时会被编译成Java代码
实际上JSP与后面要学习的Sevlet关系密切
JSP是非常古老的技术，和大家年龄差不多
JSP可以大大地帮我们偷懒<%@ page … %>
page指令：为JSP的编译提供一些信息

application对象
字面意思应用程序
可以提供整个应用程序的信息
out对象
字面意思是输出
可以向页面上输出文字等信息。

常说JSP有9大内置对象，我们后面会详细介绍
Object count = application.getAttribute("index-count");

Object   类型名
Java是强类型语言
Java中的数据是有类型的
Object是Java中最基本的类型
count    变量名
变量是一个符号，代表一个数据，本例中是访问次数
count的类型是Object
=    赋值
把右边的值赋给左边的变量
application.getAttribute(“index-count”);
application是内置对象
.getAttribute()调用内置对象的getAttribute方法，从应用对象中获取数据
“index-count”是调用函数的参数，指明要获取哪个数据，“”表示字符串类型
Java中有很多类型，整数如3，小数如3.14，表示真假的布尔类型如true
Java的代码需要英文分号;结尾
生活中有很多事情需要抉择，写代码也一样
if/else，基本分支判断



if () 括号中的值是true时执行if花括号中的代码
false时执行else花括号中的代码
>     大于          表达式 1 > 2 的值是 false
<     小于          表达式 1 < 2 的值是 true
==   等于          表达式 1 == 2 的值是 false
!=    不等于     表达式 1 != 2 的值是 true

null 表示没有任何值，是Java中特殊的值
count != null 用于判断count又没有有效值
out.println(value)
将value输出到页面上，后面还带换行
转换成整数
强类型语言需要转换成相应类型才能使用（相加）
将变量c自己加1


存储在应用程序对象中

带参数方法的返回值可以为 void
同一个类中,方法名相同,方法参数个数,顺序,类型
不同的方法称为方法的重载,
与方法的修饰符或返回值没有关系.


配置文件
<Welcome-file-list>
  <Wlecome-file>/index.jsp</Wlcome-file>配置首页
</Welcome-file-list>


改端口
conf/server.xml
< Connector port="8080"
  protocol="HTTP/1.1"
  connectionTimeout="20000"
  redirectPort="8443"
/>

默认继承 Object 的 toString( ) 方法，输出对象地址



private

setter
getter


com.imooc.music.MyClassMuisc

com.imooc.movie.MyClassMuisc


import com.imooc.movie.MyClassMuisc
包是小写的

继承

private不行


class子类extends父类

class Dog extends Ainmal
{


}

final  最终得含义
可以修饰类 方法  属性  变量
修饰的类 该类不允许被继承

修饰方法 不允许被覆盖

选其一

只能赋一次值

super
对象的内部使用  代表父类的对象

访问父类的属性
super.age
访问父类的方法
super.eat();

Object  tostring()方法

哈希code码对象的地址字符串
重写tostring

equals（）方法
比较的是对象的（引用）是否指向同一块内存地址

接口中方法不能有方法体，同时方法的访问修饰符不能是 private 和 protected

abstract关键字修饰 则该类为抽象类

abstract定义抽象类

接口 可以为一种特殊的类，有局部常量和公共的抽象方法所组成的
不关心类的内部数据
interface关键字

继承  用public  abstract  可以多继承很多父类


public static final修饰符  系统自动加上


impieme关键字

【修饰符】class类名 extends父类 implements接口1 接口2{


}
如果继承父类 继承父类必须在实现接口之前

接口在使用的过程当中 经常与匿名内部类配合使用
匿名内部类就是没有名字的内部类
多用于关注而不关注实现类的名称


Interface i=new Interface(){
   public void method(){
    System.out.println("匿名内部类实现接口的方法");
};






uml
统一建模语言
14用例图
uml工具
Visio Rational Rose PowerDesign


异常处理
throwable

error 终结者
Exception 异常   编码  

RuntimeException ：
空指针异常
数组下标越界异常
类型转换异常
算数异常

检查异常


try-catch以及try-catch-finally

try{
    //一些抛出异常方法
}catch（Exception e）{
//处理该异常的代码块

}

子到父异常处理







在需要频繁对字符串进行修改操作时使用 StringBuilder 的效率比 String 要高

jsp jcp  面向对象opp与c++相同
   
基本类型是不能调用方法的，而其包装类具有很多方法

集合框架 一种工具类   类的内部 对数据进行组织
简单而有效的搜索大量的条数
有的集合接口 提供一系列的排序的元素 并且可以在序列中快速插入和删除
有集合接口 提供了映射关系  可以通过关键字Key快速查找对应的唯一性对象 而且对于关键字可以是任意的类型

数组的长度固定  集合长度可变
数组只能通过下标访问元素 类型固定，而有的集合可以通过任意的类型查找所在的具体的对象

集合框架  collection：list：arraylist queue：linkedlist set：hashset
 Map：hashMap key value entry键值对

collection接口：list set queue接口与父接口
定义可用于操作list set queue的方法--增删改查

list的接口  -----arraylist接口：数组序列  


get post
<form name="regForm"action="动作" method="提交方式">
</form>
使用request对象的getParameterValues（）方法实现复选框信息获取
请求重定向是客户器端行为而请求转发是服务器端行为

http://spring.io/
http://projects.spring.io/spring-framework/
什么是软件框架
为什么使用框架
易于上手

IOC及Bean容器
java8接口可以方法体
java接口及声明，声明一些方法对外公开的提供
结构设计  调用外层提供一组功能接口

IOC控制反转  控制权的转移，应用程序本身不负责依赖对象的创建和维护，而是由外部容器负责创建和维护

DI（依赖注入）是一种实现的方式Dependency


目的：创建对象并且组装之间的关系
接口： 是用于隐藏具体的实现和实现多台性的组件


IOC房屋中介

找IOC容器
容器返回对象
使用对象
iterator<E>iterator返回在此collection的元素进行迭代


泛型  ：规定某一个集合只存放特定的类型的对象
编译期间检查  
泛型子类型

set接口 ：元素无序并且不可以重复的集合  被称为集

 hashset：set的一个重要实现

OC是什么?ios  编码

会话保存在服务器的内存里
session的生命周期

当客户端第一次访问jsp或者Servlet时候，服务器为当前创建一个SeesionID，每一次客户端向服务器发送请求  都会SessionID带  服务器会对SeesionID进行校验

旧的在服务器  除非超时 销毁
<session-config>
<session-timeout>
10
</session-timeout>
</session-config>//单位分钟

除非本次会话的所有页面都关闭后再重新访问某个JSP或者Servlet将会创建新的会话

application对象

实现了用户数据的共享，可放全局变量
开始服务器的启动，终止于服务器的关闭
在任何地方对application对象属性的操作 都将影响到其他用户的访问
服务器的启动和关闭决定了application对象的生命
application对象ServletContext类的实例
setAttribute方法参数第一个为字符串，第二个参数为需要保存的对象
page对象  类似this指针  java.lang.Object类


数据库

字符集GBK

系统的架构MVC
视图层----jsp页面
控制层------Servlet
模型层------------------javaBean设计--数据bean--处理bean 数据库设计

界面设计index.jsp
管理员首页admin_index.jsp




封装是把过程和数据包围起来，对数据的访问只能通过已定义的接口。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。封装是一种信息隐藏技术，在java中通过关键字private，protected和public实现封装。什么是封装？封装把对象的所有组成部分组合在一起，封装定义程序如何引用对象的数据，封装实际上使用方法将类的数据隐藏起来，控制用户对类的修改和访问数据的程度。 适当的封装可以让程式码更容易理解和维护，也加强了程式码的安全性。
例子
编辑

　　封装的简单例子：
先来个例子看看；
public class Man
{
//对属性的封装，一个人的姓名，年龄，妻子都是这个对象（人）的私有属性
private String name;
private int age;
private Woman wife;
//对该人对外界提供方法的封装，可以设定妻子，姓名，年龄也可以获得男人的姓名和年龄
　　// 方法封装
　　public void setWife(Woman wife) {
　　this.wife = wife;
　　}
　　public String getName() {
　　return name;
　　}
　　public void setName(String name) {
　　this.name = name;
　　}
　　public int getAge() {
　　return age;
　　}
　　public void setAge(int age) {
　　this.age = age;
　　}
　　}
　　public class Woman {
　　// 属性封装
　　private String name;
　　private int age;
　　private Man husband;
　　// 方法封装
　　public String getName() {
　　return name;
　　}
　　public void setName(String name) {
　　this.name = name;
　　}
　　public int getAge() {
　　return age;
　　}
　　public void setAge(int age) {
　　this.age = age;
　　}
　　public Man getHusband() {
　　return husband;
　　}
　　public void setHusband(Man husband) {
　　this.husband = husband;
　　}
　　}
/**
* 仔细看就会发现，Man类没有提供getWife的方法，这是因为男人不想让自己的妻子被外界访问，
*
* 接下来呢，就是封装可以把一个对象的属性私有，而提供一些可以被外界访问的属性的方法，
*
* 比如说，name属性，Man和Woman类都有相应的get和set方法，外界都可以通过这些方法访问和修改
*
* 同时对一些对象不想让外界访问的属性，就不提供其方法，比如说Man的wife属性，就没有get方法
*
* 外界是不能得到Man类的wife属性的
*
*/
上面那例子可能没有突出封装的好处，下面来个超简单的表达下：
public class Show
{
public static void show(String str)
{
System.out.println(str);
}
}
上面就是对 System.out.println();的封装。
调用的时候 ：
public class Use
{
public static void main(String[] args)
{
Show.show("封装")；
}
}
这样用的时候就不用使：System.out.println("封装")；



equals(Object obj)

http://developer.amap.com/




tomcat容器
servlet的容器context容器  一个context对应web工程
servlet

继承httpservlet
重写doGet（）或者dopost（）方法

在web.xml中注册servlet


编写servlet
src new Servlet
重写doGet（）或者doPost（）
部署运行


localhost是服务器主机名，也可以是IP地址127.0.0.1；8080是tomcat服务器的端口号；helloapp是web工程的上下文地址ContexRoot（一般情况下与web工程名一致）；最后是<url-pattern/>标签中的内容。



get方式请求helloServlet -----<a href="Servlet/helloServlet">


生命周期
开始  servlet实例是否存在--->   装载Servlet类创建实例

调用init（Servlet）方法---->Servlet(Servlet Request Servlet Response)方法


服务器关闭
调用Destroy方法

编写Servlet的doPost方法时，需要抛出ServletExcpetion和IOException异常。


servlet容器启动自动 只需要在web.xml添加

<lodon-startup>1</lodon-startup>
数字越小优先级越高
init（）方法只能被调用一次

不同的字符串转换用SimpleDateFormate转换
不覆盖service()方法，不是因为该方法是空，而是因为sevrvice( )方法会调用doPost或者doGet方法


相对路径 相对于当前资源的路径
绝对路径  放之四海而皆准的路径
请求重定向的方式跳转test.jsp相当于ServletpatthDirection/servlet
respone.sendRedirect(request.getcontextPath（)+"text.jsp")
服务器内部跳转
request.getRequestDispatch（"/text.jsp"）.forward
(requset,responet)

Servlet的初始化参数是从ServletConfig中获得的。

运行：services.msc，打开服务管理器，找到“VisualSVNServer”。

2 在服务上，点击右键--属性，打开“登录”选项卡。将“此帐户”改成“本地系统帐户”。再回到安装程序弹出窗口处，选择"Retry"即可。

很多方法都尝试了不行，准备放弃的时候，不选择本地账户，选择此账户用administrator 管理员密码，结果retry成功



Java-Reflect专题

class类的使用
方法的反射
成员变量的反射
构造函数的反射
java类加载机制


class.forName("类的全称")
不仅表示了类的类类型 还代表的动态加载类
编译  运行

编译时刻加载类是静态加载类   运行时刻加载类是动态加载类
//软件动态升级
class Office{
 public static void main（String[] args）{
//new创建对象 是静态加载类 在编译的时刻就需要加载所有的可能使用到的类
//通过动态加载类可以解决该问题
   if("Word".equal（args[0]）){
    Word w=new Word();
    w.start();

}
if("Excel".equal（args[0]）){
    Excel e=new Excel();
    e.start();

}

}
class OfficeBetter{

  public static void main(String[] args){

   try{

   //动态加载类，在运行时刻加载
    class c= calss.forNmae(args[0])
  //通过类类型 创建该类的对象
   OfficeAble oa=(OfficeAble)c.newInstance();
   oa.start();
   
  }
  catch(Exception e){
    e.printStackTrace();
   }

}
 
}
//创建一个标准
interface OfficeAble{
  public void start();



}


//Word
class Word implements OfficeAble{
  public void start()
  {

   System.out.println（"word...start...."）
   }

}




Class c1=int.Class；
System.out.println（c1.getName（））
    打印int类型
class c2=String.class；
System.out.println（c1.getSimpleName（））
   不包含包名的类的名称
基本的数据类型
void关键字 都存在类类型

class api
package com.imooc.reffert;

public class ClassDem3 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String s="hello";
        ClassUtil.printClassMessage(s);
    }

}
package com.imooc.reffert;

import java.lang.reflect.Method;


public class ClassUtil {
//   打印类的信息 包括类的成员函数 成员变量
    public static void printClassMessage(Object obj) {
        // TODO Auto-generated method stub
    
        
        //获取类的信息 首先获取类的类类型
        Class c=obj.getClass();//传递的那一个子类的对象 c就是该子类的类类型
        //获取类名称
        System.out.println("类的名称："+c.getName());
        
        //Method类，方法的对象  一个成员方法就是一个Method对象
        
        //getMethods()方法获取所有public函数 包括父类继承而来的
        Method[] methods=c.getMethods();// c.getDeclaredMethod()
        //c.getDeclaredMethod();getDeclaredMethod()h获取所有类的自己的声明的方法 不访问权限
        for (int i = 0; i < methods.length; i++) {
            //得到方法返回值类型的类类型
            Class returnType=methods[i].getReturnType();
            System.out.print(returnType.getName()+"(");
            
            
            //方法的名称
            
            System.out.print(methods[i].getName());
            //获取参数类型
            Class[] paramTypes=methods[i].getParameterTypes();
            for (Class class1 : paramTypes) {
                System.out.print(class1.getName()+",");
            }
        System.out.println(")");
        }

    }

}
类的名称：java.lang.String
boolean(equalsjava.lang.Object,)
java.lang.String(toString)
int(hashCode)
int(compareTojava.lang.String,)
int(compareTojava.lang.Object,)
int(indexOfjava.lang.String,int,)
int(indexOfjava.lang.String,)
int(indexOfint,int,)
int(indexOfint,)
java.lang.String(valueOfint,)
java.lang.String(valueOflong,)
java.lang.String(valueOffloat,)
java.lang.String(valueOfboolean,)
java.lang.String(valueOf[C,)
java.lang.String(valueOf[C,int,int,)
java.lang.String(valueOfjava.lang.Object,)
java.lang.String(valueOfchar,)
java.lang.String(valueOfdouble,)
char(charAtint,)
int(codePointAtint,)
int(codePointBeforeint,)
int(codePointCountint,int,)
int(compareToIgnoreCasejava.lang.String,)
java.lang.String(concatjava.lang.String,)
boolean(containsjava.lang.CharSequence,)
boolean(contentEqualsjava.lang.CharSequence,)
boolean(contentEqualsjava.lang.StringBuffer,)
java.lang.String(copyValueOf[C,)
java.lang.String(copyValueOf[C,int,int,)
boolean(endsWithjava.lang.String,)
boolean(equalsIgnoreCasejava.lang.String,)
java.lang.String(formatjava.util.Locale,java.lang.String,[Ljava.lang.Object;,)
java.lang.String(formatjava.lang.String,[Ljava.lang.Object;,)
void(getBytesint,int,[B,int,)
[B(getBytesjava.nio.charset.Charset,)
[B(getBytesjava.lang.String,)
[B(getBytes)
void(getCharsint,int,[C,int,)
java.lang.String(intern)
boolean(isEmpty)
java.lang.String(joinjava.lang.CharSequence,[Ljava.lang.CharSequence;,)
java.lang.String(joinjava.lang.CharSequence,java.lang.Iterable,)
int(lastIndexOfint,)
int(lastIndexOfjava.lang.String,)
int(lastIndexOfjava.lang.String,int,)
int(lastIndexOfint,int,)
int(length)
boolean(matchesjava.lang.String,)
int(offsetByCodePointsint,int,)
boolean(regionMatchesint,java.lang.String,int,int,)
boolean(regionMatchesboolean,int,java.lang.String,int,int,)
java.lang.String(replacechar,char,)
java.lang.String(replacejava.lang.CharSequence,java.lang.CharSequence,)
java.lang.String(replaceAlljava.lang.String,java.lang.String,)
java.lang.String(replaceFirstjava.lang.String,java.lang.String,)
[Ljava.lang.String;(splitjava.lang.String,)
[Ljava.lang.String;(splitjava.lang.String,int,)
boolean(startsWithjava.lang.String,int,)
boolean(startsWithjava.lang.String,)
java.lang.CharSequence(subSequenceint,int,)
java.lang.String(substringint,)
java.lang.String(substringint,int,)
[C(toCharArray)
java.lang.String(toLowerCasejava.util.Locale,)
java.lang.String(toLowerCase)
java.lang.String(toUpperCase)
java.lang.String(toUpperCasejava.util.Locale,)
java.lang.String(trim)
void(wait)
void(waitlong,int,)
void(waitlong,)
java.lang.Class(getClass)
void(notify)
void(notifyAll)
java.util.stream.IntStream(chars)
java.util.stream.IntStream(codePoints)


 
        /*成员变量也是对象
        java.lang.reflect.Field
        Field类封装了关于成员变量操作
        getField（）方法获取的是所有public成员变量的信息*/
       // Field[] fsFields=c.getFields();
        //getDeclaredFields()获取的是该类型自己的声明的成员变量的信息
        
        Field[] fields=c.getDeclaredFields();
        
        for (Field field : fields) {
            //的到成员变量类型的类类型
            Class fieldType=field.getType();
            
            String typeName=field.getName();
            //的到成员变量的名称
            String filedName=field.getName();
            System.out.println(typeName+""+typeName);
            
            
        }
        










package com.imooc.reffert;

public class ClassDemo5 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
    
        
        ClassUtil.printConMessage("hello");
        ClassUtil.printConMessage(new Integer(1));
        
        
    }

}
package com.imooc.reffert;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

import javax.security.auth.callback.LanguageCallback;


public class ClassUtil {
    
    
//   打印类的信息 包括类的成员函数 成员变量
    public static void printClassMessage(Object obj) {
        // TODO Auto-generated method stub
    
        
        //获取类的信息 首先获取类的类类型
        Class c=obj.getClass();//传递的那一个子类的对象 c就是该子类的类类型
        //获取类名称
        System.out.println("类的名称："+c.getName());
        
        //Method类，方法的对象  一个成员方法就是一个Method对象
        
        //getMethods()方法获取所有public函数 包括父类继承而来的
        Method[] methods=c.getMethods();// c.getDeclaredMethod()
        //c.getDeclaredMethod();getDeclaredMethod()h获取所有类的自己的声明的方法 不访问权限
        for (int i = 0; i < methods.length; i++) {
            //得到方法返回值类型的类类型
            Class returnType=methods[i].getReturnType();
            System.out.print(returnType.getName()+"(");
            
            
            //方法的名称
            
            System.out.print(methods[i].getName());
            //获取参数类型
            Class[] paramTypes=methods[i].getParameterTypes();
            for (Class class1 : paramTypes) {
                System.out.print(class1.getName()+",");
            }
        System.out.println(")");
        //pringFieldMessage(c);

        }

    }
    // 成员变量
    //private static void pringFieldMessage(Class c) {
    public static void pringFieldMessage(Object object) {
        
        Class c=object.getClass();
        /*成员变量也是对象
        java.lang.reflect.Field
        Field类封装了关于成员变量操作
        getField（）方法获取的是所有public成员变量的信息*/
       // Field[] fsFields=c.getFields();
        //getDeclaredFields()获取的是该类型自己的声明的成员变量的信息
        
        Field[] fields=c.getDeclaredFields();
        
        for (Field field : fields) {
            //的到成员变量类型的类类型
            Class fieldType=field.getType();
            
            String typeName=field.getName();
            //的到成员变量的名称
            String filedName=field.getName();
            System.out.println(typeName+""+typeName);
            
            
        }
    }
//     打印构造函数的信息
    public static void printConMessage(Object obj){
        
        Class c=obj.getClass();
        
        
//        构造函数也是对象
//        java.lang.Constructor封装了构造信息
        //getConstructors()获取public的构造函数
        //getDeclaredConstructors得到所有的构造函数
        //Constructor[] cs=c.getConstructors();
        Constructor[] cs=c.getDeclaredConstructors();
        
        for (Constructor constructor : cs) {
            System.out.print(constructor.getName()+"(");
           //获取构造函数参数列表--》得到参数列表的类类型
            Class[] paramTypes=constructor.getParameterTypes();
            for (Class class1 : paramTypes) {
                System.out.print(class1.getName()+",");
            }
            
            System.out.println(")");
            
            
            
        
        }
        
    }
    

}
java.lang.String([B,int,int,)
java.lang.String([B,java.nio.charset.Charset,)
java.lang.String([B,java.lang.String,)
java.lang.String([B,int,int,java.nio.charset.Charset,)
java.lang.String([B,int,int,java.lang.String,)
java.lang.String([C,boolean,)
java.lang.String(java.lang.StringBuilder,)
java.lang.String(java.lang.StringBuffer,)
java.lang.String([B,)
java.lang.String([I,int,int,)
java.lang.String()
java.lang.String([C,)
java.lang.String(java.lang.String,)
java.lang.String([C,int,int,)
java.lang.String([B,int,)
java.lang.String([B,int,int,int,)
java.lang.Integer(int,)
java.lang.Integer(java.lang.String,)


方法的反射
获取方法
方法的名称和方法的参数列表才能唯一决定某一个方法
方法的反射操作
method.invoke（对象，参数列表）
package com.imooc.reffert;

import java.lang.reflect.Method;

public class Methoddemo1 {

    private static Method m2;

    public static void main(String[] args) {
        // TODO Auto-generated method stub
     //要获取print（int ，int）方法
    //要获取一个方法就是获取类的信息  获取类的信息首先要获取类的类型
       A a1=new A();
       Class c=a1.getClass();
       //getMethod获取的public的方法
       //获取方法    必须要有名称与参数列表来决定
       //c.getMethod(name, parameterTypes)
       //getDeclaredMethod自己声明的方法
         //c.getDeclaredMethod(name, parameterTypes);
    
     /* try {
        
          //Method m=c.getMethod("print", new Class[]{int.class,int.class});
    } catch (NoSuchMethodException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (SecurityException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    }*/
       try {
           Method m=c.getMethod("print", int.class,int.class);
           //方法反射操作
           //方法的反射操作是用m对象来进行方法调用和a1.print调用效果完全相同
           
           //方法如果没有返回值null 有返回值具体的返回值
           
           Object o=m.invoke(a1,10,20);
           //Object o=m.invoke(a1,new Object[]{10,20});
           //a1.print(10, 20);
           
           System.out.println("================");
            //获取print(String,String)
            Method m1=c.getMethod("print", String.class,String.class);
         //用方法进行反射操作
            //a1.print("hello", "world");
            o=m1.invoke(a1, "hello","WORLD");
            System.out.println("================");
             //Method m2=c.getMethod("print", new Class[]{});
              
           
             Method m2=c.getMethod("print");
           //m2.invoke(a1, new Object[]{});
           m2.invoke(a1);
       } catch (Exception e) {
        // TODO: handle exception
           
           e.printStackTrace();
     }
      

   }

}

class A{
    public void print(){
        System.out.println("helloworld");
    }
    public void print(int a,int b){
        System.out.println(a+b);
        
    }
    public void print(String a,String b){
        System.out.println(a.toUpperCase()+","+b.toUpperCase());
        
    }
  }

30
================
HELLO,WORLD
================
helloworld



通过Class Method认识泛型的本质

package com.imooc.reffert;

import java.lang.reflect.Method;
import java.util.ArrayList;

public class MethodDemo4 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ArrayList list=new ArrayList();
        ArrayList<String>list1=new ArrayList<String>();
        list.add("hello")    ;
      //list1.add("hello")    
        Class class1=list.getClass();
        Class class2=list1.getClass();
        System.out.println(class1==class2);
        //反射的操作都是编译之后的操作
        
        //c1==c2结果返回true说明编译之后集合的泛型是去泛型化的
        //java中集合的泛型，是防止错误输入的 值在编译阶段有效
        //绕过编译就失效了
        //验证  我们可以通过方法的反射来操作，绕过编译
        try {
            
            
            Method m=class1.getMethod("add", Object.class);
            m.invoke(list1, 20);//绕过编译操作就绕过泛型
        
            System.out.println(list1.size());
            System.out.println(list1);
          /*  for (String string : list1) {
                System.out.println(string);
            }*/
            //现在不能这样遍历 类型不对
            
            
            
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();        
        
        }
        
    }

}
true
1
[20]



File类的使用
RandomAccessFile的使用
字节流的使用
字符流的使用
对象的序列化和反序列化

java.io.File类的文件项目
file类的表示（目录）的信息（名称 大小）不能用于文件内容的访问

IO流（输入流  输出流）
字节流 字符流
1>InputStream OutputStream
InputStream抽象了应用程序读取数据的方式
OutputStream抽象了应用程序写的数据的方式
2>
EOF=End 读到-1就读到结尾
3>输入流基本方法
int b=in.read（）;读取一个字节无符号填充到int低八位 -1是EOF
in.read（byte[] buf）读取的数据填充到字节数组buf
in.read（byte[] buf,int start ,int size）读取数据到字节数组buf从buf的start位置开始存放size的长度的数据
4>输入流基本方法
out.write（int b）写出一个byte到流 b的低八位
out.write（byte[] buf）将buf字节数组都写到流
out.write（byte[] buf，int start ，int size）
5>
  FileInputStream-->具体实现了





                    

float f_val=45.0f或者float f_val=45.0F

需求
分析需求  拆解需求
实现功能代码
分发各个模块功能

请求响应
客户端与浏览器交互
html缓存代码
JPA是什么？？
java虚拟机？？？
minfest-Version  版本1.0
Class-path：class路径  打jar包  引用jar包
js--->静态页面动起来
jquery--->代码少 类库 库
web App library 放入jar包
ftr 视图文件  放在WEB-INF
lib 放入jar包
Build Path
orader and Export导出


我们在卸载MySQL的时候，会发现有一个名为“Connector Net X.X.X”（如：Connector Net 6.9.3）软件总是卸载不成功，下面我们来看看解决方法：

1. 在C盘的目录下，有一个隐藏文件——ProgramData，进入C:\ProgramData\MySQL\，删除里面所有文件及文件夹；

2. 进入注册表（win7：开始-运行-regedit；win8:Ctrl+R，输入regedit）；

3. Ctrl+F，输入Connector Net X.X.X（根据自己的版本来），查找相关文件，并删除，循环此步骤，直到注册表中再也查不到Connector Net X.X.X;

到此为止，Connector Net X.X.X成功卸载。


web.xml
javascirpt

                20170418课堂笔记知识点
web页面
    html技术
        HyperText Markup Language，超级文本标记语言。
        “超文本”就是指页面内可以包含图片、链接，甚至音乐、程序等非文字元素。
        超文本标记语言的结构包括“头”部分（英语：Head）、和“主体”部分（英语：Body），其中“头”部提供关于网页的信息，“主体”部分提供网页的具体内容。
                
    CSS技术
        Cascading Style Sheets，层叠样式表。
        是用来表现HTML等文件样式的计算机语言。
    JavaScript技术
        缩写JS，脚本语言。
    Java技术
        功能强大，应用范围广。
        
作业：
    安装火狐浏览器
    改动视图：Windows——》Show View
-------------------------------------
Debug  调试    
Eclipse 快捷键"Alt+/"

.sh后缀是liunx




javabean
就是符合特定的规范的java类 使用javabean的好处是解决代数的重复编写 减少代码的冗余。功能区的分明  提供代码的维护性
javabean的设计原则  公有类  无参的公有构造方法
属性私有
getter和setter方法封装

public class Student{
  private String age；
  private int age；
  public Students（）{}
  public void setName（String name）{this.name=name；}
  public String getName（）{return this.name；}
  public void setAge（int age）{this.age=age}
  public int getAge（）{return this.age；}
}

jsp动作
jsp动作元素  动作元素为请求处理的阶段提供信息  动作元素遵循xml元素的语法 有一个包含元素名的开始标签  可以有属性  可选的内容  与开始标签匹配的结束标签

jsp中如何使用javabean

1.使用普通的Java类一样  创建Javabean实例
2.在jsp页面中通常使用jsp动作标签使用javabean
<jsp:useBean id="" class="java类名" scope="作用范围"/>
<jsp：userBeans>
<jsp:getProperty>
<jsp:setProperty>
javabean的四个作用域范围
Model简介

注解
框架相关代码
代码
spring Mybatis
自定义注解
jdk自带注解

@Override @Deprecated @suppvisewarnings
第三方注解
Spring ：
@Autowired：
@Service ：
@Repository：
Mybatis：
@InsertProvider：
@UpdateProvider：
@Options：
@inherted允许子类继承
@Documented   生成javadoc时会包含注解
@interface  注解
成员类型受限制  合法的类型包括原始类型的及String Class Annotation Enumeration

如果注解只有一个成员  则成员必须取名为Vvalue（）  在使用可以忽略成员名与赋值好（=）
没有成员  元注解


注解分类

源码注解  
编译注解.class文件中
运行注解
元注解
自定义注解
语法
@<注解名>（<成员名1>=<成员值1>,<成员名1>=<成员值1>）
持久层架构  用来替代HIbernate

注解的作用范围  @Target和生命周期@Retention
包 类 字段 方法 方的参数 局部变量






 
1．未部署Web应用
 
2．URL输入错误
      a.查看URL的IP地址和端口号是否书写正确。
      b.查看上下文路径是否正确 Project--------Properties------MyElipse-----Web----- Web Context-root检查这个路径名称是否书写正确。
      c.检查一下文件名称是否书写正确。
 
3．目录不能被引用
      在 Eclipse的“包资源管理器(Package Explorer)”检查文件存放的位置。由于META-INF WEB-INF文件夹下的内容无法对外发布，所以，如果你引用了带这两个目录的文件，肯定是不允许。
      例如： http://localhost:8080/guestbook/WEB-INF/index.html就是错误的,文件位置存放错误

4． Tomcat服务器中web.xml中的问题
      如果你的web应用程序有多个jsp页面的话，当你点击你web应用程序的虚拟根目录时可能会出现404错 误，只是你只需要修改Tomcat服务器中web.xml       
      <init-param>
            <param-name>listings</param-name>
            <param-value>false(将其该为true)</param-value>
      </init-param>

5．WEB-INF下面必须要有几个固定的文件夹和文件          
      web.xml 该web app的配置文件
      lib 该web app用到的库文件
      classes存放编译好的servlet

      请注意他们的名字，我曾经就由于把classes写成class，查错查了半宿还没解决，所以写这些的时候千万要仔细，否则浪费更多的精力去查错。

6． 如果要运行的不是.jsp文件，而是servlet（.class）文件，要配置web.xml(当然是WEB-INF下面的)，加上以下字段：   
      <servlet>
        <servlet-name>HelloWorldServlet</servlet-name>
        <servlet-class>HelloWorldServlet</servlet-class>
       </servlet>
      <servlet-mapping>
        <servlet-name>HelloWorldServlet</servlet-name>
      <url-pattern>/HelloWorldServlet</url-pattern>
      </servlet-mapping>

 其中的“HelloWorldServlet”改为你要运行的文件名
 
7．其他解决思路
     以上方法无果,介于"HTTP Status 404(The requested resource is not available"异常发生情况的多样性,采用替换大法:
    步骤:
    a.找一份正常的相同环境(找同学同事相同开发环境机子或者网上下载的正常demo等)
    b.依次替换问题项目文件,进行排除,定位.直到解决.
servlet

一、表单提交时出现乱码：
在进行表单提交的时候，经常提交一些中文，自然就避免不了出现中文乱码的情况，对于表单来说有两种提交方式：get和post提交方式。所以请求的时候便有get请求和post请求。以前我一直以为get请求和post请求方式出现的乱码的解决方式是一样的，但是今天才知道两种请求方式所产生的乱码的解决方式是不同的。每种方式都有着不同的解决方法，之所以出现乱码，原因就在于get请求时，其传递给服务器的数据是附加在URL地址之后的；而post的请求时，其传递给服务器的数据是作为请求体的一部分传递给服务器。这也就导致了对它们所产生的乱码的处理方式是不同的。
1、客户端的get请求
对于不同的请求方式，解决乱码的问题也是不一样的，对于客户端的get请求来说，服务器端处理要想不出现乱码，解决这个问题稍微复杂一些，需要用到String类型的构造函数，其中的一个构造函数就是用指定的编码方式去解码，一般都用“UTF-8”的方式。只要在服务器端将请求得到的参数重新构造成一个字符串就行了。如下所示：
String  stuname = request.getParameter("stuname");
String str = new String(stuname.getBytes("ISO-8859-1"),"utf-8")
经过构造之后，客户端输入中文，且表单时get请求的情况下，str就变成了中文了。如果请求参数比较多，最好将它封装成一个工具类：
public class MyUtil
{
    public static String getNewString(String str) throws UnsupportedEncodingException
    {
       return new String(str.getBytes("ISO-8859-1"),"UTF-8");
    }
}
String stuname= MyUtil.getNewString(request.getParameter("stuname"));
2、客户端的post请求
对于客户端的post请求来说，处理乱码的问题就比较简单了，因为请求的数据时作为请求体的一部分传递给服务器的，所以只要修改请求内的编码就行了。只要在服务器端的最开始处将请求的数据设置为“UTF-8”就行了，输入如下语句：
request. setCharacterEncoding(“UTF-8”);
这样用户在服务器端获取到的中文数据就不再是乱码了。
二、超链接时出现乱码（低版本浏览器不行IE6）
在Web开发中，挺多的时候都是通过超链接去传递中文参数的，这也会导致在显示的时候也会出现乱码，对于超链接来说，它实际上是向服务器端发送了一个请求，而它发出的请求是属于get请求，所以对于超链接的乱码来说，它处理乱码的方式和表单的get请求出现乱码的方式是一样的。
String stuname= MyUtil.getNewString(request.getParameter("stuname"));
三、重定向时出现乱码（低版本浏览器不行IE6）
有时写上response的sendRedirect()方法进行重定向时也会出现乱码，重定向时实际上也是向服务器发送了一个请求，所以解决乱码的方法和和上面是一样的。
四、浏览器版本低导致的乱码
上网的时候，有时提交的一些信息在地址栏显示的是“%2C%C6%CC%C6”的字样，其实这都是防止出现乱码进行的解决方案，如果你的浏览器是IE6或以下版本，则我们的第二种情况和第三种情况会出现乱码(尤其是当中文是奇数的时候)，这就不好使了所以我们必须采用另一种比较实际的作法：
在Java.NET包中提供了URLEncoder类和URLDcoder类，这两个类又分别提供了encode和decode两个静态方法，分别用于进行编码和解码。我们将要传递的中文参数进行编码之后，在传递给服务器，服务器解码之后，就可以显示中文了。
进行编码：URLEncoder.encode(stuname,”UTF-8”)
传递给服务器：<a href=”/1.jsp?stuname<%=stuname%>”>传递</a>
进行解码：URLDecoder.decode(stuname,”UTF-8”);
这样就可以得到传递过来的中文参数了，我发现许多网站用的都是这种方式解决中参数的。
五、返回浏览器显示的乱码
在Servlet编程中，经常需要通过response对象将一些信息返回给浏览器，给我们的客户端，而我们在服务器端显示的中文，但是响应给客户端浏览器却是乱码，这主要是由于response对象的getWriter()方法返回的PrintWriter对象默认使用“ISO-8859-1”字符集编码进行Unicode字符串到字节数组的转换，由于ISO8859-1字符集中根本就没有包含中文字符，所以Java在进行转换的时候会将无效的字符编码输出给客户端，于是便出现了乱码，为此ServletResponse接口中便定义了setCharacterEncoding、setContentType等方法来指定getWriter方法返回的PrintWriter对象所使用的字符集编码，所以我们在写Servlet程序中，在调用getWriter方法之前设置这些方法的值。我们为了防止乱码，经常将以下两条语句一起写上：
response.setContentType(“text/html;charset=utf-8”);
response. setCharacterEncoding(“UTF-8”);
只要编写Servlet文件中含有响应给客户端的信息，那么就要写上这两句话。最好写上第二句话，因为它的优先级高，它的设置结果将覆盖setContentType等方法设置的字符编码集。
六、修改Tomcat的编码
在上述的get请求所导致乱码问题中，还有一种解决的方案，我们常用Tomcat作为运行Servlet和JSP的容器，而Tomcat内部默认的编码是ISO-8859-1，所以对于get请求方式，其传递的数据(URI)会附加在访问的资源后面，其编码是Tomcat默认的，如果修改该URI的编码，那么对于所有的get请求方式便不会出现乱码了包括上边说的重定向和超链接，在Tomcat的配置文件server.xml中找到修改Tomcat的端口的地方，在其内部加入URIEncoding属性，设置为和你的项目中所设的编码一样的值，这里全部都是UTF-8。如下所示：
<Connector port="8080" protocol="HTTP/1.1" connectionTimeout="20000"redirectPort="8443"  URIEncoding="UTF-8" />
七、使用MySQL数据库乱码
有时会用JDBC连接MySQL数据库，可能会出现乱码，所以要在连接之后加上如下的语句：
useUnicode=true&characterEncoding=UTF-8
这样就可以解决乱码问题了。
在编写Servlet和JSP的时候，为了避免出现乱码，最重要的就是：采用一致的编码，如果编码都一致了，肯定不会出现乱码。如果出现了乱码肯定那个地方不一致了。
css旧知识
  table--表格
      th----表格列--表头
        tr----表行
          td--表列
GET www.baidu.com/s?wd=java
post www.baidu.com

from 表单
  input 表单   文本  密码 提交
Servlet
简单来说，Java的序列化机制是通过在运行时判断类的serialVersionUID来验证版本一致性的。在进行反序列化时，JVM会把传来的字节流中的serialVersionUID与本地相应实体（类）的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常。(InvalidCastException)

serialVersionUID有两种显示的生成方式：        一个是默认的1L，比如：private static final long serialVersionUID = 1L;        一个是根据类名、接口名、成员方法及属性等来生成一个64位的哈希字段，比如：        private static final   long     serialVersionUID = xxxxL; 当你一个类实现了Serializable接口，如果没有显示的定义serialVersionUID，Eclipse会提供这个      提示功能告诉你去定义 。在Eclipse中点击类中warning的图标一下，Eclipse就会      自动给定两种生成的方式。如果不想定义它，在Eclipse的设置中也       可以把它关掉的，设置如下：         Window ==> Preferences ==> Java ==> Compiler ==> Error/Warnings ==>         Potential programming problems         将Serializable class without serialVersionUID的warning改成ignore即可。
当实现java.io.Serializable接口的实体（类）没有显式地定义一个名为serialVersionUID，类型为long的变量时，Java序列化机制会根据编译的class(它通过类名，方法名等诸多因素经过计算而得，理论上是一一映射的关系，也就是唯一的)自动生成一个serialVersionUID作序列化版本比较用，这种情况下，如果class文件(类名,方法明等)没有发生变化(增加空格,换行,增加注释,等等),就算再编译多次,serialVersionUID也不会变化的.

如果我们不希望通过编译来强制划分软件版本，即实现序列化接口的实体能够兼容先前版本，未作更改的类，就需要显式地定义一个名为serialVersionUID，类型为long的变量，不修改这个变量值的序列化实体都可以相互进行串行化和反串行化。

如果你没有考虑到兼容性问题时，就把它关掉，不过有这个功能是好的，只要任何类别实现了Serializable这个接口的话，如果没有加入 serialVersionUID，Eclipse都会给你warning提示，这个serialVersionUID为了让该类别 Serializable向后兼容。

问题一:假设有A端和B端,如果2处的serialVersionUID不一致,会产生什么错误呢?

问题二:假设2处serialVersionUID一致,如果A端增加一个字段,B端不变,会是什么情况呢?

问题三:假设2处serialVersionUID一致,如果B段增加一个字段,A端不变,会是什么情况呢?

问题四:假设2处serialVersionUID一致,如果A端减少一个字段,B端不变,会是什么情况呢?

问题五:假设2处serialVersionUID一致,如果B端减少一个字段,A端不变,会是什么情况呢?

 

例子如下:写2个类,类名相同,字段相同,方法相同.放在不同的包里,来模仿A端和B端.

实体类:在本例中,在测试类SerialTest执行前代表A端,然后,在测试类DeserialTest执行前代表B端.

package com.test; import java.io.Serializable;

public class Serial implements Serializable{ /**   *   */ private static final long serialVersionUID = 6977402643848374753L; int id;       String name;       public Serial(int id, String name) {           this.id = id;           this.name = name;       }       public String toString() {           return "DATA: " + id + " " +name;         }   }

 

测试类,代表A端的序列化

package com.test.serializable;

import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.io.ObjectOutputStream;

public class SerialTest {

/**   * @param args   */ public static void main(String[] args) {   // TODO Auto-generated method stub   Serial serial1 = new Serial(1,"song");   System.out.println("Object Serial"+serial1);     try {    FileOutputStream fos = new FileOutputStream("serialTest.txt");    ObjectOutputStream oos = new ObjectOutputStream(fos);    oos.writeObject(serial1);    oos.flush();    oos.close();         } catch (FileNotFoundException e) {    // TODO Auto-generated catch block    e.printStackTrace();   } catch (IOException e) {    // TODO Auto-generated catch block    e.printStackTrace();   } } }

测试类,代表B端的反序列化

package com.test.serializable;

import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; import java.io.ObjectInputStream;

public class DeserialTest {

/**   * @param args   */ public static void main(String[] args) {   // TODO Auto-generated method stub   Serial serial2 ;   try {    FileInputStream fis = new FileInputStream("serialTest.txt");    ObjectInputStream ois = new ObjectInputStream(fis);    serial2 = (Serial)ois.readObject();    ois.close();    System.out.println("Object Deserial"+serial2);   } catch (FileNotFoundException e) {    // TODO Auto-generated catch block    e.printStackTrace();   } catch (IOException e) {    // TODO Auto-generated catch block    e.printStackTrace();   } catch (ClassNotFoundException e) {    // TODO Auto-generated catch block    e.printStackTrace();   }   }

}

问题一:假设有A端和B端,如果2处的serialVersionUID不一致,会产生什么错误呢?

答案如下:

1)先执行测试类SerialTest,然后修改serialVersion值(或注释掉serialVersion并编译),再执行测试类DeserialTest,报错:

java.io.InvalidClassException: com.test.serializable.Serial; local class incompatible: stream classdesc serialVersionUID = 1, local class serialVersionUID = 11

2)A端和B端都没显示的写serialVersionUID,实体类没有改动(如果class文件(类名,方法明等)没有发生变化(增加空格,换行,增加注释,等等),).序列化,反序列化正常.

 

问题二:假设2处serialVersionUID一致,如果A端增加一个字段,B端不变,会是什么情况呢?

答案二: 序列化,反序列化正常,A端增加的字段丢失(被B端忽略).

问题五:假设2处serialVersionUID一致,如果B端减少一个字段,A端不变,会是什么情况呢?

答案:与问题二类似,序列化,反序列化正常,B端字段少于A端,A端多的字段值丢失(被B端忽略).

 

问题三:假设2处serialVersionUID一致,如果B段增加一个字段,A端不变,会是什么情况呢?

问题四:假设2处serialVersionUID一致,如果A端减少一个字段,B端不变,会是什么情况呢?(与问题三类似,四答案:序列化,反序列化正常,B端字段多余A端,B端多出的字段被赋予对应类型的默认值)

答案三: 序列化,反序列化正常,B端新增加的int字段被赋予了默认值0.  

例子如下:

3)先执行SerialTest,然后在实体类增加一个字段age,再执行测试类DeserialTest.

package com.test.serializable;

import java.io.Serializable;

public class Serial implements Serializable {

/**   *   */ private static final long serialVersionUID = -2337937881709830076L;

/**   *   */ //private static final long serialVersionUID = 1L; int id;       

    String name;       public Serial(int id, String name) {           this.id = id;           this.name = name;       }       public String toString() {           return "DATA: " + id + " " +name;         }     public int age ;//在B端增加一个新字段 }

相应的修改测试类DeserialTest,打印出age的值.

package com.test.serializable;

import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; import java.io.ObjectInputStream;

public class DeserialTest {

/**   * @param args   */ public static void main(String[] args) {   // TODO Auto-generated method stub   Serial serial2 ;   try {    FileInputStream fis = new FileInputStream("serialTest.txt");    ObjectInputStream ois = new ObjectInputStream(fis);    serial2 = (Serial)ois.readObject();    ois.close();    System.out.println("Object Deserial"+serial2+" age="+serial2.age);   } catch (FileNotFoundException e) {    // TODO Auto-generated catch block    e.printStackTrace();   } catch (IOException e) {    // TODO Auto-generated catch block    e.printStackTrace();   } catch (ClassNotFoundException e) {    // TODO Auto-generated catch block    e.printStackTrace();   }   }

}

打印结果如下:

Object DeserialDATA: 1 song age=0

1.创建一个变量
对象类型 变量
2.创建一个对象
new 对象类型（）
3.赋值
对象变量  类型


说明序列化,反序列化正常,B端新增加的int字段被赋予了默认值0.
Format是CString类的一个成员函数，它通过格式操作使任意类型的数据转换成一个字符串。
实上Format方法有两种形式，另外一种是三个参数的，主要区别在于它是线程安全的， 但并不多用，所以这里只对第一个介绍。Format参数是一个格式字符串，用于格式化Args里面的值的。Args是一个变量数组，即它里面可以有多个参数，而且每个参数可以不同。 例如：
Format("my name is %6s","wind");
JDBC:链接数据库
Java  data base Connectivity（java数据库连接）

java应用
jdbc加载驱动程序 Class.forName（driverClass）
    加载Mysql驱动 Class.forName（"com.mysql.jdbc.Driver"）
    j加载Oracle驱动Class.forName   （"oracle.jdbc.driver.OracleDriver"）
    获取DriverMabager.getConnection      （"jdbc:mysql://127.0.0.1:3306/imooc","root","root"）
    创建Statement对象：conn.createStatement（）；
jdbc  Oracle  mysql SQLserver
jdbc常用的接口
jdbc编程步骤

view
contrl
model
db数据库（从下往上）
C
R：高级  报表 分页
U
D

执行的SQL语句
管理结果集
高级应用
分页：  
高级查询 ：
高级函数使用：






/*public static void main(String[] args) throws Exception {
        //加载驱动程序
        Class.forName("com.mysql.jdbc.Driver");
        //获得数据库的链接
        Connection conn    =DriverManager.getConnection(url, user, password);
        
        //通过数据库的链接操作数据库 实现增删改查
      Statement stmt=conn.createStatement();
      ResultSet  rs= stmt.executeQuery("select user_name,age from imooc_goddess");
      
      
      while (rs.next()) {
          
          System.out.println(rs.getString("user_name")+","+rs.getInt("age"));
        
       }
    
    }*/
Jdbc+odbc桥的方式
Jdbc+厂商的API形式
jdbc+厂商Database Connection
Server+DataBase的形式
特点 在Java与DataBase之间架起了一台专用于数据库连接的服务器（一般由数据库厂商提供）

Jdbc+Databesa

工具  mybatis hibernate









Servlet 通过调用 init () 方法进行初始化。
Servlet 调用 service() 方法来处理客户端的请求。
Servlet 通过调用 destroy() 方法终止（结束）。
最后，Servlet 是由 JVM 的垃圾回收器进行垃圾回收的。
init 方法被设计成只调用一次。它在第一次创建 Servlet 时被调用，在后续每次用户请求时不再调用。因此，它是用于一次性初始化，就像 Applet 的 init 方法一样。

Servlet 创建于用户第一次调用对应于该 Servlet 的 URL 时，但是您也可以指定 Servlet 在服务器第一次启动时被加载。

当用户调用一个 Servlet 时，就会创建一个 Servlet 实例，每一个用户请求都会产生一个新的线程，适当的时候移交给 doGet 或 doPost 方法。init() 方法简单地创建或加载一些数据，这些数据将被用于 Servlet 的整个生命周期
service() 方法是执行实际任务的主要方法。Servlet 容器（即 Web 服务器）调用 service() 方法来处理来自客户端（浏览器）的请求，并把格式化的响应写回给客户端。

每次服务器接收到一个 Servlet 请求时，服务器会产生一个新的线程并调用服务。service() 方法检查 HTTP 请求类型（GET、POST、PUT、DELETE 等），并在适当的时候调用 doGet、doPost、doPut，doDelete 等方法。


GET 请求来自于一个 URL 的正常请求，或者来自于一个未指定 METHOD 的 HTML 表单，它由 doGet() 方法处理。
POST 请求来自于一个特别指定了 METHOD 为 POST 的 HTML 表单，它由 doPost() 方法处理。
destroy() 方法只会被调用一次，在 Servlet 生命周期结束时被调用。destroy() 方法可以让您的 Servlet 关闭数据库连接、停止后台线程、把 Cookie 列表或点击计数器写入到磁盘，并执行其他类似的清理活动。
<servlet>
        <servlet-name>HelloWorld</servlet-name>
        <servlet-class>HelloWorld</servlet-class>
    </servlet>

    <servlet-mapping>
        <servlet-name>HelloWorld</servlet-name>
        <url-pattern>/HelloWorld</url-pattern>
    </servlet-mapping>


Accept    这个头信息指定浏览器或其他客户端可以处理的 MIME 类型。值 image/png 或 image/jpeg 是最常见的两种可能值。

Accept-Charset    这个头信息指定浏览器可以用来显示信息的字符集。例如 ISO-8859-1。

Accept-Encoding    这个头信息指定浏览器知道如何处理的编码类型。值 gzip 或 compress 是最常见的两种可能值。

Accept-Language    这个头信息指定客户端的首选语言，在这种情况下，Servlet 会产生多种语言的结果。例如，en、en-us、ru 等。
Authorization    这个头信息用于客户端在访问受密码保护的网页时识别自己的身份。

Connection    这个头信息指示客户端是否可以处理持久 HTTP 连接。持久连接允许客户端或其他浏览器通过单个请求来检索多个文件。值 Keep-Alive 意味着使用了持续连接。

Content-Length    这个头信息只适用于 POST 请求，并给出 POST 数据的大小（以字节为单位）。

Cookie    这个头信息把之前发送到浏览器的 cookies 返回到服务器。
Host    这个头信息指定原始的 URL 中的主机和端口。

If-Modified-Since    这个头信息表示只有当页面在指定的日期后已更改时，客户端想要的页面。如果没有新的结果可以使用，服务器会发送一个 304 代码，表示 Not Modified 头信息。

If-Unmodified-Since    这个头信息是 If-Modified-Since 的对立面，它指定只有当文档早于指定日期时，操作才会成功。

Referer    这个头信息指示所指向的 Web 页的 URL。例如，如果您在网页 1，点击一个链接到网页 2，当浏览器请求网页 2 时，网页 1 的 URL 就会包含在 Referer 头信息中。

User-Agent    这个头信息识别发出请求的浏览器或其他客户端，并可以向不同类型的浏览器返回不同的内容。

始状态行 + 回车换行符（回车+换行）
零个或多个标题行+回车换行符
一个空白行，即回车换行符
一个可选的消息主体，比如文件、查询数据或查询输出



100    Continue     只有请求的一部分已经被服务器接收，但只要它没有被拒绝，客户端应继续该请求。
101    Switching Protocols     服务器切换协议。
200    OK     请求成功。
201    Created     该请求是完整的，并创建一个新的资源。
202    Accepted     该请求被接受处理，但是该处理是不完整的。
203    Non-authoritative Information     
204     No Content     
205    Reset Content     
206    Partial Content     
300    Multiple Choices     链接列表。用户可以选择一个链接，进入到该位置。最多五个地址。
301    Moved Permanently     所请求的页面已经转移到一个新的 URL。
302    Found     所请求的页面已经临时转移到一个新的 URL。
303    See Other     所请求的页面可以在另一个不同的 URL 下被找到。
304    Not Modified     
305    Use Proxy     
306    Unused     在以前的版本中使用该代码。现在已不再使用它，但代码仍被保留。
307    Temporary Redirect     所请求的页面已经临时转移到一个新的 URL。
400    Bad Request     服务器不理解请求。
401    Unauthorized     所请求的页面需要用户名和密码。
402    Payment Required     您还不能使用该代码。
403    Forbidden     禁止访问所请求的页面。
404    Not Found     服务器无法找到所请求的页面。.
405    Method Not Allowed     在请求中指定的方法是不允许的。
406    Not Acceptable     服务器只生成一个不被客户端接受的响应。
407     Proxy Authentication Required     在请求送达之前，您必须使用代理服务器的验证。
408    Request Timeout     请求需要的时间比服务器能够等待的时间长，超时。
409    Conflict     请求因为冲突无法完成。
410     Gone     所请求的页面不再可用。
411    Length Required     "Content-Length" 未定义。服务器无法处理客户端发送的不带 Content-Length 的请求信息。
412    Precondition Failed     请求中给出的先决条件被服务器评估为 false。
413    Request Entity Too Large     服务器不接受该请求，因为请求实体过大。
414    Request-url Too Long     服务器不接受该请求，因为 URL 太长。当您转换一个 "post" 请求为一个带有长的查询信息的 "get" 请求时发生。
415    Unsupported Media Type     服务器不接受该请求，因为媒体类型不被支持。
417    Expectation Failed     
500    Internal Server Error     未完成的请求。服务器遇到了一个意外的情况。
501    Not Implemented     未完成的请求。服务器不支持所需的功能。
502    Bad Gateway     未完成的请求。服务器从上游服务器收到无效响应。
503    Service Unavailable     未完成的请求。服务器暂时超载或死机。
504    Gateway Timeout     网关超时。
505    HTTP Version Not Supported     服务器不支持"HTTP协议"版本。





java mysql免安装方法

basedir =F:\mysql-5.6.24-win32
datadir =F:\mysql-5.6.24-win32\data
port =3306
#编码
character_set_server=UTF8
path   ;F:\mysql-5.6.24-win32\bin

cmd mysql
mysql -install
提示成功

net start mysql
请求的服务启动
net stop mysql
服务停止
mysql -u root -p

关闭正在运行的MySQL。

　　2.打开DOS窗口，转到mysql\bin目录。

　　3.输入mysqld --skip-grant-tables回车。如果没有出现提示信息，那就对了。

　　4.再开一个DOS窗口(因为刚才那个DOS窗口已经不能动了)，转到mysql\bin目录。

　　5.输入mysql回车，如果成功，将出现MySQL提示符 >

　　6. 连接权限数据库>use mysql; (>是本来就有的提示符,别忘了最后的分号)

　　7.改密码：> update user set password=password("123456") where user="root";

　　8.刷新权限(必须的步骤)>flush privileges;

　　9.退出 > \q

regedit

"C:\Program Files\MySQL\MySQL Server 5.6\mysqld" MySQL
F:\mysql-5.6.24-win32替换C:\Program Files\MySQL\MySQL Server 5.6

mysql show databases；  展示数据库
create database First；创建数据库
drop database；删除数据库
show databases;
create database 名称;
drop database 名称;
select describe from test_table;



2. 解压MySQL压缩包
    将以下载的MySQL压缩包解压到自定义目录下,我的解压目录是:
    "D:\Program Files\MySQL\mysql-5.6.13-win32"
    将解压目录下默认文件 my-default.ini 拷贝一份，改名 my.ini
    复制下面的配置信息到 my.ini 保存
    #如果没有my-default.ini,可自己新建my.ini或者从其他地方中获取
#########################################################
    [client]
    port=3306
    default-character-set=utf8
    [mysqld]
    port=3306
    character_set_server=utf8
    basedir=D:\Program Files\MySQL\mysql-5.6.13-win32
    #解压目录
    datadir=D:\Program Files\MySQL\mysql-5.6.13-win32\data
    #解压目录下data目录
    sql_mode=NO_ENGINE_SUBSTITUTION,STRICT_TRANS_TABLES
    [WinMySQLAdmin]
    D:\Program Files\MySQL\mysql-5.6.13-win32\bin\mysqld.exe
#########################################################


3. 添加环境变量
    操作如下：
    1）右键单击我的电脑->属性->高级系统设置(高级)->环境变量
      点击系统变量下的新建按钮
      输入变量名：MYSQL_HOME
      输入变量值：D:\Program Files\mysql-5.6.11-winx64
      #即为mysql的自定义解压目录。
    2）选择系统变量中的Path
      点击编辑按钮
      在变量值中添加变量值：%MYSQL_HOME%\bin
      注意是在原有变量值后面加上这个变量，用;隔开，不能删除原来的变量值，


4. 将mysql注册为windows系统服务
    1）从控制台进入到MySQL解压目录下的 bin 目录下：
    2）输入服务安装命令：
    mysqld install MySQL --defaults-file="D:\Program Files\MySQL\mysql-5.6.13-win32\my.ini"
    #解压目录下修改的my.ini文件
    安装成功后会提示服务安装成功。
    #注：my.ini文件放在MySQL解压后的根目录下
    #移除服务命令为：mysqld remove


5. 启动MySQL服务
    方法一：
        启动服务命令为：net start mysql
    方法二：
        打开管理工具 服务，找到MySQL服务。
        通过右键选择启动或者直接点击左边的启动来启动服务。


6. 修改 root 账号的密码
    刚安装完成时root账号默认密码为空，此时可以将密码修改为指定的密码。如：123456
    c:>mysql –uroot
    mysql>show databases;
    mysql>use mysql;
    mysql>UPDATE user SET password=PASSWORD("123456") WHERE user='root';
    mysql>FLUSH PRIVILEGES;
    mysql>QUIT
 
7. MySQL控制台快捷方式建立:
    1）桌面右键->新建->快捷方式->对象位置输入：C:\Windows\System32\cmd.exe
        快捷方式名称自己定义，确定，快捷方式建立成功
    2）右键单击刚才建立的快捷方式->属性->把目标一栏修改成MySQL启动参数：
        C:\Windows\System32\cmd.exe "D:\Program Files\MySQL\mysql-5.6.13-win32\bin" /k mysql -uroot -p inventory
        解释:CMD路径 "MySQL路径bin目录" /k mysql -u用户名 -p密码 数据库名
    3）修改完成后点击确定保存，直接双击快捷方式即可连接到MySQL数据库

update user set password=password('12345') where user='root';


练习代码
show tables;
select * from  pepole;
drop table cars;
--创建表
create table cars(
name char(20),
skil char(20),
age int(20));


insert into cars values('蜘蛛侠','吐丝',21,'男');
insert into cars values('钢铁侠','飞翔',42,'男');
insert into cars values('猫女','爪子',32,'女');
insert into cars values('侠女','剑',32,'女');

select * from  cars;


alter table cars add sex char(1);

desc cars;
--删除
delete from cars;
delete from cars where name='猫女';

delete from cars where sex='男';

delete from cars where age>30;


select * from cars where name like '蜘蛛侠';

select * from cars where name like '%侠%';

select * from cars where name like '%侠%'and age>40;


select * from cars where age<30 or age>40;
update cars set sex='女';

drop table cars;

--主键primary key  不能为空  不能重复
create table cars(
id int(20) primary key auto_increment,
name char(20),
age int(3)

);

insert  into  cars values(1,'张三',21);
insert into cars values(2,'李四',12);
insert into cars values(3,'王五',45);
insert into cars values(4,null,21);


insert into cars values(null,'asd',21);

select * from cars;


delete from cars where id=4;

insert into cars values(4,'www',21);


update cars set name='你好', age=15 where id=4;

drop table user;

create table user(
id  int(12) primary key auto_increment,
name char(20) not null default '未命名',
password char(20),
age int(3) not null default 0
);

insert into user values(null,'张三','123',0);
insert into user values(null,'','123',0);
insert into user values(null,'',null);
insert into user values(null,default,'123');
insert into user values(null,'default',null,default);


select *from user;


create database school;



数据库（DataBase，DB）：指长期保存在计算机的存储设备上，按照一定规则组织起来，可以被各种用户或应用共享的数据集合。

Oracle：目前比较成功的关系型数据库管理系统。运行稳定、功能齐全、性能超群、技术领先。主要应用在大型的企业数据库领域。


DB2：IBM的产品。


SQL Server：Microsoft的产品。软件界面友好、易学易用，在操作性和交互性方面独树一帜。


PostgreSQL：加州大学伯克利分校以教学目的开发的数据库系统，支持关系和面向对象的数据库，属于自由数据库管理系统。



MySQL：免费的数据库系统。被广泛用于中小型应用系统。体积小、速度快、总体拥有成本低，开放源代码。2008年被SUN收购，2009年SUN被Oracle收购。所谓安装数据库服务器，只是在机器上装了一个数据库管理程序，这个管理程序可以管理多个数据库，一般开发人员会针对每一个应用创建一个数据库
为保存应用中实体的数据，一般会在数据库创建多个表，以保存程序中实体的数据。
数据库服务器、数据库和表的关系如图



登录MySQL mysql -uroot -p123456 – u用户名 –p密码
show databases;       --查看安装的数据库
use database_name; --使用数据库
show tables;              --查看数据库中的表
show columns form ‘表名’；
--显示数据表的属性，属性类型，主键信息 ，是否为 NULL，默认值等其他信息Structure Query Language。

DDL（Data Definition Language）：数据定义语言，用来定义数据库对象：库、表、列等；
create alter drop



DML（Data Manipulation Language）：数据操作语言，用来操作数据库表中的记录（数据）；
insert：
INSERT INTO t_student
VALUES('1','1','2016001001','王宝强','男','1985-08-30 00:00:00'); 插入的数据应与字段的数据类型相同。
--  数据的大小应在列的规定范围内，例如：不能将一个长度为80的字符串加入到长度为40的列中。
--  在values中列出的数据位置必须与被加入的列的排列位置相应
--  字符和日期型数据应包含在单引号中。
--  插入空值，不指定或insert into table value(null)update
delete



DQL（Data Query Language）：数据查询语言，用来查询记录（数据）。select
DCL（Data Control Language）：数据控制语言，用来定义访问权限和安全级别；
primary key
auto_increment



CREATE TABLE table_name (column_name column_type);  --创建表
    CREATE TABLE t_student (
    id INT (11) NOT NULL PRIMARY KEY AUTO_INCREMENT,   -- 主键自增
    class_id INT (11) NOT NULL,                         --班级ID
    student_no VARCHAR (10) NOT NULL,         -- 学号 不能为空
    student_name VARCHAR (10) NOT NULL,    -- 姓名  不能为空
    sex CHAR (2) DEFAULT NULL,                       -- 性别
    birthday datetime DEFAULT NULL                -- 生日 日期格式
)；    
DROP TABLE table_name ; --删除表

删除列
ALTER TABLE table_name DROP column_name;
添加列
ALTER TABLE table_name ADD column_name  INT;
修改列类型
ALTER TABLE table_name MODIFY column_name CHAR(10);
修改列名称
ALTER TABLE table_name CHANGE c1 c2 BIGINT;
修改字段默认值
ALTER TABLE table_name ALTER column_name SET DEFAULT 1;
修改表名
ALTER TABLE table_name RENAME TO new_table_name ;
使用 update语句修改表中数据
UPDATE t_student SET student_name='王宝强',sex='男' WHERE id=1使用 delete语句删除表中数据
DELETE FROM t_student WHERE student_name = '王宝强';
SELECT [DISTINCT] *|{column1, column2, column3..} FROM table;
SELECT指定查询哪些列的数据。
column指定列名。
*号代表查询所有列。
FROM指定查询哪张表。
DISTINCT可选，指显示结果时，是否剔除重复数据使用order by 子句排序查询结果
    SELECT column1, column2. column3..  FROM    table  order by column asc|desc
Order by 指定排序的列，排序的列即可是表中的列名，也可以是select 语句后指定的列名。
Asc 升序、Desc 降序
ORDER BY 子句应位于SELECT语句的结尾






连接查询：
交叉连接（cross join）:不带on子句，返回连接表中所有数据行的笛卡儿积。内连接（inner join）：返回连接表中符合连接条件及查询条件的数据行。外连接：分为左外连接（left out join）、右外连接（right outer join）。与内连接不同的是，外连接不仅返回连接表中符合连接条件及查询条件的数据行，也返回左表（左外连接时）或右表（右外连接时）中仅符合查询条件但不符合连接条件的数据行。
子查询
联合查询
报表查询


show databases;
--显示数据表的属性，属性类型，主键信息 ，是否为 NULL，默认值等其他信息
show columns from user;

select * from user;
--创建mydb数据库

create database cook;
--删除mydb数据库

drop database cook;
select * from cook;

drop table cook;


delete from cook;
--primary key:不允许为空，不允许重复
--主键自动增长 auto_increment
--定义非空约束 not null
--Order by 指定排序的列，排序的列即可是表中的列名，也可以是select 语句后指定的列名。
--Asc 升序、Desc 降序
--ORDER BY 子句应位于SELECT语句的结尾。
create table cook(
id int(4) primary key auto_increment,
name char(20) ,
age int(3) ,
password char(20) ,
url char(200)
);

insert into cook values(1,'淘宝',2,'123456','www.taobao.com');
insert into cook values(2,'百度',1,'123456','www.baidu.com');
insert into cook values(3,'网易',4,'123456','http://www.wangye.com');
insert into cook values(4,'京东',3,'123456','http://www.jidong.com');
insert into cook values(5,'google',7,'123456','http://www.Google.com');


select * from cook;

select * from cook where name like '%宝%';
--SELECT语句中可使用as语句


--在SELECT语句中可使用表达式对查询的列进行运算


select  from cook union;

SELECT id FROM cook
UNION ALL
SELECT id FROM user;

--连接查询的from子句的连接语法 TABLE1和TABLE2表示参与连接操作的表
--，TABLE1为左表，TABLE2为右表。on子句设定连接条件，where子句设定查询条件，
--join_type表示连接类型
select * from cook where age=2  and age>3;

alter table cook add county int(20);
--增加列 属性
alter table cook drop county;
--增加 列的类型
alter table cook modify country char(20);

--更新
update cook set country='中国' where id=1;
--删除主键
alter table cook drop primary key;
--交叉 查询CUSTOMER表和ORDERS表
select * from cook cross join user;

select * from cook,user;

--显示内连接 使用inner join关键字，在on子句中设定连接条件

select * from cook c inner join user o on c.id=o.id;
--隐式内连接 不包含inner join关键字和on关键字，在where子句中设定连接条件


select * from cook c,user o where c.id=o.id;

--右连接 使用right outer join关键字，在on子句中设定连接条件

select * from cook c right outer join user o on c.id=o.id;
--条件式右连接

SELECT * FROM user c RIGHT OUTER JOIN cook o ON c.id=o.id WHERE o.age>5;
--子查询 嵌套查询，是指在select子句或者where子句中又嵌入select查询语句,子查询的语句放在小括号之内
--所有订单

select * from cook where id=(select id from cook where name like '%宝%');

--左连接 使用left outer join关键字，在on子句中设定连接条件

select * from cook c left outer join user o on c.id=o.id;
--条件式左连接

SELECT * FROM user c left OUTER JOIN cook o ON c.id=o.id WHERE o.age>10;

--联合查询 两条查询语句的查询结果，去掉其中的重复数据行，然后返回没有重复数据行的查询结果。联合查询使用union关键字


select * from cook where age>15 union SELECT * FROM cook where name='ni';
--合计函数count sum avg MAX/MIN
Select count(age) from cook;
SELECT  SUM(age) FROM cook;
SELECT  MAX(age) FROM cook;
SELECT  MIN(age) FROM cook;
---group by语句

--报表查询

select * from cook  group by id order by 'date';

--备份单个数据库 mysqldump -u root -p mydb > D:\mydb_backup.sql
--备份多个数据库 mysqldump -u root -p mydb1，mydb2 > D:\mydb_backup.sql
--备份所有数据库 mysqldump -u root -p -all-databases > D:\mydb_backup.sql
--恢复数据库 mysql -u root -p <D:\mydb_backup.sql

package com.imooc.www;

import java.io.IOException;
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.tomcat.util.descriptor.web.LoginConfig;

import sun.security.util.Password;

/**
 * Servlet implementation class DengDmeo
 */
@WebServlet("/DengDmeo")
public class DengDmeo extends HttpServlet {
    private static final long serialVersionUID = 1L;
       
    /**
     * @see HttpServlet#HttpServlet()
     */
    public DengDmeo() {
        super();
        // TODO Auto-generated constructor stub
    }

    /**
     * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
     */
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // TODO Auto-generated method stub
        response.setContentType("text/html;charset=UTF-8");
        request.setCharacterEncoding("UTF-8");
        //response.getWriter().append("欢迎！");
        String name=request.getParameter("nam");
        //response.getWriter().append(name);
        String password=request.getParameter("password");
        //response.getWriter().append(password);    
        String sql="insert into user values(null,'"+name+"','"+password+"');";
        String content = searchDQL("select * from user where name = '"+name+"'and password='"+password+"' ");
        insertSQL(sql);
        searchDQL(content);
        if(name != null && password != null&&content!=null )
        {
            if(!name.equals("")&&!password.equals("")){
                //跳转到系统主页面
                response.sendRedirect("c.jsp");
                
                }
            else{
                //否则就提示登录错误
                response.getWriter().write("帐号或密码不能为空字符串或请注册账号！");
                
                 }
            }else if (name != null && password != null&&sql!=null) {
                if(!name.equals("")&&!password.equals("")){
                    //跳转到系统主页面
                    response.sendRedirect("a.jsp");
                    }
                else{
                    //否则就提示登录错误
                    response.getWriter().write("帐号或密码不能为空字符串或请注册账号！");
                    
                   }
            }
           
        }
        
        
        
    
   
        /*String sql="insert into user values(null,'"+name+"','"+password+"');";
        insertSQL(sql);
        
    
        String content = searchDQL("select * from user where name = '"+name+"'and password='"+password+"' ");
        searchDQL(content);*/
        

        
    

       
        
        


    private Object getString(String string) {
        // TODO Auto-generated method stub
        return null;
    }

    /**
     * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
     */
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // TODO Auto-generated method stub
        doGet(request, response);
        
        
    }
   public void insertSQL(String sql){
       try {
        Class.forName("com.mysql.jdbc.Driver");
        Connection connection=DriverManager.getConnection("jdbc:mysql://localhost:3306/test","root","123456");
        Statement statement=connection.createStatement();
        statement.execute(sql);
        statement.close();
        connection.close();
       } catch (Exception e) {
        // TODO: handle exception
    }

   }
   public String searchDQL(String sql) {
        String content = "";
        try {
            Class.forName("com.mysql.jdbc.Driver");
            Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "123456");
            Statement statement = connection.createStatement();
            ResultSet set = statement.executeQuery(sql);
            while (set.next()) {
                int id = set.getInt("id");
                String name = set.getString("nam");
                String password = set.getString("password");
                content += id;
                content += name;
                content += password;
                
            }
            set.close();
            statement.close();
            connection.close();

        } catch (Exception e) {
            // TODO: handle exception
        }
        return content;
    }
    
    
    
    
}





Servlet 过滤器可以动态地拦截请求和响应，以变换或使用包含在请求或响应中的信息。

可以将一个或多个 Servlet 过滤器附加到一个 Servlet 或一组 Servlet。Servlet 过滤器也可以附加到 JavaServer Pages (JSP) 文件和 HTML 页面。调用 Servlet 前调用所有附加的 Servlet 过滤器。

Servlet 过滤器是可用于 Servlet 编程的 Java 类，可以实现以下目的：

    在客户端的请求访问后端资源之前，拦截这些请求。
    在服务器的响应发送回客户端之前，处理这些响应。

根据规范建议的各种类型的过滤器：

    身份验证过滤器（Authentication Filters）。
    数据压缩过滤器（Data compression Filters）。
    加密过滤器（Encryption Filters）。
    触发资源访问事件过滤器。
    图像转换过滤器（Image Conversion Filters）。
    日志记录和审核过滤器（Logging and Auditing Filters）。
    MIME-TYPE 链过滤器（MIME-TYPE Chain Filters）。
    标记化过滤器（Tokenizing Filters）。
    XSL/T 过滤器（XSL/T Filters），转换 XML 内容。

过滤器通过 Web 部署描述符（web.xml）中的 XML 标签来声明，然后映射到您的应用程序的部署描述符中的 Servlet 名称或 URL 模式。

当 Web 容器启动 Web 应用程序时，它会为您在部署描述符中声明的每一个过滤器创建一个实例。

Filter的执行顺序与在web.xml配置文件中的配置顺序一致，一般把Filter配置在所有的Servlet之前



Cookie 是存储在客户端计算机上的文本文件，并保留了各种跟踪信息。Java Servlet 显然支持 HTTP Cookie。

识别返回用户包括三个步骤：

    服务器脚本向浏览器发送一组 Cookie。例如：姓名、年龄或识别号码等。
    浏览器将这些信息存储在本地计算机上，以备将来使用。
    当下一次浏览器向 Web 服务器发送任何请求时，浏览器会把这些 Cookie 信息发送到服务器，服务器将使用这些信息来识别用户。

本章将向您讲解如何设置或重置 Cookie，如何访问它们，以及如何将它们删除。

    Servlet Cookie 处理需要对中文进行编码与解码，方法如下：

    String   str   =   java.net.URLEncoder.encode("中文"，"UTF-8");            //编码
    String   str   =   java.net.URLDecoder.decode("编码后的字符串","UTF-8");   // 解码

Cookie 剖析

Cookie 通常设置在 HTTP 头信息中（虽然 JavaScript 也可以直接在浏览器上设置一个 Cookie）。设置 Cookie 的 Servlet 会发送如下的头信息：

HTTP/1.1 200 OK
Date: Fri, 04 Feb 2000 21:03:38 GMT
Server: Apache/1.3.9 (UNIX) PHP/4.0b3
Set-Cookie: name=xyz; expires=Friday, 04-Feb-07 22:03:38 GMT;
                 path=/; domain=w3cschool.cc
Connection: close
Content-Type: text/html

正如您所看到的，Set-Cookie 头包含了一个名称值对、一个 GMT 日期、一个路径和一个域。名称和值会被 URL 编码。expires 字段是一个指令，告诉浏览器在给定的时间和日期之后"忘记"该 Cookie。

如果浏览器被配置为存储 Cookie，它将会保留此信息直到到期日期。如果用户的浏览器指向任何匹配该 Cookie 的路径和域的页面，它会重新发送 Cookie 到服务器。浏览器的头信息可能如下所示：

GET / HTTP/1.0
Connection: Keep-Alive
User-Agent: Mozilla/4.6 (X11; I; Linux 2.2.6-15apmac ppc)
Host: zink.demon.co.uk:1126
Accept: image/gif, */*
Accept-Encoding: gzip
Accept-Language: en
Accept-Charset: iso-8859-1,*,utf-8
Cookie: name=xyz

Servlet 就能够通过请求方法 request.getCookies() 访问 Cookie，该方法将返回一个 Cookie 对象的数组



jsp servlet js登录与注册


LoginServlet.java
package com.zhiyou100.servlet;

import java.io.IOException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * Servlet implementation class LoginServlet
 */
@WebServlet("/login")
public class LoginServlet extends HttpServlet {
    private static final long serialVersionUID = 1L;
       
    /**
     * @see HttpServlet#HttpServlet()
     */
    public LoginServlet() {
        super();
        // TODO Auto-generated constructor stub
    }

    /**
     * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
     */
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // TODO Auto-generated method stub
        response.getWriter().append("Served at: ").append(request.getContextPath());
    }

    /**
     * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
     */
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        request.setCharacterEncoding("UTF-8");
        response.setContentType("text/html; charset=UTF-8");
        
        String username = request.getParameter("username");
        String password = request.getParameter("password");
        
        String dbPassword = null;

        try {
            Class.forName("com.mysql.jdbc.Driver");
            
            Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test3", "root", "1230123");
            
            Statement statement = conn.createStatement();
            
            String sql = "select password from user where username = '" + username + "';";
            
            ResultSet rs = statement.executeQuery(sql);

            while(rs.next()) {
                dbPassword = rs.getString("password");
            }

            rs.close();
            conn.close();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        if (dbPassword == null) {
            //帐号不存在
            response.getWriter().append("帐号不存在");
        }else if (dbPassword.equals(password)) {
            //比较存储的密码和输入的密码是否一致
            response.getWriter().append("登录成功");
        }else {
            response.getWriter().append("密码输入有误");
        }
        
        //输出 js 并执行，js 是 JavaScript 的简称和 Java 没有关系。
        //HTML，框架
        //CSS，装饰
        //JS，让网页和用户进行互动
        response.getWriter().append("<script>");
        //写一些需要执行的 js 代码
        //alert 弹出提示框
//        response.getWriter().append("alert('Hello')");
        //返回上一页面
//        response.getWriter().append("history.back();");
        //setTimeout() js 中的延迟多少秒执行
        //两个参数，第一个 需要执行的方法
        //第二个 延迟多少秒，单位是毫秒
        response.getWriter().append("setTimeout('history.back()', 3000)");
        response.getWriter().append("</script>");

        
        //为了后期的修改和维护，我们需要把相同的代码封装到方法中。
        //那么所有使用这段代码的地方，使用调用方法代替。
        //相同的代码就只用去方法实现中写一遍即可。
        //将来修改的时候，只需要去方法实现中修改一次，那么所有调用方法的地方都跟着发生变化。
        
        //在编程经验不足的时候，优先实现功能，后考虑修改和优化。
        //
    }

}


RegisterServlet.java
package com.zhiyou100.servlet;

import java.io.IOException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * Servlet implementation class RegisterServlet
 */
@WebServlet("/register")
public class RegisterServlet extends HttpServlet {
    private static final long serialVersionUID = 1L;
       
    /**
     * @see HttpServlet#HttpServlet()
     */
    public RegisterServlet() {
        super();
        // TODO Auto-generated constructor stub
    }

    /**
     * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
     */
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // TODO Auto-generated method stub
        response.getWriter().append("Served at: ").append(request.getContextPath());
    }

    /**
     * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
     */
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        //1.统一编码格式
        request.setCharacterEncoding("UTF-8");
        response.setContentType("text/html; charset=UTF-8");
        
        //2.获得用户在表单中输入的内容
        String username = request.getParameter("username");
        String password = request.getParameter("password");
        
        //3.判断 username 是否可用
        //3.0 假设这个 dbPassword 是从数据库中查询出来的 username 对应的 password。
        String dbPassword = null;
        
        //3.1 从数据库查找是否有 username 对应的 password
        //3.1.1 建立数据库和表
        try {
            //3.1.2 加载驱动，拖 jar 包
            Class.forName("com.mysql.jdbc.Driver");
            //3.1.3 建立数据库链接
            Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test3", "root", "1230123");
            //3.1.4 创建执行 SQL 语句的 Statement 对象
            Statement statement = conn.createStatement();
            //3.1.5 拼装需要执行的 SQL 语句
            String sql = "select password from user where username = '" + username + "';";
            //3.1.6 执行 SQL 语句，获得查询结果放入 ResultSet
            ResultSet rs = statement.executeQuery(sql);
            //3.1.7 通过 while 循环取出 password 赋值提前声明好的变量 dbPassword
            while(rs.next()) {
                dbPassword = rs.getString("password");
            }
            //3.1.8 关闭 rs 和 conn
            rs.close();
            conn.close();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        //3.2 判断 dbPassword 是否存在
        if (dbPassword == null) {
            //说明数据库中没有 username 这一行，说明 username 可以使用。
            //3.2.1 把 username 和 password 插入数据库
            try {
                Class.forName("com.mysql.jdbc.Driver");
                Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test3", "root", "1230123");
                Statement statement = conn.createStatement();
                
                String sql = "insert into user values(null, '" + username + "', '" + password + "')";
                
                statement.execute(sql);
                
                conn.close();
            } catch (ClassNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            //3.2.2 告诉用户注册成功
            response.getWriter().append("账号注册成功");
        }else {
            //说明数据库中有 username 这一行，说明 username 不可以使用。
            //3.2.3 告诉用户用户名不可用
            response.getWriter().append("用户名已被使用，请更换");
        }

    }

}



<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>登录</title>
</head>
<body>
<form action="LonginServlet" method="post">
用户:<input type="text" name="username"/><br>
密码:<input type="password" name="password"/><br>
<input type="submit" value="登录"/>
<a href="login.jsp">点击注册页面</a>
</body>
</html>



<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>注册</title>
</head>
<body>

    <form action="register" method="post">
    
        <input type="text" name="username">
        <br>
        <input type="password" name="password">
        <br>
        <input type="submit" value="注册">
    </form>
    
    <a href="login.jsp">点击去登录页面</a>

</body>
</html>














  page:  可以作用于单个页面
   request: 可以作用于单个请求
   session： 可以作用于整个会话
   application： 可以作用于整个Web应用
Javabean既可以封装数据同时也可以封装业务逻辑。



眼高手低：
进度由慢到快
写代码  要代码量  写代码有感觉 写多了  
1.白天老师做笔记  在不看代码与笔记  自己敲出来！创建自己新工程。
2.前一天失败的原因 自己写！晚上要练习！
3.写代码卡壳了的地方做笔记， 晚上复习与预习代码量。全部敲出来！
4.做好笔记，知识点，重要的知识点的笔记，没听懂的点，做笔记然后下课 ，搜一下资料！
<form action="${pageContext.request.contextPath}/RegistServlet" method="post">




/**
 * 用户注册
 */
public class RegistServlet extends HttpServlet {
    private static final long serialVersionUID = 1L;

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        try{
        //接受数据;
        request.setCharacterEncoding("utf-8");
        String username=request.getParameter("username");
        String password=request.getParameter("password");
        String nickname=request.getParameter("nickname");
        String email=request.getParameter("email");
        //封装数据；
        User user=new User();
        user.setUsername(username);
        user.setPassword(password);
        user.setNickname(nickname);
        user.setEmail(email);
        user.setState(0);
        String code=UUIDUtils.getUUID()+UUIDUtils.getUUID();
        user.setCode(code);
        //调用业务层处理数据
        UserService userService=new UserServiceImpl();
        userService.regist(user);
        //页面跳转
        request.setAttribute("msg", "你已经成功注册");
        request.getRequestDispatcher("/msg.jsp").forward(request, response);
        }
        catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException();
        }
    }

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        
        doGet(request, response);
    }

}





<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<style type="text/css">
button {
    background-color: white;
    width: 50px;
    height: 50px;
    border: 0px;
}

button:HOVER {
    border: 2px yellow solid;
}

td {
    text-align: center;
}
</style>
</head>
<body>
    <button οnclick="goForword()"><</button>
    <font id="title"></font>
    <button οnclick="goNext()">></button>
    <button style="width: 100px;" οnclick="showToday()">展示今天</button>
    <table id="table">
    </table>

    <script type="text/javascript">
        //获取当前时间
        var nowDate = new Date();
        //获取当前年
        var year = nowDate.getFullYear();
        //获取当前月
        var month = nowDate.getMonth();
        //记录下当前年的值 ---- 后面判断是否是当前时间
        var nowYear = year;
        //记录下当前月的值
        var nowMonth = month;
        //记录下当前日的值
        var nowDay = nowDate.getDate();

        //调用该方法，根据变量year,month
        //来展示不同的界面
        function changedHtml() {
            //获取展示月的第一天
            nowDate = new Date(year, month, 1);
            //展示月的第一天星期数
            var firstDayOfWeek = nowDate.getDay();
            //展示月的总天数
            var dayOfMonth = 0;
            switch (month + 1) {
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
            case 12:
                dayOfMonth = 31;
                break;
            case 2:
                //判断闰年还是平年
                if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
                    dayOfMonth = 29;
                } else {
                    dayOfMonth = 28;
                }
                break;
            default:
                dayOfMonth = 30;
                break;
            }
            //获取标题标签
            var title = document.getElementById("title")
            //设置标签内容
            title.innerHTML = year + "年" + (month + 1) + "月";
            //周日获取的天数为0
            if (firstDayOfWeek == 0) {
                firstDayOfWeek = 7;
            }
            //将标签拼接  拼成表格table里面的正文
            var content = "<tr><td>一</td><td>二</td><td>三</td><td>四</td><td>五</td><td>六</td><td>日</td></tr><tr>";
            for (var i = 1; i <= dayOfMonth + firstDayOfWeek - 1; i++) {
                //一个表格    
                content += "<td>";
                //判断是否为前几天的空格
                if (i - firstDayOfWeek + 1 >= 1) {
                    //判断是否为今天
                    if (year == nowYear && month == nowMonth
                            && (i - firstDayOfWeek + 1) == nowDay) {
                        //今天
                        content += "<button style='color:white;background-color:yellow;'>";
                    } else {
                        //判断周末
                        if (i % 7 == 6 || i % 7 == 0) {
                            //周末
                            content += "<button style='color:red;'>";
                        } else {
                            //工作日
                            content += "<button>";
                        }
                    }
                    //展示正文数字
                    content += (i - firstDayOfWeek + 1);
                    //按钮结束标签
                    content += "</button>";

                }
                //一个表格结束
                content += "</td>";
                //每过7个需要换行
                if (i % 7 == 0) {
                    content += "</tr><tr>";
                }
            }
            //最后不用忘记结束了
            content += "</tr>";
            //找到表格
            var table = document.getElementById("table")
            //加入内容
            table.innerHTML = content;
        }
        //第一次的时候调用方法
        changedHtml();
    </script>
    <script type="text/javascript">
        //    前一个月
        function goForword() {
            month--;
            if (month == -1) {
                month = 11;
                year--;
            }
            changedHtml();
        }
        //        后一个月
        function goNext() {
            month++;
            if (month >= 12) {
                month = 0;
                year++;
            }
            changedHtml();
        }
        //        当前月
        function showToday() {
            nowDate = new Date();
            year = nowDate.getFullYear();
            month = nowDate.getMonth();
            changedHtml();

        }
    </script>
</body>
</html>


<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<style type="text/css">
#header1 {
    color: white;
    position: relative;
    left: -120px;
    top: -8px;
    font-size: 12px;
}

table {
    border: 1px solid blue;
    width: 150px;
    margin-top: -15px;
    padding-left: 10px;
    font-size: 15px;
    margin-bottom: 2px;
}

hr {
    color: #00000000
}
</style>
</head>
<body>
    <script type="text/javascript">
        var tState1 = true;
        var tState2 = true;

        function tableChanged1() {
            var tab = document.getElementById("t1");
            if (tState1) {
                tab.style.display = "none";

            } else {
                tab.style.display = "inline";
                tab.style = "border: 1px solid blue;width: 150px;margin-top: -15px;padding-left: 10px;font-size: 15px;margin-bottom: 2px;";
            }
            tState1 = !tState1;
        }
        function tableChanged2() {
            var tab = document.getElementById("t2");
            if (tState2) {
                tab.style.display = "none";

            } else {
                tab.style.display = "inline";
                tab.style = "border: 1px solid blue;width: 150px;margin-top: -15px;padding-left: 10px;font-size: 15px;margin-bottom: 2px;";
            }
            tState2 = !tState2;
        }
    </script>
    <img alt="" src="img/main_47.gif">
    <font id="header1">客户相关</font>
    <button οnclick="tableChanged1()" style="position: relative; left: -215px; top: -11px; width: 164px; height: 22px; background-color: #00000000; border: 0px;"></button>
    <table id="t1">
        <tr>
            <td>
                <img alt="" src="img/left.gif">
            </td>
            <td>客户信息</td>
        </tr>
        <tr>
            <td>
                <img alt="" src="img/left.gif">
            </td>
            <td>客户分配</td>
        </tr>
        <tr>
            <td>
                <img alt="" src="img/left.gif">
            </td>
            <td>客户关怀</td>
        </tr>
        <tr>
            <td>
                <img alt="" src="img/left.gif">
            </td>
            <td>客户类型</td>
        </tr>
    </table>
    <hr>
    <img alt="" src="img/main_47.gif">
    <font id="header1">员工相关</font>
    <button οnclick="tableChanged2()" style="position: relative; left: -215px; top: -11px; width: 164px; height: 22px; background-color: #00000000; border: 0px;"></button>
    <table id="t2">
        <tr>
            <td>
                <img alt="" src="img/left.gif">
            </td>
            <td>员工信息</td>
        </tr>
        <tr>
            <td>
                <img alt="" src="img/left.gif">
            </td>
            <td>房屋信息</td>
        </tr>
        <tr>
            <td>
                <img alt="" src="img/left.gif">
            </td>
            <td>房屋类型</td>
        </tr>
        <tr>
            <td>
                <img alt="" src="img/left.gif">
            </td>
            <td>部门信息</td>
        </tr>
    </table>


</body>
</html>




<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
<table id="table" border="1"></table>
    <script type="text/javascript">
        var number = 31;
        var week = 0;
        if (week == 0) {
            week = 7;
        }
        var content = "<tr>";
        for(var i = 1; i <=number+week-1;i++){
            content += "<td>";
            if (i - week +1 >= 1) {
                content += (i-week+1);
            }
            
            content += "</td>";
            
            if (i % 7 == 0) {
                content += "</tr><tr>";
            }
        
        }
        content+= "</tr>";
        var x=document.getElementById("table");
        x.innerHTML=content;
    </script>


</body>
</html>


<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
    <script type="text/javascript">
        //当前时间
        var date = new Date();
        var year = date.getFullYear();
        var month = date.getMonth();
        date = new Date(year, month, 1);
        //当前时间的一号星期数
        var week = date.getDay();
        document.write(week);
        
        
    </script>
    
    
    
    
    
</body>
</html>



${EL expression}

---primary key主键 不能为空 唯一
---not null 不能为空
--auto_increment
--唯一约束 unique  可以为空

desc user;
drop table student;
drop table teacher;
create table 'student'(
'id' int(20) primary key auto_increment,
'name' char(20) unique not null,
'teacher_id' int(20),
'grade' int(20),
第一种
--外键约束
--被约束的表  添加数据 在另一个外必须有数据

--第二种约束
--主表删了 子表为空
foreign key(teacher_id) references teacher(id)on delete set null

--第三种约束
--主表一删  子全都删
foreign key(teacher_id) references teacher(id)on delete cascade
-- foreign key(外键名) references 从表名(主键)

);

create table teacher(
id int(20) primary key auto_increment,
name char(20)not null,
age int(20)
);
insert into teacher values(null,'李老师11111',2);
insert into teacher values(null,'李老师',2);
insert into teacher values(null,'龙老师',32);
insert into teacher values(null,'张老师',42);
insert into teacher values(null,'王老师',52);
insert into teacher values(null,'周老师',12);


insert into student values(null,'张三',1,85);
insert into student values(null,'李四',1,23);
insert into student values(null,'王五',2,45);
insert into student values(null,'赵六',3,100);
insert into student values(null,'张7',4,70);
insert into student values(null,'李八',1,10);
insert into student values(null,'周九',0,0);

select * from student;

select * from teacher cross join student;

select * from teacher,student;


select * from teacher inner join student on teacher.id=student.teacher_id;

select * from teacher,student where teacher.id=student.teacher_id;

select * from teacher,student where teacher.id=teacher_id;

select * from teacher,student where teacher.id=teacher_id and student.name='张三';

select teacher.name, student.name from teacher,student where teacher.id=teacher_id and student.name='张三';
--as 别名
select teacher.name as teacher_name, student.name as student_name from teacher,student where teacher.id=teacher_id and student.name ='张三';

select teacher.name as teacher_name,student.name as student_name from teacher,student where teacher.id = teacher_id and student.name = '张三';
--年龄小于40的老师的学生相关信息

select student.* from teacher,student where teacher.id=teacher_id and age<40;

select teacher.age ,student.name from teacher,student where teacher.id=student.teacher_id and teacher.age<40;

select student.* from teacher t,student where t.name=student.teacher_id and t.name='李老师';
--左右查询
select * from teacher t left join student on t.id=teacher_id;

select * from teacher t right join student on t.id=teacher_id;
--子查询
select * from student where teacher_id=();

select * from teacher where name='李老师';


select * from teacher where age<20 UNION
select * from teacher where name='李老师';

select * from teacher where name='李老师'or age<20;

select count(*) from student;

select count(id) from student;

select sum(age) from teacher;

select *,min(age) from teacher;

select * from teacher where age=(select min(age) from teacher);
--小于平均值
select * from teacher where age<(select avg(age) from teacher);

select * from student group by teacher_id;

select *,count(*) from student group by teacher_id;
--获取老师的学生
select t.*,count(student.id) from student,teacher t where t.id=student.teacher_id group by teacher_id;

--求每个老师的学生的平均分
select * from teacher;
select t.*,count(student.id),avg(student.grade)from student,teacher t where t.id=teacher_id group by teacher_id;

select t.*,count(student.id),avg(student.grade)from student,teacher t where t.id=teacher_id group by teacher_id;

select t.*,avg(student.grade) from student,teacher t where t.id = teacher_id group by teacher_id;

select t.* ,avg(student.grade)from teacher as t ,student where t.id<(select AVG(grade) from student as s  group by t.id = s.grade);


--数据库备份





数据备份

--mysqldump -u root -p imooc> D:\holle.sql
数据库恢复
--mysqldump -u root -p imooc< D:\holle.sql





select user.*,role.name as role_name ,department.name as department_name from user,role,department where role.id = user.role_id and department.id = user.department_id;
select email.*,user.name as sender_name,u.name as getter_name from email,user,user u where email.sender_id = user.id and email.getter_id = u.id;


drop table user;
drop table user;
drop table user;

-- 外键约束
-- 用户表user
-- 角色表role
-- 部门表department
create table user(
id int(4) primary key auto_increment,
name char(20),
names char(20),
age int(3),
password char(20),
sex char(2),
nation char(20),
edu char(20),
marriage char(20),
special char(20),
department_id int(20),
foreign key (department_id) references department(id),
role_id int(20),
foreign key (role_id) references role(id),
hobby char(20),
card int(20),
cellphone int(20),
proof int(20),
ids char(20),
adds char(20),
mail char(20)
);


create table role(
id int(4) primary key auto_increment,
name char(20),
star char(20)
);


create table department(
id int(4) primary key auto_increment,
name char(20),
des char(20)
);


----角色
--create table role (
--id int(20) primary key auto_increment,
--name char(20),
--star char(20)
--);
---- 部门
--create table department (
--id int(20) primary key auto_increment,
--name char(20),
--des char(20)
--);
--
--
--create table user (
--id int(20) primary key auto_increment,
--account char(20),
--password char(20),
--name char(20),
--role_id int(20),
--foreign key (role_id) references role(id),
--department_id int(20),
--foreign key (department_id) references department(id)
--);
insert into role values(null,'管理员','三星');
insert into department values(null,'后勤部','打杂的');
insert into user values(null,'123','123','123',null,null,null,null,null,null,1,1,null,null,null,null,null,null,null);
insert into user values(null,'456','456','123',null,null,null,null,null,null,2,2,null,null,null,null,null,null,null);
select * from user;
select * from role;
select * from department;

select email.*,role.name,d.name from email,role,department d where email.getter_id = role.id and email.sendr_id = d.id;      

select user.*,role.name as role_name,d.name as department_name from user,role,department d where user.role_id = role.id and user.department_id = d.id;


insert into role values(null,'管理员','三星');
insert into role values(null,'讲师','二星');
insert into role values(null,'班主任','一星');

insert into department values(null,'总务','老板');
insert into department values(null,'教学部','教学');
insert into department values(null,'后勤部','打杂的');


insert into user values(null,'admin','admin','123',1,1);
insert into user values(null,'123','123','李四',null,null,null,null,null,null,2,2,null,null,null,null,null,null,null);
insert into user values(null,'456','456','123',null,null,null,null,null,null,3,3,null,null,null,null,null,null,null);

select email.*,role.name,d.name from email,role,department d where Email.role_id = role.id and user.department_id = d.id;

select user.*,role.name as role_name,d.name as department_name from user,role,department d where user.role_id = role.id and user.department_id = d.id;

drop table email;
create table email(
id int(20)primary key auto_increment,
sendr_id int(20),
foreign key (sendr_id) references role(id),
getter_id int(20),
foreign key (getter_id) references role(id),
email_state char(20),
email_title char(20),
email_content text(1000),
email_time  TimeStamp
);

insert into email values(null,2,2,'草稿','最近可好!','发送卡纳圣诞快乐','2017-02-01 14:20:01');
insert into email values(null,3,1,'已读','最近可好!','发送卡纳圣诞快乐','2017-02-01 14:20:01');
insert into email values(null,4,1,'未读','最近可好!','发送卡纳圣诞快乐','2017-02-01 14:20:01');
insert into email values(null,1,2,'草稿','最近可好!','发送卡纳圣诞快乐','2017-02-01 14:20:01');

select email.*,role.name,d.name from email,role,department d where email.getter_id = role.id and email.sendr_id = d.id;
select email.*,role.name as role_name,d.name as department_name from email,role,department d where email.getter_id = role.id and email.sendr_id = d.id;



select email.*,role.name,d.name from email,role,department d where email.getter_id = role.id and email.sendr_id = d.id;




select email.*,role.name,d.name from email,role,department d where email.getter_id = role.id or email.sendr_id = d.id;



select email.*,role.name,d.name from email,role,department d where email.getter_id = role.id and email.sendr_id = d.id;




select user.*,role.name as role_name,d.name as department_name from user,role,department d where user.role_id = role.id and user.department_id = d.id;

select email.*,role.name as sendr_name,d.name as getter_name from email,role,department d where email.getter_id = role.id and email.sendr_id = d.id;



insert into email values(null,1,2,'哈哈哈','你在做啥子','nhsdfjkahjsd','2017-2-20 14:44:1');

select email.*,user.name as sendr_name,d.name as getter_name from email,user,user d where email.getter_id = user.id and email.sendr_id = d.id;

String name = request.getParameter("name");
        request.getSession().setAttribute("name", name);
        Drow drows=new Drow();
        List<Drow> list = new DrowDaoImp().searchAll();
        request.setAttribute("lists", list);
        
        if (name == null || name.length() <= 0 || name.length() > 11) {
            response.getWriter().append("登录失败，请重新输入手机号");
        } else if (name.equals(drows.getPhone())) {
            request.getRequestDispatcher("WEB-INF/index.jsp").forward(request, response);
        }else {
            response.getWriter().append("用户已存在");
        }
        /*Drow names = new DrowDaoImp().searchByName(name);
        System.out.println(names);*/
        
            
        }




http协议的无状态
当浏览器发送请求给服务器的时候，服务器客户端请求
但是当同一个浏览器在一次发送·请求给服务器的时候  服务器并不知道它刚才的那浏览器  

jsp状态管理
cookie  web服务器保存在客户端的一系列文本信息
作用：
判定注册用户是否已经登录
购物车 的处理

cookie：
对特定的对象的追踪
保证用户网页浏览记录与记录
简化登录
安全  容易泄露用户信息

创建cookie
cookie newCookie =new cookie(String key，object value)
写入cookie对象
response.addCookie(newCookie);
读取Cookie对象
Cookie[] cookies=request.getCookie();

Session                           Cookie
在服务器端保存用户信息             在客服端保存用户信息
Session中保存的是object类型        cookie保存是的String类型
随会话的结束而其存储的数据销毁      cookie可以长期保存客户端
保存重要的信息                      保存不重要的用户信息



include指令  include动作
<jsp:forward>动作
<jsp:param>动作
<jsp:plugin>动作
include指令
<%@ include file="url"%>

JUnit单元测试框架  多数Java开发
黑盒测试  把对象看做一个黑盒子  测试人员  完全不考虑程序内部逻辑结构和内部特征 只依据程序的需求说明书  
 
导入jar包
写计算器calculator 内部编写add minus mul aivide方法




#指定logger
# 配置Logger组件
# 设定Log4j的日志级别(error warn info  debug)
# 输出目的地(Console, logfile是appender的名字,是自己定义的,后面才赋予具体的含义)
log4j.rootLogger=debug, Console, logfile
###################################################################################################################
#指定appender(目的地)
#设定Logger的Console(appender的名字)的Appender类型为控制台输出
#org.apache.log4j.ConsoleAppender 表明 Console是控制台输出
log4j.appender.Console=org.apache.log4j.ConsoleAppender

#输出的格式
#设定Console的Appender布局Layout
#org.apache.log4j.PatternLayout（可以灵活地指定布局模式）包含选项：
#                     ConversionPattern=%m%n :指定怎样格式化指定的消息
log4j.appender.Console.layout=org.apache.log4j.PatternLayout

log4j.appender.Console.layout.ConversionPattern=%d %p %c.%M() - %m%n

###################################################################################################################
#设定Logger的logfile(appender的名字)的Appender类型为文件大小到达指定尺寸的时候产生一个新的文件
log4j.appender.logfile=org.apache.log4j.RollingFileAppender

#设定文件的输出路径(指定文件的名字和路径,tomcat的启动路径)
log4j.appender.logfile.File=../logs/logstrore.log

#设定后缀可以是KB, MB 或者是 GB. 在日志文件到达该大小时,将会自动滚动,即将原来的内容移到logstrore.log.1文件
log4j.appender.logfile.MaxFileSize=2048KB

#Keep three backup files.指定可以产生的滚动文件的最大数
log4j.appender.logfile.MaxBackupIndex=4

#设定logfile的Appender布局Layout
log4j.appender.logfile.layout=org.apache.log4j.PatternLayout
log4j.appender.logfile.layout.ConversionPattern=%d %p %c.%M() - %m%n
###################################################################################################################

Logger log=Logger.getLogger("log4j.properties");
        log.debug("我是info调试");
        log.info("我是info信息");
        log.warn("我是info警告");
        log.error("我是info错误");




log4j.appender.logfile.File=E:\\logs\\logstrore.log
必须手动创建文件夹







一、多线程可以解决什么问题？
      将耗时的、功能独立的模块通过开辟线程的方式解决。例如:优酷的APP等。
   Java 工程
二、什么是进程？什么是线程？
    Java是少数的集中支持多线程的语言之一，大多数的语言只能运行单独的一个程序块，无法同时运行不同的多个程序块，Java的多线程机制弥补了这个缺憾，它可以让不同的程序块一起运行，这样可以让程序运行更加顺畅，同时也达到了多任务处理的目的。

1、什么是进程？
   进程是：运行中的应用程序。Eclipse/QQ
   分配资源：内存(地址空间)和CPU
   一个进程包含一个或多个线程。

   知识分享：每个进程都有自己独立的一块内存空间，一个进程中可以启动多个线程。
   线程总是属于某个进程，进程中的多个线程共享进程的内存。“同时”执行是人的感觉，在线程之间实际上轮换执行。
   进程是程序（任务）执行的过程。执行过程--从字面上看，就是一个动态的过程，一个文件，一个安装包都不是进程，只有运行起来以后才是进程，才有了“生命”。

   持有资源（共享内存，共享文件）和线程。这里的资源指的是内存，程序一运行就开始消耗内存。
2、什么是线程？
   线程指：程序的执行序列。多个线程共享进程中资源。
3、多线程同时运行的理解：
    在Linux的内核处理过程中，每一个进程默认会有一个固定的时间片来执行命令（默认为1/100秒），这段时间内进程被分配到CPU，然后独占使用。
    如果使用完，同时未到时间片的规定时间，那么就主动放弃CPU的占用，
    如果到时间片尚未完成工作，那么CPU的使用权也会被收回，进程将会被中断挂起等待下一个时间片。
三、代码开始
    如何创建一个线程？
创建线程在java中有两种方式：
1、继承Thread类  Thread的构造方法
        从写run方法。
   Thread类不是抽象类，它继承了Runnable接口。
2、继承Runnable接口

    Runable方式可以避免Thread方式由于Java单继承特性带来的缺陷。
代码案例：循环打印数字，记得写上线程名字，翻阅API
public class Demo1 extends Thread {
    
    @Override  //把自定义线程的任务代码写在run方法中。
    public void run() {
        for(int i  = 0 ; i < 100 ; i++){
            System.out.println("自定义线程："+i);
        }
    }
    
    public static void main(String[] args) {
        //创建了自定义的线程对象。
        Demo1 d = new Demo1();
        //调用start方法启动线程
        d.start();
        for(int i  = 0 ; i < 100 ; i++){
            System.out.println("main线程："+i);
        }
    }
}

四、线程的常用方法
    run()方法：入口方法
start()方法：使该线程开始执行；Java 虚拟机调用该线程的 run 方法。
sleep()方法：线程休眠。参数：毫秒
join()方法：使其他线程等待当前线程终止。
yield()方法：静态方法，当前运行线程释放处理器资源
currentThread():返回当前运行的线程的引用。
getState()：返回该线程的状态。
getName():返回该线程的名称。
五、如何停止一个线程？
        不要使用stop方法，stop方法时java 1.0版本中的停止线程的方法，目前已经
过时，只存在于已经编写过的代码之中，因为它最大的缺点是另我们的程序戛然而
止，不能做后续的操作。
正确的停止方法：
使用退出标志。
举例：主线程中循环到80停止子线程。 详见小孩儿玩游戏的代码案例

六、线程安全问题
1）出现的条件：
1、存在两个或者两个以上线程对象，而且现场之间抢夺的是同一个资源。
2、有多个语句操作了共享资源。
如何解决线程安全问题：
方案一：同步代码块
    synchronized ("锁") {
           编写需要同步执行的代码
        }
    方案二：同步方法（函数）
        如果是一个非静态的方法，加上了同步锁的话，锁指的是当前的 this对象
       如果是静态的方法，锁指的是当前方法所属的类对象的字节码文件GetMoneyThread.class

   2）两种解决方案比较：优先选择同步代码块的方式
原因一：同步函数的方式是将整个方法中的代码全部加锁，效率低
原因二：同步函数的方式中的锁，不是我们自己指定的，系统带的，不方便。
 
   3）解决线程安全问题的总结：
不管是哪种方式，都会影响执行效率，能不用就不用，能少用就少用（包裹的代码数量）

七、死锁
案例：
if("gege".equals(Thread.currentThread().getName())){
              synchronized ("遥控器") {
                  System.out.println("哥哥拿到了遥控器，准备去拿电池");
                  synchronized ("电池") {
                     System.out.println("哥哥也拿到了电池，开心的看电视....");
                  }
              }
        }
        
        if("didi".equals(Thread.currentThread().getName())){
              synchronized ("电池") {
                  System.out.println("弟弟拿到了电池，准备去拿遥控器");
                  synchronized ("遥控器") {
                     System.out.println("弟弟也拿到了遥控器，开心的看电视....");
                  }
              }
        }
总结：
产生死锁的条件：
1、存在两个或者两个以上的线程
2、存在两个或者两个以上的共享资源（遥控器和电池）
解决方案：无解，只能避免发生。

八、生产者和消费者
 wait 等待   如果线程 了该方法，那么线程进入到一种等待状态，必须由另一个线程唤醒
 * notify:唤醒   唤醒线程池中的一个线程
 * notifyAll  唤醒线程池中的所有对象
 * wait 和 notify 方法需要注意的地方：
 1、wait和notify方式都属于对象Object
 2、wait和notify都必须在同步代码块儿和同步函数中才能够执行
 3、两个方法都必须由锁对象调用

package com.zhiyou.thread;

/**
 * wait 和notify 方法需要注意地方
 * 1.wait和notify方式属于object
 * 2.wait和notify 都必须同步代码块  和同步函数能够执行
 * 3.wait和notify必须要有锁对象调用
 * wait等待  如果线程执行该方法  那么线程进入等待状态  必须有另一个线程唤醒
 * notify 唤醒  唤醒线程池中的一个线程
 * notifyall  唤醒线程池的所有对象
 *
 *
 * */


//产品
class Product {
    String name;
    double price;
    boolean flag = false;
}

// 生产者
class Produter implements Runnable {
    Product p;

    public Produter(Product p) {
        this.p = p;

    }

    
    int i = 0;
    @Override
    public void run() {
        // TODO Auto-generated method stub
        while (true) {

            synchronized (p) {
                if (p.flag == false) {
                    if (i % 2 == 0) {
                        p.name = "鸡蛋";
                        try {
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                        p.price = 2.6;
                    } else {
                        p.name = "大蒜";
                        p.price = 1.1;
                    }
                    i++;
                    System.out.println("生产者产出了" + p.name + ":" + "价格是" + p.price);
                    // 通知消费者消费
                    p.notify();// p.notify 唤醒一个对象notifyall 唤醒所有对象
                    p.flag = true;

                    /*
                     * i++;
                     */
                } else {
                    // 等待消费者
                    try {
                        p.wait();// 休息一会
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
            /*i++;*/

        }
        
    }

}
// 消费者

class Consumer implements Runnable {
    Product p;

    public Consumer(Product p) {
        this.p = p;

    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        while (true) {
            synchronized (p) {
                if (p.flag) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println("消费者购买了"+ p.name + ":" + "价格是" + p.price);
                    // p.notify 唤醒一个对象notifyall 唤醒所有对象
                    p.flag = false;
                    p.notify();

                } else {
                    try {
                        p.wait();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }

            }
        }
    }
}

public class Demo01 {

    public static void main(String[] args) {
        Product product = new Product();
        Produter produter = new Produter(product);
        Consumer consumer = new Consumer(product);

        new Thread(produter).start();
        new Thread(consumer).start();
    }
}

银行家算法：package com.zhiyou.thread;


class SaleTicket extends Thread{
    
    
    static  int ticket=50 ;
    static  Object o=new Object();
    @Override
    public void run() {
        
        while(true){
        
        
        synchronized ("锁") {
            
            if(ticket>0){
            
                System.out.println(getName()+":卖出了第"+ticket+"张");
                ticket--;
                try {
                    sleep(1000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
              
            }else {
                System.out.println(getName()+":"+"票买完了");
                
            }
            
          }
        
        }
        
    }
    
}


public class TestScaleTicket {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        SaleTicket thread01=new SaleTicket();
        thread01.setName("窗口一");
        
        SaleTicket thread02=new SaleTicket();
        thread02.setName("窗口二");
        
        SaleTicket thread03=new SaleTicket();
        thread03.setName("窗口三");
        
        
        SaleTicket thread04=new SaleTicket();
        thread04.setName("窗口四");
        
        SaleTicket thread05=new SaleTicket();
        thread05.setName("窗口五");
        
        SaleTicket thread06=new SaleTicket();
        thread06.setName("窗口六");
        
        
        
        thread01.start();
        thread02.start();
        /*thread03.setPriority(Thread.MAX_PRIORITY);*/
        thread03.start();
        thread04.start();
        thread05.start();
        thread06.start();

    }

}

一、作业
   思路有多种：
第一种：验证码元素可重复
      获取随机数的两种方式：Math.random 取值范围[0,1)
      Random random = new Random();
      random.nextInt(6); 取值0到5
第二种：验证码元素不可重复
      实现方案一：数组替换，每次从数组的长度-1个中取，将最后一个替换取到的那一个。
      方案二：通过ArrayList方案
二、停止线程
      方案是：通过定义一个标志来解决
      如果线程中有等待wait(),需要在另一个线程（主线程）中先唤醒notify，再修改标志。
   也可以使用interrupt 方法，只是会捕获一个异常。
三、List
    
List接口中重点掌握：ArrayList
常用方法有：
  add（E） 添加一个元素
  ddd(index,E) 在某位置上添加一个元素，其他元素后移
  set (index,E)  替换某位置上的元素，集合长度不增加
      remove   list的长度会减一 ：切记
      get（index） 获取一个元素
     
   1、数组转List：
   //返回一个受指定数组支持的固定大小的列表
   List<Character> list = Arrays.asList('a','b','s','d','e','q');
   但是该List不能够增加和删除，只能读取。
   如果非要使用的话，可以重新编写一个List容器，将数值放进去
   List<Character> list02 = new ArrayList<>(list);
  Collections:
   Character [] a={'a','b','s','d','e','q'};
        List<Character> list = new ArrayList<>();
        Collections.addAll(list, a);
    2、将List转换为数组：
        Object[] arr = a2.toArray(); //将集合转化为数组
        System.out.println(arr[0]);

四、Map集合
    1、定义HashMap
       Map<K,V> map=new HashMap<K,V>();
       构造方法：初始容量16，最大值为2的30次方，默认加载因子0.75。
       这两个参数是影响HashMap性能的重要因素。
    2、常用方法：
       put(k,v) 添加一个元素
       get(k)   通过key获取Value
       remove(k) 通过key删除对应的键值对，返回值为Value
       size()   map的长度
       containsKey(K)  判断该K是否在map集合中，如何判断一个map中是否存在某个键  不能使用get(key)。
       containsValue(V)  判断该V是否在map集合中。
       putAll(map)     将一个map集合copy给两一个Map集合。 需要赋值的map.putAll(有值的map)。
       clear()  清空一个Map集合
       isEmpty() 判断一个map集合是否有键值对。
       values()  获取map集合的所有Value值，返回类型是Collection
    3、如何循环遍历（4种方法）
        a、keySet()+for循环
        b、keySet()+Iterator
        c、entrySet()+for循环
        d、entrySet()+Iterator
五、Set集合
    重点掌握：HashSet
    set集合的特点
      a、set集合是无序的，这个无序指的是HashSet
      b、TreeSet 集合是无序的，存储顺序可能并不是插入顺序
         TreeSet 集合是有序的，插入是的数据会按照某个逻辑进行排序
    
     HashSet :
        1、该集合具有互斥性，即：相同的元素不能重复添加
        2、hashset 默认容量是 其底层 HashMap 实例的默认初始容量是 16，加载因子是 0.75



import javax.swing.JOptionPane;
 
public class $ {
 
    public static void main(String[] args) {
 
        String answer = JOptionPane.showInputDialog("请您回答（是/否）");
        if ("是".equals(answer)) {
 
            // do some thing for a
            System.out.println("a");
        } else if ("否".equals(answer)) {
            // do some thing for b
 
            System.out.println("b");
        } else {
            System.out.println("输入错误");
        }
    }
}




maven 管理jar包   项目构建   导入 java jar Javaweb  war

管理项目  从生到上线