一、Java的基本语法
Java程序的基本结构大体分为包、类、main()方法、标识符、关键字、语句、注释等。
Java代码的基本格式：
Package 包名;
Import package1[.package2…].类名;
修饰符 class 类名{
类体;
}
包、import：Java语言中的一个package（包）就是一个库类单元。
类：Java程序是由类（class）组成的。
Main()方法：main()方法是Java程序执行的入口。
方法：方法用于改变对象的属性，或者用于接受来自其他对象的信息以及向其他对象发送消息。
标识符：标识符是指用来标识Java中的包、类、方法、变量、常量等的名称。
标识符的命名规则：
（1）标识符由字母（az，AZ）、数字、下划线（_）和美元符号（$）组成。
（2）标识符首字母不能使用数字。
（3）标识符不能是关键字，例如class。
（4）标识符区分大小写。
关键字：关键字属于一类特殊的标识符，不能作为一般的标识符来使用，如public、static等。
修饰符：修饰符指定数据、方法及类的属性的可见度，如public、protected、private等，被他们修饰的数据、方法或者类的可见度是不同的。
程序块：程序块是指一对大括号之间的内容。
语句：在Java程序中包含很多使用“；”结束的句子，即语句。语句的作用是完成一个动作或一系列动作。
Java代码的注释
（1）单行注释：//注释内容
（2）多行注释：/* 注释内容 */
（3）文档注释：/**注释内容 */
常量与变量
常量：常量就是在程序中固定不变的量，一旦被定义，它的值就不能再被改变。在定义常量时需要对常量进行初始化。常量名称通常用大写字母
变量：在程序中存在大量的数据来代表程序的状态，其中有些数据的值字在程序的运行过程中会发生改变，这种数据被称为变量。
变量是有作用范围的，一旦超出它的范围，就无法再使用这个变量。按作用范围进行划分，变量分为成员变量、局部变量和类变量。
成员变量：成员变量声明在一个类中，它的作用范围为整个类。
局部变量：局部变量在方法、构造方法或者语句块中声明，局部变量只在声明它的方法、构造方法或者语句块中可见。
类变量（静态变量）：类变量也成为静态变量，在类中以static关键字声明，但必须在方法、构造方法和语句块之外。
静态成员变量的默认值和成员变量相似，数值型变量默认值是0，布尔型默认值是false，引用类型默认值是null。
数据类型分为两种：基本数据类型和引用类型（reference）。引用类型有类（class）、接口（interface）、和数组（array）3种。
Java语言的基本数据类型总共有8种，按用途划分为4个类别：整数型、浮点型、字符型和布尔型。
类型转换：在Java中，对于除了boolean类型以外的7种基本类型，在把某个类型的值直接付给另一种类型的变量时，这种方式称为基本类型转换。
自动类型转换：必须在两种兼容的数据类型之间进行，并且必须是由低精度类型向高精度类型转换。
强制类型转换：是将高精度类型向低精度类型进行转换。
运算符：根据操作的数目来分，运算符分为一元运算符、二元运算符、和三元运算符。根据功能来分，运算符分为赋值运算符、算数运算符、比较运算符、条件运算符、逻辑运算符、位运算符以及自增自减运算符。
流程控制：程序控制语句分为3类，1、分支语句，包括if语句和switch语句；循环语句，包括for循环语句、while循环语句和do……while循环语句；3、跳转语句，包括break语句，continue语句和return语句。
二、认识面向对象编程
面向对象方法（Object-Oriented Method）是一种把面向对象的思想应用于软件开发过程中，指导开发活动的系统方法。
对象是由数据和允许的操作组成的封装体。
所有的面向对象的编程设计语言都有3个特性，即封装性、继承性和多态性。
封装是把过程和数据包围起来，对数据的访问只能通过已定义的接口，一个对象和外界的联系应当通过一个统的接口。
属性的封装: Java 中类属性的访问权限默认值不是private, 要想隐藏属性或方法，就可以加private(私有)修饰符，来限制其只能在类的内部进行访问。对于类中的私有属性，要对其给出一对方法(getXxx(0,setXxx(0)访问私有属性，保证对私有属性的操作安全性。
方法的封装:对于方法的封装，该公开的公开，该隐藏的隐藏。方法公开的是方法的声明(定义)，即只须知道参数和返回值就可以调用该方法。隐藏方法会使方法的改变对架构的影响最小化。完全的封装将类的属性全部私有化，并且提供一对 方法来访问属性。
多态性：多态是把有着共同特性的多类事务抽象成一个类，这个类就是多类事务的父类。
多态的特性：对象事例确定则不可改变（客观不可改变）；只能调用编译时类型所定义的方法；运行时会根据运行时类型去调用相应类型中定义的方法。
类：在Java语言中，将具有相同属性及相同行为的一组对象成为类。
声明类的一般格式：
修饰符 class 类名{
类的成员变量;
类的成员方法;
}
成员变量：人们将对象的静态特征抽象为属性，用数据来描述，在Java语言中称为成员变量。
成员方法：人们将对象的动态特征抽象为行为，用一组代码来表示，完成对数据的操作，在Java语言中称之为成员方法。
创建对象：在Java语言中，使用new关键字来创建对象，一般格式为：
类名 对象名 = new 类名（[参数]）；
Main（）方法：在Java语言中，main（）方法是Java应用程序的入口，程序在运行的时候，首先执行的就是main（）方法。
Main（）方法的特点如下:
(1)方法的名称必须是main。
(2) main（）方法必 须是public static 类型。由于JVM在运行这个Java应用程序的时候，首先会调用main0方法， 调用时没有实例化这个类的对象，而是通过类名直接调用，因此需要限制为public static.
(3) main（）方法没有返回值， 返回类型为void。
(4) main(方法必 须接收-个 字符串数组参数，作用是接收命令行输入参数的，命令行的参数之间用空格隔开。
(5) main（）方法中 可以抛出异常，main()方法向上也可以声明抛出异常。
构造方法：构造方法是类中一种特殊的方法，主要是用来初始化类的一个新的对象。
Instanceof关键字：Java语言中的Instanceof关键字，用来在运行时指出对象是否是特定类的一个对象。
修饰符：在Java语言中有许多修饰符，只要分为访问修饰符和非访问修饰符两种。修饰符用来定义类、方法或者变量，通常放在语句的最前面。
访问修饰符：
(1)私有的访问修饰符——private
(2)默认的访问修饰符——不使用任何关键字
(3)受保护的访问修饰符——protected
(4)公有的访问修饰符——public
非访问修饰符：
Static修饰符：修饰类的成员变量和成员方法，也可以形成静态代码块。
Final修饰符：final关键字可以修饰类、方法和变量，意义不同，但本质相同，都表示不可变。用Final修饰的成员变量表示常量，值一旦给定就无法改变。
Final修饰类中方法：如果一个类不允许其子类覆盖某个方法，则可以把这个方法声明为final方法。
Final修饰类：final关键字声明的类不能被继承，即最终类。
abstract修饰符：abstract关键字用来修饰类，这个类称为抽象类。
抽象类：抽象类不能用来实例化对象，声明抽象类的唯一的是将来对该类进行扩充;抽象类可以包含抽象方法和非抽象方法。如果一个类包含若干个抽象方法那么该类必须声明为抽象类，抽象类可以不包含抽象方法；抽象方法的声明以分号结尾；抽象方法不能被声明成final和static；抽象方法是一种没有任何实现的方法，该方法的具，体实现由子类提供。任何继承抽象类的子类必须实现父类的所有抽象方法。
synchronized修饰符：synchronized关键字声明的方法同一时 间只能被一个线程访问。
Volatile修饰符：volatile修饰符的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。
封装：封装将对象的数据隐藏起来，其他对象不能直接访问这些数据，必须通过调用该对象的公共方法来间接访问。
This关键字：当一个对象创建后，Java虚拟机（JVM）就会为这个对象分配一个引用自身的指针，这个只针的名字就是this。
继承：继承就是子类继承父类的属性和行为，使得子类对象（实例）具有父类的实例和方法，或子类从父类继承方法，使得子类具有父类相同的行为。
在Java语言中继承的特性如下：
(1) 子类不能访问父类的private 成员，但子类可以访问其父类的public 和protected成员。
(2)子类中被继承的父类成员没有在子类中列出来，但是这些成员确实存在于子类中。
(3)子类也可以拥有自己的属性和方法，即子类可以对父类进行扩展。
(5) Java的继承是单继承，但是可以多层继承。
(6) 继承提高了类之间的耦合性。
多态：多态就是一个接口，在运行时，通过指向父类的对象，来调用实现子类中的方法。
重载：重载（overload）是指在一个类或者子类中，但方法的参数个数或参数类型不同。
重写：重写（override）又称覆盖，是指在面向对象中，子类可以改写从父类继承过来的方法。
方法重写的规则方法重写的规则如下：
(1) 参数列表必须完全与被重写方法的相同。
(2) 返回类型必须完全与被重写方法的返回类型相同。
(3) 重写后的方法不能比被重写的方法有更严格的访问权限(可以相同)。例如，在父类中声明方法为protected, 那么子类中重写该方法就不能声明为private, 可以为protected 或public。
(4)父类的成员方法只能被它的子类重写。
(5) 声明为final的方法不能被重写。
(6) 构造方法不能被重写。
(7)如果不能继承一个方法，则不能重写这个方法。
构造方法重载：重载的构造方法可以调用已经存在的构造方法，利于代码的重用。
Super关键字：super是指当前类或对象的直接父类或者父类对象，是对当前类或对象的直接父类或者父类对象的引用。
三、Java的内部类
内部类就是在一个类的内部再定义一个类
内部类可以是static的，也可用public、default、protected和private修饰。而外部类只能使用public和default修饰。
this和new的使用
引用内部类，需要指明它的类型。创建某个内部类对象，必须要用外部类的对象通过.new来创建。
创建内部类对象的一般语法格式：
外部类名外部类对象= new外部类名() ;
外部类名.内部类名内部类对象=外部类对象.new内部类名() ;
产生外部类对象的引用，一般语法格式:
外部类名外部类对象= new外部类名() ;
外部类名.this
成员内部类：成员内部类是最普通的内部类，它是外部类的一个成员，所以它可以无限制地访问外部类的所有成员变量和方法，即使是private修饰的也可以访问;但是外部类要访问内部类的成员属性和方法则需要通过内部类实例。
关于成员内部类要注意以下两点：
- 成员内部类中不能存在任何static的变量和方法。
- 成员内部类是依附于外部类的，所以只有先创建了外部类才能够创建内部类。
静态内部类：static关键字除了可以修饰成员变量、方法、代码块外，还可以修饰内部类。使用static修饰的内部类，称为静态内部类（也称嵌套内部类）。
局部内部类：在方法或作用域中定义的内部类叫局部内部类
匿名内部类：匿名类，顾名思义，就是没有名称。在Swing编程中，会经常使用这种方式来绑定事件。
匿名类需要注意以下几点：
(1)匿名内部类后面的分号不可缺少。
(2)匿名内部类没有访问修饰符。
(3)new匿名内部类时，这个类首先要存在。
(4)被匿名内部类使用的方法的形参必须用final修饰。
(5)匿名内部类没有构造方法。
四、数组和方法
数组：数组是具有相同数据类型的变量集合，这些变量都可以通过索引进行访问。根据数组的维度来划分，数组主要分为一维数组、二维数组和多维数组。
数组的声明：要使用Java中的数组，必须先声明数组，再为数组分配空间。
数组类型：指明数组中元素的类型。它可以是Java中的基本数据类型，也可以是引用类型。
声明的语法格式：
数据类型 数组名[ ]；
数组类型 数组名；
数组的内存分配：
数组名 = new 数据类型 [数组的长度]；
数组类型[] 数组名 = new数据类型 [数组的长度]；
数组的元素：数组中的每个元素都拥有同一个数组名，通过数组的下标来唯一确定数组中的元素。
数组名：数组的名称。
下标：下标的值的范围是0到“数组元素个数减一”。
数组的声明并出=初始化数组的一般格式：
数据类型 数组名[ ] = {初值1，初值2，初值3，……，初值n}；
多维数组声明：
数据类型 数组名 [ ][ ]；
数据类型 [ ] 数组名 [ ]；
数据类型 [ ][ ] 数组名；
数组的内存分配：
数据类型 [ ][ ] 数组名 = new数据类型 [第一维数][第二维数]；
数组元素：
数组名 [第一维下标][第二维下标]
数组的赋值：
数组类型 数组名 [ ][ ] = {{初值1，初值2，初值3}，{初值4，初值5，初值6}…}；
遍历数组：
var arr = [“first”,“second”,“third”,“fourth”,3,5,8];
for(var i = 0; i < arr.length;i++){
console.log(arr[i]);
}
//输出：
first
second
third
fourth
3
5
8
for… in
var arr = [“first”,“second”,‘third’ ,“fourth”,3,5,8];
for(var i in arr){
console.log(arr[i] +’/’ + i);
}
//输出结果为：
first/0
second/1
third/2
fourth/3
3/4
5/5
8/6
for…of
var arr = [“first”,“second”,‘third’ ,“fourth”,3,5,8];
for(var item of arr){
console.log(item);
}
//输出结果：
first
second
third
fourth
数组排序
（1）冒泡排序：
public class BubbleSort {
public void bubble(Integer[] data){
for(int i=0;i<data.length;i++){
for(int j=0;j<data.length-1-i;j++){
if(data[j]>data[j+1]){ //如果后一个数小于前一个数交换
int tmp=data[j];
data[j]=data[j+1];
data[j+1]=tmp;
}
}
}
}
}
（2）选择排序：
public static void selectSort(int[] arr)
{
for(int i=0;i<arr.length;i++)
{
for(int j=i+1;j<arr.length;j++)
{
if(arr[j]<arr[i])
{
huan(arr,i,j);
}
}
}
}
public static void huan(int[] arr,int i,int j)
{
int c;
c = arr[i];
arr[i] = arr[j];
arr[j] = c;
}
public static void print(int[] arr)
{
for(int i=0;i<arr.length;i++)
{
if(i!=arr.length-1)
System.out.print(arr[i]+",");
else
System.out.print(arr[i]);
}
}
五、不可不说的文本数据 字符串
String类的本质”
- String类是final类，也即意味着String类不能被继承，并且它的成员方法都默认为final方法。在Java中，被final修饰的类是不允许被继承的，并且该类中的成员方法都默认为final方法。
- String类中所有的成员属性，从上面可以看出String类其实是通过char数组来保存字符串的。
- String的定义方法归纳起来总共为三种方式：
- 使用关键字new，如：String s1 = new String(“myString”);直接定义，如：String s1 = “myString”;串联生成，如：String s1 = “my” + “String”。
String的API的应用
JDK的API中的String类提供了许多操作方法，都在java.lang包中。
1.获取字符串的长度：使用String类提供的length()方法。字符串变量.length()。
2.去除字符串的空格：使用String类中的trim()方法去除空格。字符串的变量.trim()。
3.字符串分割：使用String类中的Split()方法。String[] split(String regez),String[] split(String regex,int limit)。
4.转换大小：使用toLowerCase()方法将大写字符串转换成小写字符串，toUpperCase()方法将小写字符串转换成大写字符串。String toLowerCase(),String toUpprt。
5.字符串截取：是使用substring()方法，在字符串中截取子字符串。String返回一个新的字符串，它是被截取字符串的一个子字符串。beginIndex截取字符开始的位置，包含它，endIndex截取字符串结束的EndIndex-beinIndex,字符串的长度。
6.字符串的连接：使用“+”号，格式String s=s1+s2+s3使用String类提供的concat()方法格式String contest（String str）。
7.字符串比较：
（1）使用String类的“”、equals()和equalsIgnoreCase(),””比较两个对象，比较内存地址及内容是否相同，相同结果为true,否则为false。Equsls()方法比较两个对象时，比较的是两个对象的值是否相同，与对象的内存的地址无关。equalsIgnoreCase()方法将String与String进行比较，不考虑大小。
（2）compareTo()按字典顺序比较两个字符串按和compareTolgnoreCase()按字典顺序比较两个字符串，不考虑大小。
（3）startsWith()是测试字符串是否已指定的前缀开始和endWith()测试字符串是否已指定后缀结束。
8.字符串的查找（1）charAt()方法，返回指定索引处的char值（2）indexOf()方法，搜索指定字符串中第一次出现的位置（3）lastIndexOf方法，搜索指定字符串中最后垂涎的位置。
9.字符串的替换：replace()方法，返回一个新的字符串，它是通过新字符newChar替换字符串中出现的所有旧字符oldChar。Replac的eFirst()方法替换字符串中匹配的第一个字符串，replaceAll（）方法，替换字符串中匹配的子字符串。
六、字符串解析
1.^表示匹配字符串的开始位置 (例外 用在中括号中[ ] 时,可以理解为取反,表示不匹配括号中字符串)
2.$表示匹配字符串的结束位置,表示匹配零次到多次,+表示匹配一次到多次(至少有一次)
3.?表示匹配零次或一次,.表示匹配单个字符,|表示为或者,两项中取一项,() 小括号表示匹配括号中全部字符,[] 中括号表示匹配括号中一个字符 范围描述 如[0-9 a-z A-Z],{ } 大括号用于限定匹配次数 如 {n}表示匹配n个字符 {n,}表示至少匹配n个字符 {n,m}表示至,n,最多m,\转义字符 如上基本符号匹配都需要转义字符 如 *表示匹配号,\w 表示英文字母和数字 \W 非字母和数字,\d 表示数字 \D 非数字
4.正则表达式的实例，使用String提供的方法matches()方法，用于检查字符串是否匹配给定的正则表达式，格式public Boolean matches(String regex)。
字符串的类型转换
1.字符串转换为数组，使用String类提供的toCharArray()方法，将字符串转换为一个新的数组。
2.基本数据类型的转换：使用String类提供valueof()方法，返回参数数据类型的字符串表示形式。
3.格式化字符串：使用String类中，提供format()方法格式化字符串。
StringBuffer与StringBulider
1.StringBulider类的创建，创建一个空的字符串缓冲区，初始容量为16个字符串，格式public StringBulider(int capacity)创建空字符缓冲区，并指定初始容量大小是capacity的字符串缓冲区、StringBulider(String str)创建一个字符缓冲区。
2.StringBulider类的方法：提供了append()方法，可以接受任意类型的数据，提供许多重载的inser()方法，提供两个删除字符串中字符的方法，deleteCharAT()方法，用于删除字符串中指定位置符，delete()方法用于删除字符串中指定开始和结束的位置的字符串。
Lambda表达式
格式:
（1）（parameters）->expression
（2）（parameters）->(_statements)
七、衔接更便利-抽象类与接口
抽象类和抽象方法
- 抽象类：使用abstract关键字修饰，格式abastract class 类名{类体}定义抽象类Fruit,格式 public abastract class Fruit{}。
- 抽象方法：声明抽象方法abstract 返回类型 方法名（[参数表]）。
接口概述 - 接口是比抽象类更高的抽象，它是完全抽象的类，即抽象的方法的集合，用interface来声明。
接口与抽象类
1.相同点：
（1）都可以被继承。
（2）都不能被直接实例化。
（3）都可以包含抽象方法。
（4）派生类必须实现未实现的方法。
2.不同点：
（1）接口支持多继承，抽象类不能实现多继承。
（2）一个类只能继承一个抽象类，而一个类却可以实现多个接口。（3）接口中的成员变量是public、static、final类型的，抽象类中的成员变量可以是多种类型。
（4）接口只能定义抽象方法，抽象类既可以定义抽象方法，也可以实现定义的方法。
（5）接口中只能含静态代码块与静态方法。
接口的多态
接口的多态需要满足3个条件：继承关系、方法重写、父类引用指向子类对象。
集合框架
1.Java集合的接口：
（1）collection接口，定义了存取一组对象大方法，是最基本的接口。（2）set接口，继承collection接口，包含的数据没有顺序且不可以重复。
（3）list接口，继承collection接口，包含数据的顺序且可以
（4）map接口，是一个单独接口，不继承collection接口，是一种把键对象和值对象进行关联的容器，不包含重复的键。
2.java集合中的实现类：
（1）HashSet:实现Set接口，还实现Sorted接口，可以实现对集合的自然排序。
（2）TreeSet:不仅实现Set接口，还实现了Sorted接口，可以实现自然排序。
（3）ArrayList:实现了List接口，有序集合，大小可变。
（4）LinkedList:实现List接口，有序集合，通过一个链表的形式实现List接口、适合插入和移除元素。
（5）HashMap：实现一个“键值”映射的哈希表，通过键获取对象，没有顺序，通过get(key)方法获取value的值。
collection接口
是Set接口和List接口的父接口，是最基本的接口。用iterator方法 ，返回一个实现Iterator接口对象。Collection不能实例化，通过ArrayList实现调用Collection接口的方法。
八、不可避免的问题-处理异常
异常的分类
1.异常类分为运行时异常和非运行时异常
（1）error用于Java运行时系统来显示与运行系统本身有关错误。（2）Exception用于程序可能捕货异常情况，可以用来创建自定义异常类，RuntimeException包括除数和为零和数组下标越界等
（3）非运行异常是指包括RuntionException以为的异常，是必须进行捕获的异常。
捕获异常
1.try-catch语句，try是捕获可能发生异常的代码段，catch是对发生的异常处理。
2.多条catch语句，当try语句发生多种异常，可以通过多个catch语句分别处理。
3.finally语句在异常处理中是收尾工作，用来保证程序的健壮性。
声明异常
在java中方法发生异常，但是本身不能或者不知道如何处理这个异常，可以使用throws关键字来声明抛弃这个异常，格式 throw new异常类（）。
自定义异常
自定义异常继承Exception类或Exception类的子类。Exception类没有提供方法，但它继承了Throwable类。因此继承了Throwable类定义的方法，格式class 异常类名 extends Exception。
九、Java中的输入与输出类型
I/O简介
1./O分类
（1）按照数据流大方向不同：输入流与输出流
（2）按处理数据单位不同:字节流与字符流
（3）按照功能不同：节点流和处理流。
2.预定义流：在java.lang包中有一个预定义流System,在运行程序时，系统会自动导入这个包。System.err标准错误输入流、System.in标准输入流、System.out标准输出流。
文件处理
1.file类，提供4种抽象方法
（1）public file（file parent，String child）,parent是父抽象路径名，child是子路径名字符串。
（2）public File(String pathname)pathname是路径名字符串。
（3）public File(String parent,String child)parent是父抽象路径字符串，child是子路径名字符串
（4）public File(URL uri)通过将给定的uri转换为一个抽象路径名来创建一个新的File实例。
字节流
1.InputStream是一个抽象类，是java.io包中所有字节输入流的父类。
2.OutputStream是一个抽象类，它是java.io包中所有字节输出流的父类。返回类型是void,在方法出错时会引起IOException异常。
字符流
1.Reader抽象类是所有字符输入流的父类。
2.Writer抽象类类所有字符输出流的父类。
节点流
1.FileInputStream流，用于处理字节文件，它是InputStream类的子类，实现父类的抽象方法,用来读取字节文件。
2.FileOutStream流用于处理字节文件，它是OutputStream类的子类，实现父类的抽象方法，写入字节文件。
3.FileReader用来处理文件字符。是InputStreamReader类的子类，它本身没有新的方法，所有方法都来自父类，读取文件字符。
4.FileWriter流用来处理文件字符，是OutputStreamWriter类的子类，它本身没有新的方法，所有方法都来自其父类，写入字符文件。
处理流
1.缓冲流：是要套接在相应的节点流上，对数据提供了内置的缓冲区功能，提高了读写效率。BufferedInPutStream和BufferedOutputStream是缓冲读写字节流，可以一次读写多个字节，以优化系统性能。
2.BufferedReader和BufferedWriter是缓冲区读写字符流，可以一次读写多个字节。
数据流
数据输入流DataInputStream和数据输出流分别继承InputStream和OutputStream,它们属于数据处理流，分别套在InputStream和OutputStrame类型的节点流上。
转换流
InputStreamReader和OutputStreamWeiter分别继承Reader和Writre,实现了父类所有抽象方法，是用于处理字符流的基本类。分别需要与InputStream和OutStreamStram节点流套接。
Print流
1.PrintStream类打印字符都使用平台默认的字符编码来转换字节，它提供的常用构造方法。
2.PrintWriter是使用的字符而不是字节。
Object流
1.ObjectInputStream完成对对象的读取。
2.ObjectOutputStream完成对对象的写入。
十、进程
进程：是指处于运行过程中的程序，有独立的代码和空间。
线程：是指同一类线程共享资源。
多进程：是指同时运行多个程序。
多线程：是指在同一程序中，多个顺序流同时运行。
实现线程的两种方式
1.Thread
Java.lang.Tread类是线程类，它实现Runable接口。Thread类提供了一个run()方法，run()方法的方法体是线程要执行的代码。Thread类中的run()方法是一个空方法，因此继承Thread类的子类必须重写此类的方法。
public class Thread1 extends Thread {
private String name;
public Thread1(String name){
this.name=name;
}
@Override
public void run() {
for (int i = 0; i <5; i++) {
System.out.println(i+"运行："+name);
try {
sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
Thread1 t1 = new Thread1("A");
Thread1 t2 = new Thread1("B");
t1.start();
t2.start();
}
}
2.Runable接口
Runable接口中只有一个run()方法 它的方法体是线程要运行的代码，因此实现Runable接口的类必须重写这个方法。使用Runable接口可以为多个线程提供共享的数据，在run()方法中可以使用Thread类的currentThread()静态方法，以获取当前线程的引用。
public class Thread3 implements Runnable{
private String name;
public Thread3(String name){
this.name=name;
}
@Override
public void run() {
for (int i = 0; i <5; i++) {
System.out.println(i+"运行："+name);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
new Thread(new Thread3("C")).start();
new Thread(new Thread3("D")).start();
}
}
实现Runnable接口比继承Thread类所具有的优势：
（1） 适合多个相同的程序代码的线程去处理同一个资源
（2） 可以避免java中的单继承的限制
（3） 增加程序的健壮性，代码可以被多个线程共享，代码和数据独立
线程状态转换
（1） 创建状态。New关键字和Thread类或者其子类创建一个线程对象后，该线程对象就处于创建状态直到调用start()方法启动这个线程之前。
（2） 就绪状态。线程调用start()方法后，进入就绪状态。
（3） 运行状态。获得资源后运行程序。
（4） 阻塞状态。因为某些情况，该线程让出占用的当前系统资源，进入阻塞状态。
（5） 挂起状态。调用suspend()方法时线程挂起。
（6） 睡眠状态。调用sleep()方法时，进入睡眠状态。
（7） 等待状态。调用wait()方法时，进入等待状态。当另一个线程调用notify()方法时，第一个线程进入就绪状态。
（8） 终止状态。线程执行完成或者调用stop()方法时，进入终止状态。
3.Java中的反射
反射是指允许在程序运行状态时，对任意一个类可以获取它的所有属性和方法，对任意一个对象可以调用它的任意一个方法和属性，这种动态获取信息以及动态调用对象方法的功能称为Java语言的反射机制。
java.lang.class
(1)获取Class对象的方法getClass()方法
Person p=new Person();
Class clazz=p.getClass();
(2)调用某个类的class属性来获取该类对应的Class对象
Class clazz=Person.class;
(3)调用包的地址
Calss clazz=Class.forName("");
java.lang.reflect.Method
(1)获取类的所有方法信息getDeclaredMethods();
(2)获取类的公有方法信息getMethods();
java.lang.reflect.fields
(1)获取类的所有成员属性信息getDeclaredFields()
(2)获取类的公有成员属性信息getFields()
java.lang.reflect.constructor
(1)获取类的所有构造方法信息getDeclaredConstructors()
(2)获取类的公有构造方法信息getConstructors()
4.创建实例的两种方式
(1)使用Class对象的newInstance()方法来创建该Class对象对应类的实例，但是这种方法要求该Class对象对应的类有默认的空构造器。
(2)先使用Class对象获取指定的Constructor对象，再调用Constructor对象的newInstance()方法来创建 Class对象对应类的实 例,通过这种方法可以选定构造方法创建实例。
包装类
Java包装类，就是将Java中的8种基本数据类型分别包装成为类的形式。
装箱与拆箱——实现基本数据类型与包装类之间的相互转换
基本数据类型和包装类之间的转换是通过装箱与拆箱来实现的。包装类提供了装箱和拆箱的方法，例如：
通过包装类的构造方法，我们可以实现装箱
Integer a = new Integer(5);//装箱
通过包装类的拆箱方法，我们可以实现拆箱
Float a = new Float(64.6f);//装箱
float b = a.floatValue();//拆箱
在JDK1.5之前，装箱与拆箱需要通过以上方式手动实现，在JDK1.5之后，Java提供了自动装箱和拆箱机制，例如：
Integer i = 60; //自动装箱
Float f = 66.6f;//自动装箱
int a = i;//自动拆箱
Float b = f;//自动拆箱
日期操作类
Date类
import java.util.Date;
public class t {
public static void main(String[] args) {
Date date =new Date();
System.out.println(date);
/*
* 计算明天此刻的时间
*/
long time =date.getTime();
time = time+24*60*60*1000;
date.setTime(time);
System.out.println(date);
}
}
SimpleDateFormat
SimpleDateFormat就是根据一个特定的日期格式在字符串与Date之间相互转换。
import java.util.;
import java.text.;
public class DateDemo05 {
public static void main(String[] args) {
String strData=“2016-09-26 10:11:30.123”;//定义日期时间的字符串
String pat1=“yyyy-MM-dd HH:mm:ss.SSS”;//准备第一个模板，从字符串中提取日期数字
String pat2=“yyyy年MM月dd日 HH点mm分ss秒SSS毫秒”;//准备第二个模板，从字符串中提取日期数字
//必须要根据模板实例化对象
SimpleDateFormat sdf1=new SimpleDateFormat(pat1);//实例化模板对象
SimpleDateFormat sdf2=new SimpleDateFormat(pat2);//实例化模板对象
Date d=null;
try {
d=sdf1.parse(strData);//提取字符串中的日期
} catch (ParseException e) {
e.printStackTrace();
}
System.out.println(sdf2.format(d));
}
}