JavaSE理论篇

将已学过的知识记录在此，既能便于以后温习又能方便知识共享，做到共同成长。

计算机语言发展简史

主要分为三个阶段

机器语言：打点机，有点表示1，没有表示0，打点计时器

低级语言：汇编语言

高级语言：Java C/C++  web执行效率比低级语言低

Java发展简史

Java是一种语言，具有自己的语法和数据结构。

Java来自于sun ，sun指的是斯坦福大学网络。

 

具体发展历程

时间	描述
1991~1995	Sun为了占领智能消费电子产品市场，由james gosling 负责该项目，来开发Oak语言
1995	将Oak语言改名为Java
1996	发布JDK1.0
1997	发布JDK1.1
1998	发布JDK1.2 将版本命名为J2JDK,将Java改名为Java2
1999	将Java分为三大板块：J2SE、J2EE、J2ME
2000	发布J2SE1.3
2002	发布J2SE1.4
2004	发布J2SE5.0
2005	将三大板块改名为JAVA SE,JAVA EE,JAVA ME
2006	发布JAVA SE 6.0
2011	发布JAVA SE 7.0
2014	发布JAVA SE 8.0

 

JAVA SE(标准版)、 JAVA EE(企业版)、 JAVA ME(微型版)三者之间关系

 

 

 

 

Java语言特性

简单性(没有指针)

面向对象

可移植型（编译生成.class文件可到处运行，前提条件是在不同操作系统下下载相应环境下的JVM）

健壮型(垃圾自动回收机制GC)

多线程

Java的加载与执行

 

 

 

Java se 安装、搭建开发环境

安装JDK 7.0

安装路径中不要有空格和中文，一般直接选择默认路径下！

Bin路径下存放的是命令，jre是Java虚拟机的运行环境，jre包中lib包中存放的是写好的库

。Scr.zip中存放的是源文件。Jre lib中rt.zip就是与之对应的.class文件。

配置环境变量PATH PATH是Windows操作系统搜索某一个命令的环境变量。

CLASS PATH

安装UItraEdit

设置：设置字体大小>>视图>>设置字体

      设置制表符>>高级>>编辑器>>制表符设置

      设置不备份>>高级>>文件处理>>备份

      设置高亮>>高级>>编辑器显示>>语法高亮

Public class 和class 区别

一个.Java文件中可以有多个class类，每个class类对应生成一个.class文件。

一个.Java文件中只能有一个public class 并且类名要与文件名相同。

注释符

单行注释符//

多行注释符

/*

 

*/

 

/**

*可被Javadoc工具解析生成帮助文档。

*/

转义符的使用

1.八进制转义序列：\ + 1到3位八进制数字；范围‘000‘~‘377‘

\0：空字符

2.Unicode转义字符：\u + 四个十六进制数字；0~65535

\u0000：空字符

3.特殊字符：3个

\"：双引号

\‘：单引号

\\：反斜线

4.控制字符：5个

\r 回车

\n 换行

\f 走纸换页

\t 横向跳格

\b 退格

 

 

Java语言基础

MyEclipse及破解工具下载：https://yunpan.cn/ckRGCjgxWSxqr  访问密码 4214

一、标识符（identifier）

标识符可以标识类名，变量名，接口名，方法名

1、Java标识符的命名规则：

a） 标识符是由数字、字母、下划线、美元符号构成，其他符号不可以;

b） 必须以字母、下划线、美元符号开头，不能以数字开头。

2、关键字不能作为标识符

3、标识符区分大小写

4、标识符理论上没有长度限制。

5、Java标识符的命名，最好见名知意。

6、Java命名规范：驼峰命名法，类名和接口名首字母大写，后面每个单词首字母大写。方法名和变量名首字母小写，后面每个单词首字母大写。

合法标识符	不合法标识符
_123Test	123Test
HelloWorld	Hello-World
HelloWorld	HelloWorld#
public1	public
HelloWord	Hello World

二、关键字（keywords）

关键字：是指sun定义具有特殊含义的字符序列，都是小写。

abstract	assert	Boolean	break	byte
case	catch	char	class	const
continue	default	do	double	else
enum	extends	final	finally	float
for	goto	if	implements	import
instanceof	int	interface	long	native
new	package	private	protected	public
return	strictfp	short	static	super
switch	synchornized	this	throw	throws
transient	try	void	volatile	while

三、数据类型(dataType)

1、字面值：一眼看上去就知道是多少的数据。占用内存空间，有类型、有数值，内存无法重复利用。

2、变量：是内存中的一块空间，有名字、有数据类型、有值，调用变量名能够被重复利用。

变量可分为成员变量、局部变量，Static 修饰的变量是静态变量。局部变量和静态变量必须赋值后才可以使用。成员变量如果没有赋值会自动赋值为相应数据类型的默认值。

变量的作用域：作用域出了大括号就不认识。

变量可以重复赋值，前面的值被覆盖。

同一个作用域中变量名不能重复，但是父域中声明的变量在子域中可以重复声明，采用就近原则进行取值。

3、数据类型：数据类型分为基本数据类型和引用数据类型。

8种基本数据类型：整数型（byte short int long）浮点型（float double）布尔型（boolean）字符型（char）

 

 

 

4、进制转换：二进制（b）、八进制（0）、十进制、十六进制（0x）

进制之间的相互转换。

5、字符编码

 

 

 

6、转义符

1.八进制转义序列：范围‘000‘~‘377‘\0：空字符

2.Unicode转义字符：\u + 四个十六进制数字；命令行中native2ascii 可以将字符转换成unicode码。0~65535\u0000：空字符

3.特殊字符：3个

\"：双引号，

\‘：单引号，

\\：反斜线

4.控制字符：5个

\r 回车，

\n 换行，

\f 走纸换页，

\t 横向跳格，

\b 退格

7、7种基本数据类型之间的相互转换

数据容量排序：byte-->short(char)-->int-->long-->float-->double

数据相互转换分为：

自动转换（容量小-->容量大），

强制转换（容量大-->容量小）

一个整数没有定义数据类型默认为int型，一个浮点类型数后没有加f默认为double类型。

一个整数没有超出byte/short/char的取值范围，可以直接 赋值给byte/short/char

在多种类型混合运算过程中，首先将所有数据转换成容量最大的那种，再进行计算。

byte/short/char之间的计算不会相互转换，首先转换成int类型再计算。

四、运算符(operator)

1、算数运算符：

+（加），-（减），*（乘），/（除），%（求余）

注意：在进行除法运算时，0不能做除数。

2、自增自减运算符：

a++(a--):表示在使用变量a滞后，使a的值加（减）1

++a(--a) :表示在使用变量a之前，先使a的值加（减）1

3、比较运算符：

用来对数据进行比较,通过比较得到一个boolean类型的结果。

比较运算有: > 、>= 、 < 、<=、 ==、!=

4、赋值运算符：= ，+=，-=，*=，/=，%=

扩展运算符不改变运算结果类型，但是可能损失精度。

5、字符串连接运算符：+

System.out.println(“a+b=” + (a+b));

System.out.println(“a+b=” + a+b);

System.out.println(a+”+”+b+”=” +( a+b));

6、条件运算符（三目运算符）

语法：boolean表达式？表达式1：表达式2

7、逻辑运算符：

&&(有短路功能) :  两个条件同时为true时结果才为true

&: 没有短路功能,

||(有短路功能) :  两个条件中只要有一个为true则结果为true

| : 没有短路功能

! : 非真即假，非假即真

^：异或 相同为假，相异为假。

8、运算符的优先级别：

最高的优先级：小括号，即( )

最低的优先级：赋值运算符，即=

优先级顺序：！>算术运算符>比较运算符>&&>||

不知道运算符优先级就加（）

五、控制语句(control)

1.if条件语句：

if(布尔表达式)｛

语句序列

｝

2.if…else语句

if(布尔表达式)｛

若干语句

｝else{

若干语句

}

3.if…else if多分支语句

if(条件表达式1)｛

语句序列1

｝

else if(条件表达式2)｛

语句序列2

｝

4.if…else if…else多分支语句

if(条件表达式1)｛

语句序列1

｝

else if(条件表达式2)｛

语句序列2

｝else｛若干语句｝

4.switch多分支语句

switch(表达式int类型)｛

case 值1:

语句块

  break;

case 值2:

语句块

  break;

  Default:

语句块

break;  }

Break,default不是必须的。如果没有break，将发生case穿透

Switch括号中也可以是byte /short/ char 类型将会发生自动转换

case ： case ：可以叠加

5.for循环语句

for( 表达式1 ; 表达式2 ; 表达式3 ){

语句序列

}

表达式1：初始化表达式，负责完成变量的初始化，只执行一次

表达式2：循环条件表达式，值为boolean型的表达式，指定循环条件

表达式3：循环后操作表达式，负责修整变量，改变循环条件

for循环语句的嵌套使用。

6.while循环语句（先判断后执行）

while(条件表达式){

执行语句

}

7.do…while循环语句（先执行后判断）

do{

执行语句

}while(条件表达式); //注意while后面的 ” ; ”

8.跳转语句

1、Break语句可用于循环语句中结束离它最近的一个循环。

2、Return结束的是所在的方法。

3、Continue结束本次循环，即不执行continue下面的语句，直接进入下次循环。

六、方法（method）

方法说明:

方法又称为函数，是JAVA创建一个有名字的子程序，方法的实现包括两部分内容：方法声明和方法体。

 语法：

 public(修饰符)  void(返回值)  show(方法名)([参数列表]) {方法体}    

方法重载：

方法的重载，就是在类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。调用方法时通过传递给它们的不同个数和类型的参数来决定具体使用哪个方法

要求每个方法具有不同的参数的类型或参数的个数

一般用于定义一组方法，这些方法具有相同的名称，并执行类似的操作，但是却使用不同的参数列表

方法重载的三大原则：

1、方法名相同

2、参数不同（数量不同、类型不同）

3、作用于同一个类

七、递归调用

程序调用自身的编程技巧称为递归。递归做为一种算法在程序设计语言中广泛应用，只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量

构成递归需具备的条件：

1. 子问题须与原始问题为同样的事，且更为简单；

2. 不能无限制地调用本身，须有个出口，化简为非递归状况处理。

递归算法一般用于解决三类问题：

(1) 数据的定义是按递归定义的。

(2) 问题解法按递归算法实现。这类问题虽则本身没有明显的递归结构，但用递归求解比迭代求解更简单

(3) 数据的结构形式是按递归定义的。

 

 

 

 

 

 

 

 

 

 

 

 

作业：

1、九九乘法表；

2、给出一个double 类型的成绩，输出我们的成绩等级[90-100]优秀[70-90)良好[60-70)及格，其他不及格（用switch编写）；

3、利用方法的重载（boolean）时输出，（int,int）时求积，（int，double）时求和，（double,int）时求差，（String,String,String）时字符串拼接；

4、用递归编写10的阶乘。

 

预习：

1、面向对象？面向过程？；

2、类与对象；

3、封装；

4、构造方法；

5、this关键字；

6、static关键字。

 

 

 

第三章面向对象

3.1面向对象与面向过程区别

面向对象：是把构成问题事务分解成各个对象。建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在解决问题的步骤中的行为。

面向过程：就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。

面向对象的三大特性：

封装、继承、多态

面向对象开发的三个阶段：

（OOA）面向对象分析(Object Oriented Analyze)

（OOD）面向对象设计(Object Oriented Design)

（OOP）面向对象编程(Object Oriented Programming)

3.2类与对象的概念

对象:

万事万物皆对象,每一个对象可以有自己的属性、方法、标识，这意味着每一个对象都可以拥有自己的内部数据(这些数据通过对象的属性来表示)和行为(行为通过对象的方法来体现),内存中的每一个对象都可以通过一个标识(这个标识指的就是对象在内存中的地址)唯一的和其他对

象区分开来.

类:

类是具有相同属性和行为（方法、函数）的一组对象的集合，它定义了属于该类的所有对象应该有哪些属性和方法.

对象抽象化产生类，类实例化产生对象，我们要先创建对象再去调用对象的方法和属性。

3.3类的定义

类定义的格式：[控制权限修饰符] class 类名｛属性 方法｝

对象包含属性与方法，定义类也就是要定义好所有属于这个类的对象应具有的属性与方法。

3.4对象的创建和使用

对象创建格式：类名 对象名 = new 类名();一个类可以有多个对象，创建一个对象后会在堆中创建一块空间存放对象。

3.5封装介绍

生活中的封装是指：

将某些东西包装在一起，然后以新的完整形式呈现出来；

程序中的封装是指：

隐藏对象的属性和实现细节,仅对外提供公共的访问方式

封装其实就是有选择性地公开或隐藏某些信息，它解决了数据的安全性问题，便于维护和扩展。

实际编程中我们是将类的成员属性私有化，再对外提供set 和get的方法。

3.6构造函数（Constructor）

构造函数，是一种特殊的方法，也可以叫做构造方法。主要用来在创建对象时初始化对象， 即为对象成员变量赋初始值，总与new运算符一起使用在创建对象的语句中。

构造方法注意事项：

1. 构造方法是特殊的成员方法，它与类同名，在对象实例化时由虚拟机自动调用。

2. 它没有返回值类型，也不能有返回值

3. 每个对象在生成时都必须执行构造方法，而且只能执行一次；

4. 如果构造方法调用失败，那么对象也无法创建；

5. 在没有定义构造方法的情况下，类会自动产生一个无参数的默认构造方法，这个默认的构造方法什么都不做；

6. 一旦显式地定义了构造方法，默认无参构造方法自动消失。

3.6.1构造函数的重载

参照方法的重载。

3.7 this关键字的使用

this代表当前类的对象。哪个对象调用了this所属的方法，这个this就代表哪个对象。

通过this显示的去使用当前对象的成员(属性、方法)

如果需要在一个构造方法中调用另外一个构造方法来初始化信息可以使用this

this的应用主要有：

访问对象的成员(包括属性、方法)

调用类的构造方法

3.8 static关键词

一个修饰符,用来修饰类的成员(属性、方法)

特点：

在类加载时就加载(运行、初始化)

静态初始化优于对象的

静态的成员(属性和方法)可以通过类名.操作符直接访问

注意：

只有在所有对象都是同一个属性值的时候我们才建议到属性上用static修饰

在static的方法或者语句块中不能使用this、super关键字

在static中不能使用非static的成员(属性、方法)

在非static中可以使用static的成员(属性和方法)

3.8.1静态块的使用

有些代码必须在项目启动的时候就执行，就需要使用静态代码块,这种代码是主动执行的，且只执行一次。

3.8.2构造代码(对象)块的使用

直接在类中定义且没有加static关键字的代码块称为构造代码块。

可以把不同构造方法中相同共性的东西写在它里面

构造代码块在创建对象时被调用，每次创建对象都会被调用

执行顺序上，构造代码块优先于构造函数，其次，构造代码块是给所有对象进行统一初始化，而构造函数是给对应的对象初始化，构造代码块中定义的是不同对象共性的初始化内容。

3.8.3单例模式

1.构造方法私有化。

2.对外提供一个公开的静态的获取当前类型对象的方法。

3.提供一个当前类型的静态变量。

3.9继承的介绍（inherit）

将一个类和另外一个类建立种 is a 的关系,这种关系就叫继承

有了继承就有了父类(超类,基类)和子类(派生类)概念(多态),子类中可以使用从父类继承过来的特征,在Java中，继承可以使代码重用。

语法：[修饰符] class 子类名 extends 父类名

一个类只能继承一个类，但可以间接继承

一个类可以没有继承类，系统默认继承object类

子类会将父类中的所有数据全部继承，包括私有的也能继承，但是私有的不能直接访问，要通过间接访问。

构造方法不能够被继承。

继承作用：代码互用，方法重写。

3.10方法的重写(Override)

如果在子类有和父类相同的方法，子类的这个方法叫方法重写

为什么要重写:父类的方法无法满足子类的需求。

子类重写父类方法后，子类对象调用重写方法。

注意：

如果要构成方法的重写,返回值、方法名、参数列表要相同,修饰符的访问范围不能小于父类

子类的方法不能抛出比父类更多(或更高)的异常

静态的方法不存在重写,但是可以继承。

私有方法和构造方法不能被重写。

3.10.1方法重写与方法重载的区别

方法重写是子类的方法覆盖父类的方法，要求方法名和参数都相同

方法重载是在同一个类中的两个或两个以上的方法，拥有相同的方法名，但是参数却不相同，方法体也不相同。

3.11多态（polymorphic）

类之间的转型

向上转型（多态）：子---->父（自动类型转换）

向下转型：父---->子（强制类型转换）

Instanceof 运算符:判断对象属不属于某个类。

多态作用：代码扩展能力增强。编程不要面向对象和面向具体编程，要面向父类面向抽象编程，代码的可扩展型才好。

3.12 super关键字的使用

Super代表的是当前子类对象中的父类特征。

两种用途：

第一种用途：在子类的构造方法中，super关键字可以显式地调用父类的构造方法，用于将参数传递给它；

第二种用途：如果父类和子类中有同名成员，在子类中默认访问是属于自己的那一个成员。

注意：

子类的无参构造方法没有this(),super()系统默认调用父类无参构造方法。

Super可以出现在成员方法和构造方法中，在构造方法中只能出现在第一行，所以在构造方法中this（），super（）不能共存。

3.13 final关键字的使用

final关键字就是一个修饰符，用来修饰类，方法，变量。

注意：

如果一个类被final修饰则表示这个类不能被继承

如果一个方法被final修饰则表示这个方法不能被重写

如果一个局部变量被final修饰,那么该变量的值一旦被指定,就不能再改变 。

一般final和static共同修饰成员变量，表示为常量，变量名所有字母大写。

3.14 抽象类

抽象类的使用

定义抽象类同样使用关键字abstract，一般语法：

[访问权限] abstract class 类名 {

成员列表

}

使用关键字abstract声明抽象方法，一般语法：

[访问权限] abstract 返回值类型 方法名称(参数列表);

注意：

1.抽象类不能实例化，不能创建对象。

2.抽象类、抽象方法不能被final修饰。

3.抽象类中可以定义抽象方法，抽象方法不要方法体，直接在参数列表后面以“；”结束。

4.抽象类中可以没有抽象方法，但是抽象方法只能出现在抽象类中。

5.一个非抽象类继承我们的抽象类，必须将抽象类中所有的抽象方法进行重写。

3.15接口的介绍

一个类中的所有方法都为抽象的则可以定义为接口

接口定义语法：控制权限修饰符 interface 接口名｛｝

接口的应用

与抽象类相似，接口同样不可以实例化，只能用于实现；

注意：

1、接口的控制修饰符只能是 public 和默认的。

2、接口中定义的方法不能有方法体，默认是public abstract；

3、接口中定义的变量是常量，默认是public static final；

4、接口中不能有构造方法；

5、接口不可以实例化；

如果某类要实现接口，则使用implements关键字，一般语法：

[访问权限] class 类名 implements 接口名 {

成员列表

}

接口可以多实现，用implements关键字，并且可以实现多个接口，多个接口之间用逗号分隔；

如果实现的多个接口有相同的方法，实现类只要重写一次；

如果实现的接口继承了别的接口，那么这些接口里的方法在实现类当中都必须实现 ；

3.15.1接口的作用：

1、使项目分层，所有层面面向接口开发，提高效率。

2、项目可插拔。

3.15.2 接口和抽象类的区别

接口：

接口中定义的方法不能有方法体(都是抽象方法)，默认是public abstract

接口中定义的变量都是常量，默认是public static final

接口中不能有构造方法

接口不可以实例化

接口可以多实现，用implements关键字，并且继承多个接口,多个接口之间用逗号分隔

抽象类：

抽象类中可以有抽象方法也可以有普通方法(有具体实现的方法)

抽象类中可以有常量，也可以是非常量

抽象类中可以有构造方法

如果抽象类在子类对象创建的时候会自动创建抽象类的对象

抽象类只能单继承

3.16 Object类的介绍

Object在Java中被定义为一个顶级父类，它是任何类父类，我们可以显示的继承它，也可以隐式继承

3.16.1 Object类常用方法的使用

tostring方法：

toString 方法会返回一个“以文本方式表示”此对象的字符串。结果应是一个简明但易于读懂的信息表达式。建议所有子类都重写此方法

equals方法：

Object类的equals方法默认比较的是地址，如果需要判断自定义类型对象内容是否相等，则需要重写equals方法(字符串重写了equals方法)

==：

比较的是值是否相同如果相同返回true,否则返回false

如果是引用数据类型变量比较的是地址值(地址值相等返回true，否则返回false)

finalize方法：

Finalize方法是垃圾回收器的一个方法，每个对象都有，不需要调用在回收之前，自动调用该对象的finalize()方法。

3.17包和import

有时候，类和类的名称可能发生冲突；Java提供了把类名空间划分为更容易管理的块的机制，这就是包。

包与包之间对于类的访问权限提供更有力的约束。

Package只能出现在.Java源文件的第一行。项目中package定义格式：公司域名倒序.项目名.模块名。

Import语句可以引入其他类。Import语句只能出现在package之下，class定义语句之上。

3.18修饰符访问权限（public、private、protected、默认）

private：

只能在本类中访问,

如果父类的成员(属性、方法)被声明成private

那么子类将无法继承到这些成员

public：

公共的,在其他类中都可以访问

默认的(缺省的)

在本类,同包中可以访问

protected：

在本类,同包,子类中可以访问

 

 

 

3.19内部类（成员、静态、方法、匿名）

在一个类中定义另外一个类叫做内部类，是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号 。

内部类不能用普通的方式访问。内部类是外部类的一个成员，因此内部类可以自由地访问外部类的成员变量，无论是否是private的 。

内部类声明成静态的，就不能随便的访问外部类的成员变量了，此时内部类只能访问外部类的静态成员变量 。

3.19.1成员内部类:

成员内部类不能有静态声明，成员内部类可以访问外部所有数据。

创建对象方法

外部类名 对象1名 = new 外部类名（）；

外部内名.内部类名 对象2名 = 对象1名.new 内部类名（）；

3.19.2静态嵌套类 

静态内部类可以直接外部类的静态数据，无法直接访问成员方法，

间接访问方法：外部类名.静态内部类名 对象名 = new 外部类名.内部类名（）；

对象名.方法（）；

3.19.3方法内部类 

方法内部类不能用权限控制修饰符修饰，

方法内部类不能有静态声明

方法内部类访问局部变量要被final 修饰

方法内部类只能在方法内部里调用

3.19.4匿名内部类 

指类没有名字。优点：少创建一个类，但是无法重复利用

3.20类与类之间的关系（is-a,is-ike-a,has-a）

Is-a 继承 is-like-a 实现 has-a 关联

 

 

 

 

 

一、作业：

1、一个Student类有以下私有属性 id，name，class，subject，score，将其进行封装，重写构造函数,调用构造函数进行对象的创建，如果调用无参构造函数默认赋值为(1,”hardy”,”javase”,”java”,90)。

2、写一个Animal类，定义两个常量；eating、sleeping的静态方法，仅创建第一个对象的时候输出“欢迎来到动物王国世界”，每个对象创建的时候都输出“希望你这次旅游玩的开心”，对象调用eating方法是输出“爱护动物人人有责”，调用sleeping方法输出“动物世界很美妙”。

3、利用多态写一个主人喂养不同宠物吃不同东西程序。

 

预习：

1、super关键字；

2、Final关键字；

3、抽象类；

4、接口；

5、Object类；

6、修饰符访问权限；

7、内部类；

8、安装UML工具。

 

 

二、作业：

1、定义一个Student(学生)类继承Person类,并添加学生编号(stdNo)的属性,通过有参构造方法来初始化学生的信息，并且在构造方法中同过super调用父(Person)类的构造方法来初始化name,age,sex的值

2、编写程序表示职员的基本信息与薪酬计算：

1.定义抽象类  Employee  表示职员

包含受保护的属性：姓名，基本工资，家庭住址，该月休假数

为Employee类提供构造函数，为每个属性赋值

编写方法：calculateLessPay（） 计算扣除

规则为无休假不扣除，5天以内（包含5天）扣除基本工资的4分之1，超过5天扣除基本工资的一半。

编写抽象方法calculateTotal（）计算工资总额。

2.编写子类Director 表示董事长

包含私有属性transportAllowance 表示交通补助

给该类提供构造函数，给每个属性赋值，注意使用super

重写calculateTotal（）方法计算董事长的工资总额，计算标准为：基本工资+岗位津贴5000+交通补助

重写toString()方法显示基本信息，并显示董事长的总工资和实际工资（总工资-应扣工资）

重写equals()方法，用于判断对象是否相等！

3.编写子类 Manager 表示部门经理

类中包含私有属性：Department 表示部门

给该类提供构造函数，给每个属性赋值，注意使用super

重写calculateTotal（）方法计算部门经理的工资总额，计算标准为:基本工资+岗位津贴1500+绩效工资:基本工资的20%。

重写toString()方法，显示基本信息，所在部门名称，以及总工资与实际工资（总工资-应扣工资）

4.在测试类中分别创建董事长与部门经理的实例，输出相应详细信息。

3、结合包的方式来测试public,private,protected,default的访问范围，并创建一个excel表格来概括！

 

 

预习：

1、常见异常；

2、异常的两种处理方式；

3、Finally；

4、自定义异常。

 

 

 

 

第四章异常

4.1异常的介绍

程序中出现的可以被处理的错误称为异常。

异常一般分为编译时异常和运行时异常；

编译时异常一般是指语法错误，可以通过编译器的提示加以修正，

运行时异常包括：运行错误和逻辑错误

 

 

 

异    常	说    明
Exception	异常层次结构的根类
RuntimeException	许多java.lang异常的基类
ArithmeticException	算术异常，如：除数为0
IllegalArgumentException	方法接收到非法参数
ArrayIndexOutOfBoundsException	数组下标越界
NullPointerException	访问空引用
ClassNotFoundException	不能加载所需的类
NumberFormatException	字符串转换数字失败
IOException	I/O异常的根类
FileNotFoundException	找不到文件
EOFException	文件结束

4.2异常的使用

try:用来监视异常的发生

catch:用来处理异常

finally:一定会执行的代码，一般用来做资源的释放。例如：数据库连接的关闭

throw:手动引发异常。例如：throw new AgeException();

throws:抛出异常，进行异常信息的传递，传递给方法的调用者，throws关键字必须写到方法的后面

如果有多个异常需要抛出，那么异常之间用逗号分隔

try，cacth，finally都不能单独存在catch和finally必须要和try进行搭配

如果有多个catch,并且有一个catch处理的异常类型是Exception，那么这个catch一定要在所有catch之后，因为Exception是异常类型的父类，所有异常都可以接收到。

e.getMessage();和e.printStackTrace();的区别。

4.2.1 finally,final、finalize的区别

finally：

无论try/catch块中发生了什么，finally块都一定会执行；

当异常发生时，程序可能会意外中断，有些被占用的资源就得不到清理。finally块可以确保执行所有的清理工作；

无论是否发生异常，finally块都将执行；

finally块是可选的，可视具体情况决定是否添加；

finally块必须和try块一起使用，不能单独存在

final：

final关键字就是一个修饰符，用来修饰类，方法，变量

如果一个类被final修饰则表示这个类不能被继承

如果一个方法被final修饰则表示这个方法不能被重写

如果一个变量被final修饰,就不能再改变

 

finalize：

它是在 Object 类中定义的，因此所有的类都继承了它

子类覆盖 finalize() 方法整理系统资源或者执行其他清理工作。

finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的。

4.3 自定义异常

Exception类和其子类都是系统内置的异常，这些异常不一定总能捕获程序中发生的所有异常；

有时候，我们可能要根据业务的需求创建用户自定义的异常类；

用户自定义异常类应该是Exception类的子类

接受键盘输入

Scanner  s = new Scanner(System.In);

String userInput = s.next();

 

 

作业：

1、自定义一个异常，从键盘接收的两个字符串数字不能超过4位，然后将两个数进行相处，对可能出现的异常进行处理。

 

 

预习：

1、一维数组、二维数组的两种创建方法。

2、选择排序、冒泡排序、二分法查找。

 

 

 

第五章 数组

1、数组介绍

Java中数据类型分为两大类，一种叫做基本数据类型

基本类型就是那八种基本数据类型，基本类型的一个变量，表示的都是一个数据，一个整型，一个浮点型等等。

除了基本之外，就是复杂(引用)数据类型。为什么叫复杂数据类型？就是指一个复杂数据类型的变量可能包含多个数据。Java中，称之为引用数据类型。数组就是其中之一

多个数据组合起来就是数组，而且是多个相同类型数据的组合。

数组可以节省内存空间，在大量系列数据的处理上更加便捷，快速。

2、数组的使用

定义数组包含：

数组名称，数组类型，数组成员（元素），数组的索引，数组的索引方式，数组的长度。  

定义数组的形式：

第一种定义方式只声明数组名和数组数据类型

第二种方式在第一种的基础上给我们的数组分配内存空间并确定数组长度

第三种是在第二种的基础上给我们的数组赋初始值

3、数组在内存中的分配(JVM 内存区域介绍)

Java虚拟机将它管理的内存分为五部分,每一个部分都有自己特有的功能

 

 

 

栈: 存放局部变量,在栈中的数据生命周期是确定的,数据会自动释放.

堆: 用来存放引用数据类对象(实体),在堆中的数据生命周期是不确定的,堆中的内存由垃圾回收器进行释放处理.

程序计数器: 是线程私有（与线程共享相对）的，也就是说有 N 个线程，JVM 就会分配 N 个程序计数器。如果当前线程在执行一个 Java 方法，则程序计数器记录着该线程所执行的字节码文件中的指令地址。如果线程执行的是一个 Native 方法，则计数器值为 Undefined。

方法区：方法区也可以是内存不连续的区域组成的，并且可设置为固定大小，也可以设置为可扩展的

4、二维数组的介绍

二维数组就是将一个数组作为另外一个数组的元素。

注意：

定义数组 要写长度  有初始值不能有长度

{} 只能用于第一次赋默认值，以后不能再使用

数组元素不能越界

5、二维数组的使用

二维数组的定义：

只声明数组名：

int array[ ][ ];

同时分配空间确定长度：

int array[ ][ ] = new int [2][3];

分配空间同时附初始值 ：

int array[ ][ ] = new int [ ][ ]{{1,2,3},{4,5,6},{7,8,9}};

附初始值的简写形式 ：

int array[ ][ ]= {{1,2},{3,4}};

6、杨辉三角

杨辉三角特性：

端点的数为1.

每个数等于它上方两数之和。

每行数字左右对称，由1开始逐渐变大。

7、冒泡排序的应用

冒泡排序它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序不符合要求就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换。

8、选择排序的应用

选择排序是一种坚定直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小(或最大)的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。选择排序是不稳定的排序方法。

9、数组的搜索(二分法查找)

当数据量很大适宜采用该方法。

采用二分法查找时，数据需是排好序的

每一次查找与中间值比较，可以确定是否查找成功，不成功当前查找区间缩小一半。

10、Arrays工具类的简单介绍(sort方法、toString方法)

Arrays这个工具类包括了许多对数组进行操作的方法，比如对数组排序和元素的显示.

sort()方法是用于对数组的元素进行排序

toString()方法是指返回该对象的字符串表示

 

作业：

1、用数组输出如下规律矩阵：

1

1 2 1

1 2 4 2 1

1 2 4 8 4 2 1

 

 

预习：

1、java.lang包下的String类、Math类、八大包装类。

2、Java.util包下的Date类、Random类、Enum类。

 

 

 

第六章 常用类

1.1、java.lang包介绍

java.lang包是Java基础语言包(其中lang是language(语言)的简写)

该包中包含Java语言所需要的基本的功能类、接口等信息

在默认情况下，每个java程序都会自动导入该包，因此无需在程序中显式地声明

1.2、String类介绍

Java中，字符串是String类的对象；

可以通过使用String类提供的方法来完成对字符串的操作；

创建一个字符串对象之后，将不能更改构成字符串的字符(被final修饰)，字符地址可以重新指向；

每当更改了字符串版本时，就创建了一个新的字符串对象，并在其内包含所做的修改，原始字符串保持不变。

1.3、String常见面试题和陷阱

在java中所有被双引号(””)括起来的字符串都会在字符串常量池中创建一份，在程序执行过程中如果要用到某个字符串，程序会先在字符串常量池中查找，如果找到就直接拿，没有找到就进行创建。程序中不建议频繁进行字符串的拼接。

比较两个字符串是否一致，必须使用String类提供的equals方法。

String s1 = new String(“hello”);

String s2 = new String(“hello”);

 

String s3 = new String(“hello”+”world”);

正则表达式：专门做字符串格式匹配

“^a{2}$” \d 数字 \D非数字，\w 英文字母，\W非英文字母

1.4、String类的使用

String类常用的方法。

toCharArray()

valueOf(char[] data,int offset,int count)

substring(int beginIndex,int endIndex)

replace(CharSequence target,CharSequence replacement)

length()

indexOf(int ch)

isEmpty()

split(String regex)

endsWith(String suffix) concat(String str)

1.5、StringBuffer的使用

StringBuffer类用于表示可以修改的字符串；

创建StringBuffer类的对象后，可以随意修改、变更字符串的内容。

使用+运算符的字符串将自动创建字符串缓冲对象；

1.6、StringBuilder的使用

一个可变的字符序列

此类提供一个与 StringBuffer 兼容的 API，但不保证同步

该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候

1.7、StringBuffer和StringBuilder的区别

在执行速度方面的比较：StringBuilder >  StringBuffer   

StringBuilder：线程非安全的

StringBuffer：线程安全的

当我们在字符串缓冲去被多个线程使用是，JVM不能保证StringBuilder的操作是安全的，虽然他的速度最快，但是可以保证StringBuffer是可以正确操作的。当然大多数情况下就是我们是在单线程下进行的操作，所以大多数情况下是建议用StringBuilder而不用StringBuffer的，就是速度的原因。

1.8、Math类的使用

Math类是一个数学工具类

在Java语言中，常用的数学常数和数学方法都在该类内部

该类的构造方法被修饰为private，因此不能实例化；

该类中的所有方法都是静态的，可以通过类名直接调用；

该类被修饰为final，因此没有子类

random()

1.9、八大包装类的使用

Java语言是一个面向对象的语言，但是Java中的基本数据类型却是不面向对象的，于是在设计类时为每个基本数据类型设计了一个对应的类进行代表，这样八个和基本数据类型对应的类统称为包装类(Wrapper Class)

有些地方也翻译为外覆类或数据类型类。

 

1.10、java.util包的介绍

java.util包是Java内置的一个工具包，其中包含一系列常用的工具类；

用来处理日期和日历的类以及一些集合类；

java.util包不会默认导入，如果要使用到该包中的类，则必须在程序的开始部分显式地声明如下语句：

import java.util.*;

1.11、日期类的使用

Date类对象用来表示时间和日期；

该类提供一系列操纵日期和时间各组成部分的方法；

Date类最多的用途是获取系统当前的日期和时间。

Date类的构造方法：

构 造 方 法	说    明
Date()	使用系统当前时间创建日期对象
Date(long date)	使用自1970年1月1日以后的指定毫秒数创建日期对象
Date(int year,int month,int date)	创建指定年、月、日的日期对象
Date(int year,int date, int hrs,int min,int sec)	创建指定年、月、日、时、分、秒的日期对象

Date类的常用方法：

方 法 原 型	说    明
boolean after(Date when)	如果当前日期对象在when指定的日期对象之后，返回true，否则返回false
boolean before(Date when)	如果当前日期对象在when指定的日期对象之前，返回true，否则返回false
void setTime(long time)	设置日期对象，以表示自1970年1月1日起的指定毫秒数
boolean equals(Object obj)	如果两个日期对象完全相同，返回true，否则返回false
String toString()	返回日期的格式化字符串，包括星期几

 

1.12、数字格式元素(java.text包)

#任意数字；

，千分位；

.小数点；

0不够补零。

1.13、Random的使用

Random类专门用来生成随机数；

Random类的构造方法：

构 造 方 法	说    明
Random()	直接创建一个Random类对象
Random(long seed)	使用seed作为随机种子创建一个Random类对象

 

Random类的常用方法：

方 法 原 型	说    明
int nextInt()	从随机数生成器返回下一个整型值
long nextLong()	从随机数生成器返回下一个长整型值
float nextFloat()	从随机数生成器返回0.0到1.0之间的下一个浮点值
double nextDouble()	从随机数生成器返回0.0到1.0之间的下一个双精度值
double nextGaussian()	从随机数生成器返回下一个高斯分布的双精度值。中间值为0.0，而标准差为1.0

 

1.14、枚举的使用 

枚举其实就是一种类型，跟int, char 这种差不多，就是定义变量时限制输入的，你只能够赋enum里面规定的值。

enum很像特殊的class，实际上enum声明定义的类型就是一个类 

这些类都是类库中Enum类的子类（java.lang.Enum）。它们继承了这个Enum中的许多有用的方法。

 

 

 

作业：

1、String s=”Hello”;s=s+”world!”创建几个字符串对象；

String s1= new String(“Hello”);

String s2= new String(s1+”world”); 创建几个字符串对象

2、.编写一个Java程序，完成以下功能：

声明一个名为s的String对象，并使它的内容是"Call Me tzxy";

1.显示该字符串长度。

2.使用IndexOf与LastIndexOf以及substring截取出“Me”。

3.使用CharAt 与Character的IsUpperCase()方法显示所有的大写字母

4.使用StringBuffer，去掉字符串中的“Me”

5.继续在字符串后使用append拼接上“潭州学院”

3、将系统日期设置为2008-08-08并输出当天是星期几；

4、输出一个随机不重复的五位数。

 

预习：

1、集合中 ArrayList类，LinkedList类，Vector类，之间异同；

2、集合中 HashSet  TreeSet 特性；

3、集合中 HashMap TreeMap Properties特性。

 

 

 

第七章 集合

1.1、集合（collections）介绍

集合是将多个元素组成一个单元的对象；

类似于数组，但数组最大的缺点是：长度受到限制（一经创建，就不可再改变），并且只能存放相同数据类型的元素；

集合的长度没有限制，可以存放任意多的元素，而且元素的数据类型也可以不同；

Collections继承关系图

 

 

 

1.2、ArrayList的使用

ArrayList是长度可变的对象引用数组，称为动态数组；

随着元素的添加，元素数目的增大，数组容量也会随之自动扩展；

访问和遍历数组元素时，ArrayList的性能优越；

ArrayList类继承了AbstractList类并实现了List接口。

ArrayList的构造方法

构 造 方 法	说    明
ArrayList()	创建一个空的ArrayList对象
ArrayList(Collection c)	根据指定的集合创建ArrayList对象
ArrayList(int initialCapacity )	使用给定的大小创建ArrayList对象

ArrayList的常用方法

方 法 原 型	说    明
int size()	返回ArrayList对象的大小，即元素的数量
boolean isEmpty()	判断ArrayList对象是否为空，为空返回true，否则返回false
void clear()	清空ArrayList对象中的所有元素
boolean add(Object element)	向ArrayList对象中添加一个元素，该元素可以是任何类的对象
Object remove(int index)	从ArrayList对象中删除指定索引位置的元素
Object get(int index)	返回指定索引位置的元素
Object set(int index,Object elem)	将元素elem存放到由index指定的索引位置上
int indexOf(Object element)	判断element在ArrayList对象中是否存在，存在返回对应的索引，否则返回-1

1.3、LinkedList的使用

LinkedList类用于创建链表数据结构；

链表中元素的数量不受任何限制，可以随意地添加和删除；与ArrayList相比，如果需要频繁地添加和删除元素，LinkedList的性能更加优越；

LinkedList类继承了AbstractSequentialList类，并实现了List接口。

LinkedList的构造方法

构 造 方 法	说    明
LinkedList()	创建一个空链表
LinkedList(Collection c)	根据指定的集合创建链表

LinkedList的常用方法

方 法 原 型	说    明
int size()	返回链表的大小，即元素的数量
boolean isEmpty()	判断链表是否为空，为空返回true，否则返回false
void clear()	清空链表中的所有元素，使其成为空链表
boolean add(Object element)	向链表中添加一个元素，该元素可以是任何类的对象
Object remove(int index)	从链表中删除指定索引位置的元素
Object get(int index)	返回指定索引位置的元素
Object set(int index,Object elem)	将元素elem存放到由index指定的索引位置上
int indexOf(Object element)	判断element在链表中是否存在，存在返回对应的索引，否则返回-1
void addFirst(Object element)	将指定元素添加到链表的开始处
void addLast(Object element)	将指定元素添加到链表的结尾处
Object removeFirst()	删除链表中的第一个元素
Object removeLast()	删除链表中的最后一个元素
Object getFirst()	返回链表中的第一个元素
Object getLast()	返回链表中的最后一个元素

 

1.4、ArrayList、LinkedList、Vector的区别

ArrayList 采用的是数组形式来保存对象的，这种方式将对象放在连续的位置中，所以最大的缺点就是插入删除时非常麻烦

LinkedList 采用的将对象存放在独立的空间中，而且在每个空间中还保存下一个链接的索引  但是缺点就是查找非常麻烦 要丛第一个索引开始

Vector底层和ArrayList集合相同，但是Vector是线程安全的，效率低。

1.5、Set接口的介绍

Set不保存重复的元素。

Set中最常被使用的是测试归属性，你可以很容易的询问某个对象是否在某个Set中。

Set具有与Collection完全一样的接口，因此没有任何额外的功能。

实际上Set就是Collection，只是行为不同。

实现了Set接口的主要有HashSet、TreeSet、LinkedHashSet

1.6、HashSet的使用

主要方法： add(),remove(),size(),clear();

contains(o) 判断是否包含对象0

特点：无序不可重复。

如何确定两个对象是否相同：除了equals方法返回为true,hashCode()方法返回值也必须相同。该返回值用来确定每个对象在set中的位置，只有相同才能保证会放到HashSet中的同一个位置。

HashSet其实是HashMap中的key部分。

1.7、TreeSet的使用

TreeSet是依靠TreeMap来实现的。

TreeSet是一个有序集合，TreeSet中的元素将按照升序排列，缺省是按照自然排序进行排列，意味着TreeSet中的元素要实现Comparable接口。或者有一个自定义的比较器。

我们可以在构造TreeSet对象时，传递实现Comparator接口的比较器对象

1.8、Map接口的介绍

与Collection集合不同，Map类型集合每个元素值 都包含两个对象：键--值

键在Map中不能有重复对象

主要方法：

put(key,value);

size();

remove(key),clear();

containsKey(key) 判断是否包含键key

containsValue(value)判断是否包含值value

其中put方法若添加重复的键，则表示覆盖原来的键

Map不存在索引，但同样可以实现循环访问：

使用：keySet()或entrySet()

Map集合继承结构图

 

 

 

1.9、HashMap的使用

HashMap以键值对的形式存储元素；

对于HashMap来说，不存在索引，也就是说不可以通过索引来访问元素，只能通过键去访问值，如要快速检索元素的话，HashMap性能优越；

由于没有索引，所以HashMap中元素的存放是没有顺序的；

HashMap类继承了AbstractMap类，并实现了Map接口。

HashMap(哈希表/散列表)是数组和单项链表的结合，本质是一个数组，只不过数组中的每个元素又是一个单向链表。

1.10、Hashtable介绍

类实现一个Hash表，该Hash表将键映射到相应的值。

任何非 null 对象都可以用作键或值。

为了成功地在Hash表中存储和获取对象，用作键的对象必须实现 hashCode 方法和 equals 方法。

Properties是Hashtable的属性类，也是以key和value的方式存储元素，但是key和value只能是字符串类型。

1.11、HashMap和Hashtable的区别

Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现。

当需要同步时，用Hashtable，反之用HashMap。Hashtable的线程安全并且性能较低，而HashMap的线程是不安全的

只有HashMap可以让你将空值作为一个表的条目的key或value，而Hashtable不可以让你将空值作为一个表的条目的key或value。

1.12、SortedMap的使用

StoredMap以键值对的方式存储元素；

存储特点：无序不可重复，但是存进去的元素可以按照大小顺序自动排序。Key部分的元素要实现comparable接口或者写一个比较器。

1.13、使用增强for（foreach）循环来获取集合中的元素 

foreach 语句为数组或对象集合中的每个元素重复一个嵌入语句组。

foreach 语句用于循环访问集合以获取所需信息，但不应用于更改集合内容

for(元素类型t 元素变量x : 遍历对象obj){ Java 语句块}

1.14、泛型的使用

泛型是程序设计语言的一种特性。

允许程序员在强类型程序设计语言中编写代码时定义一些可变部分，那些部分在使用前必须作出指明。

各种程序设计语言和其编译器、运行环境对泛型的支持均不一样。

泛型作用：同一类型；减少强制类型循环。

 

 

 

作业：

1、给一个字符串“abispowicpgtienczmaeciew”,利用集合知识将字符串中的重复字符去掉。

2、集合实现酒店管理

第八章 IO流

1、字节流；

2、字符流；

3、缓冲流；

4、数据流；

5、转换流；

6、序列化和反序列化。

1.1、java.io包介绍

i : input  o : output

IO 表示程序中将数据输出到程序以外或在程序以外将数据输入到程序内。

也就是程序与外界的数据交流。可以输出到控制台，文件，或网络上的其他计算机上

java.io包也是Java内置的包，其中包含一系列对文件和目录的属性进行操作，对文件进行读写操作的类；

程序中如果要使用到该包中的类，对文件或流进行操作，则必须显式地声明如下语句：import java.io.*; 

1.2、File对象的使用

File类的对象不但可以表示文件，还可以表示目录，在程序中一个File类对象可以代表一个文件或目录；

当创建一个文件对象后，就可以利用它来对文件或目录的属性进行操作，如：文件名、最后修改日期、文件大小等等；

需要注意的是，File对象并不能直接对文件进行读/写操作，只能查看文件的属性；

File构造方法：

File(String pathname)

指定文件（或目录）名和路径创建文件对象

File类中的常用方法

方 法 原 型	说    明
boolean exists()	判断文件是否存在，存在返回true，否则返回false
boolean isFile()	判断是否为文件，是文件返回true，否则返回false
boolean isDirectory()	判断是否为目录，是目录返回true，否则返回false
String getName()	获得文件的名称
String getAbsolutePath()	获得文件的绝对路径
long length()	获得文件的长度（字节数）
boolean createNewFile() throws IOException	创建新文件，创建成功返回true，否则返回false，有可能抛出IOException异常，必须捕捉
boolean delete()	删除文件，删除成功返回true，否则返回false
File[] listFiles()	返回文件夹内的子文件与子文件夹的数组

1.3、IO继承结构图

字节流继承图

 

 

 

 

字符流继承图

 

 

 

1.4、FileInputStream和FileInputStream的使用

FileInputStream类称为文件输入流，继承于InputStream类，是进行文件读操作的最基本类；

它的作用是将文件中的数据输入到内存中，我们可以利用它来读文件；

由于它属于字节流，因此在读取Unicode字符（如中文）的文件时可能会出现问题。

FileOutputStream类称为文件输出流，继承于OutputStream类，是进行文件写操作的最基本类；

它的作用是将内存中的数据输出到文件中，我们可以利用它来写文件。

1.5、FileReader、FileWriter的使用

FileReader类称为文件读取流，允许以字符流的形式对文件进行读操作。

FileWriter类 称为文件写入流，以字符流的形式对文件进行写操作与FileReader类相似，FileWriter类同样需要使用缓冲流进行包装。

1.6、BufferedReader、BufferedWriter的使用

BufferedReader类主要为字符流提供缓冲，以提高效率

BufferedReader类的构造方法：

BufferedReader(Reader in)

将字符读取流对象包装成缓冲读取流对象。

BufferedWriter类 可以为FileWriter类提供缓冲

BufferedWriter的构造方法：

BufferedWriter(Writer out)

将字符写入流对象包装成缓冲写入流对象。

1.7、BufferInputStream、BufferOutputStream的使用

1.8、DataInputStream、DataOutputStream的使用

1.9、ObjectOutputStream、ObjectInputStream的使用

ObjectOutputStream: 把对象转换为字节序列的过程称为对象的序列化。

ObjectInputStream:把字节序列恢复为对象的过程称为对象的反序列化。

主要有两种用途：

把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中；

在网络上传送对象的字节序列。

1.10 InputStreamReader、OutputStreamWriter的使用

1.11、PrintWriter、PrintStream的使用。

 

第九章 多线程

1.1、线程的介绍

线程介绍：

进程内部的一个执行单元，它是程序中一个单一的顺序控制流程。如果在一个进程中同时运行了多个线程，用来完成不同的工作，则称之为多线程

 

进程是系统资源分配的单位，可包括多个线程

线程是独立调度和分派的基本单位，共享进程资源

引入进程是为了多个程序并发执行，提高资源的利用率和系统吞吐量

引入线程是为了减少程序在并发执行时付出的时空开销

 

系统线程

(核心级线程):由操作系统内核进行管理，使用户程序可以创建、执行、撤销线程。

用户线程

管理过程全部由用户程序完成，操作系统内核只对进程进行管理

 

多线程：

多线程使系统空转时间减少，提高CPU利用率

进程间不能共享内存，但线程之间共享内存非常容易

使用多线程实现多任务并发比多进程的效率高

Java语言内置多线程功能支持，简化了Java的多线程编程

 

 

1.2、线程的使用

两种方法：

继承Java.lang.Thread类，并覆盖run() 方法

class MyThread extends Thread {

     public void run( ) {

         /* 覆盖该方法*/

      }

 }

实现Java.lang.Runnable接口，并实现run()方法

class MyThread implements Runnable{

      public void run( ) {

            /* 实现该方法*/

      }

 }

 

新建的线程不会自动开始运行，必须通过start( )方法启动，不是通过调用run()方法。

启动继承Thread的线程

MyThread  thread= new MyThread ();

t.start();

启动实现Runnable接口的线程

MyThread mt= new MyThread ();

Thread thread= new Thread(mt);

t.start();

1.3、线程的优先级别

多线程的执行本身就是多个线程的交换执行，并非同时执行

每个线程执行时都具有一定的优先级。当调度线程时，会优先考虑级别高的线程

默认情况下，一个线程继承其父线程的优先级

使用 线程对象.setPriority(p)来改变线程的优先级

 

优先级影响CPU在线程间切换，切换的原则是：

当一个线程通过显式放弃、睡眠或者阻塞、自愿释放控制权时，所有线程均接受检查而优先级高线程将会优先执行

一个线程可以被一个高优先级的线程抢占资源

同级别的线程之间，则通过控制权的释放，确保所有的线程均有机会运行。

 

1.4、 守护线程

setDaemon()

可以将指定的线程设置成后台线程

创建后台线程的线程结束时，后台线程也随之消亡

1.5、线程的同步

所谓同步，就是在发出一个功能调用时，在没有得到结果之前，该调用就不返回，同时其它线程也不能调用这个方法。

在多线程编程里面，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何时刻，最多有一个线程访问，以保证数据的完整性。

1.6、线程的wait和notify

wait()   导致当前线程等待，直到其他线程调用此对象的 notify()方法或 notifyAll()方法前，导致当前线程等待。

notify()  唤醒在此同步监视器上等待的单个线程，如果有多个线程在此同步监视器上等待，则会唤醒其中的一个，

1.7、wait和sleep的区别

sleep是Thread类的方法，让某个线程暂停运行一段时间,是线程用来控制自身流程的，其控制范围是由当前线程决定,

wait是Object类的方法，用来线程间的通信，这个方法会使当前拥有该对象锁的进程等待知道其他线程调用notify方法时再醒来。也可以给他指定一个时间，自动醒来。这个方法主要是用走不同线程之间的调度的。

 

1.8、线程的生命周期

 

线程的四个状态

1.创建状态：

当用new操作符创建一个新的线程对象时，该线程处于创建状态。

处于创建状态的线程只是一个空的线程对象，系统不为它分配资源。

2.可运行状态：

执行线程的start()方法将为线程分配必须的系统资源，安排其运行，并调用线程体——run()方法，这样就使得该线程处于可运行状态（Runnable）

这一状态并不是运行中状态（Running），因为线程也许实际上并未真正运行。

3.不可运行状态：

下列事件发生，运行状态的线程会转入到不可运行状态：

　　 调用了sleep()方法；

　　 线程调用wait()方法等待特定条件的满足；

　　 线程输入/输出阻塞。

　　返回可运行状态：

　 处于睡眠状态的线程在指定的时间过去后；

如果线程在等待某一条件，另一个对象必须通过notify()或notifyAll()方法通知等待线程条件的改变；

　　 如果线程是因为输入输出阻塞，等待输入输出完成。

4.消亡状态：

　　 当线程的run()方法执行结束后，该线程自然消亡。

 

1.10、Timer的使用

是一种工具，用Timer操作线程，可以在后台执行线程中的任务，可以控制这个任务执行一次，或者定期重复执行。

与每个Timer对象对应的是单个后台线程，用于顺序的执行所有计时器任务。

如果以外终止了Timer正在执行的线程，例如调用了这个线程的stop方法，那么以后所有的该计时器的任务的尝试都将导致IllegalStateException，就好像计时器调用了cancel方法一样。

Timer类是线程安全的，多个线程可以共享单个Timer对象而无需进行外部同步。

 

第十章  网络编程

1.1、网络基础知识

两台计算机通过网络进行通信需要满足一些必要条件

1.IP地址

每台机器的唯一标识

2.共同语言（协议）

3.相应的端口号

用于区别不同的应用

范围为 0-65535 其中0-1023为系统保留

IP和端口号组成了socket，Socket是TCP/UDP的基础

一些常用的端口号：

http ：80 ， ftp ：21 ， telent：23

4.java提供的针对网络编程的四大类

*InetAddress :用于标识网络上的硬件资源

*URL：统一资源定位符，通过URL可以直接读取或写入网络上的数据

*Sockets：使用TCP协议实现网络通信

*Datagram：使用UDP协议实现网络通信（数据报）

 

1.2、java的InetAddress

1.java中的InetAddress的应用

InetAddress类用于标识网络上的硬件资源，表示互联网协议地址

2.InetAddress的常用方法

1.3、通过socket实现TCP编程

 

1.4、通过socket实现UDP编程

第十一章 反射机制

 

 

第十二章 用户图形界面（GUI）

1.1、GUI介绍

GUI就是Graphics User Interface的缩写,即图形化用户界面。

SUN公司提供了对GUI支持的包，分别是AWT和SWING。

 

AWT是属于依赖底层代码的,所以其界面的外观由OS决定。

要使用awt包中的类，必须显式的声明如下语句：

import java.awt.*;

 

SWING是轻量级组件,不依赖于OS,在所有OS中都是统一界面。

而要使用swing包中的类，必须显式的声明如下语句：

import javax.swing.*;

 

 

1.2、GUI常用布局的使用

布局管理器用来决定组件在容器上如何摆放，决定组件的大小

JAVA中常用的布局：

FlowLayout（流式布局）

BorderLayout（边框布局）

GridLayout（网格布局）

CardLayout （卡片布局）

NullLayout（绝对布局）

 

1.3、GUI常用组件的使用

标签(JLabel)

输入框(JTextField)

密码输入框(JPasswordField)

单选框(JRadioButton)

复选框(JCheckBox)

下拉框(JComboBox<String>)

文本域(JTextArea)

按钮(JButton)

 

1.4、GUI事件介绍

用户与GUI组件进行的一次交互就会发生一个事件，如：按下一个按钮、用键盘输入一个字符、点击鼠标等等。

我们要关注的并不是“事件是如何产生的”，而是当发生事件后，我们应当“如何处理它”。

 

 

1.5、GUI事件的处理

事件有三大要素:

事件源:

当在一个图形用户界面点击鼠标或者按下键盘时，都是针对于具体组件而发生的动作，如：使用鼠标点击某个按钮，按下键盘向文本框输入内容等等，我们把动作所操纵的对象称为事件源。

 

注意：事件源一定是指某个组件；当针对于事件源发生动作时，就会产生一个事件。一个事件源必须注册监听器以便监听器可以接受关于一个特定事件的通知。

 

事件对象:

对事件的描述(包含了事件发生的信息)

事件对象实际上也就是方法里的形式参数。

 

事件监听器:

每一类型的事件，都有与之相对应的监听器，用于监听事件的发生

 

事件监听器就是实现了事件监听接口的类，监听器不断监听事件源的动作，当事件源产生一个事件后，监听器接收到事件源的通知，就调用特定的方法，以执行指定的动作

 

特定的事件监听器只对特定的事件感兴趣。

 

实现事件的3个步骤:

1.确定事件源

2.实现对应(特定)事件的监听器

3.将监听器和事件源绑定

 

1.6、适配器的使用

适配器实现原理很简单，就是一个类然后去帮我们实现对应的监听器接口。

我们如果需要监听某个事件，只需要继承对应的适配器类就可以了。

具体实现的方式可以采用: 内部类、匿名类或者外部类来实现。

1.7、GUI图像处理介绍

Java 是面向对象的语言，我们要实现某些功能就是调用某个对象的方法

要在Java中来进行图像处理，我们可以通过一个Graphics(可以理解为是一个画笔对象)对象来实现图像的绘制、处理等功能。

 

1.8、使用GUI提供的api处理图像