学习java的杂乱笔记

Posted 2020-10-04

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.