Java基础语法总览

语法总览"/>

Java基础语法总览

JAVA基础

java进阶（学完基础后再看）

基础语法通识

关键字

(1)被Java语言赋予特定含义的单词
(2)特点：全部小写。
(3)注意事项：A:goto和const作为保留字存在。B:类似于Notepad++这样的高级记事本会对关键字有特殊颜色标记

标识符

(1)就是给类，接口，方法，变量等起名字的字符序列
(2)组成规则：A:英文大小写字母B:数字C:$和_
(3)注意事项：A:不能以数字开头B:不能是java中的关键字C:区分大小写
(4)常见的命名规则(见名知意)A:包	全部小写单级包：小写举例：liuyi,com多级包：小写，并用.隔开举例：cn.itcast,com.baidu				B:类或者接口一个单词：首字母大写举例：Student,Demo多个单词：每个单词首字母大写举例：HelloWorld,StudentNameC:方法或者变量一个单词：首字母小写举例：name,main多个单词：从第二个单词开始，每个单词首字母大写举例：studentAge,showAllNames()D:常量全部大写一个单词：大写举例：PI多个单词：大写，并用_隔开举例：STUDENT_MAX_AGE

注释(掌握)

(1)就是对程序进行解释说明的文字
(2)分类：A:单行注释	//B:多行注释	/**/C:文档注释 /** */
(3)把HelloWorld案例写了一个带注释的版本。后面我们要写一个程序的过程。需求：分析：实现：代码体现：
(4)注释的作用A:解释说明程序，提高了代码的阅读性。B:可以帮助我们调试程序。后面我们会讲解一个更高端的一个调试工具

常量

(1)在程序执行的过程中，其值不发生改变的量
(2)分类：A:字面值常量B:自定义常量
(3)字面值常量A:字符串常量 "hello"B:整数常量	12,23C:小数常量	12.345D:字符常量	'a','A','0'E:布尔常量	true,falseF:空常量	null
(4)在Java中针对整数常量提供了四种表现形式A:二进制	由0，1组成。以0b开头。B:八进制	由0，1，...7组成。以0开头。C:十进制	由0，1，...9组成。整数默认是十进制。D:十六进制	由0，1，...9,a,b,c,d,e,f(大小写均可)组成。以0x开头。

变量

(1)在程序的执行过程中，其值在某个范围内可以发生改变的量
(2)变量的定义格式：A:数据类型 变量名 = 初始化值;B:数据类型 变量名;变量名 = 初始化值;

数据类型

(1)Java是一种强类型语言，针对每种数据都提供了对应的数据类型。
(2)分类：A:基本数据类型：4类8种B:引用数据类型：类，接口，数组。
(3)基本数据类型A:整数			占用字节数byte			1short			2int 			4long			8B:浮点数float			4double			8C:字符char			2D:布尔boolean			1==注意==：整数默认是int类型，浮点数默认是double。长整数要加L或者l。单精度的浮点数要加F或者f。

数据类型转换

(1)boolean类型不参与转换
(2)默认转换A:从小到大B:byte,short,char -- int -- long -- float -- doubleC:byte,short,char之间不相互转换，直接转成int类型参与运算。
(3)强制转换A:从大到小B:可能会有精度的损失，一般不建议这样使用。C:格式：目标数据类型 变量名 = (目标数据类型) (被转换的数据

运算符

(1)算术运算符A:+,-,*,/,%,++,--B:+的用法a:加法b:正号c:字符串连接符C:/和%的区别数据做除法操作的时候，/取得是商，%取得是余数D:++和--的用法a:他们的作用是自增或者自减b:使用**单独使用放在操作数据的前面和后面效果一样。a++或者++a效果一样。**参与操作使用放在操作数的前面：先自增或者自减，再参与操作int a = 10;int b = ++a;放在操作数的后面：先参与操作，再自增或者自减int a = 10;int b = a++;
(2)赋值运算符A:=,+=,-=,*=,/=,%=等B:=叫做赋值运算符，也是最基本的赋值运算符int x = 10; 把10赋值给int类型的变量x。C:扩展的赋值运算符的特点隐含了自动强制转换。
(3)比较运算符A:==,!=,>,>=,<,<=B:无论运算符两端简单还是复杂最终结果是boolean类型。C:千万不要把==写成了=
(4)逻辑运算符A:&,|,^,!,&&,||B:逻辑运算符用于连接boolean类型的式子C:结论&:有false则false|:有true则true^:相同则false，不同则true。!:非true则false，非false则true&&:结果和&是一样的，只不过有短路效果。左边是false，右边不执行。||:结果和|是一样的，只不过有短路效果。左边是true，右边不执行。
(5)位运算符(了解)A:^的特殊用法一个数据针对另一个数据位异或两次，该数不变B:面试题a:请实现两个变量的交换**采用第三方变量**用位异或运算符左边a,b,a右边a^bb:请用最有效率的方式计算出2乘以8的结果2<<3
(6)三元运算符A:格式比较表达式?表达式1:表达式2;B:执行流程：首先计算比较表达式的值，看是true还是false。如果是true，表达式1就是结果。如果是false，表达式2就是结果。C:案例：a:比较两个数据是否相等b:获取两个数据中的最大值c:获取三个数据中的最大值

流程控制语句

(1)顺序结构 从上往下，依次执行
(2)选择结构	按照不同的选择，执行不同的代码
(3)循环结构 做一些重复的代码

if语句

(1)三种格式A:格式1if(比较表达式) {语句体;}执行流程：判断比较表达式的值，看是true还是false如果是true，就执行语句体如果是false，就不执行语句体B:格式2if(比较表达式) {语句体1;}else {语句体2;}执行流程：判断比较表达式的值，看是true还是false如果是true，就执行语句体1如果是false，就执行语句体2C:格式3if(比较表达式1) {语句体1;}else if(比较表达式2){语句体2;}...else {语句体n+1;}执行流程：判断比较表达式1的值，看是true还是false如果是true，就执行语句体1如果是false，就继续判断比较表达式2的值，看是true还是false如果是true，就执行语句体2如果是false，就继续判断比较表达式3的值，看是true还是false...如果都不满足，就执行语句体n+1
(2)注意事项A:比较表达式无论简单还是复杂，结果是boolean类型B:if语句控制的语句体如果是一条语句，是可以省略大括号的；如果是多条，不能省略。建议：永远不要省略。C:一般来说，有左大括号，就没有分号，有分号，就没有左大括号。D:else后面如果没有if，是不会出现比较表达式的。E:三种if语句其实都是一个语句，只要有一个执行，其他的就不再执行。
(3)三元运算符和if语句第二种格式的关系所有的三元运算符能够实现的，if语句的第二种格式都能实现。反之不成立。如果if语句第二种格式控制的语句体是输出语句，就不可以。因为三元运算符是一个运算符，必须要有一个结果返回，不能是一个输出语句。

switch语句(掌握)

(1)格式：switch(表达式) {case 值1:语句体1;break;case 值2:语句体2;break;...default:语句体n+1;break;}格式解释说明：switch:说明这是switch语句。表达式:可以是byte,short,int,charJDK5以后可以是枚举JDK7以后可以是字符串case:后面的值就是要和表达式进行比较的值break:表示程序到这里中断，跳出switch语句default:如果所有的情况都不匹配,就执行这里,相当于if语句中的else
(2)执行流程:A:首先计算表达式的值B:和每一个case进行匹配，如果有就执行对应的语句体，看到break就结束。C:如果没有匹配，就执行default的语句体n+1。
(3)注意事项:A:case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的B:default可以省略吗?可以省略，但是不建议，因为它的作用是对不正确的情况给出提示。特殊情况：case就可以把值固定。A,B,C,DC:break可以省略吗?可以省略，但是结果可能不是我们想要的。会出现一个现象：case穿透。最终我们建议不要省略D:default一定要在最后吗?不是，可以在任意位置。但是建议在最后。E:switch语句的结束条件a:遇到break就结束了b:执行到末尾就结束了
(4)if语句和switch语句各自的场景A:if针对boolean类型的判断针对一个范围的判断针对几个常量的判断B:switch针对几个常量的判断

循环语句

(1)有三种:for,while,do...while
(2)for循环语句A:格式for(初始化语句;判断条件语句;控制条件语句){循环体语句;}执行流程：a:执行初始化语句b:执行判断条件语句如果这里是true，就继续如果这里是false，循环就结束c:执行循环体语句d:执行控制条件语句e:回到bB:注意事项a:判断条件语句无论简单还是复杂，结果是boolean类型b:循环体语句如果是一条，可以省略大括号，但是不建议c:有分号就没有左大括号，有左大括号就没有分号
(3)while循环A:基本格式while(判断条件语句) {循环体语句;}扩展格式：初始化语句;while(判断条件语句){循环体语句;控制条件语句;}通过查看这个格式，我们就知道while循环可以和for循环等价转换。B:while的练习把for语句的练习用while改进C:for和while的区别a:使用上的区别for语句的那个控制条件变量,在循环结束后不能在使用了。而while的可以继续使用。b:理解上的区别for适合于一个范围的判断while适合次数不明确的举例:吃葡萄
(4)do...while循环A:基本格式do {循环体语句;}while(判断条件语句);扩展格式：初始化语句;do {循环体语句;控制条件语句;}while(判断条件语句);通过查看格式，我们就可以看出其实三种循环的格式可以是统一的。B:三种循环的区别a:do...while循环至少执行一次循环体b:for和while必须先判断条件是否是true，然后后才能决定是否执行循环体
(5)循环使用的注意事项(死循环)A:一定要注意修改控制条件,否则容易出现死循环。B:最简单的死循环格式a:while(true){...}b:for(;;){}

控制跳转语句

(1)break:中断的意思A:用在循环和switch语句中，离开此应用场景无意义。B:作用a:跳出单层循环b:跳出多层循环，需要标签语句的配合
(2)continue:继续A:用在循环中，离开此应用场景无意义。B:作用a:跳出单层循环的一次，可以继续下一次C:填空题for(int x=1; x<=10; x++) {if(x%3 == 0) {//补齐代码}System.out.println("Java基础班");}如何让控制台输出2次：Java基础班如何让控制台输出7次：Java基础班如何让控制台输出13次：Java基础班
(3)return:返回A:用于结束方法的，后面还会在继续讲解和使用。B:一旦遇到return,程序就不会在继续往后执行。

不同的基础点

键盘录入

(1)实际开发中，数据是变化的，为了提高程序的灵活性，我们加入键盘录入数据。
(2)如何实现呢?目前就记住A:导包import java.util.Scanner;位置：在class的上边B:创建对象Scanner sc = new Scanner(System.in);C:获取数据如：int x = sc.nextInt();常用的next():读取输入知道空格。不能读取有空格或符号隔开的单词，读取后光标在本行nextLine():能读取所有直到行尾nextByte()nextDouble()nextFloat()nextLong()nextShort()D:用完后要记得close()

方法(掌握)

(1)方法：就是完成特定功能的代码块。注意：在很多语言里面有函数的定义，而在Java中，函数被称为方法。
(2)格式：修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...) {方法体语句;return 返回值;}修饰符：default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用		对象：类、接口、变量、方法private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外		部类）public : 对所有类可见。使用对象：类、接口、变量、方法protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注		意：不能修饰类（外部类）返回值类型：就是功能结果的数据类型方法名：就是起了一个名字，方便我们调用该方法。参数类型：就是参数的数据类型参数名：就是变量参数分类：实参：实际参与运算的数据形参：方法上定义的，用于接收实际参数的变量方法体语句：就是完成功能的代码块return：结束方法返回值：就是功能的结果，由return带给调用者。
(3)两个明确：返回值类型：结果的数据类型参数列表：参数的个数及对应的数据类型
(4)方法调用A:有明确返回值的方法a:单独调用，没有意义b:输出调用，不是很好，因为我可能需要不结果进行进一步的操作。但是讲课一般我就用了。c:赋值调用，推荐方案B:void类型修饰的方法a:单独调用
(5)案例：A:求和方案B:获取两个数中的较大值C:比较两个数据是否相同D:获取三个数中的最大值E:输出m行n列的星形F:输出nn乘法表
(6)方法的注意事项A:方法不调用不执行B:方法之间是平级关系，不能嵌套定义C:方法定义的时候，参数是用，隔开的D:方法在调用的时候，不用在传递数据类型E:如果方法有明确的返回值类型，就必须有return语句返回。
(7)**方法重载**在同一个类中，方法名相同，参数列表不同。与返回值无关。参数列表不同：参数的个数不同。参数的对应的数据类型不同。
(8)方法重载案例不同的类型的多个同名方法的比较。

数组

(1)数组：存储同一种数据类型的多个元素的容器。
(2)特点：每一个元素都有编号，从0开始，最大编号是长度-1。编号的专业叫法：索引
(3)定义格式A:数据类型[] 数组名;B:数据类型 数组名[];推荐是用A方式，B方法就忘了吧。但是要能看懂
(4)数组的初始化A:动态初始化只给长度，系统给出默认值举例：int[] arr = new int[3];B:静态初始化给出值，系统决定长度举例：int[] arr = new int[]{1,2,3};简化版：int[] arr = {1,2,3};
(5)数组内存图A:一个数组B:二个数组C:三个数组(两个栈变量指向同一个堆内存)![](file://D:/blog/post-images/1569138701134.bmp)

二维数组

(1)元素是一维数组的数组。
(2)格式：A:数据类型[][] 数组名 = new 数据类型[m][n];B:数据类型[][] 数组名 = new 数据类型[m][];C:数据类型[][] 数组名 = new 数据类型[][]{{...},{...},{...}};D:数据类型[][] 数组名 = {{...},{...},{...}};

Java的内存分配

	A:栈 存储局部变量B:堆 存储所有new出来的C:方法区(面向对象部分详细讲解)D:本地方法区(系统相关)E:寄存器(CPU使用)注意：a:局部变量 在方法定义中或者方法声明上定义的变量。b:栈内存和堆内存的区别栈：数据使用完毕，就消失。堆：每一个new出来的东西都有地址每一个变量都有默认值byte,short,int,long 0float,double 0.0char '\u0000'boolean false引用类型 null数据使用完毕后，在垃圾回收器空闲的时候回收。

面向对象

基本概念

(1)面向对象面向对象是基于面向过程的编程思想
(2)面向对象的思想特点A:是一种更符合我们思考习惯的思想B:把复杂的事情简单化C:让我们从执行者变成了指挥者举例：买电脑洗衣服做饭...万事万物皆对象
(3)类与对象A:现实世界的事物属性	事物的基本描述行为	事物的功能B:Java语言中最基本的单位是类。所以，我们要用类来体现事物C:类成员变量	事物属性成员方法	事物行为D:类：是一组相关的属性和行为的集合。是一个抽象的概念。对象：是该类事物的具体存在，是一个具体的实例。(对象)举例：学生：类班长：对象
(4)类的定义及使用A:类的定义成员变量	定义格式和以前一样，就是位置不同，在类中，方法外。成员方法	定义格式和以前一样，就是去掉了static。B:使用类的内容a:创建对象? 格式类名 对象名 =  new 类名();b:如何使用成员变量和成员方法呢对象名.成员变量对象名.成员方法()
(5)案例：A:学生类的定义和使用B:手机类的定义和使用
(6)内存图A:一个对象的内存图B:二个对象的内存图C:三个对象的内存图(7)Java程序的开发，设计和特征A:开发：就是不断的创建对象，通过对象调用功能B:设计：就是管理和维护对象间的关系C:特征a:封装b:继承c:多态

一些关键理解

成员变量和局部变量的区别

(1)在类中的位置不同成员变量：类中方法外局部变量：方法定义中或者方法声明上
(2)在内存中的位置不同成员变量：在堆中局部变量：在栈中
(3)生命周期不同成员变量：随着对象的创建而存在，随着对象的消失而消失局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
(4)初始化值不同成员变量：有默认值局部变量：没有默认值，必须定义，赋值，然后才能使用

类作为形式参数的问题?

(1)如果你看到一个方法需要的参数是一个类名，就应该知道这里实际需要的是一个具体的对象。

匿名对象

(1)没有名字的对象
(2)应用场景A:调用方法，仅仅只调用一次的时候。b:可以作为实际参数传递。

封装(理解)

(1)隐藏实现细节，提供公共的访问方式
(2)好处：A:隐藏实现细节，提供公共的访问方式B:提高代码的复用性C:提高代码的安全性
(3)设计原则把不想让外界知道的实现细节给隐藏起来，提供公共的访问方式
(4)private是封装的一种体现。封装：类，方法，private修饰成员变量

private关键字再提

(1)私有的意义，可以修饰成员变量和成员方法
(2)特点：被private修饰的后的成员只能在本类中被访问
(3)private的应用：以后再写一个类的时候：把所有的成员变量给private了提供对应的getXxx()/setXxx()方法

this关键字

(1)代表当前类的引用对象记住：哪个对象调用方法，该方法内部的this就代表那个对象
(2)this的应用场景：A:解决了局部变量隐藏成员变量的问题B:其实this还有其他的应用，明天讲解。

构造方法

(1)作用：用于对对象的数据进行初始化
(2)格式：A:方法名和类名相同B:没有返回值类型，连void都不能有C:没有返回值(3)构造方法的注意事项A:如果我们没写构造方法，系统将提供一个默认的无参构造方法B:如果我们给出了构造方法，系统将不再提供默认构造方法如果这个时候，我们要使用无参构造方法，就必须自己给出。推荐：永远手动自己给出无参构造方法。
(4)给成员变量赋值的方式A:setXxx()B:带参构造方法

建立一个对象发生了什么?

以Student s = new Student()为例(1)把Student.class文件加载到内存
(2)在栈内存为s开辟空间
(3)在堆内存为学生对象申请空间
(4)给学生的成员变量进行默认初始化。null,0
(5)给学生的成员变量进行显示初始化。林青霞,27             
(6)通过构造方法给成员变量进行初始化。刘意,30
(7)对象构造完毕，把地址赋值给s变量

static关键字

(1)静态的意思。可以修饰成员变量和成员方法。
(2)静态的特点：A:随着类的加载而加载B:优先与对象存在C:被类的所有对象共享这其实也是我们判断该不该使用静态的依据。举例：饮水机和水杯的问题思考D:可以通过类名调用既可以通过对象名调用，也可以通过类名调用，建议通过类名调用。
(3)静态的内存图静态的内容在方法区的静态区

(4)静态的注意事项；A:在静态方法中没有this对象B:静态只能访问静态(代码测试过)
(5)静态变量和成员变量的区别A:所属不同静态变量：属于类，类变量成员变量：属于对象，对象变量，实例变量B:内存位置不同静态变量：方法区的静态区成员变量：堆内存C:生命周期不同静态变量：静态变量是随着类的加载而加载，随着类的消失而消失成员变量：成员变量是随着对象的创建而存在，随着对象的消失而消失D:调用不同静态变量：可以通过对象名调用，也可以通过类名调用成员变量：只能通过对象名调用
(6)main方法是静态的public:权限最大static:不用创建对象调用void:返回值给jvm没有意义main:就是一个常见的名称。String[] args:可以接收数据，提供程序的灵活性格式：java MainDemo hello world javajava MainDemo 10 20 30
(7)一些小用法
可以把构造方法私有化，外界就无法创建对象了，自己可以通过静态化方法调用类中的方法
(8)内存图解

代码块

(1)用{}括起来的代码。
(2)分类：A:局部代码块用于限定变量的生命周期，及早释放，提高内存利用率。B:构造代码块把多个构造方法中相同的代码可以放到这里，每个构造方法执行前，首先执行构造代码块。C:静态代码块对类的数据进行初始化，仅仅只执行一次。
(3)静态代码块,构造代码块,构造方法的顺序问题?静态代码块 > 构造代码块 > 构造方法

继承

(1)把多个类中相同的成员给提取出来定义到一个独立的类中。然后让这多个类和该独立的类产生一个关系，这多个类就具备了这些内容。这个关系叫继承。
(2)Java中如何表示继承呢?格式是什么呢?A:用关键字extends表示B:格式：class 子类名 extends 父类名 {}
(3)继承的好处：A:提高了代码的复用性B:提高了代码的维护性C:让类与类产生了一个关系，是多态的前提
(4)继承的弊端：A:让类的耦合性增强。这样某个类的改变，就会影响其他和该类相关的类。原则：低耦合，高内聚。耦合：类与类的关系内聚：自己完成某件事情的能力B:打破了封装性
(5)Java中继承的特点A:Java中类只支持单继承B:Java中可以多层(重)继承(继承体系) 即a继承b，b继承c，则a也同时继承c
(6)继承的注意事项：A:子类不能继承父类的私有成员（方法或者变量）B:子类不能继承父类的构造方法，但是可以通过super去访问C:不要为了部分功能而去继承
(7)什么时候使用继承呢?A:继承体现的是：is a的关系。B:采用假设法
(8)Java继承中的成员关系A:成员变量a:子类的成员变量名称和父类中的成员变量名称不一样，这个太简单b:子类的成员变量名称和父类中的成员变量名称一样，这个怎么访问呢?子类的方法访问变量的查找顺序：在子类方法的局部范围找，有就使用。在子类的成员范围找，有就使用。在父类的成员范围找，有就使用。找不到，就报错。B:构造方法a:子类的构造方法默认会去访问父类的无参构造方法是为了子类访问父类数据的初始化子类构造方法第一条语句默认为super()b:父类中如果没有无参构造方法，怎么办?子类通过super去明确调用带参构造 super(...)子类通过this调用本身的其他构造，但是一定会有一个去访问了父类的构造让父类提供无参构造 this(...)子类中一定得有一个去访问了父类的构造方法，否则父类数据就没有初始化注意事项：super(…)或者this(….)必须出现在第一条语句C:成员方法a:子类的成员方法和父类中的成员方法名称不一样，这个太简单b:子类的成员方法和父类中的成员方法名称一样，这个怎么访问呢?通过子类对象访问一个方法的查找顺序：在子类中找，有就使用在父类中找，有就使用找不到，就报错
(9)两个面试题：A:Override（重写）和Overload（重载）的区别?Overload是否可以改变返回值类型?重写不能重写父类私有方法子类重写父类方法时，权限不能更低B:this和super的区别和各自的作用?
(10)数据初始化的面试题A:一个类的初始化过程成员变量进行初始化默认初始化显示初始化构造方法初始化B:子父类的构造执行过程C:分层初始化

final关键字

(1)是最终的意思，可以修饰类，方法，变量。
(2)特点：A:它修饰的类，不能被继承。B:它修饰的方法，不能被重写。C:它修饰的变量，是一个常量。
(3)面试相关：A:局部变量a:基本类型 值不能发生改变b:引用类型 地址值不能发生改变，但是对象的内容是可以改变的B:初始化时机a:只能初始化一次。b:常见的给值定义的时候。(推荐)构造方法中。

多态

(1)同一个对象在不同时刻体现出来的不同状态。
如：水的三种不同状态
(2)多态的前提：A:有继承或者实现关系。B:有方法重写。C:有父类或者父接口引用指向子类对象。多态的分类：a:具体类多态class Fu {}class Zi extends Fu {}Fu f = new Zi();b:抽象类多态abstract class Fu {}class Zi extends Fu {}Fu f = new Zi();c:接口多态interface Fu {}class Zi implements Fu {}Fu f = new Zi();
(3)多态中的成员访问特点A:成员变量编译看左边，运行看左边B:构造方法子类的构造都会默认访问父类构造C:成员方法编译看左边，运行看右边（方法重写）D:静态方法编译看左边，运行看左边（静态和类相关，算不上重写）为什么?因为成员方法有重写。
(4)多态的好处：A:提高代码的维护性(继承体现)B:提高代码的扩展性(多态体现)
(5)多态的弊端：不能使用子的特有功能。现象：子可以当作父使用，父不能当作子使用。
(6)多态中的转型（孔子装爹案例）A:向上转型Fu f = new Zi();从子到父B:向下转型Zi z = (zi)f;从父到子把父类的引用强行转换为子类的引用
(7)多态内存图解

抽象类

(1)把多个共性的东西提取到一个类中，这是继承的做法。
但是呢，这多个共性的东西，在有些时候，方法声明一样，但是方法体。
也就是说，方法声明一样，但是每个具体的对象在具体实现的时候内容不一样。
所以，我们在定义这些共性的方法的时候，就不能给出具体的方法体。
而一个没有具体的方法体的方法是抽象的方法。
在一个类中如果有抽象方法，该类必须定义为抽象类。
(2)抽象类的特点A:抽象类和抽象方法必须用关键字abstract修饰B:抽象类中不一定有抽象方法,但是有抽象方法的类一定是抽象类C:抽象类不能实例化有构造方法，但是不能实例化，用于子类访问父类数据的初始化D:抽象类的子类a:是一个抽象类。b:是一个具体类。这个类必须重写抽象类中的所有抽象方法。E:抽象的实例化其实是靠具体的子类实现的，属于多态Animal a = new Dog();
(3)抽象类的成员特点： A:成员变量有变量，有常量B:构造方法有构造方法C:成员方法有抽象 强制要求子类做的事，没有方法体有非抽象 子类继承的事(4)抽象类的几个小问题A:抽象类有构造方法，不能实例化，那么构造方法有什么用?用于子类访问父类数据的初始化B:一个类如果没有抽象方法,却定义为了抽象类，有什么用?为了不让创建对象C:abstract不能和哪些关键字共存a:final	冲突b:private 冲突c:static 无意义

接口

(1)为表示类中额外的功能，java提供了接口表示。
接口呢，是一个规范，满足该规范的类就可以实现这个接口，可以根据不同的需要重写里面的方法。
(2)接口的特点：A:接口用关键字interface修饰interface 接口名 {}B:类实现接口用implements修饰class 类名 implements 接口名 {}C:接口不能实例化D:接口的实现类a:是一个抽象类。b:是一个具体类，这个类必须重写接口中的所有抽象方法。
(3)接口的成员特点：A:成员变量只能是常量默认修饰符：public static final建议手动给出B:构造方法没有构造方法C:成员方法只能是抽象的默认修饰符：public abstract
(4)类与类,类与接口,接口与接口A:类与类继承关系，只能单继承，可以多层继承B:类与接口  实现关系，可以单实现，也可以多实现。还可以在继承一个类的同时，实现多个接口C:接口与接口继承关系，可以单继承，也可以多继承
(5)抽象类和接口的区别?A:成员区别抽象类：成员变量：可变量可常量构造方法：有成员方法：可抽象，可非抽象接口：成员变量：只可常量构造方法：无成员方法：只可抽闲B:关系区别:类与类： 继承，单继承类与接口：实现，单实现，多实现接口与接口：继承，单继承，多继承C:设计理念不同抽象类：is a，抽象类中定义的是共性功能。接口：like a，接口中定义的是扩展功能。

形式参数和返回值（引用类型）

(1)形式参数：类名：需要该类的对象抽象类名：需要该类的子类对象，多态接口名：需要该接口的实现类对象
(2)返回值类型：类名：返回的是该类的对象抽象类名：返回的是该类的子类对象接口名：返回的是该接口的实现类的对象
(3)链式编程对象.方法1().方法2().......方法n();这种用法：其实在方法1()调用完毕后，应该一个对象；方法2()调用完毕后，应该返回一个对象。方法n()调用完毕后，可能是对象，也可以不是对象。

包

(1)其实就是文件夹
(2)作用：A:区分同名的类B:对类进行分类管理a:按照功能分b:按照模块分
(3)包的定义(掌握)package 包名;多级包用.分开。
(4)注意事项：(掌握)A:package语句必须在文件中的第一条有效语句B:在一个java文件中，只能有一个packageC:如果没有package，默认就是无包名
(5)带包的编译和运行A:手动式B:自动式(掌握)javac -d . HelloWorld.java

导包

(1)我们多次使用一个带包的类，非常的麻烦，这个时候，Java就提供了一个关键字import。
(2)格式：import 包名...类名;另一种：import 包名...*;(不建议)
(3)package,import,class的顺序package > import > class

权限修饰符

(1)权限修饰符本类	同一个包下	不同包下的子类	不同包下的无关类private		Y默认		   Y		Yprotected	Y		Y			Ypublic		Y		Y			Y				Y
(2)这四种权限修饰符在任意时刻只能出现一种。public class Demo {}		

常见的修饰符

(1)分类：权限修饰符：private,默认,protected,public状态修饰符：static,final抽象修饰符：abstract
(2)常见的类及其组成的修饰类：默认,public,final,abstract常用的：public成员变量：private,默认,protected,public,static,final常用的：private构造方法：private,默认,protected,public常用的：public成员方法：private,默认,protected,public,static,final,abstract常用的：public
(3)另外比较常见的：public static final int X = 10;public static void show() {}public final void show() {}public abstract void show();

内部类

(1)把类定义在另一个类的内部，该类就被称为内部类。举例：把类B定义在类A中，类B就被称为内部类。
(2)内部类的访问规则A:可以直接访问外部类的成员，包括私有B:外部类要想访问内部类成员，必须创建对象
(3)内部类的分类A:成员内部类：在成员位置定义的类B:局部内部类：定义在成员方法内的类
(4)成员内部类A:private 为了数据的安全性B:static 为了访问的方便性成员内部类不是静态的：外部类名.内部类名 对象名 = new 外部类名.new 内部类名();成员内部类是静态的：外部类名.内部类名 对象名 = new 外部类名.内部类名();
(5)局部内部类A:局部内部类访问局部变量必须加final修饰。B:为什么呢?因为局部变量使用完毕就消失，而堆内存的数据并不会立即消失。所以，堆内存还是用该变量，而改变量已经没有了。为了让该值还存在，就加final修饰。通过反编译工具我们看到了，加入final后，堆内存直接存储的是值，而不是变量名。
(6)匿名内部类(掌握)A:是局部内部类的简化形式B:前提存在一个类或者接口C:格式:new 类名或者接口名() {重写方法; }D:本质：其实是继承该类或者实现接口的子类匿名对象
(7)匿名内部类在开发中的使用我们在开发的时候，会看到抽象类，或者接口作为参数。而这个时候，我们知道实际需要的是一个子类对象。如果该方法仅仅调用一次，我们就可以使用匿名内部类的格式简化。

API的概述(了解)

(1)应用程序编程接口。
(2)就是JDK提供给我们的一些提高编程效率的java类。

Object类(掌握)

(1)Object是类层次结构的根类，所有的类都直接或者间接的继承自Object类。
(2)Object类的构造方法有一个，并且是无参构造这其实就是理解当时我们说过，子类构造方法默认访问父类的构造是无参构造
(3)要掌握的方法：A:toString()返回对象的字符串表示，默认是由类的全路径+'@'+哈希值的十六进制表示。这个表示其实是没有意义的，一般子类都会重写该方法。B:equals()比较两个对象是否相同。默认情况下，比较的是地址值是否相同。而比较地址值是没有意义的，所以，一般子类也会重写该方法。
(4)要了解的方法：A:hashCode() 返回对象的哈希值。不是实际地址值，可以理解为地址值。B:getClass() 返回对象的字节码文件对象，反射中我们会详细讲解	C:finalize() 用于垃圾回收，在不确定的时间D:clone() 可以实现对象的克隆，包括成员变量的数据复制，但是它和两个引用指向同一个对象是有区别的。
(5)两个注意问题；A:直接输出一个对象名称，其实默认调用了该对象的toString()方法。B:面试题 ==和equals()的区别?A:==基本类型：比较的是值是否相同引用类型：比较的是地址值是否相同B:equals()只能比较引用类型。默认情况下，比较的是地址值是否相同。但是，我们可以根据自己的需要重写该方法。String类 就是重写了equals()方法，比较的是内容

Scanner

(1)在JDK5以后出现的用于键盘录入数据的类。
(2)构造方法：A:讲解了System.in这个东西。它其实是标准的输入流,对应于键盘录入B:构造方法InputStream is = System.in;Scanner(InputStream is)C:常用的格式Scanner sc = new Scanner(System.in);
(3)基本方法格式：A:hasNextXxx() 判断是否是某种类型的B:nextXxx()	返回某种类型的元素
(4)要掌握的两个方法A:public int nextInt()B:public String nextLine()
(5)需要注意的小问题A:同一个Scanner对象，先获取数值，再获取字符串会出现一个小问题。B:解决方案：a:重新定义一个Scanner对象b:把所有的数据都用字符串获取，然后再进行相应的转换

String类的概述和使用

(1)多个字符组成的一串数据。可以和字符数组进行相互转换。
(2)构造方法：A:public String()B:public String(byte[] bytes)C:public String(byte[] bytes,int offset,int length)D:public String(char[] value)E:public String(char[] value,int offset,int count)F:public String(String original)把字符常量转换为字符串下面的这一个虽然不是构造方法，但是结果也是一个字符串对象G:String s = "hello";
(3)字符串的特点A:字符串一旦被赋值，就不能改变。注意：这里指的是字符串的内容不能改变，而不是引用不能改变。B:字面值作为字符串对象和通过构造方法创建对象的不同String s = new String("hello");和String s = "hello"的区别?(4)字符串的功能A:判断功能boolean equals(Object obj)比较字符串内容boolean equalsIgnoreCase(String str)比较字符串内容忽略大小写boolean contains(String str)大字符串是否包含小字符串boolean startsWith(String str)判断以某字符串开头boolean endsWith(String str)boolean isEmpty()B:获取功能int length()char charAt(int index)int indexOf(int ch)返回指定字符的第一次索引int indexOf(String str)返回指定字符串的第一次索引int indexOf(int ch,int fromIndex)int indexOf(String str,int fromIndex)String substring(int start)从指定位置开始截取字符串String substring(int start,int end)C:转换功能byte[] getBytes()把字符串转换为字节数组char[] toCharArray()转换为字符数组static String valueOf(char[] chs)static String valueOf(int i)value把任意类型的数据转换为字符串String toLowerCase()String toUpperCase()String concat(String str)拼接字符串D:其他功能a:替换功能 String replace(char old,char new)String replace(String old,String new)b:去空格功能String trim()c:按字典比较功能int compareTo(String str)int compareToIgnoreCase(String str) 按字典顺序比较字符串

StringBuffer

(1)用字符串做拼接，比较耗时并且也耗内存，而这种拼接操作又是比较常见的，为了解决这个问题，Java就提供了一个字符串缓冲区类。StringBuffer供我们使用。
(2)StringBuffer的构造方法A:StringBuffer()B:StringBuffer(int capacity)构造一个没有字符的字符串缓冲区和指定的初始容量C:StringBuffer(String str)构造一个初始化为指定字符串内容的字符串缓冲区
(3)StringBuffer的常见功能(自己补齐方法的声明和方法的解释)A:添加功能public StringBuffer append(anydata):把任意类型添加到字符缓冲区里面需要创建对象，返回值是对象本身public StringBuffer insert(int offset,anydata):在指定位置把任意数据插入缓冲区B:删除功能public StringBuffer delete(int start, int end)public StringBuffer deleteCharAt(int index)C:替换功能public StringBuffer replace(int start, int end, String str) 包含左边不含右边D:反转功能public StringBuffer reverse()E:截取功能(注意这个返回值)String substring(int start)String substring(int start, int end) 
(4)StringBuffer的练习A:String和StringBuffer相互转换String -- StringBufferString s = "cool"构造方法StringBuffer sb = new StringBuffer(s)添加sb.append(s)StringBuffer -- StringStringBuffer buffer = new StringBuffer()构造方法String s = new String(buffer)toString()方法String s = buffer.toString()B:字符串的拼接C:把字符串反转D:判断一个字符串是否对称
(5)小细节：StringBuffer：同步的，数据安全，效率低。StringBuilder：不同步的，数据不安全，效率高。A:String,StringBuffer,StringBuilder的区别B:StringBuffer和数组的区别?
(6)注意的问题：String作为形式参数，StringBuffer作为形式参数。

数组高级以及Array

(1)排序A:冒泡排序B:选择排序把0索引的元素，和索引1以后的元素都进行比较，第一次完毕，最小值出现在了0索引。同理，其他的元素就可以排好。(2)查找A:基本查找针对数组无序的情况B:二分查找(折半查找)针对数组有序的情况(千万不要先排序，在查找)public static int binarySearch(int[] arr,int value) {int min = 0;int max = arr.length-1;int mid = (min+max)/2;while(arr[mid] != value) {if(arr[mid] > value) {max = mid - 1;}else if(arr[mid] < value) {min = mid + 1;}if(min > max) {return -1;}mid = (min+max)/2;}return mid;}
(3)Arrays工具类A:是针对数组进行操作的工具类。包括排序和查找等功能。B:要掌握的方法把数组转成字符串：static String toString(any type)排序：static void sort(any type)二分查找：static int binarySearch(int[] a,int key)

​

Integer

(1)为了让基本类型的数据进行更多的操作，Java就为每种基本类型提供了对应的包装类类型byte 		Byteshort		Shortint			Integerlong		Longfloat		Floatdouble		Doublechar		Characterboolean		Boolean
(2)Integer的构造方法A:Integer i = new Integer(100);B:Integer i = new Integer("100");注意：这里的字符串必须是由数字字符组成
(3)String和int的相互转换A:String -- intInteger.parseInt("100");B:int -- StringString.valueOf(100);
(4)其他的功能进制转换static String toBinaryString(int i) 在基数2中返回整数参数的字符串表示形式为无符号整数。  static String toHexString(int i) 返回整数参数的字符串表示形式，作为16位中的无符号整数。  static String toOctalString(int i) 在基数8中返回整数参数的字符串表示形式为无符号整数。  

Character

(1)Character构造方法	Character ch = new Character('a');
(2)要掌握的方法：:判断是否是字母static boolean isLetter(char ch)  :字母或数字static boolean isLetterOrDigit(char ch)  :判断给定的字符是否是大写static boolean isUpperCase(char ch)  :判断给定的字符是否是小写static boolean isLowerCase(char ch)  :判断给定的字符是否是数字字符static boolean isDigit(char ch) 确定指定的字符是否是数字 :把给定的字符转成大写static char toUpperCase(char ch):把给定的字符转成小写stastic char toLowerCase(char ch)

正则表达式

(1)就是符合一定规则的字符串
(2)常见规则A:字符x 字符 x。举例：'a'表示字符a\\ 反斜线字符。\n 新行（换行）符 ('\u000A') \r 回车符 ('\u000D')B:字符类[abc] a、b 或 c（简单类） [^abc] 任何字符，除了 a、b 或 c（否定） [a-zA-Z] a到 z 或 A到 Z，两头的字母包括在内（范围） [0-9] 0到9的字符都包括C:预定义字符类. 任何字符\d 数字：[0-9]\w 单词字符：[a-zA-Z_0-9]在正则表达式里面组成单词的东西必须有这些东西组成D:边界匹配器^ 行的开头 $ 行的结尾 \b 单词边界就是不是单词字符的地方。举例：hello world?haha;xixiE:Greedy 数量词 X? X，一次或一次也没有X* X，零次或多次X+ X，一次或多次X{n} X，恰好 n 次 X{n,} X，至少 n 次 X{n,m} X，至少 n 次，但是不超过 m 次 
(3)常见功能：A:判断功能String类的public boolean matches(String regex)B:分割功能String类的public String[] split(String regex)C:替换功能String类的public String replaceAll(String regex,String replacement)D:获取功能Pattern和Matcher将给定的正则表达式编译为一个模式对象Pattern p = Pattern.compile("a*b");通过模式对象得到匹配器对象Matcher m = p.matcher("aaaaab");find():查找存不存在group():获取刚才查找过的数据

Math

(1)针对数学运算进行操作的类
static double E e ，自然对数的基数。  
static double PI pi ，圆周长与其直径的比率。  (2)常见方法A:绝对值static int abs() B:向上取整static double ceil(double)C:向下取整static double floor(double) D:两个数据中的大值static max()E:a的b次幂static pow(b,a)F:随机数static double random()G:四舍五入static round()H:正平方根static sqrt()

Random

(1)用于产生随机数的类
(2)构造方法:A:Random() 默认种子，每次产生的随机数不同，是当前的时间的毫秒值B:Random(long seed) 指定种子，每次种子相同，随机数就相同
(3)成员方法:A:int nextInt() 返回int范围内的随机数B:int nextInt(int n) 返回[0,n)范围内的随机数

System

(1)系统类,提供了一些有用的字段和方法
(2)成员方法(自己补齐)A:运行垃圾回收器static void gc()B:退出jvmexit()C:获取当前时间的毫秒值currentTimeMillis()D:数组复制arraycopy(Object src, int srcPos, Object dest, int 			destPos, int length)

BigInteger

(1)针对大整数的运算
(2)构造方法	A:BigInteger(String s)
(3)成员方法A:加public BigInteger add(BigInteger val)B:减public BigInteger subtract(BigInteger val)C:乘public BigInteger multiply(BigInteger val)D:除public BigInteger divide(BigInteger val)E:商和余数public BigInteger[] divideAndRemainder(BigInteger val)

BigDecimal

(1)浮点数据做运算，会丢失精度。所以，针对浮点数据的操作建议采用BigDecimal。(金融相关的项目)
(2)构造方法A:BigDecimal(String val)
(3)成员方法：A:加public BigDecimal add(BigDecimal augend)B:减public BigDecimal subtract(BigDecimal subtrahend)C:乘public BigDecimal multiply(BigDecimal multiplicand)D:除public BigDecimal divide(BigDecimal divisor)E:自己保留小数几位public BigDecimal divide(BigDecimal divisor,int scale,int roundingMode)商，几位小数，如何舍取

Date/DateFormat

(1)Date是日期类，可以精确到毫秒。A:构造方法Date()Date(long time)B:成员方法getTime()setTime(long time)C:日期和毫秒值的相互转换案例：你来到这个世界多少天了?
(2)DateFormat针对日期进行格式化和针对字符串进行解析的类，但是是抽象类，所以使用其子类SimpleDateFormatA:SimpleDateFormat(String pattern) 给定模式yyyy-MM-dd HH:mm:ssB:日期和字符串的转换a:Date -- Stringformat()b:String -- Dateparse()

Calendar

(1)日历类，封装了所有的日历字段值，通过统一的方法根据传入不同的日历字段可以获取值。
(2)如何得到一个日历对象呢?Calendar rightNow = Calendar.getInstance();本质返回的是子类对象
(3)成员方法A:根据日历字段得到对应的值=获取年，月，日int year = rightNow.get(Calendar.YEAR[MONTH][DATE]);B:根据日历字段和一个正负数确定是添加还是减去对应日历字段的值public void add(int field, int amount)根据日历的规则，将指定的时间量添加或减去给定的日历字段C:设置日历对象的年月日注意month从0开始public void set(int year, int month, int date, int hourOfDay, int minute, int second) 

集合框架

Collection

(1)集合的由来?我们学习的是Java -- 面向对象 -- 操作很多对象 -- 存储 -- 容器(数组和StringBuffer) -- 数组而数组的长度固定，所以不适合做变化的需求，Java就提供了集合供我们使用。
(2)集合和数组的区别?A:长度区别数组固定集合可变B:内容区别数组可以是基本类型，也可以是引用类型集合只能是引用类型C:元素内容数组只能存储同一种类型集合可以存储不同类型(其实集合一般存储的也是同一种类型)
(3)集合的继承体系结构?由于需求不同，Java就提供了不同的集合类。这多个集合类的数据结构不同，但是它们都是要提供存储和遍历功能的，我们把它们的共性不断的向上提取，最终就形成了集合的继承体系结构图。Collection|--List|--ArrayList|--Vector|--LinkedList|--Set|--HashSet|--TreeSet
(4)Collection的功能概述(自己补齐)A:添加功能boolean add(E e) 确保此集合包含指定的元素boolean addAll(Collection<? extends E> c) 将指定集合中的所有元素添加到此集合B:删除功能void clear() 删除所有元素boolean remove(Object o) 从该集合中删除指定元素的单个实例（如果存在）  boolean removeAll(Collection<?> c) 删除指定集合中包含的所有此集合的元素，只要有一个移除就算移除default boolean removeIf(Predicate<? super E> filter) 删除满足给定谓词的此集合的所有元素 C:判断功能boolean contains(Object o) 如果此集合包含指定的元素，则返回 trueboolean containsAll(Collection<?> c) 如果此集合包含指定 集合中的所有元素，则返回trueboolean isEmpty() 如果此集合不包含元素，则返回 true  D:获取功能Iterator<E> iterator() 返回此集合中的元素的迭代器 E:长度功能int size() 返回此集合中的元素数 F:交集boolean retainAll(Collection<?> c) 仅保留此集合中包含在指定集合中的元素 G:把集合转数组Object[] toArray() 返回一个包含此集中所有元素的数组。  <T> T[] toArray(T[] a 返回包含此集合中所有元素的数组; 返回的数组的运行时类型是指定数组的运行时类型 
(5)Collection集合的遍历A:把集合转数组(了解)B:迭代器(集合专用方式)
(6)迭代器A:是集合的获取元素的方式。B:是依赖于集合而存在的。C:迭代器的原理和源码。a:为什么定义为了一个接口而不是实现类?b:看了看迭代器的内部类实现。
(7)Collection集合的案例(遍历方式 迭代器)集合的操作步骤：A:创建集合对象B:创建元素对象C:把元素添加到集合D:遍历集合

List

(1)List是Collection的子接口特点：有序(存储顺序和取出顺序一致)，可重复。
(2)List的特有功能：(自己补齐)A:添加功能boolean add(E e)void add(int index, E element) 指定位置插入B:删除功能Object remove(int index)：根据索引删除元素,返回被删除的元素void clear()删除所有C:获取功能Object get(int index):获取指定位置的元素D:迭代器功能ListIterator listIterator()：List集合特有的迭代器E:修改功能Object set(int index,Object element):根据索引修改元素，返回被修饰的元素
(3)List集合的特有遍历功能A:由size()和get()结合。B:代码演示//创建集合对象List list = new ArrayList();					//创建并添加元素list.add("hello");list.add("world");list.add("java");//遍历集合Iterator it = list.iterator();while(it.hasNext()) {String s =(String) it.next();System.out.println(s);}System.out.println("----------");for(int x=0; x<list.size(); x++) {String s =(String) list.get(x);System.out.println(s);}
(4)列表迭代器的特有功能：可以逆向遍历，但是要先正向遍历，所以无意义，基本不使用。
(5)并发修改异常A:出现的现象迭代器遍历集合，集合修改集合元素B:原因迭代器是依赖于集合的，而集合的改变迭代器并不知道。C:解决方案a:迭代器遍历，迭代器修改(ListIterator)元素添加在刚才迭代的位置b:集合遍历，集合修改(size()和get())元素添加在集合的末尾
(6)常见数据结构A:栈 先进后出B:队列 先进先出C:数组 查询快，增删慢D:链表 查询慢，增删快
(7)List的子类特点ArrayList底层数据结构是数组，查询快，增删慢。线程不安全，效率高。Vector底层数据结构是数组，查询快，增删慢。线程安全，效率低。LinkedList 底层数据结构是链表，查询慢，增删快。线程不安全，效率高。到底使用谁呢?看需求?分析：要安全吗?要：Vector(即使要，也不使用这个，后面再说)不要：ArrayList或者LinkedList查询多；ArrayList增删多：LinkedList什么都不知道，就用ArrayList。
(8)List集合的案例(遍历方式 迭代器和普通for)A:存储字符串并遍历B:存储自定义对象并遍历

List的子类

(1)List的子类特点ArrayList:底层数据结构是数组，查询快，增删慢线程不安全，效率高Vector:底层数据结构是数组，查询快，增删慢线程安全，效率低LinkedList:底层数据结构是链表，查询慢，增删快线程不安全，效率高
(2)ArrayListA:没有特有功能需要学习B:案例a:ArrayList存储字符串并遍历b:ArrayList存储自定义对象并遍历
(3)VectorA:有特有功能a:添加public void addElement(E obj)		--	add()b:获取public E elementAt(int index)		--	get()public Enumeration<E> elements()	--  iterator()B:案例a:Vector存储字符串并遍历b:Vector存储自定义对象并遍历
(4)LinkedListA:有特有功能	a:添加addFirst()头插入addLast()b:删除removeFirst()removeLast()c:获取getFirst()getLast()B:案例a:LinkedList存储字符串并遍历b:LinkedList存储自定义对象并遍历
(5)案例：A:去除集合中的多个字符串的重复元素如果字符串的内容相同，即为重复元素B:去除集合中的多个自定义对象的重复元素如果自定义对象的成员变量值都相同，即为重复元素C:用LinkedList模拟一个栈数据结构的集合类，并测试。你要定义一个集合类，只不过内部可以使用LinkedList来实现。

泛型

(1)泛型概述是一种把明确类型的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型。
(2)格式：<数据类型>注意：该数据类型只能是引用类型。
(3)好处：A:把运行时期的问题提前到了编译期间B:避免了强制类型转换C:优化了程序设计，解决了黄色警告线问题，让程序更安全
(4)泛型的前世今生A:泛型的由来Object类型作为任意类型的时候，在向下转型的时候，会隐含一个转型问题B:泛型类C:泛型方法D:泛型接口E:泛型高级通配符? ? extends E? super E
(5)我们在哪里使用呢?一般是在集合中使用。

增强for循环（for each循环）

(1)是for循环的一种
(2)格式：for(元素的数据类型 变量名 : 数组或者Collection集合的对象) {使用该变量即可，该变量其实就是数组或者集合中的元素。}
(3)好处：简化了数组和集合的遍历
(4)弊端增强for循环的目标不能为null。建议在使用前，先判断是否为null。

静态导入

(1)可以导入到方法级别的导入
(2)格式：import static 包名....类名.方法名;
(3)注意事项：A:方法必须是静态的B:如果多个类下有同名的方法，就不好区分了，还得加上前缀。所以一般我们并不使用静态导入，但是一定要能够看懂。

可变参数

(1)如果我们在写方法的时候，参数个数不明确，就应该定义可变参数。
(2)格式：修饰符 返回值类型 方法名(数据类型... 变量) {}注意：A:该变量其实是一个数组名B:如果一个方法有多个参数，并且有可变参数，可变参数必须在最后
(3)Arrays工具类的一个方法asList()把数组转成集合。注意：这个集合的长度不能改变。

Set

(1)Set集合的特点无序,唯一
(2)HashSet集合A:底层数据结构是哈希表(是一个元素为链表的数组)B:哈希表底层依赖两个方法：hashCode()和equals()执行顺序：首先比较哈希值是否相同相同：继续执行equals()方法返回true：元素重复了，不添加返回false：直接把元素添加到集合不同：就直接把元素添加到集合C:如何保证元素唯一性的呢?由hashCode()和equals()保证的D:开发的时候，代码非常的简单，自动生成即可。E:HashSet存储字符串并遍历F:HashSet存储自定义对象并遍历(对象的成员变量值相同即为同一个元素)
(3)TreeSet集合A:底层数据结构是红黑树(是一个自平衡的二叉树)B:保证元素的排序方式a:自然排序(元素具备比较性)让元素所属的类实现Comparable接口b:比较器排序(集合具备比较性)让集合构造方法接收Comparator的实现类对象
(4)案例：A:获取无重复的随机数B:键盘录入学生按照总分从高到底输出

Collection集合总结

Collection|--List	有序,可重复|--ArrayList底层数据结构是数组，查询快，增删慢。线程不安全，效率高|--Vector底层数据结构是数组，查询快，增删慢。线程安全，效率低|--LinkedList底层数据结构是链表，查询慢，增删快。线程不安全，效率高|--Set	无序,唯一|--HashSet底层数据结构是哈希表。如何保证元素唯一性的呢?依赖两个方法：hashCode()和equals()开发中自动生成这两个方法即可|--LinkedHashSet底层数据结构是链表和哈希表由链表保证元素有序由哈希表保证元素唯一|--TreeSet底层数据结构是红黑树。如何保证元素排序的呢?自然排序比较器排序如何保证元素唯一性的呢?根据比较的返回值是否是0来决定

Collection集合使用方法

唯一吗?是：Set排序吗?是：TreeSet否：HashSet如果你知道是Set，但是不知道是哪个Set，就用HashSet。否：List要安全吗?是：Vector否：ArrayList或者LinkedList查询多：ArrayList增删多：LinkedList如果你知道是List，但是不知道是哪个List，就用ArrayList。如果你知道是Collection集合，但是不知道使用谁，就用ArrayList。如果你知道用集合，就用ArrayList。

在集合中常见的数据结构

ArrayXxx:底层数据结构是数组，查询快，增删慢
LinkedXxx:底层数据结构是链表，查询慢，增删快
HashXxx:底层数据结构是哈希表。依赖两个方法：hashCode()和equals()
TreeXxx:底层数据结构是二叉树。两种方式排序：自然排序和比较器排序

Map

(1)将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。 
(2)Map和Collection的区别?A:Map 存储的是键值对形式的元素，键唯一，值可以重复。夫妻对B:Collection 存储的是单独出现的元素，子接口Set元素唯一，子接口List元素可重复。光棍C:Map集合的数据结构值针对键有效，跟值无关，Collection则是针对元素
(3)Map接口功能概述(自己补齐)A:添加功能V put(K key, V value) 如果键第一次存储，则直接存储元素，返回null如果不是第一次，则更新值，然后返回上一次的值B:删除功能void clear()V remove(Object key) 根据键删除键值对元素，并返回值 C:判断功能boolean containsKey(Object key)判断是否包含指定的键boolean containsValue(Object value) 值 boolean isEmpty()  D:获取功能Set<Map.Entry<K,V>> entrySet() 返回此地图中包含的映射的Set视图 V get(Object key) 返回指定键所映射的值Set<K> keySet()  返回此地图中包含的键的Set视图Collection<V> values()  获取值的集合E:长度功能int size():返回键值对数
(4)Map集合的遍历A:键找值a:获取所有键的集合b:遍历键的集合,得到每一个键c:根据键到集合中去找值B:键值对对象找键和值a:获取所有的键值对对象的集合b:遍历键值对对象的集合，获取每一个键值对对象c:根据键值对对象去获取键和值代码体现：Map<String,String> hm = new HashMap<String,String>();hm.put("it002","hello");hm.put("it003","world");hm.put("it001","java");//方式1 键找值Set<String> set = hm.keySet();for(String key : set) {String value = hm.get(key);System.out.println(key+"---"+value);}//方式2 键值对对象找键和值Set<Map.Entry<String,String>> set2 = hm.entrySet();for(Map.Entry<String,String> me : set2) {String key = me.getKey();String value = me.getValue();System.out.println(key+"---"+value);}
(5)HashMap集合的练习A:HashMap<String,String>B:HashMap<Integer,String>C:HashMap<String,Student> D:HashMap<Student,String>
(6)TreeMap集合的练习		A:TreeMap<String,String>B:TreeMap<Student,String>

Collections

(1)是针对集合进行操作的工具类，都是静态方法
(2)面试题：Collection和Collections的区别A:Collection 是单列集合的顶层接口，有两个子接口List和SetB:Collections 是针对集合进行操作的工具类，可以对集合进行排序和查找等
(3)常见的几个小方法：A:public static <T> void sort(List<T> list)排序B:public static <T> int binarySearch(List<?> list,T key)二分查找C:public static <T> T max(Collection<?> coll)D:public static void reverse(List<?> list)E:public static void shuffle(List<?> list)随机置换

异常

(1)程序出现的不正常的情况。
(2)异常的体系Throwable|--Error	严重问题，我们不处理。|--Exception|--RuntimeException	运行期异常，我们需要修正代码|--非RuntimeException 编译期异常，必须处理的，否则程序编译不通过
(3)异常的处理：A:JVM的默认处理把异常的名称,原因,位置等信息输出在控制台，但是呢程序不能继续执行了。B:自己处理a:try {可能出现问题的代码;}catch(异常名 变量) { 针对问题的处理;}finally {释放资源;}假如遇到不知名的异常，则可以用父类接收如 catch(Exception e)，一般放在其他已知异常的后面多个异常多个catch或者catch(Exception1 | Exception2 name)自己编写处理代码,后面的程序可以继续执行b:throws把自己处理不了的，在方法上声明，告诉调用者，这里有问题格式:throws 异常名（可以跟多个）格式必须跟在方法的括号后面 c:throw抛出的是一个对象面试题A:编译期异常和运行期异常的区别?编译期异常 必须要处理的，否则编译不通过运行期异常 可以不处理，也可以处理B:throw和throws是的区别throw:在方法体中,后面跟的是异常对象名,并且只能是一个throw抛出的是一个异常对象，说明这里肯定有一个异常产生了throws:在方法声明上,后面跟的是异常的类名,可以是多个throws是声明方法有异常，是一种可能性，这个异常并不一定会产生
(4)异常中需要了解的方法public String getMessage():异常的消息字符串public String toString():返回异常的简单描述printStackTrace()获取异常类名和异常信息，以及异常出现在程序中的位置printStackTrace(PrintStream s)(5)finally关键字及其面试题A:finally用于释放资源，它的代码永远会执行。特殊情况：在执行到finally之前jvm退出了B:异常处理的变形try...catch...finallytry...catch...try...catch...catch...try...catch...catch...fianllytry...finally
(6)自定义异常继承自Exception或者RuntimeException,只需要提供无参构造和一个带参构造即可
(7)异常的注意实现A:父的方法有异常抛出,子的重写方法在抛出异常的时候必须要小于等于父的异常 B:父的方法没有异常抛出,子的重写方法不能有异常抛出C:父的方法抛出多个异常,子的重写方法必须比父少或者小

I/O

File

(1)IO流操作中大部分都是对文件的操作，所以Java就提供了File类供我们来操作文件File:文件和目录（文件夹）路径名的抽象表示形式
(2)构造方法A:File(String pathname) 通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例File file = new File("e:\\demo\\a.txt");B:File(File parent, String child) 从父抽象路径名和子路径名字符串创建新的 File实例File file = new File("e:\\demo","a.txt");C:File file = new File("e:\\demo");File file2 = new File(file,"a.txt");
(3)File类的功能(自己补齐)A:创建功能boolean createNewFile()boolean mkdir()boolean mkdirs()创建由此抽象路径名命名的目录，包括任何必需但不存在的父目录=B:删除功能boolean delete()注意:删除不走回收站C:重命名功能boolean renameTo(File dest)（注意是对象）如果两个文件名路径相同的话就是重命名操作，不同则是剪切加重命名D:判断功能boolean isDirectory() 路径boolean isFile() 文件boolean exists() boolean canRead()boolean canWrite()boolean isHidden()E:获取功能String getAbsolutePath()绝对路径String getPath()String getName()long length()long lastModified()上次修改的时间F:高级获取功能String[] list()返回一个字符串数组，命名由此抽象路径名表示的目录中的文件和目录File[] listFiles()返回一个抽象路径名（文件对象）数组，表示由该抽象路径名表示的目录中的文件G:过滤器功能String[] list(FilenameFilter filter) 
返回一个字符串数组，命名由此抽象路径名表示的目录中满足指定过滤器的文件和目录 File[] listFiles(FileFilter filter) 返回一个抽象路径名数组，表示由此抽象路径名表示的满足指定过滤器的目录中的文件和目录。  File[] listFiles(FilenameFilter filter) 返回一个抽象路径名数组，表示由此抽象路径名表示的满足指定过滤器的目录中的文件和目录。  

IO流

(1)IO用于在设备间进行数据传输的操作	
(2)分类：A:流向输入流	读取数据输出流	写出数据B:数据类型字节流	字节输入流字节输出流字符流字符输入流字符输出流注意：a:如果我们没有明确说明按照什么分，默认按照数据类型分。b:除非文件用windows自带的记事本打开我们能够读懂，才采用字符流，否则建议使用字节流。
(3)FileOutputStream写出数据
用于写入诸如图像数据的原始字节流。 对于写入字符流，请考虑使用FileWriter构造方法FileOutputStream(File file)FileOutputStream(String name)字节流写数据的方式void write(byte[] b) 将 b.length个字节从指定的字节数组写入此文件输出流。  void write(byte[] b, int off, int len) 
将 len字节从位于偏移量 off的指定字节数组写入此文件输出流。  void write(int b) 
将指定的字节写入此文件输出流。  A:操作步骤a:创建字节输出流对象b:调用write()方法 c:释放资源	B:代码体现：FileOutputStream fos = newFileOutputStream("fos.txt"); fos.write("hello".getBytes());fos.close();C:要注意的问题?a:创建字节输出流对象做了几件事情?b:为什么要close()?c:如何实现数据的换行?写入换行符字节流fos.write("\n".getbytes())d:如何实现数据的追加写入?FileOutputStream(File file, boolean append) 创建文件输出流以写入由指定的 File对象表示的文件。  如果第二个值为true的话则从文本末追加FileOutputStream(String name, boolean append) 创建文件输出流以指定的名称写入文件如果第二个值为true的话则从文本末追加(4)FileInputStream读取数据构造方法FileInputStream(File file)   FileInputStream(String name)读取字节的方式int read() 从该输入流读取一个字节的数据。  int read(byte[] b) 从该输入流读取最多 b.length个字节的数据为字节数组。  int read(byte[] b, int off, int len) 从该输入流读取最多 len字节的数据为字节数组。  A:操作步骤a:创建字节输入流对象b:调用read()方法c:释放资源B:代码体现：FileInputStream fis = new FileInputStream("fos.txt");//方式1读取中文时可能会出问题  int by = 0;while((by=fis.read())!=-1) {System.out.print((char)by);}//方式2byte[] bys = new byte[1024];int len = 0;while((len=fis.read(bys))!=-1) {System.out.print(new String(bys,0,len));}fis.close();
(5)IO流分类字节流：InputStreamFileInputStreamBufferedInputStreamOutputStreamFileOutputStreamBufferedOutputStream字符流：ReaderFileReaderBufferedReaderWriterFileWriterBufferedWriter
(6)字节缓冲区流A:BufferedOutputStream构造方法BufferedOutputStream(OutputStream out) 创建一个新的缓冲输出流，以将数据写入指定的底层输出流。  BufferedOutputStream(OutputStream out, int size) 创建一个新的缓冲输出流，以便以指定的缓冲区大小将数据写入指定的底层输出流。  BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("file.txt"))B:BufferedInputStreamBufferedInputStream(InputStream in) 
创建一个 BufferedInputStream并保存其参数，输入流 in ，供以后使用。  BufferedInputStream(InputStream in, int size) 
创建 BufferedInputStream具有指定缓冲区大小，并保存其参数，输入流 in ，供以后使用。  操作类似

字符流

(1)字节流操作中文数据不是特别的方便，所以就出现了转换流。转换流的作用就是把字节流转换字符流来使用。
(2)转换流其实是一个字符流字符流 = 字节流 + 编码表
(3)编码表A:就是由字符和对应的数值组成的一张表B:常见的编码表ASCIIISO-8859-1GB2312GBKGB18030UTF-8C:字符串中的编码问题编码String -- byte[]String(byte[] bytes,String charsetName)通过指定的字符集编码字节数组解码byte[] -- Stringbyte[] getBytes(string charsetName)通过指定的字符集解码字节数组
(4)IO流中的编码问题A:OutputStreamWriterOutputStreamWriter(OutputStream os):默认编码，GBKOutputStreamWriter(OutputStream os,String charsetName):指定编码。B:InputStreamReaderInputStreamReader(InputStream is):默认编码，GBKInputStreamReader(InputStream is,String charsetName):指定编码C:编码问题其实很简单编码只要一致即可
(5)字符流Reader|--InputStreamReader基本方法int read();int read(char[] chs)|--FileReader和上面一样|--BufferedReader特殊方法String readLine()Writer|--OutputStreamWriter基本方法void write(int/char[]/String)记得flush()刷新缓冲|--FileWriter和上面一样|--BufferedWriter特殊方法void newLine() 根据系统来决定换行符

IO流小结

IO流|--字节流|--字节输入流InputStreamint read():一次读取一个字节int read(byte[] bys):一次读取一个字节数组|--FileInputStream|--BufferedInputStream|--字节输出流OutputStreamvoid write(int by):一次写一个字节void write(byte[] bys,int index,int len):一次写一个字节数组的一部分|--FileOutputStream|--BufferedOutputStream|--字符流|--字符输入流Readerint read():一次读取一个字符int read(char[] chs):一次读取一个字符数组|--InputStreamReader|--FileReader|--BufferedReaderString readLine():一次读取一个字符串|--字符输出流Writervoid write(int ch):一次写一个字符void write(char[] chs,int index,int len):一次写一个字符数组的一部分|--OutputStreamWriter|--FileWriter|--BufferedWritervoid newLine():写一个换行符void write(String line):一次写一个字符串

数据操作流

(1)可以操作基本类型的数据
(2)流对象名称	DataInputStreamDatainputStream(inputStream in)同理，和下面一样void readInt(Int)DataOutputStream构造方法：DataOutputStream(OutputStream out) 可读写基本数据类型void writeInt(int )writeFloat(float )

内存操作流

(1)有些时候我们操作完毕后，未必需要产生一个文件，就可以使用内存操作流。
(2)三种A:ByteArrayInputStream,ByteArrayOutputStream可以不必close()ByteArrayOutputStream：构造：ByteArrayOutputStream([int size])创建一个新的byte数组输出流，可指定大小主要方法：byte[] toByteArray()void write()写入一个字节ByteArrayInputStream：构造：ByteArrayInputStream(byte[] buf)主要方法：int read()读一个字节B:CharArrayReader,CharArrayWriter类似C:StringReader,StringWriter类似

打印流

(1)字节打印流PrintStream字符打印流PrintWriter(2)特点：A:只操作目的地,不操作数据源B:可以操作任意类型的数据void print(anytype)C:如果启用了自动刷新，在调用println(),printf(),format方法的时候，能够换行并刷新new PrintWriter(Write out,boolean autoflush)D:可以直接操作文件问题：哪些流可以直接操作文件呢?FileInputStreamFileOutputStreamFileReaderFileWriterPrintStreamPrintWriter
(3)复制文本文件版本一 BufferedReader br = new BufferedReader(new FileReader("a.txt"));PrintWriter pw = new PrintWriter(new FileWriter("b.txt"),true);String line = null;while((line=br.readLine())!=null) {pw.println(line);}	pw.close();br.close();

标准输入输出流

(1)System类下面有这样的两个字段in 标准输入流out 标准输出流
(2)三种键盘录入方式A:main方法的args接收参数B:System.in通过BufferedReader进行包装BufferedReader br = new BufferedReader(new InputStreamReader(System.in));C:ScannerScanner sc = new Scanner(System.in);
(3)输出语句的原理和如何使用字符流输出数据A:原理System.out.println("helloworld");PrintStream ps = System.out;ps.println("helloworld");B:把System.out用字符缓冲流包装一下使用BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

随机访问流

(1)支持对文件的访问和写入
(2)可以按照文件指针的位置写数据和读数据。RandomAccessFile(File file, String mode) 创建一个随机访问文件流从File参数指定的文件中读取，并可选地写入文件。  RandomAccessFile(String name, String mode) 创建随机访问文件流，以从中指定名称的文件读取，并可选择写入文件。  (3)案例：A:写数据void writeInt()/writeChar()B:读数据void readInt/readChar()C:获取和改变文件指针的位置long getFilePointer()void seek(long pos)

合并流

(1)把多个输入流的数据写到一个输出流中。
(2)构造方法：A:SequenceInputStream(InputStream s1, InputStream s2) B:SequenceInputStream(Enumeration<? extends InputStream> e) 实现多个文件合并到一个文件里Enumeration 是Vector的一个方法elements()返回类型实现方法Vector<InputStream> v = new Vector<InputStream>InputStream is1 = new InputStream("1.txt")InputStream is2 = new InputStream("2.txt")InputStream is3 = new InputStream("3.txt")v.add(is1)v.add(is2)v.add(is3)Enumeration<InputStream> en = v.elements()  SquenceInputStream sis = new SquenceInputStream(en)

序列化流

(1)可以把对象的基本数据类型和图形入文本文件或者在网络中传输
ObjectInputStreamObjectOutputStream
构造方法ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("oos.txt"))
成员方法void writeObject(Object obj) 将指定的对象写入ObjectOutputStream 
(2)如何实现序列化呢?让被序列化的对象所属类实现序列化接口使用序列化接口，启用序列化功能implements Serializable该接口是一个标记接口。没有功能需要实现。
(3)注意问题：把数据写到文件后，在去修改类会产生一个问题。因为实现了序列化会有一个标记UID，表明它经过序列化如何解决该问题呢?在类文件中，给出一个固定的序列化id值。而且，这样也可以解决黄色警告线问题不想序列化成员变量如何处理（默认都会）private transient int age
(4)面试题：什么时候序列化?如何实现序列化?什么是反序列化?

Properties

(1)是一个集合类，Hashtable的子类,不是泛型类表示一组持久的属性。 Properties可以保存到流中或从流中加载。 属性列表中的每个键及其对应的值都是一个字符串
(2)特有功能A:public Object setProperty(String key,String value)调用hashtable的put方法B:public String getProperty(String key)C:public Set<String> stringPropertyNames()
(3)和IO流结合的方法 void load(InputStream inStream) 从输入字节流读取属性列表（键和元素对）把键值对形式的文本文件内容加载到集合（必须是properties）中void load(Reader reader) 以简单的线性格式从输入字符流读取属性列表（关键字和元素对）。  		把集合中的数据存储到文本文件中void store(OutputStream out, String comments) 将此属性列表（键和元素对）写入此 Properties表中，以适合于使用 load(InputStream)方法加载到 Properties表中的格式输出流。  void store(Writer writer, String comments) 将此属性列表（键和元素对）写入此 Properties表中，以适合使用 	load(Reader)方法的格式输出到输出字符流把集合中的数据存储到文件(4)案例：A:根据给定的文件判断是否有键为"lisi"的，如果有就修改其值为100B:写一个程序实现控制猜数字小游戏程序不能玩超过5次

NIO

(1)JDK4出现的NIO，对以前的IO操作进行了优化，提供了效率。但是大部分我们看到的还是以前的IO，采用内存映射的方式，
(2)一些类BufferChannels
(3)JDK7的NIO的使用	Path:路径接口Paths:通过静态方法返回一个路径，类static Path get(URI uri)Files:提供了常见的功能复制文本文件static long copy(Path source, OutputStream out) 将文件中的所有字节复制到输出流 把集合中的数据写到文本文件public static Path write(Path path,Iterable<? extends CharSequence> lines,Charset cs,OpenOption... options)throws IOException相当于Files.write(path, lines, StandardCharsets.UTF_8, options);  

多线程

概念，使用方法和注意事项

(1)多线程：一个应用程序有多条执行路径进程：正在执行的应用程序线程：进程的执行单元，执行路径单线程：一个应用程序只有一条执行路径多线程：一个应用程序有多条执行路径多进程的意义?提高CPU的使用率多线程的意义?提高应用程序的使用率Java程序的运行原理及JVM的启动是多线程的吗?A:Java命令去启动JVM，JVM会启动一个进程，该进程会启动一个主线程。B:JVM的启动是多线程的，因为它最低有两个线程启动了，主线程和垃圾回收线程。
(2)Java不能直接调用系统功能，但是可以调用c或者c++的程序
(3)多线程的实现方案A:继承Thread类将一个类声明为Thread的子类。 这个子类应该重写run类的方法Threadrun()包含被多线程执行的代码使用start方法来开启线程并运行run方法，每个对象运行一个实现代码创建两个线程对象，调用start方法MyThread mt1 = new MyThread();MyThread mt2 = new MyThread();mt1.start();mt2.start();B:实现Runnable接口自定义类实现Runnable接口重写run方法创建该自定义类的对象创建Thread的对象并把上一个对象作为参数传递
(4)线程的一些操作获取线程名 Thread类中的方法getName()设置线程名称 setName()通过构造方法赋值，必须在自定义类中写构造方法返回当前正在执行的线程对象static Thread currentThread()线程的调度a:分时调度b:抢占式调度 (Java采用的是该调度方式)获取和设置线程优先级a:默认是5b:范围是1-10，10最大c:方法获取：int getPriority()设置：void setPriority(int newPriority)
(5)线程的控制(常见方法)A:休眠线程public static void sleep(long millis) 毫秒B:加入线程public final void join() 等待该线程终止，即先执行这个线程C:礼让线程public static void yield() 暂停当前执行的线程对象。先执行其他D:后台线程public final void setDaemon(boolean on)将此线程标记为daemon线程或用户线程。 当运行的唯一线程都是守护进程线程时，Java虚拟机将退出E:终止线程public final void stop()不安全，弃用public void interrupt()终止线程的状态，并抛出一杯异常
(6)线程的生命周期

(7)多线程安全问题的原因(也是以后判断一个程序是否有线程安全问题的依据)A:是否有多线程环境B:是否有共享数据C:是否有多条语句操作共享数据
(8)同步解决线程安全问题同步的特点多个线程，使用同一个对象好处：解决了安全问题弊端：因为要判断是否有锁，所以比较耗费资源，降低效率A:同步代码块synchronized(对象) {需要被同步的代码;}锁必须是同一把锁！这里的锁对象可以是任意对象。B:同步方法把同步加在方法上。public synchronized void function()这里的锁对象是thisC:静态同步方法把同步加在方法上。这里的锁对象是当前类的字节码文件对象(反射再讲字节码文件对象)
(9)回顾以前的线程安全的类A:StringBufferB:VectorC:HashtableD:如何把一个线程不安全的集合类变成一个线程安全的集合类用Collections工具类的方法即可。如：List<E> ls = Collections.synchronizedList(new ArrayList<E>)

多线程的锁

(1)JDK5以后的针对线程的锁定操作和释放操作Lock锁Lock接口void lock()创建锁void unlock()释放锁实现子类Lock lo = new ReentrantLock()
(2)死锁问题的描述和代码体现两个及以上现场在争夺资源过程中，发生的一种相互等待的现象
(3(线程间通信问题代码改进：A:最基本的版本，只有一个数据。B:改进版本，给出了不同的数据，并加入了同步机制C:等待唤醒机制改进该程序，让数据能够实现依次的出现wait()notify()notifyAll() (多生产多消费)D:等待唤醒机制的代码优化。把数据及操作都写在资源类中
(4)线程组
ThreadGroup 类
Thread(ThreadGroup group, Runnable target, String name) 
分配一个新的 Thread对象，使其具有 target作为其运行对象，具有指定的 name作为其名称，属于 group引用的线程组。 
利用线程组可同时操作线程组里所有的线程
(5)线程池
创建线程池
ExecutorService pool = Executors.newFixedThreadPool(int nThreads)
提交线程
pool.submit(new Runnable())
结束线程池
pool.shutdown()(5)定时器
Timer
void schedule(TimeTask task,long delay)
void schedule(TimeTask task,long delay,long period)
TimerTask 
abstract void run()
boolean cancel()取消计时器任务

设计模式

(1)面试对象的常见设计原则单一开闭里氏依赖注入接口迪米特
(2)设计模式概述和分类A:经验的总结B:三类创建型结构型行为型
(3)改进的设计模式A:简单工厂模式B:工厂方法模式C:单例模式(掌握)a:饿汉式b:懒汉式
(4)RuntimeJDK提供的一个单例模式应用的类。还可以调用dos命令。

网络编程

(1)网络编程：用Java语言实现计算机间数据的信息传递和资源共享
(2)网络编程模型
(3)网络编程的三要素A:IP地址B:端口C:协议UDP:数据打包,有限制,不连接,效率高,不可靠TCP:建立数据通道,无限制,效率低,可靠
(4)InetAddress没有构造方法A:成员全部是静态的（Math，Arrays，Collections）B:单例设计模式（Runtime）C:类中有静态方法返回该类的对象方法InetAddress getByName(hostname);获取一个对象String getHostName()String getHostAddress()(5)Socket机制socket: 包含IP地址和端口A:通信两端都应该有Socket对象B:所有的通信都是通过Socket间的IO进行操作的
(6)UDP协议发送和接收数据发送：创建UDP发送端的Socket对象DatagramSocket ds = new DatagramSocket();创建数据并把数据打包byte[] bytes = "Hello".getBytes();InetAddress ia = InetAddress.getByName("127.0.0.1"); DatagramPacket pocket = new DatagramPacket(bytes,bytes.length,ia,10086);发送数据ds.send(pocket);释放资源ds.close();接收：创建UDP接收端的Socket对象DatagramSocket ds = new DatagramSocket(10086);创建数据包用于接收数据byte[] bytes = new byte[1024]DatagramPacket dp = new DatagramPacket(bytes,bytes.length)接收数据ds.recieve(dp);解析数据包String ip = dp.getAddress().getHostAddressString s = new String(dp.getData(),0,dp.getLength())释放资源
(7)TCP协议发送和接收数据(掌握 自己补齐代码)发送：创建TCP客户端的Socket对象Socket s = new Socket("127.0.0.1",12345);获取输出流，写数据OutputStream os = s.getOutputStream();os.write("Hello friend".getBytes());释放资源s.close();接收：创建TCP服务器端的Socket对象ServerSocket ss = new ServerSocket(12345);监听客户端连接                                                 Socket s = ss.accept();获取输入流，读取数据byte[] bys = new byte[1024];int len = is.read(bys);String str = new String(bys,0,len);String ip = s.getInetAddress().getHostAddress();System.out.println(ip+"--"+str);释放资源s.close();

反射

(1)类的加载及类加载器加载：将class文件读入内存，并为之创建一个Class对象任何类被使用时系统都会建立一个Class对象连接：验证 是否有正确的内部结构，并和其他类协调一致准备 负责为类的静态成员分配内存，并设置默认初始化值解析 将类的二进制数据中的符号引用替换为直接引用初始化：(2)反射：通过字节码文件对象，去使用成员变量，构造方法，成员方法(3)反射的使用A:通过反射获取构造方法并使用B:通过反射获取成员变量并使用C:通过反射获取成员方法并使用(4)反射案例A:通过反射运行配置文件的内容B:通过反射越过泛型检查C:通过反射给任意的一个对象的任意的属性赋值为指定的值(5)动态代理