0基础JAVA期末复习最终版

啊啊啊啊啊啊啊啊啊啊，根据网上各位大佬的复习资料，看了很多大多讲的是基础但对内容的整体把握上缺乏系统了解。但是很不幸最终挂科了，那个出题套路属实把我整神了，所以我决定痛改前非，酣畅淋漓的写下这篇文章。。。。。

一：Java：

JDK JRE JVM

JDK:标准的开发包，提供系统编译、运行Java程序所需的各种工具和资源，包括java编译器，java运行时环境，java类库。

JRE：java运行环境，用于解释执行java的字节码文件。

JVM：java虚拟机。负责解释执行字节码，是可运行java字节码文件的虚拟计算机。

区别：JDK包含了JRE,JDK和JRE包含了JVM.

JDK包含了除JRE还包含了常用的开发工具和基础库类。

JDK用于开发，JRE用于运行java程序。

JVM是java编程语言的核心且具有平台独立性

一个java文件里面只能有一个public class

开发的Java程序需要三个步骤

1.编写源文件

2编写源文件产生字节码

3加载运行字节码

java程序运行过程

javac：java源文件->class字节码文件（0，1）

java：运行class文件

java程序语句执行顺序

java程序语句执行顺序包括4种基本控制结构：顺序结构、选择结构、循环结构、异常处理结构。

二：java编程基础

1.java基本语法

权限修饰符返回值声明方法名称（参数列表）{

方法中封装的逻辑功能；

return返回值；

}

权限修饰符
	类内部	本包	子类	外部包
public	√	√	√	√
protected	√	√	√	×
default	√	√	×	×
private	√	×	×	×

2.注释

1.//

2./* */

3/** **/

3.数据类型概述

数据类型决定了它们的表示方式、取值范围以及可用操作。

4.常量变量

变量定义：

变量包括：变量类型、变量名、作用域

按所属的数据类型划分：基本数据类型变量引用数据类型变量

按被声明位置划分：

局部变量：方法或语句块内部定义的变量

成员变量：方法外部、类的内部定义的变量

变量的类型转换

boolean类型不能转换成其它的数据类型

自动类型转换：由小到大 byte，short，int——float——long——double

byte，short，int不会相互转换，他们三者在计算机时会转换成int类型

强制转换：其容量大的转换为容量小的数据类型时，加上强制转换符（）

变量作用域

1）成员变量（全局级变量 private int i=0；或静态变量 private static Stringname="list")

在类体内定义的变量为成员变量，作用域为整个类。

2）局部变量：在一个方法或方法体内代码块中定义的变量成为局部变量。

变量作用域：变量可以使用的代码范围。

常量

常量：取值不能改变的数据

例：100 'A' ,3.14

符号常量：用标识符表示的符号常量

用关键字final来实现

例： final double PI=3.14;

final double PI=3.14159;

整型常量：

1.十进制整数

例：123，-456，0

2八进制整数

例：以0开头，013

3.十六进制整数：以0x或 0X开头

例：0x21

标识符

java语言中，标识符以字母，下划线_,美元符$开始的一个字符序列。

标识符大小写敏感，且任意长度。

关键字不能作为标识符

字符型

字符常量

字符常量是用单引号阔起来的一个字符，如'A’，‘a'

字符型变量

类型为char

例：char c='A’

布尔型

布尔型数据只有两个值true和false

定义：boolean b=true；

5.运算符

基本算术运算符

算数运算符：+-*/ % ++ --

赋值运算符：--

关系运算符：> < >= <= !=

逻辑运算符：！ & | && ||

条件运算符：XX?X:X

补码

正整数补码：其二进制表示。

负整数补码：将其对应正数变为二进制表示所有位取反后加1.

0的补码是0

2的原码：0000 0010

2的反码：1111 1101

反码加1：1111 1110

选择语句

（1）if（条件1）

{语句1；}

else

{语句2；}

（2) if(条件1）

{语句1；}

elseif（条件2）

{语句2；}

else

{语句3；}

注：测试条件必须返回为布尔型数据。不能用整型数值代替

public class Demo{public static void mian(String args[]){double a=3.14double b=6.86if(a<=b)System.out.println(a+">="+b);System.out.println(a+"<="+b);}
}

switch（XX){

case1：XX;break；

case2：XX;break；

default：XX;break；

public class Demo{public static void mian(String args[]){Scanner s=new Scanner(System.in);int input =sc.nextint();switch(input){case1:Sysetem.out.println('A');break;case2:Sysetem.out.println('B');break;default:System.out.println('C');}
}

java循环

（1）while语句

while(条件表达式）{

语句块；

}

注：当条件表达式值为true，循环执行大括号内部的语句。

循环中遇到break语句时立即跳出循环。

（2）do-while语句

do{

语句块；

}while（条件表达式）；

注：首先执行循环体，然后计算中止条件，所以这种情况循环体至少会执行一遍

for语句

for语句

for（初始化；条件表达式；迭代）{

语句块；

}

当三者均为空相当于一个无限循环

break语句

循环中，终止循环整体

continue语句

continue语句用来结束这一次循环

数组

数组特点：每一元素是同一类型，是引用类型，利用new生成对象。new以后，数目不能改变。用下标访问元素。可以是多维的。

一维数组

定义： type arrayName[];type[]arrayName;

类型（type）可以简单类型和复合类型

静态初始化：

例：int intArray[]={1,2,3}

System stringArray={"abc","mam"};

动态初始化

简单类型的数组

int intArray[];

intArray=new int[5];

一维数组的引用方式：

arrayName[index]:index为数组下标，从0开始。

数组有一个属性length指明他的长度。如：intArray.length

多维数组

多维数组被看作数组的数组

二维数组定义：type arrayName[][];type[][] arrayName;

静态初始化：int intArray[][]={{1,2},{1,2.,3},{1,2,3,4}};

注：不要求二维数组的每一维的大小相同

for（类型变量名：数组名）{

...

}

String s[]={"abc","efg","mbv"};

for （String a:s）

System.out.println(a);——输出数组的全部内容

二维数组的初始化：由于把二维数组看作是数组的数组，数组空间不是连续分配的，所以不要求二维数组每一维大小相同

三：类与对象

面向对象三大特性

1.继承性

2.封装性

3.多态性

类的定义与构成

类定义一般形式：[public]class<类名称>{

属性定义：[public/protected/private]<数据类型><属性名>;

方法定义：[public/protected/private]<返回值类型>方法名（[类型参数1],[类型参数2]...){

....//方法体

}

//其它方法定义

}

import java.util.TreeSet;
//创建一个Person类
class Person implements Comparable<Person> {public String name;public int age;public double weight;// 构造方法public Person(String name, int age, double weight) {this.name = name;this.age = age;this.weight = weight;}// 实现Comparable接口的compareTo方法@Overridepublic int compareTo(Person otherPerson) {// 按照年龄进行比较return Integer.compare(this.age, otherPerson.age);}// 重写toString方法，自定义对象输出格式@Overridepublic String toString() {return "Person{" +"name='" + name + '\'' +", age=" + age +", weight=" + weight +'}';}
}
public class TrDemo {public static void main(String[] args) {// 创建Person对象Person person1 = new Person("瑶瑶", 25, 45.0);Person person2 = new Person("琳琳", 24, 55.5);Person person3 = new Person("兰兰", 22, 61.2);// 将对象加入TreeSetTreeSet<Person> personSet = new TreeSet<>();personSet.add(person1);personSet.add(person2);personSet.add(person3);// 输出排序前的对象System.out.println("排序前的对象：");for (Person person : personSet) {System.out.println(person);}// 从集合中删除部分对象personSet.remove(person1);// 输出排序后的对象System.out.println("\n排序后的对象：");for (Person person : personSet) {System.out.println(person);}}
}

对象的生成

（1）先声明对象引用再实例化对象

Person m1=null;

p1=new Person();

(2)声明对象与实例化对象一步完成

Person p1=new person(）；

栈内存和堆内存

栈内存

在函数中定义一些基本数据类型的变量和对象的引用变量都在栈内存中分配。速度快

堆内存

堆内存用来存放所有的new创建的对象和数组的数据。速度慢

java数据

基本数据类型

int long float double Boolean

赋值（b=a）：把值赋给被赋值的变量

引用数据类型

类、接口、数组

赋值（b=啊）：把数据的地址赋值过去

成员方法

成员方法定义

方法定义：[public/protected/private]<返回值类型>方法名（[类型参数1],[类型参数2]...){

....//方法体

}

//其它方法定义

}

例：public void setAge(int_Age){

Age=_Age;

}

public void setAge(int_name){

name=_name;

}

public void speak(){

System.out.println("我是"+name);

System.out.println("我的年龄是"+Age);

return返回值

return语句返回和返回类型一致的数据。return只能返回一个值

方法体中有return语句时，遇到return语句方法体执行就结束了。

方法重载

将名字相同参数列表不同的两个或多个方法进行重载称为重载方法。

名称相同，参数个数和类型不同

方法重写

当父类和子类无法满足子类需求时，需要方法重写

子类中重写方法的访问权限不能低于父类中方法访问的权限

重写与重载区别

方法重载：在同一个类中，出现多个同名的方法，参数列表不同，与返回值类型，修饰符无关。

方法重写：子类中的出现和父类中一模一样的方法（包括返回值类型、方法名、参数列表）

class OutterClass1{                                                                                                                               public static int i=0;public String name;public double age;public OutterClass1() {age=0.0;System.out.println("年龄"+age)	;}public OutterClass1(String name) {this.name=name;System.out.println("姓名："+name);}public OutterClass1(String name,double age) {this.name=name;this.age=age;System.out.println("姓名："+name+","+"年龄："+age);}public void speak() {}}
public class OutterClass {public static void main(String[] args) {OutterClass1 p1=new OutterClass1();OutterClass1 p2=new OutterClass1("吴");OutterClass1 p3=new OutterClass1("欣瑶",18);p1.speak();p2.speak();p3.speak();}	
}

构造方法

构造方法作用：对对象进行初始化，构造方法在new一个对象时被调用

特点：构造方法具有类名相同的名称，

构造方法不能返回声明返回类型。（不是不能返回类型，是不能声明返回类型）

构造方法除初始化对象属性以外不应该有其他的语句

this关键字

this引用指向当前对象，也就是调用成员方法这个对象

class Person{
public String name;
public int age;
public Person(Sting name,int age){this.name=name;this.age=age;
}
}

四：继承性与多态性

继承就是子将父的东西承接过来。

需要条件：1.继承。2重写。3父类引用指向子类对象

继承语法

extend实现继承关系：

[访问控制方式]class <子类名>extends<父类名>{

//成员定义

}

继承访问控制方式

父类的私有成员private，在子类中不能直接访问。

protected访问控制，向所有子类和同一个包的其他类开放其访问权限

abstract class animal{ //定义抽象类public String color;//定义颜色public animal() {//定义构造方法color="白色";//初始化颜色 }public abstract void play();//定义抽象方法
}
class dog extends animal{private Integer age;//定义包装类@Override  //方重写的java注解public void play() {System.out.println("小狗激动地跑过来呀！");}
}
class cat extends animal{public void play() {System.out.println("小猫在睡觉");}
}
public class week05{public static void main(String[] args) {animal f1=new dog();//f1指向dog对象f1.play();//调用dog类中的play对象1f1=new cat();//f1指向cat对象，同名和不同方法共存f1.play();//调用cat类中的play对象}
}

super关键字

super关键字注意用于子类方法中，用于指向子类对象中的父类对象。

2子父类对象中存在同名的成员时，在子类中默认是访问子类的成员，可以提供super关键字指定访问父类成员

3默认会先调用父类无参的构造方法，可以提供super关键字指定调用父类的构造方法。

class Person{
private String name;
private int age;
public Person(String name,int age){this.name=name;this.age=age;
}
public String getName(){
return name;
public int getAge(){
return age;
}
}
class Student extends Person{
private String school;
private int grade;
public Student(String school,int grade,String  name,int age){super(name,age);this.school=school;this.grade=grade;
}
public String getSchool(){
return school;
public int getGrade(){
return grade;
}
public class Demo{public static void mian(String[] args){Students s1=new Student("清华大学",2,"琳琳",20);System.out.println("学校"+stu.getSchool(),"年级"+stu.getGrade(),"姓名"+stu.getName()+"年龄"+stu.getAge());
}
}

this和super区别

（1）代表事物不同：super代表父类空间的引用，this代表是所属函数的调用对象。

（2）使用前提不同：super必须要有继承关系才能使用，this不需要继承关系也能使用。

（3）调用构造函数不同：super调用父类构造函数，this调用所属类构造函数

方法重写

子类不能重写父类的static方法

在子类中可以使用super.方法名（）调用父类被重写的方法

重写的方法访问控制权限更宽。

final 关键字

1）使用final可以声明常量，常量不能修改，定义时要赋上初始值。

2）使用final声明方法不能被子类重写

3）使用final声明的类不能有子类

继承与子类型

类A继承类B，则类型A是类型B的子类型

例：类GraduateStudent是类Student的子类，则：

Student s=new GraduateStudent();

抽象方法

用abstract进行修饰。

只声明返回的数据类型、方法名和所需的参数，没有方法体。

必须要子类重写的方法。

格式：abstract<方法返回值类型><方法名>(参数列表);

例：abstract void f();

abstract class Fruit{//定义抽象类public String color;public Fruit(){//定义构造方法color="pink";
}
public abstract void harvest();//定义抽象方法
}
class Apple extends Fruit{public harvest(){System.out.println("你吃苹果吗");
}
}
class banana extends Fruit{public harvest(){System.out.println("你吃香蕉吗");
}
}
public class Demo{
public static void main (String[]args){Fruit a1=new Apple;a1.harvest();a1=new banana();a1.harvest();
}
}

继承的使用要点：

1.抽象类是用来继承的，具体类不是用来继承的。

2 .抽象类应该拥有尽可能多的共同代码

3抽象类应当拥有尽可能少的数据。

4继承使用条件

（1）继承代表“一般/特殊”的关系

（2）子类具有扩展超类的责任，而不是借用其中某部分功能。

多态性

同一个继承体系中不同的类的对象收到相同消息时产生多种不同的方式。

Object类

基本作用：Object类是java类层中最高层类，是所有类的超类。

所有类都继承了Object类声明的接口和方法

主要方法：

（1）equals()方法：测试某个对象是否对另一个对象相等。

（2）toString()方法：返回该对象的字符串表示。

（3)finalize()方法：当垃圾回收器将要释放无用对象的内存时，先调用该对象的finalize()方法

基本类型的包装类

用途：

（1）作为和基本数据类型对应的类型存在，方便涉及到对象操作。

（2）包含每种基本数据类型的相关属性如最大值、最小值等，以及相关的操作方法。

包装类用equal()比较值

java接口

概念：类似于纯抽象类，只包含常量和抽象方法，没有变量和具体方法。

java接口方法只能是抽象的和公开的

java接口不能有构造方法，可以有public、静态的final属性

public interface A{
//接口中所以定义的方法其实都是抽象类public abstract
//变量只能为public static final类型的
//public abstract void add();等效于 void add();
int age=100;
void add(String name);
void delete(String name);
void update(String name);
void query(String name);
}

接口与抽象类的区别

1.接口要被子类实现，，抽象类被子类继承。

2.接口中变量全为公共静态常量，而抽象类中可以是普通变量。

3.接口中全为方法的声明，抽象类中可以有方法的实现。

4.接口中不可以有构造函数，抽象类中可以有构造函数。

5.接口可多实现，而抽象类必须被单独继承。

6。接口中方法全为抽象方法，而抽象类中可以有非抽象方法

五：异常处理

异常

异常在运行时代码序列中产生的非正常的情况。

例：想打开文件不存在，磁盘空间不足，数组下标越界，除数为0，数据库操作失败，网络访问失败

异常类

Error类：无法挽回

异常：可以挽回

运行时异常（UncheckedException)

RuntimeException类及其子类

非运行时异常（CheckedException）

Exception类及其它子类

用户自定义类（非Error和RuntimeException）

区别：是否需要强制预处理

异常处理语句结构

try{
//可能抛出的异常语句；
}catch(异常类型1异常对象){
//对该类型的异常进行处理的语句；
}catch(异常类型2异常对象){
//对该类型的异常进行处理的语句；
}catch(异常类型n异常对象){
//对该类型的异常进行处理的语句；
}finally{
//执行异常处理后收尾工作的语句
}

finally语句可选的，可以没有

不论在try代码块中是否发生了异常事件，finally块中的语句块都会被执行

public static boolean catchFianllyDeom1{
try{
int i=10/0;//抛出Exception后续处理被拒绝
System.out.println("i="+i);
return true;
}catch (Exception e){//Exception已经抛出，没有获得被执行的机会
System.out.println("--Exception--");
return catchMethod();//Exception抛出，执行捕获到异常后返回的内容
}finally{
finallyMethod();//Exception抛出之后，finally内的方法也会执行
}
}

异常抛出

throws语句

throws语句：在一个方法中产生了一个异常，但这个方法并不确切的知道如何对这一异常事件进行处理。这个方法就应该声明抛出这个异常

声明抛出异常是在一个方法声明中的throws子句指明。

例：public AM(String name) throws FileNotFoundException{

//方法体

}

public int read()throws IOException{

//方法体

}

throw语句

抛出异常首先生成异常对象，生成异常对象提供throw语句实现。

IOException A=new IOException();

throw A;

可以抛出的异常必须是Throwable或其子类的实例

六：java常用类库

日期时间操作类

日期操作类
Calendar(日历)

Date(日期)

DateFormate(日期格式)

SimpleDateFormat(DateFormat的直接子类)

System类

1.System.currentTimeMillis()方法

方法声明：public static long currentTimeMillis()

long startTime=System.currentTimeMillis();//获取开始时间
do Some Thing
long endTime=System.currentTimeMillis();//获取结束时间
System.out.println("运行花了"+(endTime-stratTime)+"ms");

2.System.nanoTime()方法

方法声明：public static long nanoTime()

功能：返回最精确的可用系统计时器的当前值，以纳秒为单位

Calendar类

用java.util.Calendar类实现

Calendar c=Calendar.getInstance();

int year=c.get(Calendar.YEAR);//年份

int month=c.get(Calendar.MONTH)+1;//月份

int date=c.get(Calendar.DATE);//日期

int hour=c.get(Calendar.HOUR_OF_DAY);//小时

int minute=c.get(Calendar.MINUTE);//分钟

int second=c.get(Calendar.SECOND);//秒

int day=c.get(Calendar.DAY_OF_WEEK);//星期

DateFormat类和 SimpleDateFormat类

常用的模式字母及其含义
模式字母	说明
y	年，使用yyyy表示
M	月，使用MM表示
d	天，使用dd表示
H	小时，使用HH表示
m	分钟，使用mm表示
s	秒，使用ss表示
S	毫秒，使用SSS表示
E	星期

Date date =new Date();
SimpleDateFormat format=(SimpleDateFormat );
DateFormat.getInstance();
format.applyPattern("yyyy年MM月dd日HH时mm分ss秒）;
System.out.println(format.format(date));
SimpleDateFormat1 format=(SimpleDateFormat );
DateFormat.getInstance();
format1.applyPattern("yyyy年MM月dd日HH时mm分ss秒E）;
System.out.println(format1.format(date));
SimpleDateFormat2 format=(SimpleDateFormat );
DateFormat.getInstance();
format2.applyPattern("yyyy-MM-dd HH:mm:ss）;
System.out.println(format2.format(date));

Math类

Math.abs(-10)//绝对值
Math.sqrt(X)//计算平方根
Math.cbrt(X)//计算立方根
Math.pow(a,b)//计算a的b次方
Math.max(1,2)//计算最大值
Math.min(1,2)//计算最小值
Math.ceil(X)//接近此数大的整数的值 3.2——4
Math.floor(X)//接近此数小的整数的值 3.2——3
Math.random()//[0,1)
Math.round(X)//四舍五入,float返回int值，double返回long值

Random类

Random r=new Random();
double d1=r.nextDouble();//生成[0,1.0)区间的小数
double d2=r.nextDouble()*5;//生成[0,5.0)区间的小数
double d3=r.nextDouble()*1.5+1;//生成[1,2.5)区间的小数
int n1=r.nextInt()//生成任意整数
int n2=r.nextInt(n)//生成[0,n)任意整数
int n3=r.nextInt(n+1)//生成[0,n]任意整数
int n4=r.nextInt(20)-5//生成[-5,15)任意整数

正则表达式

语法：描述在查找文字主体时待匹配的一个或多个字符串，将某个字符模式与所搜索的字符串进行匹配

元字符：. * + () $ / \ ? ^ {} - ! <> |

预定义字符
预定义字符	含义	预定义字符	含义
.	任何字符	\s	空白字符：[t\n\x0B\f\r]
\d	数字字符：[0,9]	\S	非空白字符：[^\s]
\D	非数字字符：[^0-9]	\w	单词字符：[a-z.A-Z,0-9]
		\W	非单词字符[^\W]

量词表示
符号	次数	符号	次数
？	0次或者1次	{n}	精确为n次
*	0次或者多次	{n,m}	精确为n次到m次
+	1次或者多次

定时器任务

在java.util包中提供了两个类：Timer类和TimerTask类

这两个类可以创建一个工作台于后台的线程，该线程等待一段指定的时间，当指定的时间到来时，与该线程相连的任务被执行

import java.util.Timer;
import java.util.TimerTask;
class MyTimeask extends Timer Task{
public void run（）{
System.out.println("定时器任务被执行");
}
}
public class Demo{public static void main(String[]args){MyTimerTask myTask=new MyTimerTask();Timer myTimer=new Timer();myTimer.schedule(MyTask,1000,2000);
try{thread.sleap(5000);//休眠5000毫秒
}catch(InterruptedException exc){
}
myTimer.cancel();
}
}

Comparable接口和Comparator接口

Arrays类有sort()方法来排序

类必须实现java.lang.Comparable接口，重写其中的compareTo()方法。

Comparable 接口只有一个compareTo()方法

返回值为：1表示大于，-1表示小于，0表示相等

Comparetor接口中有一个排序方法compare().返回值为0，-1，1

使用Comparator接口需要单独定义一个实现了Comparator接口的排序规则类

七：泛型与集合

泛型

支持创建可以按类型进行参数化的类

public class Box<T>{

private T something;

public void set（T something){

this.something=something;}

public T get(){

return something;

}

public T get(){return something;}

泛型可以提高java程序的类型安全，消除强制类型转换

泛型类和泛型接口

如果一个类或接口上有一个或多个类型参数，那它就是泛型。

class 类名 <泛型类型1，泛型类型2，...>{

}

interface 接口名

<泛型类型1，泛型类型2，...>{

}

泛型接口的实现方式：

（1）实现类不指定具体的泛型类型

（2）实现类指定具体泛型类型

interface IDemo<T>{
void print(T param);
}
//方式一：实现类不指定具体的泛型类型
class Demo<T>implements IDemo<T>{
public void print(T param){System.out.println("param"+param);}
}
//方式二：实现类指定具体泛型类型
class DEMO implements IDemo<String>{public void print(String param){System.out.println("param"+param);}
}

集合

Java集合类型

（1）存储数据

（2）数组

要给出数组元组个数，大小固定不能改变，无法判断其中实际存有多少元素

定义：java提供了实现各种数据结构操作的集合类，这些集合类和接口共同组成了java集合框架。

java集合只能存放引用类型的数据，不能存放基本数据类型的数据。

java集合分类

（1）List：提供一个有序的集合，且List允许有重复元素。

（2）Set：提供一个无序的集合且不允许包含重复元素。

（3）Map：键/值对元素的集合，Map提供键Key到值Value的映射。一个Map中不能包含相同的Key，每一个Key能映射一个Value。

Collection接口

1）单元素添加、删除操作：

boolean add(E e):

boolean remove(Object o):

2)删除操作：

int size：

boolean isEmpty():

boolean cotains(Object o):

Intator iterator():返回一个迭代器，用来访问集合中的各个元素。

3）组操作

boolean containsAll(Collection<?>c):

boolean addAll(Collection<?extendsE>c):

void clear():

boolean removeAll(Collection<?>c):

void retainAll(Collection<?>c):

4)Collection转换为Object数组：

Object[]toArray():

List接口

List是Collection接口的子接口

List是有序的Collection，能够使索引来访问List中的元素

ArrayList类

ArrayList更适合读取数据：基于动态数组的数据结构

LinkedList类

LinkedList类适合添加或删除数据：基于链表的数据结构

Set接口

继承了Collection接口,不允许集合中存在重复项，每个具体的Set实现类依赖添加的对象的equal()方法来检查独一性。

Set是无序的，没有List接口中的get()方法，不能使用下标访问集合中的元素

集合工具类Collections类

java.util.Collections类中定义了多种集合操作方法。

Collection：接口

Collection：类

多线程

线程的创建

线程的创建：java.lang.Thread

java.lang.Runnable

直接继承Thread类的创建线程

java.lang.Thread类称为线程类，这个类提供了大量的方法来控制线程，

创建：从Thread类继承，新类必须覆盖从Thread类继承的run()方法，加入线程所要执行代码即可。

运行：调用从父类Thread类继承的start()方法，该方法自动调用run()方法来执行线程体

通过实现Runnable接口创建线程

Runnable只有一个抽象方法run().

创建线程过程：

（1）定义一个Runnable接口的类，实现run()方法，在其中加入线程所要执行的代码。

（2）创建该类的一个对象，然后再以该对象为参数创建Thread类的一个对象，从而创建一个线程对像。

（3）调用该Thread对象的start()方法来启动线程。

两种创建线程的方法的比较

程序开发以多线程实现Runnable接口为主

Runnable避免继承的局限，一个类可以实现多个接口。

Runnable适用于资源共享。

多线程的互斥与同步

使用synchronized关键字解决互斥问题

解决共享资源的互斥访问，可以使用synchronized关键字。

应用于同步代码块和同步方法中，一次只允许一个线程进入执行。

使用Lock解决互斥问题

实现java.util,concurrent.locks.Lock接口的类具有与synchronized关键字同样的功能。

java.utils.concurrent.locks.ReentrabtLock是较为常用的实现Lock接口的类。

多线程的同步

多线程之间有时需要协调工作，合作来完成任务，同步依赖于wait/notify/notifyAll()

wait(),notify(),notifyAll()不属于Thread类，而是属于Object类。

wait()作用：使线程释放已持有的对象互斥锁，进入对象的wait队列，导致线程阻塞。

notify()作用：唤醒wait队列中的第一个线程并把它移入锁申请队列。

notifyAll()作用：唤醒队列中的所有线程并把它们移入锁申请队列。

八：IO

IO概念

I/O（Input/Output)是输入/输出简称，从外部读取数据获取外部设备发送数据，这就是所谓的输入/输出。

数据可以来自或者发往文件、内存。

java提供了java.io包。

输入流和输出流

输入流代表从外设流入计算机内存的数据序列。

输出流代表从计算机内存流向外设的数据序列。

java通过流（stream）方式允许。

java程序使用相同的方式来访问不同的输入、输出设备。

字节流和字符流

字节流：以字节（byte，8bit）为基本处理单位。

字符流：以16位的Unicode码表示的字符为基本处理单位，基于字符流只为处理字符提供方便有效的方法。

在最底层，所有的输入/输出都是字节形式的。

File类

是文件流进行文件操作的辅助类，可以用来操纵文件以及文件目录，包括删除、重命名文件或目录，列出文件的属性，创建子目录，列出目录下文件

文件流

文件流主要有字节流：FileInputStream、FileoutputStream

字符流：FileReader和FileWriter进行文件的顺序读写。

对象序列化

对象序列化与Serializable接口

只有实现了Serializable的类的对象才可以被串行化。

凡是实现Serializable接口的类都要有一个表示序列化版本标识符的静态变量。

在ObjectInputStream中用readObject()方法可以直接读取一个对象。

ObjectOutputStream中用writeObject()方法可以直接将对象保存到输出流中。

对象序列化保存的内容

（1）只能保存对象的非静态成员变量，对于变量的任何修饰符，都不能保存。

（2）当一个对象实例变量引用其它对象，序列化该对象时也把引用对象进行序列化。

transient关键字：对于对象中不可以序列化属性，我们必须用transient关键字标明

九：图形用户界

Swing组件

是用java语言源代码实现的。

Swing组件：如Jbutton，JTextField，JTextArea，JcheckBox等。

Swing组件在javax.swing包中，AWT在java.awt包中。

Swing组件按功能分：顶层容器，中间层容器，基本组件

布局管理器

布局管理器包括：

FlowLayout（流式布局管理器）

BorderLayout（边界布局管理器）

GridLayout（网格布局管理器）

CardLayout(卡片布局管理器）

网络编程

网络编程基础：IP地址、域名、端口、客户端、TCP和UDP协议

URL

1.统一源定位器URL：是统一资源定位器的简称，表示internet上某一资源的地址。

URL组成：

格式：protocol://resourceName

协议名：指明获取资源所使用的传输协议，如：HTTP,FTP等

资源名：资源的完整地址，包括主机名、端口号、文件名或文件内部的一个引用。

URL的组成：在HTTP协议中使用的URL其完整的语法：

http://host[:port][absolutePath]

其中，http是协议的标识符，host表示主机名；端口号任选，未指定端口号则使用默认值80