2016-07-23 周六
利用键盘输入的时候需要抛出异常 ，直接快捷键 ctrl + 1 ;
定义数组 int score[] = new int[4] ;
只有4个数字
BufferedReader br = new BufferedReader(new
InputStreamReader(System.in)) ;
String str = br.readLine()
;//直接输入，直接输出
score[i] = Integer.parseInt( str) ; //转换Str 为 Int
int temp
= Integer.parseInt(str); //字符串变为int型
String str = new String(b);
byte变字符串
Scanner scan = new Scanner(System.in) ;
冒泡排序： i=1;j=0 ;
for (int i = 1 ; i < 3 ;i++ ){
for(int j = 0 ; j< 3 ;
j++){
if(score[i] < score[j]){
int temp =
score[i] ;
score[i] = score[j] ;
score[j]
= temp ;
}
方法的定义: public static 返回值 方法名（类型 参数
， 类型 参数,）{
程序体 ；
（return) //可省略
}
类名定义： ArrayDemo (单词首字母大写)
方法定义： printInfo (第一个单词小写，后面的单词首字母大写 )定义的时候 char c[] = {'','','',''} ; 字符串都是单引号，字符都是双引号
float型的参数都是 3.2f,
使用
break 可以结束一层循环
使用 return 可以结束一个方法
方法的递归 ； return x + sum(temp)
;
栈中存放的是堆空间的地址； 中放的是名字，堆内存是实际数字
2016-07-24 周日
Java 的直接数组排序 java.util.ARRAY.sort() ;
Java 的直接复制数组
System.arraycopy(源数组，源数组开始位置，目标数组，目标数组开始位置，数组长度 ) ;
(说是复制，其实就是目标位置的数组的替换，将源数组的数字复制到目标数组的位置，目标数组的长度不变)
Java 新特性：foreach(数据类型 变量名：
数组名称) ; foreach (int x ; temp) ;
Java 新特性：可变参数：返回类型 方法名(类型... 参数) public void
fun (int... arg)
例： fun(new int[]{1,1,1,1,1}); //
传递参数可以直接传递
Java的多态性：方法的重载 ； 方法名同但是参数类型和参数的个数不同 ； System.out.println
也属于重载
对象的多肽 ：
子类对象可以和父类对象进行相互转换，而且根据子类的不同，完成的功能也不同
Java的封装性：对象的属性和行为看成整体，即对象；
信息的隐蔽
private 声明的属性或者方法只能被类的内部进行访问，而不能在外部被访问；
this的使用：
this.表示当前对象，this必须发放到构造方法的首行
this调用构造方法时一定要保留一个构造方法作为出口，也就是有一个构造方法不调用this();
this.方法名()
强调是本类中的方法；
this.属性 强调是本类中的属性；
Java的继承性：拥有一般特性的事物，在基础上 派生其他；
类 ： 成员变量声明 + 方法定义：
构造方法：
在实例化的时候就可以进行赋值，而不是调用setter 和 getter 方法 //也即是说，只是一个赋值的过程，没有返回值
方法名与主类同； 不能有返回值类型声明； 不能有return语句；默认 default
类型
匿名对象：没有明确给出名称的对象；一般只使用一次，而且直接开启堆空间，不存在栈空间的索引；
new
Person("zhangsan",12).tell() ;
String
本身就是一个类，但是我们一般用的String没有开辟栈空间，比较的只是堆空间的值；
一个字符串本身就是一个String的匿名对象；
“==” 比较的是开辟的空间，而不是内容；
equal()
比较内容是否一致；
String 里面indexOf本身就可以比较内容 是否相等， 他是找到内容，然后返回字符所在位置，
!(indexOf("hello"))!= -1 表示找到
一个String对象内容的改变实际上是通过内存地址的更新完成的，本身的字符串内容不会变；
char[] toCharArray()
;//转换为字符数组 charAt() //特定的位置取值 String split()//按照指定的字符串分割
String
subString()指定字段取值 equals(), equalsIgnoreCase()
split 和
raplaxeAll() 支持正则表达式；，返回时一个 String s[] =
indexOf :
从指定位置开始查找字符串位置，没有找到就返回 -1 ；
charAt ： 取出指定位置的字符 trim()
:去掉左右的空额
length 和 length() 在数组中,length是长度，String操作中是函数，需要length()
;
引用传递： 就是将一个堆内存空间的使用权交给多个栈内存空间
接受本类的对象： public void
fun(Demo d2)
2016-07-28 周四
Java的内存区域：
栈内存：保存所有对象的名称（堆地址的内存空间）
堆内存：保存每个对象的属性内容
全局变量： static类型属性
全局代码段：保存所有的方法定义
Static关键字：堆内存保存对象，可以用static共享属性
static声明属性的又称为类属性，因为类的公共属性应该由类来修改，毕竟用户不知道到底会有多少对象产生；
static String
count = "ad"; Person.count = "bc";
static声明的方法又称为类方法，可以用类名调用；
public static setName(String name) ;
Person.setName("lvfengtao") ;
static应用，可以查看定义了多少给
实例化对象；
System.exit(1) ; //可以直接退出程序，设置非0数字
代码块：
普通代码块：{}括起来的，直接在方法或者语句中设置的
构造代码块：直接写在类中的代码块 //只有一行代码
静态代码块：用static声明的代码块
静态代码块优于主方法执行，类中的静态代码块优先于构造块执行，且只执行一次，不管产生几个对象
构造方法私有化： private 方法名()
构造方法一旦私有化，就不能new调用，就必须从内部调用
一种是static 属性，另一种是static
方法，返回实例，通过类.方法名调用；
单例设计模式：
无论程序怎么运行，始终只有一个实例化对象存在，只要将构造方法私有，就可以对控制实例化对象的产生；
数组一定要先开辟空间，因为是引用类型
主方法的String
args[] 本身就是一个类，主方法中的参数本身就是以对象数组的形式出现的；
内部类： 在类的内部在定义一个类
缺点：类由属性和方法构成，所以会破坏类结构
唯一的好处就是可以访问外部类的私有属性；
用static声明的内部类变成了外部类，但是不能访问非static声明的外部类属性
在外部访问内部类
外部类.内部类 内部类对象 =
外部类实例.new 内部类() ;
private
定义是在一个类里面都可以访问，所以内部类可以直接访问外部类的属性；
使用statIC声明的内部类就会成外部类，使用static声明的内部类不能访问非static声明的外部类
在方法中定义一个内部类
在方法中定义的内部类不能直接访问方法中的参数，如果发放中的参数想要被内部类访问，就必须在参数前加final关键字
2016-07-30 周六
使用构造方法的时候，一定是this.setName(name); 继承的时候是，super(age,name); Getter方法中：return
school;
关于输出，最好是在类中返回String方法，然后在主类中 System.out.println(实例化对象.方法名) ；6.1 继承类(派生类)
Java只允许单继承，一个子类只允许有一个父类，允许多层继承，一个父类还有一个父类；
子类是不能调用父类的私有成员，子类可以调用父类的非私有 方法，但是不能直接调用父类的私有成员，但是可以通过setter和getter；
子类实例化对象之前，先调用父类的构造方法，后调用子类的构造方法，实际上子类的构造方法中隐藏了super()方法【超类】
子类不能拥有比父类更高级的访问权限
6.2 this 和 super 区别：
1.this
只能调用本类的属性、方法，本类中没有则父类查找 super 访问父类的方法，方法
2.this 调用本类构造， supe
调用父类构造，且放在子类首行
3.this 表示当前对象
6.4 final :完结器
，final声明的类不能有子类，声明的方法不能被覆写，声明的变量为常量，不可以修改
final声明的变量必须全部大写； public static
，final String NAME = "Lvfengtao";
6.5 Abstract 抽象类：
抽象类是一种模板，必须被继承才能用，一个子类只能继承一个抽象类
包含一个抽象方法的类是抽象类； 抽象类和抽象方法必须由abstract声明；
抽象方法只需声明，不需要具体；
抽象类必须被继承，子类必须前部复写抽象类中的全部抽象方法 public abstract void
print();
抽象方法不要使用private声明，因为必须被覆写，子类不易复写；
抽象类可以定义构造函数，所以子类实例化之前必须对父类进行实例化，也就是说先必须给打印父类的构造方法然后子类的构造方法
子类可以通过super()方法调用抽象类(父类)的构造方法,也可以在子类调用父类指定参数的构造方法
子类 extends 抽象类
implements 接口A， 接口B
6.6 接口： 特殊的类，由全局常量和公共的抽象方法组成 // 接口本身已经定义，所以不需要在写 public
static fianl 和 abstract ;
由于明确规定了抽象方法是public
类，所以也不需要在写；
接口与抽象方法一样需要子类的继承
implements，一个子类可以实现多个接口，摆脱继承的单继承
全局常量，在接口里定义的时候用大写
Java允许一个抽象类实现多个接口，但是一个接口不允许继承抽象类， 允许一个接口继承多个接口
接口的继承： interface A
extends B, C
interface A {
public static final String INFO =，
"Lvfengtao" ==== String INFO = "Lvfengtao"
public
abstract void print() ========== (public)void print()
//全局常量；
抽象方法； //必须是public方法，写与不写，Java的接口方法都是pblci
}
6.7
对象的多态性
表现： 1、方法的重载和覆写
2、对象的多态性
（向上转型：子类--> 父类 ； 父类 父类对象 =
子类实类
向下转型：父类 --> 子类，且必须说明向下转型的子类类型） 子类 子类对象 =
（子类）父类实例
** 对象是Object类型，需要转型 String str =
(String)obj[i];
2016-08-02 星期二
6.12 包装类； Java数据分为基本数据类型和引用数据类型,
用的最多的还是讲字符串变为数据类型（int i=
Interger.parseInt("1234")）；
(字符串变为数组的时候需要抛出异常)
拆箱 和装箱：
Interger i = new Interger(x); int x = i.intValue();
Integer i = 0 ;//自动封装 int x = i; //自动拆箱
7.1
异常的基本概念
Java的异常都是以类和对象的形式存在，Java的错误主要是语法和语义的错误，编译的时候没有报错，但是运行的时候也可能报错
Try()
找到错误后会跳转到 catch里面，一旦产生异常，则首先回产生一个异常类 的实例化对象，
Exception 和 Error 都是Java
Throwable的异常类
通常用e.printStaceTrace()方法打印异常信息，所有的额子类的实例都可以用父类来接受，所以可以调转
7.2 throws 和
throw关键字
throws声明的方法，表示此方法不处理异常，而是调用方法去处理；
2016-08-03 星期三
9.1 多线程： 继承 Thread类【要覆写run()】或者实现Runnable类 // 都需要覆写run()方法
由于受到单继承的影响，所以一般多线
中程是通过
同时可以调用父类start()方法，实现多线程，说是调用start()方法，但是调用的却是run()方法的主题
一般重复调用start()方法回抛出异常，而且本质上调用
start0()这个方法，因为使用了native声明，所以需要依靠底层的操作系统支持
实现Runnable()方法，需要实现多线程，可以利用Thread类中设定的方法启动多线程
Thread类也是Runnable接口的子类，但是Thread并没有完全的实现Runnable接口的run() Thread 构造方法 Thread
thread = new Thread(接受 Runnable的子类，设置线程名称 )
继承Thread类并不能实现资源共享，如果想要资源共享必须实现Runnable接口
避免单继承带来的局限性；
代码能与多个线程共享，代码与数据是分开的；
9.2 线程的状态： 创建 、就绪、 运行、 阻塞、 终止
getName: 取得线程名称；
setName： 设置线程名称
main()本身也就是一个线程，每次Java运行都至少启动2个线程，一个main,一个垃圾回收
main()方法可能比其他方法更早执行；
public static Thread currentThread():
返回当前执行的类
public final String getName(): 返回线程名称
public final int
getPriority(): 返回优先级 1 5 10
public boolean isInterrupted():
线程是否中断；
9.3 Thread类中有一个方法: 利用 构造函数可以直接命名线程 子类实例化以后就可以直接start
Runnable,需要 子类实例化对象，然后调用Thread调用start方法
9.6
解决资源同步问题：1、使用同步代码(Synchronized(同步对象 this)
2、同步方法
多线程 共享同一资源的时候需要同步，但是过多会产生死锁；
方法的完整定义：
public/default/private/protected final static syncronized 返回类型 方法名（参数类型
参数名称） throws EXCEPTION{ return [返回值/返回调用处]}
死锁：
同步可以保证资源共享的正确性，所谓死锁就是2个线程都在 等待彼此完成任务，造成程序停滞
2016-08-06 星期六
new String(bInput); //byte数组变为字符串 byte[] b =
str.getBytes();
int i = Integer.parseInt(str); //字符串变整数 {\\d4}必须
数字出现4次
(^\\d+.?) 正则表达式匹配小数 ,? 表示小时代可以出现一次或0次
[a-zA-Z0-9]字母数字
\w 字母、数字、下划线 ^\\d{4}-\\d{2}-\\d{2}$:年与日
[abc]: 字符abc [^abc]:
除了abc之外的任意字符 \d ：数字 \D: 非数字 \w：字母、数字、下划线 \s:所有空白字符
X？：出现0次到1次
X*:出现0次，1次，多次 X+：出现1次或多次
X|Y： 先X或Y XY：先X后Y
正则表达式需要Patter和Matcher两种类完成, Patter类主要进行正则规范Matcher主要执行验证
Patter.complie("[0-9]+").matcher(str).matches();
Patter p =
Patter.compile("[0-9]+");
Matcher m = p.matcher(str);
m.matches();
12.16 序列化
实现Serializable接口，还需要依靠对象输出对象和对象输入流
对象输出流(ObjectOutputStream): 实现序列化
构造方法(传入输出对象)：ObjectOutputStream(OutputStream out)
普通方法(输出对象)：
writeObject(Object obj)
File file = new File("E:" +
File.separator + "test.txt");
ObjectOutputStream oos =
null;
OutputStream os = new
FileOutputStream(file);
oos = new
ObjectOutputStream(os);
oos.writeObject(new
People("People",21));
oos.close();
实现Externalable接口，还需要依靠对象输出对象和对象输入流
public void
readExternal(ObjectInput input) // 读取需要的 内容
{
this.name = (String)input.readObject(); //需要转换
}
public
void writeExternal(ObjectOutput output) // 写入需要的 内容
{
output.writeObject(this.name);
}
transient: 声明
的关键字不可以被序列化13.1 认识类集
:动态完成对象数组操作，是动态的对象数组，是对一些实现好
的数据结构的包装，不受对象数组长度限制；
特点:对基本类集（动态数组、连接表、树）实现是高效的
框架允许不同类型的类集以相同的方式和高度
Collection:
接口，存放一组单值(集合中的每个元素都是一个对象)的最大接口，
List: Collection
子类接口，堆Collection扩充，允许内容重复
Set: Collection
子类接口，没有对Collection扩充，允许内容不重复
依靠hashCode()和equals()两个方法区别
Map； 存放一对值得最大接口，Key -- >
Value
Iterator:集合的输出接口，用于输出集合中的内容，胆小
ListIterator: 可以双向输出
Enumeration: 输出指定集合的内容
SortedSet: 单值的排序接口，可以使用比较器排序
SortedMap：存放一对值得排序接口，按照key值比较
Queue: 队列接口，可以实现队列操作
Map.Entry:
Map.Entry的内部接口，每个Map.Entry对象都保存这一对 key -->
Value的内容，每个Map接口都保存很多Map.Entry接口实例
List<String> list = new
ArrayList<String>() ;
System.out.print(list);
2016-08-07 星期日
13.1 String str[] = list.toArray(new String[]{});
//后面的{}实为初始化
indexOf() 找不到返回-1 找到显示位置
ArrayList 和 Vector区别：
ArrayList是异步处理方式，性能高，非线程安全操作类，使用Iterators
LinkedList子类和Queue接口
LinkedList表示一个链表的操作类， ListedList<> l =
new ListedList<>();
poll()方法找到首字母并回删除首节点， peak()
找到首字母
Queue表示的是队列操作接口，采用FIFO方式操作，for(int i; i<
list.size()+1
set：
散列存放：HashSet：
set<String/也可以是个类名> s = new
HashSet<String/也可以是类名>();
System.out.println(set);
//自主调用toString()方法
有序存放：TresSet
类中的每一个对象所在的类都必须实现Comparable接口才可以使用；
TreeSet自定义排序是一定要继承Comparable类，复写Comparto()方法，
public
int compareTo(Person per)
但是比较器比较的时候，如果某个属性没有进行比较的指定，也会认为是同一个对象，所以应该增加按照姓名比较；
return this.name.compareTo(per.name);
去除重复元素：
主类不需要继承TreeSet,但是需要复写equals方法，编写hashCode方法
13.6 集合的输出
如果要输出Collection、Set集合中的内容，可以将其转换为对象数组输出，而List则可以直接使用get()方法输出；
常用的类集合为:
Iterator: 迭代输出(判断元素是否有内容，有就输出)
ListItarator: Iterator的子接口，专门用于输出List
Enumeration:
旧接口
2016-08-08 星期一
13.6.1
Iteration: Iterator是一个接口，直接使用Colletion定义的
itreator()实例化；同理List和Set也实现了此方法
hasNext():
返回boolean,判断元素是否有内容，
next():输出,取出内容
ListIterator：
只能通过List实现实例化，只能输List内容
hasPrevious(): 判断是否有上一个元素
pervious(): 取出当前元素
nextIndex(): 返回下一个元素的索引
previousIndex(): 返回上一个元素的索引
set(): 替换元素
实现ListIterator接口双向输出时，如果想完成右后向前输出，则一定要先右前向后输出；
forEach: for (String str:
list)//(类 对象：集合){}
13.7 Map接口
Map<K,V>:
clear(): 清空cler()
containKey(): 判断指定key是否存在
set<May.Entry><K,V> entrySet(): 将Map对象变为Set集合
Map.Entry是Map内部定义的一个接口，专门保存key->va
可以由外部通过“外部类.内部类”直接调用
Map内容是K-V形式保存，实际上K-V是把数据保存在M.E之后
Map输出数据的时候必须使用M.Entry接口
V get(OBJECT key): 根据key 取得Value
set<K> keySet(): 取得所有key
Set<String> set =
map.keySet();
Collection<V> value(): 取出全部value
V
put(K kye, V value): 向集合中加入元素
putAll<Map<? extends K, ? extends
V>t> 一个Map集合加入到另一个
13.7.1 Map接口常用的类
HashMap：
无序存放，新的操作类，key不能重复
HashTable: 无序存放，旧类操作，key不能重复
TreeMap：有序Map集合，按key排序，不允许重复
WeakHashMap： 不再用的内容青岛湖
IdenHashM： key可以重复
Map接口的使用注意事项：
1.不能直接使用迭代输出Map内容，因为Map 存放一对值，Iterator只能输出一个
2.Map很少作为直接输出的额，只是用作查询
3.直接使用非系统类作为key
2016-08-28 星期日
//利用indexOf判断某个字符是否存在 也可以用
//replaceAll （源数字 ， 目标数字)
直接替换
//System.out.println(str.charAt(8));
取出第8个字符
继承父类以后调用父类的构造方法：super(name, address, sex, age);
输出父类的属性：
super.toString()
代理模式： 代理和真实主题均要实现接口，在代理中实现真实主题实例化(构造方法中实现)
工厂模式:
其他了均实现接口，定义一个类专门获取实例，不是构造方法获得
适配器模式：接口定义方法，
构造方法实现此接口，方法体为空，后子类继承抽象类，有选择的复写方法
观察者模式： 要被关注的继承Obserable类，调用父类方法
super.setChanged(); super.nosuper.notifyObservers() 观察着实现
Observer接口，在update类中，判断是否是一个类，输出即可
//这些接口呢都需要用到多态性，都是 接口 接口对象 = new
子类对象()，实现向上转型，转型后可以调用子类复写父类的方法
如果需要向下转型，则调用子类自己的方法，但是需要先向上转型后， instanceof
比较对象；//如果要进行字符串的拆分，利用split方法
Pattern p = Pattern.compile("[a-zA-Z]");
String
s[] = p.split(str);
//如果需要正则表达式来进行字符的替换，
String str =
"123231m3m123m123m123m12";
Pattern p =
Pattern.compile("[a-zA-Z]");
Matcher m = p.matcher(str);
String ss = m.replaceAll("_");
、、以上方法String都有支持的 boolean matches(String
regex); String[] split(); String replaceAll(String regex, s)
2016-08-30 星期三
时间类： SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd
HH:mm:ss:SSS");
sdf.format(new Date()) ;
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Date temp
= sdf.parse(str);
字符串拆分：
String str = "<html xmlns=\"http://www.w3.org/1999/xhtml\">";
str = str.substring(str.indexOf(" ")+1, str.indexOf(">")).replaceAll("\"", "
").replaceAll("\\.", " ").replaceAll("/", " ");
字符串内输入双引号： \"
定时调度：
Timer类：
是一种线程设施，可以定时安排一个时间，与TimerTask(实现由TImer安排的一次或重复执行的某一个任务)配合使用
IO操作：
File打开文件--> 字节流制定位置-->读写--> 关闭流
FIle类：文件本身操作
boolean
createNewFile();
boolean exists();
boolean
isDirectory();
String[] list();
File[]
listFiles();
boolean mkdir();
boolean renameTo(File
dest); //已有文件重新命名
RandomAccessFile类：随机读取类（一般不用）
RandomAccessFile(File file, String mode) //file路径
RandomAccessFile(String path, String mode)//固定路径
close():
关闭操作
void writeBytes(String s): 字符串写入文件
void writeInt(jint
v)
int read(byte[] b): 将内容读取到一个byte数组
byte readByte():
读取一个字节
int readInt(): 读取整数型
int skipBytes(int
n):指针跳过多少字节
void seek(long pos): 指针位置
所有数据都是已流的方式传输或保存，分字节和字符
字节流：以byte为准，需要将字符串转为Byte数组
OutputStream
OutputStream out = new
FileOutputStream(file);
OutputStream out = new FileOutputStream(file,
true);追加内容
String str = "\r\nHEllo world"; 文件需换行，可以加\r\n
byte[] b = str.getBytes();
out.write(b);
out.close();
InputStream:
int avaliable();
//取得文件大小
int read();//以数字的方式读取
int read(byte[] b)
；内容读取到byte数组
InputStream input = new
FileInputStream(file);
byte[] bb = new byte
[(int)f.length()]
//byte[] bb = new byte[1212];
//int len
= input.read(b); //取出内容到byte数组,确定输出多少
while(input.read()!=-1)
{
b[len] = (byte)
temp;
len++;
}
input.close();
System.out.println(new String(b, 0, len));
一个字符2个字节；
字符流：
Writer 子类： FileWriter
可以添加对象， Writer writer = new
FileWriter(new File(), true);
write(String str) 字符串输出
write(char[] c) 字符数组输出
flush() 强制清空缓存
Reader 子类 FileReader
int read()
int read(char[] c):
内容读取到字符数组，返回长度
字符的输出： new String(c, 0 ,len)
读取字符串有2中方法：
直接从文件读取
for循环 读取一个字节 int len =
0；
int temp = 0;
//接收每一个内容
while((temp =
reader.read())!=-1)
{
c[len] =
(char)temp;
len++;
}
字符流使用了缓冲区，字节流没有使用缓冲区(内存区域)；
不关闭时也将字符内容输出，可以使用Writer类的flush()方法打印流： PrintStream() 和 字符打印流()
2016-09-03 星期六
1.Serializable(Serializable)
一个类的对象要想被序列化(一个对象变为2进制，方便存储和传输)，就必须实现Serialiable接口，依靠ObjectOutputStream()和ObjectInputStream()
Java序列化的时候会产生一个序列化ID，通过JVM实现
File file = new File("F:" +
File.separator + "hello.txt");
OutputStream out = new
FileOutputStream(file);
ObjectOutputStream oos = new
ObjectOutputStream(out);
oos.writeObject(new
Person("lisi"));
ObjectInputStream ois = new
ObjectInputStream()
oos.close();
InputStream input
= new FileInputStream(file);
ObjectInputStream ois = new
ObjectInputStream(input);
Object obj =
ois.readObject();
ois.close();
2.
Externalizable是Serializable子类，实现此接口的可以用户自己制定被序列化的内容
writeExternal(ObjectOutput ot): 指定要保存的属性信息，对象序列化时调用
readExternal(ObjectInput in): 读取被保存的信息，反序列化用
以上2个方法都是DataOutput 和
DataInput接口的子类
public Person(){};
public Person(String
name)
{ this.name = name; }
//读取属性，有一个强制转换的要求
public void readExternal(ObjectInput
input)
{ this.name = (String)
input.readObject();}
//保存name属性
public void
writeExternal(ObjectOutput output)
{
output.writeObject(this.name); }
一个类要使用Externalizable实现序列化，此类必须有一个无参构造方法，因为在反序列化的时候会默认调用无参构造实例对象
3.
transient：关键字表示对象的某一个属性不希望被序列化
4. 序列化一组对象：
对象输出时只提供了writeObject(Object
obj))，并没有多对象输出，所以要实现同时序列化多个对象，就可以使用对象数组操作。
因为数组属于引用类型，可以用Object类型接收
5. List Set(重复内容依靠hashCode() 和
equals()方法区别) Queue SortSet(对集合中的数据进行排序)
List:接口
add(int index, E element)
addAll(int
index, Collection<? extends E> c) 添加一组元素
E get(int
index)
ListIterator<E> listIterator()
E
remove(int index)
E removeAll(Collection<?>
arg0)
List<E> subList(int fronIndex, int
toIndex)
E set(int index, E element)
toArray():
集合变为对象
size(): 返回集合的长度
get(int index):
返回当前的位置的数字
for(int i = 0; i < allList.size();
i++)
{
System.out.print(allList.get[i] +
"、");
}
LinkedLis：链表操作类
addFirst(E
e );
addList(E e);
boolean offer();
E removeFirst()
Queue:先进先出
E element()：
找到表头
E peek() 找到不删除;
E pool() 找到后删除;
利用此方法先进先出输出数字
E remove() 检索并移除表头
Set：HashSet && TreeSet
HashSet:
无规律可循
TreeSet:
有规律
如果是比较对象，则需要继承Comparable接口，实现CompareTo()方法
class Person implements
Comparable<Person>//接口处定义泛型类型
public int compareTo(Person
per) {
if ( this.age > per.age)
{
return 1;
}
else
if (this.age < per.age)
{
return
-1;
}
else
{
return 0;
}
比较器操作时如果某个实现没有进行比较，则默认为是一个对象
如果实现了HashSet,则所有的重复对象也会继续出现，就需要复写Object类的equals()方法和hashCode()方法，一个对象编码表示一个对象
SortedSet: TreeSet继承SortedSet
SortedSet<String> set =
new TreeSet<String>();
first(); last();
SortedSet<E> headSet(E element):开始到指定位置
SortedSet<E>
tailSet(E element):指定到最后
//可以用get()方法输出数字
Iterator:
Iterator iter = list.iterator();
ListIterator:
由前向后： hasNext() && next()
有后向前： 利用hasPrevious()方法由前向后判断，用previous取出元素
set() 和 add()
可以更改和添加元素
foreach输出：
for (类 对象： 集合) {};
for（String str: all)
Map：HashMap &&
TreeMap
put(Object key， Object obj): 添加数据
get():
根据key值取得value的值
Map<String, String> map = new
HashMap<String, String>();
Set<String> keys =
map.keySet();
Iteration key =
keys.iterator();
while(key.hasNext())
{
String str = key.next();
System.out.println(map.get(str）);//根据key 取值
}
map.get（iter.next()）
containKey():
判断指定的key是否存在
keySet():
将一个Map中的key变为Set集合，然后利用Iterator输出
values():
返回Collection，注意定义泛型类型
Collection<String> col =
map.values();
Iteration valus =
col.iterator;
while(values.hasNext()){};
Map接口注意事项：
1.
不能直接使用迭代输出Map中的全部内容，因为Map存放的是一对值，Iterate只能每次找到一个值，如果非要迭代输出，则必须：
1> Map实例通过entrySet()方法变为Set接口对象
2>
通过Set接口实例化Iterator、
3>
Iterator迭代输出，每一个ie内容都是Map.Entry的对象
4> 通过Map.Entry进行
key --> value分离
(Map中的每对数据都是通过Map.Entry保存的，所以也是Map.Entry输出)
Map<String
,String> map = null;
map = new HashMap<String,
String>();
map.put("04122077",
"吕峰涛");
map.put("04122076", "吕峰");
` Set<Map.Entry<String, String>> set =
map.entrySet();
Iterator<Map.Entry<String,
String>> iter = set.iterator();
while(iter.hasNext())
{
Map.Entry<String, String> me = iter.next();
System.out.print( me.getKey() + "--> " + me.getValue() +
"\t");
}
SortedMap:
排序接口，实现此类都是排序的子类，例如TreeMap
Comparator<? super K>
comparator();
K firstKey(); K lastKey();
SortedMap<k, V> subMap(K fromKey, K endKey)
SortedMap<K, V> tailMap<K fromKey): 返回大于指定key的部分集合
Collection:
addAll(): 为一个集合增加内容 Collection.addAll("ARRAY",
"BufferedReader");
reserve():
binarySearch(): 返回内容位置
sort(); 排序
swap():
交换我ie之
Stack: 先进先出
push:
进站
pop: 出战
int search(Object o):
在战中查找
Properties:
new
Property().setProperty("key", "value");
store(OutputStream
out, String comment, String encoding);
list(PrintStream out):
loadFromXML(InputStream in):
storeToXML(OutputStream out)
2016-09-05 星期一
1. Class类方法
Class<?> forName(String Name):
传入完整"包.类", 实例化Class对象
c1 =
Class.forName("com.huawei.ftl.X");
System.out.println("类名称： " +
c1.getName());
也可以通过类.class或者对象.getClass()实力化Class类
实例化后可以通过newInstance()实例化对象，注意转换类型
per = (Person)
c.newInstance();
（以上注意一点，就是类中必须由无参构造方法）
Construtor[]
getConstructor: 得到类中所有的构造方法
Field[] getDeclaredFields():
得到继承来的类
Class[] getInte
2016-09-10 星期六
JavaWeb
HTML注释语句： <!-注释语言->
1. JS的事件处理： body
(onLoad()="start()" onUnload()="stop()" onClick="fun()")
onSubmint():事件在提交之前先验证
onCHange(): 变化
文本处理：
var value = document.form.content.value;
//精确到具体的name值，然后取值，否则为空2.3.3Window对象
window.location: 定位到对应网页
window.open: 打开网页设置
HTML：
表达式完成交互的收到，表单元素写在《form>里面
JavaScript是基于对象的语言，function是函数，又返回值直接返回return即可。
3.1 XML：
可扩展性标志语言，实现数据交换，系统配置，内容管理。
XML语言是以<? ?> 开始和结束的
version：
encoding：编码
standalone: 是否独立运行，
XML声导固定格式
<?xml-stylesheet type="text/css" href =
"attri.css"?>
<![CADATA[里面的内容不解析]]>
3.2 XML解析：SAX
&& DOM(文档对象模型)
4个重要的额借口：
Document：整个XML文档，根节点
Node：每一个Node代表一个节点
NodeList：节点的集合
NamedNodeMap：一组节点和其唯一名称对应关系，属性节点
NodeList getElementByTagNsme();取指定节点名
Element
createElement(String tagName):创建指定名节点
Dom4J：利用工具来读写文件
Document doc =
DocumentHelper.createDocument();
Element addresslist =
doc.addElement("addresslist");
Element linkman =
addresslist.addElement("linkman");
Element name =
linkman.addElement("name");
name.setText("吕峰涛");
OutputFormat format =
OutputFormat.createPrettyPrint();
format.setEncoding("GBK");
2016-09-11 星期日
1.创建目录-->
WEB_INFO--> 复制WEBapps/ROOT/web.xml到虚拟目录下
Tomcat修改端口：conf/server.xml
虚拟目录：复制web.xml
<content path="/mldn" docBase="虚拟目录地址"/>
修改conf/web.xml
listings的false修改为true;
2xx:请求成功
3xx:重定向
403：禁止
404：找不到文件
500：服务器内部错误
Tomcat是个Web容器
2.JSP学习
JSP的命名采用小写，且最终都是以*.class完成
request.getParameter()方法接受输入内容。
2016-09-11
1. JavaBean；一个类只包含属性，setter,getter方法
POJO:
简单的Java对象
VO： 专门传递值
TO： 传递对象
2. 数据库操作：
pstmt = conn.prepareStatement(sql);
pstmt.setInt(1, tid);
(注意顺序，一定是先执行语句，然后设置变量)
2016-09-18
1.抽象类的使用： Person per = new
Student("lvfengtao", 12o, 99.9f);
抽象类中定义抽象方法为public， 不用写方法体 public
abstract void say();即可；
2.工厂模式中在工厂类中定义了一个静态方法来获取接口的实例；
public
static Fruit getInstance(String name)
3.代理模式； Network net = new Proxy(new
Real());}
2016-10-02 星期日
1. 使用Dom4J 生成XML文件，XML主要是用于数据交换
Document创建一个DOC文档，一个文档只有一个根节点
Element添加元素，
OutputFormat完成格式化，设置为中文格式。
XMLWriter完成数据的写入
OutputFormat format = OutputFormat.createPrettyPrint();
XMLWriter
writer = new XMLWriter(
new
FileOutputStream(
"G:" + File.separator +
"new2016.xml"), format );
writer.write(doc);
writer.close();2. JS操作XML
JS点击显示文字：
document.getElementById("info").innerHTML =
"<h2>www.MLDNJAVA.cn</h2>" ;
JSP注释：
1.<!--注释内容--> 显示注释客户端可以看见
2.<%--注释内容--%>; /*
*/ // 隐式注释
Scriptlet：3种方式
1.<% %> :
定义局部变量
<%!%>： 全局变量，类，方法
<%=%>:
输出一个变量
2.标签：<jsp:scriptlet> 代码块
</jsp:scriptlet>
Page: langua="Java" contentType="text/html"
pageEncoding="GBK"
必须是text/html 因为conf/web.xml写了这个
2.错误页面显示：
<%@ page isErrorPage = "true"%>
isErrorPage (注意大小写)
<%@ page errorPage="error.jsp"%>
属于服务器端的跳转
Include：包含指令：
1.静态包含： <%@ include file= "" %>
2.动态包含：<jsp:include>:自动区分页面静态还是动态
<jsp:include page
= "{包含文件路径 | <%=表达式%>}" flush = "true/false"/>
<jsp:param name="参数名称" value="参数内容"/>
</jsp:include>
静态是先包含后处理，动态是先处理后包含
跳转：
<jsp:forward page = {""}>
2016-10-04 星期二 JSP
中文问题：
HTML：<meta http-equiv="Content-Type"
content="text/html;
charset= utf-8 "/>
REQUEST：如果获取返回的值，可以设置
request.setCharacterEncoding("utf-8");
1.JSP内置对象 (9个，out, request,
session(保存用户信息), application(所有用户的共享信息), response,
pageContext(JSP页面容器))
4个属性：page(一个页面保存，调整失效),
request(只在一次 请求保持),
session(再一次会话范围内，任何跳转都行，新开浏览器失效),
application(服务器保持)
公共方法： setAttribute(), getAttribute(),
removeAttribute(),
2.
page:
pageContext.setAttribute("name", "吕锋涛");
String name =
(String)pageContext.getAttribute("name");
取得属性后要记得想下转型
HTTPServletRequest && ServerletRequest
request：
表示跳转后属性继续保存，换成超链接之后失效，一次情况下服务器只会给予回应一次
getParametervalues(String
name)： 取得客户端发来的一组请求
String method = request.getMethod();
String ip = request.getRemoteAddr();
String path =
request.getServletPath();
String contextPath =
request.getContextPath();
Enumeration enu =
request.getHeaderNames();
角色验证
HTTPServletResponse &&
ServerletResponse
response:对客户的的请求回应(HTML跳转 &&
sendRedirectict)
addCookie(Cookie cookie)
setHeader(String
name, String value) //
response.setHeader("refresh",2)
2秒刷新一次
response.setHeader("refresh",2; URL="hello.html")
2秒刷新后跳转页面，客户端跳转
<META HTTP-EQUIV="refresh"
CONTNT="3";URL="hello.html">
sendRedirectict(String
location)客户端调整
<jsp:forward> &&
sendRedirectict:
JSP是服务器段跳转，跳抓后地址不变，客户端跳转会导致地址变化
服务器端跳转时立刻的，客户端是执行万页面后跳转
操作Cookie：让服务器端的技术保存在客户端，火灾客户端执行数据处理，提高了网页的速率，减少了服务器的运载，安全性差。
javax.servlet.http.HttpSession
session：
一次设置，与设置页面相关就保存属性，可以通过超链接。新打开浏览器失效
主要用于登陆和注销操作，每一个session对象都表示不同的访问用户
getId(),
getCreation():
getLastAccessedTime():
isNew():
invalidate()://让session失效
Enumeration getAttributeNames():
获取用户时间：getCurrentTIme()；
登陆程序：通过sessio保存方法； 使用Cookie保存信息；
通过表单隐藏域保存信息； 通过地址重写保存信息
application:保存属性到服务器
getRealPath():
getContextPath():取得当前虚拟路径名称
配置虚拟目录：<Context path="/mldn" docBase="D:/mldn">
总结一下：
1.
request.setCharacterEncoding("GBK"); 设置为中文格式。
<meta
http-equiv="Content-Type" content="text/html;
charset= utf-8
"/>
2. this.getServletContext().getRealPath("/")；
后去虚拟目录对应的真是目录
request.getContextPath(); //获取虚拟目录对应目录
3.
PrintStream ps = new PrintStream(new FileOutputStream(file)); 设置输出流
，输出到文件
ps.println(content);
ps.close();
//但凡IO操作必然涉及异常处理以及IO流的关闭
4. Scanner scanner = new Scanner(new
FileInputStream(file)); 不明到底有多少的时候用StringBuffer;
scanner.useDelimiter("\n");
StringBuffer buf = new
StringBuffer();
5. response.setHeader("refresh", "2;URL=login.jsp");
定时跳转
<META HTTP-EQUIV="refresh"
CONTENT="3";URL="request_demo_02.html">HTML定时跳转
session.invalidate(); 用户失效
session.getAttribute("userid")；
获取属性
session.getId(); 和Cookie一样
6. Cookie c[] =
request.getCookies(); 至少1个
<%=c[i].getName()%> --->
<%=c[i].getValue()%>
**inst： getParametervalues用星号其区别；
7. <jsp:param name="uname" value="<%=name%>"/> 传递参数：
get && post区别：
get:提交后的内容会显示在地址栏，post不会
pageContext: response等设置的都可以在pageContext完成。
pageContext.forward("hello.jsp"?info="hell0"); 传递参数可以直接传递
String
info = pageContext.getRequest().getParameter("info");
config的配置需要在web.xml文件中配置
2016-10-05 星期三 JavaBean；
1.
JavaBean；一个类只包含属性，setter,getter方法
POJO: 简单的Java对象
VO：
专门传递值
TO： 传递对象，远程传输时必须继承Serialization
所有的类放入一个包，声明为public
class, 属性封装，至少有一个无参构造方法
<jsp:useBean id = "sim" scope="page"
class="com.huawei.ftl.SimpleBean"/>
<jsp:setProperty
property="*" name="sim"/> name是实例化对象名称，pro="*" 自动匹配2.
三目运算： return value == null?"":value;
3. MVC:
Model:完成独立的业务操作，JAVABEAN
Control
：负责所有的用户请求，判断是否合法，根据请求类型调用JavaBean，显示给View
View：接受Servlet传递的内容，调研JavaBean显示给用户
RequDispatcher():
request属性传递内容2016-10-09 星期日 小雨
1. JSTL1.2标准库开发
c:
核心开发库
sql:查询数据库操作
xml：XML数据
fn: 函数操作
H&N：fmt.tld 格式化数据
2. c:out :输出属性
c：set: 设置属性
<jsp:useBean id="login" class = "com.huawei.mvc.servlet.LoginServlet" scope =
"request"/>
<% request.setAttribute("simple", login);
%>
<c:set var = "world" value = "hello world" target =
"${simple}" property = "content" />
var:属性名称 value: 属性内容
scope: 保存范围 target:存储的目标属性 property:制定target属性
c: remove :
删除指定属性
c: catch:异常处理
c: choose:多条件判断，可以结合c:when
c:otherwise
<c:choose>
<c:when test="${num==20}">
<h3>输入的nuam的值为： 20</h3>
</c:when>
</c:choose>
c:
foreach :输出数组，集合
<c:forEach items="${ref}" var =
"m">
${m}
</c:forEach>
注意items里写的是一个集合，一个变量，要用${}表示
c: url : 根据路径和参数生成一个新的URL
c:
redirect: 客户端跳转
c: if :
<c:if test="${10 > 1}"
var = "res" scope = "request">
test制定比较大小内容，
var保存判断结果
c:forToken: 拆分数组
c:import 可以讲其他页面导入进来，类似<jsp
include>
2016-10-10 Struts开发
1. Struts 中的Action相当于Servlet
ActionForm ==
JavaBean
所有的输入从ActionForm取得,Servlet中由request取得
Action
中完成跳转，需要在Struts-config中配置，每个Action配置也给跳转路径
2016-07-23 周六
利用键盘输入的时候需要抛出异常 ，直接快捷键 ctrl + 1 ;
定义数组 int score[] = new int[4] ;
只有4个数字
BufferedReader br = new BufferedReader(new
InputStreamReader(System.in)) ;
String str = br.readLine()
;//直接输入，直接输出
score[i] = Integer.parseInt( str) ; //转换Str 为 Int
int temp
= Integer.parseInt(str); //字符串变为int型
String str = new String(b);
byte变字符串
Scanner scan = new Scanner(System.in) ;
冒泡排序： i=1;j=0 ;
for (int i = 1 ; i < 3 ;i++ ){
for(int j = 0 ; j< 3 ;
j++){
if(score[i] < score[j]){
int temp =
score[i] ;
score[i] = score[j] ;
score[j]
= temp ;
}
方法的定义: public static 返回值 方法名（类型 参数
， 类型 参数,）{
程序体 ；
（return) //可省略
}
类名定义： ArrayDemo (单词首字母大写)
方法定义： printInfo (第一个单词小写，后面的单词首字母大写 )定义的时候 char c[] = {'','','',''} ; 字符串都是单引号，字符都是双引号
float型的参数都是 3.2f,
使用
break 可以结束一层循环
使用 return 可以结束一个方法
方法的递归 ； return x + sum(temp)
;
栈中存放的是堆空间的地址； 中放的是名字，堆内存是实际数字
2016-07-24 周日
Java 的直接数组排序 java.util.ARRAY.sort() ;
Java 的直接复制数组
System.arraycopy(源数组，源数组开始位置，目标数组，目标数组开始位置，数组长度 ) ;
(说是复制，其实就是目标位置的数组的替换，将源数组的数字复制到目标数组的位置，目标数组的长度不变)
Java 新特性：foreach(数据类型 变量名：
数组名称) ; foreach (int x ; temp) ;
Java 新特性：可变参数：返回类型 方法名(类型... 参数) public void
fun (int... arg)
例： fun(new int[]{1,1,1,1,1}); //
传递参数可以直接传递
Java的多态性：方法的重载 ； 方法名同但是参数类型和参数的个数不同 ； System.out.println
也属于重载
对象的多肽 ：
子类对象可以和父类对象进行相互转换，而且根据子类的不同，完成的功能也不同
Java的封装性：对象的属性和行为看成整体，即对象；
信息的隐蔽
private 声明的属性或者方法只能被类的内部进行访问，而不能在外部被访问；
this的使用：
this.表示当前对象，this必须发放到构造方法的首行
this调用构造方法时一定要保留一个构造方法作为出口，也就是有一个构造方法不调用this();
this.方法名()
强调是本类中的方法；
this.属性 强调是本类中的属性；
Java的继承性：拥有一般特性的事物，在基础上 派生其他；
类 ： 成员变量声明 + 方法定义：
构造方法：
在实例化的时候就可以进行赋值，而不是调用setter 和 getter 方法 //也即是说，只是一个赋值的过程，没有返回值
方法名与主类同； 不能有返回值类型声明； 不能有return语句；默认 default
类型
匿名对象：没有明确给出名称的对象；一般只使用一次，而且直接开启堆空间，不存在栈空间的索引；
new
Person("zhangsan",12).tell() ;
String
本身就是一个类，但是我们一般用的String没有开辟栈空间，比较的只是堆空间的值；
一个字符串本身就是一个String的匿名对象；
“==” 比较的是开辟的空间，而不是内容；
equal()
比较内容是否一致；
String 里面indexOf本身就可以比较内容 是否相等， 他是找到内容，然后返回字符所在位置，
!(indexOf("hello"))!= -1 表示找到
一个String对象内容的改变实际上是通过内存地址的更新完成的，本身的字符串内容不会变；
char[] toCharArray()
;//转换为字符数组 charAt() //特定的位置取值 String split()//按照指定的字符串分割
String
subString()指定字段取值 equals(), equalsIgnoreCase()
split 和
raplaxeAll() 支持正则表达式；，返回时一个 String s[] =
indexOf :
从指定位置开始查找字符串位置，没有找到就返回 -1 ；
charAt ： 取出指定位置的字符 trim()
:去掉左右的空额
length 和 length() 在数组中,length是长度，String操作中是函数，需要length()
;
引用传递： 就是将一个堆内存空间的使用权交给多个栈内存空间
接受本类的对象： public void
fun(Demo d2)
2016-07-28 周四
Java的内存区域：
栈内存：保存所有对象的名称（堆地址的内存空间）
堆内存：保存每个对象的属性内容
全局变量： static类型属性
全局代码段：保存所有的方法定义
Static关键字：堆内存保存对象，可以用static共享属性
static声明属性的又称为类属性，因为类的公共属性应该由类来修改，毕竟用户不知道到底会有多少对象产生；
static String
count = "ad"; Person.count = "bc";
static声明的方法又称为类方法，可以用类名调用；
public static setName(String name) ;
Person.setName("lvfengtao") ;
static应用，可以查看定义了多少给
实例化对象；
System.exit(1) ; //可以直接退出程序，设置非0数字
代码块：
普通代码块：{}括起来的，直接在方法或者语句中设置的
构造代码块：直接写在类中的代码块 //只有一行代码
静态代码块：用static声明的代码块
静态代码块优于主方法执行，类中的静态代码块优先于构造块执行，且只执行一次，不管产生几个对象
构造方法私有化： private 方法名()
构造方法一旦私有化，就不能new调用，就必须从内部调用
一种是static 属性，另一种是static
方法，返回实例，通过类.方法名调用；
单例设计模式：
无论程序怎么运行，始终只有一个实例化对象存在，只要将构造方法私有，就可以对控制实例化对象的产生；
数组一定要先开辟空间，因为是引用类型
主方法的String
args[] 本身就是一个类，主方法中的参数本身就是以对象数组的形式出现的；
内部类： 在类的内部在定义一个类
缺点：类由属性和方法构成，所以会破坏类结构
唯一的好处就是可以访问外部类的私有属性；
用static声明的内部类变成了外部类，但是不能访问非static声明的外部类属性
在外部访问内部类
外部类.内部类 内部类对象 =
外部类实例.new 内部类() ;
private
定义是在一个类里面都可以访问，所以内部类可以直接访问外部类的属性；
使用statIC声明的内部类就会成外部类，使用static声明的内部类不能访问非static声明的外部类
在方法中定义一个内部类
在方法中定义的内部类不能直接访问方法中的参数，如果发放中的参数想要被内部类访问，就必须在参数前加final关键字
2016-07-30 周六
使用构造方法的时候，一定是this.setName(name); 继承的时候是，super(age,name); Getter方法中：return
school;
关于输出，最好是在类中返回String方法，然后在主类中 System.out.println(实例化对象.方法名) ；6.1 继承类(派生类)
Java只允许单继承，一个子类只允许有一个父类，允许多层继承，一个父类还有一个父类；
子类是不能调用父类的私有成员，子类可以调用父类的非私有 方法，但是不能直接调用父类的私有成员，但是可以通过setter和getter；
子类实例化对象之前，先调用父类的构造方法，后调用子类的构造方法，实际上子类的构造方法中隐藏了super()方法【超类】
子类不能拥有比父类更高级的访问权限
6.2 this 和 super 区别：
1.this
只能调用本类的属性、方法，本类中没有则父类查找 super 访问父类的方法，方法
2.this 调用本类构造， supe
调用父类构造，且放在子类首行
3.this 表示当前对象
6.4 final :完结器
，final声明的类不能有子类，声明的方法不能被覆写，声明的变量为常量，不可以修改
final声明的变量必须全部大写； public static
，final String NAME = "Lvfengtao";
6.5 Abstract 抽象类：
抽象类是一种模板，必须被继承才能用，一个子类只能继承一个抽象类
包含一个抽象方法的类是抽象类； 抽象类和抽象方法必须由abstract声明；
抽象方法只需声明，不需要具体；
抽象类必须被继承，子类必须前部复写抽象类中的全部抽象方法 public abstract void
print();
抽象方法不要使用private声明，因为必须被覆写，子类不易复写；
抽象类可以定义构造函数，所以子类实例化之前必须对父类进行实例化，也就是说先必须给打印父类的构造方法然后子类的构造方法
子类可以通过super()方法调用抽象类(父类)的构造方法,也可以在子类调用父类指定参数的构造方法
子类 extends 抽象类
implements 接口A， 接口B
6.6 接口： 特殊的类，由全局常量和公共的抽象方法组成 // 接口本身已经定义，所以不需要在写 public
static fianl 和 abstract ;
由于明确规定了抽象方法是public
类，所以也不需要在写；
接口与抽象方法一样需要子类的继承
implements，一个子类可以实现多个接口，摆脱继承的单继承
全局常量，在接口里定义的时候用大写
Java允许一个抽象类实现多个接口，但是一个接口不允许继承抽象类， 允许一个接口继承多个接口
接口的继承： interface A
extends B, C
interface A {
public static final String INFO =，
"Lvfengtao" ==== String INFO = "Lvfengtao"
public
abstract void print() ========== (public)void print()
//全局常量；
抽象方法； //必须是public方法，写与不写，Java的接口方法都是pblci
}
6.7
对象的多态性
表现： 1、方法的重载和覆写
2、对象的多态性
（向上转型：子类--> 父类 ； 父类 父类对象 =
子类实类
向下转型：父类 --> 子类，且必须说明向下转型的子类类型） 子类 子类对象 =
（子类）父类实例
** 对象是Object类型，需要转型 String str =
(String)obj[i];
2016-08-02 星期二
6.12 包装类； Java数据分为基本数据类型和引用数据类型,
用的最多的还是讲字符串变为数据类型（int i=
Interger.parseInt("1234")）；
(字符串变为数组的时候需要抛出异常)
拆箱 和装箱：
Interger i = new Interger(x); int x = i.intValue();
Integer i = 0 ;//自动封装 int x = i; //自动拆箱
7.1
异常的基本概念
Java的异常都是以类和对象的形式存在，Java的错误主要是语法和语义的错误，编译的时候没有报错，但是运行的时候也可能报错
Try()
找到错误后会跳转到 catch里面，一旦产生异常，则首先回产生一个异常类 的实例化对象，
Exception 和 Error 都是Java
Throwable的异常类
通常用e.printStaceTrace()方法打印异常信息，所有的额子类的实例都可以用父类来接受，所以可以调转
7.2 throws 和
throw关键字
throws声明的方法，表示此方法不处理异常，而是调用方法去处理；
2016-08-03 星期三
9.1 多线程： 继承 Thread类【要覆写run()】或者实现Runnable类 // 都需要覆写run()方法
由于受到单继承的影响，所以一般多线
中程是通过
同时可以调用父类start()方法，实现多线程，说是调用start()方法，但是调用的却是run()方法的主题
一般重复调用start()方法回抛出异常，而且本质上调用
start0()这个方法，因为使用了native声明，所以需要依靠底层的操作系统支持
实现Runnable()方法，需要实现多线程，可以利用Thread类中设定的方法启动多线程
Thread类也是Runnable接口的子类，但是Thread并没有完全的实现Runnable接口的run() Thread 构造方法 Thread
thread = new Thread(接受 Runnable的子类，设置线程名称 )
继承Thread类并不能实现资源共享，如果想要资源共享必须实现Runnable接口
避免单继承带来的局限性；
代码能与多个线程共享，代码与数据是分开的；
9.2 线程的状态： 创建 、就绪、 运行、 阻塞、 终止
getName: 取得线程名称；
setName： 设置线程名称
main()本身也就是一个线程，每次Java运行都至少启动2个线程，一个main,一个垃圾回收
main()方法可能比其他方法更早执行；
public static Thread currentThread():
返回当前执行的类
public final String getName(): 返回线程名称
public final int
getPriority(): 返回优先级 1 5 10
public boolean isInterrupted():
线程是否中断；
9.3 Thread类中有一个方法: 利用 构造函数可以直接命名线程 子类实例化以后就可以直接start
Runnable,需要 子类实例化对象，然后调用Thread调用start方法
9.6
解决资源同步问题：1、使用同步代码(Synchronized(同步对象 this)
2、同步方法
多线程 共享同一资源的时候需要同步，但是过多会产生死锁；
方法的完整定义：
public/default/private/protected final static syncronized 返回类型 方法名（参数类型
参数名称） throws EXCEPTION{ return [返回值/返回调用处]}
死锁：
同步可以保证资源共享的正确性，所谓死锁就是2个线程都在 等待彼此完成任务，造成程序停滞
2016-08-06 星期六
new String(bInput); //byte数组变为字符串 byte[] b = str.getBytes();
int
i = Integer.parseInt(str); //字符串变整数 {\\d4}必须 数字出现4次
(^\\d+.?)
正则表达式匹配小数 ,? 表示小时代可以出现一次或0次
[a-zA-Z0-9]字母数字 \w 字母、数字、下划线
^\\d{4}-\\d{2}-\\d{2}$:年与日
[abc]: 字符abc [^abc]: 除了abc之外的任意字符 \d ：数字
\D: 非数字 \w：字母、数字、下划线 \s:所有空白字符
X？：出现0次到1次 X*:出现0次，1次，多次
X+：出现1次或多次
X|Y： 先X或Y XY：先X后Y
正则表达式需要Patter和Matcher两种类完成, Patter类主要进行正则规范Matcher主要执行验证
Patter.complie("[0-9]+").matcher(str).matches();
Patter p =
Patter.compile("[0-9]+");
Matcher m = p.matcher(str);
m.matches();
12.16 序列化
实现Serializable接口，还需要依靠对象输出对象和对象输入流
对象输出流(ObjectOutputStream): 实现序列化
构造方法(传入输出对象)：ObjectOutputStream(OutputStream out)
普通方法(输出对象)：
writeObject(Object obj)
File file = new File("E:" +
File.separator + "test.txt");
ObjectOutputStream oos =
null;
OutputStream os = new
FileOutputStream(file);
oos = new
ObjectOutputStream(os);
oos.writeObject(new
People("People",21));
oos.close();
实现Externalable接口，还需要依靠对象输出对象和对象输入流
public void
readExternal(ObjectInput input) // 读取需要的 内容
{
this.name = (String)input.readObject(); //需要转换
}
public
void writeExternal(ObjectOutput output) // 写入需要的 内容
{
output.writeObject(this.name);
}
transient: 声明
的关键字不可以被序列化13.1 认识类集
:动态完成对象数组操作，是动态的对象数组，是对一些实现好
的数据结构的包装，不受对象数组长度限制；
特点:对基本类集（动态数组、连接表、树）实现是高效的
框架允许不同类型的类集以相同的方式和高度
Collection:
接口，存放一组单值(集合中的每个元素都是一个对象)的最大接口，
List: Collection
子类接口，堆Collection扩充，允许内容重复
Set: Collection
子类接口，没有对Collection扩充，允许内容不重复
依靠hashCode()和equals()两个方法区别
Map； 存放一对值得最大接口，Key -- >
Value
Iterator:集合的输出接口，用于输出集合中的内容，胆小
ListIterator: 可以双向输出
Enumeration: 输出指定集合的内容
SortedSet: 单值的排序接口，可以使用比较器排序
SortedMap：存放一对值得排序接口，按照key值比较
Queue: 队列接口，可以实现队列操作
Map.Entry:
Map.Entry的内部接口，每个Map.Entry对象都保存这一对 key -->
Value的内容，每个Map接口都保存很多Map.Entry接口实例
List<String> list = new
ArrayList<String>() ;
System.out.print(list);
2016-08-07 星期日
13.1
String str[] = list.toArray(new String[]{});
//后面的{}实为初始化
indexOf() 找不到返回-1 找到显示位置
ArrayList 和 Vector区别：
ArrayList是异步处理方式，性能高，非线程安全操作类，使用Iterators
LinkedList子类和Queue接口
LinkedList表示一个链表的操作类， ListedList<> l =
new ListedList<>();
poll()方法找到首字母并回删除首节点， peak()
找到首字母
Queue表示的是队列操作接口，采用FIFO方式操作，for(int i; i<
list.size()+1
set：
散列存放：HashSet：
set<String/也可以是个类名> s = new
HashSet<String/也可以是类名>();
System.out.println(set);
//自主调用toString()方法
有序存放：TresSet
类中的每一个对象所在的类都必须实现Comparable接口才可以使用；
TreeSet自定义排序是一定要继承Comparable类，复写Comparto()方法，
public
int compareTo(Person per)
但是比较器比较的时候，如果某个属性没有进行比较的指定，也会认为是同一个对象，所以应该增加按照姓名比较；
return this.name.compareTo(per.name);
去除重复元素：
主类不需要继承TreeSet,但是需要复写equals方法，编写hashCode方法
13.6 集合的输出
如果要输出Collection、Set集合中的内容，可以将其转换为对象数组输出，而List则可以直接使用get()方法输出；
常用的类集合为:
Iterator: 迭代输出(判断元素是否有内容，有就输出)
ListItarator: Iterator的子接口，专门用于输出List
Enumeration:
旧接口
2016-08-08 星期一
13.6.1
Iteration: Iterator是一个接口，直接使用Colletion定义的
itreator()实例化；同理List和Set也实现了此方法
hasNext():
返回boolean,判断元素是否有内容，
next():输出,取出内容
ListIterator：
只能通过List实现实例化，只能输List内容
hasPrevious(): 判断是否有上一个元素
pervious(): 取出当前元素
nextIndex(): 返回下一个元素的索引
previousIndex(): 返回上一个元素的索引
set(): 替换元素
实现ListIterator接口双向输出时，如果想完成右后向前输出，则一定要先右前向后输出；
forEach: for (String str:
list)//(类 对象：集合){}13.7 Map接口
Map<K,V>:
clear(): 清空cler()
containKey(): 判断指定key是否存在
set<May.Entry><K,V> entrySet(): 将Map对象变为Set集合
Map.Entry是Map内部定义的一个接口，专门保存key->va
可以由外部通过“外部类.内部类”直接调用
Map内容是K-V形式保存，实际上K-V是把数据保存在M.E之后
Map输出数据的时候必须使用M.Entry接口
V get(OBJECT key): 根据key 取得Value
set<K> keySet(): 取得所有key
Set<String> set =
map.keySet();
Collection<V> value(): 取出全部value
V
put(K kye, V value): 向集合中加入元素
putAll<Map<? extends K, ? extends
V>t> 一个Map集合加入到另一个
13.7.1 Map接口常用的类
HashMap：
无序存放，新的操作类，key不能重复
HashTable: 无序存放，旧类操作，key不能重复
TreeMap：有序Map集合，按key排序，不允许重复
WeakHashMap： 不再用的内容青岛湖
IdenHashM： key可以重复
Map接口的使用注意事项：
1.不能直接使用迭代输出Map内容，因为Map 存放一对值，Iterator只能输出一个
2.Map很少作为直接输出的额，只是用作查询
3.直接使用非系统类作为key
2016-08-28 星期日
//利用indexOf判断某个字符是否存在 也可以用
//replaceAll （源数字 ， 目标数字)
直接替换
//System.out.println(str.charAt(8));
取出第8个字符
继承父类以后调用父类的构造方法：super(name, address, sex, age);
输出父类的属性：
super.toString()
代理模式： 代理和真实主题均要实现接口，在代理中实现真实主题实例化(构造方法中实现)
工厂模式:
其他了均实现接口，定义一个类专门获取实例，不是构造方法获得
适配器模式：接口定义方法，
构造方法实现此接口，方法体为空，后子类继承抽象类，有选择的复写方法
观察者模式： 要被关注的继承Obserable类，调用父类方法
super.setChanged(); super.nosuper.notifyObservers() 观察着实现
Observer接口，在update类中，判断是否是一个类，输出即可
//这些接口呢都需要用到多态性，都是 接口 接口对象 = new
子类对象()，实现向上转型，转型后可以调用子类复写父类的方法
如果需要向下转型，则调用子类自己的方法，但是需要先向上转型后， instanceof
比较对象；//如果要进行字符串的拆分，利用split方法
Pattern p = Pattern.compile("[a-zA-Z]");
String
s[] = p.split(str);
//如果需要正则表达式来进行字符的替换，
String str =
"123231m3m123m123m123m12";
Pattern p =
Pattern.compile("[a-zA-Z]");
Matcher m = p.matcher(str);
String ss = m.replaceAll("_");
、、以上方法String都有支持的 boolean matches(String
regex); String[] split(); String replaceAll(String regex, s)
2016-08-30 星期三
时间类： SimpleDateFormat sdf = new
SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");
sdf.format(new
Date()) ;
SimpleDateFormat sdf = new
SimpleDateFormat("yyyy-MM-dd");
Date temp =
sdf.parse(str);
字符串拆分：
String str = "<html xmlns=\"http://www.w3.org/1999/xhtml\">";
str = str.substring(str.indexOf(" ")+1, str.indexOf(">")).replaceAll("\"", "
").replaceAll("\\.", " ").replaceAll("/", " ");
字符串内输入双引号： \"
定时调度：
Timer类：
是一种线程设施，可以定时安排一个时间，与TimerTask(实现由TImer安排的一次或重复执行的某一个任务)配合使用
IO操作：
File打开文件--> 字节流制定位置-->读写--> 关闭流
FIle类：文件本身操作
boolean
createNewFile();
boolean exists();
boolean
isDirectory();
String[] list();
File[]
listFiles();
boolean mkdir();
boolean renameTo(File
dest); //已有文件重新命名
RandomAccessFile类：随机读取类（一般不用）
RandomAccessFile(File file, String mode) //file路径
RandomAccessFile(String path, String mode)//固定路径
close():
关闭操作
void writeBytes(String s): 字符串写入文件
void writeInt(jint
v)
int read(byte[] b): 将内容读取到一个byte数组
byte readByte():
读取一个字节
int readInt(): 读取整数型
int skipBytes(int
n):指针跳过多少字节
void seek(long pos): 指针位置
所有数据都是已流的方式传输或保存，分字节和字符
字节流：以byte为准，需要将字符串转为Byte数组
OutputStream
OutputStream out = new
FileOutputStream(file);
OutputStream out = new FileOutputStream(file,
true);追加内容
String str = "\r\nHEllo world"; 文件需换行，可以加\r\n
byte[] b = str.getBytes();
out.write(b);
out.close();
InputStream:
int avaliable();
//取得文件大小
int read();//以数字的方式读取
int read(byte[] b)
；内容读取到byte数组
InputStream input = new
FileInputStream(file);
byte[] bb = new byte
[(int)f.length()]
//byte[] bb = new byte[1212];
//int len
= input.read(b); //取出内容到byte数组,确定输出多少
while(input.read()!=-1)
{
b[len] = (byte)
temp;
len++;
}
input.close();
System.out.println(new String(b, 0, len));
一个字符2个字节；
字符流：
Writer 子类： FileWriter
可以添加对象， Writer writer = new
FileWriter(new File(), true);
write(String str) 字符串输出
write(char[] c) 字符数组输出
flush() 强制清空缓存
Reader 子类 FileReader
int read()
int read(char[] c):
内容读取到字符数组，返回长度
字符的输出： new String(c, 0 ,len)
读取字符串有2中方法：
直接从文件读取
for循环 读取一个字节 int len =
0；
int temp = 0;
//接收每一个内容
while((temp =
reader.read())!=-1)
{
c[len] =
(char)temp;
len++;
}
字符流使用了缓冲区，字节流没有使用缓冲区(内存区域)；
不关闭时也将字符内容输出，可以使用Writer类的flush()方法打印流： PrintStream() 和 字符打印流()
2016-09-03 星期六
1.Serializable(Serializable)
一个类的对象要想被序列化(一个对象变为2进制，方便存储和传输)，就必须实现Serialiable接口，依靠ObjectOutputStream()和ObjectInputStream()
Java序列化的时候会产生一个序列化ID，通过JVM实现
File file = new File("F:" +
File.separator + "hello.txt");
OutputStream out = new
FileOutputStream(file);
ObjectOutputStream oos = new
ObjectOutputStream(out);
oos.writeObject(new
Person("lisi"));
ObjectInputStream ois = new
ObjectInputStream()
oos.close();
InputStream input
= new FileInputStream(file);
ObjectInputStream ois = new
ObjectInputStream(input);
Object obj =
ois.readObject();
ois.close();2.
Externalizable是Serializable子类，实现此接口的可以用户自己制定被序列化的内容
writeExternal(ObjectOutput ot): 指定要保存的属性信息，对象序列化时调用
readExternal(ObjectInput in): 读取被保存的信息，反序列化用
以上2个方法都是DataOutput 和
DataInput接口的子类
public Person(){};
public Person(String
name)
{ this.name = name; }
//读取属性，有一个强制转换的要求
public void readExternal(ObjectInput
input)
{ this.name = (String)
input.readObject();}
//保存name属性
public void
writeExternal(ObjectOutput output)
{
output.writeObject(this.name); }
一个类要使用Externalizable实现序列化，此类必须有一个无参构造方法，因为在反序列化的时候会默认调用无参构造实例对象
3.
transient：关键字表示对象的某一个属性不希望被序列化
4. 序列化一组对象：
对象输出时只提供了writeObject(Object
obj))，并没有多对象输出，所以要实现同时序列化多个对象，就可以使用对象数组操作。
因为数组属于引用类型，可以用Object类型接收
5. List Set(重复内容依靠hashCode() 和
equals()方法区别) Queue SortSet(对集合中的数据进行排序)
List:接口
add(int index, E element)
addAll(int
index, Collection<? extends E> c) 添加一组元素
E get(int
index)
ListIterator<E> listIterator()
E
remove(int index)
E removeAll(Collection<?>
arg0)
List<E> subList(int fronIndex, int
toIndex)
E set(int index, E element)
toArray():
集合变为对象
size(): 返回集合的长度
get(int index):
返回当前的位置的数字
for(int i = 0; i < allList.size();
i++)
{
System.out.print(allList.get[i] +
"、");
}
LinkedLis：链表操作类
addFirst(E
e );
addList(E e);
boolean offer();
E removeFirst()
Queue:先进先出
E element()：
找到表头
E peek() 找到不删除;
E pool() 找到后删除;
利用此方法先进先出输出数字
E remove() 检索并移除表头Set：HashSet && TreeSet
HashSet:
无规律可循
TreeSet:
有规律
如果是比较对象，则需要继承Comparable接口，实现CompareTo()方法
class Person implements
Comparable<Person>//接口处定义泛型类型
public int compareTo(Person
per) {
if ( this.age > per.age)
{
return 1;
}
else
if (this.age < per.age)
{
return
-1;
}
else
{
return 0;
}
比较器操作时如果某个实现没有进行比较，则默认为是一个对象
如果实现了HashSet,则所有的重复对象也会继续出现，就需要复写Object类的equals()方法和hashCode()方法，一个对象编码表示一个对象
SortedSet: TreeSet继承SortedSet
SortedSet<String> set =
new TreeSet<String>();
first(); last();
SortedSet<E> headSet(E element):开始到指定位置
SortedSet<E>
tailSet(E element):指定到最后
//可以用get()方法输出数字
Iterator:
Iterator iter = list.iterator();
ListIterator:
由前向后： hasNext() && next()
有后向前： 利用hasPrevious()方法由前向后判断，用previous取出元素
set() 和 add()
可以更改和添加元素
foreach输出：
for (类 对象： 集合) {};
for（String str: all)Map：HashMap &&
TreeMap
put(Object key， Object obj): 添加数据
get():
根据key值取得value的值
Map<String, String> map = new
HashMap<String, String>();
Set<String> keys =
map.keySet();
Iteration key =
keys.iterator();
while(key.hasNext())
{
String str = key.next();
System.out.println(map.get(str）);//根据key 取值
}
map.get（iter.next()）
containKey():
判断指定的key是否存在
keySet():
将一个Map中的key变为Set集合，然后利用Iterator输出
values():
返回Collection，注意定义泛型类型
Collection<String> col =
map.values();
Iteration valus =
col.iterator;
while(values.hasNext()){};
Map接口注意事项：
1.
不能直接使用迭代输出Map中的全部内容，因为Map存放的是一对值，Iterate只能每次找到一个值，如果非要迭代输出，则必须：
1> Map实例通过entrySet()方法变为Set接口对象
2>
通过Set接口实例化Iterator、
3>
Iterator迭代输出，每一个ie内容都是Map.Entry的对象
4> 通过Map.Entry进行
key --> value分离
(Map中的每对数据都是通过Map.Entry保存的，所以也是Map.Entry输出)
Map<String
,String> map = null;
map = new HashMap<String,
String>();
map.put("04122077",
"吕峰涛");
map.put("04122076", "吕峰");
` Set<Map.Entry<String, String>> set =
map.entrySet();
Iterator<Map.Entry<String,
String>> iter = set.iterator();
while(iter.hasNext())
{
Map.Entry<String, String> me = iter.next();
System.out.print( me.getKey() + "--> " + me.getValue() +
"\t");
}
SortedMap:
排序接口，实现此类都是排序的子类，例如TreeMap
Comparator<? super K>
comparator();
K firstKey(); K lastKey();
SortedMap<k, V> subMap(K fromKey, K endKey)
SortedMap<K, V> tailMap<K fromKey): 返回大于指定key的部分集合
Collection:
addAll(): 为一个集合增加内容 Collection.addAll("ARRAY",
"BufferedReader");
reserve():
binarySearch(): 返回内容位置
sort(); 排序
swap():
交换我ie之Stack: 先进先出
push:
进站
pop: 出战
int search(Object o):
在战中查找
Properties:
new
Property().setProperty("key", "value");
store(OutputStream
out, String comment, String encoding);
list(PrintStream out):
loadFromXML(InputStream in):
storeToXML(OutputStream out)
2016-09-05 星期一
1. Class类方法
Class<?> forName(String Name): 传入完整"包.类",
实例化Class对象
c1 = Class.forName("com.huawei.ftl.X");
System.out.println("类名称： " + c1.getName());
也可以通过类.class或者对象.getClass()实力化Class类
实例化后可以通过newInstance()实例化对象，注意转换类型
per = (Person)
c.newInstance();
（以上注意一点，就是类中必须由无参构造方法）
Construtor[]
getConstructor: 得到类中所有的构造方法
Field[] getDeclaredFields():
得到继承来的类
Class[] getInte
2016-09-10 星期六 JavaWeb
HTML注释语句： <!-注释语言->
1. JS的事件处理： body (onLoad()="start()"
onUnload()="stop()" onClick="fun()")
onSubmint():事件在提交之前先验证
onCHange(): 变化
文本处理：
var value = document.form.content.value;
//精确到具体的name值，然后取值，否则为空
2.3.3Window对象
window.location: 定位到对应网页
window.open: 打开网页设置
HTML：
表达式完成交互的收到，表单元素写在《form>里面
JavaScript是基于对象的语言，function是函数，又返回值直接返回return即可。
3.1 XML：
可扩展性标志语言，实现数据交换，系统配置，内容管理。
XML语言是以<? ?> 开始和结束的
version：
encoding：编码
standalone: 是否独立运行，
XML声导固定格式
<?xml-stylesheet type="text/css" href =
"attri.css"?>
<![CADATA[里面的内容不解析]]>
3.2 XML解析：SAX
&& DOM(文档对象模型)
4个重要的额借口：
Document：整个XML文档，根节点
Node：每一个Node代表一个节点
NodeList：节点的集合
NamedNodeMap：一组节点和其唯一名称对应关系，属性节点
NodeList getElementByTagNsme();取指定节点名
Element
createElement(String tagName):创建指定名节点
Dom4J：利用工具来读写文件
Document doc =
DocumentHelper.createDocument();
Element addresslist =
doc.addElement("addresslist");
Element linkman =
addresslist.addElement("linkman");
Element name =
linkman.addElement("name");
name.setText("吕峰涛");
OutputFormat format =
OutputFormat.createPrettyPrint();
format.setEncoding("GBK");
2016-09-11 星期日
1.创建目录--> WEB_INFO--> 复制WEBapps/ROOT/web.xml到虚拟目录下
Tomcat修改端口：conf/server.xml
虚拟目录：复制web.xml
<content path="/mldn" docBase="虚拟目录地址"/>
修改conf/web.xml
listings的false修改为true;
2xx:请求成功
3xx:重定向
403：禁止
404：找不到文件
500：服务器内部错误
Tomcat是个Web容器
2.JSP学习
JSP的命名采用小写，且最终都是以*.class完成
request.getParameter()方法接受输入内容。
2016-09-11
1. JavaBean；一个类只包含属性，setter,getter方法
POJO:
简单的Java对象
VO： 专门传递值
TO： 传递对象
2. 数据库操作：
pstmt = conn.prepareStatement(sql);
pstmt.setInt(1, tid);
(注意顺序，一定是先执行语句，然后设置变量)
2016-09-18
1.抽象类的使用： Person per = new Student("lvfengtao", 12o,
99.9f);
抽象类中定义抽象方法为public， 不用写方法体 public abstract void
say();即可；
2.工厂模式中在工厂类中定义了一个静态方法来获取接口的实例；
public static Fruit
getInstance(String name)
3.代理模式； Network net = new Proxy(new
Real());
}
2016-10-02 星期日
1. 使用Dom4J 生成XML文件，XML主要是用于数据交换
Document创建一个DOC文档，一个文档只有一个根节点
Element添加元素，
OutputFormat完成格式化，设置为中文格式。
XMLWriter完成数据的写入
OutputFormat format = OutputFormat.createPrettyPrint();
XMLWriter
writer = new XMLWriter(
new
FileOutputStream(
"G:" + File.separator +
"new2016.xml"), format );
writer.write(doc);
writer.close();2. JS操作XML
JS点击显示文字：
document.getElementById("info").innerHTML =
"<h2>www.MLDNJAVA.cn</h2>" ;
JSP注释：
1.<!--注释内容--> 显示注释客户端可以看见
2.<%--注释内容--%>; /*
*/ // 隐式注释
Scriptlet：3种方式
1.<% %> :
定义局部变量
<%!%>： 全局变量，类，方法
<%=%>:
输出一个变量
2.标签：<jsp:scriptlet> 代码块
</jsp:scriptlet>
Page: langua="Java" contentType="text/html"
pageEncoding="GBK"
必须是text/html 因为conf/web.xml写了这个
2.错误页面显示：
<%@ page isErrorPage = "true"%>
isErrorPage (注意大小写)
<%@ page errorPage="error.jsp"%>
属于服务器端的跳转
Include：包含指令：
1.静态包含： <%@ include file= "" %>
2.动态包含：<jsp:include>:自动区分页面静态还是动态
<jsp:include page
= "{包含文件路径 | <%=表达式%>}" flush = "true/false"/>
<jsp:param name="参数名称" value="参数内容"/>
</jsp:include>
静态是先包含后处理，动态是先处理后包含
跳转：
<jsp:forward page = {""}>
2016-10-04 星期二 JSP
中文问题：
HTML：<meta http-equiv="Content-Type"
content="text/html;
charset= utf-8 "/>
REQUEST：如果获取返回的值，可以设置
request.setCharacterEncoding("utf-8");
1.JSP内置对象 (9个，out, request,
session(保存用户信息), application(所有用户的共享信息), response,
pageContext(JSP页面容器))
4个属性：page(一个页面保存，调整失效),
request(只在一次 请求保持),
session(再一次会话范围内，任何跳转都行，新开浏览器失效),
application(服务器保持)
公共方法： setAttribute(), getAttribute(),
removeAttribute(),
2.
page:
pageContext.setAttribute("name", "吕锋涛");
String name =
(String)pageContext.getAttribute("name");
取得属性后要记得想下转型
HTTPServletRequest && ServerletRequest
request：
表示跳转后属性继续保存，换成超链接之后失效，一次情况下服务器只会给予回应一次
getParametervalues(String
name)： 取得客户端发来的一组请求
String method = request.getMethod();
String ip = request.getRemoteAddr();
String path =
request.getServletPath();
String contextPath =
request.getContextPath();
Enumeration enu =
request.getHeaderNames();
角色验证
HTTPServletResponse &&
ServerletResponse
response:对客户的的请求回应(HTML跳转 &&
sendRedirectict)
addCookie(Cookie cookie)
setHeader(String
name, String value) //
response.setHeader("refresh",2)
2秒刷新一次
response.setHeader("refresh",2; URL="hello.html")
2秒刷新后跳转页面，客户端跳转
<META HTTP-EQUIV="refresh"
CONTNT="3";URL="hello.html">
sendRedirectict(String
location)客户端调整
<jsp:forward> &&
sendRedirectict:
JSP是服务器段跳转，跳抓后地址不变，客户端跳转会导致地址变化
服务器端跳转时立刻的，客户端是执行万页面后跳转
操作Cookie：让服务器端的技术保存在客户端，火灾客户端执行数据处理，提高了网页的速率，减少了服务器的运载，安全性差。
javax.servlet.http.HttpSession
session：
一次设置，与设置页面相关就保存属性，可以通过超链接。新打开浏览器失效
主要用于登陆和注销操作，每一个session对象都表示不同的访问用户
getId(),
getCreation():
getLastAccessedTime():
isNew():
invalidate()://让session失效
Enumeration getAttributeNames():
获取用户时间：getCurrentTIme()；
登陆程序：通过sessio保存方法； 使用Cookie保存信息；
通过表单隐藏域保存信息； 通过地址重写保存信息
application:保存属性到服务器
getRealPath():
getContextPath():取得当前虚拟路径名称
配置虚拟目录：<Context path="/mldn" docBase="D:/mldn">
总结一下：
1.
request.setCharacterEncoding("GBK"); 设置为中文格式。
<meta
http-equiv="Content-Type" content="text/html;
charset= utf-8
"/>
2. this.getServletContext().getRealPath("/")；
后去虚拟目录对应的真是目录
request.getContextPath(); //获取虚拟目录对应目录
3.
PrintStream ps = new PrintStream(new FileOutputStream(file)); 设置输出流
，输出到文件
ps.println(content);
ps.close();
//但凡IO操作必然涉及异常处理以及IO流的关闭
4. Scanner scanner = new Scanner(new
FileInputStream(file)); 不明到底有多少的时候用StringBuffer;
scanner.useDelimiter("\n");
StringBuffer buf = new
StringBuffer();
5. response.setHeader("refresh", "2;URL=login.jsp");
定时跳转
<META HTTP-EQUIV="refresh"
CONTENT="3";URL="request_demo_02.html">HTML定时跳转
session.invalidate(); 用户失效
session.getAttribute("userid")；
获取属性
session.getId(); 和Cookie一样
6. Cookie c[] =
request.getCookies(); 至少1个
<%=c[i].getName()%> --->
<%=c[i].getValue()%>
**inst： getParametervalues用星号其区别；
7. <jsp:param name="uname" value="<%=name%>"/> 传递参数：
get && post区别：
get:提交后的内容会显示在地址栏，post不会
pageContext: response等设置的都可以在pageContext完成。
pageContext.forward("hello.jsp"?info="hell0"); 传递参数可以直接传递
String
info = pageContext.getRequest().getParameter("info");
config的配置需要在web.xml文件中配置
2016-10-05 星期三 JavaBean；
1. JavaBean；一个类只包含属性，setter,getter方法
POJO:
简单的Java对象
VO： 专门传递值
TO：
传递对象，远程传输时必须继承Serialization
所有的类放入一个包，声明为public class,
属性封装，至少有一个无参构造方法
<jsp:useBean id = "sim" scope="page"
class="com.huawei.ftl.SimpleBean"/>
<jsp:setProperty
property="*" name="sim"/> name是实例化对象名称，pro="*" 自动匹配
2. 三目运算： return
value == null?"":value;
2016-10-22 星期六
1. <script language = "javascript"> js 是小写
用onsubmit()方法的时候一定是 return validate(this)
JS 中
判断值得方法是：
DOM4J XMLWriter 和SAXReader解读
2017-01-01 星期日
1. Java中sleep和wait的区别
①
这两个方法来自不同的类分别是，sleep来自Thread类，和wait来自Object类。
sleep是Thread的静态类方法，谁调用的谁去睡觉，即使在a线程里调用b的sleep方法，实际上还是a去睡觉，要让b线程睡觉要在b的代码中调用sleep。
②
锁:
最主要是sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。
sleep不出让系统资源；wait是进入线程等待池等待，出让系统资源，其他线程可以占用CPU。一般wait不会加时间限制，因为如果wait线程的运行资源不够，再出来也没用，要等待其他线程调用notify/notifyAll唤醒等待池中的所有线程，才会进入就绪队列等待OS分配系统资源。sleep(milliseconds)可以用时间指定使它自动唤醒过来，如果时间不到只能调用interrupt()强行打断。
Thread.sleep(0)的作用是“触发操作系统立刻重新进行一次CPU竞争”。
③
使用范围：wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用。
synchronized(x){
x.notify()
//或者wait()
}