1.在dos下删除文件夹（rd命令）须保证文件夹是空的。而del命令(删除文件)不同。
建立jar包双击可执行：
将java文件打包
javac -d 存放目录 源文件.java
进入存放目录
jar -cvf 文件名.jar 包名
建立一个清单文件指定Main-Class: 包名.主函数所在类名
jar -cvfm 文件名.jar 清单文件 包文件名
2.% %动态获取某原有环境变量的值。
3.临时配置方式：set命令。只在当前窗口有效。set classpath= (清空) classpath顺序问题：先找配置的环境变量（不要带分号），再找当前路径
4.用public定义的类，文件名必须与类名一致；
5.负数的二进制表示：绝对值的二进制取反再加1.
6.开辟内存空间：通过明确数据类型，变量名称，数据来完成。
7.小数默认为double类型的，在定义float类型时：float f = 2.3f;
8.什么时候定义变量：当数据不确定时，需要对数据进行存储时。
9.字符串数据和任何数据使用+都是相连接，最终都会变成字符串。
10.转义字符：通过\ 来转变后面字母或者符号的含义。\r:按下回车键。window系统，回车符是由两个字符来表示\r\n.例：打印带双引号的hello;System.out.println("\"hello\"");
11.short s=4;s=s+5;//编译不通过，因为5默认为int类型
s+=5;//编译通过，区别：只赋值，有自动类型转换功能。
12.& 和 &&的区别：&时，左边无论真假，右边都进行运算；&&时，如果左边为真，右边参与运算，如果左边为假，右边不参加运算。
另外，& 位运算。
13.>>:最高位补什么由原有数据的最高位值决定；>>>:无论最高位是什么，右移后都以0补。
应用：十进制转换成十六进制 :先&15，再>>>4,再&15，再>>>4……
十进制转换成八进制 :先&7，再>>>3,再&7，再>>>3……
十进制转换成二进制 :先&1，再>>>1,再&1，再>>>1……
14.选择if和switch:如果判断的具体数值不多，且符合byte,short,int,char这四种类型，建议使用switch。
其他类型：对区间判断或对结果为boolean类型判断，使用if。
15.for和while的区别：变量驻留内存中的时间稍有不同。对于for来讲，如果将用于控制循环的增量定义在for语句中，该变量只在for语句中有效。for语句执行完毕，该变量在内存中被释放。
16.函数内不能调用函数，只能调用。定义函数：首先，明确函数的返回值；其次明确函数的参数列表。
17.new出的对象或数组（引用数据类型）都存放在堆内存中，int类型变量默认初始化值都是0，boolean型默认值为false。String默认为null.
18.注意二维数组的写法：int[][] arr;int arr[][];int[] arr[]
19.成员变量与局部变量：作用范围：成员变量作用于整个类中；局部变量作用于函数或语句中。
在语句中的位置：成员变量在堆内存中，因为对象的存在，才在内存中存在；局部变量存在栈内存中。
20.构造代码块（{//构造代码块中定义的是不同对象共性的初始化内容}）作用：给对象进行初始化，对象一建立就运行，而且优先于构造函数执行。
和构造函数的区别：构造代码块是给所有对象进行统一初始化，而构造函数式给对应的对象初始化。
21.this代表它所在函数所属对象的引用。简单说，哪个对象在调用this所在的函数，this就代表哪个对象。
this的应用：当定义类中方法时，该方法内部要用到调用该方法的对象时，这时用this表示这个对象。但凡本类方法内部使用了本类对象，都用this表示。
this语句：用于构造函数之间进行互相调用。this语句只能定义在构造函数的第一行，因为初始化要先执行。
22.static：用法：是一个修饰符，用于修饰成员（成员变量，成员函数）。当成员被static修饰后，就多了一个调用方式，除了可以被对象调用外，还可以直接被类名调用 ：类名.静态成员。
特点：随着类的加载而加载，也就是说：静态会随着类的消失而消失，说明它的生命周期最长；
优先于对象存在，静态是先存在，而对象是后存在的；
被所有对象所共享；
可以直接被类名调用；
实例变量和类变量（静态成员变量）的区别：
1存放位置：类变量随着类的加载而存在于方法区中；实例变量随着对象的建立而存在于堆内存中；
2生命周期：类变量生命周期最长，随着类的消失而消失；实例变量生命周期随着对象的消失而消失；
静态的使用注意事项：1、静态方法只能访问静态成员；
非静态方法可以访问静态也可以访问非静态；
2、静态方法中不可以定义this，super关键字，因为静态优先于对象存在，所以静态方法中不可以出现this。
3、主函数是静态的。
静态利弊：利：对对象的共享数据进行单独空间的存储，节省空间。没有必要每一个对象中都存储一份。可以直接被类名调用。
弊：生命周期过长；访问出现局限性（只能访问静态）。
什么时候使用静态：当对象中出现共享数据时，该数据被static所修饰；对象中的特有数据要定义成非静态存在于堆内存中。
当方法内部没有访问到非静态数据（对象的特有数据），那么该方法可以定义成静态的。
23.对源文件中的文档注释进行提取形成说明文档（网页形式）：javadoc -d 指定目录 [-author] [-version] 源文件名.java
注意：源文件中的类必须是public修饰的。才能形成说明文档。
24.静态代码块：格式：static{执行语句;}
特点：随着类的加载而执行，只执行一次，并优先于主函数，用于给类进行初始化。
25.java有23种设计模式：单例设计模式：解决一个类在内存只存在一个对象。
保证对象唯一：
模式一:先初始化对象。三步：1 将构造函数私有化 private Single(){}
2 在类中创建一个本类静态对象private static Single s = new Single();
3 提供一个静态方法可以获取到该对象public static Single getInstance(){return s;}
单例设计模式方式二：对象在方法调用时，才初始化，也叫对象的延时加载。
private static Single s = null;
private Single(){}
public static Single getInstance(){ if(s==null)s=new Single();return s;}
原则：定义单例，建议用模式一。
26.继承：提高代码的复用性；让类于类之间产生了关系，有了这个关系，才有了多态的特性。
注意：不要为了获取其他类的方法，简化代码而继承，必须是类与类之间有所属关系才可以继承。
java只支持单继承，不支持多继承。java支持多层继承。
27.覆盖（重写）：子类覆盖父类，必须保证子类权限大于等于父类权限，否则编译失败。
静态只能覆盖静态。
记住：重载只看同名函数的参数列表。
重写：子父类方法要一模一样。
28.super()：会访问父类中空参数的构造函数，而且子类中所有的构造函数默认第一行都是super();
为什么子类一定要访问父类中的构造函数？
因为父类中的数据子类可以直接获取，所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的。如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式来指定。
注意：super语句一定定义在子类构造函数的第一行。
子类的实例化过程：子类的所有构造函数，默认都会访问父类中空参数的构造函数。
因为子类每一个构造函数内的第一行都有一句隐式super();
当父类中没有空参数的构造函数时，子类必须手动通过super语句形式来指定要访问的父类构造函数。
当然，子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数，子类中至少有一个构造函数会访问父类中的构造函数。
29.final：被final修饰的类不可以被继承。
被final修饰的方法不可以被重写。
被final修饰的变量是一个常量，只能赋值一次，不能改变其值。
当在描述事物时，一些数据的出现值是固定的，那么这时为了增强阅读性，都给这些值起个名字，方便阅读，而这个值不需要改变，所以加上final修饰。
作为常量，书写规范：所有的字母都大写，如果由多个单词组成，单词间通过_连接。
30.抽象类的特点：抽象方法一定在抽象类中。
抽象方法和抽象类必须被abstract修饰
抽象类不可以用new创建对象，因为调用抽象方法没意义
抽象类中的抽象方法要被使用，必须由子类重写所有的抽象方法后，建立子类对象调用。
如果子类只重写了部分抽象方法，那么该子类还是一个抽象类。
31.模板方法设计模式：当定义功能时，功能的一部分是确定的，但是有一部分是不确定的，而确定的部分在使用不确定的部分，那么这时就将不确定的部分暴露出去，由该类的子类去完成。
32.接口：当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。
class用于定义类；interface用于定义接口。
接口定义时，格式特点：
接口中常见定义：常量，抽象方法；
接口中的成员都有固定修饰符。常量：pubic static final;方法：public abstract
记住：接口中的成员都是public的。
接口是不可以创建对象的，因为有抽象方法。
需要被子类实现，子类对接口中的抽象方法都覆盖后，子类才可以实例化。否则子类是一个抽象类。
接口可以被类多实现，也是对多继承不支持的转换形式。java支持多实现。
接口与接口之间可以有继承关系，且可以是多继承关系。
33.多态：多态的体现：父类的引用指向了自己的子类对象
父类的引用也可以接收自己的子类对象
多态的前提：必须是类与类之间有关系，要么继承，要么实现
通常还有一个前提：存在覆盖
多态的好处：多态的出现大大的提高了程序的扩展性
多态的弊端：只能使用父类的引用访问父类中的成员
多态的应用：
强制类型转换：当父类的引用指向了自己的子类对象时，该引用可以被提升，也可以被强制转换。
但是不能将父类对象转成子类对象。
多态自始至终都是子类对象在做着变化。
多态中非静态成员函数的特点：
在编译时期，参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有编译失败。
在运行时期，参阅对象所属的类中是否有调用的方法。
简单总结：成员函数在多态调用时，编译看左边，运行看右边。
多态中成员变量的特点：无论编译还是运行，都参考左边（引用型变量所属的类）
多态中静态成员函数的特点：无论编译还是运行，都参考左边（引用型变量所属的类）
34.内部类的访问规则：内部类可以直接访问外部类中的成员，包括私有。因为内部类中持有了一个外部累的引用，格式：外部类名.this.
外部类要访问内部类，必须建立内部类对象。
访问格式：当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中，直接建立内部类对象。
格式：外部类名.内部类名 变量名 = 外部类名.内部类对象;
当内部类在成员位置上，可以被成员修饰符所修饰，比如，private：将内部类在外部类中进行封装；static：内部类就是具备static的特性。
当内部类被static修饰，只能直接访问外部类中的static成员，出现访问局限。
注意：当内部类中定义了静态成员，该内部类必须是static所修饰的。
当外部类中的静态方法访问内部类时，内部类也须是static的。
内部类定义在局部时，不可以被成员修饰符修饰；
可以直接访问外部类中的成员，因为还持有外部类中的引用。
但是不可以访问它所在的局部中的变量，只能访问被final修饰的局部变量。
匿名内部类：其实就是内部类的简写格式。
定义匿名内部类的前提：内部类必须是继承或者实现接口。
匿名内部类的格式：new 父类或接口(){定义子类的内容;}
其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。可以理解为带内容的对象。
匿名内部类中定义的方法最好不要超过3个。
35.异常：就是程序在运行时出现不正常情况。
异常由来：问题也是现实生活中一个具体的事物，也可以通过java的类形式进行描述，并封装成对象。
其实就是java对不正常情况进行描述后的对象体现。
对于问题的划分：两种：一种是严重的问题，一种非严重的问题。
对于严重的，java通过error类进行描述。
对于非严重的，java通过exception类进行描述。
异常的处理：try
{需要被检测的代码；}
catch(异常类 变量)
{处理方式；}
finally
{一定会执行的语句；}
在函数上声明异常（通过throws关键字声明该函数有可能出现的问题）：便于提高安全性，让调用者进行处理，不处理编译失败。
对多异常的处理：声明异常时，建议声明更为具体的异常，这样处理的可以更具体。
对方声明几个异常，就对应有几个catch块。不要定义多余的catch块。
如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面。
catch中一定要定义具体的处理方式。不要简单定义一句e.printStackTrace(),也不要简单的就书写一条输出语句。
如何自定义异常信息？
因为父类中已经把异常信息的操作完成了，所以子类只要在构造时，将异常信息传递给父类通过super语句。
那么就可以直接通过getMessage方法获取自定义的异常信息了。
当函数内容有throw抛出异常对象，并未进行try处理，必须要在函数上声明，否则编译失败。
注意：RuntimeException除外，也就是说，函数内如果抛出的RuntimeException异常,函数上可以不声明。
自定义异常：必须是自定义类继承Exception.原因：异常体系有一个特点：因为异常类和异常对象都被抛出。他们都具备可抛性。这个可抛性是Throwable这个体系中独有特点。
只有这个体系中的类和对象才可以被throws和throw操作。
自定义异常时：如果该异常发生，无法再继续进行运算，就让自定义异常继承RuntimeException
throws和throw的区别：
throws使用在函数上，throw使用在函数内。
throws后面跟的是异常类，可以跟多个，用逗号隔开。throw后跟的是异常对象。抛出后函数结束。throw语句下面的语句无法进行。throw单独存在时，下面不要定义语句，因为执行不到。
finally代码块：通常用于关闭资源。
finally只有一种情况不会执行。当执行到System.exit(0);finally不会执行。
异常在子父类覆盖中的体现：
1.子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类的异常或者该异常的父类。
2.如果父类方法抛出多个异常，那么子类在覆盖该方法时，只能抛出父类异常的子集。
3.如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可抛出异常。
如果子类方法发生了异常，就必须要就行try处理，绝对不能抛。
36.package 包与包之间进行访问，被访问的包中的类以及类中的成员，需要public修饰，否则无法访问，从这一点说，包也是封装的一种形式。
不同包中的子类可以直接访问父类中被protected权限修饰的成员
包与包之间可以使用的权限只有两种：public,protected
37.import:为了简化类名的书写。建议不要用通配符*，需要用到包中的哪个类，就导入哪个类。
38.jar工具：把类打包。
-------------------------------------------------------------------
39.进程：是一个正在执行的程序，每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元。
线程：就是进程中的一个独立的控制单元，线程在控制着进程的执行。
一个进程中至少有一个线程。
创建线程的第一种方式：继承Thread类。
1、子类覆盖父类的run方法，将线程运行的代码存放在run中。
2、建立子类对象的同事线程也被创建。
3、通过调用start方法开启线程。
创建线程的第二种方式：实现Runnable接口
1、定义类实现Runnable接口
2、覆盖Runnable接口中的run方法。
3、通过Thread类建立线程对象。
4、将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
因为自定义的run方法所属的对象是Runnable接口的子类对象，所以要让线程去执行指定对象的run方法，就必须明确该run方法所属对象。
5、调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。
为什么要覆盖run方法呢？
Thread类用于描述线程，该类就定义了一个功能，用于存储线程要运行的代码，该存储功能就是run方法。
两种方式的区别：实现接口的方式避免了单继承的局限性，在定义线程时，建议使用实现方式。
继承Thread：线程代码存放在Thread子类的run方法中；实现Runnable:线程代码存放在接口的子类run方法中。
线程运行状态：被创建、运行、阻塞、冻结、消亡。
static Thread currentThread():获取当前线程对象。getName():获取线程名称。
设置线程名称：setName或者构造函数。
多线程的安全问题：当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没执行完，另一个线程参与进来执行，导致共享数据的错误。
解决办法：对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不许参与执行。
java对于多线程的安全问题提供了专业的解决方式：同步代码块。synchronized(对象){需要被同步的代码块；}
同步函数：通过synchronized 关键字修饰函数
函数需要被对象调用。那么函数都有一个所属对象的引用，就是this。所以同步函数使用的锁是this。
如果同步函数被static修饰后，使用的锁是class。静态进入内存时，内存中没有本类对象，但是一定有该类对应的字节码文件对象。类名.class,该对象的类型是class
------------------------------------------------------------------------------------
第12天
1、如何停止线程：结束run方法。开启多线程运行，运行代码通常是循环结构，只要控制住循环，就可以让run方法结束，也就是线程结束。
2、当A线程执行到了B线程的.join()方法时，A就会等待，等B线程执行完，A才会执行。join可以用来临时加入线程执行。
------------------------------------------------------------------------------------------------
第13天
1、字符串最大的特点：一旦被初始化就不可以被改变。
2、StringBuffer是字符串缓冲区。
是一个容器。特点：长度可变化；可字节操作多个数据类型；最终会通过toString方法变成字符串；
3、基本数据类型对象包装类型和字符串类型之间做转换。
基本数据类型转成字符串：
基本数据类型+""
基本数据类型.toString(基本数据类型值);如：Interger.toString(32);
字符串转成基本数据类型：
xxx a = Xxx.parseXxx(String);如：int a = Interger.parseInt("123");
JDK1.5版本后出现的新特性：
自动装箱；Integer x = 4;
自动拆箱变成int类型，加2后再将和进行封装赋给x；x = x+2;
-------------------------------------------------------------------------------------
第14天
1、集合类：只用于存储对象；长度可变；可存储不同类型的对象。
2、迭代器：集合的取出元素的方式。for（Iterator it = al.iterator(); it.hasNext(); ）{System.out.print(it.next());}//获取迭代器，用于取出集合中的元素
3、枚举：是Vector特有的取出方式。其实枚举与迭代是一样的。
因为枚举的名称以及方法的名称都过长，所以被迭代取代了。
4、往集合中存放：一般都要复写类的hashCode方法和equals方法。
5、排序时，当主要条件相同时，一定要判断下次要条件。
TreeSet排序的第一种方式：让元素自身具备比较性：元素需要实现Comparable接口，覆盖compareTo方法。
这种方式也称为元素的自然顺序，或者叫默认顺序。
第二种排序方式：当元素自身不具备比较性时，或者具备的比较性不是所需要的，这时就需要让集合自身具备比较性。
在集合初始化时，就有了比较方式：定义比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。
两种排序都存在时，以比较器为主。
定义比较器方法：定义一个类，实现Comparator接口，覆盖compare方法。
6、泛型：用于解决安全问题，是一个安全机制。
格式：通过<>来定义要操作的引用数据类型。
其实<>就是用来接收类型的，当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。
泛型类定义的泛型，在整个类中有效，如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。
为了让不同方法可以操作不同类型，而且类型还不确定，那么可以将泛型定义在方法上。如：public <T> void show(T t){ }
特殊之处：静态方法不可以访问类上定义的泛型。如果静态方法操作的引用数据类型不确定，可以将泛型定义在方法上。
？通配符。也可以理解为占位符。
泛型的限定：？extends E:可以接收E类型或者E类型的子类型。上限。
？super E:可以接收E类型或者E的父类型。下限。
泛型限定：用于泛型扩展。
------------------------------------------------------------------------------------------
第16天
1、Map集合：该集合存储键值对。一对一对存，而且保证键的唯一性。
2、集合框架的工具类：Collections 。对象比大小：compare，compareTo
Arrays:用于操作数组的工具类。里面都是静态方法。
3、类 Arrays
asList方法:将数组变成List集合。可以使用集合的思想和方法来操作数组中的元素。
注意：将数组变成集合，不可以使用集合的增删方法。因为数组的长度是固定的。
如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合中的对象；
如果数组中的元素都是基本数据类型，那么会将数组作为集合中的元素存在。
4、集合变数组：Collection接口中的toArray方法。
为了限定对元素的操作，不允许进行增删。
指定类型的数组到底要定义多长？
当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组。长度为集合的size。
当指定类型的数组长度大于了集合的size，那不会新创建数组，而是使用传递进来的数组。
所以创建一个刚刚好的数组最优。
String[] y = x.toArray(new String[x.size()]);
5、高级for循环
格式：for(数据类型 变量名 ： 被遍历的集合（Collection）或者数组){ }
对集合进行遍历，只能获取集合元素，但是不能对集合进行操作。
如果是用ListIterator,还可以在遍历过程中对集合进行增删改查的动作。
与传统for有什么区别：高级for有局限性：必须有被遍历的目标。
6、可变参数：show(int... arr){ }
不用每一次都手动的建立数组对象，只要将要操作的元素作为参数传递即可，隐式将这些参数封装成了数组。
注意：可变参数一定要定义在参数列表的最后面。
7、StaticImport 静态导入。如：import static java.lang.*:
当类名重名时，需要指定具体的包名。
当方法重名时，指定具备所属的对象或者类。
---------------------------------------------------------------------------------------
第18天
1、产生1到10的随机数。第一种方法：int d = (int)(Math.random()*10+1);
第二种方法：Random r = new Random();
int d = r.nextInt(10)+1;
--------------------------------------------------------------------
第19天
1、IO流：用来处理设备之间的数据传输。
---字节流：处理媒体数据 抽象基类：InputStream OutputStream
---字符流:只用来处理文字数据 抽象基类：Reader Writer
2、文本文件读取方式一：一次读取单个字符。
方式二：通过字符数组进行读取。
3、将C盘一个文本文件复制到D盘
复制原理：将C盘下的文件数据存储到D盘的一个文件中。
步骤：1、在D盘创建一个文件，用于存储C盘文件中的数据
2、定义读取流和C盘文件关联
3、通过不断的读写完成数据存储
4、关闭资源。
4、缓冲区：为了提高流的操作效率而出现的。
所以在创建缓冲区之前，必须要先有流对象。只要将需要被提高的流对象作为参数传递给缓冲区的构造函数即可。
记住：只要用到缓冲区，就要记得刷新。
关闭缓冲区，就是在关闭缓冲区的流对象。
缓冲区中提供了一个跨平台的换行符。用法：缓冲区对象.newLine();
5、装饰设计模式：
当想要对已有的对象进行功能增强时，可以定义类将已有对象传入，基于已有对象的功能，并提供加强功能。
那么自定义的该类称为装饰类。
装饰类通常会通过构造方法接收被装饰的对象，并基于被装饰的对象的功能，提供更强的功能。
装饰模式比继承要灵活。避免了继承体系臃肿，而且降低了类与类之间的关系。
装饰类因为增强已有对象，具备与已有对象相同的功能，只不过提供了更强功能，所以装饰类和被装饰类通常是属于一个体系中的。
6、复制图片：思路：1.用字节读取流对象和图片关联 FileInputSteam fis = new FileInputSteam ("c:\\1.bmp");
2.用字节写入流对象创建一个图片文件，用于存储获到的图片数据。FileOutputStream fos = new FileOutputStream ("c:\\2.bmp");
3.通过循环读写，完成数据的存储。byte[] buf = new byte[1024];int len = 0;while((len=fis.read(buf))!=-1){fos.write(buf,0,len);}
4.关闭资源。if(fis!=null)fis.close();if(fos!=null)fos.close();
7、键盘录入最常见写法：BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
8、流操作的基本规律：
如何明确用哪个流对象？
1.明确源和目的 源：输入流。InputStream Reader
目的：输出流。 OutputStream Writer
2.操作的数据是否是纯文本。
是：字符流
不是：字节流
3.当体系明确后，在明确要使用哪个具体的对象。
通过设备来进行区分：源设备：内存，硬盘，键盘
目的设备：内存，硬盘，控制台
4、是否需要提高效率：
是：加入对应体系中的缓冲区
记住：转换流，字符和字节之间的桥梁，通常涉及到字符编码转换时使用。
------------------------------------------------------------------------------------
第20天
1、File 对象：在判断文件对象是文件还是目录时，要先判断该文件对象封装的内容是否存在。通过 对象.exists();判断。
2、删除带内容的目录：
原理：window中删除目录时从里往外删，递归操作。
3、类 Properties
是集合中和IO技术相结合的集合容器。
该对象的特点：可以用于键值对形式的配置文件。
那么在加载数据时，需要数据有固定格式：key = value
-------------------------------------------------------------------------------------------
第21天
1、接口 Serializable
没有方法的接口称为标记接口。
2、静态修饰的成员（方法区中）是不能被序列化的。
被transient 修饰的堆内存中的数据也不可被序列化。
3、字符编码：
编码：字符串变成字节数组。String-->byte[];str.getBytes(charsetName);
解码：字节数组变成字符串。byte[]-->String;new String(byte[],charsetName);
--------------------------------------------------------------------------------
第22天
1、GUI（图形用户界面）
java为GUI提供的对象都存在java.Awt和javax.Swing两个包中。
java.Awt:(抽象窗口工具包)需要调用本地系统方法实现功能，属重量级控件。
java.Swing:在Awt的基础上，提供了更多的组件，且完全由java实现，增强了移植性，属轻量级控件。
2、创建图形化界面：
1.创建frame窗体
2.对窗体进行基本设置
3.定义组件
4.将组件通过窗体的add方法添加到窗体中
5.让窗体显示，通过setVisible(true)
3、事件监听机制的特点：
1.事件源：awt包或者swing包中的那些图形界面组件
2.事件：每一个事件源都有自己特有的对应事件和共性事件
3.监听器：将可以触发某一个事件的动作（不止一个）都已经封装到了监听器中
以上三者，在java中都已经定义好了，直接获取其对象来用就ok
4.事件处理：我们要做的。
----------------------------------------------------------------------------
第23天
1、通信三要素：IP 端口 协议
2、java.net包
3、网络编程--Socket编程
Socket就是为网络服务提供的一种机制。
数据在两个Socket间通过IO传输。
第24天
1、结束标记：自定义结束标记
定义时间戳 获取时间System.currentTimeMillis();
s.shutdownOutput();//关闭客户端的输出流。相当于给流中加入一个结束标记-1；
2、客户端并发：
定义多线程，实现runnable接口，覆盖run方法 ，且把客户端通过构造函数传进去。
3、URL类 应用层
Socket类 传输层
-----------------------------------------------
第25天
1、正则表达式：符合一定规则的表达式。
作用：用于操作字符串。
好处：可简化对字符串的复杂操作
弊端：符号定义越多，正则越长，阅读性越差。
具体操作功能：
1、匹配：String mathches(regex)方法:用规则匹配整个字符串，只要有一处不符合，就匹配结束。返回false
2、切割：String split(reget)
reg = "\\."; 按 . 切
reg = " +" ;按多个空格切
reg = "\\\\"; 按\\切
3、替换：String replaceAll(reg,rep)方法。
4、获取：将字符串中的符合规则的子串取出。
步骤：
1、将正则表达式封装成对象
2、让正则对象和要操作的字符串相关联
3、关联后，获取正则匹配引擎
4、通过引擎对符合规则的子串进行操作。比如取出。
四种功能的选择思路：
1、如果只想知道该字符是对是错，使用匹配。
2、想要将已有的字符串变成另一个字符串，使用替换。
3、想要按照自定的方式将字符串变成多个字符串，使用切割。
获取规则以外的子串
4、想要拿到符合需求的字符串子串，使用获取。
获取符合规则的子串。
建立jar包双击可执行：
将java文件打包
javac -d 存放目录 源文件.java
进入存放目录
jar -cvf 文件名.jar 包名
建立一个清单文件指定Main-Class: 包名.主函数所在类名
jar -cvfm 文件名.jar 清单文件 包文件名
2.% %动态获取某原有环境变量的值。
3.临时配置方式：set命令。只在当前窗口有效。set classpath= (清空) classpath顺序问题：先找配置的环境变量（不要带分号），再找当前路径
4.用public定义的类，文件名必须与类名一致；
5.负数的二进制表示：绝对值的二进制取反再加1.
6.开辟内存空间：通过明确数据类型，变量名称，数据来完成。
7.小数默认为double类型的，在定义float类型时：float f = 2.3f;
8.什么时候定义变量：当数据不确定时，需要对数据进行存储时。
9.字符串数据和任何数据使用+都是相连接，最终都会变成字符串。
10.转义字符：通过\ 来转变后面字母或者符号的含义。\r:按下回车键。window系统，回车符是由两个字符来表示\r\n.例：打印带双引号的hello;System.out.println("\"hello\"");
11.short s=4;s=s+5;//编译不通过，因为5默认为int类型
s+=5;//编译通过，区别：只赋值，有自动类型转换功能。
12.& 和 &&的区别：&时，左边无论真假，右边都进行运算；&&时，如果左边为真，右边参与运算，如果左边为假，右边不参加运算。
另外，& 位运算。
13.>>:最高位补什么由原有数据的最高位值决定；>>>:无论最高位是什么，右移后都以0补。
应用：十进制转换成十六进制 :先&15，再>>>4,再&15，再>>>4……
十进制转换成八进制 :先&7，再>>>3,再&7，再>>>3……
十进制转换成二进制 :先&1，再>>>1,再&1，再>>>1……
14.选择if和switch:如果判断的具体数值不多，且符合byte,short,int,char这四种类型，建议使用switch。
其他类型：对区间判断或对结果为boolean类型判断，使用if。
15.for和while的区别：变量驻留内存中的时间稍有不同。对于for来讲，如果将用于控制循环的增量定义在for语句中，该变量只在for语句中有效。for语句执行完毕，该变量在内存中被释放。
16.函数内不能调用函数，只能调用。定义函数：首先，明确函数的返回值；其次明确函数的参数列表。
17.new出的对象或数组（引用数据类型）都存放在堆内存中，int类型变量默认初始化值都是0，boolean型默认值为false。String默认为null.
18.注意二维数组的写法：int[][] arr;int arr[][];int[] arr[]
19.成员变量与局部变量：作用范围：成员变量作用于整个类中；局部变量作用于函数或语句中。
在语句中的位置：成员变量在堆内存中，因为对象的存在，才在内存中存在；局部变量存在栈内存中。
20.构造代码块（{//构造代码块中定义的是不同对象共性的初始化内容}）作用：给对象进行初始化，对象一建立就运行，而且优先于构造函数执行。
和构造函数的区别：构造代码块是给所有对象进行统一初始化，而构造函数式给对应的对象初始化。
21.this代表它所在函数所属对象的引用。简单说，哪个对象在调用this所在的函数，this就代表哪个对象。
this的应用：当定义类中方法时，该方法内部要用到调用该方法的对象时，这时用this表示这个对象。但凡本类方法内部使用了本类对象，都用this表示。
this语句：用于构造函数之间进行互相调用。this语句只能定义在构造函数的第一行，因为初始化要先执行。
22.static：用法：是一个修饰符，用于修饰成员（成员变量，成员函数）。当成员被static修饰后，就多了一个调用方式，除了可以被对象调用外，还可以直接被类名调用 ：类名.静态成员。
特点：随着类的加载而加载，也就是说：静态会随着类的消失而消失，说明它的生命周期最长；
优先于对象存在，静态是先存在，而对象是后存在的；
被所有对象所共享；
可以直接被类名调用；
实例变量和类变量（静态成员变量）的区别：
1存放位置：类变量随着类的加载而存在于方法区中；实例变量随着对象的建立而存在于堆内存中；
2生命周期：类变量生命周期最长，随着类的消失而消失；实例变量生命周期随着对象的消失而消失；
静态的使用注意事项：1、静态方法只能访问静态成员；
非静态方法可以访问静态也可以访问非静态；
2、静态方法中不可以定义this，super关键字，因为静态优先于对象存在，所以静态方法中不可以出现this。
3、主函数是静态的。
静态利弊：利：对对象的共享数据进行单独空间的存储，节省空间。没有必要每一个对象中都存储一份。可以直接被类名调用。
弊：生命周期过长；访问出现局限性（只能访问静态）。
什么时候使用静态：当对象中出现共享数据时，该数据被static所修饰；对象中的特有数据要定义成非静态存在于堆内存中。
当方法内部没有访问到非静态数据（对象的特有数据），那么该方法可以定义成静态的。
23.对源文件中的文档注释进行提取形成说明文档（网页形式）：javadoc -d 指定目录 [-author] [-version] 源文件名.java
注意：源文件中的类必须是public修饰的。才能形成说明文档。
24.静态代码块：格式：static{执行语句;}
特点：随着类的加载而执行，只执行一次，并优先于主函数，用于给类进行初始化。
25.java有23种设计模式：单例设计模式：解决一个类在内存只存在一个对象。
保证对象唯一：
模式一:先初始化对象。三步：1 将构造函数私有化 private Single(){}
2 在类中创建一个本类静态对象private static Single s = new Single();
3 提供一个静态方法可以获取到该对象public static Single getInstance(){return s;}
单例设计模式方式二：对象在方法调用时，才初始化，也叫对象的延时加载。
private static Single s = null;
private Single(){}
public static Single getInstance(){ if(s==null)s=new Single();return s;}
原则：定义单例，建议用模式一。
26.继承：提高代码的复用性；让类于类之间产生了关系，有了这个关系，才有了多态的特性。
注意：不要为了获取其他类的方法，简化代码而继承，必须是类与类之间有所属关系才可以继承。
java只支持单继承，不支持多继承。java支持多层继承。
27.覆盖（重写）：子类覆盖父类，必须保证子类权限大于等于父类权限，否则编译失败。
静态只能覆盖静态。
记住：重载只看同名函数的参数列表。
重写：子父类方法要一模一样。
28.super()：会访问父类中空参数的构造函数，而且子类中所有的构造函数默认第一行都是super();
为什么子类一定要访问父类中的构造函数？
因为父类中的数据子类可以直接获取，所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的。如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式来指定。
注意：super语句一定定义在子类构造函数的第一行。
子类的实例化过程：子类的所有构造函数，默认都会访问父类中空参数的构造函数。
因为子类每一个构造函数内的第一行都有一句隐式super();
当父类中没有空参数的构造函数时，子类必须手动通过super语句形式来指定要访问的父类构造函数。
当然，子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数，子类中至少有一个构造函数会访问父类中的构造函数。
29.final：被final修饰的类不可以被继承。
被final修饰的方法不可以被重写。
被final修饰的变量是一个常量，只能赋值一次，不能改变其值。
当在描述事物时，一些数据的出现值是固定的，那么这时为了增强阅读性，都给这些值起个名字，方便阅读，而这个值不需要改变，所以加上final修饰。
作为常量，书写规范：所有的字母都大写，如果由多个单词组成，单词间通过_连接。
30.抽象类的特点：抽象方法一定在抽象类中。
抽象方法和抽象类必须被abstract修饰
抽象类不可以用new创建对象，因为调用抽象方法没意义
抽象类中的抽象方法要被使用，必须由子类重写所有的抽象方法后，建立子类对象调用。
如果子类只重写了部分抽象方法，那么该子类还是一个抽象类。
31.模板方法设计模式：当定义功能时，功能的一部分是确定的，但是有一部分是不确定的，而确定的部分在使用不确定的部分，那么这时就将不确定的部分暴露出去，由该类的子类去完成。
32.接口：当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。
class用于定义类；interface用于定义接口。
接口定义时，格式特点：
接口中常见定义：常量，抽象方法；
接口中的成员都有固定修饰符。常量：pubic static final;方法：public abstract
记住：接口中的成员都是public的。
接口是不可以创建对象的，因为有抽象方法。
需要被子类实现，子类对接口中的抽象方法都覆盖后，子类才可以实例化。否则子类是一个抽象类。
接口可以被类多实现，也是对多继承不支持的转换形式。java支持多实现。
接口与接口之间可以有继承关系，且可以是多继承关系。
33.多态：多态的体现：父类的引用指向了自己的子类对象
父类的引用也可以接收自己的子类对象
多态的前提：必须是类与类之间有关系，要么继承，要么实现
通常还有一个前提：存在覆盖
多态的好处：多态的出现大大的提高了程序的扩展性
多态的弊端：只能使用父类的引用访问父类中的成员
多态的应用：
强制类型转换：当父类的引用指向了自己的子类对象时，该引用可以被提升，也可以被强制转换。
但是不能将父类对象转成子类对象。
多态自始至终都是子类对象在做着变化。
多态中非静态成员函数的特点：
在编译时期，参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有编译失败。
在运行时期，参阅对象所属的类中是否有调用的方法。
简单总结：成员函数在多态调用时，编译看左边，运行看右边。
多态中成员变量的特点：无论编译还是运行，都参考左边（引用型变量所属的类）
多态中静态成员函数的特点：无论编译还是运行，都参考左边（引用型变量所属的类）
34.内部类的访问规则：内部类可以直接访问外部类中的成员，包括私有。因为内部类中持有了一个外部累的引用，格式：外部类名.this.
外部类要访问内部类，必须建立内部类对象。
访问格式：当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中，直接建立内部类对象。
格式：外部类名.内部类名 变量名 = 外部类名.内部类对象;
当内部类在成员位置上，可以被成员修饰符所修饰，比如，private：将内部类在外部类中进行封装；static：内部类就是具备static的特性。
当内部类被static修饰，只能直接访问外部类中的static成员，出现访问局限。
注意：当内部类中定义了静态成员，该内部类必须是static所修饰的。
当外部类中的静态方法访问内部类时，内部类也须是static的。
内部类定义在局部时，不可以被成员修饰符修饰；
可以直接访问外部类中的成员，因为还持有外部类中的引用。
但是不可以访问它所在的局部中的变量，只能访问被final修饰的局部变量。
匿名内部类：其实就是内部类的简写格式。
定义匿名内部类的前提：内部类必须是继承或者实现接口。
匿名内部类的格式：new 父类或接口(){定义子类的内容;}
其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。可以理解为带内容的对象。
匿名内部类中定义的方法最好不要超过3个。
35.异常：就是程序在运行时出现不正常情况。
异常由来：问题也是现实生活中一个具体的事物，也可以通过java的类形式进行描述，并封装成对象。
其实就是java对不正常情况进行描述后的对象体现。
对于问题的划分：两种：一种是严重的问题，一种非严重的问题。
对于严重的，java通过error类进行描述。
对于非严重的，java通过exception类进行描述。
异常的处理：try
{需要被检测的代码；}
catch(异常类 变量)
{处理方式；}
finally
{一定会执行的语句；}
在函数上声明异常（通过throws关键字声明该函数有可能出现的问题）：便于提高安全性，让调用者进行处理，不处理编译失败。
对多异常的处理：声明异常时，建议声明更为具体的异常，这样处理的可以更具体。
对方声明几个异常，就对应有几个catch块。不要定义多余的catch块。
如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面。
catch中一定要定义具体的处理方式。不要简单定义一句e.printStackTrace(),也不要简单的就书写一条输出语句。
如何自定义异常信息？
因为父类中已经把异常信息的操作完成了，所以子类只要在构造时，将异常信息传递给父类通过super语句。
那么就可以直接通过getMessage方法获取自定义的异常信息了。
当函数内容有throw抛出异常对象，并未进行try处理，必须要在函数上声明，否则编译失败。
注意：RuntimeException除外，也就是说，函数内如果抛出的RuntimeException异常,函数上可以不声明。
自定义异常：必须是自定义类继承Exception.原因：异常体系有一个特点：因为异常类和异常对象都被抛出。他们都具备可抛性。这个可抛性是Throwable这个体系中独有特点。
只有这个体系中的类和对象才可以被throws和throw操作。
自定义异常时：如果该异常发生，无法再继续进行运算，就让自定义异常继承RuntimeException
throws和throw的区别：
throws使用在函数上，throw使用在函数内。
throws后面跟的是异常类，可以跟多个，用逗号隔开。throw后跟的是异常对象。抛出后函数结束。throw语句下面的语句无法进行。throw单独存在时，下面不要定义语句，因为执行不到。
finally代码块：通常用于关闭资源。
finally只有一种情况不会执行。当执行到System.exit(0);finally不会执行。
异常在子父类覆盖中的体现：
1.子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类的异常或者该异常的父类。
2.如果父类方法抛出多个异常，那么子类在覆盖该方法时，只能抛出父类异常的子集。
3.如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可抛出异常。
如果子类方法发生了异常，就必须要就行try处理，绝对不能抛。
36.package 包与包之间进行访问，被访问的包中的类以及类中的成员，需要public修饰，否则无法访问，从这一点说，包也是封装的一种形式。
不同包中的子类可以直接访问父类中被protected权限修饰的成员
包与包之间可以使用的权限只有两种：public,protected
37.import:为了简化类名的书写。建议不要用通配符*，需要用到包中的哪个类，就导入哪个类。
38.jar工具：把类打包。
-------------------------------------------------------------------
39.进程：是一个正在执行的程序，每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元。
线程：就是进程中的一个独立的控制单元，线程在控制着进程的执行。
一个进程中至少有一个线程。
创建线程的第一种方式：继承Thread类。
1、子类覆盖父类的run方法，将线程运行的代码存放在run中。
2、建立子类对象的同事线程也被创建。
3、通过调用start方法开启线程。
创建线程的第二种方式：实现Runnable接口
1、定义类实现Runnable接口
2、覆盖Runnable接口中的run方法。
3、通过Thread类建立线程对象。
4、将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
因为自定义的run方法所属的对象是Runnable接口的子类对象，所以要让线程去执行指定对象的run方法，就必须明确该run方法所属对象。
5、调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。
为什么要覆盖run方法呢？
Thread类用于描述线程，该类就定义了一个功能，用于存储线程要运行的代码，该存储功能就是run方法。
两种方式的区别：实现接口的方式避免了单继承的局限性，在定义线程时，建议使用实现方式。
继承Thread：线程代码存放在Thread子类的run方法中；实现Runnable:线程代码存放在接口的子类run方法中。
线程运行状态：被创建、运行、阻塞、冻结、消亡。
static Thread currentThread():获取当前线程对象。getName():获取线程名称。
设置线程名称：setName或者构造函数。
多线程的安全问题：当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没执行完，另一个线程参与进来执行，导致共享数据的错误。
解决办法：对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不许参与执行。
java对于多线程的安全问题提供了专业的解决方式：同步代码块。synchronized(对象){需要被同步的代码块；}
同步函数：通过synchronized 关键字修饰函数
函数需要被对象调用。那么函数都有一个所属对象的引用，就是this。所以同步函数使用的锁是this。
如果同步函数被static修饰后，使用的锁是class。静态进入内存时，内存中没有本类对象，但是一定有该类对应的字节码文件对象。类名.class,该对象的类型是class
------------------------------------------------------------------------------------
第12天
1、如何停止线程：结束run方法。开启多线程运行，运行代码通常是循环结构，只要控制住循环，就可以让run方法结束，也就是线程结束。
2、当A线程执行到了B线程的.join()方法时，A就会等待，等B线程执行完，A才会执行。join可以用来临时加入线程执行。
------------------------------------------------------------------------------------------------
第13天
1、字符串最大的特点：一旦被初始化就不可以被改变。
2、StringBuffer是字符串缓冲区。
是一个容器。特点：长度可变化；可字节操作多个数据类型；最终会通过toString方法变成字符串；
3、基本数据类型对象包装类型和字符串类型之间做转换。
基本数据类型转成字符串：
基本数据类型+""
基本数据类型.toString(基本数据类型值);如：Interger.toString(32);
字符串转成基本数据类型：
xxx a = Xxx.parseXxx(String);如：int a = Interger.parseInt("123");
JDK1.5版本后出现的新特性：
自动装箱；Integer x = 4;
自动拆箱变成int类型，加2后再将和进行封装赋给x；x = x+2;
-------------------------------------------------------------------------------------
第14天
1、集合类：只用于存储对象；长度可变；可存储不同类型的对象。
2、迭代器：集合的取出元素的方式。for（Iterator it = al.iterator(); it.hasNext(); ）{System.out.print(it.next());}//获取迭代器，用于取出集合中的元素
3、枚举：是Vector特有的取出方式。其实枚举与迭代是一样的。
因为枚举的名称以及方法的名称都过长，所以被迭代取代了。
4、往集合中存放：一般都要复写类的hashCode方法和equals方法。
5、排序时，当主要条件相同时，一定要判断下次要条件。
TreeSet排序的第一种方式：让元素自身具备比较性：元素需要实现Comparable接口，覆盖compareTo方法。
这种方式也称为元素的自然顺序，或者叫默认顺序。
第二种排序方式：当元素自身不具备比较性时，或者具备的比较性不是所需要的，这时就需要让集合自身具备比较性。
在集合初始化时，就有了比较方式：定义比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。
两种排序都存在时，以比较器为主。
定义比较器方法：定义一个类，实现Comparator接口，覆盖compare方法。
6、泛型：用于解决安全问题，是一个安全机制。
格式：通过<>来定义要操作的引用数据类型。
其实<>就是用来接收类型的，当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。
泛型类定义的泛型，在整个类中有效，如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。
为了让不同方法可以操作不同类型，而且类型还不确定，那么可以将泛型定义在方法上。如：public <T> void show(T t){ }
特殊之处：静态方法不可以访问类上定义的泛型。如果静态方法操作的引用数据类型不确定，可以将泛型定义在方法上。
？通配符。也可以理解为占位符。
泛型的限定：？extends E:可以接收E类型或者E类型的子类型。上限。
？super E:可以接收E类型或者E的父类型。下限。
泛型限定：用于泛型扩展。
------------------------------------------------------------------------------------------
第16天
1、Map集合：该集合存储键值对。一对一对存，而且保证键的唯一性。
2、集合框架的工具类：Collections 。对象比大小：compare，compareTo
Arrays:用于操作数组的工具类。里面都是静态方法。
3、类 Arrays
asList方法:将数组变成List集合。可以使用集合的思想和方法来操作数组中的元素。
注意：将数组变成集合，不可以使用集合的增删方法。因为数组的长度是固定的。
如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合中的对象；
如果数组中的元素都是基本数据类型，那么会将数组作为集合中的元素存在。
4、集合变数组：Collection接口中的toArray方法。
为了限定对元素的操作，不允许进行增删。
指定类型的数组到底要定义多长？
当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组。长度为集合的size。
当指定类型的数组长度大于了集合的size，那不会新创建数组，而是使用传递进来的数组。
所以创建一个刚刚好的数组最优。
String[] y = x.toArray(new String[x.size()]);
5、高级for循环
格式：for(数据类型 变量名 ： 被遍历的集合（Collection）或者数组){ }
对集合进行遍历，只能获取集合元素，但是不能对集合进行操作。
如果是用ListIterator,还可以在遍历过程中对集合进行增删改查的动作。
与传统for有什么区别：高级for有局限性：必须有被遍历的目标。
6、可变参数：show(int... arr){ }
不用每一次都手动的建立数组对象，只要将要操作的元素作为参数传递即可，隐式将这些参数封装成了数组。
注意：可变参数一定要定义在参数列表的最后面。
7、StaticImport 静态导入。如：import static java.lang.*:
当类名重名时，需要指定具体的包名。
当方法重名时，指定具备所属的对象或者类。
---------------------------------------------------------------------------------------
第18天
1、产生1到10的随机数。第一种方法：int d = (int)(Math.random()*10+1);
第二种方法：Random r = new Random();
int d = r.nextInt(10)+1;
--------------------------------------------------------------------
第19天
1、IO流：用来处理设备之间的数据传输。
---字节流：处理媒体数据 抽象基类：InputStream OutputStream
---字符流:只用来处理文字数据 抽象基类：Reader Writer
2、文本文件读取方式一：一次读取单个字符。
方式二：通过字符数组进行读取。
3、将C盘一个文本文件复制到D盘
复制原理：将C盘下的文件数据存储到D盘的一个文件中。
步骤：1、在D盘创建一个文件，用于存储C盘文件中的数据
2、定义读取流和C盘文件关联
3、通过不断的读写完成数据存储
4、关闭资源。
4、缓冲区：为了提高流的操作效率而出现的。
所以在创建缓冲区之前，必须要先有流对象。只要将需要被提高的流对象作为参数传递给缓冲区的构造函数即可。
记住：只要用到缓冲区，就要记得刷新。
关闭缓冲区，就是在关闭缓冲区的流对象。
缓冲区中提供了一个跨平台的换行符。用法：缓冲区对象.newLine();
5、装饰设计模式：
当想要对已有的对象进行功能增强时，可以定义类将已有对象传入，基于已有对象的功能，并提供加强功能。
那么自定义的该类称为装饰类。
装饰类通常会通过构造方法接收被装饰的对象，并基于被装饰的对象的功能，提供更强的功能。
装饰模式比继承要灵活。避免了继承体系臃肿，而且降低了类与类之间的关系。
装饰类因为增强已有对象，具备与已有对象相同的功能，只不过提供了更强功能，所以装饰类和被装饰类通常是属于一个体系中的。
6、复制图片：思路：1.用字节读取流对象和图片关联 FileInputSteam fis = new FileInputSteam ("c:\\1.bmp");
2.用字节写入流对象创建一个图片文件，用于存储获到的图片数据。FileOutputStream fos = new FileOutputStream ("c:\\2.bmp");
3.通过循环读写，完成数据的存储。byte[] buf = new byte[1024];int len = 0;while((len=fis.read(buf))!=-1){fos.write(buf,0,len);}
4.关闭资源。if(fis!=null)fis.close();if(fos!=null)fos.close();
7、键盘录入最常见写法：BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
8、流操作的基本规律：
如何明确用哪个流对象？
1.明确源和目的 源：输入流。InputStream Reader
目的：输出流。 OutputStream Writer
2.操作的数据是否是纯文本。
是：字符流
不是：字节流
3.当体系明确后，在明确要使用哪个具体的对象。
通过设备来进行区分：源设备：内存，硬盘，键盘
目的设备：内存，硬盘，控制台
4、是否需要提高效率：
是：加入对应体系中的缓冲区
记住：转换流，字符和字节之间的桥梁，通常涉及到字符编码转换时使用。
------------------------------------------------------------------------------------
第20天
1、File 对象：在判断文件对象是文件还是目录时，要先判断该文件对象封装的内容是否存在。通过 对象.exists();判断。
2、删除带内容的目录：
原理：window中删除目录时从里往外删，递归操作。
3、类 Properties
是集合中和IO技术相结合的集合容器。
该对象的特点：可以用于键值对形式的配置文件。
那么在加载数据时，需要数据有固定格式：key = value
-------------------------------------------------------------------------------------------
第21天
1、接口 Serializable
没有方法的接口称为标记接口。
2、静态修饰的成员（方法区中）是不能被序列化的。
被transient 修饰的堆内存中的数据也不可被序列化。
3、字符编码：
编码：字符串变成字节数组。String-->byte[];str.getBytes(charsetName);
解码：字节数组变成字符串。byte[]-->String;new String(byte[],charsetName);
--------------------------------------------------------------------------------
第22天
1、GUI（图形用户界面）
java为GUI提供的对象都存在java.Awt和javax.Swing两个包中。
java.Awt:(抽象窗口工具包)需要调用本地系统方法实现功能，属重量级控件。
java.Swing:在Awt的基础上，提供了更多的组件，且完全由java实现，增强了移植性，属轻量级控件。
2、创建图形化界面：
1.创建frame窗体
2.对窗体进行基本设置
3.定义组件
4.将组件通过窗体的add方法添加到窗体中
5.让窗体显示，通过setVisible(true)
3、事件监听机制的特点：
1.事件源：awt包或者swing包中的那些图形界面组件
2.事件：每一个事件源都有自己特有的对应事件和共性事件
3.监听器：将可以触发某一个事件的动作（不止一个）都已经封装到了监听器中
以上三者，在java中都已经定义好了，直接获取其对象来用就ok
4.事件处理：我们要做的。
----------------------------------------------------------------------------
第23天
1、通信三要素：IP 端口 协议
2、java.net包
3、网络编程--Socket编程
Socket就是为网络服务提供的一种机制。
数据在两个Socket间通过IO传输。
第24天
1、结束标记：自定义结束标记
定义时间戳 获取时间System.currentTimeMillis();
s.shutdownOutput();//关闭客户端的输出流。相当于给流中加入一个结束标记-1；
2、客户端并发：
定义多线程，实现runnable接口，覆盖run方法 ，且把客户端通过构造函数传进去。
3、URL类 应用层
Socket类 传输层
-----------------------------------------------
第25天
1、正则表达式：符合一定规则的表达式。
作用：用于操作字符串。
好处：可简化对字符串的复杂操作
弊端：符号定义越多，正则越长，阅读性越差。
具体操作功能：
1、匹配：String mathches(regex)方法:用规则匹配整个字符串，只要有一处不符合，就匹配结束。返回false
2、切割：String split(reget)
reg = "\\."; 按 . 切
reg = " +" ;按多个空格切
reg = "\\\\"; 按\\切
3、替换：String replaceAll(reg,rep)方法。
4、获取：将字符串中的符合规则的子串取出。
步骤：
1、将正则表达式封装成对象
2、让正则对象和要操作的字符串相关联
3、关联后，获取正则匹配引擎
4、通过引擎对符合规则的子串进行操作。比如取出。
四种功能的选择思路：
1、如果只想知道该字符是对是错，使用匹配。
2、想要将已有的字符串变成另一个字符串，使用替换。
3、想要按照自定的方式将字符串变成多个字符串，使用切割。
获取规则以外的子串
4、想要拿到符合需求的字符串子串，使用获取。
获取符合规则的子串。
346
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
