java基础总结

一、基础知识：Java 语言基础组成

day02

1、组成：关键字、标识符、注释、常量和变量、运算符、语句、函数、数组

二、基础知识：关键字
2、关键字的定义和特点：定义：被 Java 语言赋予了特殊含义的单词。特点：关键字中所有字母都为小写。 3、用于定义数据类型的关键字：class、interface、byte、short、int、long、float、double、 char、boolean、void。 4、用于定义数据类型值的关键字：true、false、null。 5、用于定义流程控制的关键字：if、else、switch、case、default、while、do、for、break、

continue、return。 6、用于定义访问权限修饰的关键字：private、protected、public。 7、用于定义类，函数，变量修饰的关键字：abstract、final、static、synchronized。 8、用于定义类与类之间关系的关键字：extends、implements。 9、用于定义建立实例以及引用实例，判断实例的关键字：new、this、super、instanceof。 10、用于异常处理的关键字：try、catch、finally、throw、throws。 11、用于包的关键字：package、import。 12、其他修饰符关键字：native、strictfp、transient、volatile、assert。

三、基础知识：标识符
13、标识符：在程序中自定义的一些名称；由 26 个英文字母大小写，数字：0-9，符号_$组成；定义合法标识符规则：数字不可以开头、不可以使用关键字；Java 中严格区分大小写；注意：在起名时，为了提高阅读性，要尽量有意义。 14、Java 中的名称规范：包名：多单词组成时所有都小写，如：xxxyyyzzz；类名接口名：多单词组成时，所有单词的首字母大写，如：XxxYyyZzz；变量名和函数名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写，如：xxxYyyZzz；常量名：所有字母都大写，多单词时每个单词用下划线连接，如：XXX_YYY_ZZZ。

四、基础知识：注释
15、注释：对于单行和多行注释，被注释的文字，不会被 JVM（Java 虚拟机）解释执行；对于文档注释，是 Java 特有的注释，其中注释内容可以被 JDK 提供的工具 javadoc 所解析，生成一套以网页文件形式体现的该程序的说明文档；注释是一个程序员必须要具有的良好编程习惯；初学者编写程序可以养成习惯；先写注释再写代码；将自己的思想通过注释先整理出来，再用代码去体现；因为代码仅仅是思想的一种体现形式而已；用于注解说明解释程序的文字就是注释；提高了代码的阅读性。 16、Java 中的注释格式：单行注释：格式：//注释文字；多行注释：格式：/*注释文字*/；文档注释：格式：/**注释文字*/。

五、基础知识：常量
17、常量表示不能改变的数值。 18、Java 中常量的分类：整数常量：所有整数；小数常量：所有小数；布尔型常量：较为特有，只有两个数值：true 和 false；字符常量：将一个数字字母或者符号用单引号（’’）标识；字符串常量：将一个或者多个字符用双引号（””）标识；null 常量：只有一个数值就是 null。 19、对于整数：Java 有三种表现形式：十进制：0-9，满 10 进 1；八进制：0-7，满 8 进 1，用 0 表示开头；十六进制：0-9，A-F，满 16 进 1，用 0x 开头表示。

六、基础知识：进制转换
20、进制的转换特点：八位二进制表示一个字节（基本的数据单元）。三个二进制位表一个

八进制位。四个二进制位表示一个十六进制位。ASCII 码编码表。 21、二进制和十进制之间的转换：十进制转二进制：原理：对十进制数进行除 2 运算（除二取余法）；二进制转十进制：原理：二进制乘以 2 的 N 次的过程。 22、快捷方法：8421 法则。 23、负数的二进制表现形式：对应的正数二进制取反加 1。负数的最高位都是 1。

七、基础知识：变量
24、变量的概念：内存中的一个存储区域；该区域有自己的名称（变量名）和类型（数据类型）；该区域的数据可以在同一类型范围内不断变化；理解：变量就如同数学中的未知数；变量：就是将不确定的数据进行存储，也就是需要在内存中开辟一个空间。 25、为什么要定义变量：用来不断的存放同一类型的常量，并可以重复使用。 26、使用变量注意：变量的作用范围（一对{}之间有效）；初始化值。 27、定义变量的格式：数据类型变量名=初始化值；注：格式是固定的、记住格式，以不变应万变。 28、Java 语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存总分配了不同打小的内存空间。数据类型：基本数据类型（数值型（整数类型（byte，short，int， long）；浮点类型（float，double））；字符型（char）；布尔型（boolean））；引用数据类型（类（class）；接口（interface）；数据（[]））。注意：整数默认：int，小数默认：double。 29、数据类型空间：byte 8 位二进制（一个 8 位二进制或 1 个字节）；short 16 位二进制（二个 8 位二进制或 2 个字节）；int 32 位二进制（四个 8 位二进制或 4 个字节）；long 64 位二进制（八个 8 位二进制或 8 个字节）；float（单精度）32 位二进制（四个 8 位二进制或 4 个字节）；double（双精度）64 位二进制（八个 8 位二进制或 8 个字节）；char 取值：0-65535； boolean 取值：true，false。 30、类型转换。不同类型的数据不能进行运算。需要进行数据类型提升，从小往大提升，自动数据类型提升。强制类型转换：格式：变量=（类型名）（需转换的数据）；什么时候使用强制转换：如：小数保留整数部分。 31、表达式的数据类型自动提升：所有的 byte 型、short 型和 char 的值将被提升到 int 型；如果一个操作数是 long 型，计算结果就是 long 型；如果一个操作数是 float 型，计算结果就是 float 型；如果一个操作数是 double 型，计算结果就是 double 型。分析： system.out.println （ ‘a’ ）与 system.out.println（ ‘a’+1）的区别。

八、基础知识：运算符
32、算数运算符：+正号，-负号，+加，-减，*乘，/除，%取模，++自增（前），++自增（后）， --自减（前），--自减（后），+字符串相加（字符串数据和任何数据使用+都是相连接，最终都会变成字符串）。 33、转义字符：通过来转变后面字母或者符号的含义。在 Linux 系统中换行是一个字符来表示，windows 系统中，换行由实现。 :换行。:退格。相当于 backspace 键。 : 按下回车键。 :制表符。相当于 tab 键。 34、赋值运算符：符号：=：赋值，+=：a+=5 等价于 a=a+5，-=，*=，/=，%=。 35、比较运算符：==：相等于；！=：不等于；<：小于；>：大于；<=：小于等于；>=：大于等于；instanceof：检查是否是类的对象。注意：比较运算符的结果都是 boolean 型，也就是

要么是 true，要么是 false；比较运算符“==”不能误写成“=” 。 36、逻辑运算符：&：AND（与）两边的 boolean 表达式结果，有一个为 false，那么结果就是 false，只要两边都为 true，结果为 true；|：OR（或）两边的 boolean 表达式结果，只要有一个为 true，结果为 true，只有两边都有 false，结果为 false； ^： XOR （异或）两边的 boolean 表达式结果相同结果为 false，两边不同结果为 true；！：NOT（非）；&&：AND（短路）；||OR：（短路）。逻辑运算符用于连接 boolean 类型的表达式。&和&&的特点：&：无论左边是真是假，右边都运算；&&：当左边为假时，右边不运算。|和||的特点：|：两边都做运算；||：但左边为真时，右边不运算。 37、位运算符：<<：左移，如：3<<2=12 等价于 3*2^2=12；>>：右移，如：6>>2=1 等价于 6/2^2=1；>>>：无符号右移，如：3>>>1=1；&：与运算，如：6&3=2；|：或运算，如：6|3=7； ^：异或运算，如：6^3=5；~：反码，如：~6=-7；位运算是直接对二进制进行运算。<<：其实就是乘以 2 的移动的位数次幂；>>：就是除以 2 的移动的位数次幂。>>：最高位补什么由原有数据的最高位值而定；如果最高位 0，右移后，用 0 补空位；如果最高位 1，右移后，用 1 补空位。>>>：无论最高位是什么，右移后，都用 0 补。一个数异或同一个数两次，结果还是拿个数。 38、三元运算符：格式：（条件表达式）？表达式 1：表达式 2；如果条件为 true，运算后的结果是表达式 1；如果条件为 false，运算后的结果是表达式 2。如：获取两个数中大数，int x=3,y=4,z;z=(x>y)?x:y//z 变量存储的就是两个数的大数。

九、基础知识：if 语句
39、程序流程控制：顺序结构，判断结构，选择结构，循环结构。 40、判断结构：if 语句三种格式：一层判断：if(条件表达式){执行语句;}；两层判断：if(条件表达式){执行语句;}else{ 执行语句;}；多层判断：if(条件表达式){执行语句;}else if(条件表达式){执行语句;}else{执行语句;}。 41、if else 结构间歇格式：变量=（条件表达式）？表达式 1：表达式 2；三元运算符：好处：可以简化 if else 代码；弊端：因为是一个运算符，所以运算完毕需要有一个结果。 42、解决 DOS 命令下，编译无法识别 GDK 码方法：方法一：使用-encoding 参数指明编码方式：javac -encoding UTF-8 XX.java。方法二：保存 java 文件时，选择编码格式为 ANSI。

十、基础知识：switch 语句
43、选择结构：switch 语句：格式：switch(表达式){case 取值 1：执行语句；break；case 取值 2：执行语句；break；??default：执行语句；//break；} 44、switch（表达式）：表达式只接收四种类型：byte，short，int，char。 45、if 语句与 switch 语句的区别：if 除了能判断数值，还能判断具体区间，switch 判断区间很累；对于数字是布尔型时，只有 if 能判断。 46、if 语句与 switch 语句的用法：如果要对具体数字进行判断，数值不多，而且符合 byte、 short、int、char 这四种类型，虽然两个语句都可以使用，建议用 switch 完成。因为效率稍高。其他情况一般用 if。当结果为布尔型或区间时，用 if 完成。If 的使用范围更广。

2016 年 01 月 08 日 day03
一、基础知识：while 语句
1、循环结构：代表语句：while、do while、for。 2、while 语句格式：while（条件表达式）{执行语句；}。 3、do while 语句格式：do{执行语句；}while（条件表达式）；。Do while 特点是条件无论是否满足，循环体至少被执行一次。 4、while 和 do while 的区别：while：先判断条件，只有条件满足才执行循环体。do while：先执行循环体，再判断条件，条件满足，再继续执行循环体。简单一句话：do while：无论条件是否满足，循环体至少执行一次。

二、基础知识：for 语句
5、 for 语句格式： for （初始化表达式；循环条件表达式；循环后的操作表达式） {执行语句； }。注意：a：for 里面的连个表达式运行的顺序，初始化表达式只读一次，判断循环条件，为真就执行循环体，然后再执行循环后的操作表达式，接着继续判断循环条件，重复找个过程，直到条件不满足为止。b：while 与 for 可以互换，区别在于 for 为了循环而定义的变量在 for 循环结束就是在内存中释放。而 while 循环使用的变量在循环结束后还可以继续使用。c：最简单无限循环格式：while（true），for（；；），无限循环存在的原因是并不知道循环多少次，而是根据某些条件，来控制循环。 6、for 和 while 的区别：a：变量有自己的作用域。对于一个变量来将，如果这个变量仅仅用于控制循环的次数，用作循环增量时用 for 语句。循环结束时，该变量在内存被释放。用于优化内存。b：for 和 while 可以进行互换，如果定义循环增量，用 for 更为合适。 7、什么时候使用循环结构？当要多某些语句执行很多次时，就是用循环结构。 8、循环注意：一定要明确哪些语句需要参与循环，哪些不需要。 9、两种思想：累加思想：原理：通过变量记录住每次变化的结果。通过循环的形式，进行累加动作。计数器思想：原理：通过一个变量记录住数据的状态变化。也通过循环完成。 10、循环嵌套：语句嵌套形式，其实就是语句中含有语句。 11、其他流程控制语句：break（跳出），continue（继续）。Break 语句：应用范围：选择结构和循环结构。Continue 语句：应用于循环结构。注意：a：这两个语句离开应用范围，存在是没有意义的。b：这两个语句单独存在下面都不可以有语句，因为执行不到。c：continue 语句是结束本次循环继续下次循环。 d：标号的出现，可以让这两个语句作用于指定的范围。 12、注意：标号只能用于循环语句上，给循环起名字。 13、continue：只能作用于循环结构。继续循环。特点：结束本次循环，继续下一次循环。 14、总结：a：break 和 continue 语句作用的范围。b：break 和 continue 单独存在时，下面可以有任何语句。因为都执行不到。

三、基础知识：函数
15、函数的定义：什么是函数？函数就是定义在类中的具有特定功能的一段独立小程序；函

数也称为方法。 16、函数的格式：修饰符返回值类型函数名（参数类型形式参数 1，参数类型形式参数 2， ?） {执行语句；return 返回值；}。返回值类型：函数运行后的结果的数据类型。参数形式：是形式参数的数据类型。形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。实际参数：传递给形式参数的具体数值。Return：用于结束函数。返回值：该值会返回给调用者。 17、函数的特点：定义函数可以将功能代码进行封装；便于对该功能进行复用；函数只有被调用才会被执行；函数的出现提高了代码的复用性；对于函数没有具体返回值的情况，返回值类型用关键字 void 表示，那么该函数中的 return 语句如果在最后一行可以省略不写。注意：函数中只能调用函数，不可以在函数内部定义函数；定义函数时，函数的结果应该返回给调用者，交由调用者处理。 18、重点：函数的应用。如何定义一个函数呢？a：既然函数是一个独立的功能，那么该功能的运算结果是什么先明确。因为这是在明确函数的返回值类型。b：再明确在定义该功能的过程中是否需要未知的内容参与运算。因为是在明确函数的参数列表（参数的类型和参数的个数）。 19、函数的重载（overload）：重载的概念：在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。重载的特点：与返回值无关，只看参数列表。重载的好处：方便与阅读，优化了程序设计。重载示例：//返回两个整数的和 int add(int x,int y){return x+y;}；//返回三个整数的和 int add(int x,int y,int z){return x+y+z;}；//返回两个小数的和 double add(double x,double y){return x+y;}。 20、什么时候用重载？当定义的功能相同，但参与运算的未知内容不同。那么，这时就定义一个函数名称以表示其功能，方便阅读，而通过参数列表的不同来区分多个同名函数。

四、基础知识：数组
21、数组的定义：概念：同一种数据类型的集合。其实数组就是一个容器。数组的好处：可以自动给数组中的元素从 0 开始编号，方便操作这些元素。关键字：new：用来在内存中产生一个容器实体。格式一：元素类型[]数组名=new 元素类型[元素个数或数组长度]；示例： int [] arr=new int[5]；格式二：元素类型[]数组名=new 元素类型[]{元素，元素， ?}；示例： int[] arr=new int[]{3,5,1,7}；int[] arr={3,5,1,7}。 22、内存结构：Java 程序在运行时，需要在内存中分配空间。为了提高运行效率，又对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存的管理方式。 A：栈内存（栈区）：用于存储局部变量，当数据使用完，所占空间会自动释放。B：堆内存（堆区）：数组和对象，通过 new 建立的实例都存放在堆内存中。每一个实体都有内存地址。实体中的变量都有默认初始化值。实体不在被使用，会在不确定的时间内被垃圾回收器回收。 C：方法区，本地方法区，寄存器。

2016 年 01 月 09 日
一、基础知识：数组

day04

1、获取数组中的元素。通常会用到遍历。 2、数组中有一个属性可以直接获得到数组元素个数。length。使用方式：数组名称.length。 3、数组排序：选择排序：内循环结束一次，最值出现头角标位置。冒泡排序：第一圈：最值出现在了最后位。 4、java 中排序工具：import.java.util.*；Array.sort(arr)。java 中已经定义好的一种排序方式。开发中，对数组排序，要使用该句代码。 5、二维数组：数组中的数组：格式一：int[][] arr=new int[3][2]；定义了名称为 arr 的二维数组；二维数组中有 3 个一维数组；每一个一维数组中有 2 个元素；一维数组的名称分别为 arr[0]，arr[1]，arr[2]；给第一个一维数组 1 脚标位赋值为 78 写法是：arr[0][1]=78。格式二： int[][] arr=new int[3][]；二维数组中有 3 个一维数组；每个一维数组都是默认初始值 null；可以对这个三个一维数组分别进行初始化： arr[0]=new int[3]； arr[1]=new int[1]； arr[2]=new int[2]。

2016 年 01 月 10 日
一、面向对象：概述

day05

1、理解面向对象：面向对象是相对面向过程而言；面向对象和面向过程都是一种思想；面向过程：强调的是功能行为；面向对象：将功能封装进对象，强调了具备了功能的对象；面向对象是基于面向过程的。让我们的角色从执行者变为指挥者。面向过程是面向对象的基础。 2、一切皆对象，境界：万物皆对象。 3、写程序时：先考虑对象。有对象时，直接用。没对象时，自己造一个对象。 4、人开门：名称提炼法。事物：人、门。示例：人{开门（门）{门。开（）；}}；门{开（） {操作门轴等。}}。 5、面向对象的三个特征：封装，继承，多态。 6、以后的开发：其实就是找对象使用。没有对象，就创建一个对象。 7、找对象，建立对象，使用对象，维护对象的关系。 8、类和对象的关系：类就是：对现实生活中事物的描述。对象：就是这类事物，实实在在的个体。映射到 java 中，描述就是 class 定义的类。具体对象就是对于 java 在堆内存中用 new 建立实体。 9、类与对象示例：图纸：汽车，汽车，汽车。可以理解为：类就是图纸；汽车就是堆内存中的对象。 10、描述事物其实就在是描述事物的属性和行为。 11、属性对应是类中的变量，行为对应的类中的函数（方法）。其实定义类，就是在描述事物，就是在定义属性和行为。属性和行为共同成为类中的成员（成员变量和成员函数（方法））。 12、引用变量：类类型变量。记住：类类型变量指向对象。 13、就需要该对象做使用，在 java 指挥方式是：对象.对象成员。

14、成员变量和局部变量：作用范围：成员变量作用于整个类中。局部变量作用于函数中，或者语句中。在内存中的位置：成员变量：在堆内存中，因为对象的存在，才在内存中存在。局部变量：存在栈内存中。 15、匿名对象：匿名对象是对象的简化形式；匿名对象两种使用情况：当对对象方法仅进行一次调用的时；匿名对象可以作为实际参数进行传递。

二、面向对象：封装
16、封装的定义：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。 17、封装的好处：将变化隔离；便于使用；提高重用性；提高安全性。 18、封装原则：将不需要对外提供的内容隐藏起来；把属性都隐藏，提供公共方法对其访问。 19、函数是最小的封装体；类是较小的封装体；包是中级封装体；框架是较大的封装体。 20、关键字 private：私有，权限修饰符：用于修饰类中的成员（成员变量，成员函数）。在类中隐藏。私有只在本类中有效。 21、注意：私有仅仅是封装的一种表现形式。 22、之所以对外提供访问方式，就是因为可以在访问方式中加入逻辑判断语句。对访问的数据进行操作。提高代码健壮性。 23、关键字 private：将成员变量私有化。对外提供对应的 set，get 方法对其进行访问。提高对数据访问的安全性。

三、面向对象：构造函数
24、构造函数的特点：函数名与类名相同；不用定义返回值类型；不可以写 return 语句。 25、构造函数的作用：给对象进行初始化。注意：默认构造函数的特点；多个构造函数是以重载的形式存在的。 26、构造函数：对象一建立就会调用与之对应的构造函数。构造函数的作用：可以用于给对象进行初始化。 27、构造函数的小细节：当一个类中没有定义构造函数时，那么系统会默认给该类假如一个空参数的构造函数。当在类中自定义了构造函数后，默认的构造函数就没有了。 28、构造函数和一般方法（函数）的区别：A：构造函数和一般函数在写法上有不同。B：在运行上也有不同。构造函数是在对象一建立就运行。就对象初始化。而一般方法是对象调用才执行，是给对象添加对象具备的功能。C：一个对象建立，构造函数只运行一次。而一般方法可以被该对象调用多次。 29、什么时候定义构造函数呢：当分析事物时，该事物存在具备一些特征或者行为，那么将这些内容定义在构造函数中。 30、构造代码块：作用：给对象进行初始化。对象一建立就运行，而且优先于构造函数执行。 31、构造代码块和构造函数区别：构造代码块是给所有对象进行统一初始化，而构造函数是给对应的对象进行初始化。 32、构造代码块中定义的是不同对象共性的初始化内容。

四、面向对象：this 关键字
33、关键字 this：看上去，是用于区分局部变量和成员变量同名情况。 34、关键字 this 的特点：就代表本类的对象，到底代表哪一个呢？this 代表它所在函数所属对象的引用。简单说：哪个对象在调用 this 所在的函数，this 就代表哪个对象。 35、this 的应用：当定义类中功能时，该函数内部要用到该函数的对象时，这时用 this 来表示这个对象。但凡本类功能内部使用到了本类对象，都用 this 代替。 36、 this 语句：用于构造函数之间函数互相调用。 this 语句：只能定义在构造函数的第一行。因为初始化要先执行。 37、this 语句只能用于构造函数间，不能用于一般函数。

2016 年 01 月 11 日
一、面向对象：static 关键字

day06

1、static（静态）关键字：用于修饰成员（成员变量和成员函数）。被修饰后的成员具备以下特点：随着类的加载而加载；优先于对象存在；被所有对象所共享；可以直接被类名调用。使用注意：静态方法只能访问静态成员；静态方法中不可以写 this，super 关键字；主函数是静态的。 2、用法：是一个修饰符，用于修饰成员（成员变量，成员函数）。当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，还可以直接被类名用。类名.成员变量。 3、实例变量和类变量的区别：A，存放位置：类变量随着类的加载而存在于方法区中。实例变量随着对象的建立存在于堆内存中。B，生命周期：类变量生命周期最长，随着类的消失而消失。实例变量随着对象的消失而消失。 4、静态使用注意事项：A，静态方法只能访问静态成员。非静态方法既可以访问静态也可以访问非静态。B，静态方法中不可以定义 thsi，super 关键字。因为静态优先于对象存在，所有静态方法中不可以出现 this。C，主函数是静态的。 5、静态优缺点：优：对对象的共享数据进行单独空间的存储，节省空间。没有必要每个对象中都存储一份。可以直接被类名调用。缺：生命周期过长。访问出现局限性。（静态虽好，只能访问静态。） 6、public static void main(String[] args) 主函数：是一个特殊的函数，作用程序的入口，可以被 jvm 调用。 7、主函数的定义：public：代表着该函数访问权限是最大的。static：代表主函数随着类的加载就已经存在了。void：代表主函数没有具体的返回值。main：不是关键字，但是是一个特殊的单词，可以被 jvm 识别。（String[] args）：函数的参数，参数类型是一个数组，该数组中的元素是字符串。字符串类型的数组。 8、主函数是固定格式的：jvm 识别。jvm 在调用主函数时，传人的是 new String[0]；。 9、什么时候使用静态？要从两方面下手：因为静态修饰的内容有成员变量和函数。什么时候定义静态变量（类变量）呢？当对象中出现共享数据时，该数据静态所修饰。对象中的特有数据要定义成非静态存在于堆内存中。 10、什么时候定义静态函数呢？当功能内部没有访问到非静态数据（对象的特有数据），那

么该功能可以定义成静态的。 11、静态的应用：A 每一个应用程序中都有共性的功能，可以将这些功能进行抽取，独立封装。以便复用。 B 虽然可以通过建立 ArrayTool 的对象使用这些工具方法，对数组进行操作。但是：1，对象是用于封装数据的，可以 ArrayTool 对象并未封装特特有数据。2，操作数组的每一个方法都没有用到 ArrayTool 对象中的特有数据。C 这时就考虑，让程序更严谨，是不需要对象的。可以将 ArrayTool 中的方法都定义成 static 的，直接通过类名调用即可。D 将方法都静态后，可以方便于使用，但是该类还是可以被其他程序建立对象的。为了更为严谨，强制让该类不能建立对象。可以通过将构成函数私有化完成。 12、接下来，将 ArrayTool.class 文件发送给其他人，其他人只要将该文件设置到 classpath 路径下，就可以使用该工具类。但是，很遗憾，该类中到底定义了多少个方法，对方不清楚。因为该类并没有使用说明书。开始制作程序的说明书。java 的说明书通过文档注释来完成。 13、注释符号：/***/；@author 作者；@version 版本；@param 参数；@return 返回值。 14、静态代码块。格式：static{静态代码块中的执行语句。}。 15、静态代码块的特点：随着类的加载而执行，只执行一次,并优先于主函数。用于给类进行初始化的。 16、重点：对象的初始化过程： Person p=new Person(“zhangsan”,20);该句话都做了什么事情？ A 因为 new 用到了 Person。Class。所有会先找到 Person。Class 文件并加载到内存中。B 执行该类中的 static 代码块，如果有的话，给 Person.class 类进行初始化。C 在堆内存中开辟空间，分配内存地址。D 在堆内存中建立对象的特有属性，并进行默认初始化。E 对属性进行显示初始化。F 对对象进行构造代码块初始化。G 对对象进行对应的构造函数初始化。H 将内存地址付给栈内存中的 p 变量。

二、面向对象：单例设计模式
17、设计模式：解决某一类问题最行之有效的方法。 java 中 23 中设计模式：单例设计模式：解决一个类在内存只存在一个对象。 18、想要保证对象唯一。1，为了避免其他程序过多建立该类对象。先禁止其他程序建立该类对象。2，还为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象。3，为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。 19、这三步怎么用代码体现呢？1，将构造函数私有化。2，在类中创建一个本类对象。3，提供一个方法可以获取到该对象。 20、对于事物该怎么描述，还怎么描述。当需要将该事物的对象保证在内存中唯一时，就将以上的三部加上即可。 21、单例设计方法一：这个是先初始化对象。称为：饿汉式。Single 类一进内存，就已经创建好了对象。开发一般用饿汉式：安全、简单。 22、单例设计方法二：对象被调用时，才初始化，也叫做对象的延时加载。称为：懒汉式。 Single 类进内存，对象还没有存在，只有调用了 getInstance 方法时，才建立对象。 23、记住原则：定义单例，建议使用饿汉式。但面试时：考懒汉式的多。特别是如何解决懒汉式的缺点。

2016 年 01 月 12 日
一、面向对象：继承

day07

1、继承：1，提高代码的复用性。2，让类与类之间产生了关系。有了这个关系，才有了多态的特性。关键字：extends。 2、注意：千万不要为了获取其他类的功能，简化代码而继承。必须是类与类之间有所属关系才可以继续。所属关系 is a。 3、java 语言中：java 只支持单继承，不支持多继承。原因：因为多继承容易带来安全隐患：当多个父类中定义了相同功能，当功能内容不同时，子类对象不确定要运行哪一个。但是 java 保留这种机制，并用另一种体现形式来完成表示，多实现。 4、java 支持多层继承。也就是一个继承体系。如何使用一个继承体系中的功能呢？想要使用体系，先查阅父类的描述，因为父类中定义的是该体系中共性功能。通过了解共性功能，就可以知道该体系的基本功能。那么这个体系已经可以基本使用了。 5、那么在具体调用时，要创建最子类的对象，为什么呢？一是因为有可能父类不能创建对象，二是创建子类对象可以使用更多的功能，包括基本的也包括特有的。 6、简单一句话：查阅父类功能，创建子类对象使用功能。 7、this 代表本类对象的引用，super 代编父类对象的引用。 8、子父类出现后，类成员的特点：类中成员：A，变量。B，函数。C，构造函数。 9、子父类中的变量：如果子类中出现非私有的同名变量时，之类要访问本类中的同名变量，用 this 子类要访问父类中的同名变量，用 super。super 的使用和 this 的使用几乎一致。this 代表的是本类对象的引用。super 代表的是父类对象的引用。 10、子父类中的函数：当子类出现和父类一模一样的函数时，当子类对象调用该函数，会运行子类函数的内容。如同父类的函数被覆盖一样。这种情况是函数的另一个特性：重写（覆盖）。 11、修改以往的源码绝对是灾难。 12、单子类继承父类，沿袭了父类的功能，到子类中，但是子类虽具备该功能，但是功能的内容却和父类不一致，这时，没有必要定义新功能，而是使用覆盖特殊，保留父类的功能定义，并重写功能内容。 13、注意：覆盖：子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。静态只能覆盖静态。 14、记住大家：重载：只看同名函数的参数列表。重写：子父类方法要一模一样。 15、子父类中的构造函数：发现在对子类对象进行初始化时，父类的构造函数也会运行。那是因为子类的构造函数默认第一行有一条隐式的语句 super（）；super（）；会访问父类中空参数的构造函数。而且子类中所有的构造函数默认第一行都是 super（）；。 16、为什么子类一定要访问父类中的构造函数：因为父类中的数据子类可以直接获取，所有之类对象在建立时，需要先查看父类是如何对这些数据进行初始化的。所有之类在对象初始化时，要先访问一下父类中的构造函数。如果要访问父类中指定的构造函数，可以通过手动定义 super 语句的方式来指定。注意：super 语句一定一定在子类构造函数第一行。 17、子类的实例化过程。结论：子类的所有的构造函数默认都会访问父类中空参数的构造函数。因为子类每一个构造函数内的每一行都有一句隐式的 super（）；当父类中没有空参数的构造函数时，子类必须手动通过 super 语句或者 this 语句形式来指定要访问父类中的构造函

数。当然：子类的构造函数第一行也可以收到指定 this 语句来访问本类中的构造函数。子类中至少会有一个构造函数会访问父类中的构造函数。 18、关键字：final：final 可以修饰类，方法（函数），变量；final 修饰的类不可以被继承； final 修饰的方法（函数）不可以被覆盖；final 修饰的变量是一个常量，只能被赋值一次；内部类只能访问被 final 修饰的局部变量。

二、面向对象：抽象类
19、当多个类中出现相同功能，但是功能主体不同，这时也可以进行向上抽取。这时，只抽取功能定义，而不抽取功能主体。 20、抽象：看不懂。 21、抽象类的特点： A，抽象方法一定定义在抽象类中。 B，抽象方法和抽象类都必须被 abstract 关键字修饰。C，抽象类不可以被 new 创建对象。因为调用抽象方法没意义。D，抽象类中的抽象方法要被使用，必须由子类复写其所有的抽象方法后，建立子类对象调用。 22、如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。 23、抽象类和一般类没有太大的不同。该如何描述事物，就如何描述事物，只不过，该事物中出现了一些看不懂的东西。这些不确定的部分，也是该事物的功能，需要明确出现，但是无法定义主体。通过抽象方法来表示。 24、抽象类比一般类多了抽象方法（函数）。就是在类中可以定义抽象方法。抽象类不可以实例化（即不可以 new）。特殊：抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。 25、什么是模板方法呢？在定义功能时，功能的一部分是确定的，但是有一部分是不确定，而确定的部分在使用不确定的部分。那么这时就将不确定的部分暴露出去。由该类的子类去实现。

三、面向对象：接口
26、接口：格式：interface{}。接口中的成员修饰符是固定的。成员常量：public static final；成员函数： public abstract。接口的出现将 “多继承” 通过另一种形式体现出来，即 “多实现” 。 26、接口：初期理解：可以认为是一个特殊的抽象类。当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。class 用于定义类。interface 用于定义接口。 27、接口：是不可以创建对象的，因为有抽象方法。需要被子类实现，子类对接口中的抽象方法全部覆盖后，子类才可以实例化。否则子类是一个抽象类。接口可以被类多实现，也是对多继承不支持的转换形式。java 支持多实现。用关键字：implements。 28、接口与接口之间支持多继承，类与类之间只支持单继承。 29、接口的特点：接口是对外暴露的规则；接口是程序的功能扩展；接口可以用来多实现；类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口；接口与接口之间可以有继承关系。

2016 年 01 月 13 日
一、面向对象：多态

day08

1、多态的定义：某一类事物的多种存在形态，例：动物中猫，狗。猫这个对象对应的类型是猫类型：猫 x=new 猫（）；同时猫也是动物中的一种，也可以把猫称为动物。动物 y=new 猫（）；动物是猫和狗具体事物中抽取出来的父类型；父类型引用指向了子类对象。 2、多态的体现：父类的引用指向了自己的子类对象。父类的引用也可以接收自己的子类对象。 3、多态的前提：必须是类与类之间有关系。要么继承，要么实现。通常还有一个前提：存在覆盖。 4、多态的弊端：提高了扩展性，但是只能使用父类的引用访问父类中的成员。 5、多态的好处：多态的出现大大的提高了程序的扩展性。 6、引用数据类型转换：类型提升。向上转型。如果想要调用猫的特有方法时，如何操作？强制将父类的引用，转成子类类型。向下转型。注意：千万不要出现这样的操作，就是将父类对象转成子类类型。我们能转换的是父类引用指向了自己的子类对象时，该引用可以被提升，也可以被强制转换。多态自始至终都是子类对象在做着变量。 7、关键字：instanceof。判断引用数据类型是否一致。 8、在多态中成员函数的特点：在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有编译失败。在运行时期：参阅对象所属的类中是否有调用的方法。简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。 9、在多态中，成员变量的特点：无论编译和运行，都参考左边（引用型变量所属的类）。 10、object 类：是所有对象的直接或者间接父类，传说中的上帝。该类中定义的肯定是所有对象都具备的功能。 11、Object 类中已经提供了对对象是否相同的比较方法。如果自定义类中也有比较相同的功能，没有必要重新定义。只要沿袭父类中的功能，建立自己特有的比较内容即可。这就是覆盖。

2016 年 01 月 15 日
一、面向对象：内部类

day09

1、内部类的定义：将一个类定义在另一个类的里面，对里面那个类就称为内部类（内置类，嵌套类）。 2、内部类访问特点：内部类可以直接访问外部类中的成员，包括私有成员。之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式：外部类名 .this。而外部类要访问内部类中的成员必须要建立内部类的对象。 3、访问格式：当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。可以直接建立内部类对象。格式：外部类名 . 内部类名变量名 = 外部类对象 . 内部类对象； Outer.Inner in=new Outer().new Inner();。

4、当内部类在成员位置上，就可以被成员修饰符所修饰。比如，private：将内部类在外部类中进行封装。static：内部类就具备了 static 的特性。当内部类被 static 修饰后，只能直接访问外部类中的 static 成员。出现了访问局限。 5 、在外部其他类中，如何直接访问 static 内部类的非静态成员呢？ new Outer.Inner().function(); 。在外部其他类中，如何直接访问 static 内部类的静态成员呢？ Outer.Inner().function();。 6、注意：当内部类中定义了静态成员，该内部类必须是 static 的。当外部类中的静态方法访问内部类时，内部类也必须是 static 的。 7、当描述事物时，事物的内部还有事物，该事物用内部类来描述。因为内部事物在使用外部事物的内容。 8、内部类定义在局部时， 1，不可以被成员修饰符修饰； 2，可以直接访问外部类中的成员，因为还持有外部类中的引用；但是不可以访问它所在的局部中的变量。只能访问被 final 修饰的局部变量。 9、匿名内部类：1，匿名内部类其实就是内部类的简写格式。2，定义匿名内部类的前提：内部类必须继承一个类或者实现接口。3，匿名内部类的格式：new 父类或者接口（）{定义子类的内容}。4，其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。可以理解为带内容的对象。5，匿名内部类中定义的方法最好不要超过 3 个。

二、面向对象：异常
10、异常：异常的体系：Throwable：（Error：通常出现重大问题如：运行的类不存在或者内存溢出等；不编写针对代码对其处理。Exception：在运行时运行出现的一起情况，可以通过 try catch finally）。Exception 和 Error 的子类名称都是以父类名作为后缀。 11、异常：就是程序在运行时出现不正常情况。 12、异常由来：问题也是现实生活中一个具体的事物，也可以通过 java 的类的形式进行描述，并进行封装。其实就是 java 对不正常情况进行描述后的对象体现。 13、对于问题的划分：两种：一种是严重的问题。一种是非严重的问题。对于 Error 一般不编写针对性的代码对其进行处理。对于严重的， java 通过 Error 类进行描述。对于非严重的， java 通过 Exception 类进行描述。对于 Exception 可以使用针对性的处理方式进行处理。 14、无论 Error 或者 Exception 都具体有一些共性内容。比如：不正常情况的信息，引发原因等。 15、异常的处理：java 提供了特有的语句进行处理。Try{需要被检测的代码；}catch{异常类变量}{处理异常的代码：（处理方式）}finally{一定会执行的语句；}。 15、throws Exception//在功能上通过 throws 的关键字声明了该功能有可能会出现问题。在函数上声明异常。便于提高安全性，让调用者进行处理。不处理编译失败。 16、对多异常的处理。1，声明异常时，建议声明更为具体的异常。这样处理得可以更具体。 2，对声明几个异常，就对应有几个 catch 块。不要定义多余的 catch 块。如果多个 catch 块中的异常出现继承关系，父类异常 catch 块放在最下面。 17 、建议在进行 catch 处理时， catch 中一定要定义具体处理方式。不要简单定义一句 e.printStackTrace()，也不要简单的就书写一条输出语句。 18、自定义异常：因为项目中会出现特有的问题，而这些问题并未被 java 所描述并封装对象。所有对于这些特有的问题可以按照 java 的对问题封装的思想。将特有的问题，进行自定义的异常封装。 19、当在函数内部出现了 throw 抛出了异常对象，那么就必须要给对应的处理动作。要么在

内部 try catch 处理。要么在函数上声明让调用者处理。 20、如何定义异常信息呢？因为父类中已经把异常信息的操作都完成了。所有子类只要在构造时，将异常信息传递给父类通过 super 语句。那么就可以直接通过 getMessage 方法获取自定义的异常信息。 21、自定义异常：必须是自定义类继承 Exception。继承 Exception 原因：异常体系有一个特点：因为异常类和异常对象都被抛出。他们都具备可抛性。这个可抛性是 Throwable 这个体系中独有特点。 22、只有这个体系中的类和对象才可以被 throws 和 throw 操作。 23、throws 和 throw 的区别：throws 使用在函数上。throw 使用在函数内。throws 后面跟的异常类。可以跟多个。用逗号隔开。throw 后跟的是异常对象。 24、Exception 中有一个特殊的子类异常 RuntimeException 运行时异常。如果在函数内容抛出该异常，函数上可以不用声明，编译一样通过。如果在函数上声明了该异常。调用者可以不用进行处理，编译一样通过。 25、之所以不用在函数声明，是因为不需要让调用者处理。当该异常发生，希望程序停止。因为在运行时，出现了无法继续运算的情况，希望停止程序。对代码进行修正。 26 、自定义异常时：如果该异常的发生，无法在继续进行运算，就让自定义异常继承 RuntimeException。 27、对于异常分两种：1，编译时被检测的异常。2，编译时不被检测的异常（运行时异常， RuntimeException 以及其子类）。

2016 年 01 月 16 日
一、面向对象：异常

day10

1、finally 中存放的是一定会被执行的代码。 2、finally 代码块：定义一定执行的代码。通常用于关闭资料。 3、记住一点：catch 是用于处理异常。如果没有 catch 就代表没有被处理过，如果该异常时检测时的异常，就必须声明出去。 4、异常在子父类覆盖中的体现：A，子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类的异常或者该异常的子类。 B，如果父类方法抛出多个异常，那么子类在覆盖该方法时，只能抛出父类异常的子集。C，如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常。如果子类方法发生了异常。就必须要进行 try 处理。绝对不能抛。 5、异常：是什么？是对问题的描述，将问题进行对象的封装。 6、异常体系：Throwable：|--Error；|--Exception（|--RuntimeException）。 7、异常体系的特点：异常体系中的所有类以及建立的对象都具备可抛性。也就是说可以被 throw 和 throws 关键字所操作。只有异常体系具备这个特点。 8、throw 和 throws 的用法：throw 定义在函数内，用于抛出异常对象。throws 定义在函数上，用于抛出异常类，可以抛出多个用逗号隔开。 9、当函数内容有 throw 抛出异常对象，并未进行 try 处理。必须要在函数上声明，都在编译失败。注意：RuntimeException 除外。也就是说，函数内如果抛出的 RuntimeException 异常，函数上可以不用声明。

10、如果函数声明了异常，调用者需要进行处理。处理方法可以 throws 和 try。 11、异常有两种：编译时被检测异常：该异常在编译时，如果没有处理（没有抛也没有 try），编译失败。该异常被标识，代表着可以被处理。运行时异常（编译时不检测）：在编译时，不需要处理，编译器不检查。该异常的发生，建立不处理，让程序停止。需要对代码进行修正。 12、异常处理语句：try（需要被检测的代码；） catch（处理异常的代码；） finally（一定会执行的代码；）。有三种结合格式：try catch；try finally；try catch finally。注意：A，finally 中定义的通常是关闭资源代码。因为资源必须释放。B，finally 只有一种情况不会执行。当执行到 System.exit(0);finally 不会执行。 13、自定义异常：定义类继续 Exception 或者 RuntimeException。A，为了让该自定义类具备可抛性。B，让该类具备操作异常的共性方法。当要定义自定义异常的信息时，可以使用父类已经定义好的功能。异常异常信息传递给父类的构成函数。 class MyException extends Exception{MyException(String message){super(message);}}。 14、自定义异常：按照 java 的面向对象思想，将程序中出现的特有问题进行封装。 15、异常的好处：A，将问题进行封装。B，将正常流程代码和问题处理代码相分离，方便于阅读。 16、异常的处理原则：A，处理方式有两种：try 或者 throws。B，调用到抛出异常的功能时，抛出几个，就处理几个。一个 try 对应多个 catch。 C，多个 catch，父类的 catch 放到最下面。 D，catch 内需要定义针对性的处理方式。不要简单的定义 printStackTrace,输出语句。也不要不写。当捕获到的异常，本功能处理不了时，可以继续在 catch 中抛出。 17、异常的注意事项：在子父类覆盖时：A，子类抛出的异常必须是父类异常的子类或者子集。B，如果父类或者接口没有异常抛出时，子类覆盖出现异常，只能 try 不能抛。

二、面向对象：包
18、包（package）：对类文件进行分类管理。给类提供多层命名空间。写在程序文件的第一行。类名的全称的格式是：包名.类名。包也是一种封装形式。 19、关键字 protected：/*保护*/权限。权限修饰符。可用于修饰包里的父类。 20、总结：包与包之间进行访问，被访问的包中的类以及类中的成员，需要 public 修饰。不同包中的子类还可以访问直接父类中被 protected 权限修饰的成员。 21、包与包之间可以使用的权限只有两种，public protected。 22、public protected default private 同一个类中可以可以可以可以同一个包中可以可以可以不可以子类可以可以不可以不可以不同包中可以不可以不可以不可以。 23、为了简化类名的书写，使用一个关键字 import。import 导入的是包中的类。建议，不要写通配符*，需要用到包中的哪个类，就导入哪个类。 24、建议定义包名不要重复，可以使用 url 来完成定义，url 是唯一的。 25、jar 包：java 的压缩包：方便项目的携带。方便于使用，只要在 classpath 设置 jar 路径即可。数据库驱动，SSH 框架等都以 jar 包体现的。

2016 年 01 月 17 日
一、多线程：概述

day11

1、进程：是一个正在执行中的程序。每一个进程执行都有一个执行顺序。该顺序是一个执行路径，或者叫一个控制单元。 2、线程：就是进程中的一个独立的控制单元。线程在控制着进程的执行。一个进程中至少有一个线程。 3、Java VM 启动的时候会有一个进程 java.exe。该进程中至少有一个线程负责 java 程序的执行。而且这个线程运行的代码存在于 main 方法中。该线程称之为主线程。扩展：其实更细节说明 jvm，jvm 启动不止一个线程，还有负责垃圾回收机制的线程。 4、如何在自定义的代码中，自定义一个线程呢？通过对 API 的查找，java 已经提供了对线程这类事物的描述。就是 Thread 类。 5、创建线程的第一种方式：继承 Thread 类。步骤：1，定义类继承 Thread。2，复写 Thread 类中的 run 方法。目的：将自定义代码存储在 run 方法中，让线程运行。3，调用线程的 start 方法，该方法有两个作用：启动线程；调用 run 方法。 6、发现运行结果每一次都不同：因为多个线程都获取 cpu 的执行权。cpu 执行到谁，谁就运行。明确一点，在某一时刻，只能有一个程序在运行。（多核除外）cpu 在做着快速的切换，以达到看上去是同时运行的效果。我们可以形象把多线程的运行形容为在互相抢夺 cpu 的执行权。这就是多线程的一个特性：随机性。谁抢到谁执行，至于执行多长， cpu 说了算。 7、为什么要覆盖 run 方法呢？Thread 类用于描述线程。该类就定义了一个功能，用于存储线程要运行的代码，该存储功能就是 run 方法。也就是说 Thread 类中的 run 方法，用于存储线程要运行的代码。 8、原来线程都有自己默认的名称。 Thread-编号。该编号从 0 开始。 static Thread currentThread()：获取当前线程对象。getName()：获取线程名称。设置线程名称：setName 或者构造函数。 9、创建线程的第二种方式：实现 Runnable 接口。步骤：1，定义类实现 Runnable 接口。2，覆盖 Runnable 接口中的 run 方法。目的：将线程要运行的代码存放在 run 方法中。3，通过 Thread 类建立线程对象。4，将 Runnable 接口的子类对象作为实际参数传递给 Thread 类的构造函数。为什么要将 Runnable 接口的子类对象传递给 Thread 的构造函数？因为，自定义的 run 方法所属的对象时 Runnable 接口的子类对象。所有要让线程去指定指定对象的 run 方法。就必须明确该 run 方法所属对象。5，调用 Thread 类的 start 方法开启线程并调用 Runnable 接口子类的 run 方法。 10、实现方式和基础方法有什么区别呢？实现方式好处：避免了单继承的局限性。在定义线程时，建议使用实现方式。两种方式区别：继承 Thread：线程代码存放在 Thread 子类 run 方法中。实现 Runnable：线程代码存放在接口的子类的 run 方法中。

二、多线程：同步
11、多线程的运行出现了安全问题：问题的原因：当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，汗没有执行完，另一个线程参与进来执行。导致共享数据的错误。解决办法：对多条操作共享数据的语句，只能让一个线程都执行完。在执行过

程过，其他线程不可以参与执行。java 对于多线程的安全问题提供了专业的解决方式。就是同步代码块。synchronized(对象){需要被同步的代码；}。 12、对象如同锁。持有锁的线程可以在同步中执行。没有锁的线程即使获取了 cpu 的执行权，也进不去，因为没有获取锁。 13、同步的前提： 1，必须要有两个或者两个以上的线程。 2，必须是多个线程使用同一个锁。必须保证同步中只能有一个线程在运行。 14、好处：解决了多线程的安全问题。弊端：多个线程需要判断锁，较为消耗资源。 15、多线程安全问题：如何找到问题：1，明确哪些代码是多线程运行代码。2，明确共享数据。3，明确多线程运行代码中哪些语句是操作共享数据的。 16、同步函数：将关键字 synchronized 放到函数名称前。即把 synchronized 当作修饰符使用。 17、同步函数用的是哪一个锁呢？函数需要被对象调用。那么函数都有一个所属对象引用。就是 this。所有同步函数使用的锁是 this。 18、如果同步函数被静态修饰后，使用的锁是什么呢？通过验证，发现不再是 this。因为静态方法中也不可以定义 this。静态进内存时，内存中没有本类对象，但是一定有该类对应的字节码文件对象。类名.class 该对象的类型是 Class。静态的同步方法，使用的锁是该方法所在类的字节码文件对象。类名.class。 19、死锁：同步中嵌套同步。而锁却不同。

2016 年 01 月 18 日
一、多线程：线程间通信

day12

1、wait()，notify()，notifyALL()，用来操作线程为什么定义在了 Object 类中？这些方法存在于同步中。使用这些方法时必须要标识所属的同步的锁。锁可以是任意对象，所以任意对象调用的方法一定定义 Object 类中。 2、wait()和 sleep()有什么区别？wait()：释放资源，释放锁。sleep()：释放资源，不释放锁。 3、wait：notify：notifyALL：都被使用在同步中，因为要对持有监视器（锁）的线程操作。所有要使用在同步中，因为只有同步才具有锁。 4、为什么这些操作线程的方法要定义在 Object 类中呢？因为这些方法在操作同步中线程时，都必须要标识他们所操作线程只有的锁。只有同一个锁上的被等待线程，可以被同一个锁上 notify 唤醒。不可以对不同锁中的线程进行唤醒。也就是说，等待和唤醒必须是同一个锁。而锁可以是任意对象，所有可以被任意对象调用的方法定义在 Object 类中。 5、JDK1.5 中提供个多线程升级解决方案。将同步 synchronized 替换成现实 Lock 操作。将 Object 中的 wait，notify，notifyAll，替换了 condition 对象。该对象可以 Lock 锁，进行获取。

二、多线程：其他操作
6、停止线程：A：定义循环结束标记：因为线程运行代码一般都是循环，只要控制了循环即可。B：使用 interrupt（中断）方法：该方法时结束线程的冻结状态，使线程回到运行状态中来。注意：stop 方法已经过时不再使用。 7、如何停止线程？只有一种，run 方法结束。开启多线程运行，运行代码通常是循环结构。

只要控制住循环，就可以让 run 方法结束，也就是线程结束。特殊情况：当线程处于了冻结状态。就不会读取到标记。那么线程就不会结束。 8、当没有指定的方式让冻结的线程恢复到运行状态时，这时需要对冻结进行清除。强制让线程恢复到运行状态中来。这样就可以操作标记让线程结束。 Thread 类中提供该方法： interrupt 方法。 9、join 方法：当 A 线程执行到了 B 线程的.join()方法时，A 就会等待。等 B 线程都执行完， A 才会执行。join 可以用来临时加入线程执行。

2016 年 01 月 19 日
一、String 类：概述

day13

1、 String 类：字符串是一个特殊的对象。字符串一旦初始化就不可以被改变。 String str=”abc”； String str1=new String(“abc”)；。Str 和 str1 的区别：str 在内存中有一个对象。Str1 在内存中有两个对象。

二、***重点：String 类：常见操作
常见的操作有哪些？ "abcd" 1，获取。 1.1 字符串中包含的字符数，也就是字符串的长度。 int length()：获取长度。 1.2 根据位置获取位置上某个字符。 char charAt(int index)：获取位置上某个字符。 1.3 根据字符获取该字符在字符串中位置。 int indexOf(int ch)：获取该字符在字符串中位置。返回的是 ch 在字符串中第一次出现的位置。 int indexOf(int ch,int fromIndex)：从 fromIndex 指定位置开始，获取 ch 在字符串中出现的位置。 int indexOf(String str)：返回的是 str 在字符串中第一次出现的位置。 int indexOf(String str,int fromIndex)：从 fromIndex 指定位置开始，获取 str 在字符串中出现的位置。 int lastIndexOf(int ch)：反向索引。 2，判断。 2.1 字符串中是否包含某一个子串。 boolean contains(str); 特殊之处：indexOf(str)：可以索引 str 第一次出现位置，如果返回-1,表示该 str 不在字符串中存在。

所以，也可以用于对指定判断是否包含。 if(str.indexOf("aa")!=-1) 而且该方法既可以判断又可以获取出现的位置。 2.2 字符串是否有内容。 boolean isEmpty(str)：原理就是判断长度是否为 0。 2.3 字符串是否是以指定内容开头。 boolean startsWith(str); 2.4 字符串是否是以指定内容结尾。 boolean endsWith(str); 2.5 判断字符串的内容是否相同。复写了 Object 类中的 equals 方法。 boolean equals(str); 2.6 判断内容是否相同，并忽略大小写。 boolean equalsIgnoreCass(); 3，转换。 3.1 将字符数组转成字符串。构造函数：String(char[]) String(char[],offset,count)：将字符数组中的一部分转成字符串。静态方法：static String copyValueOf(char[]); static String copyValueOf(char[] data,int offset,int count); static String valueOf(char[]); 3.2 将字符串转成字符数组。//重点**。 char[] toCharArray(); 3.3 将字节数组转成字符串。 String(byte[]) String(byte[],offset,count)：将字节数组中的一部分转成字符串。 3.4 将字符串转成字节数组。 byte[] getBytes(); 3.5 将基本数据类型转成字符串。 static String valueOf(int) static String valueOf(double) //3+"";//String.valueOf(3); 特殊：字符串和字节数组在转换过程中，是可以指定编码表的。 4，替换。 String replace(oldchar,newchar); 5，切割。 String[] split(regex); 6，子串。获取字符串中的一部分。 String substring(begin); String substring(begin,end); 7，转换，去除空格，比较。 7.1 将字符串转成大写或者小写。 String toUpperCase(); String toLowerCase(); 7.2 将字符串两端的多个空格去除。

String trim(); 7.3 对两个字符串进行自然顺序的比较。 int compareTo(string);

三、String 类：StringBuffer
8、StringBuffer 类：字符串的注组成原理就是通过该类实现的。StringBuffer 可以对字符串内容进行增删。StringBuffer 是一个容器。很多方法与 String 相同。StringBuffer 是可变长度的。 9、StringBuffer 是字符串缓冲区。是一个容器。 10、缓冲区的特点：1，而且长度是可变化的。2，可以直接操作多个数据类型。3，最终会通过 toString 方法变成字符串。 11、StringBuffer 常见操作： C create U update R read D delete 1，存储。 StringBuffer append()：将指定数据作为参数添加到已有数据的结尾处。 StringBuffer insert(index,数据)：可以将数据插入到指定 index 位置。 2，删除。 StringBuffer delete(start,end)：删除缓冲区中的数据，包含 start，不包含 end。 StringBuffer deleteCharAt(index)：删除指定 index 位置的字符。 3，获取。 char charAt(int index); int indexOf(String str); int lastIndexOf(String str); int length(); String substring(int start,int end); 4，修改。 StringBuffer replace(start,end,string); void setCharAt(int index,char ch); 5，反转。 StringBuffer reverse(); 6，将缓冲区中指定数据存储到指定字符数组中。 void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)。 12、JDK1.5 版本之后出现了 StringBuilder。 StringBuffer 是线程同步。单线程使用 StringBuffer 效率较低。多线程使用 StringBuffer 保证了安全性。 StringBuilder 是线程不同步。单线程使用 StringBuilder 提高了效率。多线程使用 StringBuilder 可能存在安全问题，但可以通过自定义锁来解决安全问题。以后开发，建议使用 StringBuilder。 13、升级三个因素：1，提高效率。2，简化书写。3，提高安全性。

四、基本数据类型对象包装类
14、基本数据类型对象包装类的最常见作用：就是用于基本数据类型和字符串类型之间做转

换。 15、数据类型转换： A：基本数据类型转成字符串。基本数据类型+"" 基本数据类型.toString(基本数据类型值); 如：Integer.toString(34);//将 34 整数变成"34"。 B：字符串转成基本数据类型。静态：基本数据类型包装类.parseInt(字符串); 如：xxx a=Xxx.parseXxx(String); int a=Integer.parseInt("123"); double d=Double.parseDouble("12.23"); boolean b=Boolean.parseBoolean("true"); 非静态： Integer i=new Integer("123"); int num=i.intValue(); C：十进制转成其他进制。 toBinaryString(); toHexString(); toOctalString(); D：其他进制转成十进制。 parseInt(string,radix);。

2016 年 01 月 22 日
一、集合框架：概述

day14

1、集合类：为什么会出现集合类？面向对象语言对事物的体现都是以对象的形式，所有为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。 2、数组和集合类同是容器，有何不同？数组虽然也可以存储对象，但长度是固定的；集合长度是可变的，数组中可以存储基本数据类型，集合只能存储对象。 3、集合类的特点：集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。 4、为什么会出现这么多的容器呢？因为每一个容器对数据的存储方式有所不同。这个存储方式称之为：数据结构。 5、add 方法的参数类型是 Object。以便于接收任意类型对象。集合中存储的都是对象的引用（地址）。 6、什么是迭代器呢？其实就是集合的取出元素的方式。

二、集合框架：List 类
7、List:

特有方法。凡是可以操作角标的方法都是该体系特有的方法。增 add(index,element); addAll(index,Collection); 删 remove(index); 改 set(index,element); 查 get(index); subList(from,to); listIterator(); 8、List 集合特有的迭代器。ListIterator 是 Iterator 的子接口。在迭代时，不可以通过集合对象的方法操作集合中的元素。因为会发生 ConcurrentModificationException 异常。所有，在迭代器时，只能用迭代器的方法操作元素，可以 Iterator 方法时优先的，只能对元素进行判断，取出，删除的操作，如果想要其他的操作如添加，修改等，就需要使用其子接口， ListIterator。该接口只能通过 List 集合的 ListIterator 方法获取。 9、Collection |--List:元素是有序的，元素可以重复。因为该集合体系有索引。 |--ArrayList:底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。 |--LinkedList:底层使用的是链表数据结构。特点：增删速度很快，查询速度稍慢。 |--Vector:底层是数据数据结构。线程同步。被 ArrayList 替代了。 |--Set:元素是无序的，元素不可以重复。 10、枚举就是 Vector 特有的取出方式。发现枚举和迭代器很像。其实枚举和迭代是一样的。因为枚举的名称以及方法的名称都过长。所有被迭代器取代了。枚举郁郁而终了。 11、LinkedList：特有方法： addFirst(); addLast(); getFirst(); getLast(); 获取元素，但是不删除元素。如果集合中没有元素，会出现 NoSuchElementException。 removeFirst(); removeLast(); 获取元素，但是元素被删除。如果集合中没有元素，会出现 NoSuchElementException。在 JDK1.6 出现了替代方法。 offerFirst(); offerLast(); peekFirst(); peekLast();

获取元素，但是不删除元素。如果集合中没有元素，会返回 null。 pollFirst(); pollLast(); 获取元素，但是元素被删除。如果集合中没有元素，会返回 null。

三、集合框架：Set 类
12、HaseSet 是如何保证元素唯一性的呢？是通过元素的两个方法，hashCode 和 equals 来完成。如果元素的 hashCode 值相同，才会判断 equals 是否为 true。如果元素的 hashCode 值不同，不会调用 equals。 13、注意：对于判断元素是否存在，以及删除操作，依赖的方法时元素的 hashcode 和 equals 方法。

2016 年 1 月 23 日
一、集合框架：Set 类

day15

1、Set：无序，不可以重复元素。 |--HashSet：数据结构是哈希表。线程是非同步的。保证元素唯一性的原理：判断元素的 hashCode 值是否相同。如果相同，还会继续判断元素的 equals 方法，是否为 true。 |--TreeSet：可以对 Set 集合中的元素进行排序。底层数据结构是二叉树。保证元素唯一性的依据： compareTo 方法和 return 0。 2、TreeSet 排序的第一种方式：让元素自身具备比较性。元素需要实现 comparable 接口，覆盖 comparaeTo 方法。这种方式也称为元素的自然顺序，或者默认顺序。 3、TreeSet 排序的第二种方式：当元素自身不具备比较性时，或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。在集合初始化时，就有了比较方式。 4、当元素自身不具备比较性，或者具备的比较性不是所需要的。这时需要让容器自身具备比较性。定义了比较器，将比较器对象作为参数传递给 TreeSet 集合的构造函数。 5、当两种排序都存在时，以比较器为主。定义一个类，实现 Comparator 接口，覆盖 compare 方法。

二、集合框架：泛型
6、泛型：JDK1.5 版本以后出现的新特性。用于解决安全问题，是一个类型安全机制。 7、泛型的好处：好处：1，将运行时期出现问题 ClassCastException，转移到了编译时期。方便于程序员解决问题。让运行时期问题减少。更加安全。2，避免了强制转换麻烦。 8、泛型格式：通过<>来定义要操作的引用数据类型。在使用 java 提供的对象时，什么时候

写泛型呢？通常在集合框架中很常见。只要见到<>就要定义泛型。其实<>就是用来接收类型的。当使用集合时，将集合中要存储的数据类型作为参数传递到<>即可。 9、什么时候定义泛型类？当类中要操作的引用数据类型不确定的时候，早期定义 Object 来完成扩展。现在定义泛型来完成扩展。 10、泛型类定义的泛型，在整个类中有效。如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。为了让不同方法可以操作不同类型，而且类型还不确定，那么可以将泛型定义在方法上。 11、特殊之处：静态方法不可以访问类上定义的泛型。如果静态方法操作的引用数据类型不确定，可以将泛型定义在方法上。 12、? 通配符。也理解为占位符。泛型的限定：？ extends E：可以接收 E 类型或者 E 的子类型。上限。？ super E：可以接收 E 类型或者 E 的父类型。下限。

2016 年 01 月 24 日
一、集合：Map 概述

day16

1、Map 集合：该集合存储键值对。一对一对往里存，而且要保证键的唯一性。 2、Map 框架： 1，添加。 put(K key,V value) putAll(Map<? extends K,? extends V> m) 2，删除。 clear() remove(Object key) 3，判断。 containsValue(Object value) containsKey(Object key) isEmpty() 4，获取。 get(Object key) size() values() entrySet() keySet() 3、Map |--HashTable：底层是哈希表数据结构，不可以存入 null 键 null 值，该集合是线程同步的。JDK1.0。效率低。 |--HashMap：底层是哈希表数据结构，允许使用 null 键和 null 值，该集合是不同步的。 JDK1.2。效率高。

|--TreeMap：底层是二叉树数据结构，线程不同步，可以用于给 map 集合中的键进行排序。 4、和 Set 很像。其实大家，Set 底层就是使用了 Map 集合。 5、map 集合的两种取出方式：1，keySet：将 map 中所有的键存入到 Set 集合。因为 Set 具备迭代器。所以可以迭代方式取出所有的键，在根据 get 方法，获取每一个键对应的值。 Map 集合的取出原理：将 map 集合转成 set 集合。在通过迭代器取出。 2， Set<Map.Entry<k,v>> entrySet：将 map 集合中的映射关系存入到了 set 集合中，而这个关系的数据类型就是： Map.Entry。 6、Map.Entey 其实 Entry 也是一个接口，它是 Map 接口中的一个内部接口。 7、什么时候使用 map 集合呢？当数据之间存在映射关系时，就要先想到 map 集合。 8、map 扩展知识：map 集合被使用是因为具备映射关系。

2016 年 01 月 26 日
一、集合：Collections
1、fill 方法可以将 list 集合中所有元素替换成指定元素。

day17

二、集合：Arrays
2、Arrays：用于操作数组的工具类。里面都是静态方法。 3、asList：将数组变成 list 集合。 4、把数组变成 list 集合有什么好处？可以使用集合的思想和方法来操作数组中的元素。注意：将数组变成集合，不可以使用集合的增删方法。因为数据的长度是固定的。如果你增删，那么会发生 UnsupportedOperationException。 5、数组变集合：如果数组中的元素都是对象。那么变成集合时，数组中的元素就直接转成集合中的元素。如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。 6、集合变数组：指定类型的数组到底要定义多长呢？当指定类型的数组长度小于了集合的 size，那么该方法内部会创建一个新的数组，长度为集合的 size。当指定类型的数组长度大于了集合的 size，就不会新创建数组，而是使用传递进来的数组。所以创建一个刚刚好的数组最优。 7、为什么要讲集合变数组？为了限定对元素的操作。不需要进行增删了。 8、高级 for 循环：格式：for（数据类型变量名：被遍历的集合（Collection）或者数组）｛｝。 9、高级 for 循环、迭代器、ListIterator 的区别：高级 for 循环对集合进行遍历。只能获取集合元素，但是不能对集合进行操作。迭代器除了遍历，还可以进行 remove 集合中元素的动作。如果使用 ListIterator，还可以在遍历过程中对集合进行增删改查的操作。 10、传统 for 和高级 for 有什么区别呢？高级 for 有一个局限性：必须有被遍历的目标。建议在遍历数组的时候，还是希望使用传统 for。因为传统 for 可以定义角标。 11、JDK1.5 版本出现的新特性：可变参数：其实就是上一种数组参数的简写形式。不用每一

次都手动的建立数组对象。只要将要操作的元素作为参数传递即可。隐式将这些参数封装成了数组。 12、方法的可变参数。在使用时注意：可变参数一定要定义在参数列表最后面。 13、import static：静态导入：例如：import static java.lang.System.*;//导入了 System 类中所有静态成员。注意：当类名重名时，需要制定具体的包名。当方法重名时，指定具备所属的对象或者类。

2016 年 01 月 28 日
一、其他对象：System

day18

1、System:类中的方法和属性都是静态的。out:标准输出，默认是控制台。int:标准输入，默认是键盘。描述系统一些信息。 2、获取系统属性信息：Properties getProperties();。因为 Properties 是 Hashtable 的子类，也就是 Map 集合的一个子类对象。那么可以通过 map 的方法取出该集合中的元素。该集合中存储都是字符串。没有泛型定义。 3、Runtime 对象：该类并没有提供构造函数。说明不可以 new 对象。那么会直接想到该类中的方法都是静态的。发现该类中还有非静态方法。说明该类肯定会提供方法获取本类对象。而且该方法是静态的，并返回值类型是本类类型。由这个特点可以看出该类使用了单例设计模式完成。该方式的 static Runtime getRuntime();。 4、Math 类：ceil 方法：返回大于指定数据的最小整数。floor 方法：返回小于指定数据的最大整数。round 方法：四舍五入。pow 方法：幂运算。random：返回 0-1 之间的随机数。

二、IO 流：概述
5、IO(Input Outpu)流：IO 流用来处理设备之间的数据传输。Java 对数据的操作是通过流的方式。Java 用于操作流的对象都在 IO 包中。流按操作数据分为两种：字节流与字符流。流按流向分为：输入流，输出流。 6、IO 流常用基类：字节流的抽象基类：InputStream，OutputStream。字节流的抽象基类： Reader， Writer。注：由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀（如： InputStream 的子类 FilelnputStream，如：Reader 的子类 FileReader。）。 7、字符流和字节流：字节流两个基类： InputStream OutputStream。字符流两个基类： Reader Writer。先学习字符流的特点：既然 IO 流是用于操作数据的，那么数据的最常见体现形式是：文件。

2016 年 01 月 30 日
一、IO 流：Buffered 缓冲区

day19

1、字符流的缓冲区：缓冲区的出现提高了对数据的读写效率。对应类：BufferedWriter； BufferedReader。缓冲区要结合流才可以使用。在流的基础上对流的功能进行了增强。 2、缓冲区的出现是为了提高流的操作效率而出现的。所以在创建缓冲区之前，必须要先有流对象。该缓冲区中提供了一个跨平台的换行符。newLine();。 3、字符读取流缓冲区：该缓冲区提供了一次读一行的方法 readLine()，方便于对文本数据的获取。当返回 null 时，表示读到文件末尾。 4、readLine 方法返回的时候只返回回车符之前的数据内容。并不返回回车符。 5、装饰设计模式：当想要对已有的对象进行功能增强时，可以定义类，将已有对象传入，基于已有的功能，并提供加强功能。那么自定义的该类称为装饰类。 6、装饰类通常会通过构造方法接收被装饰的对象。并基于被装饰的对象的功能，提供更强的功能。 7、装饰模式比继承要灵活，避免了继承体系臃肿。而且降低了类与类之间的关系。装饰类因为是增强已有对象，具备的功能和已有的是相同的，只不过提供了更强功能。所以装饰类和被装饰类通常是都属于一个体系中的。

二、IO 流：字节流
8、字符流： FileReader FileWriter BufferedReader BufferedWriter 字节流： InputStream OutputStream BufferedInputStream BufferedOutputStream 9、流操作的基本规律：最痛苦的就是流对象有很多，不知道该用哪一个。通过两个明确来完成。 1，明确源和目的。源：输入流。InputStream Reader。目的：输出流。OutputStream Writer。 2，明确操作的数据是否是纯文本。是：字符流。不是：字节流。 3，当体系明确后，再明确要使用哪个具体的对象。

通过设备来进行区分：源设备：内存，硬盘，键盘。目的设备：内存，硬盘，控制台。

2016 年 01 月 31 日
一、IO 流：File 类

day20

1、File 类：用来将文件或者文件夹封装成对象。方便对文件与文件夹进行操作。File 对象可以作为参数传递给流的构造函数。了解 File 类中的常用方法。 2、File 类常见方法： 1，创建。 boolean createNewFile()；在指定位置创建文件，如果该文件已经存在，则不创建，返回 false。和输出流不一样，输出流对象一建立创建对象。而且文件已经存在，会覆盖。 boolean mkdir();创建一级文件夹。 boolean mkdirs();创建多级文件夹。 2，删除。 boolean delete();删除失败返回 false。 void deleteOnExit();在程序退出时删除指定文件。 3，判断。 boolean exists();文件是否存在。 boolean isFile();判断是否是文件。 boolean isDirectory();判断是否是文件夹。 boolean isHidden();判断是否是隐藏文件。 boolean isAbsolute();判断是否是绝对路径。 4，获取信息。 String getName();获取文件名称。 String getPath();获取文件相对路径。 String getParent();该方法返回的是绝对路径中的父目录。如果获取的是相对路径，返回 null。如果相对路径中有上一层目录那么该目录就是返回结果。 getAbsolute();获取文件绝对路径。 lastModified();返回文件最后一次被修改的时间。 length();。 3、因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可。在列出过程中出现的还是目录的话，还可以再次调用本功能。也就是函数自身调用自身。这种表现形式，或者编程手法，称为递归。递归要注意：1，限定条件。2，要注意递归的次数。尽量避免内存溢出。 4、练习：将一个指定目录下的 java 文件的绝对路径，存储到一个文本文件中。建立一个 java 文件列表文件。思路：1，对指定的目录进行递归。2，获取递归过程所有的 java 文件的路

径。3，将这些路径存储到集合中。4，将集合中的数据写入到一个文件中。

二、IO 流：Properties 类
5、Properties 是 hashtable 的子类。也就是说它具备 map 集合的特点。而且它里面存储的键值对都是字符串。是集合中和 IO 技术相结合的集合容器，该对象的特点：可以用于键值对形式的配置文件。 6、那么在加载数据时，需要数据有固定格式：键=值。

三、IO 流：其他类
7、打印流：PrintWriter 与 PrintStream：可以直接操作输入流和文件。打印流：该流提供了打印方法，可以将各种数据类型的数据都原样打印。字节打印流：PrintStream 构造函数可以接收的参数类型： 1，file 对象。File。 2，字符串路径。String。 3，字节输出流。OutputStream。字符打印流：PrintWriter 构造函数可以接收的参数类型： 1，file 对象。File。 2，字符串路径。String。 3，字节输出流。OutputStream。 4，字符数出来：Writer。 8、序列流：SequenceInputStream：对多个流进行合并。 9、操作对象：ObjectInputStream 与 ObjectOutputStream：被操作的对象需要实现 Serializable （标记接口）。

2016 年 02 月 01 日
一、IO 流：其他类

day21

1、RandomAccessFile：随机访问文件，自身具备读写的方法。通过 skipBytes(int x),seek(int x) 来达到随机访问。 2、管道流：PipedInputStream 和 PipedOutputStream：输入输出可以直接进行连接，通过结合线程使用。 3、RandomAccessFile：该类不算是 IO 体系中子类。而是直接继承自 Object。但是它是 IO 包中成员。因为它具备读和写功能。内部封装了一个数组，而且通过指针对数据的元素进行操作。可以通过 getFilePointer 获取指针位置。同时可以通过 seek 改变指针的位置。其实完成读写的原理就是内部封装了字节输入流和输出流。通过构造函数可以看出，该类只能操作文

件。而且操作文件还有模式：只读 r，读写 rw 等。 4、如果模式为只读 r。不会创建文件。会去读取一个已存在文件，如果该文件不存在，则会出现异常。如果模式为读写 rw。操作的文件不存在，会自动创建。如果存在则不会覆盖。 5、IO 包中的其他类：操作基本数据类型：DataInputStream 与 DataOutputStream。操作字节数组：ByteArrayInputStream 与 ByteArrayOutputStream。操作字符数组：CharArrayReader 与 CharArrayWrite。操作字符串：StringReader 与 StringWriter。 6、用于操作字节数组的流对象。 ByteArrayInputStream ：在构造的时候，需要接收数据源，而且数据源是一个字节数组。 ByteArrayOutputStream ：在构造的时候，不用定义数据目的，因为该对象中已经内部封装了可变长度的字节数组。这就是数据目的地。因为这两个流对象都操作的数组，并没有使用系统资源。所以，不用进行 close 关闭。在流操作规律讲解时：源设备：键盘 System.in，硬盘 FileStream，内存 ArrayStream。目的设备：控制台 System.out，硬盘 FileStream，内存 ArrayStream。用流的读写思想来操作数组。

二、IO 流：字符编码
7、字符编码：字符流的出现为了方便操作字符。更重要是的加入了编码转换。通过子类转换流来完成：InputStreamReader；OutputStreamWriter。在两个对象进行构造的时候可以加入字符集。 8、编码表的由来：计算机只能识别二进制数据，早期由来是电信号。为了方便应用计算机，让它可以识别各个国家的文字。就将各个国家的文字用数字来表示，并一一对应，形成一张表。这就是编码表。 9、常见的编码表： ASCII：美国标准信息交换码。用一个字节的 7 位可以表示。 ISO8859-1：拉丁码表。欧洲码表。用一个字节的 8 位表示。 GBK2312：中国的中文编码表。用两个字节的 16 位来表示。 GBK：中国的中文编码表升级，融合了更多的中文文字符号。 Unicode：国际标准码，融合了多种文字。所有文字都用两个字节来表示，Java 语言使用的就是 Unicode。 UTF-8：最多用三个字节来表示一个字符。 ?? 10、编码：字符串变成字节数组。解码：字节数组变成字符串。 String-->byte[]; str.getBytes(charsetName); byte[]-->String; new String(byte[],charsetName);。

2016 年 02 月 02 日
一、GUI：概述

day22

1、GUI：图形用户界面。 GUI：Graphical User Interface（图形用户接口）。用图形的方式，来显示计算机操作的界面，这样更方便跟直观。 CLI：Command line User Inteface（命令行用户接口）。就是常见的 Dos 命令行操作。需要记忆一些常用的命令，操作不直观。举例：比如：创建文件夹，或者删除文件夹等。 Java 为 GUI 提供的对象都存在 java.Awt 和 javax.Swing 两个包中。 2、Awt 与 Swing： java.Awt：Abstract Window ToolKit（抽象窗口工具包），需调用本地系统方法实现功能。属重量级控件。 javax.Swing：在 Awt 的基础上，建立的一套图形界面系统，其中提供了更多的组件，而且完全由 Java 实现。增强了移植性，属轻量级控件。 3、继承关系图：

4、布局管理器：容器中的组件的排放方式，就是布局。常见的布局管理器： FlowLayout（流式布局管理器）从左到右的顺序排列。 Panel 默认的布局管理器。 BorderLayout（边界布局管理器）东，南，西，北，中。 Frame 默认的布局管理器。

GridLayout（网格布局管理器）规则的矩阵。 CardLayout（卡片布局管理器）选项卡。 GridBagLayout（网格包布局管理器）非规则的矩阵。 5、创建图形化界面： 1，创建 frame 窗体。 2，对窗体进行基本设置。比如：大小、位置、布局。 3，定义组件。 4，将组件通过窗体的 add 方法添加到窗体中。 5，让窗体显示，通过 setVisible(true)来完成。 6、建立一个简单的窗体： Container 常用子类：Window Panel（面板，不能单独存在。） Window 常用子类：Frame Dialog。简单的窗体创建过程： Frame f = new Frame(“my window”); f.setLayout(new FlowLayout()); f.setSize(500,400);//设置窗体大小。 f.setLocation(300,200);//设置窗体出现在屏幕的位置。 f.setVisible(true);。

二、GUI：事件监听机制
7、事件监听机制组成：事件源（组件）；事件（Event）；监听器（Listener）；事件处理（引发事件后处理方式）。 8、事件监听机制流程图：

9、事件监听机制的特点： 1，事件源。 2，事件。 3，监听器。 4，事件处理。事件源：就是 awt 或者 swing 包中的那些图形界面组件。事件：每一个事件源都有自己特有的对应事件和共性事件。监听器：将可以触发某一个事件的动作（不止一个动作）都已经封装到了监听器中。以上三者，在 java 中都已经定义好了。直接获取其对象来用就可以了。我们要做的事情是，就是对产生的动作进行处理。

2016 年 02 月 03 日
一、网络编程：概述
1、网络编程：网络模型：OSI 参考模型。TCP/IP 参考模型。网络通讯要素：IP 地址。端口号。传输协议。 2、网络参考模型：

day23

3、网络通讯要素： IP 地址：网络中设备的标识。不易记忆，可用主机名。本地回环地址： 127.0.0.1 主机名： localhost。端口号：用于标识进程的逻辑地址，不同进程的标识。有效端口： 0~65535，其中 0~1024 系统使用或保留端口。传输协议：通讯的规则。常见协议：TCP，UDP。

4、UDP 和 TCP： UDP：将数据及源和目的封装成数据包中，不需要建立连接。每个数据报的大小在限制在 64k 内。因无连接，是不可靠协议。不需要建立连接，速度快。特点：面向无连接。数据会被封包。不可靠。速度快。比如：聊天，视频会议，桌面共享。 TCP：建立连接，形成传输数据的通道。在连接中进行大数据量传输。通过三次握手完成连接，是可靠协议。必须建立连接，效率会稍低。特点：面向连接。可大数据量传输。比较可靠。稍微有点慢。比如：下载。 5、Socket： Socket 就是为网络服务提供的一种机制。通信的两端都有 Socket。网络通信其实就是 Socket 间的通信。数据在两个 Socket 间通过 IO 传输。

二、网络编程：UDP
6、UDP 传输： DatagramSocket 与 DatagramPacket。建立发送端，接收端。建立数据包。调用 Socket 的发送接收方法。关闭 Socket。发送端与接收端是两个独立的运行程序。

三、网络编程：TCP
7、TCP 传输： Socket 和 ServerSocket。建立客户端和服务器端。建立连接后，通过 Socket 中的 IO 流进行数据的传输。关闭 socket。同样，客户端与服务器端是两个独立的应用程序。

2016 年 02 月 04 日
一、网络编程：浏览器客户端
1、视频演示讲解。

day24

2016 年 02 月 6 日
一、正则表达式

day25

1、正则表达式：符合一定规则的表达式。作用：用于专门操作字符串。 2、正则表达式：符合一定规则的表达式。作用：用于专门操作字符串。特点：用一些特定的符号来表示一些代码操作。这样就简化了书写。所以学习正则表达式，就是在学习一些特殊符号的使用。好处：可以简化对字符串的复杂操作。弊端：符号定义越多，正则越长，阅读性越差。 3、具体操作功能： 1，匹配：String matchess();方法。用规则匹配整个字符串，只要有一处不符合规则，就匹配结束，返回 false。 2，切割：String split(); 3，替换：String replaceAll(); 4，获取：将字符串中符合规则的子串取出。 4、获取：操作步骤： 1，将正则表达式封装成对象。 2，让正则对象和要操作的字符串相关联。 3，关联后，获取正则匹配引擎。 4，通过引擎对符合规则的子串进行操作，比如取出。