第一阶段java基础复习
1.软件开发基础
1.1开发软件的目的
提高人个计算机之间的交互方式
1.2软件
软件=数据+指令+文档
1.3软件开发
学习指令操作数据并编写使用说明书
1.4交互方式
1.图形交互方式
如：QQ thunder
2.命令行交互方式
如：DOS java
运行--》cmd
d:
cd
cd ..
cd \
dir
md
rd
echo "数据" >文件名
del
cls
exit
1.5软件的分类
1.系统软件
2.应用软件(需要开发的)
2.计算机语言
2.1计算机语言
是人和计算机交流的载体
2.2计算机语言的分类
基于过程的计算机语言
C
面向对象的计算机语言
java
3. java语言
3.1 java语言的介绍
SUN Oracle
詹姆斯.高斯林
1995.5.23日
标记：咖啡和公爵
JDK的发展历史
7.0 --> 1.7.0
3.2语言的特点
1.面向对象
2.扩平台的
3.编译型语言( C java )
解释型语言( javascript )
3.3环境搭建
1.下载
http://www.oracle.com
2.安装
路径中最好不要出现中文、空格
3.测试
进入到安装目录\bin在DOS窗口中输入：
java -version
4.环境变量配置
4.1永久设置
4.2临时设置
set
path： 设置java的开发工具所在的根目录(bin) %java_home%\bin;
classpath： 设置要运行的class文件所在的目录
java_home:为了避免频繁的修改paht环境变量提出来的。一般为JDK的根目录
5. JDK、JRE和JVM
JDK : Java开发工具集
JRE：Java运行环境
JVM：Java虚拟机，主要用于运行java的字节码(class)文件
JDK > JRE > JVM
6.程序体验
class HelloWorld{
public static void main( String [] args ){
System.out.println( "hello world!!" );
}
}
编译：javac HelloWorld.java
运行：java HelloWorld
4. java的基础语法
4.1关键字
length不是关键字
main不是关键字
staitc是
关键字严格区分大小写
保留字：goto
4.2标识符
java源代码中出现的各种名字(类名、包名、属性名、接口名、函数名、变量名、常量名)。
组成：数字、字母、_、$
约束:
1.不能以数字开头
2.区分大小写
类名|接口名： 单词首字母大写
属性名|函数名：从第二个单词开始首字母大写
常量：全部大写，单词之间使用_分隔
包名：全部小写，单词之间使用.分隔。每一个单词代表一个文件夹
是域名的反写。
4.3常量
正数常量34
小数常量34.0
布尔常量true false
字符常量'\n' '中' '\u0000'
引用常量null
4.4常量的表现形式
十进制默认16
二进制0001 0000
八进制020
十六进制0x10 F f
进制之间的相互转换
4.5变量
主要用于存储可变数据的容器。
4.5.1数据类型：
1.基本数据类型
整型
byte 1byte -128~127
short 2byte
int 4byte默认
long 8byte L
浮点型
float 4byte
double 8byte
布尔型
boolean4byte boolean[] 1byte
字符型
char 2byte
2.引用数据类型
数组类型
类类型
接口
4.5.2默认的数据类型
小数：double
正数：int
4.6注释
对程序进行显示的说明，给开发者看的。
1.单行注释//可以嵌套
2.多行注释/* */不能嵌套
3.文档注释/** */不能嵌套javadoc
4.6操作符
算术运算符
+
-
*
/ 0正数报错 小数无穷大
%结果的符号取决于第一个操作数
++
--
byte short char在运算的自动提升为int类型
赋值运算符
=
+=
-=
*=
/=
%=
自动的进行强制类型转换
byte a = 1;
a+=1; a = (byte)( a + 1 )
a = a+1;报错
比较运算符
==
>
<
!=
<=
>=
结果一定是布尔类型true false
逻辑运算符
&
|
!
^
&&当第一个表达式为false时候短路第二个表达式
||当第一个表达式为true时候短路第二个表达式
位运算符
&
|
~
^
全部采用数值的二进制补码方式进行运算。
原码：
反码：
补码：
正数的原码即为补码
负数的补码=反码+ 1
移位运算符
算术移位
>>
<<
最高位为符号位，当右移的时候最高位补全符号位。
左移的时候右边补0
逻辑移位
>>>最高位补0
4.7语句
每一条java语言后面需要加;
int a , b ;
顺序语句
判断语句
if(){
}
if(){
}else{
}
if(){
}else if(){
}...
当if或else控制的只有一条语句的时候{}可以省略。
选择语句
switch(){
case 1:语句
break;
case 2:语句
break;
default:语句;
}
switch中可以传递的参数只能是byte short int char枚举(enum)
原理：
先执行case再执行default与顺序无关
使用细节：
break是否存在
循环语句
while(){
}
do{
}while();
for(;;){
}
当循环的时候如果次数清楚，使用for，如果不明确使用while或do{}while();
其他控制语句
break:停止循环和选择
continue:继续下一次循环
都可以结合标签使用。
outer: for(;;){
break outer;
}
4.8代码块
使用{}包含起来的代码称之为代码块
1.隔离变量的作用域
2.将功能相同的语句进行封装
代码块的分类：
局部代码块：在函数中
成员代码块：在类的描述中
构造代码块：主要初始化对象的属性
静态代码块：主要初始化静态成员
4.9函数
封装具有独立功能的代码块。
函数定义的格式：
修饰符返回值类型函数名(参数列表)异常的声明{ //方法签名
//具备的功能
return返回值;
}
函数的调用：
[类名|对象名].函数名(实参);
函数的重载：
1.函数名相同
2.参数列表不同
顺序不同
类型不同
个数不同
3.与方法签名的其他部位没有任何的关系
4.10数组
数组是用来存储多个相同数据类型的变量的容器。
一维数组：
数组定义：
int [] a = new int[4];
数组初始化：
默认初始化：
new int[4] 0 0 0 0
静态初始化：
new int[]{23,45,67};
{45,576,78}
动态初始化：
for(;;){
a[i] = i+1;
}
数组操作常见错误：
1.数组的角标越界异常
2. null指针异常
3.数组一旦声明好不可变
4.数组的是引用类型变量，如果打印数组名，输出类型@哈希值的十六进制形式
5. []可以放在变量的前或后
数组操作：
1.遍历
for(; i < a.length ;){
}
2.求最值
遍历和比较
3.查找
值查找
索引查找
4.排序
遍历、比较、交换
5.反序
两个指针、判断、交换
6.去除重复值
二维数组：(存储一维数组的一维数组)
定义：
int [][] a = new int[4][];必须指定一维数组的长度
a[0] = null
初始化：
a = { {},{} };
for(;;){
for(;;){
}
}
重点练习以下打印几何图形。
5. OOP面向对象编程
5.1类和对象的关系
is a继承关系
has a组合或聚合关系
5.2类的描述
class类名{
//属性(变量)
//方法(函数)
//构造函数(函数)
}
5.3对象的创建
new关键字，在堆中开辟空间，存储对象的内容。
对象的成员访问：
对象.属性名;
对象.函数名(实参);
5.4构造函数
构造函数是特殊的函数。
1.函数名和类名一致
2.调用的时候使用new关键字
3.没有返回值类型也不能用void
4.构造函数主要用来初始化对象的属性
5.构造函数可以被重载
6.构造函数可以使用this和super进行相互调用
this访问本类中的其他构造函数
super访问父类的构造函数
7.如果描述一个类没有声明构造函数，那么编译器默认添加一个无参数的构造函数
但是如果开发者自己显示的定义了构造函数，那么编译器不会再创建无参数的构造函数。
8.子类的构造函数中默认在第一行会调用父类的无参数构造函数，可以显示的调用其他构造函数。
9.构造函数中调用构造函数的语句只能在第一行位置，所以只能调用一次。
5.5 this关键字
代表具体的一个对象，谁调用就代表是哪个对象。
1.封装的时候如果在函数中形参和成员属性命名冲突了，可以使用this加以区分。
2.可以调用本类中的其他构造函数
3.一定不能在静态上下文中使用this和super关键字
4.类中成员函数如果访问成员属性默认省略了this关键字
5.6 static关键字
static修饰的内容在类装载的时候就被初始化。主要存储在共享区。
static修饰类：该类只能是成员内部类，如果一个成员内部类中包含静态属性，那么该内部类必须声明为静态的
static修饰属性：多个对象之间该属性共享
static修饰方法：对象共享
static修饰代码块：初始化静态属性
static修饰的内容使用类名可以直接访问，但是也可以通过对象来访问。
5.7对象的初始化(构造代码块)
1.属性的声明
2.属性的默认初始化 正数0小数0.0布尔false字符'\u0000'引用null
3.显示初始化
4.构造代码块初始化
5.构造函数初始化
注意：构造代码块初始化和显示初始化的语句默认会按照出现的顺序加载到构造函数中去，
在构造函数本身代码之前。
5.8封装
为了提高代码的安全性，描述类的属性和方法的时候需要对属性和有些方法进行封装。
封装的实现：
封装属性：
1.私有化所有的成员属性
2.提供publie修饰的get和set方法
在设置方法中可以过滤无效数据。
封装方法：
1.将函数声明为private，此时该方法只能在该类中被使用。
5.9继承
主要用于解决类和类之间的数据重复，进而提高代码的复用性。
继承的实现：
class A extends B{
}
类A继承类B
继承的特点：
1.私有的成员子类无法继承
2.构造函数无法继承
3.静态的成员也无法继承
4.继承只能是单继承
5.10子类对象的初始化过程(super)
子类对象的初始化会先创建父类对象加以属性的初始化。
子类的构造函数中默认第一条语句super()调用父类的无参数构造函数。
注意：描述一个类的时候，一定要显示的定义无参数构造函数。
5.11函数的重写
前提：必须有继承
子类可以有和父类完全相同的函数。
函数重写的特点：
1.函数名和参数列表必须相同
2.子类的修饰符必须大于等于父类的修饰符
3.子类的返回值类型必须小于等于父类的返回值类型
4.子类的异常声明类型必须小于等于父类的异常声明类型
5.12 final关键字
final修饰类、属性、方法、形参
类：该类不能被继承
属性：是常量
方法：不能被重写
形参：函数中不能被修改，可以打印或使用
5.13抽象类
当一个类在描述的时候如果不清楚函数的具体实现，那么该函数可以被声明为抽象的，而该类一定要
为抽象类。
abstract class{
//属性
//构造函数
//函数
public abstract void print();
}
抽象类中不一定有抽象方法
但是包含抽象方法的类一定是抽象类。
特点：
1.使用abstract进行描述
2.不能被创建对象（实例化）
3.强制子类必须实现父类没有具体实现的函数
4.抽象类不能和final关键字一同修饰类
5.14接口
主要使用接口对类进行功能的扩展。
接口的定义：
interface A{
//静态常量
public static final
//公有的抽象方法
public abstract
}
接口的特点：
1.使用interface创建接口
2.不能被创建对象
3.需要子类进行实现implements
4.接口中可以相互多继承
5.实现类可以多实现接口
6.接口中定义的常量一定要初始化
7.接口中不能显示的定义静态代码块
5.15多态
前提：继承、重写
表现形式：
父类的引用指向子类的对象
多态下访问对象的成员：
如果子类重写了父类的非静态函数，那么调用该函数的时候一定调用子类的，其他访问的
都是父类的。
多态的应用：
1.形参
2.返回值类型
5.16内部类
将声明在一个类中的类称之为内部类。
内部类的分类：
成员内部类：
静态内部类：当内部类中包含了静态成员
私有内部类：当想要封装外部类的时候
局部内部类：
定义在函数中的类。
局部内部类中只能访问函数中fianl的属性。
内部类可以直接访问外部类的所有的成员。
外部类如果要访问内部类的成员，需要创建内部类的对象。
外部类.内部类a = new外部类().new内部类(); //创建一个非静态的内部类对象
外部类.内部类a = new外部类.内部类(); //创建一个静态内部类对象
匿名内部类：是一种特殊的成员内部类的简写形式。
abstract class A{
int x = 21;
abstract void add();
}
class B{
class C extends A{
public void add(){
}
}
public void print(){
new C().add();
}
}
简写形式：
abstract class A{
int x = 21;
abstract void add();
}
class B{
public void print(){
new A(){
public void add(){
}
}.add();
}
}
5.17异常
程序中的不正常情况统称为异常，SUN将程序的各种不正常状态描述为不同的类。
异常的体系：
---| Throwable实现类
toString() getMessage() printStackTrace()
-----| Error
-----| Exception
--------| RuntimeException
该异常在运行时出现后，开发者可以不用处理，编译器直接通过。
--------|受检异常
该异常是受检异常，如果程序发生了该异常，必须处理，否则编译报错。
异常的处理：
1.自行处理
try{ //可能发生异常的代码}catch(异常类型 变量) { //异常的处理方式}
特点：
1. try catch语句块不能相互访问，如果要访问，需要将变量写在代码块的外面
2. catch语句块可以是多条
3.多态catch语句的时候需要由小到大处理异常，否则报错。
2.抛出处理
函数内部抛出给函数外部用throw异常的对象;
函数上使用throws将异常声明给调用者，由调用者处理异常，如果没有人处理，
那么最终抛出给JVM，JVM直接打印异常栈信息。
3. throw和throws的区别
使用位置不同：函数中函数外
后面接受的类型不同：异常对象异常类型
后面接受的内容个数不同：一个对象多个类型
throw同一条件下后面不能出现其他语句。
finally：主要用于释放资源
1. try{} catch(){}catch(){}。。。
2. try{} catch(){}finally{ //释放资源的代码
if( a != null ){
try{
a.close();
}catch(){
}
}
}
3. try{}finally{}
finally代码块中的语句除了虚拟机退出意外其他任何情况都会执行。
异常的自定义
1.继承异常父类(受检异常)
2.编写无参和带参数的构造函数
受检异常(非运行时异常)和非受检异常(运行时异常)：
受检异常必须处理
非受检异常可以通过开发者的编程习惯解决掉，所以不用处理。
要掌握常见的受检和非受检异常。
如果一个函数中声明了一个异常，那么一般情况下该异常一定是受检异常。
异常类型的转换：
将受检异常转换为非受检异常
new RuntimeException(受检异常)
将非受检异常转换为受检异常
new Exception(非受检异常)
5.18包和导包
包：package包名;域名反写
导包：import包名.类名|*;
* :不会导入子包中的类。
编译：javac -d class的目录(.) java源文件
运行：java包名.类名
使用细节：
1. package必须是描述类的第一条语句，且是有一条
2. import可以出现多条，但是尽量不要使用*
5.19访问控制符
public protected default private
本类true true true true
同一包类true true true
子类true true
不同包类true
注意：protected不能修饰类。
5.20 JDK常见的开发工具
javac编译源程序
java运行字节码文件
javap反编译class文件
javadoc生成软件说明书( @author @version @param @return @exception )
jar打包class文件
压缩：
jar -cvf jar文件名 需要打包进来的文件或目录
查看：
jar -tvf jar文件名[ >重定向文件名]
解压：
jar -xvf jar文件名 解压在当前目录
注意：可运行jar的制作。Main-Class： 主类
第二阶段Java基础复习
6.多线程
6.1线程的概念
程序：下载回来的静态的文件数据集合。
进程：运行着的程序。
线程：程序运行的多条路径。
6.2线程的模型
CPU Thread
代码run()
数据run()使用的数据
6.3线程的实现
方式一：继承Thread类，并重写run(),默认是空实现
class MyThread extends Thread{
public void run(){
//线程的代码
}
}
方式二：实现Runnable接口，并实现run()
class MyThread implements Runnable{
public void run(){
//线程的代码
}
}
区别：
1.如果使用继承方式，该类无法继承其他的类
2.如果使用继承方式，体现不出面向对象的编程思想
3.如果使用接口实现，可以多实现其他的接口的同时还可以继承其他的类
注意：
1.线程的启动
start()内部调用的是重写的run(){}
2.如果直接调用run方法，不会以线程的方式运行
3.一个线程的只能启动一次
IllegalThreadStateException无效线程状态异常
6.4线程的生命周期
new start()抢到CPU run()
新建状态---------》可运行状态-----------》运行态-----------》终止
||
休眠时间到|| CPU被抢走/sleep()
|------阻塞状态--------|
6.5线程的常用方法（Thread）
getName()
getPriority() 1~10 5
currentThread()
getId()
sleep(毫秒值)
join()
Object
wait()
notify()
6.6线程的安全性问题
线程安全问题：当多个线程并发访问同一资源的时候，会导致同一资源的数据紊乱，称之为线程安全问题。
解决方案：线程同步
同步实现：synchronized
给调用的同一资源的代码加锁：
1.同步代码块
synchronized(锁对象){ // java中任意对象都可以最为锁 一般是this
//需要同步的代码
}
2.同步非静态函数
public synchronized void add(){ //默认的锁是this关键字
}
3.同步和静态函数
public synchronized static void add(){ //默认的锁是所属类的Class对象Class类名.class
}
6.7死锁
前提：
1.多线程环境下
2.每个线程完成任务需要获取多个资源
表现：
线程1拿到可以执行任务的一个资源，想获取第二个资源，但是第二个资源被线程二获取了，
而且线程二想获取完成任务的第一个资源，但是第一个资源被线程一加锁了，所以导致死锁。
实现：
......
避免死锁的算法：
银行家算法
6.8线程的终止
1.正常死亡
run()被执行完毕
2.通过标记变量死亡
run(){
while( tag ){
}
}
tag = false
3.设置为后台线程死亡
setDaemon(boolean on)
当系统中所有的线程为后台线程的时候，JVM退出。
6.9线程的通信
1.锁
synchronized(this)
2. wait()和notify()
3.管道流
PipedInputStream
PipedOutputStream
注意：管道流之间数据通信的时候一定要进行管道的连接connect()
7. API( Applaction Program Interface)
6.1 Object
所有类的终极父类，该类中定义的方法，其他类中都有。该类可以直接创建对象。
常见方法：
String toString()返回一个描述对象的字符串信息
boolean equals()比较两个对象的内存地址是否相等，默认使用==实现
int hashCode()如果两个对象equals()返回true，那么该方法的返回值也要一致
Class getClass()返回当前对象的Class对象
注意：
在开发者自定义类的时候，必须要记得重写这三个函数。
6.2 String
1.创建对象
String str = "abc";对象在常量池中
String str = new String("abc")对象在堆中
==比较的是字符串对象的内存地址是否相等
equals比较是的两个对象的内容是否相等
2.判断
equals()
contains()
isEmpty()
endsWith()
startWith()
3.查看
charAt()
indexOf()
lastIndexOf()
4.截取和替换
trim()
substring( start,end )不包含end索引
split()
replace()
replaceAll()
matches()
5.转换
toUpperCase()
toLowerCase()
toCharArray()
getBytes("") //编码
new String( byte[] bs,"" ) //解码
6.3字符串缓冲区对象
因为String不可变(数组不可变),所以提出了字符缓冲区对象。
-----| StringBuffer线程安全的
append()
toString()
String substring(int start)
insert(int offset, float f)
delete(int start, int end)
-----| StringBuilder推荐使用
6.4 System
属性：
InputStream in
PintStream out
方法：
getProperties()获取系统素有属性os.name=Window XP file.encoding=GBK
currentTimeMillis()获取当前系统的时间值
exit(int status) 0为正常退出
getenv(String name)获取系统环境变量
console()获取控制台对象
setIn(InputStream in)重定向标准输入流
setOut(OutStream out)重定向标准输出流
6.5 Runtime
描述的是运行环境对象。
static Runtime getRuntime()通过该方法获取该类的对象
exit()
gc()
Process exec()执行一个命令行命令程序，可以指定参数
6.6 Date(java.util.*)
描述的是系统的当前的日期，包含年、月、日、时、分和秒
getYear()
.......都过期了
Calendar.set(year + 1900, month, date)
格式化日期类：(java.text.*)
SimpleDateFormat
"yyyy-MM-dd a E hh:mm:ss"
String str = format( Date date );
6.7 Calendar
static Calendar getInstance()只能通过该静态方法获取
Calendar.get( Calendar.YEAR )获取年份
6.8 Math
ceil()向上取整
floor()向下取整
round()四舍五入
random() 0~1
6.9 Random
nextInt(10)
nextLong(10)
nextDouble(23.7)
8.集合(Collection)
7.1集合的概念
1.主要用于存储对象
2.数组VS集合
2.1数组是不可变
2.2数组操作比较麻烦
7.2集合体系结构
-----| Iterable接口
Iterator iterator()
-------| Collection接口
add() remove() clear()
---------| List有序，可重复
get() remove() set() listIterator()
------------| ArrayList数组实现，默认10，增长0.5操作慢，查询快
------------| Vector线程安全的ArrayList
------------| LinkedList链表实现，操作快，查询慢， 数据结构： 栈、队列
---------| Set无序，不可重复
------------| HashSet哈希表，底层使用HashMap, hashCode()且eauqls()则两个对象重复
------------| TreeSet红黑树，底层采用TreeMap,如果比较的结果为0说明对象重复
Comparable conpareTo( Object o )
Comparator compare( Object o1, Object o2 ) new TreeSet(比较器对象);
-----| Iterator接口
hasNext() next() remove()
-------| ListIterator接口
add() hasPrevious() previou() set()
-----| Comparable接口 实现自然排序
compareTo( Obejct o ) String Integer
-----| Comparator
compare( Object o1, Object o2 )
equals()
-----| Map主要存储关联对象Key --- Value
--------| HashMap哈希表，对Key对象进行hash存储，Key对象的hashCode()且eauqls()则两个对象重复
--------| TreeMap红黑树，如果Key比较的结果为0说明对象重复
如果比较出来Key对象重复了，那么会使用新值对象进行替换原来的旧值对象
--------| Properties代表一个配置文件对象，可以将配置文件映射为内存的中Map对象
load()将某一个配置文件装载为Map对象
get(key)获取某一个key关联的值对象
getProperty()
setProperty( key , value )内存
store( Writer )
7.3集合的遍历
1.直接打印集合对象
System.out.println(list);
2. for循环（只能遍历List）
for( int i = 0; i < list.size() ; i++ ){
list.get(i)
}
3.增强for循环
for( T t : list ){
System.out.println(t);
}
4.迭代器
4.1 while
Iterator it = list.iterator();
while( it.hasNext() ){
it.next()
}
4.2 for
for( Iterator it = list.iterator(); it.hasNExt() ; ){
it.next()
}
Iterator it = list.iterator();
for( ; it.hasNExt() ; ){
it.next()
}
5. Map的遍历
5.1直接打印Map对象
5.2获取key的set
Set keys = map.keySet();
for( Iterator it = list.iterator(); it.hasNExt() ; ){
it.next()
}
5.3获取value对象
Collecion vs = map.values();
for( Iterator it = list.iterator(); it.hasNExt() ; ){
it.next()
}
5.4 EntrySet
Set set = map.entrySet();
for( Iterator it = list.iterator(); it.hasNExt() ; ){
Map.Entry entry = it.next();
T key = entry.getKey();
T value = entry.getValue();
}
6.使用泛型的迭代器进行遍历
ArrayList list = new ArrayList();
Iterator it = list.iterator();
for( ; it.hasNext(); ){
String v = it.next();
}
for( String temp : list ){
}
7.4泛型(Generic)
泛型的概念：泛型即类型的参数化。
1.泛型的应用
集合中使用泛型可以提高数据的安全性。
ArrayList list = new ArrayList ();推荐使用
ArrayList list = new ArrayList ();
ArrayList list = new ArrayList ();
注意：
泛型不能自动类型转换
2.泛型的自定义
2.1非静态方法
public void print( T t ){
}
2.2类泛型
如果一个类中属性和方法几乎都用到泛型了，那么可以将泛型的自定义声明到类上。
class Person{
public void eat( T t){
}
}
注意:
1.如果创建给类的时候没有指定具体的数据类型，默认是Object
2.具体的类型只能是对象类型，不能是基本数据类型
2.3静态方法的泛型声明
静态方法不能使用类上的泛型声明，所以要自己单独的声明
public static void print( T t ){
}
3.泛型的继承
3.1 class A extends B
3.2 class A extends B
注意：
1.接口可以有泛型
interface A{}
4.泛型的约束
Collection任意的对象类型
Collection必须是Number的子类或自身
Collection必须是Integer的父类或自身
注意：
一个类是自己本身的子类或父类。
7.5工具类
1.数组的工具类(Arrays)
sort()自然排序
binarySearch()前提是先排序
toString()遍历数组[,]
asList()
2.集合的工具类(Collections)
sort()自然排序
binarySearch()前提是先排序
reverse()
max()
synchronizedCollection(Collection c)将线程不安全的集合对象转换为线程安全的
所有的集合类都有一个方法
toArray()转换为数组
注意：
1.根据源代码学习二分查找的实现原理
2.在项目的实际开发中要学会定义工具类
所有的属性和方法都是静态的。该类一定是一个final的。
9. IO流
9.1 IO的概念
主要做设备和设备之间的数据传输。
9.2 IO的分类
单位：
字节流(主要操作二进制数据)
字符流(主要操作字符文本数据)
方向：
输入流
输出流
以代码为基准：输入流、输出流
9.3 IO的体系结构
字符流（使用了缓冲区）
-----| Writer抽象类 每次操作一个字符
write(int) write( char[] ) flush() close()
--------| FileWriter
--------| OutputStreamWriter
--------| BufferedWriter
newLine()
-----| Reader抽象类 每次操作一个字符
read() read(char[]) close()
--------| FileReader
--------| InputStreamReader
--------| BufferedReader
readLine()
----------| LineNumberReader
getLineNumber()
setLineNumber()
mark(34242)
reset()
skip()
注意：
文本文件的拷贝练习。
字节流不是用缓冲区
-----| OutputStream抽象类 每次操作一个字节
write(byte) write(byte[]) close()
--------| FileOutputStream
--------| ObjectOutputStream
--------| BufferOutputStream (有缓冲区了)
--------| PipedOutputStream
-----| InputStream抽象类 每次操作一个字节
--------| FileInputStream
--------| BufferedInputStream
--------| ObjectInputStream
--------| SequenceInputStream
--------| PipedInputStream
注意：
拷贝一个图片文件。
9.4字符流
1.操作单位为字符
2.使用了内存中的缓冲区，所以需要刷新
3.操作文本数据，不能操作二进制数据
4.内部做了码表的转换，所以要注意乱码
编码和解码的码表必须一致。
getBytes()
new String()
9.5字节流
1.操作单位是字节
2.没有使用缓冲区，不需要刷新
3.主要操作二进制数据，无需编码
9.6转换流
字节流到字符流的桥梁。
InputStreamReader将字节输入流转换为字符输入流
OutputStreamWriter将字节输出流转换为字符输出流
new BufferedReader( new InputStreamReader( (System.in) ) );
9.7标准输入和输出流
InputStream System.in
PrintStream System.out
接受控制台输入的数据：
BufferedReader read = new BufferedReader( new InputStreamReader( (System.in) ) );
---》23
String age = read.readLine();
Person age int
int age = Integer.parseInt(age);
---》34.8
String price = read.readLine();
double price = Double.parseDouble(price);
注意：
学会使用标准流重定向实现日志文件。
9.8顺序流
SequenceInputStream
new SequenceInputStream( InputStream in1 , InputStream in2 )
new SequenceInputStream( Enumeration< ? extends InputStream > )
new Enumeration(){
public boolean hasMoreElements(){
return it.hasNext()
}
public Object nextElement(){
return it.next()
}
}
注意：
文件的切割和合并。
9.9 File类
该类描述的是一个文件或文件夹。
0.属性
separator \ /
pathSeparator ;
1.构造函数：
new File(String name)
new File( File dir , String name)
2.常见的方法
boolean createNewFile()
delete()
deleteOnExit()
createTempFile(String prefix, String suffix) .tmp存储在系统的默认的临时文件夹中
exists()目录或是否存在
isFile()
isDirectory()
String[] list()返回一个文件夹下面的所有的目录和文件
File[] listFiles()返回一个文件夹下面的所有的目录和文件对象
File [] listFiles(FileFilter filter)
-----| FileFilter接口
public boolean accept(File pathname){
return pathname.getName().endsWith(".java");
}
mkdir()创建一级目录
mkdirs()常见多级目录
renameTo()重命名 如果指定的路径不相同实现的是剪切
注意：
1.实现遍历一个多级目录的文件夹
2.删除一个目录
3.拷贝一个带目录的文件夹
3.递归
3.1递归的概念
函数自身调用自身。
3.2递归的实现
1.函数中自己调用自己
2.退出条件
3.3递归的练习
1.递归目录的删除
2.递归目录的拷贝
public void print( int x ){
if( x > 3 ){
print(--x);
}
Systenm.out.println(x);
}
print( 5 );
4.带File的流操作
new FileWriter( new File("a.txt") , true );
9.10序列化和反序列化流
序列化：对象------》 目标设备
反序列换：目标设备----》对象
ObjectInputStream
ObjectOutputStream
注意：
1.序列化的类对象一定要实现Serializable接口
2.为了避免整容后不认识该对象，在序列化的类定义的时候需要定义一个
public static final long serialVersionUID = 1L;
3.如果A实现了Serializable接口，B继承了A，那B可以被序列化。
9.11管道流
主要做的是线程之间的数据通信
PipedInputStream
PipedOutputStream
注意：
需要相互连接
9.12打印流
打印方便开发者格式化输出日志信息或其他数据信息。
PrintStream
PrintWriter
println()
print()
printf()
%s字符串
%d正数
%f小数
%c字符
9.13其他流
RandomAccessFile
new RandomAccessFile(文件设备, "rw" );
writeUTF();
readUTF();
seek();
DataInputStream
DataOutputStream
......
10. IDE
10.1 IDE概念
10.2常见IDE
10.3 eclipse的使用
1.管理模式
1.1创建工作区
1.2创建java项目
1.3在项目的src目录下创建java源文件
2.快捷键
Ctrl+1
Alt+/
Ctrl+Shift+O
Ctrl+/
Ctrl+Shift+/ Ctrl+Shift+\
Ctrl+Shift+F
Ctrl+D
Ctrl+单击
3.代码重构
抽取方法
抽取接口
4.关联源代码
选择源代码
5.代码的调试
5.1进入调试视图debug as
5.2单步、进入
5.3调试后的清理
清除断点
清楚变量
关闭JVM
切换编辑java视图
6.项目的导入和导出
.....
11. JDK5.0新特性
11.1静态导入
import static包名.类名.静态属性|静态方法|*
11.2增强for循环
for(临时变量:需要遍历的容器){
}
注意：在循环中改变临时变量的值，不会改变容器的值。
11.3可变参数
...
public long gerSum( int... a ){
}
特点:
1.可变参数底层是可变数组
2.可以直接创建数组对象接受并按照数组操作来操作
3.可变参数只能在参数列表的最后一个位置
4.可变参数只能且只有一个
11.4枚举
实现：enum枚举值
enum枚举类名{
//所有的枚举值 大写形式
}
特点：
1.枚举类是一个类
2.默认继承java.lang.Enum
3.所有的枚举值都是枚举类的常量对象
public static final枚举类 枚举常量名
4.可以做作为switch的参数
5.内部可以定义属性、构造函数、函数、以及抽象函数。
12.正则表达式
12.1正则的概念
Regular Expresion正则表达式，描述的是数据要满足的规则。
12.2正则的适用范围
String
matches()
split()
replaceAll()
java.util.regex
Pattern描述的正则的编译形式Pattern pattern = Pattern.compile("正则");
Matcher描述的是要匹配的文本Matcher matcher = pattern.matches(str);
find()查找符合规则的字符集，如果有返回true，否则返回false
group()返回匹配的文本字符
12.3正则的语法
1. .匹配任意一个字符
a匹配一个a
abc
2.数量匹配
? 0 1
+ 1 ~ n n>=1
* 0 ~ n
{4}
{4, }
{4,8}
"a{5}" aaaaa
3.简写形式
\d数字范围0 ~ 9
\D非数字
\s空白字符
\S
\w单词字符[a-zA-Z0-9]
\W
"^[^0]\\d{5,10}$"
4.规则范围
[a-z] a 7
[a-z[1-4]]并集
[a-z&&[a-b]]交集
[a-z&&[^a-b]] [c-z]
5.边界
^
$
\b
6.练习
由5~10个字母组成的用户名"[a-zA-Z]{5,10}"
身份证18位数字0 "^[^0]\\d{16}[0-9x]{1}"
email "\\w+@\\w+(\\.\\w+)+"
密码是6为大写字母"[A-Z]{6}"
12.4正则的应用
1.基本的数据的校验
2.特殊的字符正则应用
jiao.ning.bo "\\."
jiao ning bo " +"
jiao\ning\bo "\\\\"
aabbbbcccccf "(.)\\1" #
aabbbbcccccf "(.)\\1" $1
3.从页面上搜集email
4.从页面上搜集url连接
13. GUI图形界面编程(了解)
GUI图形界面编程：java中主要使用的是AWT(java.awt.*)或Swing(javax.swing.*)
GUI体系
----| Component
-------| Container
----------| Window
-------------| Frame
-------------| Dialog
----------| Panel
-------|普通的组件
----------| Button
----------| Label
对于Swing而言，所有的容器对象和普通的组件对象前面都加一个"J"即可。
GUI的容器：
---| Window默认不显示、JFrame是顶层的容器。
-----| JFrame默认的布局管理器是BorderLayout
-----| JDialog
---| JPanel默认必须添加在另外一个顶层容器中使用，不能单独的使用。默认布局管理器是FlowLayout
常见的方法如下：
add() :添加组件的方法
setLayout():修改布局管理器的方法
setVisiable()：设置容器的可见性
setSize() :设置窗口大小
setLocation():设置窗口的位置
setBounds() :一次性设置大小和位置
GUI组件：
常见的组件：JButton JLabel JTextField JPasswordField JCheckBox JTextArea
GUI布局管理器：BorderLayout(5) FlowLayout(居中) GridLayout(行列) CardLayout(JPanel)
GUI事件监听器：
ActionListener一个处理动作事件的action方法
WindowListener处理窗口事件的
MourseListener鼠标监听器
KeyListener键盘监听器
因为实现接口需求全部实现所有的方法，但是在实际的项目开发中不需要将所有的实现，所以SUN提供了
默认的监听器的所有的方法的空实现的适配器。
GUI事件适配器：
WindowAdapter处理窗口事件的
MourseAdapter鼠标监听器
KeyAdapter键盘监听器
编写GUI程序的一个模版写法：
public class GUI{
// 1.声明所有的组件对象
// 2. init()提供对象的初始化
// 3. setConponent()设置所有的组件对象
// 4. bindEvent()给需要的组件监听事件
public static void main(String [] args){
// 5.创建GUI对象，一次调用2/3/4方法
}
}
14.网络编程
前面的所有知识，无论是文件的操作，还是线程的管道通信都是在本地PC上进行的，但是在实际的项目
开发中需要实现网络中的多台PC之间的数据通信，所以SUN提供了java.net.*帮助开发人员进行网络操作。
该网络操作也被形象的称之为Socket编程。
网络基础知识：
IP IPV4 IPV6 192.168.10.1 0~255 256 = 2(8) 4字节
port主要是为了区分一个pc上的多个网络应用程序
protocol主要约束的是数据的传输的格式TCP/IP UDP TCP
网络模型：
网络的5层模型
通信的协议：
UDP： 数据的接收端可以不在
TCP： 数据的接收端必须在发送端发送数据之前存在
UDP通信：
1、InetAddress描述的是发送的数据的ip和port
有两个子类:Inet4Address, Inet6Address
获取对象: InetAddress getByName(String host)
2、客户端
DatagramSocket主要用于接受可发送数据包
发送：send(DatagramPacket p)
DatagramPacket主要用于打包数据
DatagramPacket(byte[] buf, int length, InetAddress address, int port)
3、接收端
receive(DatagramPacket p)
TCP通信(重点)：
1、InetAddress描述的是发送的数据的ip和port
2、Socket主要描述的是客户端用于发送数据的节点对象
Socket(String host, int port)
getOutputStream()获取输出流进行数据的发送
3、ServerSocket
Socket accept()接受客户端发送过来的数据Socket对象
4、客户端和服务器端相互的发送和接收数据。全双工的数据通信
多线程下的TCP通信：
将通信的数据代码写在Thread的run()或Runnable的run()
可以启动多个线程来进行通信。
面试：
问？是不是多线程可以提高通信的效率？
理论上：多线程是降低效率的。
15. HTML网页结构设计
后期的主要学习的是JavaEE，主要开发的是网站的管理系统，基于页面的，所以必须要学习网页的开发。
网页：
1、 后缀为.html或.htm的文件
2、 该文件内容主要由HTML标记组成
HTML标记
HTML是一种超文本标记语言，主要用于开发页面，还页面中的所有的标记都是预先定义好的，不能自己修改。
文本标签：
h1~h6
p == 2
ul
ol
li
font
pre
sub
sup
span语义标签
div分区标签
表格标签：
table
caption
thead
tbody
tfoot
tr
td
th默认作为表格的表头，文本加粗
属性：
align
border
rowspan
clospan
cellspacing
多媒体标签：
embed
bgsound
object
滚动标签：
marquee
属性：
scrollamount滚动的速度
scrolldelay滚动的延迟
direction滚动的方向
超链接标签：
的锚链接
的超链接
注意一个属性：
target: _self _blank _top _parent可以是一个子窗口的name属性值
集合框架标签(帧标签)：
实现的是画中画的效果
该标签不能和body
rows属性切割行
clos属性切割列
一般使用相对单位的%数据来充当切割的数值。
name属性：指定该子窗口的名称
src属性： 指定该窗口打开的页面URL
表单标签(重点)：
表单标记的出现主要是为快速的从页面上采集用的输入信息。
表单：
属性：
action该属性指定将表单的数据提交个谁(动态页面的路径)？ 默认提交给自己。
method指定数据传输的方式get post
get方式数据在浏览器的地址栏的信息的后面
www.baidu.com?keywords=java&name=jiao
1、明码 不能传递密码
2、长度受限 必须小于1K所以如果要实现文件的上传只能post
post方式将表单的数据写在HTTP协议的请求体中传输，对于数据的长度没有限制。
enctype是一种组合表单数据的格式。
application/x-www-form-urlencoded默认值,一般情况下使用。
multipart/form-data将不同的数据类型进行分类发送给服务器。
text/plain以纯文本的形式进行发送
主要用于邮件的发送表单中。
项目应用：
如果要实现文件上传和下载，form表单的，method属性必须是post且
enctype属性必须是multipart/form-data。
表单项：用于搜集用户数据的具体标记。
是空标签
type:
text
password
button
submit
reset
file
hidden
checkbox
radio
name:
如果要传递数据，那么表单项中的元素一定要有name属性，否则数据无法传输，
获取到一定是null。
表单提交：
在表单的form标记中有一个事件属性：onsubmit="return指定处理函数"
16. CSS网页美化
在HTML中既有结构化的标签又有样式标签（font、b、i），后期HTML中摒弃了所有的样式标签，
一定要使用CSS样式语言进行页面的修饰。这样可以使得页面结构和样式进行分离，进而便于
网站的维护。
CSS语言：Cascading Style Sheet语言。
CSS的页面引入：
行内：元素的style属性
内部：
/*样式*/
外部： link标签属于HTML
@import URL("xx.css");该关键字属于CSS
选择器：
h1{ }标记选择器
#my{ } ID选择器
.c1{ }类选择器
h1,h2{ }并集选择器
关系选择器
p a{ }后代选择器
p>a{ }直接后代选择器
p a:first-child老大选择器
p a:first-child+a老二选择器
读懂以下选择器：
p>a:first-child+a+a{
color:#F00;
}
超链接的特殊伪类选择器：
LoVeHAte
a:link{}链接在显示的时候的样式
a:visited{}链接在访问过后的样式
a:hover{}链接在鼠标移上去之后的样式
a:active{}链接被激活的一瞬间的样式
CSS属性：
在实际的项目中如果要使用DOM动态操作带-的CSS属性，那么必须要进行命名的调整。
some text
window.document.getElementByTagName("P").iterm(0).style.backgroundColor = "#00f";
text-decoration
CSS属性值：
!important
BOXModel：
padding:是内容到边框之间的间距
margin：是边框到外部空白区域的举例
margin：10px;上下左右都为10px
margin：0px 10px;上下0px左右10px
margin：1px 2px 3px 10px;上右下左
浮动：
1、浮动的元素脱离文档流，如果页面文档流中的元素遇到浮动的元素，元素内容的环绕。
2、浮动元素的虽脱离了文档流，但是浮动的位置坐标取决于文档流中的页面位置。
作用：布局
练习：
1、使用浮动+div技术模拟框架集。
2、使用浮动+ul技术实现动态链表菜单。
定位：
position:absolute fixed relative
absolute:绝对定位，脱离文档流z-index:12;
使用left top bottom right来模拟x和y坐标
fixed： 固定定位在页面的一个位置，不会随着页面滚动条的滚动来滚动。
relative：相对的是该元素在标准文档流中没有定位之前的位置。
扩展：滤镜
*,html{
filter：gray
}
17. JavaScript网页行为
参见javascript上课文档.doc
18.总结
30天基础结束!端午节快乐!
------------------------------------------------------------------------------------------------------
扩展设计模式
1单例模式
恶汉式：
懒汉式：
1.将构造函数私有化
2.声明一个该类的静态变量
3.给该变量进行赋值
4.提供public static的返回静态变量的方法
getInstance(){
if( == null ){
new对象();
}
}
2模版模式
1.创建模版代码并形成一个独立的函数
2.抽取模版函数中的可变部分形成一个抽象方法
3.将该类声明为抽线该类
4.创建子类实现父类的抽象方法
5.将模版函数为final的
3.修饰模式
1.在修饰类中维护一个被修饰类的变量引用
2.在修饰类的构造函数中初始化1中的变量
3.在修饰类的方法中调用被修饰对象的方法，并写修饰代码
------------------------------------------------------------------------------------------------------
上就业班JAVA基础知识归类：
必须的
环境搭建
语法基础【关键字、操作符、语句控制、break、continue、return、数组 、函数 】
面向对象【类描述、创建对象(new)、构造函数初始化、this、final、super、static】
高级OOP【封装、继承(extends)、多态 、抽象类、接口(interface implements)】
异常【处理异常、自定义异常、throws、throw】
API【String】
集合【ArrayList、LinkedList、TreeSet、TreeMap、Map.Entry、Iterator】
IO【字节流和字符流、文件的拷贝】
HTML【基本的常用标签、会写表单】
CSS【基本选择器】
JavaScript【 变量、函数、事件、基本的DOM操作 】
可选的
环境搭建【classpath、java_home】
语法基础【保留字(goto)、位运算、死循环、标记使用、数组的常见操作、函数的重载 】
面向对象【代码块、子类的初始化过程、内部类、包、修饰符】
高级OOP【类的加载、多态的原理】
异常【异常的体系、受检和非受检异常】
线程【线程定义、线程声明周期、线程安全、synchronized、线程的通信 】
API【StringBuffer，StringBudiler】
集合【HashSet、HashMap、Vector】
IO【 顺序流、序列换流、打印流 、转换流(可以指定码表)】
JDK5.0【 可变参数、增强for循环 、泛型使用 】
HTML【 框架页、iframe】
CSS【伪类选择器、关系选择器、浮动、定位、盒子模型】
JavaScript【 函数覆盖、特殊值转换为boolean、自定义对象 】
设计模式【可以查看文档读懂】
没必要
环境搭建【临时环境变量的设置】
语法基础【进制的表示形式、以及之间的转换原理】
面向对象【构造函数的调用】
高级OOP【Class getClass()/class】
异常【异常的类型转换和日志的编写】
线程【生产者和消费者】
API【Object、System、Runtime、Math、Random】
集合【Vector、Properties、LinkedHashMap】
GUI【】
Socket编程【】
IO【 行流、其他的数据流 】
JDK5.0【 反射、注解、泛型的复杂应用、动态代理 】
HTML【 多媒体、滚动标签 】
CSS【滤镜】
JavaScript【 异常的处理、继承、prototype】