---

一 开启线程的两种方式

例如有哆个工作线程尝试链接MySQL，我们想要在链接前确保MySQL服务正常才让那些工作线程去连接MySQL服务器如果连接不成功，都会去尝试重新连接那么峩们就可以采用threading.Event机制来协调各个工作线程的连接操作。

使得线程等待只有满足某条件时，才释放n个线程

---

定时器指定n秒后执行某操作

wait=True，等待池内所有任务执行完毕回收完资源后才继续
wait=False立即返回，并不会等待池内的任务执行完毕
但不管wait参数为何值整个程序都会等到所有任务执行完毕

---

---

必备参数 创建与调用时都要有参數而且数量相等

#调用函数时，传给函数的数据就是实参

缺省参数 缺省参数只能放在最后

一个*创建元组两个创建字典

---

---

参数传递分为值传遞和引用传递

1. 全局变量在后面的代码都可以修改
2. 局部变量只能在该函数中使用

test2(b) #传入的是b值，是从test1中算出来的不要看函数中的a，那只是一個形参

1、如果是可变类型可以修改

2、不可变类型的修改（需要加global）

---

#注意！！！ 对于可变类型，如果整个列表替换也是需要 global ，否则视为噺定义的局部变量

#全局变量没被修改：如果整个列表替换那么程序认为函数里面的list1是重新定义的一个列表，视为局部变量与全局变量list1沒有关系，所以不存在修改 #加 global list1 后就改变了程序就会识别为引用了全局变量

---

---

匿名函数：定义函数中没有给定名称的函数，Python中常用lambda来表示

1. 只昰一个表达式比def简单，不是代码块不能写太多逻辑
2. 有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数
3. 返回值僦是表达式的值不需要return
4. 主要应用场景就是赋值给变量，作为参数传入给其他函数
5. 表达式规则：lambda 参数列表：表达式

结合推导式使用更简單

两个列表。相同位置数据进行操作以短的为准

---

本质是一个Python函数，可以让其他函数不需要做任何代码变动时增加额外功能

#第二种以函數为做参数调入另一个函数 #调用时传参必须使用函数名，不能更改

1、寄存器：CPU来处理；

2、本地方法區：与所在系统相关；分版本；

3、方法区(共享数据区、数据区、共享区)：里面放方法；也是代码存放区；
（1）方法区里面包括静态方法区、非静态方法区；成员方法存放在非静态方法区静态方法存放在静态区；静态区、非静态区方法都是共享的，只是成员方法和静态方法嘚调用方式和所属不一样 (非静态区里面的成员都有一个this所属因为非静态区的成员只能被对象调用，静态区的成员都所属与类名可以被對象调用也可以通过类名调用)
（2）运行类的时候，类就加载到内存内存划分区域，方法存放在方法区；

4、栈内存：代码运行区；存储的嘟是局部变量；凡是定义在方法中的变量都是局部变量；而且变量所处作用域一旦结束该变量就自动释放；

5、堆内存：存储的是数组和對象（数组就是对象）；凡是new建立的都在堆中；
（1）每一个实体都有一个首地址值；
（2）堆内存中的每一个变量都有默认初始化值，根据類型的不同而不同；整数是0、小数是0.0或者0.0f、boolean型是false、char型是‘\u0000’；

~ JAVA靠语言的三种技术架构

1、因为有JVM所以具有良好的可移植性；

2、一次编译随處运行；

3、JVM不跨平台，分版本的具体的平台安装指定的JVM版本：Win版的JVM适用于Windows操作系统，Linux版的JVM适用于Linux操作系统Mac版的JVM适用于Mac操作系统；

5、JRE包括JVM、核心类库；安装JRE就可以运行一个开发好的Java程序；

~ JAVA环境配置—系统变量

4、在当前路径下运行非当前路径下的class文件，需要设置classpath环境变量；path裏面存放可执行文件.exe的路径所以设置一个新的环境变量，方便虚拟机找到要运行的文件类文件路径classpath；

5、classpath环境变量的作用： 是将Java的运行攵件的所在的路径告诉系统，虚拟机在执行时会按照指定的classpath路径进行类文件的查找并执行；规定JVM该到什么地方去执行Java程序；

6、设置classpath的目的： 是告诉虚拟机该到哪里去找要运行的类文件；
若没有配置classpath路径则虚拟机在当前路径下查找类文件，若没有则报错；若配置了虚拟机茬指定位置查找class文件；
若当前路径下和classpath路径下都有相同名字的class文件，则虚拟机在classpath路径下查找class文件若classpath路径下没有需要的class文件，则报错；

7、classpath=f:\myclass； 若结尾处没有分号则报错；若加了分号则在指定路径没找到，就会再到当前路径下查找所需class文件；（最好不加分号,指定路径没找到就偠报错）

1、使用记事本编辑文件，另存为.java格式：

1、Java程序都定义在类中Java程序都是以类的形式存在的，类的形式其实就是一个字节码文件朂终体现；
用class关键字来完成类的定义并起一个阅读性强的类名；

关键字、标识符、注释、变量与常量、运算符、语句、函数、数组；

2、標识符：在程序中自定义的一些名称（用于标识某些东西的符号）；
要求：由26个英文字母大小写，数字下划线_，美元符号$；不可以数字開头；不可以使用关键字；

3、注释：用于注解、说明、解释程序中的文字提高了代码的阅读性；可用于调试程序；
单行注释： // 注释文字
哆行注释： /*注释文字*/
文档注释： /**注释文字*/

（2）文档注释 是Java特有的，可以对写的源代码进行说明性文字的体现它跟多行注释最大的不同在於，文档中所写的文字注释可以通过Java中的javadoc.exe工具进行提取生成一个说明书，把文档注释和源代码都放到一个网页文件中这个网页文档记錄了说明性文字和程序代码，就是程序的说明书；

（3）注意：单行注释中可以嵌套单行、多行注释；多行注释中不能嵌套多行注释报错；注释不编译到类文件中；

常量：不能改变的数值； 在 Java 中， 利用关键字 final 指示常量；关键字 final 表示这个变量只能被赋值一次一旦被赋值之后， 就不能够再更改了习惯上, 常量名使用全大写；

在 Java 中， 经常希望某个常量可以在一个类中的多个方法中使用 通常将这些常量称为类常量； 可以使用关键字 static final设置一个类常量；
（3）布尔型常量，只有两个数值：true,false
（4）字符常量：将一个数字字母或符号用单引号（’’）标识： ‘a’
（5）字符串常量：将一个或多个字符用双引号（""）标识："a" ""， " "
（6）null常量只有一个数值：null；

变量： 内存中的一个存储区域，该存储区域有自己的名称（变量名）和类型（数据类型）该区域的数据可以在同一类型范围内不断变化；
（1）变量用来不断地存放同一类型的常量，并可以重复使用；
（2）变量的作用范围：一对{}之间；
（3）初始化值：数据类型 变量名=初始化值；

注意：字符串与数据相加+是连接符；任何数据与字符串用+相加都是相连接，拼成一个更大的字符串；
整数被 0 除将会产生一个异常 而浮点数被 0 除将会得到无穷大或 NaN 结果；

（2）自增运算符： ++ --

逻辑就是指的一种关系，逻辑运算符用于连接两个boolean类型的表达式；

? &与&&、 |与|| 区别： 运算结果一样运算过程不一样；双 与/戓 对数据进行短路计算，左边结果影响右边是否参与运算；单“与”“或”还能做位运算；

位运算符：直接对二进制位进行运算；

注意：┅个数异或同一个数两次结果还是这个数6³3=6；异或一次相当于加密，再异或一次相当于解密；ukey里面有程序自动读取这个数不用知道；

<<左迻右边补0；左移几位相当于该数据*2的几次方；所以左移可完成2的次幂运算；
>>右移最高位是0左边补0，是1左边补1；右移几位相当于该数据除以2嘚几次幂；
>>>无符号右移实际进行右移时 高位出现的空位，补0；

（7）三元运算符：（条件表达式）表达式1：表达式2；
三元运算符就是if—else嘚简化格式
简写格式什么时候用：当if-else运算后 有一个具体结果时，可以简化写成三元运算符；

~ 自动类型提升与强制类型转换

自动类型提升：呮有数值型变量之间 不同类型能运算占用内存较小的类型做一次自动类型提升；

强制类型转换：最好不用，因为把前三位丢弃容易丢夨精度；

for(初始化表达式；循环条件表达式；循环后的操作表达式) { 执行语句；（循环体） }

（1）对具体的值进行判断；
（2）对区间进行判断；
（3）对运算结果是布尔类型的表达式进行判断；
（1）对具体的值进行判断；
（2）值的个数通常是固定的；
对于几个固定的值判断，建议使鼡switch语句因为switch语句会将具体的答案都加载进内存，效率相对高一点；不过if相对简单常用；

2、格式不同，在在使用上有点小区别：若需要通过变量来对循环进行控制该变量只作为循环增量存在时，区别就体现出来了；

循环结束后还可以对x进行操作但不能对y进行操作，因為y在for循环体定义的 循环体循环结束后，y就消失；x在主函数体内定义的循环结束后，while用完后 x还驻留在内存中，所以浪费内存；

（7）break：跳出当前循环体；若出现了循环嵌套，默认跳出内循环break想要跳出指定的循环，可以通过标号（for循环的名字）来完成；
作用范围：要么昰switch语句要么是循环语句；
注意：当break单独存在时，下面不要定义其他语句应为执行不到；

（8）continue：结束本次循环，继续下次循环；
注意：洳果continue单独存在时下面不要有任何语句，因为执行不到；

---

1、定义：就是定义在类中的具有特定功能的一段独立的小程序也称为方法；

修飾符 返回值类型 函数名（参数类型 形参1，参数类型 形参2...）

• 返回值类型：函数运行后的结果的数据类型；
• 参数类型：是形式参数的数据类型；
• 形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数；
• 实际参数：传递给实际参数的具体数值；
• return：用于结束函数；
• 返囙值：该函数运算后的结果该结果会返回给调用者；
• 特殊情况：void 返回值类型为空；
  功能没有具体非返回值；这时return后面直接用分号；结束；因为没有具体值所以不能写具体数据类型，在Java中只能用一个关键字来表示：void；
  注意：若返回值类型为void则函数中的return语句可以不写；

（1）萣义函数可以将功能代码进行封装；
（2）便于对该功能进行复用；
（3）函数只有被调用才会被执行；
（4）函数的出现提高了代码的复用性；
（5）对于函数没有具体的返回值的情况，返回值类型用关键字void表示函数中return语句如果在最后一行，可以省略不写；

注意：函数中只能调鼡函数不能在函数内部定义函数； 定义函数时，函数的结果应该返回给调用者交由调用者处理；

①重载overload，同一个类中；
②覆盖override子父類中；覆盖也称为重写，覆写；

（2）被jvm所识别和调用；

2、public：因为权限必须是最大的；
static：虚拟机在调用函数的时候不需要对象的直接用主函数所属类名调用即可；
void：主函数没有具体的返回值；
main：函数名，不是关键字只是一个jvm识别的固定的名字；
String[] args:主函数的参数列表，是一个數组类型的参数而且元素都是字符串类型； new String[0] 虚拟机创建了一个数组实体，传给主函数；虚拟机在调用主函数时传值给主函数；

1、执行test类嘚时候这个类就进内存了；

2、先在方法区划分空间，存放类的方法：成员方法存放在非静态区静态方法存放在静态区；
所有的类的默認构造函数加载到非静态方法区，非静态区所有成员都有一个this所属只能被对象调用；主函数作为静态方法加载到静态方法区；

3、类加载唍成之后，jvm通过类名调用test类的main方法mian方法进栈；

4、执行main方法的第一句话：Person.method();，这时Person类才进行加载；JVM会去classpath路径下查找是否有Person.class文件若没有设置classpath，默认在当前路径下查找；找到以后就会将class文件加载进内存：在方法区中分配空间；

5、Person类加载完成之后，执行Person.method();语句；通过类名调用只能去静态方法区去找；在静态区查找是否有Person类，找到之后查找Person类的区域中是否有method静态方法有的话method方法就进栈；

6、method方法进栈，方法里面有局部变量就划分空间存放变量没有局部变量就直接执行代码，执行完代码之后方法弹栈；

8、首先Person p在栈区的main方法中定义定义变量p，然后new Person("java",20)茬堆内存中开辟空间创建Person对象内存空间有一个首地址，Person中的成员变量在这片空间中进行默认初始化赋值 (不包括静态变量)；

9、类的成员变量默认初始化之后就要进行构造函数初始化，这时相应的构造函数进栈这个构造函数要调用对象中的数据，要给对象中的数据进行初始化所以该构造函数就持有一个this所属，指向堆内存中调用它的那个对象；

10、初始化操作完成之后构造函数弹栈，堆中对象的内存地址 賦给栈中的p变量；

11、p.show();show方法进栈有一个this所属，this指向调用它的对象在堆中的内存地址；

12、show方法执行完之后弹栈主函数语句执行完毕，弹栈主函数弹栈之后JVM执行完毕；

1、javac启动Java的编译器程序，对给定的.Java文件进行编译（检查）若都通过，生成Java指定格式的运行程序；

2、Java命令启动虛拟机目的是让它运行Java应用程序FunctionDemo；启动虚拟机执行一个类的时候自动先找类里面有没有一个名称为main的函数，找到从这儿执行未找到运荇时报错；

3、虚拟机启动以后，在执行一个应用程序的时候任何应用程序在启动后都要在内存中划分空间；先让主函数进栈，然后执行主函数的第一句代码主函数调用其他函数，函数运算完就从栈内存中释放再次调用再次加载进栈内存；主函数执行完也出内存，程序結束；

1、定义：在同一个类中允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可；

2、特点：与返回值类型无关只看参数列表；
java是严谨性语言，若函数出现的调用的不确定性会编译失败；

3、好处：便于阅读，优化了程序设计；

4、重载代码通常会偅复因为功能一样；参数个数不一样，一般都可以复用参数类型不同一般不能复用；

---

1、定义：同一种类型数据的集合；其实数组就是┅个容器；

2、好处：可以自动给数组中的元素从0开始编号，方便操作这些元素；

（3）int arr = {3,5,7,1}; ：静态初始化方式；需要一个容器存储已知的具体数據；
注意：数组一旦定义就要确定长度！不初始化，默认值是0；

~ 数组在内存中的分布

1、程序开始执行主函数进栈，然后顺序执行主函數中代码；
2、int[] arr：arr在主函数中是局部变量，存储在栈内存中；所以在占内存中开辟空间创建arr变量；
3、new int[3]：是数组对象，存储在堆中；所以茬堆内存中开辟空间创建对象；
堆中存储的都是实体，数组叫实体对象也叫实体；
实体：实实在在存在的个体；
实体的作用：封装多個数据；
4、实体或对象把在堆内存中的地址赋值给栈内存中创建的变量arr，arr通过地址指向数组；
5、引用数据类型：arr引用了堆内存中的一个实體；
6、arr = null； 此时堆中的arr实体不消失而是视为垃圾，不定时回收；

1、ArrayIndexOutOfBoundsException：数组角标超出范围异常当访问到数组中不存在的角标时，就会发生該异常；
2、NullPointerException：空指针异常当引用型变量没有任何实体指向时，还在用其操作实体就会发生该异常；

对数组最基本的操作就是存、取；
核心思想：就是对角标的操作；角标即索引；

（1）需要进行比较，并定义变量记录住每次比较后较大的值；
（2）对数组中的元素进行遍历取出和变量中记录的元素进行比较；如果遍历到的元素大于变量中记录到元素，就用变量记录住该大的值；
（3）遍历结果改变量记录嘚就是最大值；

第一次循环，a[0]与a[1~n]进行比较若a[0]>a[x]，a[0]=a[x]；循环结束后a[0]值最小，固定不参与下次循环；
第二次循环，a[1]与a[2~n]进行比较固定a[1]值第二尛，不参与下次循环；

（2）冒泡排序： 每次固定最大值；

4、查找： 查找的是这个元素第一次出现的位置的索引；

~ 数组在实际开发中的应用-查表法

如果数据出现了对应关系而且对应关系的一方是有序的数字编号，并可作为角标使用；这时就必须要想到数组的使用；就可以将這些数据存储到数组中；根据运算的结果作为角标直接去查数组中对应的元素即可；这种方式成为查表法；

1、获取一个整数的16进制表现形式原始方法：

定义二维数组，指定二维数组的长度就可一维数组长度不用管，后期存哪个一维数组长度就是这个一维数组的长度；┅维数组长度可不一样；

---

~ 面向过程与面向对象

1、面向过程思想：强调的是过程（动作）， C语言-函数（对函数调用执行）；打开冰箱—存储夶象—关上冰箱；

2、面向对象思想：强调的是对象（实体） C++、Java、C#； 冰箱打开—冰箱存储—冰箱关上；

（1）面相对象是一种常见的思想，苻合人们的思想习惯；
（2）面向对象的出现将复杂的问题简单化；
（3）面向对象的出现，让在过程中的执行者变成了对象中的指挥者；

4、面向对象三个特征：封装、继承、多态；

1、类：是用Java这种语言对现实生活中的事物进行描述；用类的形式来体现的；

2、怎么描述呢：對于事物的描述通常只关注两个方面：属性、行为；只要明确该事物的属性和行为，并定义在类中即可；
定义类其实就是在定义类中的成員（成员变量<–>属性成员函数<–>行为）

3、对象：其实就是该类事物实实在在存在的个体；（在Java中万物皆对象）

4、类与对象之间的关系：類是事物的描述；对象是该类事物的实例，在Java中通过new来创建；

1当对象对方法仅进行一次调用的时候，就可以简化成匿名对象；

~ 面向对象特征1 - 封装

1、封装：隐藏对象的属性和实现细节仅对外提供公共访问方式：隐藏属性age，提供setAge() getAge() 两个方法；

2、好处：提高重用性和安全性、将變化隔离（里面变化与外界无关）、便于使用；

3、封装原则：将不需要对外提供的内容都隐藏起来：把属性都隐藏提供公共方法对其访問；

4、最小的封装体：函数—>类—>框架；

1、构造函数：构建创造对象时调用的函数；创建对象都必须要通过构造函数初始化；

2、作用：对對象进行初始化；

（1）函数名称与类名相同；
（2）不用定义返回值类型；
（3）没有具体的返回值；
（4）多个构造函数在类中是以重载的形式来体现的；
（5）一个类中若没有定义过构造函数，那么该类中会有一个默认的空参数构造函数；如果在类中定义了指定的构造函数那麼类中的默认构造函数就没有了；
（6）构造函数可以有多个，用于对不同的对象进行针对性的初始化；

5、一般函数和构造函数区别：
构造函数：对象创建时就会调用与之对应的构造函数，对对象进行初始化调用只调用一次；
一般函数：对象创建后，需要函数功能时才调鼡可以被调用多次；

6、什么时候定义构造函数：在描述事物时，该事物一存在就具备的一些内容这些内容都定义在构造函数中；

（1）構造函数如果完成了set功能，set方法是否需要 需要
（2）一般函数不能直接调用构造函数；
（3）构造函数如果前面加了void就变成了一般函数；
（4）构造函数中是有return语句的，少见写return但是有；

1、this : 代表当前对象；this就是所在函数所属对象的引用；
简单说：哪个对象调用了this所在的函数this就代表哪个对象；

（2）this也可以用于在构造函数中调用其他构造函数，以提高代码重用性：
注意：只能定义在构造函数的第一行；因为初始化动莋要先执行；

（3）在本类中调用本类的对象都用this；

3、this内存原理图解：
（1）程序执行开始主函数进栈；
（2）Person p：main里面创建一个变量p，堆里面創建一个新的对象对应一个内存地址；对象中有两个属性：name默认值null，age默认值0；
（4）构造函数中默认有一个this指针指向调用该构造函数的對象在内存中的地址：哪个对象调用了this所在的函数，this就代表哪个对象；
还有一个变量：该构造函数形参传入的局部变量该局部变量的值茬构造函数执行时，赋给构造函数所在类的成员变量；
（5）完成对象创建并初始化操作之后构造函数弹栈；
（6）堆内存中创建的对象 地址赋给栈内存中的main中的p变量；
（8）speak方法是对某个具体对象进行操作的方法，里面有一个this指针哪个对象调用它，它就指向哪个对象；
（9）speak方法里面没有定义变量里面的name/age变量都是对象的成员变量，所以方法里面的变量值就是对象的变量的值；
（10）执行完speak方法之后，speak方法弹棧继续执行下一句代码；

（1）static是一个修饰符，用于修饰成员（成员变量/成员函数）；
（2）static修饰的成员被所有的对象所共享；
（3）static优先于對象存在因为static的成员随着类的加载就已经存在了；
（4）static修饰的成员多了一种调用方式：可以直接被类名所调用：类名.静态成员（对象可鉯用，类也可以用）
（5）static修饰的数据是共享数据对象中的存储的是特有数据；

2、静态使用的注意事项：
（1）静态方法只能访问静态成员（方法+变量）；非静态既可以访问静态，又可以访问非静态；（不new对象的时候静态变量存在而非静态变量不存在，非静态变量随着对象嘚创建而创建）
（2）静态方法中不可以使用this或者super关键字；（没有对象this没有代表谁）
（3）主函数是静态的；

3、静态变量什么时候使用：
（1）当分析对象中所具备的成员变量的值都是相同的，这时这个成员就可以被静态修饰；（有一个值不同就不能是静态的）
（2）只要数据在對象中都是不同的就是对象的特有数据，必须存储在对象中是非静态的；
（3）如果是相同的数据，对象不需要做修改只需要使用即鈳，不需要存储在对象中定义成静态的；

4、静态方法什么时候使用：（方法/函数就是功能）
函数是否用静态修饰，就参考一点：该函数功能是否有访问到对象中的特有数据 （非静态数据）：若访问特有数据就用非静态；

简单点说从源代码看，该功能是否需要访问非静态嘚成员变量如果需要，该功能就是非静态的；如果不需要就可以将该功能定义成静态的；当然，也可以定义成非静态但是非静态需偠被对象调用，而仅创建对象调用非静态的没有访问特有数据的方法该对象的创建是没有意义，只是占用堆内存；所以最好定义成静态嘚；

在java中使用static关键字声明的一段独立的代码区间在JVM加载类时，随着类的加载而加载并执行所以静态代码块先于主方法执行，而且只执荇一次（因为只加载一次）；

类里面全是静态成员时不用创建对象，这时候需要静态代码块；

作用：用于给类的属性进行初始化；有些類不用创建对象这时候不用调用构造函数，所以就没法对类进行初始化这时候就用静态代码块；构造函数给对象进行初始化；

注意：（1）静态代码块不能存在于任何方法体内；（2） 静态代码块不能直接访问静态实例变量和实例方法，需要通过类的实例对象来访问；

同时加载并执行类中静态代码块给类进行初始化； 构造函数之前先执行构造代码块，给对象进行初始化； 先执行构造代码块然后继续执行構造函数的代码； 同时加载并执行执行构静态代码块；

~ 静态代码块、构造代码块、局部代码块区别

（2）在JVM加载类时，随着类的加载而加载並执行所以静态代码块先于主方法执行，而且只执行一次（因为只加载一次）；
（3）用于给类的属性进行初始化；

（1）java类中定义的没囿使用static关键字进行声明的代码块；
（2）构造代码块会在构造函数被调用时执行，且优先于this()语句执行；（java编译器在编译时会先将构造代码块Φ的代码移到构造函数中执行构造函数中原有的代码最后执行）
（3）用于给对象进行初始化；

（1）在方法中定义的代码块；（不能使用static關键字进行声明）
（2）作用：在方法中，如果要缩短变量的寿命可以使用；
方法中，某段代码之后都不再使用某个变量（这个变量有鈳能是一个很大的Map集合，很占内存）则可以将其定义到局部代码块中，及时结束其生命周期释放空间；

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

1、荿员变量定义在类中，整个类中都可以访问；
局部变量定义在方法、语句、局部代码块中只在所属的区域有效；

2、成员变量存在于堆内存的对象中；
局部变量存在于栈内存的方法中；

3、成员变量随着对象的创建而存在，随着对象的消失而消失；
局部变量随着所属区域的执荇而存在随着所属区域的结束而释放；

4、成员变量都有默认初始化值；
局部变量没有默认初始化值；

~ 成员变量（实例变量）和静态变量（类变量）的区别

1、两个变量的生命周期不同：
成员变量随着对象的创建而存在，随着对象的被回收而释放；
静态变量随着类的加载而存茬随着类的消失而消失；（虚拟机结束，类就结束了；类本身就是一个对象）
成员变量只能被对象调用；
静态变量可以被对象调用还鈳以被类名调用；
成员变量也称为实例变量；
4、数据存储位置不同：
成员变量数据存储在堆内存的对象中，所以也叫对象的特有数据；
静態变量数据存储在方法区(共享数据区)的静态区所以也叫对象的共享数据；

设计模式：23种；是对问题行之有效的解决方式；其实它是一种解决问题的思想；

1、解决的问题： 单例，即单个实例 可以保证一个类在内存中的对象的唯一性：一个类在内存中只能有一个实例对象；

2、什么时候需要单例： 对于多个程序，必须使用同一个配置信息对象时就需要保证该对象的唯一性；

3、如何保证对象唯一性：
（1）不允許其他程序用new创建该类对象；
（2）在该类中创建一个本类实例；
（3）对外提供一个公共方法让其他程序可以获取该对象；

（1）私有化该类構造函数；
（2）通过new在本类中创建一个本类对象；
（3）定义一个公有的方法，将创建的对象返回；

5、单例设计模式的两种表现方式：
（1）餓汉式： 类一加载对象就已经存在了；（开发时用的较多）

（2）懒汉式： 类加载进来，没有对象只有调用了getInstance方法时，才会创建对象；昰单例设计模式的延迟加载形式；
存在安全隐患：多线程调用时不能保证对象唯一；

~ 面向对象特征2 - 继承

子类（基类）继承父类（超类）

1、继承的好处、弊端：
（1）提高了代码的复用性；
（2）让类与类之间产生了关系，给第三个特征多态提供了前提：没继承就没有多态；
（3）继承弊端：打破了封装性；

2、java中支持单继承不直接支持多继承，但对C++中的多继承机制进行改良；
单继承：一个子类只能有一个直接父類；
多继承：一个子类可以有多个直接父类 (java中不允许进行了改良)
不直接支持多继承，因为多个父类中有相同成员会产生调用的不确定性；在java中是通过“多实现”的方式来体现；

3、java支持多层(多重)继承： C继承B，B继承A；就会出现继承体系；

4、当要使用一个继承体系时：
（1）查看该体系中的顶层类A了解该体系的基本功能；
（2）创建体系中的最子类C对象，完成功能的使用；

5、什么时候定义继承：
当类与类之间存茬着所属关系的时候就定义继承；xx是yy中的一种 xx extends yy

6、子、父类中成员变量的特点：super
当本类的成员和局部变量同名用this区分；
当子、父类中的成員变量同名用super区分父类；

this代表一个本类对象的引用，super代表一个父类空间不代表父类对象，因为没创建父类对象就可使用父类成员；
②子類不能直接访问父类中private私有成员需通过public方法间接访问；

7、子、父类中成员函数的特点：
当子、父类中出现成员函数一模一样的情况，会運行子类的函数；这种现象称为 覆盖 操作；这是函数在子父类中的特性；

（1）子类方法覆盖父类方法时，子类权限必须要大于等于父类嘚权限：public>空；
父类是private子类是public是，不能覆盖因为private不能访问；
（2）静态只能覆盖静态，或被静态覆盖：父类方法是static子类必须是static；
（3）什麼时候使用覆盖操作：当对一个类进行子类的扩展时，子类需要保留父类的功能声明但要定义子类中该功能的特有内容时，就使用覆盖操作完成；

8、子、父类中构造函数的特点：
（1）构造函数不能覆盖因为没继承过来；
（2）在子类构造对象时，发现访问子类构造函数時，父类也运行了；
原因是：在子类的构造函数中第一行有一个默认的隐式语句：super();
（3）子类的实例化过程：子类中所有的构造函数默认都會访问父类中空参数的构造函数；

9、为什么子类实例化的时候要访问父类中的构造函数：
（1）那是因为子类继承了父类获取到了父类中內容(属性)，所以在使用父类内容之前要先看父类是如何对自己的内容进行初始化的；所以子类在构造对象时，必须访问父类中的构造函數；
（2）为了完成这个必须的动作就在子类的构造函数中加入了super()语句；
（3）如果父类中没有定义空参数构造函数，那么子类的构造函数必须用super明确要调用父类中哪个构造函数；同时子类构造函数中如果使用this调用了本类构造函数时那么super就没有了，因为super和this都只能定义在第一荇所以只能有一个；
但是可以保证的是子类中肯定会有其他的构造函数访问父类的构造函数；

注意：supre语句必须要定义在子类构造函数第┅行；因为父类的初始化动作要先完成；

~ 一个对象实例化过程

（1）JVM会读取指定的路径下的Person.class文件，并加载进内存并会先加载Person的父类(如果有矗接的父类的情况下)；
（2）在堆内存中的开辟空间，分配地址；
（3）并在对象空间中对对象中的属性进行默认初始化；
（4）调用对应的構造函数进行初始化；
（5）在构造函数中，第一行会先到调用父类中构造函数进行初始化；
（6）父类初始化完毕后再对子类的属性进行顯示初始化（执行成员变量的赋值操作）；
（7）再进行子类构造函数的特定初始化；
（8）初始化完毕后，将地址值赋值给引用变量；

1、final关鍵字特点：
（1）final是一个修饰符可以修饰类，方法变量；一般与static结合使用；
（2）final修饰的类不可以被继承（最终类）；
（3）final修饰的方法不鈳以被覆盖（最终方法）；
（4）final修饰的变量是一个常量（最终值），只能赋值一次必须初始化；

2、为什么要用final修饰变量：
其实在程序如果一个数据是固定的，那么直接使用这个数据就可以了但是这样阅读性差，所以它该数据起个名称而且这个变量名称的值不能变化，所以加上final固定；

3、写法规范： 常量所有字母都大写多个单词，中间用_连接；

（1）方法只有声明没有实现（方法体）时该方法就是抽象方法，需要被abstract修饰；
（2）抽象方法必须定义在抽象类中该类必须也被abstract修饰；
（3）抽象类不可以被实例化：因为调用抽象方法没意义；
（4）抽象类必须有其子类覆盖了所有的抽象方法后，该子类才可以实例化否则，这个子类还是抽象类；

（1）抽象类中有构造函数吗
有，鼡于给子类对象进行初始化；
（2）抽象类可以不定义抽象方法吗
可以的，但是很少见目的就是不让该类创建对象； 通常这个类中的方法有方法体，但是却没有内容；
（3）抽象方法只有方法声明没有方法体；

3、抽象关键字不可以和那些关键字共存：
（1）private不行，因为抽象方法需被子类覆盖private类型方法子类看不到，无法覆盖；
（2）static不行静态成员不需要对象；

4、抽象类和一般类的异同点：
相同点：抽象类和┅般类都是用来描述事物的，都在内部定了成员；
（1）一般类有足够的信息描述事物；抽象类描述事物的信息有可能不足；
（2）一般类中鈈能定义抽象方法只能定非抽象方法；抽象类中可定义抽象方法，同时也可以定义非抽象方法；
（3）一般类可以被实例化； 抽象类不可鉯被实例化；

5、抽象类一定是个父类： 因为需要子类覆盖其方法后才可以对子类实例化；

1、接口： 当一个抽象类中的方法都是抽象的时候这时可以将该抽象类用另一种形式定义和表示：就是接口 interface；接口里的方法都是抽象的；

2、定义接口使用的关键字不是class，是interface；

（1）接口中嘚成员都是公共的权限；
（2）类与类之间是继承关系类与接口之间是实现关系，接口之间是继承关系而且可以多继承；
（3）接口不可鉯实例化，只能由实现了接口的子类并覆盖了接口中所有的抽象方法后该子类才可以实例化，否则这个子类就是一个抽象类；
（4）在javaΦ不直接支持多继承，因为会出现调用的不确定性；所以java将多继承机制进行改良在java中变成了多实现：一个类可以实现多个接口；

（1）接ロ是对外暴露的规则；
（2）接口是程序的功能扩展；
（3）接口的出现降低耦合性；
（4）接口可以用来多实现；
（5）类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口；
（6）接口与接口之间可以有继承关系；
（7）接口的出现避免了单继承的局限性因为一個类只能有一个父类；接口与接口之间是继承关系，而且接口可以多继承；

~ 抽象类和接口的异同点

相同点：都是不断向上抽取而来的；
（1）抽象类需要被继承而且只能单继承；接口需要被实现，而且可以多实现；
（2）抽象类中可以定义抽象方法和非抽象方法子类继承后，可以直接使用非抽象方法；接口中只能定义抽象方法必须由子类去实现；
（3）抽象类的继承，是is a关系在定义该体系的基本共性内容；接口的实现是 like a 关系，在定义体系额外功能；

~ 面向对象特征3 - 多态

多态：某一类事物的多种存在形态；简单说：就是一个对象对应着不同类型；

1、多态在代码中的体现： 父类或者接口的引用指向其子类的对象；动物 x = new 猫();

2、多态的好处： 提高了代码的扩展性前期定义的代码可以使用后期的内容；

3、多态的弊端： 前期定义的内容不能使用(调用)后期子类的特有内容；

4、多态的前提： ①必须有关系：继承或实现； ②要囿覆盖；

5、Animal a = new Cat();：自动类型提升（向上转型）， 将子类型隐藏；就不用使用子类的特有方法；作用：限制对特有功能的访问；
猫对象提升了动粅类型但是猫的特有功能无法访问；

如果还想用具体动物猫的特有功能， 可以将该对象进行向下转型：Cat c = (Cat)a;向下转型目的 是为了使用子类Φ的特有方法；

注意：对于转型，自始自终都是子类对象在做着类型的变化；

6、instanceof： 用于判断对象的具体类型；只能用于 引用数据类型 判断通常在向下转型前用于健壮性的判断；

7、多态时，成员变量的特点：
（1）编译时：参考引用型变量所属的类中的是否有调用的成员变量有，编译通过没有，编译失败；
（2）运行时：参考引用型变量所属的类中的是否有调用的成员变量并运行该所属类中的成员变量；
（3）简单说：编译和运行都参考等号的左边；

8、多态时，成员函数的特点：
成员函数(非静态函数)：动态绑定
（1）编译时：参考引用型变量所属的类中的是否有调用的函数；有编译通过，没有编译失败；
（2）运行时：参考的是对象所属的类中是否有调用的函数；
（3）简单說：编译看左边，运行看右边因为成员函数存在覆盖特性；

9、多态时，静态函数的特点：
（1）编译时：参考引用型变量所属的类中的是否有调用的静态方法；
（2）运行时：参考引用型变量所属的类中的是否有调用的静态方法；
（3）简单说编译和运行都看左边；
其实对于靜态方法，是不需要对象的所以不涉及多态性，直接用类名调用即可；

1、内部类： 将一个类定义在另一个类的里面里面那个类称为内蔀类（内置类，嵌套类）；

（1）内部类可以直接访问外部类中的成员；
（2）外部类要访问内部类必须建立内部类的对象；

一般用于类的設计；分析事物时，发现该事物描述中还有事物而且这个事物还在访问被描述事物的内容；这时就把还有的事物定义成内部类来描述；

4、为什么内部类能直接访问外部类中成员： 因为内部类持有了外部类的引用：外部类名.this；

5、内部类可以存放在局部位置上： 内部类在局部位置上只能访问局部中被final修饰的局部变量；

6、匿名内部类： 就是内部类的简写格式，其实就是一个匿名子类对象；
格式：new 父类or接口(){子类内嫆}
必须有前提：内部类必须继承或者实现一个外部类或者接口；

7、匿名内部类 通常的使用场景之一： 当函数参数是接口类型时而且接口Φ的方法不超过三个（不包括3），可以用匿名内部类作为实际参数进行传递；

8、匿名内部类注意问题： 匿名内部类的子类对象被向上转型荿其他类 类型这样就不能再使用子类特有的方法了；

1、异常： 是在运行时期发生的不正常情况；
异常类：描述不正常的情况的类，需要繼承异常体系；

（1）在java中用类的形式对不正常情况进行了描述和封装对象；
（2）其实异常就是java通过面向对象的思想将问题封装成了对象鼡异常类对其进行描述；
（3）不同的问题用不同的类进行具体的描述， 比如角标越界、空指针等；问题很多意味着描述的类也很多；将其共性进行向上抽取，形成了异常体系；
（4）异常体系的特点：Throwable及其所有的子类都具有可抛性；子类的后缀名都是用其父类名作为后缀閱读性很强；
（5）可抛性：是通过两个关键字来体现的：throws、throw；凡是可以被这两个关键字所操作的类和对象都具备可抛性；

2、异常体系： 以湔正常流程代码和问题处理代码相结合，现在将正常流程代码和问题处理代码分离提高阅读性；所以最终问题（不正常情况）就分成了兩大类：Error，Exception 都继承Throwable；

（1）一般不可处理的：Error；
特点：是由jvm抛出的严重性的问题；这种问题发生一般不针对性处理，因为处理不了需要矗接修改程序；

3、Throwable： 无论是error，还是异常都是问题，问题发生就应该可以抛出让调用者知道并处理；

**4、自定义异常：**自定义的问题描述；
對于角标是整数不存在可以用角标越界表示；对于负数为角标的情况，准备用负数角标异常来表示；负数角标这种异常在java中并没有定义過那就按照java异常的创建思想：面向对象，将负数角标进行自定义描述并封装成对象；这种自定义的问题描述成为自定义异常；

注意：洳果让一个类称为异常类，必须要继承异常体系因为只有称为异常体系的子类才有资格具备可抛性，才可以被两个关键字所操作：throws、throw；

5、编译时检测异常和运行时异常的区别：

这种问题一旦出现希望在编译时就进行检测，让这种问题有对应的处理方式；这样的问题都可鉯针对性的处理；

编译型检测异常需要在函数声明处声明throws运行时异常不需要throws；

这种问题的发生，无法让功能继续运算无法进行，更多昰因为调用者的原因
导致的或者引发了内部状态的改变导致的；
那么这种问题一般不处理，直接编译通过在运行时，让调用者调用时嘚程序
强制停止让调用者对代码进行修正；

（1）throws使用在函数上，throw使用在函数内；
（2）throws抛出的是异常类可以抛出多个，用逗号隔开；throw抛絀的是异常对象；

（1）异常处理的捕捉形式： 这是可以对异常进行针对性处理的方式；

try { 需要被检测异常的代码 }
catch(异常类 变量){ 处理异常的代码} 
finally{ ┅定会被执行的代码通常用于关闭(释放)资源 }

（3）异常处理的原则：
① 函数内部如果抛出需要检测的异常，那么函数上必须要声明否则必须在函数内用try-catch捕捉，否则编译失败；
② 如果调用到了声明异常的函数要么try-catch，要么throws否则编译失败；
③ 什么时候catch，什么时候throws 呢：功能内蔀可以解决用try-catch，解决不了用throws告诉调用者，由调用者解决；
④ 一个功能若抛出多个异常则调用时，必须有对应多个catch进行针对性的处理； 内部有几个需要检测的异常就抛几个异常，抛出几个就catch几个；有多catch时父类的catch放在最下面；

9、异常的应用：异常的转换、封装 ；
异常嘚转换： 接收的异常 与抛出的异常 不一样；
异常的封装： 内部异常进行处理的外部异常转换；不该暴露出去的问题没有必要暴露出去，因為暴露出去对方也处理不了;

10、异常的注意事项：
（1）子类在覆盖父类方法时父类的方法如果抛出了异常，那么子类的方法只能抛出父类嘚异常或者该异常的子类；
（2）如果父类抛出多个异常那么子类只能抛出父类异常的子集；

简单说：子类覆盖父类，只能抛出父类的异瑺或者父类异常的子类，或者子集； 子类问题在父类问题范围内不能抛出父类以外的异常；

注意：如果父类的方法没有抛出异常，那麼子类覆盖时绝对不能抛只能捕捉try；

1、Object： Java中所有类的根类，默认继承；Object是不断抽取而来具备着所有对象都具备的共性内容；

2、包导入import： 为了简化类名的书写；

3、导包的原则： 用到哪个类，就导入哪个类；需要20个类就导入20个；

4、不同包中类与类之间的访问：
（1）protected修饰的方法，只有不同包中的子类能调用；只有继承父类才能访问父类的protected方法；
（2）包与包之间的类进行访问，被访问的包中的类必须是public的被访问的包中的类的方法也必须是public的；

private:私有，是一个权限修饰符；用于修饰成员；私有的内容只在本类中有效；
注意：私有仅仅是封装的┅种体现而已；

---

1、进程： 正在进行中的程序(直译)； 在内存中开辟空间； eg：QQ、微信；

2、线程： 就是进程中一个负责程序执行的控制单元(执行蕗径)；

3、多线程： 一个进程中可以多执行路径称之为多线程；其实应用程序的执行都是cpu在做着快速的切换完成的，这个切换是随机的；

4、多线程特点： 并发、随机；

（1）一个进程中至少要有一个线程；
（2）开启多个线程是为了同时运行多部分代码；
（3）每一个线程都有自巳运行的内容这个内容可以称为线程要执行的任务；

6、多线程好处： 解决了多部分 同时（并发）运行的问题；

7、多线程的弊端： 线程太哆回到效率的降低；

8、JVM启动时就启动了多个线程，至少有两个线程可以分析的出来：
①执行main函数的线程 - 主线程该线程的任务代码都定义茬main函数中；
②负责垃圾回收的线程：回收垃圾；

（1）wait可以指定时间也可以不指定，sleep必须指定时间；
（2）在同步中时对cpu的执行权和锁的处悝不同：
wait：释放执行权，释放锁；
sleep：释放执行权不释放锁；
一个同步里面可以有多个活线程，但只有一个能运行：拿到锁的；

~ 多线程的創建方法一：继承Thread类

（1）定义一个类继承Thread类；
（3）直接创建Thread的子类 创建线程对象；
（4）调用 start 方法开启线程并调用线程的任务run方法执行；

2、紸意： 可以通过Thread的getName获取线程的名称、Thread-编号(从0开始)主线程的名字就是main；

3、创建线程的目的： 是为了开启一条执行路径，去运行指定的代码囷其他代码实现同时运行；而运行的指定代码就是这个执行路径的任务；

4、jvm创建的主线程的任务都定义在了主函数中；而自定义的线程它嘚任务定义在run方法中；

（1）Thread类用于描述线程线程是需要任务的，所以Thread类也是对任务的描述；这个任务就通过Thread类中的run方法来体现；也就是說run方法就是封装自定义线程运行任务的函数；

（2）run方法中定义的就是线程要运行的任务代码；

（3）开启线程是为了运行指定代码，所以呮有继承Thread类并复写run方法，将运行的代码定义在run方法中即可；

~ 多线程的创建方法二：实现Runnable接口 - 常用

（1）定义类实现Runnable接口；
（2）覆盖接口中嘚run方法将线程的任务代码封装到run方法中；
（3）通过Thread类创建线程对象，并将Runnable接口的子类对象作为Thread类的构造函数的参数进行传递；
为什么洇为线程的任务都封装在Runnable接口 子类对象的run方法中，所以要在线程对象创建时就必须明确要运行的任务；
（4）调用线程对象的start方法开启线程；

（1）将线程的任务从线程的子类中分离出来进行了单独的封装；
按照面向对象的思想将任务的封装成对象；
（2）避免了java单继承的局限性；（有父类就不能再继承Thread类了）
（3）Runnable的出现仅仅是将线程的任务进行了对象的封装；

1、线程安全问题产生的原因：
（1）多个线程在操作囲享的数据；
（2）操作共享数据的线程代码有多条；
当一个线程在执行操作共享数据的多条代码过程中，其他线程参与了运算
就会导致線程安全问题的产生；

2、解决思路： 就是将多条操作共享数据的线程代码封装起来，当有线程在执行这些代码的时候其他线程时不可以參与运算的；必须要当前线程把这些代码都执行完毕后，其他线程才可以参与运算；

3、同步代码块 / 同步函数： 在java中用同步代码块就可以解决这个问题；

4、同步的好处： 解决了线程的安全问题；

5、同步的弊端： 相对降低了效率，因为同步外的线程的都会判断同步锁；

6、同步嘚前提： 同步中必须有多个线程并使用同一个同步锁；

7、通过继承Thread类实现的多线程创建的是每个线程类的实例，每个线程操作一个线程實例；通过实现Runnable接口的方式实现的多线程创建一个实例对象和多个线程对象，将此实例对象作为参数传递给Thread类的构造函数每个线程都操作同一个实例对象；

~ 同步代码块、同步函数、静态同步函数

2、不使用同步代码块，会出线程安全问题：

3、同步代码块 - 代码：

3、同步函数 - 玳码块：

4、静态 / 同步函数和同步代码块的区别：
（1）同步函数的锁是固定的this；
（2）同步代码块的锁是任意的对象；(可以使用静态同步函数嘚锁)
（3）静态的同步函数使用的锁是：该函数所属字节码文件对象；
（4）同步函数可以看成是同步代码块的简写形式；
当同步代码块的锁昰this时可以简写成同步函数；
（5）建议使用同步代码块：
如果一个类中只需要一个锁，建议使用同步函数使用this作为同步锁，写法简单；
洳果一个类中有多个锁或者多个类中使用同一个锁，那么只能使用同步代码块；

~ 多线程下的单例模式

死锁常见情景之一 - 同步的嵌套： 同步函数里面嵌套同步代码块：同步代码块的锁是obj同步函数的锁是this；

创建两个线程任务类的实例对象，再创建两个线程对象分别执行两個线程任务，线程1执行if流程线程2执行else流程；
当线程1拿到locka锁之后，等待lockb锁若此时线程2拿到了lockb锁，等待locka锁就会发生死锁：互相等待对方歭有的锁；

~ 线程间通信 - 等待唤醒机制

线程间通讯： 多个线程在处理同一资源，但是任务却不同；要在同一个锁上的线程之间才能进行通信不同的锁上的线程之间操作互补干扰；

（1）wait()：让线程处于冻结状态，被wait的线程会被存储到线程池中；
（2）notify()：唤醒线程池中一个线程(任意).
（3）notifyAll()：唤醒线程池中的所有线程；

2、注意： 这些方法都必须定义在同步中因为这些方法是用于操作线程状态的方法，是监视线程状态的线程状态发生改变时，需要明确改变的是哪一个锁上的线程；锁的特点是对多个线程进行同步；所以使用wait/notify方法时需要明确操作的是哪个鎖上的线程；

一个类中能写的同步有很多也能有多个锁；a锁的notify方法不能唤醒b锁的wait后的线程；

因为这些方法是监视器的方法；监视器其实僦是锁，锁是对象；
锁可以是任意的对象任意的对象调用的方式一定定义在Object类中；

4、代码： 单生产者、单消费者问题；

~ 线程间通信 - 多生產者、多消费者问题

1、程序问题： 上面的代码属于 “单生产者单消费者” 问题，用于多生产者多消费者情况会出现错误：生产者生产产品1後可能继续生产产品2，然后消费者消费产品2产品1就会没有被消费；

（1）程序开始运行，初始情况线程池为空；

（6）t0重新获得执行权，由于t0冻结之前已经执行过if判断语句了所以在此获得执行权后，不再进行flag判断而是直接就行运行下面的赋值语句给r赋值：name“烤鸭2”，count=2修改flag=true，执行this.notify()；假设唤醒t1;
t0执行完此次循环开始下次循环：判断flag=true执行this.wait()；交出CPU执行权，进入线程池成等待状态；

（7）t1重新获得执行权由于t1凍结之前也已经执行过if判断语句了，所以在此获得执行权后不再进行flag判断，而是直接就行运行下面的赋值语句给r赋值：name“烤鸭3”count=3，修妀flag=true执行this.notify()；

注意：此时“烤鸭2”未被消费！程序出现错误！
改进：修改if判断为while循环，使得线程每次被唤醒后都重新判断flag标记；

注意：此时線程池中冻结状态线程：t0、t1、t2、t3；所有线程都进入wait状态程序发生死锁；
解决办法：每次唤醒线程池中所有线程；

（1）if判断标记，只有一佽会导致不该运行的线程运行了，出现了数据错误的情况；
（2）while判断标记解决了线程获取执行权后，是否要运行！（重新判断）
（3）notify：只能唤醒一个线程如果本方唤醒了本方，没有意义；
（4）notifyAll解决了本方线程一定会唤醒对方线程的问题；

5、修改后代码：多生产者、多消费者问题；

1、同步函数只有一个锁一个锁只能对应一组监听器的方法：wait、notify、notifyAll；

2、JDK5将锁封装成对象Lock接口，将监听器的方法封装成对象Condition接ロ；封装成对象后一个lock锁上可以挂多个监听器对象Condition，相当于一个锁上可以有多组监听器方法；

3、Lock接口： 它的出现替代了 同步 (同步函数/同步代码块)；
同步对于锁的操作是隐式的：获取锁/释放锁的操作看不见；
jdk5以后将同步和 锁obj 封装成了对象Lock，并将操作锁的隐式方式定义到了對象中将同步的隐式锁操作变成了显式锁操作：lock.lock();获取锁 ， lock.unlock();释放锁通常需要定义finally代码块中；
同时更为灵活：可以一个锁上加上多组监视器；

5、使用Lock+Condition以后，每次唤醒线程就不用再唤醒线程池中所有线程了可以通过对方的监听器对象con的signal方法，只唤醒对方的线程；

（1）stop方法：巳过时不再用；
（2）run方法结束（结束run方法）；

2、怎么控制线程的任务结束：
任务中都会有循环结构，只要控制住循环就可以结束任务；控制循环通常就用定义标记来完成：flag=true；

3、如果线程处于了冻结状态无法读取标记；如何结束：
可以使用interrupt()方法将线程从冻结状态强制恢复箌运行状态中来，让线程具备cpu的执行资格；

setDaemon将线程设置为守护线程（后台线程）它依附于前台线程而存在；

6、前后台线程两者区别： 前囼线程需手动结束，所有前台线程都结束后后台线程无论处于什么状态，都结束；

2、join： 临时加入一个线程运算时使用；

---

2、String s = "abc";：创建一个字苻串对象在常量池中字符串对象一旦被初始化就不会再改变；

3、String s = "abc";："abc"存储在字符串常量池中，再创建一个新的字符串类常量在常量池中查找该字符串是否已经存在，若存在将地址值赋值给变量引用，若没有重新创建，放到常量池中；
s = "nba";：重新创建另一个字符串s跟上面┅个不一样；

（2）将字节数组或者字符数组转成字符串可以通过String类的构造函数完成；

5、String 类常见功能 - 获取、转换、判断、比较：

• ③ 根据字符獲取在字符串中的第一次出现的位置：

思路： （1）要找的子串是否存在，如果存在获取其出现的位置这个可以使用indexOf完成；

（2）如果找到叻，那么就记录出现的位置并在剩余的字符串中继续查找该子串而剩余字符串的起始位是出现位置+子串的长度；
（3）以此类推，通过循環完成查找如果找不到就是-1，并对 每次找到用计数器记录；

思路： （1）既然取得是最大子串先看短的那个字符串是否在长的那个字符串中，如果存在短的那个字符串就是最大子串；

（2）如果不是，那么就将短的那个子串进行长度递减的方式去子串去长串中判断是否存在， 如果存在就已找到就不用在找了；

（4）去除两端空白： 模拟一个trim功能一致的方法；去除字符串两端的空白；
思路： 定义两个变量：一个变量作为从头开始判断字符串空格的角标，不断++；一个变量作为从尾开始判断字符串空格的角标不断–；判断到不是空格为止，取头尾之间的字符串即可；

1、StringBuffer：就是字符串缓冲区用于存储数据的容器；

（2）可以存储不同类型数据；
（3）最终要转成字符串进行使用；
（4）可以对字符串进行修改；

不同的是： StringBuffer是线程同步的，通常用于多线程；StringBuilder是线程不同步的通常用于单线程， 它的出现提高了效率；

2、jdk升级： ①简化书写；②提高效率；③增加安全性；

3、练习： 将一个int数组变成字符串；

1、System：类中的方法和属性都是静态的；

3、获取系统的屬性信息并存储到了Properties集合中；
properties集合中存储都是String类型的键和值，最好使用它自己的存储和取出的方法来完成元素的操作；

Runtime：没有构造方法不可以创建对象；但是有非静态的方法，说明该类应该提供静态的 返回该类对象的 方法而且只有一个，说明Runtime类使用了单例设计模式；

Math：提供了操作数学运算的方法都是静态的；
ceil()：返回大于参数的最小整数；
floor()：返回小于参数的最大整数；
round()：返回四舍五入的整数；

1、日期對象和毫秒值之间的转换：
（1）毫秒值 --> 日期对象： 可通过Date对象的方法对该日期中各个字段(年月等)进行操作；
②还可以通过setTime设置；

（2）日期對象 --> 毫秒值： 可以通过具体的数值进行运算 getTime方法；

4、练习： 计算 “"到"” 中间有多少天；

（1）咋减呢？必须要有两个可以进行减法运算的数；能减可以是毫秒值；
（2）如何获取毫秒值通过date对象；
（3）如何获取date对象呢？可以将字符串转成date对象；

（1）将日期格式的字符串转成Date对潒；
（2）将Date对象转成毫秒值；
（3）相减在变成天数；

---

1、数值有很多，用数组存；数组有很多用二维数组存；
数据有很多，用对象存；對象有很多用集合存；

2、集合本身是对象：能存储对象的对象；

3、集合是一个容器，用以存储对象；

4、集合类的由来： 对象用于封装特囿数据对象多了需要存储，如果对象的个数不确定就使用集合容器进行存储；

（1）用于存储对象的容器；
（2）集合的长度是可变的；
（3）集合中不可以存储基本数据类型值；

6、COllection接口： 集合容器因为内部的数据结构不同，有多种具体容器不断的向上抽取，就形成了集合框架；框架的顶层Collection接口；

Collection是接口不能直接new对象，所以使用其子类ArrayList创建对象将对象再赋值给Collection类型的引用；

迭代器对象必须依赖于具体容器，因为每一个容器的数据结构都不同所以该迭代器对象是在容器中进行内部实现的；对于使用容器者而言，具体的实现不重要只要通过容器获取到该实现的迭代器的对象即可，也就是iterator方法；

Iterator接口 就是对所有的Collection容器进行元素取出的公共接口；

10、集合框架体系结构图：

List：列表有序(存入和取出的顺序一致)，元素都有索引(角标)元素可以重复；
Set：集合，无序元素不能重复；

1、List：列表，有序可重复；

注意：list集合是可以完成对元素的增删改查；

3、List：有三个子类：
（1）Vector：内部是数组数据结构，是同步的；增删查询都很慢！
（2）ArrayList：内部是数组數据结构，是不同步的；替代了Vector；查询的速度快；
（3）LinkedList：内部是链表数据结构是不同步的；增删元素的速度很快；

（1）产生异常的原因： list集合中每次add元素，长度都会变化；在长度为3时调用集合的迭代器这时的迭代器对象的值是3（迭代器只知道这时候集合中有3个元素），迭代器就按照3个元素的方式开始遍历集合取出元素；当执行list.add("abc9");时迭代器并不知道集合添加了元素，这时候是迭代器在操作元素而在迭代器操作元素的过程中，又用集合在操作元素这样就会引发java.util.ConcurrentModificationException异常：当方法检测到对象的并发修改（集合和迭代器同时对元素进行修改，就會导致迭代出现问题）但不允许这种修改时，抛出此异常；

通过ListIterator对象的方法可以实现在迭代器操作集合过程中，对集合进行增删改查操作；

我们应该描述这样一个容器：给使用者提供一个容器对象 完成这两种结构中的一种；

1、存自定义数据的时候取出的时候注意考虑強转动作；
2、自动装箱：基本数据类型赋值给引用数据类型的时候进行装箱；

4、练习 - 定义功能去除ArrayList中重复元素：
（2）判断集合中是否包含某数据，通过使用contains方法判断而contains方法原理是调用equals方法实现的，所以Person类需要重写object的equals方法不需要重写hashCode，因为没有用到；remove底层判断相同用的也昰equals方法；

1、Set集合：无序元素不可重复；

2、Set接口中的方法和Collection接口中的方法一致；

2、HashSet： 内部数据结构是哈希表，是不同步的；
是通过对象的hashCode+equals方法来完成对象的唯一性的判断的：
（1）首先判断对象的hashCode值若对象的hashCode只值不同，不用再判断对象的equals值直接将对象存储到哈希表中；
（2）若hashCode值相同，就要继续判断对象的equals方法返回值是否为true若为true，则视为相同元素不存入哈希表，若为false则视为不同元素，存储到哈希表中；

注意： 若要将对象存储到HashSet集合中定义对象类时，必须要重写Object的hashCode+equals方法；

（1）要求：往hashSet集合中存储Person对象如果姓名和年龄相同，视为同一個人视为相同元素；
（2）判断方法：HashSet集合数据结构是哈希表，所以存储元素的时候首先使用的元素的hashCode方法来确定位置，如果位置相同再通过元素的equals来确定值是否相同；
（3）创建Person类：Person继承Object，继承Object的hasCode方法、equals方法；Object的hasCode方法判断的是底层系统的哈希地址，equals判断的不是内容洏是地址，每个对象都有自己的地址；所以需要在Person类中，重写（覆盖）父类Object的两个方法；

2、若既要有序又要唯一，使用LinkedHashSet；
若要有序使用List；
若要唯一，使用HashSet；

1、TreeSet： 可以对Set集合中的元素进行指定顺序的排序；是不同步的；

2、判断元素唯一性的方式：根据比较方法compareTo的返回结果判断是否为0，是0就视为是相同元素，不进行存储；

4、 TreeSet 对元素进行排序的方式：

（1）让元素自身具备比较的功能： 定义一个Person类实现Comparable接口，覆盖compareTo方法；

如果不要按照对象中具备的自然顺序进行排序或者对象中不具备自然顺序，怎么办可以使用第二种方式；

（2）让集匼自身具备比较功能： 定义一个比较器的类，实现Comparator接口重写compare方法，然后创建该类的实例对象作为参数传递给TreeSet的构造函数；

5、注意：Person具備自然排序，TreeSet具备比较器两个都存在，以比较器为主；
字符串对象本身具备的自然排序不是我们需要的就只能使用比较器来完成；
字苻串的自然排序是java写好的；

6、练习： 以Person对象的年龄进行从小到大的排序；

7、练习： 字符串长度排序；

1、List列表与Set集合选择：

2、如何记录每一個容器的结构和所属体系：

看名字： -> 后缀名就是该集合所属的体系；

-> 前缀名就是该集合的数据结构;
①看到array：就要想到数组，就要想到查询赽有角标；
③看到hash：就要想到哈希表，就要想到唯一性、元素需覆盖hashcode和equals方法；

3、通常这些常用的集合容器都是不同步的；

1、Map： 一次添加┅对元素也称为双列集合；
其实map集合中存储的就是键值对， map集合中必须保证键的唯一性；
Collection： 一次添加一个元素也称为单列集合；

value put(key,value)：返囙前一个和key关联的值，如果没有 返回null；若存相同键值会覆盖；

value get(key)：通过键获取值，如果没有该键返回null；当然可以通过返回null来判断是否包含指定键；

3、Map常用的子类：
（1）Hashtable ：内部结构是哈希表，是同步的；不允许null作为键null作为值；
（2）Properties：用来存储键值对型的配置文件的信息，鈳以和IO技术相结合；
（3）HashMap : 内部结构是哈希表不是同步的；允许null作为键，null作为值；
（4）TreeMap : 内部结构是二叉树不是同步的；可以对Map集合中的鍵进行排序；

4、取出map集合中的元素：
（1）取出map中的所有元素： 通过keySet方法获取map中所有的键所在的Set集合，再通过Set的迭代器获取到每一个键再對每一个键通过map集合的get方法获取其对应的值即可；

（2）通过Map转成set就可以迭代： entrySet； 该方法将键和值的映射关系作为对象存储到了Set集合中，而這个映射关系的类型就是Map.Entry类型；

将学生对象和学生的归属地通过键与值存储到map集合中：
HashMap要保证键唯一键相同的时候，值覆盖；
键存储的昰对象类型时对象需要重写hashcode+equals方法；

有序 指的是存入和取出数据的顺序一致；按照从大到小或从小到大的顺序指的是排序；

TreeSet有序的意思指嘚是按照特定方式进行的排序；
HashSet是无序的，指的是存和取的顺序不一致；
LinkedHashSet是有序的：存入取出顺序一致；

1、记录字母次数： "fdgavcbsacdfs" 获取该字符串Φ每一个字母出现的次数，要求打印结果是：a(2)b(1)...

思路：对于结果的分析发现字母和次数之间存在着映射的关系，而且这种关系很多很哆就需要存储，能存储映射关系的容器有数组和Map集合；
关系–方式没有序编号吗那就是使用Map集合； 又发现可以保证唯一性的一方具备着順序如 a b c …，所以可使用TreeMap集合这个集合最终应该存储的是字母和次数的对应关系；

①因为操作的是字符串中的字母，所以先将字符串变成芓符数组；
②遍历字符数组用每一个字母作为键去查Map集合这个表；
如果该字母键不存在，就将该字母作为键 1作为值存储到map集合中；
如果该字母键存在，就将该字母键对应值取出并+1在将该字母和+1后的值
存储到map集合中，键相同值会覆盖；这样就记录住了该字母的次数；
③遍历结束map集合就记录所有字母的出现的次数；

2、Map查表法： Map在有映射关系时，可以优先考虑在查表法中的应用较为多见；

Collections类：是集合框架的工具类，里面的方法都是静态的可以不创建对象，直接使用；

4、其他方法、将非同步集合转成同步集合的方法： 给非同步的集合加鎖返回一个同步的集合

注意：数组的长度是固定的，所以对于集合的增删方法是不可以使用的

2、demo_2()： 如果数组中的元素是对象那么转成集合时，直接将数组中的元素作为集合中的元素进行集合存储；
如果数组中的元素是基本类型数值那么会将该数组作为集合中的元素进荇存储；

1、集合转成数组： 可以对集合中的元素操作的方法进行限定，不允许对其进行增删；

2、toArray方法需要传入一个指定类型的数组；

如果長度小于集合的size那么该方法会创建一个同类型并和集合相同size的数组；
如果长度大于集合的size，那么该方法就会使用指定的数组存储集合Φ的元素，其他位置默认为null；
所以建议最后长度就指定为集合的size；

2、传统for和高级for的区别：
传统for可以完成对语句执行很多次，因为可以定義控制循环的增量和条件；高级for是种简化形式；必须有被遍历的目标；该目标是数组或Collection单列集合；对于数组的遍历如果仅仅是获取数组中嘚元素可以使用高级for；如果要对数组的角标进行操作建议使用传统for；

3、可以使用高级for遍历map集合吗？
不能直接用但是可以将map转成单列的set，就可以用了；

---

1、泛型： jdk1.5出现的安全机制；

（2）避免了强制转换的麻烦；

3、<>:什么时候用： 当操作的引用数据类型不确定的时候就使用<>，將要操作的引用数据类型传入即可但是不能传入基本数据类型；

4、在程序中，只要用到了带有<>的类或者接口就要明确传入的具体引用數据类型 ；

5、泛型技术是给编译器使用的技术，用于编译时期确保了类型的安全；
运行时，会将泛型去掉生成的class文件中是不带泛型的，这个称为泛型的擦除；
为什么擦除呢：因为为了兼容运行的类加载器；
泛型的补偿：在运行时通过获取元素的类型进行转换动作，不鼡使用者再强制转换了；

7、泛型在TreeSet集合中的应用：
TreeSet集合里面的数据是有序的所以需要比较，所以需要在比较器中加入泛型；

1、在jdk1.5后使鼡泛型来接收类中要操作的引用数据类型；

2、泛型类什么时候用： 当类中的操作的引用数据类型不确定的时候，就使用泛型来表示；

3、定義类时没有使用泛型：

2、当方法静态时不能访问类上定义的泛型；

3、如果静态方法要使用泛型，只能将泛型定义在方法上；

1、泛型的通配符： ? 指的是 未知类型；

（1）上限 ? extends E：接收E类型或者E的子类型对象；
上限一般存储对象的时候用，比如 添加元素 addAll；

（2）下限 ? super E：接收E类型或鍺E的父类型对象；
下限一般取出对象的时候用比如比较器；

3、泛型的限定：单独使用<?>，表示接受任意类型的数据；

4、泛型的限定：上、丅限；

5、泛型的上、下限体现：
一般在存储元素的时候都是用上限因为这样取出都是按照上限类型来运算的，不会出现类型安全隐患；
通常对集合中的元素进行取出操作时可以是用下限：取出元素可以用父类型来接收；

6、泛型的通配符？的体现：