Java基础学习知识点总结

Java基础知识点总结

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

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。

基础知识：常量

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系统中换行是一个字符来表示\n，windows系统中，换行由\n\r实现。\n:换行。\b:退格。相当于backspace键。\r:按下回车键。\t:制表符。相当于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的使用范围更广。

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：方法区，本地方法区，寄存器。

数组

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]。

面向对象：概述

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语句只能用于构造函数间，不能用于一般函数。

面向对象：static关键字

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、记住原则：定义单例，建议使用饿汉式。但面试时：考懒汉式的多。特别是如何解决懒汉式的缺点。

面向对象：继承

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、接口的特点：接口是对外暴露的规则；接口是程序的功能扩展；接口可以用来多实现；类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口；接口与接口之间可以有继承关系。

面向对象：多态

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

面向对象：内部类

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以及其子类）。

面向对象：异常

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包体现的。

String类：概述

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

集合框架：概述

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方法。

集合框架：Set类

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的父类型。下限。

集合：Map概述

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

集合：Collections

1、fill方法可以将list集合中所有元素替换成指定元素。

集合：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类中所有静态成员。注意：当类名重名时，需要制定具体的包名。当方法重名时，指定具备所属的对象或者类。

一、其他对象：System

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流是用于操作数据的，那么数据的最常见体现形式是：文件。

IO流：File类

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流：其他类

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（标记接口）。

IO流：其他类

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);。

正则表达式

1、正则表达式：符合一定规则的表达式。作用：用于专门操作字符串。
2、正则表达式：符合一定规则的表达式。
作用：用于专门操作字符串。
特点：用一些特定的符号来表示一些代码操作。这样就简化了书写。
所以学习正则表达式，就是在学习一些特殊符号的使用。

好处：可以简化对字符串的复杂操作。<br />    弊端：符号定义越多，正则越长，阅读性越差。<br />3、具体操作功能：<br />1，匹配：String matchess();方法。用规则匹配整个字符串，只要有一处不符合规则，就匹配结束，返回false。<br />2，切割：String split();<br />3，替换：String replaceAll();<br />4，获取：将字符串中符合规则的子串取出。<br />4、获取：操作步骤：<br />1，将正则表达式封装成对象。<br />2，让正则对象和要操作的字符串相关联。<br />3，关联后，获取正则匹配引擎。<br />4，通过引擎对符合规则的子串进行操作，比如取出。