java精简学习笔记（黑马毕老师授）

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、想要拿到符合需求的字符串子串，使用获取。

获取符合规则的子串。