| Java语法速查 |
Java语法整理
Java语言基础
数据类型取值范围
byte
[-128,127]
short
[-32768,32767]
int
[-2147483648,2147483647]
char
[0.65535]
控制语句
if
语法格式
if(布尔表达式){
Java语句；
}else if（布尔表达式）{
Java语句；
}else if（布尔表达式）{
Java语句；
}else{
java语句；
}
使用注意事项
对于Java中的if语句来说，只要有一个分支执行，整个if语句全部结束
带有else分支语句可保证会有分支执行
所有的控制语句都可以嵌套使用
if语句的分支中只有一条Java语句，大括号可省略不写。格式： if（true/false） 一条Java语句；//不推荐使用
switch
语法格式
switch（int或String类型的字面值或变量）{
case int或String类型的字面值或变量：
Java语句；
break；
default：
Java语句；
}
使用注意事项
case穿透现象（可在case分支语句中加break避免）
switch和case后只能是int或String类型的数据，不能是其他类型。但byte,short,char也可直接写到switch和case后面，因为他们可进行自动类型转换。
case可以合并。格式：
case 1：case 2：case 10：
Java语句；
for
语法格式
for（初始化表达式；布尔表达式；更新表达式）{
Java语句；//循环体
}
使用注意事项
初始化表达式，布尔表达式和更新表达式都不是必须的。但两个分号必须写（若布尔表达式不写，陷入死循环）
初始化表达式最先执行，且在整个for循环中只执行一次
若要输出某一变量，则该变量的定义要在循环体之外（不然每进入一次循环，变量就被初始化一次）
for循环可嵌套for循环。内层循环中的变量与外层循环中的变量不能重名
while
语法格式
while（布尔表达式）{
循环体；
}
do{
循环体；
}whike（布尔表达式）；
break
使用注意事项
break ；可成为一个单独的完整的Java语句
break可应用于switch语句和循环语句中，用来中止switch语句或循环语句的执行
默认情况下break中止的是离他最近的循环。但可用： break 循环名称；来中止特定的循环
continue
使用注意事项
continue ; 可成为一个单独的完整的Java语句。主要出现在循环语句中，用来控制循环的执行
break表示循环不执行了，continue表示直接进行下一次循环继续执行
continue 循环名称；（用法与break相似）
方法初步
方法的定义
[修饰符列表] 返回值类型 方法名（形式参数列表）{
方法体；
}
普通方法的调用
方法修饰符中带有static： 类名 . 方法名（实参列表）
方法修饰符中没有static： 引用 . 方法名（实参列表）
使用注意事项
方法只定义不调用是不会执行的
方法的调用不一定是在main方法中，也可以在其他方法当中。只要是程序可以执行的位置都可以去调用其他方法
方法的修饰符列表当中有static关键字时，完整的调用方法是类名 . 方法名（实参列表）；。但去负责调用的方法和被调用的方法在同一类中时——类名 . ——可以不写
方法执行时的内存分配
方法只定义不调用是不会执行的，并且在JVM中也不会给该方法分配“运行所属”的内存空间
方法代码片段属于.class字节码的一部分。字节码文件在类加载时将其放到了方法区内存当中
代码片段虽然在方法区内存当中只有一份，但可以被重复调用，每一次调用该方法时，需要给该方法分配独立的内存空间，在栈内存中分配
方法调用时发生压栈动作。方法执行结束后，给该方法分配的内存空间全部释放，此时发生弹栈动作
局部变量是在栈内存中存储，在”方法体“中声明
方法重载
特征
同名不同参
构成方法重载需满足的条件
在同一类中
方法名相同
参数列表不同
类型不同
数量不同
顺序不同
使用注意事项
方法重载只和方法名+参数列表有关。和返回值类型和修饰符列表无关
方法递归
定义
方法自身调用自身
使用注意事项
递归必须有结束条件，没有结束条件一定会发生栈内存溢出
面向对象编程基础
面向对象与面向过程
类和对象的概念
Java虚拟机内存分配总结
封装性
构造方法
参数传递
this关键字
static关键字
继承
方法重写
多态
final关键字
package，import
访问控制权限修饰符
面向对象编程深入和数组
抽象类和抽象方法
抽象方法
定义：使用abstract修饰的方法，没有方法体，只有声明
理解：定义的是一种“规范”，即告诉子类必须要给抽象方法提供具体的实现。
注意事项：
1. 没有实现
2. 子类必须实现
抽象类
定义：包含抽象方法的类就是抽象类
理解：抽象方法定义规范，要求子类必须定义具体实现。所以通过抽象类我们就可以做到严格限制子类的设计，使子类之间更加通用
self-thinking：抽象类提供了一个更加简洁，对子类要求更加严格的模板
注意事项
1. 有抽象方法的类只能定义成抽象类。但抽象类中的方法不一定全是抽象方法，也可能没有抽象方法。
2. 抽象类不能实例化，即不能用new 来实例化抽象类，只能被子类调用
3. 抽象类可以包含属性，方法，构造方法。但此构造方法不能用来new 对象
4. 抽象类只能用来被继承
5. 抽象方法必须被子类实现。抽象类的子类只有具体实现所有的抽象方法才能被实例化，否则还是抽象类
接口
语法格式
[访问修饰符] interface 接口名 [extends 父接口1，父接口2]{
常量定义；
方法定义；
}
定义接口的详细说明
访问修饰符：只能是public或默认
接口名：与类名采用相同命名机制
extends：接口可以多继承
常量：接口中的属性只能是常量，总是：public static final。不写也是
方法：接口中的方法只能是：public abstract。省略也是
理解
类与接口不是父子关系，是”实现与规则“的关系
子类通过implements（实现）来实现接口中的规范
接口不能创建实例，但可以用于声明引用变量类型
一个类实现了接口，必须实现接口中所有的方法，并且这些方法只能是public的。
注意事项
JAVA语言中，类只支持单继承，接口支持多继承
子接口扩展某个父接口，将会获得父接口中所定义的一切
内部类
定义
把一个类放在另一个类的内部定义，成为内部类（innerclasses）
理解
内部类作为外部类的成员，可以直接访问外部类的成员（包括private成员），但外部类不能访问内部类的内部成员
内部类可声明为pubilc,protected,默认或private
内部类成员只有在内部类的范围之内是有效的
用内部类定义在外部类中不可访问的属性，这样就在外部类中实现了比外部类的private还要小的访问权限
内部类提供了更好的封装。只能让外部类直接访问，不允许同一个包中的其他类直接访问，详见内部类的访问
注意事项
内部类只是一个编译时的概念，一旦编译成功就会成为两个完全不同的类。所以内部类是相对独立的一种存在，其成员变量/方法名可以和外部类的相同
对于一个名为Outer的外部类和其内部定义的名为Inner的内部类。编译完成后会出现Outer.class和Outer$Inner.class两个类的字节码文件
使用内部类间接实现了多继承：每个内部类都能独立地继承一个类或者实现某些接口，所以无论外部类是否已经继承了某个类或者实现了某些接口，对于内部类没有任何影响
分类
成员内部类
非静态内部类
成员变量访问要点
内部类访问
静态内部类
匿名内部类
定义：new 父类构造器(实参类表) / 实现接口 () {
匿名内部类类体；
}
局部内部类
String类
数组
定义
数组是相同类型数据的有序集合。
理解
数组描述的是相同类型的若干数据，按照一定的先后次序排列组合而成。每一个元素可以通过一个索引（下标）来访问它们。
基本特点
长度是确定的。数组一旦被创建，他的大小不可改变
其元素必须是相同类型，不允许出现混合类型
数组类型可以是任何数据类型，包括基本数据类型和引用数据类型
语法格式
声明
type[ ] arr_name ;
type arr_name[ ];
初始化
静态初始化：在定义数组的同时为数组元素分配空间并赋值
int[] a = {1,2,3};//静态初始化基本数据类型数组
Man[] mans = {new Man(1,1),new Man(2,2)}; //静态初始化引用类型数组
动态初始化：数组定义与为数组元素分配空间并赋值的操作分开进行
int[] a1 = new int[2];// 动态初始化数组，先分配空间
a1[0] = 1; //给数组元素赋值
a2[1] = 2;//给数组元素赋值
默认初始化
数组的遍历
for-each
for ( type 变量：数组名){
System.out.println(变量)；
}
数组的拷贝
语法结构
System.arraycopy(object src,int srcpos, object dest, int destpos, int length);
该方法可以将src数组里的元素值赋给dest数组的元素，其中srcpos指定从src数组的第几个元素开始赋值，length参数指定将src数组的多少个元素赋给dest数组的元素
注意事项
从数组中删除某个元素：本质上还是数组的拷贝
数组扩容：先定义一个更大的数组，再将原数组的内容原封不动拷贝到新数组中
打印数组
Arrays.toString(数组名)
Arrays.toString()方法是Arrays类的静态方法，不是前面讲的Object的toString()方法。
数组元素的排序
Arrays.sort(数组名)
数组元素是引用型的排序(Comparable接口的应用)
常用类
包装类
理解：
JAVA语言中基本数据类型不是对象。但是我们在实际应用中经常需要将基本数据转化成对象，以便于操作。因此Java在设计类时为每个基本数据类型设计了一个对应的类进行代表，这样八个和基本数据类型对应的类统称为包装类(Wrapper Class)
语法格式
基本数据类型转成包装类
包装类转成基本数据类型
字符串转成包装类
包装类传承字符串
自动装箱拆箱
缓存问题
String类
理解
String：不可变字符序列
StringBuilder: 可变字符序列，效率高，线程不安全
StringBuffer: 可变字符序列，效率低，线程安全
注意事项
字符串比较用equals。==是判断对象是否是同一对象
时间处理相关类
Date时间类
获得当前时刻 new Date()
遇到日期处理用Calendar日期类
时间格式化类
DateFormat 抽象类
SimpleDateFormat 实现类
用法：先用实现类声明转化格式，再将时间对象转化成字符串，或字符串转化成时间对象
SimpleDateFormat s1 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
SimpleDateFormat s2 = new SimpleDateFormat("yyyy-MM-dd");
// 将时间对象转换成字符串
String daytime = s1.format(new Date());
System.out.println(daytime);
// 将符合指定格式的字符串转成成时间对象.字符串格式需要和指定格式一致。
String time = "2007-10-7";
Date date = s2.parse(time);
Calendar日历类
Calendar 抽象类
GregorianCalendar 实现类
功能
获得日期
GregorianCalendar calendar = new GregorianCalendar(2999, 10, 9, 22, 10, 50);
int year = calendar.get(Calendar.YEAR); // 打印：1999
设置日期
GregorianCalendar calendar2 = new GregorianCalendar();
calendar2.set(Calendar.YEAR, 2999);
calendar2.set(Calendar.MONTH, Calendar.FEBRUARY); // 月份数：0-11
calendar2.set(Calendar.DATE, 3);
日期的计算
GregorianCalendar calendar3 = new GregorianCalendar(2999, 10, 9, 22, 10, 50);
calendar3.add(Calendar.MONTH, -7); // 月份减7
calendar3.add(Calendar.DATE, 7); // 增加7天
printCalendar(calendar3);
日期与时间对象转化
Date d = calendar3.getTime();
GregorianCalendar calendar4 = new GregorianCalendar();
calendar4.setTime(new Date());
file类
代表文件和目录
应用：打印目录树
枚举
需要定义一组常量时，使用枚举
异常机制（Exception）
本质：
当程序出现错误，程序安全退出的机制
定义：
在程序的运行过程中发生的不正常的事件。异常会中断正在进行的程序
异常的分类
异常处理过程：
抛出异常
捕获异常
解释：当Java程序出现以上异常时，就会在所处的方法中产生一个异常对象。这个对象包括异常的类型，异常出现时程序的运行状态以及对该异常的详细描述
异常处理方式
捕获异常
try-catch-finally
异常类型
声明异常
throws
自定义异常
容器
IO流
File类
定义
代表文件和路径（文件夹）
常用方法
访问文件名
getName()--获取当前文件名或文件夹名称
getPath()--获取文件夹或文件的路径
getAbsoulteFile()--返回一个用当前的文件的绝对路径构建的file对象
getAbsolutePath()--获取文件夹或文件的绝对路径
getParent()--返回当前文件或文件夹的父级路径
renameTo(new File("路径/路径+文件名"))--给文件或文件夹重命名
文件检测
exists()
canWrite()
canRead()
isFile()--判断当前的file对象是不是文件
isDirectory()--判断当前的file对象是不是文件夹或路径
获取常规文件信息
lastModify()--获取文件的最后修改时间，返回的是毫秒数
Length()--获取文件的长度，单位是字节数
文件操作相关
createNewFile()--创建新的文件
delete()--删除文件
目录操作相关
mkDir()--创建单层目录
mkDirs()--直接创建多层目录
list()--返回当前文件夹的子集的名称，包括目录和文件
listFiles()--返回当前文件夹 的自己的file对象，包括文件夹和目录
利用迭代的方法输出某一路径下的全部文件夹名称及文件名
注意事项
File能新建，删除，重命名文件和目录，但File不能访问文件内容本身。若需要访问文件内容本身，则需要使用输入输出流
IO原理
理解
IO流用来处理设备间的数据传输
Java程序中，对于数据的输入/输出操作以“流（stream）”的方式进行
java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过标准的方法输入或输出数据。
自己的理解：IO操作更像是将数据源的目标文件转换成一种特殊的存在形式（比如可以想象类比成水），在这种存在形式下数据可以被以流的传输方式将数据传输到数据的目的地
自己的理解：流是一种处理数据的方式方法，用这种方法处理数据传输数据时会让数据的存在形态改变？可以将数据被处理时的存在状态称为流。流既是一个动词也是一个名词
注意事项
处理数据时，一定要先明确数据源和数据目的地
数据源可以是文件，可以是键盘
数据目的地可以是文件、显示器或者其他设备
流是用来处理数据的。流只是在帮助数据进行传输，并对传输的数据进行处理，比如过滤处理，转换处理等。
流的分类
抽象基类
字节流 字符流
输入流 InputStream Reader
输出流 OutputStream Writer
文件字符流
FileInputStream
FileOutPutStream
文件字节流
FileReader
FileWriter
缓冲流
BufferedInputStream
BufferedOutputStream
BufferedReader
BufferedWriter
缓冲流是将数据缓冲到内存里，在内存中去做IO操作。基于内存的IO操作比基于硬盘快75000多倍
转换流
InputStreamReader
OutputStreamWriter
转换流可以将字节流转化成字符流，当字节流中的数据都是字符时使用转换字符流处理效率更高
FileInputStream fs = new FileInputStream("D:\\eclipse\\eclipse-workspace\\IO\\src\\day13\\tt5.txt");
//把字节流转化成字符流
InputStreamReader in = new InputStreamReader(fs,"UTF-8");//参数1是字节流，参数2是编码
标准输入输出流
System.in和System.out分别代表了系统标准的输入和输出设备
默认输入设备是键盘，输出设备是显示器
数据流
为了方便地操作Java语言的基本数据类型的数据，可以使用数据流。
DataInputStream
DataOutputStream
注意事项
用数据输出流写到文件中的基本数据类型的数据，是乱码，不能直接辨认出来，需要数据输入流来读取
用数据输入流读取数据输出流写到文件中的数据时，要保证使用和当时写的数据类型一致的类型来读取
对象流
用于存储和读取对象的处理流。对象被序列化后存储到指定位置是以IO流的形式存储的
序列化(Serialize)：将一个Java对象写入IO流中，用ObjectOutputStream类。因为需要将对象序列化的IO流放到指定的文件中，所以用output
反序列化(Deserialize)：从IO流中恢复该Java对象，用ObjectInputStream类。因为要从指定文件中读取被序列化的对象，读到再将对象从IO流中进行恢复，所以用input
注意事项：
不能序列化 static和transient修饰的成员变量，即序列化和反序列化是针对当前对象的各种属性，不包括类的属性（比如类的成员变量，类的成员方法）
对象序列化和反序列化使用的类要严格一致，包名，类名，类结构等等要严格一致
随机存取文件流
流使用的步骤
创建源——选择流——操作——关闭资源。一般创建源和选择流一起操作
关闭流时，最晚开的最早关，依次关
知道有什么类，常用类下有什么常用方法
反射
定义
反射机制，就是通过一个抽象的类名能够在自己记忆（加载类的内存）中找到相匹配的类的具体信息
前提：JVM已经加载这个类，相当于人脑有了这个类的记忆
理解
Reflection（反射）是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法
功能
在运行时判断任意一个对象所属的类
在运行时构造任意一个类的对象
在运行时判断任意一个类所具有的成员变量和方法
在运行时调用任意一个对象的成员变量和方法
生成动态代理
反射相关的主要API：
java.lang.Class:代表一个类
java.lang.reflect.Method:代表类的方法
java.lang.reflect.Field:代表类的成员变量
java.lang.reflect.Constructor:代表类的构造方法
应用
实例化class类对象
Class c0 = Person.class;//通过类名.class创建指定类的Class实例
Class c1 = p.getClass();//通过一个类的实例对象的getclass（）方法，获取对应实例对象的类的Class实例
Class c2 = Class.forName("day14.Person");//获取Class实例的常用方法
//通过Class的静态方法forName(String className)来获取一个类的Class实例
//forName(String className)方法中的参数是你要获取的Class实例的类的全路径（包名.类名）
通过反射调用类的完整结构
一个类极限情况都有什么？
一个父类，多个接口，多个构造方法，多个普通方法
或Field、Method、Constructor、Superclass、Interface、Annotation
Class clazz = Class.forName("day14.Student");//通过包名.类名的字符串，调用Class.forName方法获取指定类的Class实例.
通过反射取得类实现的全部接口
Class[] interfaces = clazz.getInterfaces();//获取当前类的所有接口
通过反射取得类所继承的父类
Class superClazz = clazz.getSuperclass();//获取父类
返回此Class对象所表示的类的所有构造方法
返回所有public构造方法
Constructor[] cons = clazz.getConstructors();//获取到类的公有的构造方法
返回所有构造方法
Constructor[] cons1 = clazz.getDeclaredConstructors();//获取类的所有的构造方法，包括公有和私有的
Constructor类中：
取得修饰符: cons1.getModifiers();
取得方法名称: cons1.getName();
取得参数的类型,有几个参数，数据的元素就有几个：cons1.getParameterTypes();
用反射的构造方法来创建对象
Object obj = clazz.newInstance();//相当于调用Student类的无参公有的构造方法
Student stu = (Student)obj ;
Constructor c = clazz.getConstructor(String.class);//指定获取有一个参数且参数为String类型的公有构造方法
Student stu1 = (Student)c.newInstance("第一中学");//通过newInstance实例化对象，相当于调用public Student(String school)
System.out.println(stu1.school);
通过反射机制可以强制调用私有的构造方法
Constructor c1 = clazz.getDeclaredConstructor(String.class,int.class);//指定获取有两个参数（string，int）的构造方法
c1.setAccessible(true);//解除私有的封装，下面就可以对这个私有方法强制调用
Student stu2 = (Student)c1.newInstance("张三",12);
返回全部的方法
获取到类的所有公有方法
Method [] ms = clazz.getMethods();
获取类的所有方法，包括公有和私有
Method [] ms = clazz.getDeclaredMethods();
Method类中：
取得修饰符ms.getModifiers();
取得全部的返回值:ms.getReturnType();
取得全部的参数:ms.getParameterTypes();
返回全部的属性
返回此Class对象所表示的类或接口的public的Field
返回此Class对象所表示的类或接口的全部Field
Field方法中：
以整数形式返回此Field的修饰符 fs.getModifiers()
返回Field的名称 fs.getName()
得到Field的属性类型 fs.getType()
获取类所在的包
Package p = clazz.getPackage(); //获取类所在的包
通过反射调用类中的指定方法、指定属性
调用指定方法
m.invoke(obj, "zhangsan","第一中学"); //参数1是需要实例化的对象，后面的参数是调用当前的方法的实际参数
Constructor con = clazz.getConstructor(); //获取无参构造
Object obj = con.newInstance(); //使用无参构造创建对象
Method m = clazz.getMethod("setInfo",String.class,String.class);//得到名称叫setInfo，参数是String，String的方法
m.invoke(obj, "zhangsan","第一中学"); //参数1是需要实例化的对象，后面的参数是调用当前的方法的实际参数
Object invoke(Object obj, Object … args)
说明：
1.Object 对应原方法的返回值，若原方法无返回值，此时返回null
2.若原方法若为静态方法，此时形参Object obj可为null
3.若原方法形参列表为空，则Object[] args为null
4.若原方法声明为private,则需要在调用此invoke()方法前，显式调用方法对象的setAccessible(true)方法，将可访问private的方法。
调用指定属性
Field f = clazz.getField("school"); //获取名称为school的属性
f.set(stu, "第三中学");//对stu对象的school属性设置值，
String school = (String)f.get(stu); //获取stu对象的school属性的值
System.out.println(school);
Field f1 = clazz.getDeclaredField("privateField");//获取私有属性
java动态代理
步骤
1.创建一个实现接口InvocationHandler的类，它必须实现invoke方法，以完成代理的具体操作。
2.创建被代理的类以及接口
3.通过Proxy的静态方法
newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h) 创建一个Subject接口代理
4.通过 Subject代理调用RealSubject实现类的方法
Proxy.newProxyInstance(ClassLoader, interfaces, h)
* 参数1是代理对象的类加载器
* 参数2是被代理的对象的接口
* 参数3是代理对象
* 返回的值是成功被代理后的对象,返回的是Object类型，需要根据当时的情况去转换类型
注意事项
如果一个对象想要通过Proxy.newProxyInstance方法被代理，
那么这个对象的类一定要有相应的接口。
就像例子中的ITestDemo接口 和实现类TestDemoImpl一样
看实例即可理解
线程
定义
程序
是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象
进程
是程序的一次执行过程，或是正在运行的一个程序。动态过程：有它自身的产生、存在和消亡的过程。
线程
进程可进一步细化为线程，是一个程序内部的一条执行路径。
理解
多线程
一个进程（一个程序运行时），可以分化为并行执行的多个线程（多个子程序）。多线程是进程的支流，当分支之后，就各自执行各自的程序。 类比河流的主流和支流
何时需要多线程
程序需要同时执行两个或多个任务
程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等
需要一些后台运行的程序时
使用多线程的优点
提高应用程序的响应。对图形化界面更有意义，可增强用户体验
提高计算机系统CPU的利用率
改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改
实现
Java语言的JVM允许程序运行多个线程，它通过java.lang.Thread类来实现。
Thread类的特性
每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常把run()方法的主体称为线程体
通过该Thread对象的start()方法来调用这个线程
构造方法
Thread()：创建新的Thread对象
Thread(String threadname)：创建线程并指定线程实例名
Thread(Runnable target)：指定创建线程的目标对象，它实现了Runnable接口中的run方法
Thread(Runnable target, String name)：创建新的Thread对象
控制台输出的结果是两条或多条并行程序的运行结果总和。这个结果需要拆开成两部分或多部份来看。与此同时可以看到每个线程各自保持了自己的输出顺序
应用
创建线程的两种方式
继承Thread类
1) 定义子类继承Thread类。
2) 子类中重写Thread类中的run方法。
3) 创建Thread子类对象，即创建了线程对象。
4) 调用线程对象start方法：启动线程，调用run方法
Thread t0 = new TestThread();// 继承thread类的线程
t0.start();// 启动线程
实现Runnable接口
1）定义子类，实现Runnable接口。
2）子类中重写Runnable接口中的run方法。
3）将Runnable接口的子类对象作为实际参数传递给
Thread类的构造方法中。
4）通过Thread类含参构造器创建线程对象。
5）调用Thread类的start方法：开启线程，调用
Runnable子类接口的run方法。
Thread t3 = new Thread(new TestRunnable());
t3.start();
两种方式的区别
继承Thread: 线程代码存放Thread子类run方法中。重写run方法
实现Runnable：线程代码存在接口的子类的run方法。实现run方法
实现接口方式的好处
1）避免了单继承的局限性
2）多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源。——thread类实现时，每开一个线程就要新建一个thread子类的对象
一般使用实现接口方式来实现多线程
Thread类的有关方法
void start(): 启动线程，并执行对象的run()方法
run(): 线程在被调度时执行的操作
String getName(): 返回线程的名称
void setName(String name):设置该线程名称
static currentThread(): 返回当前线程
线程的优先级
10级最高，1级最低，默认是5级
线程的优先级和买彩票的概率一样，概率再高也可能不中奖
getPriority() ：返回线程优先值
setPriority(int newPriority) ：改变线程的优先级
static void yield()：线程让步
暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程
若队列中没有同优先级的线程，忽略此方法
join() ：线程夹塞
当某个程序执行流中调用其他线程的 join() 方法时，调用线程将被阻塞，直到 join() 方法加入的 join 线程执行完为止
低优先级的线程也可以获得执行
static void sleep(long millis)：(指定时间:毫秒)
令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后重排队。
抛出InterruptedException异常
stop(): 强制线程生命期结束
boolean isAlive()：返回boolean，判断线程是否还活着
线程的生命周期
新建： 当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件
运行：当就绪的线程被调度并获得处理器资源时,便进入运行状态， run()方法定义了线程的操作和功能
阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行，进入阻塞状态
死亡：线程完成了它的全部工作或线程被提前强制性地中止
线程的同步
安全问题出现的原因
当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行。导致共享数据的错误。
解决方法
对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行——使用同步锁
语法格式
在方法声明中，表示整个方法
为同步方法。
public synchronized void show (String name){
….
}
在普通方法上加同步锁synchronized，锁的是整个对象，不是某一个方法
不同的对象就是不同的锁，普通方法加synchronized，线程使用不同的对象执行此方法时，还是有共享资源的问题
public static synchronized void show (String name){
….
}
静态方法加synchronized，对于所有的对象都是同一个锁
对代码块声明，表示某一块代码为同步方法
synchronized (对象）{
// 需要被同步的代码；
}
理解
静态方法锁Class,普通方法锁对象
静态方法——相当于公司一共有3000块钱，公司里的所有人（类的所有对象）的总支出不能超过3000
普通方法——有很多个人（很多对象），每个人都有3000块钱，每个人的总支出不超过3000即可，在满足前面的条件下至于多个人的总支出是否超过3000块都无所谓
普通方法加同步锁，锁的是当前方法对应的对象。当前对象所有加了同步锁的方法是共用一个同步锁
静态方法加同步锁，是对于所有的对象都是使用同一个锁
线程的死锁
理解
不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
解决方法
使用专门的算法、原则，比如加锁顺序一致
尽量减少同步资源的定义，尽量避免锁未释放的场景
线程的通信
常用方法
wait()：令当前线程挂起并放弃CPU、同步资源，使别的线程可访问并修改共享资源，而当前线程排队等候再次对资源的访问
在当前线程中调用方法： 对象名.wait()
使当前线程进入等待（某对象）状态 ，直到另一线程对该对象发出 notify (或notifyAll) 为止。
notify()：唤醒正在排队等待同步资源的线程中优先级最高者结束等待
在当前线程中调用方法： 对象名.notify()
notifyAll ()：唤醒正在排队等待资源的所有线程结束等待
注意事项
wait() 与 notify() 和 notifyAll() 这三个方法只能用在有同步锁的方法或代码块上
网络编程
定位
IP-定位机器
IP:定位一个节点：计算机、路由器、通信设备
* InetAddress:多个静态方法
* 1. getLocalHost:本机
* 2. getByName:根据域名对应的去解析IP地址 或 根据IP地址解析IP地址
两个成员方法：
* getHostAddress()：返回地址
* getHostName()：返回计算机名
端口-定位机器上的软件
端口
* 1 区分软件
* 2 两个字节 0-65535
* 3 同一个协议端口不能冲突
* 4 定义端口越大越好
* InetSocketAddress
* 1 构造器
* new InetSocketAddress(地址|域名,端口);
* 2 方法
* getAddress()
* getPort()
* getHostName()
URL-定位软件的资源
URL: 统一资源定位器，区分资源
* 1 协议
* 2 域名或计算机名
* 3 端口：http默认80
* 4 请求资源
* http://www.baidu.com:80/index.html?uname=shsxt&agr=18#a
底层的传输协议
TCP
Client 客户端
创建客户端
* 1 建立连接： 使用 Socket创建客户端+服务器的地址和端口
* 2 操作：输入输出流操作
* 3 释放资源
Sever 服务器
创建服务器
* 1 指定端口 使用ServerSocket创建服务器
* 2 阻塞式等待连接 accept
* 3 操作：输入输出流操作
* 4 释放资源
底层使用IO流
UDP
Client 发送端
发送端
* 1 使用 DatagramSocket()指定接口 创建发送端
* 2 准备数据 一定要转成字节数组
* 3 封装成DatagramPacket 需要指定目的地
* 4 发送包裹 send(DatagramPacket p)
* 5 释放资源
Sever 接收端
接受端
* 同一个协议下端口不允许冲突
* 1 使用 DatagramSocket()指定接口 创建接收端
* 2 准备容器 封装成DatagramPacket
* 3 阻塞式接受包裹 receive(DatagramPacket p)
* 4 分析数据
* byte[] getData()
* getLength()
* 5 释放资源
•不需要利用IO流实现数据的传输
•每个数据发送单元被统一封装成数据包的方式，发送方将数据包发送到网络中，数据包在网络中去寻找他的目的地。