学习java的杂乱笔记

1.局部变量：定义在方法中的变量，定义在方法中的参数的变量，定义在for循环中变量，都是局部变量，
在栈内存中开辟一个空间，数据使用完毕，自动释放。

2.何定义一个函数？（不须要死记，只需了解）
1.既然函数是一个独立的功能，那么该功能的运算结果是什么要先明确。
是在明确函数的返回值类型
2.在明肯定义该功能的过程当中是否须要未知的内容参与运算。
明确函数的参数列表（参数的类型和参数的个数）

3.break:只可做用于选择结构与循环结构。
continue：只可做用于循环(loop)结构,结束本次循环，继续下次循环。
continue与break若是没有该有的做用域而单独存在，则没有意义，语句编译失败

4.能够以字母为标号，给for循环标号，也只能给for循环标号！！便于区分

5.累加思想：
经过变量记录住每次变化的结果，经过循环的形式，进行累加操做。
计数器思想
经过一个变量记录住数据的状态变化，也须要经过循环来实现

6.何时动用重载？重载与返回值类型无关
当定义的功能相同时，但其中参与运算的未知内容不一样时，
那么就定义一个函数名称以表示其功能，方便阅读，而经过参数列表的不一样来区分多个同名函数
注意：参数列表中参数是有顺序的！！！！！！！！

7.函数定义思想：每一个函数只须要完成他所须要的功能就能够，不须要多余的动做，列如求和语句
只须要完成求和并返回就能够，而不要进行多余的打印输出语句，每一个函数都是独立的
只需完成应完成的定义，不须要多余的的定义，若是须要，那也是调用者所干的事，每一个函数
则只要返回就可。

8.一：变量都有本身的做用域，对于for循环来说，若是将控制循环的增量定义在for语句中，变量只在该循环内有效，
当for语句执行完毕，该变量就会在内存中被释放
二：for循环能够与while语句互换，若是须要定义循环变量，则for循环更为合理

9.转义字符：经过\来转变-后面-字母或符号的含义。
\n:换行；
\b:退格，至关于BackSpace;
\r:按下回车键，在windows系统，回车键是由两个字符来表示\r,\n
在Linux系统，回车键只由一个字符表示
\t:制表符，至关于tab键

10. 堆内存中每个实体都有一个内存地址值，或有或无的被栈内存中的定义变量所含的地址值所引用，而不是直接表明

11.数组角标从零开始，并且数组一被定义就都有值且默认值为0.

12.堆内存中的实体都是封装数据的，且都有默认初始化值

13.面向对象的三个特征：1，封装；2，继承；3，多态；

14.对象与类的区别：
类是对现实生活中事物的描述。
对象是这类事物实实在在存在的个体。

15,其实定义类就是在描述事物，就是在定义属性与行为；属性与行为共同称为类中的成员（成员变量和成员方法）；

16，类类型变量指向对象

17，成员变量与局部变量的区别：
做用范围：
成员变量做用于整个类中，
局部变量做用于函数中或语句中；
在内存中的位置：
成员变量在堆内存中，由于对象的存在，才在内存中存在；
局部变量存在在栈内存中。

18,private:私有，权限修饰符，用于修饰类中的成员(成员变量，成员函数)。私有只在本类中有效
将成员变量私有化，对外提供set get方法对其进行访问，提升对数据访问的安全性
注意：私有仅仅只是封装的一种形式，私有是封装，但封装不是私有

19，构造函数的定义：
1.函数名要与类名一致
2.不用定义返回值类型
3.不用写return语句
对象一创建就会调用与之对应的构造函数
构造函数能够用于对象进行初始化
细节：当一个类中没有定义构造函数时，那么系统会默认会给该类加入一个空参数的构造函数
方便于该类进行初始化，当在类中自定义了构造函数后，默认的构造函数就没了
构造函数与通常函数的区别：
1.在写法上不一样
2.在运行上不一样
构造函数就是在对象一创建就运行，给对象初始化
通常函数是在对象调用才执行，给对象添加对象具有的功能
一个对象创建，构造函数只运行一次
通常函数能够被对象调用不少次
何时定义构造函数：
当分析事物时，该事物存在即具有一些特性或者行为，那么将那些内容定义在构造函数中
一个类中默认会有一个空参数的构造函数，这个默认的构造函数的权限与所属类一致
若是类被public修饰，那么默认的构造函数也带public修饰符
若是类没被public修饰，那么默认的构造函数也没有public修饰

默认的构造函数的权限是随着类的变化而变化的

20.构造代码块：做用：给对象进行初始化
对象一创建就运行，并且优先于构造函数执行
与构造函数的区别：
构造代码块是给全部对象进行统一初始化
而构造函数时给对应的对象初始化。
构造代码块中定义的是不一样对象共性的初始化内容

new xxx(); 其中先默认初始化，null或者0等，显示初始化，再构造代码块初始化，再构造函数初始化，有前后顺序

21.this关键字：
表明它所在函数所属对象的引用
简单说：那个对象在调用this所在函数，this就表明那个对象
this的应用：当定义类中功能时，该函数内部都要用到调用该函数的对象时，这时用this来表示这个对象
但凡本类功能内部使用了本类对象，都要用this表示
this的功能：1.用以区分局部变量和成员变量的同名状况。
2.用于构造函数之间进行互相调用。
注意：this语句只能定义在构造函数的第一行，由于初始化要先执行，不然会报错
对this的调用必须是构造器中的第一个语句。

22.java中有堆内存，栈内存，以及方法区（共享区，数据区）；

23.static关键字：
用法：是一个修饰符，用于修饰成员（成员变量，成员函数）；
当成员被静态修饰后，就多了一种调用方式，除了能够被对象调用外，
还能够直接被类名调用，方式：类名.静态成员

定义的静态的成员变量又称类变量，类被调用就执行

成员变量又称实例变量

static特色：
1.随着类的加载而加载。
也就是说，静态会随着类的消失而消失，说明它的生命周期最长。

2.优先于对象存在
明确一点，静态是先存在，对象是后存在

3.被全部对象所共享

4.能够直接被类名调用

实例对象和类变量的区别：
1.存放位置：
类变量随着类的加载而存在于方法区中
实例对象随着对象的创建而存在于对堆内存中
2.生命周期：
类变量生命周期最长，随着类的消失而消失
实例变量声明周期随着对象的消失而消失

静态的使用注意事项：
1.静态方法只能访问静态成员。
非静态方法既能够访问静态，也能够访问非静态
2.静态方法中不能够定义this,super关键字
由于静态优先于对象存在，因此静态方法中不能够出项this
3.主函数是静态的

静态有利有弊：
利处：对对象的共享数据进行单独空间的存储，节省空间，没有必要每个对象都存储一份，
能够直接被类名调用
弊处：生命周期过长。
访问出现局限性（静态只能访问静态、。；

24.何时使用静态？
要从两方面下手：
由于静态修饰的内容有成员变量和成员函数。
何时定义静态变量（类变量）？
当对象中出现共享数据时，该数据被静态所修饰
对象中的特有数据要定义成非静态存在于堆内存中。

何时定义静态函数？
当功能内部没有访问到非静态数据（对象的特有数据）
那么该功能能够定义成静态的。

25.文档注释的特殊字符：
@auther 做者
@version 版本号
@param 参数
@return 返回值

26.Person p =new Person("张三"，20)；

该句话都作了什么事？
1.由于new用到了Person.class.因此会先找到Person.class文件并加载到内存中。
2.执行该类中的static代码块，若是有的话，给Person.class类进行初始化。
3.在堆内存中开辟空间，分配内存地址。
4.在堆内存中创建对象的特有属性，并进行默认初始化。
5.对属性进行显示初始化。
6.对对象进行构造代码块初始化
7.对对象进行对应的构造函数初始化。
8将内存地址赋给栈内存中的p变量。

27.事物不只仅只有继承关系，还有汇集：聚合和组合。

28.子类的实例化过程：（逐级向上找）

子类中的全部构造函数默认都会访问父类中的空参数构造函数，由于子类构造函数
中的第一行都有一句隐式的super语句。

当父类中没有空参数的构造函数时，子类必须手动经过super语句形式来指定要访问的父类中的构造函数，

固然，子类中的构造函数第一行也能够手动指定this语句来访问本类中的构造函数，子类中至少会有一个构造函数会访问
父类中的构造函数。

注意：this和super语句不能在一个函数中，由于两个函数都必须在第一行，
而为何this和super语句为何在第一行，由于两个语句要进行初始化，若是不在第一行，
初始化没有意义。

29.什么是模板方法
在定义功能时，有一部分功能是肯定的，而有另外一部分功能是不肯定的，并且肯定的功能在使用不肯定的功能时，
能够将不肯定的功能暴露出去，由子类进行覆写。
30.public，protected，private是Java里用来定义成员的访问权限的，另外还有一种是“default”，也就是在成员前不加任何权限修饰符。如：
public class A{
void method(){};
}
method就属于default权限。

这四个修饰符的访问权限以下表:
-----------------------------------------------
类内部 package内 子类 其余
public 容许 容许 容许 容许
protected 容许 容许 容许 不容许
default 容许 容许 不容许 不容许
private 容许 不容许 不容许 不容许
-----------------------------------------------

好比：用protected修饰的成员（变量或方法），在类内部能够调用，同一个package下的其余类也能够调用，子类里也能够调用，其余地方则不能够调用，
也就是说在其余

Java语言定义了public、protected、private、abstract、static和final这6经常使用修饰
词外还定义了5个不太经常使用的修饰词，下面是对这11个Java修饰词的介绍：
1.public
使用对象：类、接口、成员
介绍：不管它所处在的包定义在哪，该类（接口、成员）都是可访问的
2.private
使用对象：成员
介绍：成员只能够在定义它的类中被访问
3.static
使用对象：类、方法、字段、初始化函数
介绍：成名为static的内部类是一个顶级类，它和包含类的成员是不相关的。静态方法
是类方法，
是被指向到所属的类而不是类的实例。静态字段是类字段，不管该字段所在的类建立了
多少实例，该字
段只存在一个实例被指向到所属的类而不是类的实例。初始化函数是在装载类时执行
的，而不是在建立
实例时执行的。
4.final
使用对象：类、方法、字段、变量
介绍：被定义成final的类不容许出现子类，不能被覆盖（不该用于动态查询），字段值
不容许被
修改。
5.abstract
使用对象：类、接口、方法
介绍：类中包括没有实现的方法，不能被实例化。若是是一个abstract方法，则方法体
为空，该方
法的实如今子类中被定义，而且包含一个abstract方法的类必须是一个abstract类
6.protected
使用对象：成员
介绍：成员只能在定义它的包中被访问，若是在其余包中被访问，则实现这个方法的类
必须是该成
员所属类的子类。
7.native
使用对象：成员
介绍：与操做平台相关，定义时并不定义其方法，方法的实现被一个外部的库实现。
8.strictfp
使用对象：类、方法
介绍：strictfp修饰的类中全部的方法都隐藏了strictfp修饰词，方法执行的全部浮点
计算遵照
IEEE 754标准，全部取值包括中间的结果都必须表示为float或double类型，而不能利用
由本地平台浮
点格式或硬件提供的额外精度或表示范围。
9.synchronized
使用对象：方法
介绍：对于一个静态的方法，在执行以前jvm把它所在的类锁定；对于一个非静态类的方
法，执行
前把某个特定对象实例锁定。
10.volatile
使用对象：字段
介绍：由于异步线程能够访问字段，因此有些优化操做是必定不能做用在字段上的。
volatile有时
能够代替synchronized。
11.transient
使用对象：字段
介绍：字段不是对象持久状态的一部分，不该该把字段和对象一块儿串起。

31.接口与继承的区别：
接口是对象和事物的拓展属性，属于单独的，属于每一个实现接口的类。
而继承则是子类对父类的所有传递，并增长一些子类所特有的属性，

列如高三学生是学生的一种，高三学生继承了学生的一切属性和方法，如学习和思考。
而有部分高三学生还会抽烟，喝酒等，若是用继承，则表明全部学生都会抽烟，喝酒。然而只是
部分高三学生会。因此用接口来表示拓展属性。

32.多态：事物存在的多种体现形态。
多态的体现：父类的引用指向了子类的对象，
父类的引用也能够接受子类的对象。
Person m = new Man();
多态的前提：必须类与类有关系，要么继承，要么实现，且子类对父类存在覆盖。
多态的好处：多态的出现大大提升了程序的拓展性。
多态的弊端：虽然提升了代码的拓展性，但只能使用父类的引用来访问父类中的成员。
多态自始自终都是子类对象在作着变化，能够转换的是父类应用指向了本身的子类对象时，能够向上转换，也能够强制转换。

在多态中成员函数的特色：
在编译时期，参阅引用型变量所属的类中是否有调用的方法，若是有，编译经过，不然失败。
在运行时期，参阅对象所属的类中是否有调用的方法
即，成员函数在多态调用时，编译看左边，运行看右边。

在多态中，成员变量的特色；
不管编译仍是运行，都参考左边（引用型变量所属的类）

在多态中，静态成员函数的特色：
不管编译仍是运行，都参考左边。

33.异常：程序在！运行！时产生的不正常状况。
异常的由来：异常在现实生活中也是具体的问题，Java在将这些问题描述成类，并封装成对象。
就是Java对不正常状况进行描述后的对象表现。

对于问题的划分：一种是严重的问题-Error ,一种则是严重的----Exception
对于Error问题不进行代码处理，而Exception问题进行处理
但Error与Exception都具有一些共性
列如不正常状况的信息，引起缘由等

Throwable
--Error

--Exception

34.在Exception类中有一个特殊的类RuntimeExceptiom
若是在函数内容抛出异常，函数上能够不声明，编译同样经过
若是在函数声明了异常，调用者能够不处理，编译同样经过，之因此不须要调用者处理，是由于不须要

当该代码异常发生时，RuntimeException但愿这段代码中止，由于在运行中，若是出现了中止，则应该中止操做，修改代码

自定义异常时，若是该异常的发生，程序没法继续，则让自定义类继承RuntimeException

对于异常分为两类
1.编译时被检测的异常

2.编译时不被检验的异常，而运行时被检验的异常(RuntimeException及其子类)

35.异常在子父类中的覆盖体现：
1.子类在覆盖父类时，若是父类的方法抛出异常，那么子类的覆盖的方法只能抛出父类的异常或者该异常的子类。
2.若是父类中抛出了多个异常，那么子类在覆盖该方法时，那么子类只能抛出的是父类的子集
3.若是父类或者接口的方法中没有异常抛出，则子类在覆盖的方法中也不准抛出异常
若是子类方法中出现了异常，只能进行try处理，不能够抛出。

36.多线程：
进程：是一个正在执行的程序。
每个进程执行都有一个执行顺序。该顺序是一个执行路径，或者叫一个控制单元。即在cpu中开辟运行的空间

线程：是进程中一个独立的控制单元。线程控制着进程的执行

一个进程中至少有一个线程。

jvm在启动时会有一个进程 Java。exe

该进程中至少有一个线程在负责Java程序的执行
并且这个线程运行的代码存在于main方法中
该线程称之为主线程。
拓展：
jvm其实启动的不止一个线程，还有负责垃圾回收机制的线程。

建立线程的第一种方法，继承Thread类
1.定义类继承Thread。
2.覆写Tread中的run方法
将自定义代码写入run方法中，使线程运行。
3.调用线程的start方法
start方法：1.启动线程。2.调用run方法

发如今每次运行时，运行结果都不同。
由于多个线程都在获取cpu的执行权，cpu执行到谁，谁就运行
明确一点，在某一时刻，cpu只能执行一个线程，cpu在高速地在作着切换,以达到效果上的同时运行(多核除外)
咱们能够把多线程的运行获取在抢夺cpu的执行使用权。

这也是多线程的一个特性：随机性。谁抢到谁执行。至于执行多长时间，cpu说了算。


建立线程的第二种方法，实现Runnable接口
1.将定义的类实现Runnable接口
2.覆盖Runnable接口中的run方法
将线程要运行的代码块定义在run方法中
3.经过Thread来建立线程对象
4.将Runnable的子类对象做为实际参数传入Thread类的构造函数
由于自定义的run方法的所属对象是Runnable接口的子类对象
因此要让线程去执行指定对象的run方法。必须明确run方法的所属对象
5.调用Thread中的start方法开始线程并调用Runnable接口中的run方法。

实现与继承有什么区别？
实现是为了不单继承的局限性
在定义线程时，建议使用实现Runnable接口方法

区别：
两种方法最大的区别就是run方法的存在的位置不一样
继承Thread类，线程代码存在于Thread子类中的run方法中
实现Runnable接口，线程代码存在于Runnable接口中的run方法中

37.泛型类定义：
class 类名<泛型名>
泛型通配符 ？

当须要定义未知引用数据类型的对象时，使用泛型，能够更好减小代码

38.Arrays中的asList方法
把数组变成集合，就可使用集合中的方法，更加简单

但变成集合后不可使用增删操做，由于数组长度是固定的。会导出.UnsupportedOperationException错误

若是数组中的元素都是对象，那么变成集合时，数组中的元素直接转换成集合中的元素

若是数组中的元素都是基本数据类型，那么会讲这个数组做为对象传入集合。

39.
其实Java自身不具有建立存入数据到文件的功能，只是在调用了windows底层的建立存入方法
Java在其余操做系统上，就调用操做系统内部底层的方法进行操做

40. IOExcption标准处理方法
FileWriter fw =null;

try
{
fw =new FileWriter("a:\\demo.txt");//若是目的值出错，fw初始化失败，fw为null，不能调用close语句，因此要先判断

fw.write("sdfasfas");


}
catch (IOException e)
{
System.out.println(e.toString());
}
finally{

try
{
if(fw!=null)
fw.close();//必定要关闭流资源，将其放入finally语句中

}
catch (IOException e)
{

System.out.println(e.toString());
}
}

41.装饰设计模式：
当想要对已有对象进行功能加强时，能够定义类，将已有对象传入，
基于已有的功能，并提供加强的方法，那么该自定义的类称为装饰类

装饰类一般会经过构造函数的方法来接受要被装饰的对象，并基于被装饰类的
方法来提供更增强大的方法

例子：bufferedReader中的readLine方法就是基于FileReader中的read方法

装饰设计模式与继承的区别：
装饰模式比继承要灵活，避免了过多继承而产生的臃肿性，并且下降了类与类之间的联系

装饰类由于是加强已有对象，具有的功能和已有的是类似的，只不过提供了更强的修饰方法
因此装饰类与被装饰类一般都是属于同一体系中的，是组合关系。


42. 流操做的基本规律
三个明确
1.明确源和目的
源：输入流 ：字节流：InputStream 字符流：Reader
目的：输出流 ：字节流：OutputStream 字符流：writer

2.明确操做的数据是否为纯文本文件
是：字符流
否：字节流

3.当体系明确后，就要明确具体使用哪一个对象
经过设备来区分
源设备：内存，硬盘，键盘录入
目的设备：内存，硬盘，控制台


1.将一个文本文件数据复制到另外一个文本文件中
源：由于是源，因此使用输入流，InputStream Reader

由于操做的文本为纯文本，因此使用字符流 Reader

明确具体使用设备，硬盘中的文本文件，
因此使用Reader类中的具体操做文件的方法 FileReader

文本文件是否过大，是否须要提升效率，使用缓冲区方法

FileReader fr =new FileReader("yuan.xxx");
BufferedReader br =new BufferedReader(fr);

目的：
由于是目的，因此使用输出流 ，OutputStream Writer

由于操做的文本为纯文本，因此使用字符流 Writer

明确具体使用设备，硬盘中的新文本文件
因此使用Writer类中的具体操做文件的方法 FileWriter

文本文件是否过大，是否须要提升效率，使用缓冲区方法

FileWriter fw =new FileWriter("newmudi.xxx");
BufferedWriter bw =new BufferedWriter(fw);

43.拓展：将键盘录入的数据按照指定编码表（UTF-8）传到一个的文件中

源：由于是输入流，因此为InputStream，Reader

由于为纯文本，因此使用字符流 Reader

设备：键盘，因此使用System.in
但由于要操做方便，因此要转成字符流来操做要快
因此使用Reader类中的InputStreamReader方法将字节转成字符

InputStreamReader isr =new InputStreamReader(System.in);

所输文本是否过大。，是否须要高效，加缓冲区

BufferedRead br =new BufferedRead(isr);

目的：由于是输出流，因此为OutputStream，Writer

由于为纯文本，因此使用Writer

设备：硬盘中的一个新文件，因此使用FileWriter
可是FileWriter使用的默认编码表为GBK

而存储一个指定编码格式为UTF-8的文本文件，只能用转换流中的OutputStreamWriter，
而该转换流要接受一个字节输出流，并且能够操做的字节输出流为FileOutputStream

OutputStreamWriter osw =new OutputStreamWriter(new FileOutputStream("d.txt"),"UTF-8");

是否须要高效，加缓冲

BufferedWriter buw =new BufferedWriter(osw);

涉及到转码中的编码表问题，都须要使用转换流。

44.jar抓包
先将java文件进行包装，
再dos中运行javac -d 包须要放的位置 需编译的java文件
例子：javac -d g:\javab\mypackage AwtDemo5.java 将AwtDemo5进行装包到g:\javab\mypackage中
运行直接在在mypackage中运行java 包名.类名

在进行抓包中，首先进行声明主类，即建立一个文件，将Main-Class: 包名.主类名 而后回车表该行结束。注意冒号后必须有空格
例如 ：Main-Class: mymenu.AwtDemo5
抓包格式：jar -cvfn jar名 声明主类文件 包名
例子：jar -cvfm menu.jar Main.txt mymenu

45.TCP与UDP
UDP：1.将数据，目的及源封装到数据包中，不须要创建链接。
2.每次传输的数据包的大小限定在64k内
3.因无链接，因此为不可靠链接
4.由于不须要创建链接，因此速度相对较快

例子：对讲机，邮局寄物，视频会议，由于传输很快，数据丢失无所谓

TCP：1.创建数据链接，造成传输数据的通道
2.在传输通道中能够进行大数据的传输。
3.经过三次握手链接完成，是可靠链接
三次握手链接，即客户端向服务器发出请求，服务器回应客户端的请求，客户端接受到回应发回服务器的回馈。
4.由于须要创建链接，因此速度相对较慢

例子；两人打电话，

46.在函数中判断条件，在循环中只求结果，能够在循环外定义一个标记，若是循环中标记改变，则记住结果，不然不记住。列如 boolean flag= true

47.*.split(#) *对象以#分割

48. http请求消息头
/*
http://169.254.84.190:12000/myweb/demo.html
GET /myweb/demo.html HTTP/1.1 发送get请求，将
Accept: text/html, application/xhtml+xml, */* 支持格式 */*表除以上格式还支持
Accept-Language: zh-CN
User-Agent: Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Win64; x64; Tride
nt/5.0)
UA-CPU: AMD64
Accept-Encoding: gzip, deflate 支持封装格式
Host: 169.254.84.190:12000 客户端
Connection: Keep-Alive //可为closed
//空行，必须存在，用来分隔头与体
//这部分为请求消息体。
*/

49.InnetAddress 封装的是ip地址
InnerSocketAddress 封装的是ip地址加端口号

50.域名解析，若是输入的是IP地址，直接按照IP地址来打开网页
若是输入的是域名，通常先从本地C盘下的host文件来寻找域名与IP地址的映射。若是有，按照本地文件中的映射打开网页。
若是没有，再从DNS中寻找映射关系。

51.在对象调用指定方法时，必须指定调用对象，以及传入参数。

52.正则表达式:符合必定规则的表达式。
做用：用于专门操做字符串。
特色：用于一些特定的符号来表示一些代码操做。这样就简化书写。
因此学习正则表达式，就是在学习一些特殊符号的使用。
好处：能够简化对字符串的复杂操做。
弊端：符号定义越多，正则越长，阅读性越差。
具体操做功能：
1，匹配：String matches方法。用规则匹配整个字符串，只要有一处不符合规则，就匹配结束，返回false。
2，切割：String split();
3，替换：String replaceAll(regex,str);若是regex中有定义组，能够在第二参数中经过$符号获取正则表达式中的已有的组。
正则表达式的第四个功能。
4，获取:将字符串中的符合规则的子串取出。
操做步骤：
1，将正则表达式封装成对象。
2，让正则对象和要操做的字符串相关联。
3，关联后，获取正则匹配引擎。
4，经过引擎对符合规则的子串进行操做，好比取出。

53.\\1 后向引用，表示表达式中，从左往右数，第一个左括号对应的括号内的内容。
以此类推，\2表示第二个，\0表示整个表达式

$1,$2...是表示的小括号里的内容
$1是第一个小括号里的 ,$2是第2个小括号里的
好比 /gai([\w]+?)over([\d]+)/
匹配 gainover123
$1= 括号里的 n
$2= 第2个括号里的 123


匹配双字节字符(包括汉字在内)：[^\x00-\xff]

匹配中文字符的正则表达式： [\u4e00-\u9fa5]

54.static void setErr(PrintStream err)
从新分配“标准”错误输出流。
static void setIn(InputStream in)
从新分配“标准”输入流。
static void setOut(PrintStream out)
从新分配“标准”输出流。
即将System.out.println() System.in转换流

55.随机访问流，RandomAccessFile 可读可写。

56.html中将数据都使用标签进行封装，能够经过标签中的属性来操做被封装的数据。 数据细节化。 57.