java概述：
一：java体系
1、javaSE（Java Platform, Standard Edition），标准版，各应用平台的基础，桌面开发和低端商务应用的解决方案。
--Java SE是基于JDK和JRE的，包括用于开发Java Web服务的类库，同时，Java SE为Java EE和Java ME提供了基础。
2、javaEE（Java Platform，Enterprise Edition），企业版，以企业为环境而开发应用程序的解决方案。
--Java EE 是在 Java SE 的基础上构建的，能够帮助我们开发和部署可移植、健壮、可伸缩且安全的服务器端 Java应用程序。
3、javaME（Java Platform，Micro Edition），微型版，致力于消费产品和嵌入式设备的最佳方案。
--是为机顶盒、移动电话和PDA之类嵌入式消费电子设备提供的Java语言平台，包括虚拟机和一系列标准化的Java API。二：Java的特性
1、一种面向对象的编程语言。
2、一种与平台无关的语言（根据JVM实现的）。
3、一种健壮性语言。
4、具有较高的安全性。三：JDK、JRE与JVM
1、JVM:虚拟机，java虚拟机实际上只是一层接口，一层Java程序和操作系统通讯的接口。.java源文件经编译生成.class字节码文件，
再由java虚拟机加载并运行.class文件，若将.class文件看成一个软件，那么java虚拟机就是运行这个软件的操作系统。
2、JRE：java运行环境，包括：JVM+系统类库，它是运行Java程序的最小单位。
3、JDK：java开发工具包，包括：JRE+编译运行指令，它是开发Java程序的最小单位。
注：安装了JDK后，JRE已经存在无需额外安装。
四：Java程序开发与运行机制
1、编写源程序，java源代码文件。
2、编译源程序，编译器编译编译成.java字节码文件。
3、运行时，Java虚拟机（JVM）将.Java源文件编译成可运行的.class文件。
4、Java环境变量的配置：
1）下载安装JDK,进入电脑的高级系统设置，找到环境变量；
2）新建JAVA_HOME ：%安装路径%\Java\jdk（安装JDK路径）；
3）path 后追加两个变量,即 : %JAVA_HOME%\bin 与%JAVA_HOME%\jre\bin;
4) 新建CLASSPATH系统变量，CLASSPATH= .;%JAVA_HOME%\lib;%JAVA_HOME%\lib\tools.jar （注意：一定要写 ".;",标点全部为英文状态下）。
五：Java中的一些规则
1、应用
1) 一个源文件中只能有一个public修饰的类，其他类个数不限。
2) 一个源文件有n个类时，编译结果的class文件就有n个。
3) 源文件的名字必须和public修饰的类名相同。
4) Java语言中单词拼写大小写严格区分。
5) main方法为入口方法。
6) 每一句以分号(;)结束。
2、注释
1) 单行注释//
2) 多行注释/* */
3) java文档注释/** */
3、标识符
1) 命名规则：
由字母、下划线、数字和美元符号组成；
不能以数字开头；
区分大小写；
不能是关键字和保留字（goto、const）；
长度一般不超过15个字符。
2) 驼峰式命名：
包名：全部小写。
类名：每个单词首字母都大写。--大驼峰
方法名、参数名、变量名：第一单词首字母小写，后面其他单词首字母大写。--小驼峰
六：Java语言基础
1、关键字：Java中赋予了特殊含义的单词
访问控制 ：public、private、protected
类,方法和变量修饰符 : abstract class extends final implements interface native new
static strictfp synchronized transient volatile
程序控制 : break continue return do while if else for instanceof switch case default
异常处理 : try cathc throw throws
包相关 : import package
基本类型 : boolean byte char double float int long short null true false
变量引用 : super this void
保留字 : goto const
2、数据类型
1) 基本数据类型：byte、short、int、long、float、double、char、boolean
| 数据类型 |
boolean |
byte |
char |
short |
int |
long |
float |
double |
void |
| 二进制位数 |
1 |
8 |
16 |
16 |
32 |
64 |
32 |
64 |
-- |
| 封装类 |
Boolean |
Byte |
Character |
Short |
Integer |
Long |
Float |
Double |
Void |
2) 引用数据类型: 字符串 String、数组 []、类 class、接口 interface、枚举 enum。
3) a.数据类型划分：
基本类型变量：数据的值
引用类型变量：数据的地址
b.声明的位置划分： 局部变量 全局变量
区别：
1、默认值：局部变量没有默认值，使用前必须初始化。
全局变量有默认值，默认为0，不必须初始化。
2、声明位置：局部变量在方法内。 全局变量在方法外类内。
3、作用位置：局部变量只能在自己声明的方法里。全局变量在整个类中。
3、自动类型转换与强制类型转换
自动类型转换：从低级别到高级别，系统自动转的；
强制类型转换：把一个高级别的数赋给一个比该数的级别低的变量；
4、常量与变量
常量：在程序中，不会变化的数据。
变量：其实就是内存中的一个存储空间，用于存储常量数据。
作用：方便于运算。因为有些数据不确定。所以确定该数据的名词和存储空间。
特点：变量空间可以重复使用。
变量的作用域：作用域从变量定义的位置开始，到该变量所在的那对大括号结束；
生命周期：变量从定义的位置开始就在内存中活了；变量到达它所在的作用域的时候就在内存中消失了；
5、运算符
1) 算术运算符：+ 、 - 、 * 、 / 、 % 、 ++ 、 --
2) 赋值运算符：= 、 += 、 -= 、 *= 、 /= 、 %=
3) 关系运算符：> 、 < 、 >= 、 <= 、 == 、 !=
4) 逻辑运算符：
! (一般用于boolean类型前,表示非);
& (只要有一个false 最终结果就是false);
| (但凡有一个true 最终结果就是true);
^ (如果两边一样,最终结果为false;如果两边不同,最终结果为true);
&& (若第一个表达式结果为false,发生短路,第二个表达式不执行,最终结果为false);
|| (若第一个表达式结果为true,发生短路,第二个表达式不执行,最终结果是true）
5) 位运算符：用于操作二进制位的运算符。
~ 、 >> 、 << 、 >>>(无符号右移) 6) 字符串连接运算符：+ 7) 三目运算符：X ? Y : Z
X为boolean类型表达式,若x的结果为true,返回表达式Y的值，否则返回表达式Z的值。七：Java中的流程控制
1、三种结构： 顺序、分支、循环
1） if语句
a.if（）{}
b.if（）{}else{}
c.if（）{}else if(){}
d.if（）{if(){}else()}
e.if（）执行语句 esle 执行语句 （注意：执行语句只有一条语句的时候.可以将if esle 的大括号省略）
注意：()中为boolean类型表达式,{}中为执行语句块
equals : 比较字符串用,比较的是内容。
== : 比较数值，比较的是引用的地址。
基本数据类型：变量名、变量值在栈中。
引用数据类型：变量名在栈中，变量值在常量池中。
object中的equals比较的是地址，底层封装的是==
== 比较基本数据类型时，比较的是内容
比较引用数据类型时，比较的是地址
String中也有equals，String中的equals被重写过了，比较的是内容。
2）switch多分支语句
import java.util.Scanner;
public class MySwitch {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.print("请输入今天星期几：");
int week = scan.nextInt();
switch (week) {
case 1:
System.out.println("星期一");
break;
case 2:
System.out.println("星期二");
break;
case 3:
System.out.println("星期三");
break;
case 4:
System.out.println("星期四");
break;
case 5:
System.out.println("星期五");
break;
case 6:
System.out.println("星期六");
break;
case 7:
System.out.println("星期天");
break;
default:
System.out.println("今天要不要上班呢？");
break;
}
}
}
注意：
1、表达式必须是int、byte、char、short、enmu、String类型
2、case后必须是常量或者finall变量，不能是范围
3、所有的case语句的值不能相同，否则编译会报错
4、default可要可不要
5、break用来执行完一个分支后使程序跳出switch语句块，否则会一直会执行下去。
if与switch比较： a.if可以判断范围,也可以判断一个值switch只能判断指定的值。
b.若只判断指定的值,则使用switch语句,效率快 if判断范围,对数据判断灵活,自身的格式也比较灵活。
3）for循环
for ([循环变量初始值设定]; [循环条件判断]; [改变循环变量的值])｛
循环体;
｝
注意：
1、表达式2一般不可以省略,否则死循环
2、表达式3可以省略,但是在循环体中必须有语句修改变量,以使表达式2在某一时刻为false结束循环。
3、若同时省略表达式1,表表达式3,则相当于while（表达式2）语句
4、三个表达式均省略 即for(;;)语句，此时相当于while(true)语句
5、表达式1、表达式3可以是逗号表达式,以使循环变量值在修改时可以对其它变量赋值
6、一般情况下,表达式3,应向循环的结束变
1 public class Sfor { 2 3 public static void main(String[] args) { 4 for (int i = 1; i <= 9; i++) { 5 for (int j = 1; j <= i; j++) { 6 System.out.print(i+"*"+j+"="+j*i+" "); 7 } 8 System.out.print("\n"); 9 } 10 } 11 12 } 13 输出结果是： 14 1*1=1 15 2*1=2 2*2=4 16 3*1=3 3*2=6 3*3=9 17 4*1=4 4*2=8 4*3=12 4*4=16 18 5*1=5 5*2=10 5*3=15 5*4=20 5*5=25 19 6*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36 20 7*1=7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49 21 8*1=8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64 22 9*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81
4）while循环
while(条件表达式语句)｛
循环体语句;
}
do｛
循环体;
｝while( 循环条件判断);
注意：
1、当第一次执行时，若表达式=false时，则while语句不执行，而do/while语句执行一次后面的语句
2、一定要切记在switch循环中，如果没有break跳出语句，每一个case都要执行一遍，在计算最终结果。
public class SWhile {
public static void main(String[] args) {
int x = 1; // 定义初值
int sum = 0; // 定义求和变量，用于存储相加后的结果
while(x <= 10) {
sum += x; // 循环相加，也即 sum = sum + x;
x++;
}
System.out.println(sum);
}
}
public class CDoWhile {
public static void main(String[] args) {
int a = 10;
int b = 10;
// while循环语句
while(a == 8) {
System.out.println("a == " + a);
a--;
}
// do···while循环语句
do {
System.out.println("b == " + b);
b--;
} while(b == 8);
}
}
2、break、return和continue
break：跳出某个循环
continue：跳出本次循环,进入下一轮
return：以return；终止方法的执行
注意：if外有循环可以用break、continue，单纯if不可以用。
3、递归
a.有返回值
b.有参数
c.能够有跳出循环的控制语句
d.自己调用自己
//用递归方法求累加
public class Recursion {
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
System.out.print("请输入要求的值：");
int N =scan.nextInt();
for(int n = 1; n <= N; n++) {
if(n % 20 == 0){
int sum = recursion(n);
System.out.println("1 到 " + n + " 的累加值是： " + sum);
}
}
}
public static int recursion(int n) {
if (n < 1) return 0;
return recursion(n - 1) + n;
}
}
八：重写（Overriding）与重载（Overloading）
方法重载：指同一个类中的多个方法具有相同的名字,但这些方法具有不同的参数列表,即参数的数量或参数类型不能完全相同
方法重写：存在子父类之间的,子类定义的方法与父类中的方法具有相同的方法名字,相同的参数表和相同的返回类型
注:
(1)子类中不能重写父类中的final方法
(2)子类中必须重写父类中的abstract方法
(3)子类函数的访问修饰权限不能小于父类的；
(4)子类的异常类型要小于父类；
重写方法的规则：
1、参数列表必须完全与被重写的方法相同，否则不能称其为重写而是重载。
2、返回的类型必须一直与被重写的方法的返回类型相同，否则不能称其为重写而是重载。
3、访问修饰符的限制一定要大于被重写方法的访问修饰符（public>protected>default>private）
4、重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查型异常。例如：父类的一个方法申明了一个检查异常IOException，
在重写这个方法是就不能抛出Exception,只能抛出IOException的子类异常，可以抛出非检查异常。
而重载的规则：
1、必须具有不同的参数列表；
2、可以有不责骂的返回类型，只要参数列表不同就可以了；
3、可以有不同的访问修饰符；
4、可以抛出不同的异常；
重写与重载的区别在于：
重写多态性起作用，对调用被重载过的方法可以大大减少代码的输入量，同一个方法名只要往里面传递不同的参数就可以拥有不同的功能或返回值。
用好重写和重载可以设计一个结构清晰而简洁的类，可以说重写和重载在编写代码过程中的作用非同一般.
1、重写是在继承关系中；重载是在同一个类中。
2、重写是方法名、参数列表和父类相同；重载，方法名相同，参数列表不相同（个数、类型、顺序）。
3、重写返回值类型和父类相同；重载和返回值无关。
4、重写访问权限修饰符不能比父类更加严格；重载没有要求。
九：面向对象和面向过程
1、面向对象：是以具体的事物为单位，考虑的是它的特征（属性）和行为（方法）。
2、面向过程：是以具体的流程为单位，考虑功能的实现。
十：类和对象
1、对象：看得见摸得着的具体事物。
类：抽象化的概念
2、类和对象的关系：
类是对象的模板/抽象化的概念，对象是类的实例。
3、创建类和对象
类：
特征：全局变量/属性/成员变量
动作：方法
对象：
类名 对象名=new 类名（）
注意：一个类可以创建多个对象，，每个对象之间没有关系。
十一：内存图
1、栈：先进后出，存放基本数据类型变量名和变量值，引用数据类型的变量名，方法执行的时候进入栈中
2、堆：先进先出，new出来的对象的实例，包括类的属性个方法。
十二：构造方法
1、构造方法是new关键字调用的，用来帮助构建对象
2、显示构造对象
3、隐示构造对象（没有显示的情况下存在）
4、构造对象可以重载，参数类型不一致。
十三：关键字
1、static调用格式：
1)同一个类中：
静态的： 方法名 属性名
类名.方法名 类名.属性名
对象名.方法名 对象名.属性名
非静态的： 对象名.属性名 对象名.方法名
2)不同类中:
静态的： 对象名.方法名 对象名.属性名
类名.方法名 类名.属性名
非静态的： 对象名.属性名 类名.方法名
注意：
1、static可以修饰属性、方法、代码块，不可以修饰类和构造方法。
2、静态方法随着类的加载而加载。
3、在静态方法区内的东西只有一份，所有的对象共享这一份空间，只要有一个对象对属性进行修改，所有的对象调用都是修改后的数据。
4、代码块的执行顺序：静态代码块（只被调用一次）>构造代码块{}>构造方法>普通方法（需调用）
2、this关键字
1)可以调用属性和方法。 this.属性名（全局变量） this.方法名（）;
2)在构造方法中：
a.this();括号内的参数个数、顺序、类型根据调用的方法来决定。
b.必须放在第一行，只能调用一次。
c.调用构造方法时只能在构造方法中调用，调用属性和方法时可以在构造方法中可以在普通方法中。
d.当全局变量和局部变量有重名字的时候，用this来区分。
3、super关键字
1)super指代父类对象。
2)super可以调用属性、方法、构造方法。
3)super调用父类的构造方法。
4)super调用构造方法时候必须放在第一行。
4、final最终的
1)可以修饰全局变量，声明的时候必须赋值，只能赋值一次。
2)可以修饰局部变量，声明时候可以不赋值，但也只能赋值一次。
3)可以修饰方法，可以正常使用，不能被重写。
4)可以修饰类，可以正常使用，不能被继承。
5)用final修饰的属性通常叫常量。
6)static final 全局变量。每个字母都要大写。
5、this和super的区别
1)this指的是本类创建的对象。 super指代的是父类的对象
2)this可以调用属性、方法、构造方法。 super也可以调用属性、方法、构造方法。
3)this调用属性和方法的时候，调用自己本类的属性和方法。 如果本类没有，那就用super去父类中找
4)this调用构造方法调用，调用本类的其他构造方法。 super调用父类的构造方法。
5)this和super在调用构造方法的时候必须放在第一行。
6)this和super不能同时存在
6、最小作用域最强原则： 局域变量在此方法中，比全局变量在此方法中的作用强。
十四：面向对象的三大特征
1、封装
作用：提高代码的安全性
1)将属性私有化，并提供对外界的接口（get/set方法）。
2)用private修饰的属性和方法，只能在本类中使用。 2、继承
作用：提高代码的复用性，减少重复代码
1)子类可以继承父类非私有的属性和方法，不能继承构造方法和私有的属性和方法。
2)可以综合子类的共同特征来去提炼父亲的类。
3)子类在继承父类的各种属性和方法时，也可以有自己的属性和方法。
4)一个子类只能有一个父类，java只能单继承，不能多继承，因为多个类中的方法名相同，方法体不同，不知使用哪个。 5)一个类继承最顶端叫做基类或者超类，所有的超类叫做object 。 6)在继承关系中，如果父类没有无参数的构造方法，如何解决？ a.子类中添加一个和父类构造方法参数列表相同的构造方法，通过super参数传递给父类的构造方法 b.如果父类允许修改的时候，可以在父类中创建一个无参的构造方法 7)在继承关系中，代码块的执行顺序：父静>子静>父构造代码块>父构造方法>子构造代码块>子构造方法 3、多态
1)分类
编译时多态：在编译过程中察觉的多态，重载，向上转型。
运行时多态：在运行过程中察觉的多态，向下转型。
2)向上转型、向下转型是在继承关系中，向下转型必须在向上转型的基之上。
3)在继承关系中，父类的对象可以指向子类的实例，父类引用实体方法的时候，是调用子类重写以后的方法。
4)向上转型 父类的引用指向子类的实体 父类类名 对象名=new 子类类(); 优点：减少重复代码，提高代码的复用性 缺点:父类的引用无法调用子类特有的属性和方法 解决方案：向下转型 5)向下转型： 子类对象的父类引用赋给子类 子类类名 对象名=（子类类名）父类对象; 6) instanceof 判断左边的对象是否属于右边的类 对象名 instanceof 类名（子类类名） 7)匿名对象 new 类名（） 只有堆空间，没有栈空间，只能属于一次，为了节省代码。十五：抽象abstract与接口interface
abstract：
作用：节省代码，提高代码的复用性
1)抽象类格式：访问权限修饰符 abstract class 类名{ 2)抽象方法格式：访问权限修饰符 abstract 返回值类型 方法名(形式参数列表); 注意： 1、如果一个类里有抽象方法，那么这个类必须声明成抽象类。 2、一个类里面可以没有抽象方法，可以有非抽象方法， 3、类继承抽象类： 把子类也用abstract修饰，变成抽象类。 子类重写父类的抽象的方法 4、抽象类不能创建对象。 5、抽象类可以有构造方法，在创建子类的时候，super隐式调用父类的构造方法，将父类的属性和方法放到子类的对象空间里。 6、在继承你关系中，子类能够继承抽象类的各种属性和方法，除了私有的和构造方法。 7、只有公开的才可以和abstract连用，static final private 都不可以。 static属于类方法，不允许覆盖，abstract必须被覆盖。final不能被重写。
interface：
作用：规范了代码，提高代码的拓展性 1、格式：访问权限修饰符 interface 接口名称{}
2、实现类的格式：访问权限修饰符 class 实现类名 implements 接口名{必须重写接口中的所有的抽象方法}
3、接口中只有全局常量和抽象方法。
4、书写的时候可以省略部分修饰符，系统会默认给添上。
5、接口在实现的同时去继承，extends在implement前面。
6、接口可以多实现，实现的也必须是接口，方法名可以重复，实现类实现一个就行了，因为没有方法体，不会发生冲突。
抽象和接口的区别：
1、关键字：抽象类 abstract 接口interface
2、抽象类继承 extends 接口实现 implements
3、子类继承抽象类和 实现类实现接口的格式不同
4、接口中只有全局变量和抽象方法 抽象类中有各种属性和方法
5、抽象类只能单继承 接口可以多实现
6、抽象类的子类只能继承一个父类 实现类可以实现多个接口，并且还可以继承父类
7、抽象类的作用：提高代码的复用性 接口的作用：1、规范代码2、提高代码的拓展新
十六：访问权限修饰符
本类中 本包中 其他包子类 其他包非子类
public √ √ √ √
protected √ √ √ ×
default √ √ × ×
private √ × × ×
十七：内部类
分类：成员内部类、静态内部类、局部内部类、匿名内部类
1、成员内部类：
1、可以用四种访问权限修饰符修饰
2、可以有自己的属性和方法，除了静态的。
3、可以使用外部类的所有属性和方法，包括私有的。 4、创建对象 1、通过创建外部类对象的方式创建对象 外部类 外部类对象=new 外部类(); 内部类 对象名=外部类对象.new 内部类(); 2、内部类 对象名=new 外部类.new 内部类(); 2、静态内部类 1、格式：static class 类名{} 2、可以声明静态的属性和方法 3、可以使用外部的静态的属性和方法 4、创建对象 内类名 对象名=new 内类名();(可以直接创建) 外部类名.内部类 对象名=new 外部类.内部类(); 包名.外部类名.内部类 对象名=new 包名.外部类.内部类(); 5、外部类与内部类同名时，默认是使用内部类对象调用外部类属性 this代表内部类对象 6、要想使用外部类属性，需要使用外部类对象调用 3、局部内部类 1、在方法中声明 2、只能用default修饰 3、可以声明属性和方法，但不能是静态的 4、创建对象，必须在声明内部类的方法内创建 5、调用方法的时候，局部内部类才会被执行 4、匿名内部类 1、匿名内部类只是用一次 2、格式： 父类或接口名 对象名=new 父类或接口名（参数列表）{ 重写抽象方法 } 调用抽象方法：对象名.方法名十八：常用设计模式
1、单例模式 分类：懒汉式、饿汉式
1、构造方法私有化
2、在本类中创建本类对象
3、保证对象的唯一性final
4、给外界提供得到对象的方法 static
5、在多线程中，饿汉式安全，懒汉式不安全
2、简单工厂模式 批量创建对象
1 创建工厂类 : 创建对象的方法
2 果汁类 是所有种类果汁的父类
3 在工厂类的方法中返回果汁类
4 根据测试类中传递的字符串判断到底返回哪种果汁
5 测试类通过工厂类返回果汁对象
3、建造者模式
内部类使用场景 目的：静态内部类创建外部类对象
1、 创建外部类，在其中创建一个静态内部类
2、静态内部类中写属性，构造方法和set get方法
3、静态内部类中写一个方法，必须返回外部类对象
4、 给外部类创建对象，传递参数。
4、装饰者模式
1、在处理流中使用
2、子类重写父类的方法,提高父类方法的功能及效率
3、为了尽可能减少重复代码,在重写的方法中用父类的对象调用父类原来的方法
4、得到父类对象可以通过将父类对象作为子类属性,通过子类构造方法传递父类对象
十九：数组及常用算法
1、声明： int a[]; int []b;
2、初始化：
动态初始化：
1、a=new int[2]; int[0]=1;... 动态初始化：
2、b=new b[]{3,4}; 静态初始化：int [] c={5,6};
3、数组常用的方法：
排序：Array.sort();
查找：Array.binarySearch();
打印：Array.toString();
复制：Array.copyof();
4、常用操作
1、冒泡排序
for(int i=0;i<a.length-1;i++){//控制外循环的次数
for(int j=0;j<a.length-1-i;j++){//控制内循环次数，比外循环少一次，与下一个比较
if(a[j]>a[j+1]){
int temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}
}
2、选择排序
for (int i = 0; i < a.length-1; i++) {
int k=i;
for (int j = i; j < a.length-1; j++) {
if (a[k]>a[j+1]) {
k=j+1;
}
}
if(i!=k){
int temp=a[i];
a[i]=a[k];
a[k]=temp;
}
}
3、顺序查找
public static int find(int []b,int a){
for (int i = 0; i < b.length; i++) {
if (a==b[i]) {
return i;
}
}
return -1;
}
4、二分查找
public static int find(int b[],int a){
int max=b.length-1;
int min=0;
for (int i = 0; i < b.length; i++) {
int midle=(max+min)/2;
if(a==b[midle]){
return midle;
}else if(a>b[midle]){
min=midle+1;
}else if(a<b[midle]){
max=midle-1;
}
}
return -1;
}
二十：时间相关的类
1、Date类 .getTime();计算毫秒
2、SimpleDateFormat类 格式化时间 .format();返回的是String字符串
3、Calendar接口
日历字段之间的转换提供了一些方法
.get(Calendar.YEAR);
.get(Calendar.MONTH);// 默认是当前月份减一 从0开始的
.get(Calendar.DAY_OF_MONTH);
.get(Calendar.DAY_OF_WEEK);
Calendar calendar = Calendar.getInstance();
Date date = calendar.getTime();
4、Runtime运行时时间 .freeMemory(); 当前的系统剩余空间
5、System.exit(0);退出程序,参数是0是正常退出
System.gc();调用垃圾回收器,不一定能够起来,只是起到一个促进的作用
二十一：Java异常处理机制
异常：
1、在运行时期出现的不正常的事件，从继承的角度看，throwable是错误和异常的超类
2、错误Error：程序员无法处理的严重性问题，资源耗尽，jvm系统内部的错误
异常Exception:程序员可以处理的一般性问题，偶然的外界因素，编程的逻辑性错误
3、处理的必要性角度：
受检异常：编译时期就能发现的异常，必须要去处理的异常，继承自Exception
非受检异常：运行时期发现的异常，不是必须要去处理的，继承自RuntimeException
4、异常的处理机制： 当运行代码的时候首先先碰到异常，首先产生异常对象，抛出给jvm，jvm会携带异常对象，
去找代码能够处理或者捕获异常代码,如果找到了，则交给这个代码去处理，没有找打，则程序停止运行。
5、异常处理的两种方式
1、捕获异常
try{可能会产生异常的代码}catch(异常类 异常对象){处理异常的代码}
try{}catch(){}catch(){}... catch中子类异常放在父类异常的上面
try{]catch(){}finally{} finally中的代码一定会被执行到
try{}finally{}
1> 如果不去捕获异常,发生异常,异常后面的代码都不会被执行到
2> 如果捕获异常 try/catch后面的代码会被执行到
3> 捕获异常,try块中异常后面的代码不会被执行到
2、抛出异常
产生异常的位置不去处理异常,由调用此方法的调用者去处理异
throws 方法的声明后面 后面跟的是异常的类名 可以跟多个类名之间用逗号隔开 可以抛出受检异常和非受检异常
throw 方法的内部 异常的对象名 一个对象 抛出非受检异常
6、自定义异常
自定义
受检异常继承Exception
非受检异常 RuntimeException
final finally finalize区别
final 最终的，可修饰类，方法，属性
类：不能被继承
方法：不能被重写，可以被继承
属性:全局变量：声明是必须初始化。局部变量：声明的时候可以不初始化。但都只能赋值一次
finally 跟try/catch后面，无论是否发生异常都会被执行。关闭数据库，关闭数据流。
finalize 由系统调用，垃圾回收器回收之前做一些清理的工作。
二十二：
数组：长度固定，数据类型相同
集合：长度不固定，数据类型可以不同，只能存对象
collection
List Set Vector
ArrayList HashSet
LinkedList TreeSet
Map
HashMap
TreeMap
List：元素是有序的，元素可以重复。因为该集合体系有索引。
|--ArrayList：底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。
|--LinkedList：底层使用的是链表数据结构。特点：增删速度很快，查询稍慢。
|--Vector：底层是数组数据结构。线程同步。被ArrayList替代了。
Set：元素是无序（存入和取出的顺序不一定一致），元素不可以重复。
|--HashSet：底层数据结构是哈希表。线程不同步。 保证元素唯一性的原理：判断元素的hashCode值是否相同。如果相同，还会继续判断元素的equals方法，是否为true。
|--TreeSet：可以对Set集合中的元素进行排序。默认按照字母的自然排序。底层数据结构是二叉树。保证元素唯一性的依据：compareTo方法return 0。
Set集合的功能和Collection是一致的
1、HashSet： 哈希表 1、可以通过元素的两个方法，hashCode和equals来完成保证元素唯一性。如果元素的HashCode值相同，才会判断equals是否为true。
如果元素的hashCode值不同，不会调用equals。
2、hashcode是内存地址通过一定运算的到的int类型的数值。返回值是int类型的数据，各个属性的hash值。 相加
3、hashcode值相同,也不一定是同一个对象
4、调用hashcode方法可以帮助去过滤调用完全不可能相同的 对象,提高执行效率
5、equals最终确定两个对象是否相同的
Map :
1)该集合存储键值对，一对一对往里存
2)要保证键的唯一性
|--Hashtable：底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。JDK1.0，效率低。 |--HashMap：底层是哈希表数据结构。允许使用null键null值，该集合是不同步的。JDK1.2，效率高。 |--TreeMap：底层是二叉树数据结构。线程不同步。可以用于给Map集合中的键进行排序。 初始容量16，加载因子0.75 Map和Set很像。其实Set底层就是使用了Map集合。二十三：Java多线程
1）线程和进程
1、线程
注意：多线程。从宏观角度：同时执行了多个线程。
从微观角度：同一时间只能执行一个线程
多个线程是竞争关系，抢占cpu资源，否则只能等待。
2、进程和线程的区别
进程是应用程序，线程是一条执行路径
进程有独立的内存空间，崩溃不会影响其他程序，
线程没有独立的空间，多个线程在同一个进程的空间，可能会影响其他线程
一个进程中，至少有一个线程
3、主线程与子线程
主线程：main方法产生的线程，也叫作UI线程。
子线程：除了主线程以外的，也叫工作线程。
守护线程（即daemon thread），是个服务线程，准确地来说就是服务其他的线程。
4、创建线程的方式
a.创建一个类继承Thread,重写run方法,创建线程对象,启动线程,Thread.currentThread().getName()，哪个线程调用，名字就是哪个现成的名字.
b.共享资源类实现Runable接口,重写run方法,创建共享资源对象,创建线程对象，将共享资源对象添加到线程中,启动线程
c.实现callable接口，Callable接口代表一段可以调用并返回结果的代码;Future接口表示异步任务，是还没有完成的任务给出的未来结果。
所以说Callable用于产生结果，Future用于获取结果。
d.线程池ThreadPoolExcutor
new ThreadPoolExecutor(int corePoolSize, int maximumPoolSize,long keepAliveTime, TimeUnit unit,BlockingQueue workQueue,RejectedExecutionHandler handler)
(1)corePoolSize： 线程池维护线程的最少数量 （core : 核心）
(2)maximumPoolSize： 线程池维护线程的最大数量
(3)keepAliveTime： 线程池维护线程所允许的空闲时间
(4)unit： 线程池维护线程所允许的空闲时间的单位
(5)workQueue： 线程池所使用的缓冲队列
(6)handler： 线程池对拒绝任务的处理策略
思考：说一下 runnable 和 callable 有什么区别？
Runnable接口中的run()方法的返回值是void，它做的事情只是纯粹地去执行run()方法中的代码而已；
Callable接口中的call()方法是有返回值的，是一个泛型，和Future、FutureTask配合可以用来获取异步执行的结果。
5、run和start的区别
每个线程都是通过某个特定Thread对象所对应的方法run()来完成其操作的，方法run()称为线程体。通过调用Thread类的start()方法来启动一个线程。
start()方法来启动一个线程，真正实现了多线程运行。这时无需等待run方法体代码执行完毕，可以直接继续执行下面的代码； 这时此线程是处于就绪状态， 并没有运行。
然后通过此Thread类调用方法run()来完成其运行状态， 这里方法run()称为线程体，它包含了要执行的这个线程的内容， Run方法运行结束， 此线程终止。然后CPU再调度其它线程。
run()方法是在本线程里的，只是线程里的一个函数,而不是多线程的。 如果直接调用run(),其实就相当于是调用了一个普通函数而已，直接待用run()方法必须等待run()方法执行完毕
才能执行下面的代码，所以执行路径还是只有一条，根本就没有线程的特征，所以在多线程执行时要使用start()方法而不是run()方法。
run没有开辟新的栈空间，没有新线程，都是主线程在执行
start开辟了新的栈空间，在新的栈空间启动run()方法
6、线程的调度
setPriority();分配优先级，默认5,最低1，最高10
.join();插队，阻塞指定的线程等到另一个线程完成以后再继续执行
.sleep();需要设置睡眠时间
.yield();礼让，当执行到这个方法时，会让出cpu时间，立马变成可执行状态
sleep和pield的区别：
sleep 线程进入被阻塞的状态
yeild 线程转入暂停执行的状态
7、打断线程的终止方式
1、用标记，当终止线程时，会执行完run方法
2、stop()方法，不建议使用，会执行不到特定的代码
3、interrupt()，只能中断正在休眠的线程，通过抛异常的方法中断线程的终止。
InputStream inputStream=System.in;
int m=inputStream.read();
myThread2.interrupt();//通过外界输入打断
8、线程的五种状态
新建(new) 就绪(runnable) 执行(running) 死亡(dead) 阻塞(blocked)
1、新建状态(New)：新创建了一个线程对象。
2、就绪状态(Runnable)：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于“可运行线程池”中，
变得可运行，只等待获取CPU的使用权。即在就绪状态的进程除CPU之外，其它的运行所需资源都已全部获得。
3、运行状态(Running)：就绪状态的线程获取了CPU，执行程序代码。
4、阻塞状态(Blocked)：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。
阻塞的情况分三种：
(1)、等待阻塞：运行的线程执行wait()方法，该线程会释放占用的所有资源，JVM会把该线程放入“等待池”中。
进入这个状态后，是不能自动唤醒的，必须依靠其他线程调用notify()或notifyAll()方法才能被唤醒，
(2)、同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入“锁池”中。
(3)、其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。
当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。
5、死亡状态(Dead)：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。
思考：（1）sleep() 和 wait() 有什么区别？
sleep()：方法是线程类（Thread）的静态方法，让调用线程进入睡眠状态，让出执行机会给其他线程，等到休眠时间结束后，线程进入就绪状态和其他线程一起竞争cpu的执行时间。
因为sleep() 是static静态的方法，他不能改变对象的机锁，当一个synchronized块中调用了sleep() 方法，线程虽然进入休眠，但是对象的机锁没有被释放，其他线程依然无法访问这个
对象。
wait()：wait()是Object类的方法，当一个线程执行到wait方法时，它就进入到一个和该对象相关的等待池，同时释放对象的机锁，使得其他线程能够访问，
可以通过notify，notifyAll方法来唤醒等待的线程
（2）notify()和 notifyAll()有什么区别？
如果线程调用了对象的 wait()方法，那么线程便会处于该对象的等待池中，等待池中的线程不会去竞争该对象的锁。
当有线程调用了对象的 notifyAll()方法（唤醒所有 wait 线程）或 notify()方法（只随机唤醒一个 wait 线程），被唤醒的的线程便会进入该对象的锁池中，锁池中的线程会
去竞争该对象锁。也就是说，调用了notify后只要一个线程会由等待池进入锁池，而notifyAll会将该对象等待池内的所有线程移动到锁池中，等待锁竞争。
优先级高的线程竞争到对象锁的概率大，假若某线程没有竞争到该对象锁，它还会留在锁池中，唯有线程再次调用 wait()方法，它才会重新回到等待池中。而竞争到对象锁的线程
则继续往下执行，直到执行完了 synchronized 代码块，它会释放掉该对象锁，这时锁池中的线程会继续竞争该对象锁。
2)同步
发生在两个以两个以上的线程中
解决代码的重复问题 优点：提高了线程中数据的安全性 缺点：降低了执行效率
1、同步代码块 synchronized（锁）{同步代码块} 注意：锁分任意锁和互斥锁，锁是对象，琐是唯一的。
2、同步方法 public synchroinzed 返回值类型 方法名（）{同步代码}
3、在共享资源中：
线程操作相同，锁是this
synchronized (this) {// 同步代码块，包含同步代码块。任意锁，互斥锁。
if (ticket > 0) {
System.out.println(Thread.currentThread().getName() + "---" + ticket--);
} else {
break;
}
}
线程操作不相同，锁是共享资源对象
synchronized (card) {
card.setMoney(card.getMoney() + 1000);
System.out.println("Boy+1000---" + card.getMoney());
}
4、在同步方法中：
共享资源，线程操作相同，资源类中的锁是this
共享资源，线程操作不相同，资源类中的锁也是this
public synchronized void input(){
money+=100;
System.out.println("input+100----"+money);
}
（1）什么是死锁？
死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统
产生了死锁，这些永远在互相等待的进程称为死锁进程。是操作系统层面的一个错误，是进程死锁的简称，最早在 1965 年由 Dijkstra 在研究银行家算法时提出的，它是计算机操作系统
乃至整个并发程序设计领域最难处理的问题之一。
(2)怎么防止死锁？
死锁的四个必要条件：
1、互斥条件：进程对所分配到的资源不允许其他进程进行访问，若其他进程访问该资源，只能等待，直至占有该资源的进程使用完成后释放该资源
2、请求和保持条件：进程获得一定的资源之后，又对其他资源发出请求，但是该资源可能被其他进程占有，此事请求阻塞，但又对自己获得的资源保持不放
3、不可剥夺条件：是指进程已获得的资源，在未完成使用之前，不可被剥夺，只能在使用完后自己释放
4、环路等待条件：是指进程发生死锁后，若干进程之间形成一种头尾相接的循环等待资源关系
这四个条件是死锁的必要条件，只要系统发生死锁，这些条件必然成立，而只要上述条件之 一不满足，就不会发生死锁。理解了死锁的原因，尤其是产生死锁的四个必要条件，
就可以最大可能地避免、预防和 解除死锁。所以，在系统设计、进程调度等方面注意如何不让这四个必要条件成立，如何确 定资源的合理分配算法，避免进程永久占据系统资源。
此外，也要防止进程在处于等待状态的情况下占用资源。因此，对资源的分配要给予合理的规划。
(3)说一下 synchronized 底层实现原理？
synchronized可以保证方法或者代码块在运行时，同一时刻只有一个方法可以进入到临界区，同时它还可以保证共享变量的内存可见性。Java中每一个对象都可以作为锁，
这是synchronized实现同步的基础：
普通同步方法，锁是当前实例对象
静态同步方法，锁是当前类的class对象
同步方法块，锁是括号里面的对象
(4)synchronized 和 Lock 有什么区别？
首先synchronized是java内置关键字，在jvm层面，Lock是个java类；
synchronized无法判断是否获取锁的状态，Lock可以判断是否获取到锁；
synchronized会自动释放锁(a 线程执行完同步代码会释放锁 ；b 线程执行过程中发生异常会释放锁)，Lock需在finally中手工释放锁（unlock()方法释放锁），否则容易造成线程死锁；
用synchronized关键字的两个线程1和线程2，如果当前线程1获得锁，线程2线程等待。如果线程1阻塞，线程2则会一直等待下去，而Lock锁就不一定会等待下去，如果尝试获取不到锁，
线程可以不用一直等待就结束了；
synchronized的锁可重入、不可中断、非公平，而Lock锁可重入、可判断、可公平（两者皆可）；
Lock锁适合大量同步的代码的同步问题，synchronized锁适合代码少量的同步问题。