软件:一系列按照特定顺序组织的计算及数据和指令的集合
系统软件 应用软件
应用程序=算法+数据结构
机器语言 汇编语言 高级语言
1996 SUN发布JDK1.0
C/S (c客户端) B/S
类 对象 继承 封装 多态
计算机底层都以补码来存储数据
第一章:初识java
oop(面向对象
)
1.java语言特点
健壮性:去除了C语言中的指针 自动的垃圾回收机制(仍会出现内存溢出内存泄漏)
跨平台性:一次编译到处运行
半编译半解释性:实时编译
标识符:数字字母下划线美元符号
数字不能开头,不能包含空格,区分大小写
遇关键字可用下划线串联
包名:小写
类,接口:大驼峰法
变量名，方法名:小驼峰
常亮名:XXX_YYY_ZZZ
关键字:已经定义过的单词
保留字:还没定义,系统预留出来的单词
第二章:变量
1.基本数据类型:
1.1整数类型
byte-----(1字节=8bit -128~127)
short----(2字节)
int-------(4字节,默认类型)
long-----(8字节.声明以L/l结尾不加默认int)
1.2小数类型
float-----(4字节,精确到7位,尾部加f/F单精度)
double--(8字节,双精度,默认类型)
1.3字符类型
char-----(一个字符2字节)
char a = 97 A = 65
1.4布尔类型
boolean-(true,false)
注:char byte short 在运算时会默认转换成int
将double类型转化精度减小
2.引用数据类型:
String
3.进制
二进制:0~1
八进制:0~7
十进制:0~9
十六进制:0~9 10~a 11~b 12~c 13~d 14~e 15~f
4.类型转换:
自动转换: 小转大
强制类型转换: 大转小 ,易出现数据精度缺失
int x = 100;
byte y= (byte)x;
5.运算符:
取余 : % 取余结果看%前的正负号
自增 : ++ ,++x前自增 x++后自增
自减 : -- , -- x前自减 x -- 后自减
r1 中 : x1=3 (x1++ +)=4
*拼接 : (1+2+"1+2"+1+2) = "31+212"
6.赋值运算符 :
x+=10 等同于 x=x+10
-= *= /= %= != ==
7.与(且) 或(或者 ) 非(不是) :
真&&真 == 真 真||假 == 真 非真 == 假 (!)
短路现象:
&& : 第一个表达式为假 结果为假 第二个被短路
|| : 第一个表达式为真 结果为真 ~
按位% 按位| 不会短路
8.三目运算符 : A>B?a:b
9.优先级 :
第三章 ：流程控制语句
1.条件语句
1.1 ： if语句
1. if
2. if.....else
3. if.....else if..... 如果满足第一个if条件则停止
1.2 ： switch语句
2.循环语句：
2.1 : while 先判断再循环 死循环while（true）
2.2：do...while 先循环再判断
2.3：for 死循环：删除条件
2.4：for...each
语法:for(1 2 : 3){代码块}
1是遍历后得到的数据的类型
2是遍历起的数据名 、
3是要遍历的数据
for(Integer i : a) {
System.out.print(i);
}
注：可以使用debug模式进入循环中
3、循环中断
break：终止语句块执行，并退出循环
continu：只跳出被循环，继续执行下一次循环
return ：结束整个方法
4、数据类型：
1、基本数据类型
存储的是数据
2、引用数据类型
存储的是内存地址
2.1、数组
2.2、类
2.3、接口
第四章、数组
1、数组：可以看成是多个相同数据类型的组合，实现 对这些数据的统一管理
注：数组长度确后就不能更改
引用数据类型
数组的异常：存储超出（数组越界异常）
java.lang.ArrayIndexOutOfBoundsException
运行时异常：
编译时异常：在java文件---编译---class文件时报错
空指针异常：
冒泡排序：
工具类：
Arrays: sort排序
copyof复制
随机数：1~10
Random rd = new Random();
int x = rd.nextInt(10)+1;
【10,99】随机两位数
公式：(b-a+1)+a
(int)(Math.random( )*(99 - 10 +1） + 10
第五章、方法
main：程序的入口，主方法
方法不能嵌套
static 静态的 可直接调用
void 方法返回值 无返回值
方法的整体结构：
[访问控制符][修饰符] 返回值类型 方法名（形参）{
方法体
}
分类：有参方法：say（String name）
无参方法：say（ ）
有返回值：int say（ ）{ return 10}
无返回值：void say（ ）
方法的重载：在一个类中允许同时存在一个以上同名的方法的现象叫做重载
条件：形参列表不同就行，返回值可不同
1、方法的参数的个数不同就可以
say（int x）say (int x,int y)
2、个数相同，类型不同也可以
say (int x) say (Sring name)
注、say (String name1,int name2)
say (int name1, Strng name2) 也可以
方法在被调用时才会执行
return：只能返回一次，但return可以写多个，结束方法
必须与方发声明中的返回值类型匹配
普通方法被对象调用
静态方法被类调用也被对象调用
第六章：面向对象
面向对象：注重结果
1.将所有事情/业务交给不同的对象去完成
2.万物皆对象
面向过程：注重过程/步骤
2.注重过程每一步都按部就班的去操作
主要：类的定义和对象的使用是java语言程序设计的核心
对象是通过类去创造的
概念：把相似的对象 划归一个类定义了通用的属性与方法
总结：类是对象的模板
成员变量：定义在类中（全局变量）
局部变量：定义在方法中
对象：实际存在的某类事物的个体，也称实际例
总结：对象的创建也被称为实例化类
构造方法：为属性赋值用，没有返回值，名与类名一致
创建对象用
注：1.如没写，类class中系统默认追加空参构造器
2. 如果定义了构造器那么系统不会追加
3.构造器在类的实例化是就被调用了
4.一般会默认追加一个空构造
5.类中可创建多个构造器
特点: 1.没有返回值类型
2.名与类名一致
3.不能在方法中用return返回一个值
4.一般访问权限为public
普通方法和构造方法：
1.普通方法：完成业务 构造方法：类的实例化
2.有无返回类型，值
匿名对象：一次性对象，使用完后就变为垃圾
垃圾回收机制：
范围：仅适用于堆内存 栈不需要清理 先进后出
什么时候会变成垃圾?
1.匿名对象使用完后
2.Student s1 = new Student(1001,张三,男,沈阳科技 学院);
s1 = null;
Student s1 = new Student(1001,张三,男,沈阳科技学院);
s1 = new Student(1001,李四,男,沈阳科技 学院);
张三变成垃圾
3.超出生命周期 前99次变为
for(int i = 0;i<100;i++){
person p = new person( );
}
this关键字：当前 代表本类对象
1、引用实例（本类）变量：
当方法中的参数与当前类的成员变量有相同名字时局部变量优先，成员变量被隐藏。
应用情况：
1、方法中变量与属性重名时
2、在一个构造方法中调用重载的其他构造方法
this( )只能在构造器中使用且必须放在第一行
3、也可在普通方法中使用：返回当前对象的引用
第七章：面向对象高级特性
1、封装
2、继承
3、多态
封装：封装就是信息的隐藏,隐藏对象的实现细节，不让用户看到，是将东西包装在一起，然后以新的完整形式呈现出来。
1、私有化属性
2、提供公有的方法存取属性
3、通过toString方法将类存储的地址里的数据转成 String 类型
优点：
1、让使用者只能通过事先定制好的方法来访问数据，可 以方便地加入控制逻辑,限制对属性的不合理操作
2、便于修改,增强代码的可维护性
3、可进行数据检查
继承：（类的扩展）
定义：继承是从父类（已有类）中派生出新的子类，新的子类能拥有父类的属性和方法，并能扩展自己新的属性和方法
person人类(父类)
Student学生类(子类) worker 工人类(子类) Dog(狗类）无法继承
发生继承的条件:
什么情况下两个类可以发生继承关系?
子类可以在任何时候去代替父类进行操作
子类继承关键字extends 单词扩展
java 中类的继承其实就是类的扩展
特点：
1.子类继承父类的所有属性和方法，同时也可以增加自己的属性和方法。
2.Java中只能单继承，也就是说每个类只能有一个直接父类
3.一个父类可以有多个子类
子类实例化过程：
1、 子类实例化时先实例化其父类，然后实例化子类。
2、要先调用父类的构造方法，父类构造方法运行完毕， 才调用子类的构造方法。
3、如果因父类没有空构造产生报错的情况
3.1可以为父类添加一个空构造
3.2使用super
方法的重写：@override
一定存在继承或者实现的关系
方法的重写与重载的区别：
1、重写存在继承或者实现的关系，重载不需
2、重写改变方法体，重载改变形参列表
相同点：但是方法名都不变
使编码更高效
易维护
代码的重用
super关键字：调用父类）构造器
注：只能出现在子类的构造方法中，且必须是第一行super（）中的参数，决定了调用父类哪个构造方法
如果子类构造方法中没有出现super，那么编译器会默认加上super（），即调用父类的空构造方法，如果父类没有空构造方法，编译器提示错误。
java 包的作用：
关键字：package
在类文件的最前面
每个源文件只能声明一个包
若无package语句则默认为无名包（default package）
1.包允许将类组合成较小的单元、
2.有助于避免命名冲突
3.包允许在更广的范围内保护类、数据和方法
4.包可以是类、接口和子包的集合
java中常用的jar包：
1.基础核心包：
java.lang: Java编程语言的基本类库
java.sql:提供了访问和处理来自于Java标准数据源(通 常是一个关系型数据库）数据的类
java.util:包括集合类、时间处理模式、日期时间工具等各类常用工具包
java.io:提供了通过数据流、对象序列以及文件系统实现的系统输入、输出、拷贝文件、生成word，ppt，pdf
java.net提供了用于实现网络通讯应用的所有类
javax.swing:提供了一系列轻量级的用户界面组件，是 目前Java用户界面常用的包
导包关键字: import
例：import java.util.Arrays;
import java.util.*; 导所有包 *
java.lang包不需要导入，系统自动导入
注：
1．只能引入其他包中的public类;
2.一个类可以使用多个import语句引入其他包;
3. import语句是在package语句(如果有）后的第一条非注释语句。
访问权限修饰：
protected 当发生继承条件是与public范围一致
不继承与default范围
方法的覆盖（方法的重写）：
覆盖的方法（子类）与被覆盖的方法（父类）的特点：
1．相同的方法名
2．相同的参数列表（参数数量、参数类型、参数顺序都要相同)
3．相同的返回值类型
4．子类覆盖方法的访问权限要不小于父类中被覆盖方法的访问权限
频繁出现的错误
1．括号问题成对出现{ } 作用域{ } 变量不能同名
2．主方法内不能定义其他方法只能调用方法
3. 不细心
4 运行程序找主方法
5 先理清答题思路 再去编写 *看完题
上溯造型：会用在多态的特性中
即向上转型：是指子类转换为父类,这是自动转换
Animal an = new Cat ( ) ;
向上转型损失了子类新扩展的属性和方法，仅可以使用从父类中继承的属性和方法
下溯造型：
即向下转型(Downcasting)称之为强制转换，是将父类对象显式的转换成子类类型。
*曾经向上转换过的对象，才能再向下转换。对象不允许不经过上溯造型而直接下溯造型。对象不能直接下塑造型
Person p父类student s 子类 p----->s
错误的：没向上转换，不能直接下溯造型
先向上转
Animal a = new Cat ( ) ;
再向下
Cat a = (Cat) a ;
Instanceof （实例）:判断这个类对象是否属于某个类
猫不能代表动物，动物包括猫
Vehicle v = new Vehicle();
system.out.println(v instanceof Vehicle);
//判断v对象是否属于vehicle类的实例
Instanceof 类对象与类毫无关系 ---- 报错
类对象与父类 -------True
类对象与本类 -------True
父类对象与子类 -------False
猫对象与狗类 都继承animal ----报错
多态︰不同的对象对同一行为作出的不同响应
情况一:没有继承实现关系方法的重载（编译时的多态性）
sort(数组1)
sort(数字1,数字2,数字3)
sort(对象数组Student[] stu)
(覆盖）
情况二:存在继承实现关系上塑造性（运行时的多态性）
多态的条件：
要有继承，或实现。
要有重写
父类引用指向子类对象 （上溯造型）
效果: 一旦满足以上3个条件，当调用父类中被重写的方法后，运行时创建的是哪个子类的对象，就调用该子类中重写的那个方法。
多态的优点:
简化代码
改善代码的组织性和可读性
易于扩展
静态属性：
static可以修饰的元素包括:属性、方法和代码块。需要注意的问题是static只能修饰类成员，不能修饰局部变量和构造方法
属性：静态变量 public static String name;
特点：用static修饰的成员变量，它们在类被载入时创建，只要类存在，static变量就存在。
访问静态属性不需要进行类的实例化不需要创建对象去访问 直接----类名.属性
如果为静态属性，只在空间中存在一个被所有对象所共享
public static string city="沈阳市";
public static String city2="沈阳市";
只有一个"沈阳市"被共享
无法在静态方法中引用非静态成员(包括方法和变量)
之所以会报Cannot make a static reference to the non-static field email email---属性
这个错，是因为在静态方法中，不能直接访问非静态成员(包括方法和变量)。
因为，非静态的变量是依赖于对象存在的，对象必须实例化之后，它的变量才会在内存中存在。
因此，这个东西解决起来特别简单，第一种，可以把变量改成静态的。第二种，先实例化对象，然后使用对象名.变量名来调用即可
方法：加在返回值类型前 public static void Test(){ }
静态代码块：static { }
注：
1.静态方法里只能直接访问静态成员，而不能直接访问类中的非静态成员。静态方法里的属性局部变量都是静态的不用再static
2.静态方法中不能使用this、super关键字
3
.静态方法不能被非静态方法覆盖（只能改变方法体），static不能修饰构造方法
static的应用
单例模式：单例模式(singleton）是保证一个类仅有一个实例，并提供一个访问它的全局访问点
单例模式：
1.私有化构造器
2.提供一个自身静态私有的成员变量
3.提供公有的方法去实例化对象
效果:
1．某个类只能有一个实例只有一个内存地址不浪费资源
2. 它必须自行创建这个实例
final关键字:（修饰关键字）出现位置与static一样
修饰属性：使用final修饰的变量(属性和局部变量)不能被重新赋值，在声明时赋值，或在构系统造方法中赋值，不会对final属性默认的赋初始值。
修饰方法：使用final修饰的方法不能在子类中被覆盖(不能被重写)，即不能修改。
修饰类：final修饰的类不能被继承，但是他可以继承别的类
final 变量所有字母大写、单词之间用下划线。
抽象类：
1.抽象方法：使用abstract修饰的方法叫抽象方法
2.如果一个类有抽象方法此类一定是抽象类
3.修饰抽象类的修饰符有public和默认修饰符两种;
4.抽象类中可以有抽象方法，也可以有非抽象的方法;
5.抽象方法是无方法体的方法。必须被重写
6.抽象方法只有被重写才有意义
7.抽象类可以继承抽象类不用必须重写
总结：抽象类不能被实例化，必须被继承，默认没有构造器，可以加
子类继承了抽象类以后,要么还是一个抽象类,要么就把父类的所有抽象方法都重写
abstract 修饰类/方法
抽象方法使用abstract修饰的方法叫抽象方法
如果一个类有抽象方法此类一定是抽象类
/*本类用作抽象类构造函数测试*/
/*抽象类是否有构造方法？有
* 既然抽象类不能实例化，
为什么要有构造方法呢？
* 不是为了自己使用，
而是为了子类创建对象时使用super(); */
抽象方法要求子类继承后必须重写。
那么，abstract关键字不可以和哪些关键字一起使用呢？以下关键字，在抽象类中。用是可以用的，只是没有意义了。
1.private：被私有化后，子类无法重写，与abstract相违背。
2.static：静态优先于对象存在，存在加载顺序问题。
3.final：被final修饰后，无法重写，与abstract相违背。
接口（interface）：不是类（class）
1.修饰接口的修饰符有public和默认修饰符两种;
一般为public
2.接口可以是多继承，接口只能继承接口，不能继承类;
3.属性必须是常量(有初值)，方法必须是抽象的(无方法体)。
接口中默认 public abstract 可不写
接口----类 关系 ： 实现
implements
implements 工具，执行
类可以去实现接口 类可以多实现接口
类可以去继承类 类只能单继承
接口解决了类不能多继承的缺点，类可以多实现
接口可以多继承
注：实现接口的类称为此接口的实现类，接口可以接受所有它的实现类对象
总结：四问
接口是什么？
接口是一种用于描述类对外提供功能规范的、能够多继承的、特殊的抽象类
接口能做什么？
能够代替类去实现多继承的作用， 接口多实现
接口怎么用？
通过类去实现，使用class demo implements+接口名
为什么用接口？
为解决类继承的局限性
接口 ------- 类
1、接口与接口 ---------可以继承（多继承）extends
2、类与类 ---------可以继承（单继承）extends
3、类与接口 --- -----可以实现（多实现）implements
4、类既可以实现接口也可继承父类extends implements 可同时出现
异常：
异常是程序中的一些错误，但并不是所有的错误都是异常有些异常是可以处理的。
1.语法错误：这种错误在编译程序时就会发现
2.逻辑错误：这种错误很少在编写程序时被轻易地发现，因为这种错误不是语法错误，所以编译器无法提示相应的错误信息。
3.运行时错误：有些程序虽然编译通过了，但是在运行过程中却出现了问题而导致程序异常终止，出现了运行时的错误
1. java.lang.ArithmeticException 算术异常
异常的异常树
Object类：java中没有父类的类，所有对象的总类
Throwable 类： 是Java语言中所有错误和异常的总类
Eror类：特指应用程序在运行期间发生的严重错误。如:虚拟机内存用尽、堆栈溢出等等。一般情况下这种错误都是灾难性的，所以没有必要使用异常处理机制处理Error。
Exception ：程序中出现异常的总类，有很多不同的子类
每一种子类就是一种错误
RuntimeExcption: 运行时异常
IOException ：编译时异常（代码下的红线）
Object 总类 （| 继承）
|
Throwable 错误总类
| |
Error 错误 Exception 异常
| |
RuntimeExcption IOException
try{
}catch{
}
try: 捕获
catch：处理
处理异常的方式：
1.自行处理：可能引发异常的语句封入在try 块内，而处理异常的相应语句则封入在 catch 块内。
2.回避异常：在方法声明中包含throws子句，通知潜在调用者，该方法可能会出现异常，但没有处理这种异常，必须由调用者处理。
finally 子句：
finally语句放在try ..catch语句后，fianlly语句中的代码块不管异常是否被捕获总是要执行
注：当try或catch代码块中执行了System.exit(0)时，finally代码块中的内容不被执行
System.exit(0)：强制退出虚拟机
自定义异常：
throw
throw
new
Exception();
1. catch子句的捕获范围，限制于与其匹配的try子句，不能捕获其他try子句中的异常;
2．不能单独使用try子句，它必须和catch子句或finally子句结合使用,catch子句可以设置多个，finally子句只能
有一个;
3．有多重catch子句时，只能执行那个捕获到异常的子句，其余的catch子句不能执行;
4. try/catch/finally三个子句中变量的作用域独立而不能相互访问。如果要在三个子句中都可以访问，则需要将变量定义到这些子句的外面;
5．不要写过大的try子句，一个try子句中尽量不要存在太多的异常;
6.一个方法中如果有发生异常的可能，则可以进行捕获处理，也可以声明由调用者来处理;
7. throw语句后不允许有其他语句，因为这些语句没有机会执行;
8．不能利用异常处理来进行程序的分支处理，它只是处理非正常情况的一种机制。
第九章：工具类
java API：应用程序接口
就是JDK提供的各种功能的java类
Object类：所有类的超类（父类）
object是Java语言中唯一一个没有父类的类。
public boolean equals (Object obj):
比较两个对象引用的值是否相等（比较地址）。
指出调用该方法的对象是否与obj对象相等。即地址是否相等。
使用equals时都会将其重写(覆盖)
如Sring类会重写，之后会比较两个字符串的值。
equals 没重写只能比较引用数据类型
== 引用数据类型与基本数据类型都能比较
"=="运算符:
〉比较基本数据类型:相当于算术等号
〉比较引用数据类型:比较引用的值，不能被覆盖。
通常情况，子类要重写equals()，改变它的含义。所以有的类中equals( )是比较地址，有的类中该方法就不比较地址，具体的，就看子类新定义的该方法的规定。看看包装类中的equals()方法在java中有个规定:如果equals()返回两个对象是相等的，那这两个对象上调用hashCode( )返回的整数必须相等。否则在使用Hash类型集合时就会产生错误。
public int hashCode() :
该方法返回对象的哈希码，哈希码是一个代表对象的十六进制整数，比作对象的身份证号。在程序运行期间，每次调用同一个对象的
hashCode()返回的哈希码必定相同，但是多次执行同一个程序，程序的一次执行和下一次执行期间同一个对象的哈希码不一定相同。实际上默认的哈希码是将对象的内存地址通过某种转换得到的，所以不同对象会有不同的哈希码。
public String toString():
返回类名@hashcode ;事实上返到这样的字符串没有什么实际的意义
一般子类都会覆盖该方法，让它返回有意义的文本。
包装类：
基本数据类型和引用数据类型的区别?
java 中: Everything is object. 万物皆对象
把基本数据类型包装成对象
优点：变为包装类后基本数据类型有了自己的属性和方法
基本数据类型：-----> 包装类
用户输入的信息都是字符串形式的数据
电话号码:"86779312"
年龄:"23"
id : "1001”
字符串<-------->包装类<------->数字
Integer
i = 10;
String
s1 = Integer.
toString(
i);
System.
out.println(
s1+1);
String
str =
"10";
int
x = Integer.
parseInt(
str);
System.
out.println(
x+1);
Integer i = 10;
Integer 和 int 可直接转
字符串类：string类是final类型的类。不能被继承
String
str1 =
"hello";
//常量池(方法区中）1.7堆 1.8 元空间
String
str2 =
new String(
"hello");
//在堆中
StringBuffer
sb =
new StringBuffer(
"good");
1.String：定长字符串
String对象对它的任何修改实际上是产生一个新的字符串
String类对象的内容一旦被初始化就不能再改变。
char[]
c = {
'h',
'e',
'l',
'l',
'o'};
String
s =
new String(
c,0,3);
//hel
byte[]
b = {76,111,118,101};
String
ss =
new String(
b);
System.
out.println(
ss);
//Love
string s1 ="hello";
String ss1 = "hello" ;
string ss2 = "hello" ;
String ss3 = "hello";
1、常量池中 hello 只创建一个被四个对象所指向
2、在程序的任何地方，相同的字符串字面常量都是同一个对象
3、strirg类重置了equals方法，用于比较两个字符串的内容是否相等
2.StringBuffer：可变字符串
StringBuffer :可以使用stringBuffer来对字符串的内容进行动态操作，不会产生额外的对象
append 加在末尾
insert 选定位置加入
System.
out
.println(Math.
round
(-10.5));//-10 <=0.5 舍
>0.5 为-11
日期类:
java.util.Date日期类︰表示指定的时间信息，可以精确到毫秒。
Lambda表达式
1.使用前提
必须是接口。接口中只能有一个抽象方法
2.使用格式
(数据类型参数名1,数据类型参数名2,...)->{方法体}
( ):代表的是要执行接口中对应的那个抽象方法。如果方法中有参数，那么就需要传递参数
->:固定格式。作用是将小括号中的参数传递给后面的大括号方法体中
{ }:代表的是实现接口中那个抽象方法后的方法体
使用Lambda表达式去调用一个有参数有返回值类型的方法
Lambda表达式的省略规则:
如果方法中只有一个参数，那么数据类型和小括号都可以省略如果方法中有多个参数,那么数据类型可以省略
如果大括号中Collection接口只有一行代码，那么大括号、return、分号都可以省略(三者必须一起省略)
第十章：集合
特点:如果想要对不定长的数据操作，可以使用集合.(数量不确定）
集合概述：
1、Java中集合类是用来存放对象的（包装类）
2、集合相当于一个容器，里面包容着一组对象——容器类
3、其中的每个对象作为集合的一个元素出现
4、Java API提供的集合类位于java.util包内
集合与数组：
1、数组也是容器，它是定长的，访问较快，但是数组不会自动扩充
2、数组可以包含基本数据类型或引用类型的对象，而集合中只能包含引用类型的对象
集合的继承树：
1、
List接口：
1、有序存储，允许重复
retainAll（）仅保留
Arraylist类
1、底层使用数组来实现有索引值而set没有
2、容量初始值为10
3、线性顺序存储，是一种线性表
它的特性和数组很接近
每次扩容：本次容量+本次容量 >>1 (约为1.5倍)
一、ArrayList的扩容机制1、
扩容的计算方式是向右位移，即: newSize = this.size +(this.size>>1)。向右位移，只有在当前值为偶数时，才是除以2;奇数时是抹去最后一位，也就是先减1，然后除以2;
2、扩容的上限:ArrayList的长度并不是没有限制的，它的默认最大长度值是，Integer...
ArrayList list = newArrayList<>(20);//容量20
ArrayList中特有的方法（了解即可):
ensureCapacity(int minCapacity)
如有必要，增加此 ArrayList 实例的容量，以确保它至少能够
容纳最小容量参数所指定的元素数
我们一般是使用ArrayList的构造函数指定初始容量trimToSize()
将此 ArrayList实例的容量调整为列表的当前大小。
LinkedList类
有序可重复
1、是数据结构中链表的java实现
特点：在插入删除时快
ArrayList
增删慢但
ArrayList
查询效率高
LinkedList中特有的方法(了解即可):
addFirst(E e)
将指定元素插入此列表的开头。
addLast(E e)
将指定元素添加到此列表的结尾。
getFirst()
返回此列表的第一个元素。
getLast()
返回此列表的最后一个元素。
removeFirst()
移除并返回此列表的第一个元素。
removeLast()
移除并返回此列表的最后一个元素。
栈:先进后出
push()
将元素添加到此集合的开头
pop()
删除集合的首元素并返回
队列:先进先出
offer将元素添加到此元素的末尾poll
删除集合的首元素并返回
descendingIterator()返回逆序的迭代器对象
Vector
Set接口（自带排序算法）：
1、无序存入，唯一
HashSet 类: Hash算法
comparetor :
int compare( T o1, T o2)
比较其两个参数的顺序。 返回负整数，零或正整数，因为第一个参数小于，等于或大于第二个参数。
TreeSet 类： 二叉树
2、Map接口
HashMap 类：
允许null值和键
默认容量16，每次扩容翻倍
newHashMap< >(32);//容量32
newHashMap<>(32,0.75f);// 0.75f 负载因子
new HashMap<>(hm3);//可以加入其他的map 对象
注：1、HashMap的一个实例有两个影响其性能的参数:初始容量和负载因子。
2、负载因子:负载因子是在容量自动增加之前允许哈希表得到满足的度量。默认0.75
0.75:作为一般规则，默认负载因子(0.75〉提供了时间和空间成本之间的良好折中。
Hashmap的扩容需要满足两个条件:当前数据存储的数量（即size())大小必须大于等于阈值;当前加入的数据是否发生了hash冲突。(1)、就是hashmap在存值的时候（默认大小为16，负载因子0.75，阈值12)，可能达到最后存满16个值的时候，再存入第17个值才会发生扩容现象，因为前16个值，每个值在底层数组中分别占据一个位置，并没有发生hash碰撞。
时间复杂度高：牺牲时间节省内存
空间复杂度高：牺牲内存节省时间
1、Map内存储的是键/值对这样以成对的对象组(可以把一组对象当成一个元素)，通过“键”对象来查询“值”对象
键 ：key 值 ：value 其中key是唯一的
2、Map是不同于collection的另外一种集合接口
3、Map中，key值是唯一的(不能重复)，而key对象是与value对象关联在一起的
遍历：
//将map集合转换为Entry类型的SET集合
Set<Entry<String, String>>
entrySet =
hm.entrySet();
for (Entry<String, String>
entry :
entrySet) {
System.
out.println(
entry.getKey()+
"="+
entry.getValue());
}
isEmpty();只要调用put（）方法存了就不是空
values()获取所有value
HashTable 类 :
HashMap与Hashtable的比较
Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现。
Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的。
HashMap.允许将null作为一个entry的key或者value，而Hashtable不允许用null。
TreeMap 类
HashMap与TreeMap的比较
HashMap基于哈希表实现。
TreeMap基于树实现。
HashMap可以通过调优初始容量和负载因子，优化HashMap空间的使用。TreeMap没有调优选项，因为该树总处于平衡状态王
HashMap性能优于TreeMap。
迭代器：
概念: Iterator对象称作迭代器，用来方便的实现对容器内的元素进行遍历操作。
特点: Iterator是为遍历而设计，能够从集合中取出元素和删除元素(remove()),但是没有添加元素的功能add()添加
元素的功能。
迭代器方法∶
next() :返回游标右边的元素并将游标移动到下一个位置获取迭代器指向的数据并且继续向下移动
hasnext():判断游标右边是否有元素
流程:先通过hasnext判断右边是否有元素如果有元素next()去获取数据，没有就停止next（）方法
Collections工具类：
copy（list l，list s）：
1、ArrayList声明时默认的元素个数是0，只有进行add（），remove（）操作时size（）的大小才有相应的变化。
2、进行集合复制时，一要声明目的集合的元素的个数，并且要等于或者大于源集合的元素的个数。
3、如果不声明或者小于源集合的元素个数，这样就会报错，报下标界的异常（java.lang.IndexOutOfBoundsException）。
// 声明一个目的集合，不规定集合中元素的个数
ArrayList<String> arrayList3 = new ArrayList<>();
//将String类型的空值添加到目的集合中
Collections.addAll(
arrayList3,new String[arrayList1.size()]);
泛型：
集合在使用上的问题：
集合中的add()方法接受的是一个0bject对象的参数，在获取集合中的对象时，必须进行造型（强制类型转换）操作。造型操作可能出现问题，一般在程序运行时才能发生，发现问题比较困难。
集合中泛型的使用：
1、在对象放入集合前，为其作个限制
2、在获取集合中的对象时，不用进行造型的操作
3、当有不同类型的对象添加到集合中的时候，编译时就能检查出错误
文件与流：
1、文件：
1. Java中的对文件的管理，通过java.io包中的File类实现
主要是针对文件或是目录路径名的管理
>文件的属性信息
>文件的检查
>文件的删除等
>不包括文件的访问王
流：程序中数据的流通（数据流）
1、数据流是一串连续不断的数据集合、kb,Mb,GB
2、在Java程序中，对于数据的输入/输出操作是以流(Stream)的方式进行的。
判断条件：
输入流：流入程序的
输出流：流出程序的
在java程序中，从输入流读取数据（读到内存中），而从输出流输出数据（从内存存储到文件或显示到屏幕上）
流的分类：
按流的方向不同
>输入流、输出流
按处理数据的单位不同
>字节流、字符流
按功能不同
>节点流(低级流)、处理流（高级流）
Java语言中，控制数据流的类都放在java.io包中
字节输入流：inputStream
字节输出流：outputStream
字符输入流：Reader 读取：输入
字节输入流：writer 写出：输出
fis1
.read(
b
)
b:数组
byte
[]
b
=
new
byte
[1024];
存满了返回1024，存完了返回-1
高级字节输入流BufferedInputStream
高级字节输出流BufferedOutputStream
对象的序列化
通过使用objectInputStream和objectOutputStream类保存和读取对象的机制叫做序列化机制
1. ObjectInputStream
2. ObjectoutputStream
什么是对象序列化:
Serializable
序列化接口，标识接口
Serializable接口没有定义任何属性或方法。它只用来表示一个类可以被序列化。如果一个类可以序列化，它的所有子类都可以序列化
对象(object)序列化是指将对象转换为字节序列的过程
反序列化：ObjectInputStream 流 readObject
字节输出流:FileoutputStream
特点∶
输出流写出数据,关联文件的时候，如果文件不存在，则自动创建
输出流写出数据，如果关联的文件已经存在，会将原本内容清空掉之后，再次写入
如果不想清空掉原有内容，就可以在构造方法的位置，加入true的开关即可
字符流的作用∶
操作纯文本文件的时候,可以解决中文乱码问题
问题:怎么解决的?
答:字符流底层实际上是通过(字节流＋编码表)的形式进行读取的
GBK ->一个中文占2个字节
UTF-8->一个中文占3个字节
会根据平舍默认编码表，决定一次读取几个字节，并在内存中转换为字符
问题︰如果文本中带有非中文字符，那么在读取过程中为什么没有乱码?
答:字符流底层有一个判断，如果读取到的是中文字符，一次读取2个字节(GBK)
如果读取到的是非中文字符,那么就一次读取一个字节.
问题︰系统是怎么判断，当前读取到的字符是不是中文呢?
答:中文字符一般都是负数的字节，非中文字符都是正数.一般都是负数的字节，部分中文->第一个字节为负数，后面的字节有可能为正数
Filewriter ->字符输出流
注意∶
1.如果字符输出流没有调用close方法\flush方法的话，数据将不会写出到文件当中
2. close方法的主要功能是关闭流释放资源,同时也具有刷出数据的效果
close方法调用结束后，不能再调用write方法写出数据、
字符缓冲流
BufferedInputStream BufferedOutputStream
BufferedReader
readLine() ->一次读取一整行字符串 结束标记：null 不会读取到回车换行符
Bufferedwriter
newLine()->写出回车换行，但是此方法具有跨平台效果
问题:转换流的作用是什么?
转换流可以按照指定的编码表读写数据
InputStreamRreader :
字节流通向字符流的桥梁
InputStreamReader(InputStream in)
InputStreamReader( InputStream in, String charsetName)
多线程：
只要访问资源就是多线程
进程︰就是一个正在运行的应用程序，进程当中可以包含多条线程，但至少要有一条线程在执行.
一个Java程序运行之后，至少会开启一条主线程
线程∶程序的一条执行路径，多线程就是多条执行路径同时在执行(假象)
CPU切换很快
多线程实现的两种方式:
1.继承Thread类
2.实现Runnable接口
3.以上二者都需通过Thread类构造完成多线程
4.调用start（）方法激活线程对象
1、继承thread类 / 实现Runnable接口
2、重写run方法
3、在run方法中编写要执行的任务
4、创建线程对象
5、调用start方法开启线程。自动调用run方法 /
将Runnable实现类对象，作为资源传递给Thread类的有参构造，并调用start方法开启线程
new Thread(
线程对象
).start()
总结:只有调用了start方法，才算真正的开启了线程
如果只调用run方法，仅仅是对成员方法进行一次调用，并非是开启线程。
如何获取线程名字?
Thread类:
getName( );
Thread.currentThread().
getName( ) :获取到当前正在执行的线程对象的名字
如何给线程设置名字?
Thread类 :
setName(String name);
通过Thread类的构造方法，直接指定
new Thread(b,"线程B-->").start();
Callable :既能开启线程，又能能够得到线程的返回值结果
1．实现Callable接口，重写call方法
2．创建FutureTask对象，并将callable的实现类对象传入构造方法
3．创建Thread类对象，并将FutureTask传入构造方法当中，并调用start方法开启线程
调用get方法获取call方法的返回值
通过实现Runnable接口(或者Callable接口）相对于继承Thread类实现多线程来说，有如下显著的好处:
适合多个线程去处理同一个共享资源的情况。可以避免Java单继承带来的局限性。
继承Thread类：可以很方便的使用父类中的任何一个方法
说明:事实上，实际开发中大部分的多线程应用都会采用Runnable接口或者Callable接口的方式实现多线程。
t1
.setDaemon(
true
);设置为后台线程
isDaemon（）判断
计时等待：
Thread.sleep(1000...); 线程休眠
Thread.yield(); 线程让步
t1.join(); 线程插入 可设置参数 ti插入时间
在应用程序中，要对线程进行调度，最直接的方式就是设置线程的优先级。优先级越高的线程获得cpu执行的机会越大，而优先级越低的线程获得cPu执行的机会越小。
线程的优先级用1~10之间的整数来表示，数字越大优先级越高。
除了可以直接使用数字表示线程的优先级，还可以使用Thread类中提供的三个
静态常量表示线程的优先级。
t1.
setPriority(10);
t1.
setPriority
(Thread.Max_priority);
同步技术的应用场景∶
当一段线程的代码在执行过程中，我们希望CPU不要切换到其他线程进行工作，这时候就可以使用同步技术
同步代码块：
synchronized(锁对象){ //任意类型对象
}
任意类型对象︰多个线程的锁对象，必须是同一把锁
推荐使用万能锁︰类名.class ->字节码对象
同步方法：（不建议繁琐）
@Override
public void run() {
while (true) {
method();
}
}
public synchronized void method() {
}
从JDK 5开始，Java增加了一个功能更强大的Lock锁。Lock锁与
synchronized隐式锁在功能上基本相同，其最大的优势在于Lock锁可以让某个线程在持续获取同步锁失败后返回，不再继续等待，另外Lgck锁在使用时也更加灵活。
同步锁：
Lock lock = new Lock（）；
lock.lock（）；上锁
lock.unlock()；释放锁
死锁:定义:两个线程在运行时都在等待对方的锁，这样便造成了程序的停滞，这种现象称为死锁。
同步嵌套同步造成
避免死锁方式:
1、加锁顺序（线程按照一定的顺序加锁)
2、加锁时限（线程尝试获取锁的时侯加上一定的时限，超过时限则放弃对该锁
的请求，并释放自己占有的锁)
3、死锁检测
抢票系统：
多线程并发访问会发生错误，需要给资源加锁
synchronized
设计模式：
1、生产者与消费者 模式
案例：咖啡续杯
生产者：生产咖啡的店员，为咖啡续杯，续杯完毕后唤醒等待着
消费者：抢咖啡，谁抢到谁喝，唤醒店员续杯，抢咖啡
Thread：
wait( ) 等待 等待过程中释放锁
notifyyAll( ) 唤醒
sleep( ) 休眠 睡眠时不释放锁
join（ ）
注解
Annotation是从JDK5.0开始引入的新技术．
Annotation的作用:
不是程序本身,可以对程序作出解释.(这一点和注释(comment)没什么区别)
可以被其他程序(比如:编译器等)读取.
Annotation的格式:
注解是以"@注释名"在代码中存在的，还可以添加一些参数值﹐例如:@SuppressWarnings(value="unchecked")
Annotation在哪里使用?
可以附加在package , class , method , field等上面﹐相当于给他们添加了额外的辅助信息,我们可以通过反射机制编程实现对这些元数据的访问
元注解的作用就是负责注解其他注解， Java定义了4个标准的meta-annotation类型,他们被用来提供对其他annotation类型作说明.
这些类型和它们所支持的类在java.lang.annotation包中可以找到.(Target , @Retention ,@Documented , @Inherited )
Target:用于描述注解的使用范围(即:被描述的注解可以用在什么地方)
@Retention:表示需要在什么级别保存该注释信息﹐用于描述注解的生命周期
(SOURCE<CLASS< RUNTIME)
>@Document:说明该注解将被包含在javadoc中
@Inherited:说明子类可以继承父类中的该注解
反射
Reflection(反射）是Java被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection APl取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。
Class c= Class.forName(java.lang.String")
加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为:反射
优点:
可以实现动态创建对象和编译，体现出很大的灵活性
缺点:
对性能有影响。使用反射基本上是一种解释操作，我们可以告诉JVM，我们希望做什么并且它满足我们的要求。这类操作总是慢于直接执行相同的操作。
java.lang.Class :代表一个类
java.lang.reflect.Method:代表类的方法
java.lang.reflect.Field:代表类的成员变量
java.lang.reflect.Constructor:代表类的构造器
若已知具体的类，通过类的class属性获取，该方法最为安全可靠，程序性能最高。
Class clazz= Person.class;
已知某个类的实例，调用该实例的getClass()方法获取Class对象
Class clazz = person.getClass();
已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法
forName()获取，可能抛出ClassNotFoundException
Class clazz= Class.forName("demo01.Student");
内置基本数据类型可以直接用类名.Type
还可以利用ClassLoader我们之后讲解
哪些类型可以有Class对象?
class:外部类，成员(成员内部类，静态内部类)，局部内部类，匿名内部类
interface:接口
[]:数组 一维和二维
enum:枚举
annotation:注解@interface
primitive type:基本数据类型
void：
private
static
<
E
>
void
print
(
E
[
]
e
)
{
for
(
E
d
:
e
)
{
System
.
out
.
println
(
d
)
;
}
}
java中对象和对象引用的区别
1.何谓对象？
在Java中有一句比较流行的话，叫做“万物皆对象”，这是Java语言设计之初的理念之一。要理解什么是对象，需要跟类一起结合起来理解。下面这段话引自《Java编程思想》中的一段原话：
“按照通俗的说法，每个对象都是某个类（class）的一个实例（instance），这里，‘类’就是‘类型’的同义词。”
从这一句话就可以理解到对象的本质，简而言之，它就是类的实例，比如所有
的人统称为“人类”，这里的“人类”就是一个类（物种的一种类型），而具体到每个人，比如张三这个人，它就是对象，就是“人类”的实例。
2.何谓对象引用？
我们先看一段话：
“每种编程语言都有自己的数据处
理方式。有些时候，程序员必须注意将要处理的数据是什么类型。你是直接操纵元素，还是用某种基于特殊语法的间接表示（例如C/C++里的指针）来操作对象。所有这些在 Ja
va 里都得到了简化，一切都被视为对象。因此，我们可采用一种统一的语法。尽管将一切都“看作”对象，但操纵的标识符实际是指向一个对象的“引用”（reference）。”
这段话来自于《Java编程思想》，很显然，从这段话可以看出对象和对象引用不是一回事，是两个完全不同的概念。举个例子，我们通常会用下面这一行代码来创建一个对象：
Person person = new Person("张三");
有人会说，这里的person是一个对象，是Person类的一个实例。
也有人会说，这里的person并不是真正的对象，而是指向所创建的对象的引用。
到底哪种说法是对的？我们先不急着纠结哪种说法是对的，再看两行代码：
Person person;
person = new Person("张三");
这两行代码实现的功能和上面的一行代码是完全一样的。大家都知道，在Java中new是用来在堆上创建对象用的，如果person是一个对
象的话，那么第二行为何还
要通过new来创建对象呢？
由此可见，person并不是所创建
的对象，是什么？上面的一段话说的很清楚，“操纵的标识符实际是指向一个对象的引用”，也就是说person是一个引用，是指向一个可以指向Person类的对象的引用
。真正创建对象的语句是右边的new Person("张三");
Annotation是从JDK5.0开始引入的新技术．
Annotation的作用:
不是程序本身，可以对程序作出解释.(这一点和注释(comment)没什么区别)
可以被其他程序(比如:编译器等)读取.
Annotation的格式:
注解是以"@注释名"在代码中存在的,还可以添加一些参数值﹐例如:@SuppressWarnings(value="unchecked")
Annotation在哪里使用?
>可以附加在package , class , method , field等上面﹐相当于给他们添加了额外的辅助信息,我们可以通过反射机制编程实现对这些元数据的访问
@Override:定义在java.lang.Override 中,此注释只适用于修辞方法﹐表示一个方法声明打算b
重写超类中的另一个方法声明.
@Deprecated:定义在java.lang.Deprecated中,此注释可以用于修辞方法﹐属性﹐类﹐表示
不鼓励程序员使用这样的元素﹐通常是因为它很危险或者存在更好的选择．
@suppressWarnings:
（镇压警告）定义在java.lang.SuppressWarnings中,用来抑制编译时的警告信息.与前两个注释有所不同,你需要添加一个参数才能正确使用,这些参数都是已经定义好了的，我们选择性的使用就好了﹒
@SuppressWarnings("all")
@SuppressWarnings("unchecked")
@SuppressWarnings(value={"unchecked" , "deprecation"})
元注解的作用就是负责
注解其他注解，Java定义了4个标准的meta-annotation类型,他们被用来提供对其他annotation类型作说明.
这些类型和它们所支持的类在java.lang.annotation包中可以找到.( @Target , @Retention ,Documented , @lnherited )
Target:用于描述注解的使用范围(即:被描述的注解可以用在什么地方)
@Retention:表示需要在什么级别保存该注释信息﹐用于描述注解的生命周期
(SOURCE< CLASS< RUNTIME)
@Document:说明该注解将被包含在javadoc中
@Inherited:说明子类可以继承父类中的该注解