Java_SE培训笔记

=============JAVA===================
8.5
一、数据类型分类
基本数据类型和对象类型（引用类型）

基本数据类型（8个）
byte short int long  整型数
float double			浮点型数（带小数）
boolean 					true false		布尔型（对错） 1bit
char						'a'		字符型 2字节

对象类型（个数无法确定，简单分类）
class
interface
数组
String

小于 int 型 的 相互操作 自动 变为int以上

不同类型：操作，结果以大类型为准
相同类型操作，是什么就是什么
注意：小于int 类型的操作 自动变成int

float 和  double
默认小数的字面量 是double类型；
float f1＝3.3f；

字符串与任何类型（基本数据类型，对象类型）变量相加操作，就是字符串的拼接

二、运算符号
//数学运算
+-*/ % () =
//比较符号
> >= < <= == != !
//逻辑符号
并且&& 或者||
//复合运算符
+= -= *=...
//自增，自减符号
++ --
//位运算符号：
& | ^ ~
//位移运算符
<<,>>,>>>
//三目运算符
?  	:	 :
[] {} ; ,

8.6
三、程序的结构
顺序结构：自上往下
分支判断：if..else if...else,switch..case(break),三目运算符?:
循环结构：do...while,while,for

8.7
四、数组
1、.字面量方式定义，不能作为重新赋值的语句
int[] datas= {1,23};
datas = {2,3};//不可以
2、定义的时候，赋值为null
int[] datas = null;
int ele = datas[0];
//后续的操作会出现空指针NullPointerException	这叫运行期错误（异常）
3、定义的时候，没有赋任何值
int[] datas;
int ele = datas[0];
//编译的时候，会出现，尚未初始化变量谁谁

4、使用的时候，如果出现非法的下标
int[] datas = {1,3};
int ele = datas[2];
//运行时会报ArrayIndexOutOfBoundsException

常用的操作
设值
取值
遍历（循环取值，从头到尾）
1.普通循环代码写的多，控制力度强
2.forech有局限性，jdk要求，不能从右到左，控制力有限

数组排序：
int[] arr = new int[]{1,3,2,4,7,5};
java.util.Arrays.sort(arr);
for(int ele:arr){
System.out.println(ele);
}
多维数组，常用的是二维，最多不超过三维

四、字符串对象(java.lang.String类)

=============JAVA_面向对象===================
8.8
//class 类名{}命名规则牢记
//	变量命名规则

类的组成成分（由那些“东西”组成）
1.属性（很像之前定义的变量）

2.构造方法：命名规则 与类名同名！！！
作用：为属性赋值（提供机会给程序员，用与否在于程序员）
构造方法的重载：重载定义（参数列表不同，或者相同位置上类型不同）
默认编译器会安排一个无参的构造方法（不定义任何构造方法的前提下）
this关键字的使用：2种用途：本类对象，调用本类的其他构造方法（必须是第一句）

3非构造方法
普通方法的定义  返回值类型_方法名称（签名）_参数类表_{_逻辑代码_}
调用是通过对象打点的方式调用

类中的成分之一（构造方法)
构造方法的作用:对属性进行赋值
构造方法的重载(overload)：有多个构造方法定义，只是参数列表的个数不同或者相同的个数而对应位置上类型不一样
this关键字

8.9
//字符串（对象类型）
//!!!!
//取得参数所对应下标的字符返回
char charAt(int index);

//!!!!
//把字符串变成字符数组返回
char[] toCharArray();

//把字符数组变成字符串
new String(char[]) String.valueOf(char[]) 遍历数组+" " 拼接字符串

//!!!!
//获取字符串中字符的个数（长度）
int	length();

//测试字符串是否是空字符串（空字符串不同于null)
boolean isEmpty()//???jdk>=6

//取得参数表示下标的字符对应的unicode码值
int codePointAt(int index);

//取得参数表示下标之前一位字符的码值
int codePointBefore(int index)

//比较字符串出现在字典中的顺序
int compareTo(String otherStr)
"a".compareTo("b")//-1

//比较字符串出现的字典顺序（不区分大小写）
int compareToIgnoreCase(String otherString)

//!!! +
//拼接字符串(通常使用+操作来取代concat）
String concat(String otherString)
"a".concat("b");//"ab"

//测试包含参数字符串
boolean contains(String otherString)
"ab".contains("a");//true
"ab".contains("c");//false
//没有containsIgnoreCase,但可以使用其他的机制来完成这个功能
//toLowerCase
//toUpperCase

//!!!
//字符串变大，小写
String toUpperCase();
"a".toUpperCase();//"A"
"AB".toUpperCase();//"AB"

String toLowerCase();
"AB".toLowerCase();//"ab";
"Ab".toLowerCase();//"ab"

//!!!!! equals
//测试参数与调用者字符串内容是否相同
boolean contentEquals(String otherString)
"a".contentEquals("a");//true
"ab".contentEquals("a");//false
//多数使用equals,equalsIgnoreCase

"a".equals("a");//true
"A".equals("a");//false;
"A".equalsIgnoreCase("a");//true

//把字符数组变成字符串返回
String copyValueOf(char[] chArr);
String.copyValueOf(new char[]{'a','b'});//"ab"

String.copyValueOf(new char[]{'a','b','c'},1,2);//"bc"

//!!!!
//以参数字符串开始，startsWith
//以参数字符串结尾，endsWith
boolean startsWith(String otherString)
"abc".startsWith("a");//true
"abc".startsWith("abc");//true

boolean endsWith(String otherString)
"abc".endsWith("abc");//true
"abc".endsWith("ab");//false

//把字符串赋值到字符数组中
void getChars(int startIndex,int endIndex,
char[] charArr,int toStartIndex);
//startIndex:表示字符串中开始下标
//endIndex:表示字符串中结束下标（不包含在内）
//charArr:目标字符数组（字符串中的字符将要复制到的数组）
//toStartIndex ：字符数组准备接受第一个字符的下标

String str = "abcdefg";
char[] chArr = new char[3];
str.getChars(1,4,chArr,0);

chArr//{'b','c','d'}

8.10
//数组的拷贝
int[] datas = new int[]{1,2,3};
int[] datas2 = new int[3];

System.arraycopy(5参数）
//字符串余下的部分(String)
//String的兄弟类（StringBuffer，StringBuilder）
StringBuilder-单线程,快于 StringBuffer,建议使用
StringBuffer--多线程
8.13
//非构造（成员方法）方法的重载
类似构造方法的重载，至少会定义

//初始化块，static 静态块，静态成员
功能：类似构造方法，对数据成员进行初始化的

//变长参数方法

//属性的getter和setter方法（封装） 属性不要在类外被直接访问

//类的继承extends
继承的好处:代码复用，少些代码完成同样的功能

继承带来的问题:子类构造方法调用，还会先调用父类的无参构造方法，一直到Object类

方法的重写（override）
调用父类的方法，结果子类对象的逻辑在执行（多态）

8.14 - 8.15
//多态机制

//软件包概念(package)
访问修饰符
作用
种类
private:只能在类的内部访问
[default]：默认的，同包中可见
protected：同包中可见，异包中的子类可见
public:任何人任何场合都能访问这个修饰符修饰的变量和方法

只要是方法（构造方法，和普通方法）通常都是public
只要是属性通常是private
如果涉及到继承中的父类，那么属性可以选用protected
default不推荐使用

编译器提供的无参构造方法，其实是public的！！！

访问修饰符修饰数据成员和方法都没有问题
修饰类的话只能使用public和default

静态方法一般也是public的

private修饰的方法，用途是这个方法作为一个辅助方法
帮助另一个方法解决部分问题

8.16
final 修饰符
修饰类:不能被继承
修饰方法：不能被重写
修饰变量：常量不能被修改

抽象类
定义:关键字abstract
注意：有抽象方法的类必定是抽象类，
抽象类不一定有抽象方法

//非抽象类（具象类）
与非抽象类的不同:1.abstract 2.抽象类中可以有抽象方法
抽象方法的定义？
和普通方法一样，就是在方法定义上多了一个abstract关键字
另外抽象方法是没有方法体的（没有左大括号和右大括号封闭)

特征（作用）
1.把若干个类中共性部分提取出来定义到某个类中
因为共性的东西主要是为了复用，所以产生对象是没有
意义的，对于这种类就不应该能产生实例，这时
这个类最好定义成抽象类（不能实例化）

2.抽象类中有抽象方法的时候，必须要求子类重写所有
的抽象方法，否则子类编译不过。
不重写父类的抽象方法子类变成抽象类也可以
（必须重写抽象方法）

接口（也和类一样是一种自定义类型，级别一样）
定义：关键字与类关键字(class)不同，其他都差不多

与抽象类的比较
抽象类包含接口中的东西
接口中有常量和抽象方法

相同点：都不能实例化
不同点：抽象类有成员变量和非抽象方法，
接口有抽象方法，和常量没有其他东西

抽象类能被单根继承
接口能被多重继承

抽象类重量级：既有数据又有做什么事本领

接口轻量级的
关注点不一样：接口关注的是能做什么事

内部类
A
内部类就是一个类中定义另一个类
而这个类可以加上4个访问修饰符，另外加static也没有问题
B
内部类总的来说可以访问外部类的所有信息
静态内部类只能访问外部类的静态信息

C
实例化内部类怎么做？
非静态内部类是这样
Outer outer = new Outer();//先构造外部类对象
Outer.Inner i = outer.new Inner();//再通过外部类对象去构造内部类对象

静态内部类做法
Outer.Inner3 ii = new Outer.Inner3();
D
内部类如果有属性名或者方法名与外部类同名
那么如何外部类中的属性或者方法。
同时如果访问自己的属性和方法

E:以上介绍的代码都是在类中定义类（内部类）
其实内部类也可以定义在方法中(不能加访问修饰符）
匿名内部类:针对接口和抽象类{}
8.17
对象的复制(clone)
对象的复制（产生新对象）

CloneNotSupportedException

1.准备克隆的类要实现java.lang.Cloneable接口
2.重写父类Object中的protected Object clone()方法
3.调用的时候通过对象的clone()方法返回一个新对象
clone() 也是产生对象的一种方式
//	（克隆出来的对象和原对象不指向同一个内存地址）

Object中的方法介绍

equals方法，如果子类重写了equals，
那么子类间的==，equals方法比较是不一样的
重写的子类常见的有8个包装类型和String

字符串对象通常使用equals比较，不光比较内存地址，同时
也比较字符串内容！！！

5方法
clone()克隆对象
finalize()垃圾回收器回收对象时调用被回收对象的此方法
int hashCode()返回一个数字

String toString()返回对象的字符串表现形式

equals比较对象内存地址是否相同

===========JAVA_Exception===========
8.20
Error，Exception

概念：（Exception）程序中的错误，是程序员应该去处理的
（Error）程序中的严重错误，是程序员不应该去处理的
继承图谱、
java.lang.Object
|
|
java.lang.Throwable
|																	|
|																	|
java.lang.Exception						java.lang.Error(到此为止，知道子类通常是XXXError）
|							|
|							|
编译期异常（检查异常）   运行期异常（非检查异常）

8.21
顶层类java.lang.Throwable
java.lang.Error,java.lang.Exception

Exception分类
编译期异常（编译之前一定要提供解决方案，否则编译不通过）
运行期异常（编译之前可以不予考虑提供解决方案）

解决方案2种：
1.
try..catch(多个catch)...finally

2.在方法定义的时候声明异常:throws XXXException

另外还有一个关键字throw
通常在逻辑代码中碰到某个条件，throw 异常的实例

===========JAVA_IO===========
8.22
File类
1.File类表示物理文件或者文件夹

File f = new File(c:\\abc.txt);

File f2= new File(c:\\bbb);
2.不同操作系统上面的文件路径分隔符不一样
windows：\
unix:/
File.separator

什么是输入输出
目前而言：读取键盘输入内容；读文件中数据；写数据到文件等等
输入：输入源（键盘，鼠标）===>输入目标（计算机内存）
把一切东西东西“送入”内存中

输出：输出源（内存）===》输出目标（显示屏）
把内存中的一切“送出”内存
8.23
字节输入输出流
InputStream					OutputStream //父类 抽象类
FileInputStream			FileOutputStream //文件
BufferedInputStream		BufferedOutputStream //缓冲
ByteArrayInputStream		ByteArrayOutputSteam //字节数组
ObjectInputStream			ObjectOutputStream //对象 类要实现序列化

RandomAccessFile随机访问文件

序列化（serialize）：就是把对象经过某种格式编码成字节数组的过程
反序列化：把字节数组经过某种格式反向的编程对象的过程

某个类的对象能否通过对象流进行读写，还要看
这个对象所对应的类是否实现java.io.Serializable接口

不实现java.io.Serializable接口
会出现的异常java.io.NotSerializableException
transient所修饰的属性不参与序列化

8.24
字符输入输出流
FileReader					FileWriter
BufferedReader				PrintWriter
InputStreamReader // 字节方式转换为字符方式

===========JAVA_集合===========
8.27
List 接口
子类ArrayList
Vector
LinkedList

以上3个List的子类，所擅长的地方不一样
ArrayList：特点底层是靠一个Object一维数组来维护内部的元素
优势就是数组的优势按下标访问，效率好
缺点删除，插入某个元素不方便

LinkedList：缺点：查询效率不如ArrayList
优点：增删改的效率很好

Vector：是多线程版本的ArrayList
多线程安全（执行效率低）

// lise 和 set 区别：set（只有一个null，没有重复的元素，不保证排序）
Set 接口
实现类
HashSet
LinkedHashSet
TreeSet

排序 TreeSet
元素必须实现Comparable，并重写int compareTo(Object otherEle)
或者
构造TreeSet的时候，传入java.util.Comparator对象
Comparator是接口，抽象方法
int compare(Object ele1,Object ele2);
排序规则，返回值为负数放在左边位置，正数放在右边位置，0认为相同

8.28
Map 接口 // map 可以认为是List 和 Set的集成（无序，惟一性，访问快）
HashMap
Hashtable
Properties
（键，值）
方法：
put()
Object get()
int size()
clear()
remove(键) //删值
bolean containsKey（Object）//测试莫个键是否存在
//遍历
一、
Set keySet（） //把 Map键收集返还Set类型
二、
Collection Values（） 把值作为集合返回
三、
Set entrySet（） 复合型，键值对象遍历
<> // 泛型
==============Oracle=========
8.29
SQL语句分类,按照功能不同分成5类
DQL:Data Query Language
select ..... from .....
DML:Data Manipulation Language
insert增加  update修改  delete删除
TCL：Transaction Control Language
关于数据增删改的事务控制	rollback	commit savepoint
DDL：Data Definition Language
数据的定义	表的增加，删除修改。。
DCL：Data control Language
数据控制语言
授权和撤销权限。。 	grant	revoke
-----------
select 列
from 表
where 过滤行 //能在where 过滤的 不要留到 having 过滤
group by 分组
having 分组过滤  //having中的条件判断不能使用计算列的别名
order by 排序//desc asc //可以使用计算列的别名
8.30
连表查询：
按连接类型分类
内连接 :emp,dept  e.deptno=d.deptno
外连接:emp,dept  e.deptno=d.deptno，满足内连接的基础上，把因为null值匹配不了的记录也给显示出来
外连接分成左外连接和右外连接，全外连接3种
自连接:自己连接自己
//连表查询，连接条件至少是n-1个
左外连接
select e.deptno,e.ename,d.dname from emp e,dept d where e.deptno=d.deptno(+); //oracle语法
select e.deptno,e.ename,d.dname from emp e left outer join dept d on(e.deptno=d.deptno); //标准语法

右外连接
select e.deptno,e.ename,d.dname from emp e,dept d where e.deptno(+)=d.deptno;
select e.deptno,e.ename,d.dname from emp e right outer join dept d on(e.deptno=d.deptno);
全外连接
select d.deptno,d.dname,e.ename from emp e full outer join dept d on(e.deptno=d.deptno);

子查询分类：
嵌套子查询：子查询可以单独作为一个完整的查询，并查询出结果
相关子查询：子查询的结果必须依赖外部查询传递的信息才能查出结果，
子查询中的结果再作为外部查询的条件辅助外部查询完成最终查询

//dual虚表
//rownum 伪列

//exists:一般使用在关联子查询中，用来测试行存在的可能性
select e.deptno,e.ename,e.sal from emp e
where
exists
(
select avg(e2.sal) avgsal from emp e2
where
e2.deptno=e.deptno
having
e.sal>avg(e2.sal)
)

8.31
#内置函数
#单行函数
#多行函数（聚合函数，组函数）

9.3
1.操纵数据(DML)
对数据库表中的数据进行增删改的操作
//insert:插入行到表
insert into emp values(..,..,......);
insert into emp(empno,ename,sal)values(..,..,..);
//delete：删除表中行
delete [from] emp where ...

delete from emp;//删除emp中所有行 （DML）
truncate table emp;//清空表emp（DDL） 不能rollback
//update：更新表中的行
update emp set .. where ...

//merge合并表
merge  into emp2 e2 using emp e
on(e.empno=e2.empno)
when matched then
update set e2.ename=e.ename
when not matched then
insert  (e2.empno,e2.ename) values(e.empno,e.ename);

9.4
//.表的管理(DDL)
新建表 ：create table xxx
修改表结构:alter table xxx
重命名表:rename XXX to YYY
//建表
create table student(列名,类型) //建表
create table student(列名,类型 default '')
create table emp2 as select * from emp where 1=2;
default 默认给一个数据
schema //另一个用户名
//修改表结构
alter table student  //增加一列
add (regdate date default sysdate,phonenumber varchar2(11));

//修改（列的长度）
//a,没有数据的情况下，修改类型值大小//b.有数据情况，修改类型值大小，不能小于值的长度
//c.跨类型修改，例如：把varchar2改成number 要在没有数据的情况下［设置为null］
alter table student
modify phonenumber number;

//2.2修改（列的名称）
alter table student
rename column phonenumber to phone;
//3删除（删列定义）
alter table student //drop列的时候注意，表中至少要有一列
drop column (ID,name);

//把列设置成不可用 unused
alter table student
set unused column school;//单列
alter table student
set unused (列1,列2.....)//多列

//不可用，但磁盘空间仍然被占用
//可以使用下面一句让不可用，当占用磁盘的列被真正的删除
alter table student
drop unused columns;
//改表的名称
rename emp4 to emp400;
//删表
drop table 表名

5个约束
主键（primary key):就是唯一约束+非空约束
非空(not null):修饰的这列不能有空值
唯一（unique):修饰的这列中的值必须是唯一的
检查（check):这列的值必须满足检查条件
外键（foreign key):

create table student(
id number constraint pk_student primary key ,
name varchar2(10) constraint nk_name not null,
phone varchar2(11) constraint uk_phone unique,
birth date constraint ck_birth
check(birth between to_date('1970-1-1','yyyy-mm-dd')
and to_date('2000-1-1','yyyy-mm-dd')
)
);
//外键约束
前提要有一个主表，一个子表。
主表中是被引用的列（dept.deptno)
子表中式引用主表中的列（emp.deptno)

constraint fk_student_team foreign key(teamid)
references team(id)
//外键约束的级联删除，级联置空
on delete cascade
on delete set null

//禁用约束(disable|enable)
alter table student
disable constraint 约束名字

//删除约束
alter table student drop constraint 约束名

9.5
数据库中其他对象
视图：view [就是命了名称的select语句]
序列：sequence
索引：index
同义词：synonym

视图分成：简单视图，复杂视图
简单视图意味着可以发送DML语句操作简单视图
而复杂视图是不可以发送DML操作的
//创建视图：
create view view10 as
select deptno,ename,sal from emp where deptno=10;
//简单视图的修改
update view10 set sal=2000 where ename='CLARK';
//force强制视图创建成功，即使视图对应的基表不存在
create or replace force view view22  as  //修改视图
select * from emp2;

//创建序列
create sequence 序列名称;
默认是从1开始，每次递增1
currval,nextval

drop sequence xxxx; //删除序列

//创建索引
自动创建：如果列上是主键或者unique约束，那么oracle自动为这列创建唯一索引
手动创建：
CREATE index 索引名称 on 表(表中的列)
create index 索引名称 on 表(函数(表中列))

//删除索引
drop index 索引名称

高级查询：集合操作
minus:相减操作
intersect：相交操作
union| union all：联合操作|全联合操作

//oracle的树状结构表的查询
//start with connect by语句另外可以加上level伪列
select lpad(e.ename,length(e.ename)+(level-1)*2,'-') ename from emp e
start with mgr is null
connect by prior empno=mgr;
－－－－－
DCL:（数据控制语言）
授权和撤销权限
grant 权力 or 角色 to 用户
revoke 权力 from 用户
//创建用户
create user 用户名 indentified by 口令

grant connect,resoure to 用户名
============pl/sql============
9.6
语法：
declare //定义变量
v_ename vharchar(2)
v_ename vharchar(2):='xwq'
v_ename emp.ename%type   锚定变量[%type %rowtype]
begin
end;

打开控制台
set serveroutput on

//分支判断
if..elsif...else之外还可以使用decode

//循环结构
for i in [reverse] 1..v_num loop
dbms_output.put_line(i);
end loop;

while .. loop

end loop;
--基础循环
loop
end loop;

//停止循环的一种方式

if(v_num>5) then
exit;
end if;
或者
exit when v_num>5;

9.7
系统定义异常（相当于jdk中的NullPointerException)
预定义异常(java中没有对等产物）
raise_application_error(number[-20000~-20999],varchar);
自定义异常：(相当于我们之前员工管理里面的WorkerOperationException)
XXX exception;(declare中）//定义异常
raise XXX （begin中）//抛异常
exception when XXX  then(exception中）//异常处理
异常代码结构
BEGIN
EXCEPTION
WHEN excep_name1 THEN
…
WHEN excep_name2 THEN
…
WHEN OTHERS THEN
…
END;
－－－－－－－－
存储过程    [可以重复利用的，相当于方法]
create or replace procedure proc_helloworld as
调用方法：
1.begin
proc_helloworld();
end;
2.sql命令行中执行
execute proc_helloworld

参数模式：
in //不能修改
out //不能看 能修改
in out // 能看到，也能修改
两种模式，必须在调用的时候传入*变量*
主要是为了，过程调用完毕之后的返回值
9.10
游标:
分类：
隐式游标（在执行DQL,DML的时候自动创建，通常用的不多）
显式游标（大部分情况下，程序员操作的是显式游标）

步骤：
declare
cursor cur_emp is select * from emp;--定义游标（变量）
begin
open cur_emp;--打开游标
fetch cur_emp into v_deptno,v_dname,v_loc; --操作游标
close cur_emp;--关闭游标
end;

－－－－－－－－－－
cursor 游标
procedure 过程
function 函数
trigger 触发器
=============JDBC=============
9.11
数据库连接类型
4种:
数据库连接类型
JDBC-ODBC(type1):	什么是ODBC：Open DataBase Connection
jdbc-native(type2):java访问c写的访问数据库代码
jdbc-net(type3):java访问一些第三方中间件（服务器），通过中间件来间接访问数据库
jdbc-thin(type4):	纯java程序访问数据库

四要素：
String username = "scott2";
String password = "tiger";
String driverClass = "oracle.jdbc.OracleDriver";
String url = "jdbc:oracle:thin:@172.16.1.10:1521:tenera";

Class.forName(driverClass);
conn = DriverManager.getConnection(url,username,password);
String sql="";
stmt = conn.createStatement();
rs = stmt.executeQuery(); //executeUpdate()

终端运行的命令：
编译：javac TestJDBC.java
运行：java -cp .:ojdbc14.jar TestJDBC
9.12
conn.setAutoCommit(false); //默认commit 是 true
conn.commit();
conn.rollback();

conn.createStatement 第一个参数：
ResultSet.TYPE_FORWARD_ONLY; 不能滚动
ResultSet.TYPE_SCROLL_SENSITIVE; 在修改数据后能识别出
ResultSet.TYPE_SCROLL_INSENSITIVE;
{getRow() relativer() absolute()....}

conn.createStatement 第二个参数：
ResultSet.CONCUR_READ_ONLY;不可以修改数据库信息
ResultSet.CONCUR_UPDATABLE; 可以修改数据库的信息
updateDouble() updateRow()
deleteRow()
moveToInsertRow() updateXXX() insertRow()

Statement的子类:
PreparedStatement(预处理语句),批量处理问题batch
CallableStatement（调用存储过程）

PrepareStatement 和 Statement 的对比：
1、防止sql注入
2、效率高

批量效率：PreparedStatement+batch>PreparedStatement>Statement=batch

大对象操作clob,blob:
===============Thread=================
9.13
创建2种方式:
继承java.lang.Thread类
实现java.lang.Runnable接口，并重写run方法
Thread t= new Thread(r); r是个 实现接口类的对象
t.start()

Thread Thread.currentThread(); 当前线程

方法：
setName()
gettName()
getId()
getPriority() 优先级
setPriority()
jion //等待 调用对象的人  结束
yield //放弃cpu分配当前的时间
MAX_PRIORIYT 最大 10
MIN_PRIORIYT 最小 1   最好不要使用，可以放到同一个线程中运作
NORM_PRIORIYT 正常 5

void interrupt //中断(true)：是中断 内部的  状态（默认是非中断） 在中断的时候不能在睡觉（sleep()）
boolean static interrupted //返还两种结果1、改变中断状态 2、报异常
//返回当前线程 的 中断状态
//重置 当前状态为 false
boolean isInterrupted() //判断 状态是否为 中断或者非中断状态

interrupt 和  isinterrupted 的搭配可以完成一个线程停止另一个线程的任务
不要使用Thread类中的stop方法来完成以上功能
因为stop方法有问题。
//一个线程让另一个线程停止的方法
//[可以用interrupt 和 isinterrupted 搭配使用]［利用一个中间的boolean 控制达到效果］

9.17 *******
一、synchronized 同步技术
两种方法：

public synchronized void run(){}
------
public void run(){
synchronized(this){

}
}

如果是 static void run()
//static方法，synchronized获得的锁不是this的锁
//而是这个类Class的对象的锁
//java中每一个类加载到jvm中的时候
//jvm会为这个类生成一个Class类型的对象
//这个对象就是用来“管理”这个类的

Class c = StaticPrinter.class;
synchronized(c){

}

二、notify,notifyAll,wait

//notify 一般不用
注意：需要  在 synchronizefd  需要while()

三、死锁

//防止死锁，按照顺序  abcd。。。。

四、线程的状态
//一张 过程图

=============JAVA_GUI=================== [jse_gui]
9.18
1、图形用户界面（GUI）graphic user interface

Component--Container--Window--Frame--JFrame

//组件（6-8）分类：容器组件，非容器组件 java.awt.Component
//布局管理器（2-3）:在容器组件中，以怎样的方式安排其他组件
Container c = f.getContentPane()
c.add(btn,BorderLayout.NORTH);
//c.add(Jpanal,BorderLayout.NORTH);
//组件的事件（3）：当用户点击鼠标或者键盘之后，执行的某件事
------------------------------------------------------------------
JFrame f = new JFrame();//构造界面类对象
f.setTitle("你好第一个GUI程序");
f.setSize(500,350);
JButton btn = new JButton("按钮");
btn.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent ae){
JOptionPane.showMessageDialog(f,"你好，欢迎学习Swing程序");
}
});
Container c = f.getContentPane();
c.add(btn,BorderLayout.NORTH);

f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setVisible(true);//显示界面
-------------------------------------------------------------------
三种布局方式：
BoderLayout	（JFrame 默认布局）
FlowLayout 流式布局（JPanal 默认布局）
GridLayout 网格布局
JFrame 容器组件
setTitle 设置标题
setSize	设置宽度和高度（界面大小）
setBounds	边界（界面大小，x，y）
Toolkit

JPanel二级容器，主要用来安排组件的位置

//非容器组件
JButton	 //按钮
JLabel	//标签
JTextField	//文本框 [get.Text() set.Text()]

JPasswordField
JTextArea //文本域	//	通常搭配一个滚动条在他"身上"
//JScrollPane 也是一个容器
//JScrollPane js = new JScrollPane(ta);

JCheckBox  //多选按钮
JRadioButton	//单选按钮默认是可以多选的,要真正的实现单选按钮，
//必须加入一个按钮组的对象,来管理他们（ButtonGroup)
JComboBox  //下拉框
三种添加数据的方式： 数组、vertor<String>、moder
//model = new DefaultComboBoxModel();
//model.addElement("南京");
//model.addElement("苏州");
JTree //树
==================JAVA_网路编程=======================(jse_net)
Socket		--------------》	ServerSocket
Socket
InputStream				InputStream
OutputStream				OutputStream
1。发送请求（输出流）		2。接受请求（输入流）
4。就收响应（输入流）		3。相应请求（输出流）
。。。。
5。关闭连接				6关闭对此客户的连接

//TCP/IP
服务器：
int port = 8888;
ServerSocket server = new ServerSocket(port);

Socket socket = server.accept();

创建输入输出流

服务器，先接受，后发送

关闭资源

客户端：
int port = 8888;
String ip = "127.0.0.1";
Socket socket = new Socket(ip,port);

创建输入输出流

服务器，先发送，后接收

关闭资源
----------键盘读数据-------------------
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
br.readLine();
----------------------------
//UDP

同一个类 DatagramSocket

//服务器
DatagramSocket server = new DatagramSocket(2222);

byte[] buff = new byte[1024];
DatagramPacket p = new DatagramPacket(buff,buff.length);
server.receiver(p);

InetAddress add = p.getAddress();
int port = p.getPort();
byte[] datas = p.getData();
int datalen = p.getLength();
String contents = new String(datas,0,datalen);
System.out.println(..............);

//客户端

DatagramSocket client = new DatagramSocket();

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String line = br.readLine();
byte[] datas = line.getBytes();
int len = datas.length;
DatagramPacket p = new DatagramPacket(buff,0,len,InetAddress.getAddress("loaclhost"),2222);
client.send(p);

===================JAVA_反射==================
9.20
三种创建Class对象的方法：
一、String.Class

三、Studetnt s = new Student();
s.getClass();

四、Class.forName(字符串的包名+类名全限定名);

------------------------------------------
反射API
Class：管理类的类型
可以获得Constructor信息：getDeclaredConstructors(); getDeclaredConstructor(Class...)
可以获得Field信息：getDeclaredFields,getDeclaredField(String fieldName)
可以获得Method信息：getDeclaredMethods,getDeclearedMethod(String methodName)
Constructor：构造方法对象
getName去的构造方法签名
Class[] getParameterTypes去的参数列表
Field：类中属性
getName去的属性名称
getType去的属性的类型
Method：类中方法
getModifiers()取得访问修饰符
Class	getReturnType():去的返回值类型
getName去的方法名称
Class[] getParameterTypes()获得方法的参数列表
Array：数组

动态代理
Proxy
类中信息：
1、属性	Field
2、构造方法 Constructor
3、方法 Method
========================复习==========================

native2acsii
char默认值 \u0000

double 计算不精确

BigInteger
BigDeicmal

栈：放变量的
堆：放对象的

同一个对象才能互相引用

排序：
选择排序
冒泡排序
插入排序

只能创建一个对象的实例的方法：
一、调用java命令时

二、创建对象时

三、访问静态成员时

四、Class.forName("包名.类名")

//用空间换时间
public class C{
private static C c;
static{
c = new C();
}

public static void getC(){
return c;
}
}
//用时间换空间
public class C{
private static C c;

public static void getC(){
if(c!==null){
c = new C();
}
return c;
}
}
耦合度有高到底：
is a
继承
实现

has a
组合：人和心脏
聚合：汽车和发动机
关联：人和汽车

use a
依赖： 人和火车

uml图：
继承：空心三角形－实线－指向父类
实现：空心三角形－需线－指向接口
组合：实心菱形－实线－菱形指向（人）－箭头指向（心脏）
聚合：空心菱形－实线－菱形指向（汽车）－箭头指向（发动机）
关联：实线－箭头指向（汽车）［人－－－》汽车］
依赖：虚线指向（火车）［人－－－>火车］

x.equals(s);
x不能为null

接口：
Compareable
Comparetor

可变长参数 只能出现在最后一个

泛型：类的参数，表示类型    ｜就像方法的参数

集合：Collection
Collevtion
|		|
ArrayList   Set
|				|
|			HashSet TreeSet8tttffdfdfwww``
ArrayList vector LinkedList

List: add(); get(); size() ; for循环
Set:add(); for循环
Map: put(,); get(); put(,)--修改操作

set:
Iterator it = set.iterator();
while(it.hasNext()){
Object o = it.next();
}
迭代器只能用一次｜不能并发删除 调用迭代器的remove() 方法

迭代器 Iterator
注意
迭代器用完无效，指针已经到最后，需要重新获取
循环内只允许做一次next()
在迭代器内做删除，调用迭代器的remove()，不允许调用集合的remove()

HashSet 用  HashMap 实现的

Map:
遍历：
m.
m.entrySet();

哈希散列表
Hash表判断放入元素不重复的方法
1.调用对象的hashCode()，得到hash码
2.通过哈希散列算法，得到哈希表里的位置
3.如果当前位置没有元素，直接放入 retrun
4.如果当前位置有元素，调用equals()
5.如果返回为true，舍弃（HashSet）或覆盖（HashMap） return
6.如果返回为false，在当前位置以链表形式追加

Stack 有bug  要封装 ［截图］

//Date>>>>String
DataFormate dateformate = new SimpleDateFormate("yyyy年－MM月－dd号－hh点－mm分－ss秒");
Date date = new Date();
String dateString = dateformate.formate(date);

//String >>>>Date
Date newDate = dateformate.parse(dateString);

FileReader 一般只能读GBK编码的文件，用InputStreamReader包装成UTF-8

3层结构

表示层
用于实现显示逻辑
控制层
用于跟用户进行数据交互
并连接业务功能与视图逻辑
调用业务层完成核心业务逻辑

业务层
处理核心业务逻辑
包含业务流程的组织,事务管理,等交叉业务逻辑
并调用持久层完成数据持久化操作

持久层
处理单一的访问持久化设备的操作

域层:
要实现 序列化  Serializable();
private Integer id;// 包装类型
必须要有无参的构造方法

mysql:
mysql -u root
show dababases
create database xwq charset=utf8;
use xwq
show tables
auto_increment

============Hibernate============
10.9
Configuration cfg = new Configuration();
cfg.configure(); //加载配置文件 hibernate.cfg.xml Xxx.hbm.xml
SessionFactory sf = cfg.buildSessionFactory();

Session session = sf.openSession();

Person p = new Person();
p.setXXXX();

session.getTransation().begin();
session.save(p);
session.getTransation().commint();

Hibernate核心api
Configuration 用于解析hibernate.cfg.xml和Xxx.hbm.xml,并创建SessionFactory对象
SessionFactory 用户创建Session，很消耗资源的，线程安全的，做成单例
Session	持久化管理器，线程不安全的 1加锁synchronized 2不要将Session写成成员变量（属性）
Query XxxQuery 对对象做持久化查询操作
Transaction 事务管理器

注意：同一个session 没有commit rollback 不管获取多少次是同一个seesion
======
10.10
======
CRUD  增删改查

动态DML
dynamic-insert="true"
dynamic-update="true"

hibernate 对象的状态
临时态
内存里有，
而数据库没有一条记录跟他对应，
对象没有被Session管理
持久态
内存里有，
而数据库中有对应的记录，
这个对象被Session管理，
对象的状态改变，数据库会更新
游离态
内存里有，
而数据库中有对应的记录，
这个对象没有被Session管理
无名态	内存里没有，而数据库中有记录
－－－－－－－－－－
//增加
public static void insert(Person p){
session.save(p);
//session.saveOrUpdate(p); //数据库有相同的id就更新，反之就插入
}

//删除 根据id
public static void delete(Integer id){
Person p = new Person();
p.setID(2);
session.delete(p);
}

//删除 根据 Person
public static void delete(Person p){
session.delete(p);
}

//修改
public static void update(Person p){
session.update(p);
//session.saveOrUpdate(p);
}

//查询 根据id
public static Person selectById(Integer id){
session.get(Person.class,id);
//session.load(Person.class,id) //有取值后再查询  p.getName(); 后执行查询

//load 有延迟加载，如果对象不存在，抛出异常
//get  没有延迟加载，如果对象不存在，返回null
}

//查询所有
public static List<Person> select(){
List<Person> persons = null;
String hql = "from Person";
Query query = session.createQuery(hql);
persons = query.list();
}

// 查询 根据name
public static List<Person> selectByName(String name){
List<Person> persons = null;
String hql = "from Person p where p.name = ?";
// String hql = "from Person p where p.name = :name"; //name随便写
Query query = session.createQuery(hbl);
query.setString(0,name);
//	query.setString("name",name);
persons = query.list();
}
=====
10.11
=====
分页技术：
Query
setFirstResult(int)//开始位置  hibernate 从0开始
setMaxResults(int)//个数
setXxx()
list()
uniqueResult() //唯一结果
executeUpdate()

persons = session.createQuery(hql).setFirstResult(3).setMaxResults(4).list();

//通过id 和 sex 更新 sex
public static void updateSexById(Integer id, boolean sex) {
//先查询 后更新(方法一)
Person = session.get(Person.class,id);
person.setSex(true);

//直接更新（方法二）
String hql = "update Person p set p.sex=:sex where id=:id";
session.createQuery(hql).setBoolean("sex", sex).setInteger("id", id).executeUpdate();
｝

//通过name 查 person
public static void selectPersonByName(String name) {
//返回一条结果  方法一
String hql = " from Person where name = :name";
p=(Person) session.createQuery(hql)
.setString("name", name)
.uniqueResult();
//返回多条
String hql = " from Person where name = :name";
list=session.createQuery(hql)
.setString("name", name)
.list();

//返回 id 和  name 结果 是person 对象的
String hql=new StringBuffer()
.append("select new Person(p.id,p.name) ")
.append("from Person p ")
.append("where p.name=:name")
.toString();
p=(Person) session.createQuery(hql)
.setString("name", name)
.uniqueResult();
//返回 id 和 name 的 结果 ---是个objet 对象

String hql=new StringBuffer()
.append("select p.id,p.name ")
.append("from Person p ")
.append("where p.name=:name")
.toString();
arr=(Object[]) session.createQuery(hql)
.setString("name", name)
.uniqueResult();
//返回是个Map 对象的 结果
String hql=new StringBuffer()
.append("select new Map(p.id as id,p.name as name)")
.append("from Person p ")
.append("where p.name=:name")
.toString();

map=(Map) session.createQuery(hql)
.setString("name", name)
.uniqueResult();

}

cascade属性设置级联操作
none			不使用
save-update		保存-更新
delete			删除
all			save-update-delete
delete-orphan		删除时，级联删除孤儿
all-delete-orphan	全部级联

关系映射类型：
多对一
一对一
一对多
多对多
继承
组件

多对一（emp－dept）
Emp.hbm.xml:
<many-to-one name="dept" column="dept_id" class="Dept" fetch="join"></many-to-one>

test:

String hql=new StringBuffer()
//					.append("select e ")
.append("from Emp e ")
.append("left join fetch e.dept d ")
.toString();

emps=session.createQuery(hql).list();

说明：
默认情况下
多对一情况下
从多方根据id查询一方
关联属性使用了延迟加载
------
fetch="join"
get时，级联抓取关联属性
如果没有配置，关联属性延迟加载

一对一（car－engine）
方法一：(
engine 中	 car_id 作为外键FK 和 唯一 UK
)

car.hbm.xml:
<one-to-one
name="engine"
class="Engine"
fetch="join" cascade="save-update"
property-ref="car"></one-to-one>

engine.hbm.xml:
<many-to-one name="car" column="car_id" class="Car" fetch="join" unique="true"></many-to-one>

说明：
property-ref="car"  //
unique="true"	// 保证唯一

test:
session.save(car);

方法二：（engine 中	 id 作为主键PK 和 外键 FK）
car.hbm.xml:
<one-to-one name="engine" class="Engine"
fetch="join" cascade="save-update"></one-to-one>

engine.hbm.xml:
<class name="Engine" table="engine2">
<id name="id" column="id">
<generator class="foreign">   // 注意：foreign
<param name="property">car</param>  // 注意：
</generator>
</id>
<property name="name" column="name"></property>
<one-to-one name="car" class="Car"
fetch="join"
constrained="true"></one-to-one>
</class>

说明：
constrained="true"  //

一对多（order－item）
Order(类)--有个属性是 Set<Item>
Order.hbm.xml:
<set name="items" inverse="true" cascade="all-delete-orphan">
<key column="order_id"></key>  //通过 order_id 知道 关联的
<one-to-many class="Item"/>  //集合中的类型
</set>

Item.hbm.xml:
<many-to-one name="order" column="order_id" class="Order"></many-to-one>

说明：
inverse="true"  //少了 update 操作
是否放弃关系维护权
默认情况下一对多中关系维护权在一方
=====
10.12
=====
一对多：
说明：一对多情况下从一方抓取多方会有重复对象
解决方法： .append("select distinct o ") [hibernate3.2解决了]

用户：xwq订单号：9
商品一：5 商品名：aaa 商品数量：1 商品单价20.00
商品一：6 商品名：bbb 商品数量：3 商品单价10.00
总价为;50.00

方法一：
order = (Order) session.get(Order.class, id);

方法二：
String hql = new StringBuffer()
.append("select distinct o") //查出多条结果需要
.append("from Order o ")
.append("join fetch o.user ")
.append("join fetch o.items i ")
.append("join fetch i.product ")
.append("where o.id=:id")
.toString();

映射：
类中有属性 －－表中没有（属性－－sql语句）  //hibernate 可以进行子查询
<property name="count" formula="(select count(*) from t_item i where i.order_id = id)"></property> // id 默认是当前的表的id

多对多（Student--Course）一般采用  两个多对一的 hibernate 也支持 但一般不用。

Student.hbm.xml:

<set name="courses" table="t_student_course">
<key column="s_id"></key>
<many-to-many class="Course" column="c_id"></many-to-many>
</set>

Course.hbm.xml:
<set name="students" inverse="true" table="t_student_course">
<key column="c_id"></key>
<many-to-many class="Student" column="s_id"></many-to-many>
</set>

=====
10.15
=====
继承映射：（User - Manager - Member）
三种方法：

一、一张表：所有属性都放在一张表中，用一个字段做区分
多态查询效率最高的，但会浪费数据库的空间
user
id
username
password
name
phone
status me/ma

User.hbm.xml:
class name="User" table="user">
<id name="id" column="id">
<generator class="native"></generator>
</id>

<discriminator column="status" type="string"></discriminator>  //  区分的字段 discriminator

<property name="username" column="username"></property>
<property name="password" column="password"></property>

<subclass name="Member" discriminator-value="me">  // 子类 subclass
<property name="name" column="name"></property>
<property name="phone" column="phone"></property>
</subclass>

<subclass name="Manager" discriminator-value="ma">
</subclass>

</class>

二、一个子类一张表：只有子类建表，包装自己的和父类的所有数据
节省空间，多态查询效率最低，如果不考虑多态查询时，效率最高
member
id
username
password
name
phone

manager
id
username
password

Member.hbm.xml:
<import class="User"/>  //多态查询，不写，也可以用 不能多态查询
<class name="Member" table="member3">
<id name="id" column="id">
<generator class="native"></generator>
</id>
<property name="username" column="username"></property>
<property name="password" column="password"></property>
<property name="name" column="name"></property>
<property name="phone" column="phone"></property>
</class>

Manager.hbm.xml:
<import class="User"/> //多态查询，不写，也可以用 不能多态查询
<class name="Manager" table="manager3">
<id name="id" column="id">
<generator class="native"></generator>
</id>
<property name="username" column="username"></property>
<property name="password" column="password"></property>
</class>

三、一个类一张表：一个类一张表，用外键做关系
节省空间，效率最低，不建议使用
user
id
usename
password

member
user_id
name
phone

manager
user_id

User.hbm.xml:
<class name="User" table="user2">
<id name="id" column="id">
<generator class="native"></generator>
</id>
<property name="username" column="username"></property>
<property name="password" column="password"></property>

<joined-subclass name="Member" table="member2">   // id有关联的子类 joined-subclass
<key column="user_id"></key>
<property name="name" column="name"></property>
<property name="phone" column="phone"></property>
</joined-subclass>

<joined-subclass name="Manager" table="manager2">
<key column="user_id"></key>
</joined-subclass>

</class>

组件映射
Person
id
Name name

Name
firstName
lastName
person
id first_name last_name

Person.hbm.xml:
<hibernate-mapping package="day05">
<class name="Person" table="person">
<id name="id" column="id">
<generator class="native"></generator>
</id>
<component name="name" class="Name">  			 // 组件 component
<property name="firstName" column="first_name"></property>
<property name="lastName" column="last_name"></property>
</component>
</class>

<query name="selectAll">   //hql语句 可以写在配置文件中
<![CDATA[					//test类的写法：persons=session.getNamedQuery("selectByName")
.setString("firstName", "aaa")
.setString("lastName", "bbb")
.list();
from Person
where id<:id
]]>
</query>
<query name="selectByName">
<![CDATA[
from Person p
where p.name.firstName=:firstName
and p.name.lastName=:lastName
]]>
</query>

</hibernate-mapping>

三种 query 方法
Query	官方文档中文15章
Criteria官方文档中文16章
SQLQuery官方文档中文17章