CoreJava知识点总结
《CoreJava》知识点总结
第1单元 Java入门............................................................................................................... 8
1.1 Java的历史.............................................................................................................. 8
1.2 Java平台介绍........................................................................................................... 8
1.3 Java语言的特点....................................................................................................... 8
1.4 Java程序的运行机制................................................................................................ 9
1.4.1 JVM与跨平台................................................................................................ 9
1.4.2 JVM、JRE、JDK........................................................................................... 9
1.5 java开发环境安装、配置.......................................................................................... 9
1.5.1 安装JDK........................................................................................................ 9
1.5.2 配置环境变量................................................................................................. 9
1.6 java开发流程......................................................................................................... 10
1.6.1 结构化编程与面向对象编程.......................................................................... 10
1.6.2 编写和运行Java程序的三个步骤.................................................................. 10
1.6.1 案例............................................................................................................. 10
1.7 常用命令................................................................................................................ 11
1.7.1 Dos命令....................................................................................................... 11
1.7.2 Java命令...................................................................................................... 11
第2单元 标识符、关键字、数据类型.................................................................................. 12
2.1 注释....................................................................................................................... 12
2.2 分隔符：; 空格 代码块.......................................................................................... 12
2.3 标识符................................................................................................................... 12
2.3.1 标识符的概念............................................................................................... 12
2.3.2 标识符的语法要求........................................................................................ 12
2.3.2 标识符的命名规范........................................................................................ 12
2.3.3 标识符案例................................................................................................... 13
2.4 Java的关键字......................................................................................................... 13
2.4.1 Java中的全部关键字..................................................................................... 13
2.4.2 目前已经接触到的关键字.............................................................................. 13
2.5 基本数据类型......................................................................................................... 13
2.5.1 数据类型的分类............................................................................................ 13
2.5.2 整型............................................................................................................. 14
2.5.3 浮点型.......................................................................................................... 14
4.9e-324～1.8e+308................................................................................................................ 14
2.5.4 字符型.......................................................................................................... 15
2.5.5 布尔型.......................................................................................................... 15
2.6 变量与常量............................................................................................................ 16
2.6.1 变量的声明与赋值........................................................................................ 16
2.6.2 常量的声明与赋值........................................................................................ 16
2.6.3 实例变量与局部变量..................................................................................... 16
2.6.4 变量案例...................................................................................................... 17
2.7 类型转换................................................................................................................ 17
2.7.1 自动类型转换............................................................................................... 17
2.7.2 强制类型转换............................................................................................... 17
2.7.3 类型转换案例............................................................................................... 17
2.8 面向对象初步......................................................................................................... 18
2.8.1 了解类和对象............................................................................................... 18
2.8.2 创建对象...................................................................................................... 18
2.9 原始类型和引用类型.............................................................................................. 18
第3单元 运算符&表达式&选择结构................................................................................... 20
3.1 运算符................................................................................................................... 20
3.1.1 赋值运算符................................................................................................... 20
3.1.2 算术运算符................................................................................................... 20
3.1.3 关系运算符................................................................................................... 21
3.1.4 逻辑运算符................................................................................................... 21
3.1.5 位运算符...................................................................................................... 22
3.1.6 ?运算符........................................................................................................ 23
3.2 运算符的优先级..................................................................................................... 23
3.3 流程控制-选择结构................................................................................................. 24
3.3.1 if-else........................................................................................................... 24
3.3.2 多分支语句switch......................................................................................... 24
3.3.3 if-else与Switch的区别................................................................................. 25
第4单元 控制语句.............................................................................................................. 26
4.1 while循环结构....................................................................................................... 26
4.2 do while循环结构................................................................................................... 26
4.3 While和dowhile的区别......................................................................................... 26
4.4 for循环结构........................................................................................................... 26
4.4.1 语法............................................................................................................. 26
4.4.2 嵌套的for循环............................................................................................. 27
4.4.3 使用两个变量控制循环................................................................................. 27
4.4.4 for循环实例................................................................................................. 27
4.5 break和continue..................................................................................................... 28
第5单元 数组..................................................................................................................... 29
5.1 数组的概念............................................................................................................ 29
5.2 数组声明................................................................................................................ 29
5.3 数组创建与初始化.................................................................................................. 29
5.3.1 使用new创建数组........................................................................................ 29
5.3.2 创建数组的三种方式..................................................................................... 29
5.3.3 创建数组需要注意的问题.............................................................................. 29
5.3.4 动态初始化................................................................................................... 30
5.4 数组操作................................................................................................................ 30
5.5 数组处理案例......................................................................................................... 30
5.6 数组元素的类型..................................................................................................... 30
5.7 多维数组................................................................................................................ 31
5.7.1 二维数组的声明、创建................................................................................. 31
5.7.2 单独为第二维分配内存................................................................................. 31
5.7.3 为二维数组使用初始化器.............................................................................. 32
5.8 Arrays.................................................................................................................... 32
第6单元 面向对象-类和对象.............................................................................................. 33
6.1 类与对象的概念..................................................................................................... 33
6.1.1 面向对象的概念............................................................................................ 33
6.1.2 使用类和对象开发程序的基本步骤................................................................ 33
6.1.3 类与对象...................................................................................................... 33
6.2 定义类................................................................................................................... 34
6.2.1 类的一般形式............................................................................................... 34
6.2.2 类的属性...................................................................................................... 34
6.2.2 类的方法...................................................................................................... 34
6.3 对象的声明与创建.................................................................................................. 35
6.4 类练习................................................................................................................... 37
6.5 为引用变量变量赋值.............................................................................................. 37
6.6 构造器/构造方法.................................................................................................... 38
6.6.1 new运算符深入分析..................................................................................... 38
6.6.2 构造方法的语法............................................................................................ 38
6.7 this关键字.............................................................................................................. 38
第7单元 面向对象-封装..................................................................................................... 40
7.1 封装的概念............................................................................................................ 40
7.2 访问控制................................................................................................................ 40
7.2.1 包与访问范围............................................................................................... 40
7.2.2 访问修饰符与访问范围................................................................................. 41
7.3 方法深入分析......................................................................................................... 42
7.3.1 参数传递...................................................................................................... 42
7.3.2 return............................................................................................................ 42
7.3.3 方法调用...................................................................................................... 42
7.4 方法重载................................................................................................................ 42
7.4.1 方法重载基础............................................................................................... 42
7.4.2 重载构造方法............................................................................................... 43
7.5 static关键字........................................................................................................... 43
7.5.1 静态变量...................................................................................................... 43
7.5.2 静态代码块................................................................................................... 44
7.5.3 静态方法...................................................................................................... 44
7.5.4 关于static的几点说明................................................................................... 45
第8单元 面向对象-继承..................................................................................................... 46
8.1 继承基础................................................................................................................ 46
8.1.1 继承的概念................................................................................................... 46
8.1.2 继承的语法................................................................................................... 46
8.1.3 对继承的说明............................................................................................... 46
8.1.4 子类的构造方法............................................................................................ 47
8.1.5 创建多级继承层次........................................................................................ 47
8.1.6 超类变量可以引用子类对象.......................................................................... 47
8.1.7 对象的转型................................................................................................... 48
8.2 super关键字........................................................................................................... 48
8.2.1 使用super()调用父类的构造方法................................................................... 48
8.2.2 使用super访问父类中被子类隐藏的成员变量................................................ 49
8.4 object类................................................................................................................. 49
8.4.1 toString()方法............................................................................................... 49
8.4.2 equals()方法与==.......................................................................................... 49
8.4 final....................................................................................................................... 50
8.4.1 final修饰变量、方法、类............................................................................. 50
8.4.2 引用类型的常量............................................................................................ 50
第9单元 面向对象—多态................................................................................................... 50
9.1 多态的概念............................................................................................................ 50
9.2 方法重写................................................................................................................ 50
9.2.1 方法重写的规则............................................................................................ 51
9.2.2 方法重写与方法重载的区别.......................................................................... 51
9.2 动态方法调度与运行时多态.................................................................................... 51
9.2.1 动态方法调度............................................................................................... 51
9.2.2 运行时多态................................................................................................... 51
9.2.3 多态的两种形式............................................................................................ 52
9.3 多态实例................................................................................................................ 52
9.4 多态应用................................................................................................................ 52
9.4 抽象方法与抽象类.................................................................................................. 52
9.4.1 抽象方法...................................................................................................... 53
9.4.2 抽象类.......................................................................................................... 53
第10单元 面向对象—接口................................................................................................. 53
10.1 接口的概念与定义................................................................................................ 53
10.2 接口中的属性和方法............................................................................................. 54
10.3 接口的实现........................................................................................................... 55
10.4 接口继承.............................................................................................................. 56
10.5 接口的实例........................................................................................................... 56
10.5.1 实例1......................................................................................................... 56
10.5.2 案例2......................................................................................................... 56
10.6 抽象类和接口的区别............................................................................................. 57
第11单元 常用类................................................................................................................ 58
11.1 Object................................................................................................................... 58
11.1 Object类介绍................................................................................................. 58
11.1 Object类的常用方法...................................................................................... 58
11.2 String.................................................................................................................... 58
11.2.1 String类介绍............................................................................................... 58
11.2.2 String类的构造方法.................................................................................... 59
11.2.3 字符串比较................................................................................................. 59
11.2.4 字符串连接................................................................................................. 60
11.2.5 字符串查找................................................................................................. 60
11.2.6 字符串修改................................................................................................. 61
11.2.7 提取字符与子串.......................................................................................... 61
11.2.8 其他字符串常用方法................................................................................... 62
11.3 StringBuffer和StringBuilder.................................................................................. 62
11.3.1 StringBuffer与StringBuilder类介绍............................................................. 62
11.3.2 StringBuffer类的构造方法........................................................................... 63
11.3.2 长度与容量的概念....................................................................................... 63
11.3.3 StringBuffer类的常用方法........................................................................... 63
11.4 Math..................................................................................................................... 65
11.4.1 Math介绍.................................................................................................... 65
11.4.2 Math类的常量............................................................................................. 65
11.4.3 Math类的常用方法...................................................................................... 65
11.5 Random................................................................................................................. 66
11.5.1 Random类介绍............................................................................................ 66
11.5.2 常用方法..................................................................................................... 66
11.6 Date与Calendar.................................................................................................... 66
11.7.1 Date类........................................................................................................ 66
11.7.2 Calendar与GregorianCalendar类.................................................................. 67
11.7 包装类.................................................................................................................. 67
11.7.1 Character包装器.......................................................................................... 68
11.7.2 Boolean包装器............................................................................................ 68
11.7.3 数值类型的包装器类................................................................................... 68
11.7.1 自动装箱与自动拆箱................................................................................... 69
11.7.2 数值与字符串形式之间的转换..................................................................... 69
11.7.3 字符分类..................................................................................................... 70
11.7.4 包装器类中其他常用的常量和方法.............................................................. 70
第12单元 集合................................................................................................................... 70
12.1 集合概述.............................................................................................................. 70
12.2 集合接口.............................................................................................................. 71
12.2.1 Collection接口............................................................................................ 71
12.2.2 List接口..................................................................................................... 72
12.2.3 Queue和Deque接口.................................................................................... 73
12.2.4 Set接口...................................................................................................... 73
12.3 集合类.................................................................................................................. 73
12.3.1 Arraylist类.................................................................................................. 74
12.3.2 LinkedList类............................................................................................... 74
12.3.3 HashSet....................................................................................................... 74
12.3.4 LinkedHashSet类......................................................................................... 75
12.3.4 TreeSet类................................................................................................... 75
12.4 集合遍历.............................................................................................................. 75
12.4.1 Iterable接口................................................................................................ 75
12.4.2 Iterator接口................................................................................................ 76
12.4.3 ListIterator接口........................................................................................... 76
12.4.1 使用迭代器................................................................................................. 77
12.4.2 增强的for循环........................................................................................... 77
12.5 Comparable和Comparator接口.............................................................................. 77
12.5.1 Comparable接口.......................................................................................... 77
12.5.2 Comparator接口.......................................................................................... 78
12.6 Collections类与集合算法....................................................................................... 78
12.7 遗留的集合类和接口............................................................................................. 78
12.7.1 Vector类..................................................................................................... 78
12.7.2 Hashtable类................................................................................................ 79
第13单元 映射................................................................................................................... 79
13.1 支持映射的接口.................................................................................................... 79
13.2 映射类.................................................................................................................. 79
13.2.1 HashMap..................................................................................................... 80
13.2.2 LinkedHashMap........................................................................................... 80
13.2.3 TreeMap...................................................................................................... 80
13.3 映射的遍历........................................................................................................... 81
第14单元 异常Exception.................................................................................................... 82
14.1 概念..................................................................................................................... 82
14.2 异常处理基本流程................................................................................................ 82
14.3 嵌套的try语句..................................................................................................... 84
14.4 异常类型.............................................................................................................. 85
14.4.1 异常继承体系............................................................................................. 85
14.4.2 异常分类.................................................................................................... 85
14.4.3 常用异常.................................................................................................... 86
14.5 throw.................................................................................................................... 87
14.6 throws................................................................................................................... 87
14.7 异常的传播........................................................................................................... 87
14.8 自定义异常........................................................................................................... 88
第15单元 File-IO流........................................................................................................... 89
15.1 I/O的概念和java.io包.......................................................................................... 89
15.2 File类.................................................................................................................. 89
15.2.1 创建File对象............................................................................................. 89
15.2.2 File类的常用方法....................................................................................... 89
15.3 流......................................................................................................................... 90
15.3.1 流的分类.................................................................................................... 90
15.3.2 IO流结构图................................................................................................ 91
15.3.2 字节流........................................................................................................ 91
15.3.3 字符流........................................................................................................ 93
15.4 缓存流.................................................................................................................. 94
15.4.1 缓存的字节流............................................................................................. 94
15.4.2 缓存的字符流............................................................................................. 94
15.5 序列化与反序列化................................................................................................ 95
15.5.1 Serializable接口.......................................................................................... 95
15.5.2 ObjectOutput和ObjectInput接口.................................................................. 95
15.5.3 ObjectInputStream和ObjectOutputStream类................................................. 95
第16单元 反射&线程&网络编程........................................................................................ 96
16.1 反射..................................................................................................................... 96
16.1.1 反射的概念................................................................................................. 96
16.1.2 类加载与Class对象..................................................................................... 96
16.1.3 获取类的相关信息...................................................................................... 96
16.1.4 使用反射生成并操作对象............................................................................ 97
16.2 线程（Thread）.................................................................................................... 97
16.2.1 线程的概念................................................................................................. 97
16.2.2 创建线程.................................................................................................... 97
16.2.3 线程同步与线程安全................................................................................... 98
16.2.4 线程的状态................................................................................................. 98
16.3 网络编程.............................................................................................................. 99
16.3.1 IP地址与端口号......................................................................................... 99
16.3.2 套接字........................................................................................................ 99
附录 下个阶段学习的内容................................................................................................. 100
第1单元 Java入门
1.1 Java的诞生与发展历史
Java的出生地：SUN Microsystems Inc.
SUN：Stanford UniversityNetwork
Oracle（甲骨文）
Java之父：James Gosling（詹姆斯·高斯林）
1995年发布Java第一版
Java发展历史中的几个重要版本：
l Java 1.2 从该版本开始，把Java分成Java SE、Java ME、Java EE三部分。
l Java 5 2004年9月30日18:00PM，J2SE 1.5发布，成为Java语言发展史上的又一里程碑。为了表示该版本的重要性，J2SE 1.5更名为Java SE 5.0
l Java 6 Java的各种版本更名，以取消其中的数字"2"：J2EE更名为Java EE，J2SE更名为Java SE，J2ME更名为Java ME。
2009年04月20日，甲骨文（Oracle）74亿美元收购Sun。取得java的版权。
1.2 Java技术体系
Java技术分为三个体系：
l Java SE（J2SE）（Platform Standard Edition，java平台标准版）开发桌面应用程序
l Java EE（J2EE）（Java 2 Platform,EnterpriseEdition，java平台企业版）开发面向Internet的应用程序 Java Web
l Java ME（J2ME）（Java 2 Platform MicroEdition，java平台微型版）开发运行于智能设备的程序。
1.3 Java语言的特点
面向对象（OOP）
跨平台（操作系统）
安全健壮
没有指针操作
垃圾自动回收机制
多线程
分布式
1.4 Java程序的运行机制
1.4.1 JVM与跨平台
Java程序不是直接在操作系统之上运行，而是运行于JVM（java虚拟机）之上。
针对不同的操作系统开发相应的JVM，Java程序运行于不同的JVM之上，因此Java程序可以在不同修改的情况下运行于不同的操作系统之上，从而实现了所谓的跨平台。
Java源代码（.java文件）经编译器编译成字节码（.class文件），JVM本质上就是一个负责解释执行Java字节码的程序。
JVM执行Java程序的过程：
l 加载.class文件
l 管理并分配内存
l 执行垃圾收集
1.4.2 JVM、JRE、JDK
JVM：Java虚拟机
JRE：Java运行时环境（JVM+类库） //后面编写代码时在强调类库
JDK：Java开发工具包（JRE+编译工具）
JDK的全称：Java Development kit
提示：
运行Java程序只需要安装JRE，开发Java程序则需要安装JDK。
1.5 java开发环境安装、配置
1.5.1 安装JDK
1.5.2 配置环境变量
1.5.2.1 PATH
目的：在任意路径下能够直接执行相关命令。
原理：在命令行中执行某个命令时，首先在当前路径下查找，如果找不到则到PATH配置的各个路径下查找。
Path作用：指定从哪些地方查找命令
配置细节：
JAVA_HOME：C:\ProgramFiles\Java\jdk1.8.0_102
PATH：%JAVA_HOME%\bin; 或
C:\ProgramFiles\Java\jdk1.8.0_102\bin; //bin =binary(二进制)
环境变量之间使用;分割
1.5.2.2 CLASSPATH
（1）目的：在任意路径下能够找到要运行的.class文件。
（2）CLASSPATH：
.;
C:\ProgramFiles\Java\jdk1.6.0\lib\dt.jar; //lib = library(库)
C:\ProgramFiles\Java\jdk1.6.0\lib\tools.jar;
从其他目录下找class文件
（3）注意：Java1.4之后不需要配置上述CLASSPATH环境变量，默认从上述路径下查找.class文件。
1.6 java开发流程
1.6.1 结构化编程与面向对象编程
结构化编程：函数
面向对象编程：类
java类的基本结构：变量 + 方法
1.6.2 编写和运行Java程序的三个步骤
l 编写源代码，保存到源代码文件中，例如 HelloWorld.java
l 编译源代码，例如javac HelloWorld.java, 生成.class文件（字节码）
l 执行字节码，例如java HelloWorld
案例1.1 HelloWorld
1.6.3 源文件与class文件
在Java中源文件的名称必须是文件中主类的名称，扩展名必须为.java。源文件中可以包含多个类，但是最多只能有一个类使用public修饰，使用public修饰的类就是主类。在Java中，源文件还被作为编译单元，即一个源文件就是一个编译单元。
编译器会为源代码中的每个类生成一个.class文件，.class文件的名称是类的名称，扩展名为.class。
1.6.4 main()方法
方法名：只能是main，不能是Main等形式。
修饰符：public static void 三个缺一不可，多一个不行
参数：
1、参数类型为字符串数组
2、参数名称只要符合Java中标识符命名要求即可
3、参数声明的两种方式：String[] args, 或 String args[]
案例1.2 打印输出
1、打印：个人信息
姓名：xxx
年龄：xx
性别：x
2、打印一首古诗
1.7 常用命令
1.7.1 Dos命令
命 令 |
功 能 |
盘符： |
转换到指定分区 |
cd 目录 |
进入指定的目录 |
dir |
查看当前路径下的目录和文件 |
cd .. |
进入上一级目录，..表示上一级目录 |
cls |
清屏 |
1.7.2 Java命令
javac //后跟文件名称，需要包含扩展名.java
javac -d //指明存放字节码文件（class）文件的位置
java //后跟类名
javadoc //生成注释文档
1.8 课后作业
1、复习理论知识点，组长负责检查
2、技能作业
（1）完成课堂案例HelloWorld
（2）完成课堂案例，打印一首古诗
（3）编写程序，输出个人基本信息，例如：
姓名：张三
年龄：22
性别：男
单位：八维计算机学院
技能作业要求：
使用文本编辑工具编写源代码
使用命令行编译、运行程序，该过程要有录屏
上交录屏和源代码
第2单元 标识符、关键字、数据类型
2.1 注释
注释的三种形式：单行注释、多行注释、文档注释
文档注释(documentation comment)以“/**”开始，以“*/”结束。使用文档注释可以将关于程序的信息嵌入到程序自身中。/* */
javadoc命令可以文档注释中的内容提取出来，将其放入到一个HTML文件中。文档注释方便了程序的文档化。
2.2 分隔符、代码块
每行功能代码以;作为结束符号
空格没有实际意义，可以利用空格无意义，将代码合理缩进，易读
{}包含的代码称之为代码块， 例如类if(){}、方法{}、类{}等等
2.3 标识符
2.3.1 标识符的概念
Java中类、方法和变量的名称，称之为标识符。
2.3.2 标识符的语法要求
（1）以字母、数字、_或$组成
（2）不能以数字开头
（3）不能使用java的关键字和保留字
注意：
1、标识符的长度没有限制
2、Java是大小写敏感的，所有标识符区分大小写 main Main
2.3.2 标识符的命名规范（驼峰）
Java中的标识符通常是由多个英文单词构造，每个单词除了首字母外其他字母小写。
2.3.2.1 大驼峰
第一个单词的首字母大写。以大写字母开头，用于类名、接口名
class Account {…} //类名
class HelloWorld{…} //类名
interface AccountBase {…} //接口名
2.3.2.2 小驼峰
第一个单词的首字母是小写，其他单词的首字母大写。以小写字母或单词开头，用于变量名、方法名
String studentName; //变量名
String getStudentName() {…} //方法名
2.3.2.3 常量命名规范
常量是使用final修饰的存储单元。（最终的）
全部为大写字母表示
final public int DAYS_WEEK= 7; //常量必须在声明时赋初值
final public double PI= 3.1415926;
2.3.3 标识符案例
演示标识符的要求、规范、常量的定义
abc a+b my_city $money class _78
myName _come my&bb 2name public
name#1 age- name3 class5 _$ $a
2.4 Java的关键字
2.4.1 Java中的全部关键字
目前定义了50个关键字
abstract |
continue |
for |
new |
switch |
assert |
default |
goto |
package |
synchronized |
boolean |
do |
if |
private |
this |
break |
double |
implements |
protected |
throw |
byte |
else |
import |
public |
throws |
case |
enum |
instanceof |
return |
transient |
catch |
extends |
int |
short |
try |
char |
final |
interface |
static |
void |
class |
finally |
long |
strictfp |
volatile |
const |
float |
native |
super |
while |
Java保留了const和goto关键字，但是没有使用。Java还保留了下面这些关键字：true、false和null。这些关键字是Java定义的数值。
2.4.2 目前已经接触到的关键字
public static void class
2.5 基本数据类型
2.5.1 数据类型的分类
注意：基本数据类型也可以分成两大类：数值型、布尔型
2.5.2 整型
Java不支持无符号的、只是正值的整数。
2.5.2.1 类型、宽度、范围
名 称 |
宽 度 |
范 围 |
long |
64/8 |
-9 223 372 036 854 775 808至9 223 372 036 854 775 807 |
int |
32/4 |
-2 147 483 648至2 147 483 647 大约21亿 |
short |
16/2 |
-32 768至32 767 |
byte |
8/1 |
-128至127 |
2.5.2.2 字面值
（1）整数字面值默认是int类型
（2）将字面值赋给byte或short变量时，如果字面值位于目标类型的范围之内，就不产生错误。
（3）大写或小写的L明确地标识其类型为long
（4）在字面值可以包含下划线，例如1_000_000_000
（5）十进制、八进制（0）、十六进制（0X/0x）、二进制（0B/0b）
案例2.1 整型案例
2.5.3 浮点型
浮点数，也称为实数(real number)，当计算需要小数精度的表达式时使用。
2.5.3.1 类型、宽度、范围
名称 |
宽度(位) |
大致范围 |
double（双精度） |
64/8 |
4.9e-324～1.8e+308 |
float （单精度） |
32/4 |
1.4e-045～3.4e+038 |
2.5.3.2 浮点数字面值
（1）默认为double类型，为了指定float字面值，需要使用后缀F或f
（2）科学计数法。例如6.022E23、314159E-5、2e+100
案例2.2 浮点型案例
2.5.4 字符型
2.5.4.1 char类型与字符编码
（1）char是16位，Java在内部使用16位的整数表示字符（Unicode编码），char类型的范围0～65535。//全世界基本的语言符号基本都包含了
（2）char也可以用作整数类型，可以将整型字面值赋给char类型的变量，可以在char类型上执行算术运算。
（3）26个小写字母、26个大写字母、以及10个数字0-9，其编码是连续的。
2.5.4.2 char类型字面值
（1）字符型字面值使用单引号中的字符表示，例如’a’。
（2）转义字符
转义序列 |
描 述 |
\ddd |
八进制字符(ddd) |
\uxxxx |
十六进制Unicode字符(xxxx) |
\’ |
单引号 |
\” |
双引号 |
\\ |
反斜杠 |
\r |
回车符 |
\n |
新行符(也称为换行符) |
\f |
换页符 |
\t |
制表符 |
\b |
回格符 |
字符串类型：
字符串类型是String，String是类，所以是引用类型。字符串字面值是使用双引号包围起来的内容。
案例2.3 字符型案例
2.5.5 布尔型
（1）boolean类型表示逻辑值，它只能是true或false
（2）boolean类型的值与整数0和1没有任何关系
案例2.4 boolen类型
2.6 变量与常量
2.6.1 变量的声明与赋值
说明：变量表示存储单元，变量名就是存储单元的名称，变量初始化之后就可以通过变量名访问存储单元。
1、变量声明 int i; String str; //还没有分配存储空间
2、初始化（赋初值） i=10; str=”abc”; //初始化之后就分配了存储空间
3、声明并赋值 int i = 10; String str=”abc”; //声明的同时进行初始化
注意：变量在使用之前必须先初始化（赋初值）。
2.6.2 常量的声明与赋值
声明常量需要使用final关键字，如，final double PI = 3.1415926。
常量通常在声明时赋值，并且赋值之后其值不能改变
常量标识符通常全部为大写。
案例 2.5 常量案例
2.6.3 实例变量与局部变量
根据变量声明的位置，变量可以分为实例变量和局部变量。
2.6.3.1 实例变量及作用范围
在类的{}内直接定义的变量，称为实例变量或成员变量。
作用范围：整个类中都可以使用
实例变量在创建对象时会自动初始化，并有初始值(默认值)
byte/short/int：0
long：0L
float：0.0f
double：0.0
boolean：false
引用类型：null
2.6.3.2 局部变量及作用范围
在方法中或代码块{}中定义的变量，称之为局部变量。
作用范围：直接包含它的{}内有效
局部变量不会自动初始化，没有默认值，使用之前必须要初始化。
案例2.6 变量案例
2.7 类型转换
当将一种类型的变量或字面值赋给另外一种类型的变量时，就会发生类型转换。
Java中类型转换分自动类型转换和强制类型转换。
总结：对于数值类型，如果目标类型的范围包含了原类型的范围，则可以自动转换，否则就需要强制转换。
2.7.1 自动类型转换
类型兼容、小类型转换为大类型
byte-->int short--->int int--->long
long--->float float--->double
String--->Object （子类--->父类）
2.7.2 强制类型转换
大类型转换为小类型
int-->byte int--->short long--->int
float--->long double--->float
Object--->String
案例2.7 类型转换案例
2.8 面向对象初步（了解）
2.8.1 了解类和对象
2.8.2 创建对象
2.9 原始类型和引用类型（了解）
原始类型变量的赋值
int x = 10; int y = x; (将x的值10赋给y， x和y没有任何关联关系，改变值互不影响)
引用类型变量的赋值
Teacher teacher = new Teacher(“John Smith”, 30, 10000);
or
Teacher teacher1, teacher2;
teacher1= new Teacher(“John Smith”, 30, 10000);
teacher2 = teacher1;
teacher2=teacher1;将teacher1的引用的地址值赋给teacher2，这样两个引用指向同一个堆内存地址，所以任何一个修改属性，另一个也变化。
2.10 课后作业
1、熟悉Eclipse的基本使用，创建工程、创建包、创建类、编译和运行
2、分别用八种基本数据类型定义变量，并输出
3、分别定义六种数值类型，两两之间进行赋值，测试类型转换效果。
4、定义一个常量PI=3.14159，并输出
5、实现一个数字加密器，加密规则是：（选作）
加密结果 = （整数*10+5）/ 2 + 3.14159，加密结果仍为一整数
最后输出加密结果
6、熟悉java关键字 （选作）
第3单元 运算符&表达式&选择结构
3.1 运算符
可以将大部分Java运算符划分为四组：算术运算符、位运算符、关系运算符以及逻辑运算符。
3.1.1 赋值运算符
赋值运算符有一个有趣的特性：它允许创建赋值链。例如，分析下面的代码段：
intx, y, z;
x= y = z = 100; // set x, y, and z to 100
3.1.2 算术运算符
算术运算符用于数学表达式，其使用方法与在代数中的使用方法相同。
运算符 |
结 果 |
+ |
加法(也是一元加号) |
- |
减法(也是一元负号) |
* |
乘法 |
/ |
除法 |
% |
求模 |
|
|
+= |
加并赋值 |
-= |
减并赋值 |
*= |
乘并赋值 |
/= |
除并赋值 |
%= |
求模并赋值 |
|
|
++ |
自增 |
-- |
自减 |
需要注意的地方：
（1）当将除法运算符用于整数类型时，其结果不会包含小数部分。
（2）求模运算符%，返回除法操作的余数。它既可以用于浮点数也可以用于整数。可以用于判断一个整数是否是奇数、偶数、是否是某个数的倍数。
案例3.1 基本算数运算符演示
名称：BasicMathDemo
演示算术运算，特别注意是整除，演示除0效果
案例3.2 求模运算符案例1
项目名称：ModulusDemo
演示求模运算符的运算规则和应用：
判断一个数是奇数还是偶数
判断一个数是否是5的倍数…
案例3.3 求模运算符案例2
名称：GetDigital
输入一个三位数，分别获取个、十、百位上的数字。
3.1.2.1 算术与赋值复合运算符
int a = 1;
a += 2; //相当于a = a+2;
（1）对于所有的二元算术运算，都有相应的复合赋值运算符。
（2）复合赋值运算符的效率更高。所以在专业的Java程序中，会经常看到复合赋值运算符。
案例3.4 复合运算符案例：
名称：OpEqualsDemo
演示复合运算符的规则。
3.1.2.2 自增与自减
（1）自增运算符将其操作数加1。自减运算符将其操作数减1。
（2）自增与自减分前缀形式与后缀形式。++、--
前缀形式：
int i = 10;
int a = ++ i; //等同于 i++; int a = i; 所以a=11， i= 11
后缀形式：
intj = 10;
int b = j++; //等同于 int b = j; j++; 所以b=10，j = 11
案例3.5 自增与自减运算符案例
名称：IncDecDemo
重点演示前缀与后缀形式的区别。
3.1.2.3 表达式
（1）表达式的概念：由操作数与运算符组成 j++ a+b
（2）表达式的求值：表达式是有值的，需要注意表达式值的类型
（3）表达式中的类型提升规则：
表达式的类型会自动提升为所有操作数的最大类型。
对于操作数全为非long类型整数的表达式，其类型会自动提升为int。
案例3.6 表达式求值案例
名称：ExpressionDemo
演示类型自动提升
3.1.3 关系运算符
关系运算符也称为比较运算符
运算符 |
结 果 |
== |
等于 |
!= |
不等于 |
> |
大于 |
< |
小于 |
>= |
大于等于 |
<= |
小于等于 |
（1）关系运算的结果为boolean型数值。
（2）关系运算符最常用于if语句和各种循环语句中的控制表达式。
案例3.7 关系运算符应用演示
CompareOperatorDemo
判断一个字符是否是小写字母、大写字母、数字
3.1.4 布尔逻辑运算符
布尔逻辑运算符，只能操作boolean型操作数。
运算符 |
结 果 |
&& |
逻辑与（短路形式） |
|| |
逻辑或（短路形式） |
^ |
逻辑异或 |
! |
逻辑一元非 |
& |
逻辑与 |
| |
逻辑或 |
布尔逻辑运算规则：
操作数 |
逻辑运算及结果 |
||||
A |
B |
A || B |
A && B |
!A |
A ^ B |
false |
false |
false |
false |
true |
false |
true |
false |
true |
false |
false |
true |
false |
true |
true |
false |
true |
true |
true |
true |
true |
true |
false |
false |
运算规则说明：
对于||，只要有一个操作数为true，则结果为true；
对于&&，只要有一个操作数为false，则结果为false。
对于^，两个操作数不同，则结果为true，否则结果为false。
注意：&&和||（短路形式）， &和| （非短路形式）
这两个运算符是所谓短路形式的逻辑运算符。假如单独根据左操作数就能确定表达式的结果，那么就不会计算右操作数的值。
案例3.8 逻辑运算案例
BoolLogicDemo
演示逻辑运算符的运算符规则
示例3.9 短路逻辑案例
演示短路逻辑表达式的求值过程
inta = 5;
intb = 6;
if(（a < b） || （++a == b） )
//通过第一部分就能确定最终结果的话，第二部分就不会执行
{
System.out.println(a);
} //分别使用 | 和 || 测试效果（输出a的值）
3.1.5 位运算符（了解）
位运算符：针对整数的二进制表示形式中的每一位进行运算
3.1.5.1 左移与右移
（1）左移<<：左移动1位，低位补0，相当于乘以2
（2）右移>>：右移1位，高位补符号位，相当于除以2
（3）无符号右移 >>>：高位补0
3.1.5.2 位逻辑运算符
运算符 |
结 果 |
~ |
按位一元取反 |
& |
按位与 |
| |
按位或 |
^ |
按位异或 |
运算规则：
操作数 |
位运算及结果 |
||||
A |
B |
A | B |
A & B |
A ^ B |
～A |
0 |
0 |
0 |
0 |
0 |
1 |
1 |
0 |
1 |
0 |
1 |
0 |
0 |
1 |
1 |
0 |
1 |
1 |
1 |
1 |
1 |
1 |
0 |
0 |
注意：
&和|，如果操作数为boolean类型，则为逻辑运算符，如果操作数为整数则为位运算符。通常将&和|作为位运算符。
&&和||只能作为逻辑运算符，两个操作数只能是boolean类型。
3.1.5.3 位运算符与赋值运算符的结合
例如：a >>= 4; 相当于a = a >> 4;
示例3.10 位运算案例
演示<<、>>以及>>>
演示位逻辑运算
3.1.6 ?:运算符
运算规则
expression1? expression2 : expression3
expression1可以是任何结果为boolean型数值的表达式。如果expression1为true，则对expression2进行求值；否则对expression3进行求值。“？”运算的结果是对其进行求值的表达式。expression2和expression3都需要返回相同(或兼容)的类型，并且不能为void。
示例3.11 条件运算符示例
（1）使用?运算符解决除0问题
ratio= denom == 0 ? 0 : num / denom;
//优美地解决了除0问题
（2）使用？运算符获取绝对值
inti=-10;
intk = i < 0 ? -i : i; //k为i的绝对值
3.2 运算符的优先级
最高 |
|
|
|
|
|
|
++(后缀) |
--(后缀) |
|
|
|
|
|
++(前缀) |
--(前缀) |
~ |
! |
+(一元) |
-(一元) |
(类型匹配) |
* |
/ |
% |
|
|
|
|
+ |
- |
|
|
|
|
|
>> |
>>> |
<< |
|
|
|
|
> |
>= |
< |
<= |
instanceof |
|
|
== |
!= |
|
|
|
|
|
& |
|
|
|
|
|
|
^ |
|
|
|
|
|
|
| |
|
|
|
|
|
|
&& |
|
|
|
|
|
|
|| |
|
|
|
|
|
|
?: |
|
|
|
|
|
|
= |
op= |
|
|
|
|
|
最低 |
|
|
|
|
|
|
大概顺序：算术运算符>移位运算符>关系运算符>逻辑运算符>赋值运算符
圆括号会提升其内部操作数的优先级。为了得到所期望的结果，这通常是必需的。圆括号(不管是否冗余)不会降低程序的性能。所以，为了减少模糊性而添加圆括号，不会对程序造成负面影响。
3.3 流程控制-选择结构
选择结构是通过分支语句实现的，分支语句有两种。
3.3.1 if-else
1、if语句的三种形式
注意：
else不能单独使用，要和if配对使用
if else 都可以后面不跟{}，但是只能控制下面的一行代码
案例：3.12
输入两个数，输出较大的数（if-else）
案例：3.13
使用Scanner获取输入成绩，输出对应的成绩等级(if-else if-else)
3.3.2 多分支语句switch
3.3.2.1 switch语句的结构
switch (expression) {
case value1:
// statement sequence
break;
case value2:
// statement sequence
break;
...
case valueN :
// statement sequence
break;
default:
// default statement sequence
}
3.3.2.2 switch语句需要注意的问题
（1）switch(expression)中expression的结果必须是byte,short,char,int中的一种。 新增：枚举类型、String
注意：long不行
（2）在同一个switch语句中，两个case常量不允许具有相同的值
（3）每个case语句中需要加上break;语句。如果遗漏了break，则会继续进入到下一个case。
（4）可以省略default语句。
（5）default语句通常放在末尾，可以放在开始，中间或者末尾位置。
案例3.14 switch案例
输入1-7之间的数字表示一周的中的第几天，输出对应的星期几。
3.3.3 if-else与Switch的区别
（1）switch语句只能进行相等性测试，这一点与if语句不同，if语句可以对任何类型的布尔表达式进行求值。即，switch只查看表达式的值是否和某个case常量相匹配。
（2）相对于一系列嵌套的if语句，switch语句通常效率更高。
课后作业
1、输入两个数，输出其中较小的数。（**）
2、输入三个数，输出其中最大和最小的数。（***）
3、输入一个字符，如果是小写字母则输出“小写字母”，如果是大写字母则输出“大写字母”，如果是数字，则输出“数字”，否则输出“其他字符”。（***）
4、输入一个三位数，分别输出个、十、百位上的数字。（***）
5、输入两个数和运算符，输出运算结果，运算符可以是+ - * /以及%，使用swtich语句。（***）
6、输入年份，分析判断该年份的属相，例如输入2016，则输出属猴。（***）
子鼠 |
丑牛 |
寅虎 |
卯兔 |
辰龙 |
巳蛇 |
午马 |
未羊 |
申猴 |
酉鸡 |
戌狗 |
亥猪 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
0 |
1 |
2 |
3 |
7、输入年份，输出农历纪年法。例如输入2016，输出丙申年。（****）
天干 地支
甲 |
乙 |
丙 |
丁 |
戊 |
己 |
庚 |
辛 |
壬 |
癸 |
4 |
5 |
6 |
7 |
8 |
9 |
0 |
1 |
2 |
3 |
8、判断是否是闰年。（****）
被400整除是闰年；能被4整除不能被100整除是闰年
9、输入1-12之间的数表示月份，打印输出该月份的天数（**）
第4单元 控制语句
选择语句（分支语句）、迭代语句（循环语句）、跳转语句
4.1 while循环结构
while(condition) {
// body of loop
}
一般在循环体内控制循环的结束条件：让循环条件为false或break
4.2 do while循环结构
do {
// body of loop
} while (condition);
至少执行一次循环。
示例：
分别使用while和do-while循环计算1-100的和
//改进第3单元中判断成绩等级的例子，如果输入的数值为负数，则退出程序
4.3 While和do while的区别
do while先执行 后判断 所以它至少执行一次
while先判断条件 再执行 有可能一次也不执行
所有的循环，都可能出现死循环
4.4 for循环结构
4.4.1 语法
for(initialization; condition; iteration) {
// body
}
四个部分：初始化部分A、循环条件B、循环体D、迭代部分C
A只执行一次。
执行B判断真假，如果真T，执行D，然后再执行C变量变化
演示案例：
使用for循环计算1-100的和
4.4.2 嵌套的for循环
循环是可以嵌套的，包括while和do-while循环
4.4.3 使用两个变量控制循环
案例：输入两个数，查找两个数的中间数
for(inti=0, j=10; i //输出i和j的值 } 练习总结： 学生基本语法可以掌握，稍有逻辑不会，建议多做稍有逻辑练习题 例如： i%2==0 知道是2的整倍数的判断 基本语法没问题 判断一个数字i 能否被2 到（i-1）任意一个整除，就不会了。 break：终止直接包含的循环体，结束（本层）循环 continue：终止本次循环，直接执行循环的下一次 break有两个作用：一是结束本层循环，二是跳出switch语句 案例： 打印0-20之间的偶数，如果大于10则终止循环（break） 打印0-20之间的偶数，如果等于10则终止本次循环（continue） 1、计算1-100的和 (*) //5050 2、计算10的阶乘：1*2*3*4*5*6*7*8*9*10 3、打印0-100之间的偶数，每行打印5个数 (***) 4、打印100-200中3的倍数，每行打印5个数 (***) 5、计算1-100之间能被3整除的数之和。（****） 5、查找水仙花数(asphodel)并打印输出 (****) 三位数 = 个位数字的立方 + 十位数字的立方 + 百位数字的立方 比如：153 = 1 + 125 + 27 6、打印以下图案(***) 7、打印九九乘法表(****) 8、判断一个数是否是质数（素数）。//只能被1和本身整除的数 9、打印输出1-100之间的质数 (*****)素数。 10、模拟登录 （1）定义两个String类型的变量，保存用户名和密码； （2）通过屏幕输入用户名和密码，进行比较，如果正确则通过登录，否则要求重新输入。 （3）共有3次机会，每次登录失败后提醒剩余的次数，如果3次后仍然失败，则退出程序。 （4）如果登录成功，显示欢迎信息 11、打印输出兔子数列（小于100）(*****) 1 1 2 3 5 8 …..，从第三个数开始，当前数为前两个数之和。 具有固定大小，可以容纳相同类型数据的集合。 数组元素的类型：可以是基本类型，也可以是引用类型 数组可以认为是Java中最简单的复合类型。 两种方式：建议采用第一种方式 int[] nums; 或 int nums[]; int[]nums; //声明数组，并没有创建数组，没有开辟堆内存。 nums= new int[5]; //创建数组，必须设置长度 开辟堆内存 new：用于分配内存的特殊运算符。通过new分配的数组，其元素会被自动初始化为0(对于数值类型)、false(对于boolean类型)或null(对于引用类型)。 说明：获得一个数组需要两个步骤，第一步是声明，第二步是创建数组对象。 一个数组就是一个对象。数组是动态创建的，所有对象都是动态创建的。 int[] nums = new int[5]; //初始化为默认值，默认初始化 int[] nums = {1,2,3,4,5}; //初始化为{}中指定的值，静态初始化 int[] nums = new int[] {1,2,3,4,5};//初始化为{}中指定的值 静态初始化 1、创建数组时必须知道数组的长度，否则new不知道要开辟多大的内存 2、第二种方式创建数组，必须在声明数组的同时创建数组 3、创建数组之后，数组的长度不能再改变。 说明： 数组的初始化分为静态初始化和动态初始化，静态初始化在初始化时由程序员显式指定每个数组元素的初始值，由系统决定数组长度。 1、通过下标访问数组元素 为指定的数组元素赋值、使用数组元素。如果数组下标越界，会抛出异常。 2、通过循环处理数组（打印输出所有数组元素） 3、可以使用length属性获取数组的长度，从而可以避免数组越界。 示例5.1 创建数组、静态初始化、遍历输出数组元素 示例5.2 随机数生成 使用Math类的random方法，动态初始化 //查找最大值、最小值、求和 5.5.1 排序（冒泡） 5.5.2 Arrays.sort() 数组元素的类型不仅可以为基本类型，也可以为引用类型。 演示案例： 字符串数组 定义一个Student类，定义一个Student类的数组，使用初始化器创建数组对象，通过循环对数组进行处理。 在Java中，多维数组(multidimensional array)实际上是数组的数组。 下面声明并创建了一个名为twoD的二维数组： int[][]twoD = new int[4][5]; //4行5列 这种说法是错误 本质上，Java中只有一维数组。 twoD,，是一维数组，但是数组的元素也是一个数组 int[] 表示int类型的数组，即数组元素为int类型 int[][] 表示int[]类型的数组，即数组元素为int[]类型 当为多维数组分配内存时，可以只为第一(最左边的)维指定内存，之后再单独为余下的维分配内存，第二维的长度可以不同。 int[][] twoD = new int[4][]; //twoD中有4个元素，每个元素为一个int[]数组 twoD[0] = new int[2]; twoD[1] = new int[4]; twoD[2] = new int[3]; twoD[3] = newint[5]; twoD[0] = ?? //一个内存地址 twoD[0][0] = 0 对于这种情况，第一维的长度必须指定。 int[][] twoD= newint[][]; //错误 int[][] a = new int[3][]; a[0] = new int[]{1,2,3}; a[1] = new int[]{4,-5,6,9,0,8}; //a[1][2] a[2] = new int[]{7,8}; int[][] nums = {{1,2,3}, {2,3}, {,4,5,6}}; 1 2 3 2 3 4 5 6 下面这行代码 int[][] s =new int[10][10]; //String[][]strss = new String[10][10]; A s 是一个10行10列的数组。 B s 是一包含10个一维数组的二维数组。 C s中每个元素都为0; //null。 D 该行代码非法。 库隐藏部分== 特别注意： 二维数组，创建数组是，[][] 第一个必须指明长度 声明的有效方式： int[][ ] ia1 = new int[2][3]; int[][ ] ia2 = new int[2][]; ia2[0] = new int[2], ia2[1] = new int[3]; Teacher[][] ta; ta = new Teacher[2][]; ta[0] = new Teacher[3]; ta[1] = new Teacher[4]; 无效的声明方式 int[][ ] ia1 = new int[][3]; Teacher[][] ta = new Teacher[][5]; 数组操作的工具类 使用Arrays类对数组进行排序，查找元素 Arrays.sort(XXX); 1、创建一个数组，存储12个月份的天数，演示数组的声明、创建、初始化 2、查找数组中的最大值、最小值 3、计算数组所有元素的和及平均值：随机生成10个整数，求和，打印输出 4、在数组中查找元素（先打印输出所有元素，输入一个数，如果找到了则打印输出其位置，没有找到则提示没有找到）。 5、统计一个字符数组中大写字母、小写字母、数字的个数，并输出。 6、通过屏幕输入5个学生的成绩，排序后输出。（循环、排序、遍历） 7、使用数组保存5个学生的姓名，并打印输出。 //字符串数组 8、通过屏幕输入5个学生的姓名(用拼音)，使用Arrays.sort()方法对数组进行排序，然后输出，并分析程序执行效果。 面向对象编程：OOP（Object-OrientedProgramming）。 一切皆对象！比如学生对象、空调对象等等。 对于面向对象编程，主要工作就是编写类。面向对象开发的步骤： l 开发类，类 = 属性（成员变量） + 方法 l 通过new关键字和类创建对象 l 使用类中的属性和方法：对象.属性名 对象.方法名() （1）类是一种逻辑结构，对具有公共属性特征和行为（功能）的一个群体进行描述。例如可以定义Student类描述学生的公共属性和行为，定义一个Teacher类，描述老师的公共属性和行为。 （2）定义了类之后，就可以根据类创建(new)出一个实例。比如学生张三，老师王老师。 通俗地说： 类定义了一种新的数据类型(复合类型)。对象就是根据类定义的变量。可以将类看做是复合类型。 类是对象的模板(template)，对象是类的实例(instance)。因为对象是类的实例，所以经常会看到交换使用“对象”和“实例”这两个词。 教学需要注意的问题： 开始时不要讲理论，提示一下后就直接编写类，声明并创建对象。然后结合具体的程序，介绍上面的概念。 //程序 = 数据 + 算法 类 = 属性 + 方法 class 类名 { //类名通常以大写字母开始 类型 变量1; 类型 变量2; … 类型 方法名(参数列表) { // 方法体 } … } 在类中定义的变量和方法都称为类的成员。所以变量又称为成员变量，方法又称为成员方法。 类的成员变量又称为类的属性。 public class Student { /** * 属性成员变量 * 类的{}内直接声明(定义)的变量 叫 成员变量/实例变量 */ String name; int age; double score; } 属性属于类的某个具体对象。类的每个实例(即，类的每个对象)都包含这些变量的副本，因此在类中定义的变量又被称为实例变量。 方法是对象行为特征的抽象，类具有的共性的功能操作，称之为方法。方法是个“黑匣子”，完成某个特定的应用程序功能。 方法的基本语法： 修饰符 返回类型 方法名（形参列表）{ //功能代码 } 形参可以为空，可以有多个，形参的类型可以是基本类型也可以是引用类型。 public class Student { String name; int age; double score; void study(){ // } void show(){ // } } 注意： 方法中定义变量称为局部变量。 如果没有返回值，则方法的返回类型必须为void 当方法有具体的返回类型时，则必须使用return语句返回一种值。 Student stu1; //声明对象的引用 sut1 = new Student(); //创建对象 public static void main(String[] args) { Student stu1 = new Student(); stu1.name = "张三"; //访问对象的属性 stu1.age = 20; stu1.score=95.5; stu1.show(); //方法调用 Student stu2 = new Student(); stu2.name = "李四"; //访问对象的属性 stu2.age = 22; stu2.score=98; stu2.show(); //方法调用 Student stu3 = stu2; sut2.show(); } 提示：如何使用对象的成员变量和方法 注意： 属性属于类的具体对象，不同对象的属性值通常是不同的。 虽然方法也是通过对象调用的，但是各对象共享相同的方法。 教学需要注意的问题： 带着学生多定义几个简单的类，让学生自己也多定义几个类。 逐步增加类的复杂程度 //Boxb1 = new Box(); //创建对象，让b1指向(引用)所创建的对象 Boxb2 = b1; 注意：b1和b2引用同一个对象。 对象b1：本质是指b1指向的对象 对象引用与对象的关系： （1）对象引用，有时也称为对象引用变量，或称为引用变量。 （2）对象引用与对象在物理上是两个不同的东西。 （3）对于上图，我们通常说b1引用（有时也称为指向）图中的那个Box对象。 （4）对象只能通过对象引用来操作。有时直接使用对象引用代指对象，例如对于上面的例子，有时会直接将b1引用的对象称为“对象b1”或“”b1对象。 （5）将一个对象引用赋值给另一个对象引用，则两个引用变量指向同一个对象。 （6）对引用变量进行相等性比较，例如b1==b2，是比较两个引用变量是否引用同一个对象，所以b1==b2的结果为true。对对象引用进行相等性比较，有时也直接称为对象的相等性比较。 注意：基本变量与引用变量的区别 基本类型的变量位于栈内存中，引用变量所所引用的对象位于堆内存中。 构造方法也叫做构造器 构造方法的作用：开辟内存空间、创建实例、初始化属性值。 构造方法的特点： （1）方法名与类名相同 （大写敏感） （2）不能声明返回类型 //没有返回类型(也算对，但是不严谨) （3）不能使用return语句返回内容/不能有返回值 （4）通常为public 注意： （1）如果没有明确提供构造方法，则系统会提供一个默认的构造方法，默认构造方法（也称为缺省构造方法）没有参数。 （2）如果我们提供了一个构造方法，则系统不再提供无参数的默认构造方法。 （3）如果我们提供了一个有参数的构造方法，同时又需要无参构造方法的话，则必须同时提供一个无参数的构造方法。 new运算符实际是就是调用构造方法，创建一个新对象。当进入到构造方法内部时，实际上对象已经创建完毕，可以在构造方法中为各成员变量赋值。 在类的内部，可以在任何方法中使用this引用当前对象。 使用this关键字解决在实例变量和局部变量之间可能发生的任何名称冲突。 局部变量，包括方法的形参，可以和类的实例变量重名。当局部变量和实例变量具有相同的名称时，局部变量隐藏了实例变量。 方法可以看做是独立的功能模块，供调用模块调用，功能模块要有输入、输出，对于方法而言输入就是方法的参数，输出就是方法的返回值。调用者通过参数将需要输入的数据传递给方法，方法通过返回值将输出返回给调用者。 1、方法定义包括：访问修饰符、返回类型、方法名、形参 2、方法必须有返回类型（构造方法除外），可以省略访问修饰符 3、可以有参数，也可以没有参数 1、实参与形参的概念 2、方法调用的执行过程 方法调用中发生的数据传送是单向的。即只能把实参的值传送给形参，而不能把形参的值反向地传送给实参。因此在函数调用过程中，形参的值发生改变，而实参中的值不会变化。 两种参数传递方式： 值传递：参数类型为基本类型，参数传递时是将实参的值赋给形参，实参和形参是不同的变量。 引用传递：引用类型（对象）作为参数，参数传递时，实参和形参指向同一个对象。所以在方法中修改形参指向的对象会影响到实参所指向的对象（本来就是同一对象）。 （1）return语句用于明确地从一个方法返回。即，return语句导致程序的执行控制转移回到方法的调用者。 （2）如果return之后还有代码，也不会执行。 （3）如果方法的返回类型为void，可以使用return跳出方法，但是不能使用return返回数据。 （4）方法的返回值可以是对象。 public static int test(int a){ if(a>10){ return 1; } if(a>20){ return 2; } else{ return 3; } } 因为封装，不能直接访问其他对象的成员变量，通常是调用其他对象的方法。方法调用有两种情况： 调用相同类中的方法：可以直接调用。（本质上是使用this关键字调用） 调用其他类中的方法：对象.方法名 Teacher类 定义Teacher，属性：姓名，年龄，工资 方法：Teach()； Show(); Box类 属性：长、宽、高 方法：计算体积 Dog类： 属性：name color age 方法：eat() //狗吃肉 show();//显示当前对象的每个属性 Cat类： 属性：name color age 方法：eat() //猫吃鱼 Triangle类：底、高、计算面积 Reatangle类：长length、宽width，计算面积area Circle类：半径，计算面积 银行卡类Card：卡号、姓名、密码、金额。取钱、存钱 封装是面向对象的三大特征之一。 面向对象的三大特征是：封装、继承、多态。 类 = 属性 + 方法，类是对属性和方法的封装。类封装了类的成员。 结合Student类，介绍后续内容： 如果在类的外部可以随意访问类的成员，那将属性和方法放到类中就没有意义了。因此Java允许在类中通过访问修饰符控制类成员的访问权限。之前已经接触过public访问修饰符。 在完整学习访问控制之前，先熟悉一下包的概念。 （1）包的概念 类通常位于某个包中，包(packages)是多个类的容器。它们用于保持类的名称空间相互隔离。因此包是一种名称机制。 例如，Java类库中的类，分别包含在不同的包中：java.lang；java.util。例如String类位于java.util包中。 （2）定义包 package pack1 （3）层次化的包 package www.bawie.cloud （4）包与目录结构 位于包中的类，在文件系统中也必须有与包名层次相同的目录结构。 需要指出的是，包名与文件目录结构一致是针对.class文件而言的，对于源代码文件没有这一要求，但是通常也将源代码文件放到与包名一致的目录结构中。并且建议将源文件与类文件分开存放。 class文件的存储位置与包名必须一致：因为执行class文件时，只指定类的全名，然后根据类的全名去查找class文件。 （5）导入包 类的全名为：包名.类名。例如在www.bawie包中定义的Student类，其全面为www.bawie.Student。 当在不同的包中使用某个类时，需要使用类的全名，如果包名很长的话，使用类的全名不是很方便，这时可以通过导入包来避免使用类的全名。 导入包的目的：减少输入 导入包的两种方式 import java.util.Scanner； import java.util.*; 包既是一种命名机制，也是一种可见性控制机制。可以在包中定义该包外部的代码不能访问的类成员。 类是对类成员（属性和方法）的封装，可以通过不同的访问修饰符控制类成员的可见范围，即控制类的成员在多大的范围是可见的。 类成员的访问范围划分为四个：本类、本包、子类、全局（所有包） 为类的成员指定不同的修饰符，就是控制成员的在什么样的范围内是可见的，即在什么样的范围是能够访问的。 private 默认 protected public 同一个类中 是 是 是 是 相同包中的其他类 否 是 是 是 子类(不同包) 否 否 是 是 全局（所有包） 否 否 否 是 访问范围： 本类 < 本包 < 子类(不同包) < 全局（所有包） 访问修饰符：private < 缺省（default） < protected < public 封装的通常做法： （1）将类的属性的访问权限设置为private，提供访问权限为public的set和get方法。在有些情况下不提供set和get方法，有时只提供其中的一个。 （2）提供合理的构造方法，即开发相应参数的构造方法，方便实例化对象。 （3）类的全部或部分方法的访问权限为public，类的公有方法是类对外开放的接口，供外部代码使用类的功能。类的私有方法通常是辅助方法实现部分功能，供类的公有方法调用。 封装案例： 在pack1包中定义Student类 在pack1包中定义StudentTest类，使用Student类，访问该类中的成员变量和方法。 将StudentTest类的定义放入到pack2包中，再次访问类中的成员变量和方法。 封装案例：堆栈类 让学生体会封装的原理。 直接切入主题： 在类中可以定义名称相同的方法：只要形参列表不同即可。 特点： 1、方法名相同 2、形参列表不同：形参的类型、形参的个数 说明： 方法名+形参列表，共同构成了方法的唯一标识。（方法原型/方法签名） 注意的地方： 1、返回值在区分重载方法时不起作用。修饰符也不起作用 2、当调用重载方法时，Java使用实参的类型和/或数量确定实际调用哪个版本。 方法重载案例： Calculator类，添加add()方法，计算两个数的和。 两个参数的类型分别为：int、float、double Box（double length, doublewidth, double height） Box（double dim） Box（Box box） Box（） 特别说明： 在某个构造方法中可以使用this()调用重载的构造方法： public Box（double dim）{ this(dim, dim, dim) } 在正常情况下，只有通过组合类的对象才能访问该类的成员。有时可能希望定义能够独立于类的所有对象进行使用的成员。为了创建这种成员，需要在成员声明的前面使用关键字static。例如Math类中的方法，就是静态方法。 方法和变量都可以声明为静态的。main()方法是最常见的静态成员的例子。main()方法被声明为静态的，因为需要在创建所有对象之前调用该方法。 案例：（演示静态变量的访问方式、不同实例共享相同的值） Math中的成员变量PI就是静态变量。 public class StaticM{ //实例变量 private int i; //静态变量 static int si; public static showStatic(){}; } 特别注意： （1）被声明为静态的变量本质上是全局变量，类的所有实例共享相同的静态变量。因此，通过一个对象修改静态变量的值后，通过该类的其他对象访问到的静态变量是修改后的值。 （2）访问静态变量的方式： 类名.变量名（推荐） 对象.变量名（不推荐） （3）初始化时机 静态变量：当类被虚拟机加载，静态变量就初始化，既不需要创建类的对象就可以使用静态变量。 实例变量：创建类的对象时初始化 静态代码块,只执行一次,而且是类加载时就执行 作用：一般完成静态变量初始化赋值或完成整个系统只执行一次的任务 静态方法也是独立于类的对象而存在，可以直接通过类名访问静态方法。 最典型的静态方法是main()方法； 静态的方法有几个限制： l 它们只能直接调用其他静态方法。 l 它们只能直接访问静态数据 l 它们不能以任何方式引用this或super关键字。（super是与继承相关的关键字，将在下一章介绍。） 案例： 改写前面的Calculator类，使用静态方法实现两个数量相加的功能。 main方法、math类中提供的许多方法都是静态方法 1、static的本质作用是区分成员属于类还是属于实例（对象）。 2、通常把使用static修饰的变量和方法称为类变量和类方法，有时也称为静态变量和静态方法，把不使用static修饰的变量和方法称为实例变量和实例方法。 3、对于使用static修饰的成员，既可以通过类来调用也可以通过类的实例调用，但是建议使用类调用静态成员。对于实例变量和实例方法，则只能通过类的实例调用。 作业： 1、定义Student类：属性全部为私有的，show()方法、sutdy()方法，为公有的。 进行合理的封装：添加有参构造方法，为每个属性添加get和set方法。 定义测试类，测试Student类。 2、定义Box类，属性私有化，进行合理的封装。添加重载的构造方法。 定义测试类，测试Box类。 3、定义Rectangle、Triangle、Circle类，属性私有化，进行合理的封装。添加公有的area()方法，计算图形的面积。 定义测试类，测试Rectangle、Triangle、Circle类。 4、定义Dog、Cat类，属性私有化，进行合理的封装。添加公有的eat()方法。 定义测试类Zoo，分别创建Dog、Cat类的对象，并调用eat()方法。 5、为课堂案例Calculator类添加计算两个数的乘积、差的重载方法，分别计算两个int、float、double类型数的乘积和差。 6、修改Student、Box、Rectangle、Triangle、Circle类，为这些类添加有参构造方法和无参构造方法。（重载的构造方法）。 继承是面向对象的基本特征之一。 使用继承可以为一系列相关对象定义共同特征的一般类，然后其他类(更特殊的类)可以继承这个一般类，每个进行继承的类都可以添加其特有的内容。 被继承的类称为超类（super class）/父类，继承的类称为派生类/子类（subclass）。 一旦创建了一个定义一系列对象共同特征的超类，就可以使用该超类创建任意数量的更特殊的子类。 继承使用关键字extends（扩展）实现。 publicclass A extendsSuperA{ } 子类可以从父类继承属性和部分方法，自己再增加新的属性和方法。通过继承可以重用父类的方法和属性，减少代码重复编写，便于维护、代码扩展。 继承案例： 案例1 父类：Person：name age sex sleep() 子类：Student：grade score study() 子类：Teacher：college course teach() 案例2： 父类：Animal：name color age eat(); “动物吃东西！” 子类：Dog：layal（忠诚度） watch(); “忠诚地看家护院” 子类：Cat：wakan（灵力值） catchMouse(); “聪明地捉老鼠” 案例3： 父类：Box：length width height volume() 子类：WeightBox：weight 子类：ColorBox：color （1）子类不能从父类继承构造方法。 属性的继承：理论上子类会继承父类的全部成员变量（属性），但是子类不能访问父类的私有成员变量，如果子类与父类在不同包中，子类也不能访问父类中具有默认访问权限的成员变量。 方法的继承：根据访问权限，在子类中能够访问的那些方法都可以继承。 l 父类中访问权限为public和protected的方法，子类可以继承。 l 父类中访问权限为private的方法，不能继承 l 父类中访问权限为默认的方法，如果子类和父类同包，可以继承，不同包不能继承。 （2）java类继承只允许单继承（只能有一个超类）；java中接口允许多继承。 （3）子类中可以定义与父类中同名的成员变量，这时子类的成员变量会隐藏/覆盖父类中的同名成员变量。 （4）子类中也可以定义与父类中同名的成员方法，这时子类中的方法重写了父类中的同名方法。 （1）构造方法的调用顺序 在类继承层次中按照继承的顺序从超类到子类调用构造方法。 （2）在子类的构造方法中，一定会首先调用父类的构造方法。super(); （3）子类的每个构造方法都会隐式的调用父类的无参数构造方法，如果想调用父类的其他构造方法，必须使用super(参数列表)来显式调用。 说明：编写类时，通常需要提供无参数构造方法。 （4）如果父类没有无参的构造方法，或者想调用父类的有参构造方法，则在子类的构造方法中必须显式使用super(xxx)调用父类有参构造方法。这时super(xxx)必须是子类中的第一条语句。 （5）通常的做法： 在父类中定义有参数的构造方法，负责初始化父类的成员变量。 在子类的构造方法中，先调用父类的构造方法完成从父类继承来的那些成员变量，然后初始化子类中特有的成员变量。 通常为每个类添加无参的构造方法。 注意： 如果父类中定义了一个有参数的构造方法，系统就不会再为父类提供默认的构造方法。这时，在子类的构造方法中，必须使用super(xxx)显示调用父类的有参构造方法。 public Person( ){ } public Student( ) extends Person{ } public BawieStudent( ) extends Student{ } 多级继承案例 //Student类的子类BawieStudent，增加kpi属性 //Dog类的子类PetDog，增加主人属性 Animal ani = null; //声明超类的变量 Dogdog = new Dog(); //创建子类对象 ani= dog; //将子类对象赋给父类的引用 ani= new Dog(); //创建一个新的子类对象，赋给父类引用变量 可以将子类的对象赋给父类的引用变量，但是这时使用父类的引用变量只能访问父类中定义的那些成员变量。换句话说，可以访问哪些成员是由引用变量的类型决定的，而不是由所引用的对象类型决定的。 Animal a = new Dog(); //小转大 可以自动进行 a.getLayal(); //语法错误，这时通过a只能使用父类中定义的成员变量。编译时就确定 a.eat(); // Animal a = new Dog()； d = (Dog)a; //正确 大转小， 需要强制转换 Dog d = new Animal(); //错误 Dog d = (Dog)new Animal(); //语法没错，可以编译，但运行时会抛出异常 Cat c = new Cat(); d = (Dog)c; //不正确 子类对象 赋给 父类引用 可以，自动转换 父类引用 赋给 子类引用 需要强转，前提：父类引用确实指向了正确的子类对象 当子类从父类中继承来的方法不能满足需要时，子类可以重写该方法，重写方法要求方法名与参数列表都相同。 案例： 重写Student、Teacher类中的sleep()、show() 重写Dog、Cat类中的eat()、show() 重写WeightBox、ColorBox类中的Show() Son类重写Father类中的gain()方法 当在子类中定义的成员变量与父类中的变量具有相同名称时，子类中定义的变量会隐藏父类中定义的变量。 class Father{ double money = 100_000; public void showMoney(){ System.out.println(money); } } class Son extendsFather{ double money = 10_000; public void showMoney(){ System.out.println(super.money); System.out.println(money); } } 关键字super用于调用/访问从父类中继承来的实例变量和方法。 super有两种一般用法。第一种用于调用超类的构造方法。第二种用于访问超类中被子类的某个成员隐藏的成员。 l 在子类中使用super()调用父类的构造方法，必须是第一条语句 l 在本类中可以使用this()调用重载的构造方法，也必须是第一条语句 l 在子类的构造方法中this()和super()不能同时使用 父类的属性被子类继承，如果子类又添加了名称相同的属性，则子类有两个相同名称的属性，如果父类型对象调用属性，就是父类的，如果是子类型对象调用就是子类的属性。 当子类需要引用它的直接超类时，就可以使用关键字super。 所有其他类都是Object的子类。也就是说，Object是所有其他类的超类。这意味着Object类型的引用变量可以引用任何其他类的对象。此外，因为数组也是作为类实现的，所以Object类型的变量也可以引用任何数组。 Object类定义了下面列出的方法，这意味着所有对象都可以使用这些方法。 方 法 用 途 Object clone() 创建一个和将要复制的对象完全相同的新对象。 boolean equals(Object object) 确定一个对象是否和另外一个对象相等 void finalize() 在回收不再使用的对象前调用 Class getClass() 在运行时获取对象的类 int hashCode() 返回与调用对象相关联的散列值 void notify() 恢复执行在调用对象上等待的某个线程 void notifyAll() 恢复执行在调用对象上等待的所有线程 String toString() 返回一个描述对象的字符串 void wait() void wait(long milliseconds) void wait (ling milliseconds, int nanoseconds) 等待另一个线程的执行 Object类中的equals()方法实现等价于“==”运算符 含义：两个对象是否是同一个对象 如果希望使用不同的规则，就需要重写equals()方法。 例如：String类对equals()方法进行了重写，重写后的equals方法比较两个字符串的内容是否相同。 Strings1 = new String( “abc”); Strings2 = new String(“abc”); 对于引用类型都比较： if(s1== s2) //比较是s1与s2是否指向同一个对象 s1.equals(s2); 因为不同的类可以重写equals方法，所以euqals方法比较的行为可能不同 equals方法最初是Object类中定义，在该类中的默认实现等价于“==” String类对equals进行了重写，比较两个字符串中内容是否一致 l equals(Object obj)方法 Object类的实现是 等价于 == 比较对象相等：两个引用是否指向同一个对象。 案例：重写Box类的equals()方法 l toString()方法 直接打印对象时，默认调用对象的toString()方法 Object类的toString方法输出格式： getClass().getName()+ '@' + Integer.toHexString(hashCode()) 自己的类要重写toString() 案例：重写Box类的toString()方法。 l protected Object clone() 克隆对象的方法 被克隆的对象的类必须实现Cloneable接口 l finalize()方法 //终结方法 当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。 l HashCode()方法 返回该对象的哈希码值 当我们重写equals()方法，判断两个对象相等时，最好也同时重写hascode()方法，让相同对象的哈希码值也相同 l 如果final修饰变量，变量就是常量，常量不可修改，定义时必须初始化 l 如果final修饰方法，方法就不能被子类重写 l 如果final修饰类，类就不能再被扩展，不能再有子类。Java类库中的String、Math就是final类。 如果常量是基本数据类型，不可以再修改。 如果常量是引用类型，不能再将其他对象赋给该引用，但可以使用该引用改变对象内部的属性。 例如 final Student s = new Student(“zhangsan”,20); s= new Student(“李四”,20); //错误 s.setName(“李四”); //可以 正确 矩形类、圆形、三角形：父类-形状 同一个方法名称，执行不同的操作。方法重载就是一种多态的一种形式。 当子类从父类中继承来的方法不能满足需要时，子类可以重写该方法，重写方法要求方法名与参数列表都相同。 因此如果子类中的方法与父类中的方法同名、并且参数类型也相同，那么子类中的方法就重写了父类中的同名方法。 为什么不直接定义另外一个方法？因为重写方法可以实现运行时多态的效果。 注意：重写只针对方法，属性没有重写概念 两同：方法名相同、参数列表相同 两小：返回值类型更小（子类）或相等、抛出的异常类更小或相等 一大：访问权限更大或相等 案例复习： Student、Teacher重写Person中的sleep()、show()方法 Dog、Cat重写Animal中的eat()、show()方法 WeightBox、ColorBox重写Box中的show()方法 重写Shape类中的area()方法 重写fruit类中的show()方法 Son类重写Father类中earn()方法 只有当两个方法的名称和类型签名都相同时才会发生重写。如果只是方法名相同，参数类型不同，那么这两个方法就只是简单的重载关系。 当通过父类引用调用重写方法时，在运行时会调用子类中的重写版本。 动态方法调用要以方法重写为前提。 Animal a; a= new Dog(); a.eat(); //动态方法调度：在运行时根据超类引用指向的对象确定调用哪个方法 运行时多态的实现机理：动态方法调度 总结：方法重写是前提、动态调度是手段、多态是最终的目的 运行时多态的优点：灵活 Animal a; a= new Dog(); a.eat(); a= new Cat(); a.eat(); //运行时多态：方法名相同，得到的结果不同 运行时多态的两个要素： （1）在子类中重写超类中的方法 （2）使用超类引用调用重写方法。 在自己的类中定义的toString()方法就是重写方法。 注意不要混淆： 使用超类引用调用成员变量时，调用的是超类的成员变量。 运行时多态：动态方法调度实现 编译时多态：重载方法，编译时通过方法匹配实现的 实例1：Animal、Dog、Cat类的eat()方法、show()方法 实例2：Shape、Rectangle、Circle、Triangle类的area()、draw()方法 实例3：Person、Student、Teacher、Worker类的show()方法、eat、sleep 实例4：Fruit、Apple、Banana的Show()方法 案例1：Feeder类，喂养Dog、Cat 定义饲养员类Feeder 定义类的属性和方法 定义子类Dog和Cat 把Dog和Cat对象作为feed方法的参数 案例2：Manager类，管理Student、Teacher、Worker 案例3：Salesman类，卖水果 案例4：Engineer类，使用Shape类 当编写一个类时，常常会为该类定义一些方法，这些方法用以描述该类的行为，那些这些方法都有具体的方法体。但在某些情况下，某个父类只知道其子类应该包含哪些方法，但无法准确地知道这些子类如何实现这些方法。例如Shape类的area()方法，因为Shape类的不同子类对面积的计算方法不同，即Shape类无法准确地知道其子类计算面积的方法，因此area()方法只能留给子类实现。 在某些情况下会希望定义这样一种超类，在该超类中定义了一些子类应该包含的方法，但是在超类中不能给出这些方法的有意义的实现。例如，Animal类的eat()方法、Shape类的area()方法，无法给出有实际意义的实现，对于这类方法可以声明为抽象方法。 问题： 既然父类中不能给出抽象方法的实现，为什么还要在父类中添加这些方法呢？ 抽象方法是使用abstract修饰的方法。将一个方法声明为抽象方法，从而要求子类必须重写该方法。 注意： l 抽象方法没有方法实现，即没有方法体{}，只有定义。 l 类中如果有抽象方法，该类必须是抽象类，必须使用abstract l 对于抽象方法，abstract不能与private、static同时使用。为父类添加抽象方法，然后让子类实现，一个主要目的就是实现多态的效果，而实现多态效果需要两个前提：一是子类重写父类中的方法，二是使用父类引用调用子类重写后的方法，根据父类实际指向的对象调用相应的重写方法。如果将抽象方法声明为private，则子类中就无法重写该抽象方法；如果方法为static方法，则该方法属于类，而不属于某个对象，从而也就无法根据实际的指向的对象调用想用的方法。 类定义中使用abstract修饰的类为抽象类。 注意： l 从语法上讲，抽象类中可以没有抽象方法，但是没有实际意义 l 有抽象方法的类必须是抽象类 l 不能创建抽象类的对象，即不能new对象 l 抽象类可以当做一种引用类型来使用，声明引用变量 (通常这么做) l 继承自抽象类的类，需要重写抽象类中的所有抽象方法，否则自身也使用abstract修饰，即也是抽象类。 抽象类的子类，会继承抽象类中的所有抽象方法，子类要么重写所有的抽象方法。如果有一个抽象方法的没有重写的话，子类中也有抽象方法。 说明： 抽象类只定义被其所有子类共享的一般形式，而让每个子类填充其细节。这种类确定了子类必需实现的方法。 注意： 有抽象方法的一定是抽象类。 错误，因为接口中的也有抽象方法，而且接口中的所有方法都是接口方法。 提示： 抽象类与一般类的区别： 从类中可以包含的成员看，一般类中可以包含的成员，抽象类中都可以包含。 接口可以理解为抽象到不能再抽象的类，但是不要将接口和类混为一谈。可以认为类是一套体系，接口是另外一套体系，只不过类可以实现接口。 接口中的方法全部都是抽象方法，不能存在实现的方法。 接口使用interface关键字定义，接口的定义和类很相似。下面是经过简化的接口的一般形式： 访问修饰符 interface 接口名称 { return-type method-name1(parameter-list); //可以省略各种修饰符 return-type method-name2(parameter-list); ... return-type method-nameN(parameter-list); type varname1 = value; //可以省略各种修饰符 type varname2 = value; .. type varnameN = value; } 说明： 声明接口时可以使用abstract修饰符 （1）接口中所有方法默认是公有的抽象方法。 隐式地标识为public、abstract，并且接口中的方法也只允许使用这两个修饰符。 注意，在抽象类中必需使用abstract关键字明确指定方法为抽象方法。 （2）在接口中所有变量默认为公有的静态常量。 被隐式地标识为public、static、final。这意味着实现接口的类不能修改它们。同时还必须初始化它们。 public interface IA1 { //接口中的属性必须public、static、final常量 public static final int I=10; //接口中的属性public、static、final都可以省略 int J = 100; //接口中的方法默认是public、abstract，所以publicabstract可以省略 public abstract void print(); public void print2(); void print3(); } 注意： l 接口能new对象吗？不可以 l 接口能作为一种类型定义引用变量吗？ 可以 A1 a; 一旦定义了一个接口，一个或多个类就可以实现该接口。为了实现接口，在类定义中需要包含implements子句，然后创建接口定义的方法。 class 类名implements 接口名 { // } 注意： （1）实现接口的类，需要实现接口的所有抽象方法，如果只实现了部分抽象方法，该类必须声明为抽象类。 （2）一个类可以实现多个接口，实现的多个接口用“,”隔开 （3）实现接口的类可以同时继承一个超类。 public interface IA1 { //接口中的属性必须是 public static final 常量 public static final int a=10; //接口中的属性 public static final都可以省略 int b = 100; //接口中的方法都是 public abstract 所以public abstract可以省略 public abstract void print(); public void print2(); void print3(); } public interface IA2 { void show(); } /** * 类实现接口 使用implements * 类可以实现多个接口，用 , 隔开 * 一个具体的类，实现接口，必须实现接口的所有抽象方法 *@author Administrator * */ public class SubA implements IA1, IA2{ @Override publicvoid print() { } @Override publicvoid print2() { } @Override publicvoid print3() { } @Override publicvoid show() { } } 说明： 接口定义了一组抽象方法，实现该接口的类需要实现这些抽象方法，从而实现接口的类就具备了接口所规定的行为（功能）。 在Java中，接口可理解为对象间相互通信的协议，相当于模板。 接口可以通过关键字extends继承另一个接口，其语法和类继承相同。如果类实现的接口继承自另外一个接口，则该类必需实现在接口继承链中定义的所有方法。 说明： 一个类可以同时继承一个父类，并实现多个接口 一个接口可以继承多个父接口 补充： 抽象类有构造方法，接口没有构造方法 类只能单继承，接口可以多继承接口 抽象类中可以没有抽象方法，但是有抽象方法的类必须是抽象类。 接口：通常在接口中定义一组方法（抽象方法），实现接口的类通常重写这些方法。接口相当于一种规定（规范）。 int i = 10; String s = “abc”; Studentstu = new Student(“张三”, 18, 95.0); 一方面出于性能方面的考虑，java为数值使用基本类型，而不是对象。基本类型不是对象层次的组成部分，它们不继承Object。 另一方面有时需要创建表示基本类型的对象，例如集合类只处理对象。为了在对象中存储基本类型，需要将基本类型包装到一个类中，为此Java为8种基本数据类型分别提供了对应的包装类。本质上这些类将基本类型包装到一个类中，因此通常将它们称为类型包装器。包装器类位于Java.lang包中。 如何创建对象(构造器)，有哪些功能（方法）可以使用 八个包装类 Byte Short Integer Long Float Double Character Boolean byte short int long float double char boolean inti = 10; IntegeriObj = new Integer(10); 1、构造器 所有数值类型包装器都定义了用于从给定数值或数值的字符串表示形式构造对象的构造函数，例如，下面是为Integer定义的构造器： Integer(int num) Integer(String str) 如果str没有包含有效的数字值，则会抛出NumberFormatException异常。 对于Byte、Short、Integer、Long、Double类都具有两个构造器，其中一个构造器的参数为相应的数值类型、另外一个构造器的参数为字符串。 Float是个例外，有三个构造器，其中一个构造器的参数类型为double。 2、从包装器对象中提取数值 最常用类型的包装器是那些表示数值的包装器。包括Byte、Short、Integer、Long、Float以及Double。所有这些数值类型包装器都继承自抽象类Number。Number声明了以不同数字格式从对象返回数值的方法，如下所示： byte byteValue( ) double doubleValue( ) float floatValue( ) int intValue( ) long longValue( ) short shortValue( ) 3、将包装器对象转换成字符串 类型包装器都重写了toString()方法，该方法可以将数值转换成字符串形式。 //toString()方法的重载形式 String str = Integer.toString(100); 案例：包装器类演示 WrapperDemo 自动装箱是这样一个过程，只要需要基本类型的对象，就自动将基本类型自动封装(装箱)进与之等价的类型包装器中，而不需要明确地构造对象。自动拆箱是当需要时自动抽取(拆箱)已装箱对象数值的过程。不需要调用intValue()或doubleValue()这类方法。 自动装箱和自动拆箱特性极大地简化了一些算法的编码，移除了单调乏味的手动装箱和拆箱数值操作。它们还有助于防止错误。此外，它们对于泛型非常重要，因为泛型只能操作对象。最后，集合框架需要利用自动装箱特性进行工作。 案例：自动装箱与自动拆箱测试 AutoBox FloatfObj = 1.0; //错误 LonglObj = 1; //错误 最常见的编程杂务之一是将数值的字符串表示形式转换成数值。数值类型的包装器类为此提供了相应的方法。例如： l Integer类的parseInt()方法 l Long类的parseLong()方法 l Double类的parseDouble()方法 示例：StringToValue intI = Integer.parseInt(“100”); doubled = Double.parseDouble(“12.3”); 为了将数值转换成字符串形式，可以调用相应包装类的toString()方法。 示例： ValueToString inti = 100; IntegerobjI = i; //自动装箱 Stringstr1 = objI.toString(); //第一种方法 Stringstr2 = Integer.toString(i); //第二种方法 Stringstr3 = String.valueOf(i); //第三种方法 Stringstr4 = i + ""; //第四种方法：投机取巧的方法 Integer.MAX_VALUE Integer.MIN_VALUE Integer.SIZE //长度，多少bit 32位 注意数值包装器的valueOf()方法的功能，例如： Integer.valueOf(100); //根据整数创建Integer对象 Integer.valueOf("100"); //根据字符串创建Integer对象 Character是char类型的包装器。Character的构造函数为： Character(charch) 其中，ch指定了将由即将创建的Character对象包装的字符。 为了获取Character对象中的char数值，可以调用charValue()，如下所示： charcharValue( ) 该方法返回封装的字符。 Character类提供一些静态方法用于判断字符属于哪一类。 static boolean isDigit(char ch) 如果ch是数字，则返回true。 static boolean isLetter(char ch) 如果ch为字母，则返回true。 static boolean isLetterOrDigit(char eh) 如果ch为字母或数字，则返回true。 static boolean isLowerCase(char ch) 如果ch为小写字母，则返回true； static boolean isUpperCase(char ch) 如果ch为大写字母，则返回true。 static boolean isSpaceChar(char ch) 如果ch为空格字符，则返回true。 static boolean isWhitespace(char ch) 如果ch为空白字符，则返回true。 示例：CharacterDemo Boolean是包装boolean值的包装器。它定义了以下构造方法： Boolean(boolean boolValue) Boolean(String boolString) 在第一个版本中，boolValue必须是true或false。在第二个版本中，如果boolString包含字符串“true”(大写或小写形式都可以)，则新的Boolean对象将为真，否则，将为假。 为了从Boolean对象获取boolean值，可以使用booleanValue()，如下所示： boolean booleanValue( ) 该方法返回与调用对象等价的boolean型值。 （1）创建的每个字符串实际上都是String类的对象。即使是字符串字面值实际上也是String对象。 （2）String类型的对象是不可变的；一旦创建了一个String对象，其内容就不能再改变。即，一旦创建了一个String对象，就不能改变该对象包含的内容。 所谓String类型对象中的字符串是不可改变的，是指创建了String实例后不能修改String实例的内容。但是可以修改String引用变量，使其指向其他String对象。 当每次需要已存在字符串的修改版本时，会创建包含修改后内容的新String对象。原始字符串仍然没有改变。使用这种方法的原因是，实现固定的、不能修改的字符串与实现能够修改的字符串相比效率更高。 （3）对于那些需要能够修改的字符串的情况，Java提供了两个选择：StringBuffer和StringBuilder。这两个类都包含在创建之后可以进行修改的字符串。 （4）String、StringBuffer和StringBuilder类都是在java.lang包中定义的。这三个类都实现了CharSequence接口。 注意：API文档的使用 l String(); //创建不包含内容的字符串对象 l String(char[ ] chars) l String(char[ ] chars,int startIndex, int numChars) l String(String strObj) l 还可以直接使用字符串字面创建String对象：String str = “abc”; 示例：StringMakeDemo 注意：没有使用单位字符作为参数的构造器。 //String(charc); 没有 说明： 因为会为字符串字面值创建String对象，所以在能够使用String对象的任何地方都可以使用字符串字面值。 System.out.println("abc".length()); String str1 = “abc”; //一旦创建了字符串对象，其内容不能再改变 String str2 = “def”; String str1 = str1 + str2; String类型的引用，指向的字符串对象是不能修改的。 String表示不可变的字符串，只要创建了字符串对象，那么这个对象的内容就不能再改变。 案例：StringModifyDemo 1．String concat(String str) 将指定字符串连接到此字符串的结尾，concat()与“+”执行相同的功能。 2．String replace(char oldChar, char newChar) 返回一个新的字符串，它是通过用newChar替换此字符串中出现的所有oldChar得到的。 3．String toLowerCase() 使用默认语言环境的规则将此String中的所有字符都转换为小写。 4．String toUpperCase() 使用默认语言环境的规则将此String中的所有字符都转换为大写。 5．String trim( ) 返回字符串的副本，删除前导空白和尾部空白。 String类重写了equals()方法，重写后的方法比较两个字符串对象的内容是否相同。 运算符“==”比较两个String引用是否指向同一个String对象。 示例：StringCompareDemo l boolean equalsIgnoreCase(String str) 将此String与另一个String比较，不考虑大小写。 l boolean endsWith(String suffix) 测试此字符串是否以指定的后缀结束。 l boolean startsWith(String prefix) 测试此字符串是否以指定的前缀开始。 l int compareTo(String str) 按照字典顺序比较两个字符串。 其中，str是将要与调用String对象进行比较的String对象。返回的比较结果及其解释如下所示： 值 含 义 小于0 调用字符串小于str。 大于0 调用字符串大于str。 0 两个字符串相等。 l int compareToIgnoreCase(String str) 按字典顺序比较两个字符串，不考虑大小写。 案例：StringSearchDemo 1．boolean contains(CharSequence s) //CharSequence是String的父类， 当且仅当此字符串包含指定的char值序列时，返回true。 CharSequence 表示字符串序列，是String的父类 2．int indexOf(int ch) 和 int indexOf(String str) 返回指定字符/子串第一次出现处的索引。 3．int lastIndexOf(int ch) 和 int lastIndexOf(String str) 返回指定字符/子串最后一次出现处的索引。 说明： 当没有字符/子串没有出现时，返回值为-1。可以使用该方法判断字符/子串是否存在。 4．可以使用下面这些重载形式指定查找的开始位置： intindexOf(int ch, int startIndex) intlastIndexOf(int ch, int startIndex) intindexOf(String str, int startIndex) intlastIndexOf(String str, int startIndex) 案例：GetCharsDemo 1．char charAt(int index) 返回指定索引处的char值。 2．char[ ] toCharArray() 将此字符串转换为一个新的字符数组。 3．String substring(int beginIndex) //注意方法名 subString 返回一个新的字符串，它是此字符串的一个子字符串。该子字符串始于指定索引处的字符，一直到此字符串末尾。 4．String substring(int beginIndex, int endIndex) 返回一个新字符串，它是此字符串的一个子字符串。该子字符串从指定的beginIndex处开始，一直到索引endIndex-1处的字符。 案例：StringOtherMethDemo 1．int length() 返回此字符串的长度 注意：数组的长度为数组对象.length 属性 2．String[] split(String regex) //分割 根据给定正则表达式的匹配拆分此字符串。最简单的使用方法是为参数regex 3．static String valueOf( int i) //将基本数据类型的值转换成字符串形式 将数据从内部格式转换成人类可读的形式。它是一个静态方法。 对于大部分数组，valueOf()会返回一个相当隐蔽的字符串，表明这是某种类型的数组。然而，对于字符数组，会创建包含字符数组中字符的String对象。 String表示长度固定、不可修改的字符序列。在修改字符串时实际是创建一个新的字符串对象，并在新的字符串对象中放入修改后的内容。因此当需要频繁修改字符串的内容时，效率低下，为此Java提供了StringBuffer类。 StringBuffer表示可增长、可写入的字符序列。StringBuffer允许在中间插入字符和子串，或在末尾追加字符和子串。StringBuffer能够自动增长，从而为这类添加操作准备空间，并且通常预先分配比实际所需更多的字符空间，以允许空间增长。 StringBuffer() //默认预留16个字符的空间 StringBuffer(int size) //size指定预留的字符空间 StringBuffer(String str) //额外预留16个字符的空间 StringBuffer(CharSequence chars) //额外预留16个字符的空间 提示： 再次分配内存空间是很耗时的操作。此外，频繁分配空间会产生内存碎片。 1．append () append()方法将各种其他类型数据的字符串表示形式连接到调用StringBuffer对象的末尾。该方法有多个重载版本，下面是其中的几个： StringBuffer append(String str) StringBuffer append(int num) //基本的数值类型都可以 StringBuffer append(Object obj) 当需要将许多小的字符串连接成一个大的字符串时，使用StringBuffer的append()是合理选择。 2．insert () 在指定位置插入参数提供的内容，返回修改后的该StringBuffer对象引用。该方法有多个重载版本，下面是其中的几个： StringBuffer insert(int index, String str) StringBuffer insert(int index, char ch) StringBuffer insert(int index, Object obj) 3．StringBuffer delete (int start，int end) 删除从start开始到end-1为止的一段字符序列，返回修改后的该StringBuffer对象引用。 4．StringBuffer deleteCharAt(intindex) 移除指定位置的字符，返回修改后的该StringBuffer对象引用。 5．StringBuffer reverse() 将字符序列逆序，返回修改后的该StringBuffer对象引用。 6．StringBuffer setCharAt( (int index，char ch) 将指定索引处的字符设置为 ch，返回修改后的该StringBuffer对象引用。 几点说明 （1）StringBuffer对象不能使用 += 赋值 （2）注意使用StringBuffer的append()方法连接字符串与使用“+”运算符直接连接String对象的区别。 案例：StringBufferDemo publicstatic void main(String[] args){ StringBuffersb = new StringBuffer(); sb+= “I”; sb.append(“like ”); sb.append(“core java ”); sb.append(true); System.out.println(sb); } 长度是指StringBuffer中实际保存的字符的个数，容量是指已经分配的空间大小。 1．int length() 获取StringBuffer对象的当前长度 2．void setLength(int len) 设置StringBuffer对象中字符串的长度。当增加字符串的大小时，会向末尾添加空字符。如果调用setLength()时使用的值小于length()返回的当前值，则超出新长度的字符将丢失。 3．int capacity( ) 获取StringBuffer对象的当前容量 4．void ensureCapacity(int minCapacity) 设置缓存的大小。minCapacity指定了缓存的最小尺寸。(出于效率考虑，可能会分配比minCapacity更大的缓存。) JDK5引入了另外一个类StringBuilder，该类与StringBuffer功能相同。 StringBuffer与StringBuilder的区别： l StringBuffer类是线程安全的，而StringBuilder则不是，即不保证其对象的同步性，在多线程环境中是不安全的。 l StringBuilder在性能上要比StirngBuffer好一些。 Math类包含所有用于几何和三角运算的浮点函数，以及一些用于通用目的的方法，这些方法都是静态方法。Math类定义了两个静态常量：E和PI。 位于java.lang包下。 1．自然对数的底 E(约等于2.72) 2．圆周率PI (约等于3.14) 1．public staticdouble abs(double a) 返回 double 值的绝对值 2．public static double random() 返回一个随机数，大于等于0.0且小于 1.0 2．static double sqrt(double arg) 返回arg的平方根 4．static double pow(doubley, double x) 返回y的x次方。例如，pow(2.0, 3.0)返回8.0 5．public static long round(double a) 返回距离参数a最近的整数，例如a=4.51，则返回5。 //测试：-4.5 -4.51 4.5 4.51 6．public static double ceil(double a) 返回大于或等于a的最小整数，例如a=4.3则返回5。 7．public static double floor(double a) 返回小于或等于a的最大整数，例如a=4.6，则返回4 注意：round()、ceil()、floor()三个方法之间的区别。 案例：MathDemo Random类是伪随机数生成器，提供了比Math.random()方法更强大的随机数生成功能。Random类位于java.util包中。Random类的构造方法如下： Random() //使用相对唯一的种子 Random(longseed) //手动指定种子 常见的做法是使用当前时间（毫秒数）作为种子。 Random类与math.random()方法的区别： Random类提供了多个法，可以生成多种形式的随机数，Math.random()方法只能随机生成[0.0, 1.0）之间的浮点数。 1．public int nextInt() 返回下一个伪随机数 2．public int nextInt(int n) [0,100) 返回一个伪随机数，它是取自此随机数生成器序列的、在 0（包括）和指定值（不包括）之间均匀分布的 int 值 int I = random.nextInt(100); Date类封装了当前日期和时间。位于java.util包。 （1）类构造方法 publicDate() //使用当前日期和时间初始化对象 publicDate(long date) //参数date为自从1970年1月1日子时经历的毫秒数 （2）常用方法 long getTime() 返回从1970年1月1日午夜开始已经流逝毫秒数 void setTime(long time) 将日期和时间设置为time所指定的值，time是是自从1970年1月1日午夜开始已经流逝的毫秒数 String toString() 将调用Date对象转换成字符串并返回结果 （3）Date类示例 importjava.util.Date; public classDateTest { public static void main(String[] args) { Date d = new Date(); System.out.println(d); //System.out.println(d.toLocaleString()); long time1 =d.getTime();//1970-1-1 00:00:00 GMT 到现在的 总毫秒数 System.out.println(time1); long time2 =System.currentTimeMillis(); System.out.println(time2);//1970-1-100:00:00 GMT 到现在的 总毫秒数 Date d2 = new Date(time2); System.out.println(d2); } } Calendar是抽象类，提供了一套方法将毫秒数形式的时间转换成大量有用的组分，例如年、月、日、小时、分和秒。 GregorianCalendar是Calendar的具体实现，它实现了格林尼治日历。Calendar类的getInstance()方法通常会返回一个使用默认地区和时区下的当前时间初始化的GregorianCalendar对象。 示例：CalendarDemo importjava.util.GregorianCalendar; publicclass GregorianCalendarDemo { public static void main(String[] args) { GregorianCalendar g = newGregorianCalendar(); System.out.println("年：" + g.get(Calendar.YEAR)); System.out.println("月：" + g.get(Calendar.MONTH)); System.out.println("日：" + g.get(Calendar.DAY_OF_MONTH)); System.out.println("时：" + g.get(Calendar.HOUR)); System.out.println("分：" + g.get(Calendar.MINUTE)); System.out.println("秒：" + g.get(Calendar.SECOND)); } } 集合框架：Collection、Map 集合类：有两种含义： 第一种：狭义上的含义：就是实现Collection接口的集合类 第二种：广义上的含义：包括实现Collection和Map接口的所有类 （1）集合是存储其他对象的特殊对象。可以将集合当做一个容器 （2）集合的相关接口和类位于java.util包中 （3）集合中的接口和类是一个整体、一个体系，整个体系称为集合框架 学习内容：一系列接口和类的使用 集合与数组的相同点和不同点： 1、数组的长度是固定的，集合的长度可以变化 2、集合中只能保存对象，不能保存基本类型的变量；数组中既可以保存对象也保存基本类型的变量。 如果确实需要集合中保存基本类型的值怎么办？包装类 接口定义了一组抽象方法，实现该接口的类需要实现这些抽象方法，从而实现接口的类就具备了接口所规定的行为（功能）。 集合框架定义了一些接口，它们决定了集合类的本质特性。具体的集合类只是提供了标准接口的不同实现。 接 口 描 述 Collection 允许操作一组对象，它位于集合层次结构的顶部 List 扩展Collection，以处理序列(对象列表) Set 扩展Collection，以处理组，组中的元素必须唯一 Deque 扩展Queue，以处理双端队列 注意： List（列表）：表示有序、元素可以重复的集合。 Set（组、集）：表示无序、元素不能重复的集合。组中的元素必须唯一。 //在List集合中，每个元素都有一个索引（下标） Collection接口是构建集合框架的基础，Collection是泛型接口，其声明如下： interfaceCollection 其中，E指定了集合将存储的对象类型。从而限制了可以存储的对象的类型，这样可以提高程序的健壮性。 提示： l 集合中只能存储对象，不能存基本类型。 l 使用泛型的优点是在编译时可以检查元素的类型，从而更加安全。 Collection接口扩展了Iterable接口。这意味着所有集合都可以使用for-each风格的for循环进行遍历。 方 法 描 述 boolean add(E obj) 将obj添加到调用集合。 boolean addAll(Collection c) 将c中的所有元素添加到调用集合中。 boolean remove(Object obj) 从调用集合中删除obj的一个实例。 boolean removeAll(Collection c) 从调用集合中删除c的所有元素。 void clear() 删除调用集合中的所有元素 boolean contains(Object obj) 如果obj是调用集合的元素，则返回true。 boolean isEmpty() 如果调用集合为空，则返回true。 int size() 返回调用集合中元素的数量 Iterator 返回调用集合的一个迭代器 containAll(Collection c) 提示： 1、Collection接口中没有提供修改元素的方法。 2、Collection接口的父接口是Iterable接口，实现了Iterable接口的类是可以迭代的。 List接口、ArrayList类、LinkedList类、Vector类 List接口扩展了Collection，并且声明了存储一连串元素的集合的行为。在列表中，可以使用从0开始的索引，通过它们的位置插入或访问元素。列表可以包含重复的元素。其声明如下： List接口中：有几个add()方法？2个，重载 interfaceList 方 法 描 述 void add(int index, E obj) 将obj插入到index所指定的位置。 boolean addAll (int index, Collection c) 将c的所有元素插入到index所指定的位置。 E remove(int index) 删除index位置的元素，返回删除的元素 E set(int index, E obj) (修改) 将index所指定位置的元素设置为obj E get(int index) 返回指定索引处存储的对象 int indexOf(Object obj) 返回第一个obj实例的索引。 int lastIndexOf(Object obj) 返回列表中最后一个obj实例的索引 ListIterator 返回一个迭代器，该迭代器从列表的开头开始 List 返回一个子列表。 注意： List接口中操作元素的方法许多都提供了index参数，这是与Collection接口中所提供相关方法的主要区别。 ArrayList实现了List接口。本质上是元素为对象引用的长度可变的数组。 构造方法： l ArrayList( ) //长度取默认值 l ArrayList(int capacity) //指定长度，容量 l ArrayList(Collection c) 案例：List集合演示 LinkedList类实现了List、Deque以及Queue接口。它提供了（双向）链表数据结构。 LinkedList具有两个构造方法： LinkedList() LinkedList(Collection c) ArrayList与LinkedList的区别： 1、ArrayList是基于数组结构的集合，有容量的概念；LinkedList是基于链表结构的集合，没有容量的概念 2、对于随机访问（get和set方法），ArrayList优于LinkedList，因为LinkedList要移动指针。 3、对于新增(插入)和删除操作（add和remove方法），LinkedList比较占优势，因为ArrayList要移动数据。但是如果只是在末尾追加元素，并且没有超出容量限制，则ArrayList的性能更好。 4、LinkedList 还实现了Queue接口,该接口比List提供了更多的方法,包括 offer(),peek(),poll()等。 以前Java提供了特定的类，存储和管理对象组，例如Dictionary、Vector、Stack和Properties。后来在添加集合框架时，对上述几个原始类进行了重新设计，以支持集合接口。这些类称为“遗留类”。 ArrayList等现代集合类都不是同步的，但是所有遗留类都是同步的。 Vector类是“遗留类”之一，与ArrayList类似，也是动态数组、也实现List接口。但有如下区别： l Vector实现同步，线程安全。ArrayList没有实现线程安全。 l Vector性能比ArrayList低。 l Vector和ArrayList在更多元素添加进来时会请求更大的空间。Vector每次请求其大小的双倍空间，而ArrayList每次对size增长50%。 Set接口、HashSet类、LinkedHash类、TreeSet类 Set接口定义了组/集/集合(set)。它扩展了Collection接口，并声明了不允许重复元素的集合的行为。如果为集合添加重复的元素，add()方法会返回false。声明如下： interfaceSet Set接口没有添加自己的方法。 SortedSet接口扩展了Set接口，并且声明了以升序进行排序的集合的行为。 interfaceSortedSet SortedSet定义了一些便于进行集合处理的方法。例如，为了获得集合中的第一个对象，可以调用first()方法。为了得到最后一个元素，可以使用last()方法。 NavigableSet接口扩展了SortedSet接口，并且该接口声明了支持基于最接近匹配原则检索元素的集合行为。 注意： Set相关接口表示的集合没有索引的概念。 HashSet类实现了Set接口。该类在内部使用哈希表存储元素。 哈希表使用称之为散列法(hashing)的机制存储信息。哈希法的优点是add()、contains()、remove()以及size()方法的执行时间保持不变，即使是对于比较大的集合也是如此。 HashSet() //默认容量是16 HashSet(intcapacity) HashSet(intcapacity, float fillRatio) //填充率：0.0-1.0之间，默认0.75 HashSet(Collection c) HashSet中元素不是按有序的顺序存储的，遍历输出HashSet中的元素时，输出的顺序可能不同。 LinkedHashSet类扩展了HashSet类，它没有添加它自己的方法。 LinkedHashSet在内部使用一个链表维护元素添加到集合中的顺序，因此可以按照插入顺序迭代集合。 TreeSet类实现了NavigableSet接口，该类在内部使用树结构存储元素。元素以升序存储，访问和检索相当快。TreeSet适合于存储大量的、需要快速查找到的有序信息。 1、Set中的元素不能重复，List中的元素可以重复。 2、List是有序的，有索引（下标）的概念，Set是无序的，没有索引的概念。 3、对于Set表示的集合，通常是遍历操作，没有get()和set()方法。 注意1： List集合表示有序、元素可重复的集合。 Set集合表示无序、元素不能重复的结合。 注意2： HashSet是无序的，LinkedHashSet和TreeSet是有序的。 LinkedHashSet按照添加元素的顺序遍历 TreeSet按照元素的升序遍历 注意3： TreeSet以升序保存对象，所以TreeSet中保存的对象能够比较大小，即TreeSet保存的对象类型必须实现Comparable接口。 遍历、迭代：逐个获取容器中的元素 实现了Iterable接口的类是可以遍历的。因为Iterable接口是Collection接口的父接口，而所有集合类都实现了Collection接口，从而也都实现了Iterable接口，所以所有集合类都是可以遍历的。 Iterable接口只定义了一个方法： Iterator 既然所有集合都实现了Iterable接口，所以所有集合类都重写了iterator()方法以返回一个迭代器对象。 Iterator接口描述了迭代器的行为，所有迭代器类都必须实现该接口，该接口定义了一下方法： l boolean hasNext() 如果迭代还有更多的元素则返回true l T next() 返回下一个元素（向下走一步） l void remove() 删除迭代器返回的元素 提示： 从Iterator接口定义的方法不难看出Iterator只能从前向后进行遍历。 Iterator接口有一个子接口ListIterator，ListIterator接口即可以从前向后遍历，也可以从后向前遍历集合。只有实现了List接口的集合类才提供了ListIterator迭代器。 List接口提供以下两个方法用于获取列表集合的列表迭代器： ListIterator ListIterator ListIterator接口定义了以下常用方法。 l boolean hasNext() l Boolean hasPrevious() l E next() l int nextIndex() l E previous() l int previousIndex() 通常，为了使用迭代器遍历集合的内容，需要以下步骤： 1．通过调用集合的Iterator()方法，获取指向集合开头的迭代器。 2．建立一个hasNext()调用循环。只要hasNext()返回true，就循环迭代。 3．在循环中，通过调用next()获取每个元素。 对于实现了List接口的集合，还可以调用listIterator()获取迭代器。列表迭代器提供了向前和向后两个方向访问集合的能力，并且允许修改元素。 如果不修改集合的内容，也不以反向获取元素，则使用for-each版的for循环遍历集合通常比使用迭代器更方便。 迭代器与增强的for循环之间的区别： （1）使用迭代器遍历集合时，可以调用Iterator.remove()方法删除集合中元素，使用增强的for循环遍历集合时，不能删除集合中的元素。 （2）可以使用增强的for循环遍历数组，但是数组不支持迭代器。 在迭代过程中删除特定的元素： //第一种（正确）：使用迭代器删除 Iterator while (ite.hasNext()) { int i = ite.next(); if (i > 6) ite.remove(); } // 第二种（错误）：使用增强的for循环 for (Integer iObj : al) { if (iObj > 6) { System.out.println("开始删除"); al.remove(iObj); System.out.println("删除了一个元素"); } } 经常需要对集合中的对象进行排序，为了进行排序需要知道两个对象那个“大”那个“小”。这两个接口就是定义了比较两个对象大小的行为。 结合图书管理系统进行演示。 该接口位于Comparable位于java.lang包下。实现了该接口的类可以比较大小。该接口只定义了一个方法： intcompareTo(T o) 实现了该接口的类必须实现该方法，定义该类对象之间大小比较的规则。该方法比较调用对象与指定对象的顺序。如果调用对象大于指定的对象o，则返回整数，调用对象小于指定对象o则返回负数，相等则返回0。 提示： l 目前为止，用到的能够比较大小的引用类型有String、基本类型的包装器类，这些类都实现了Comparable接口。 l 此接口强行对实现它的每个类的对象进行整体排序。此排序被称为该类的自然排序，类的compareTo 方法被称为它的自然比较方法。 l 实现此接口的对象列表（和数组）可以通过Collections.sort （和 Arrays.sort ）进行自动排序。 l 实现此接口的对象可以用作有序映射表中的键或有序集合中的元素 该接口表示比较器，该接口定义了用于比较两个对象大小的方法： intcompare(T o1, T o2) 实现该接口的类必须实现该方法，指明两个对象大小比较的规则。 提示： 该接口为那些没有实现Comparable接口的类提供了“补救”措施。 集合框架定义了一些可以应用于集合和映射的算法。这些方法被定义为Collections类中的静态方法。 Collection：所有集合接口的父接口 Collections：类，提供了很多静态方法，对各种集合进行操作 例如：查找最大值、最小值、排序 Collection和Collections区别： java.util.Collection是一个集合接口，是所有其他集合接口的父接口，提供了对集合对象进行基本操作的通用接口方法。 java.util.Collections是一个工具类，包含有各种有关集合操作的静态方法，所以此类不需要实例化。 映射(map)是存储键和值间关联(即，键值对)的对象。给定一个键，可以找到其值。键和值都是对象。键必须唯一，但是值可以重复。 可以认为映射容器分为两部分，一部分保存键，一部分保存值，并且部分之间有关联（一个键对应一个值）。 几个键值对示例： 银行卡号——银行卡 身份证号——人 学号 —— 学生 //List集合：有索引的概念，索引只能是int类型 Map是所有映射类的父接口： interfaceMap Map接口中的常用方法： 方 法 描 述 V put(K k, V v) 将一个条目放入到调用映射中，覆盖之前与此键关联的所有值。键和值分别为k和v。如果键不存在，则返回null；否则，返回之前与键相关联的值 V get(Object k) 返回与键k相关联的值。如果没有找到键，则返回null V remove(Object k) 删除键等于k的条目 void clear() 删除调用映射中的所有键-值对 boolean containsKey(Object k) 如果调用映射包含k作为键，则返回true；否则，返回false boolean containsValue(Object v) 如果映射包含v作为值，则返回true；否则，返回false 映射围绕两个基本操作：put()和get()。为了将值放入到映射中，使用put()，指定键和值。为了获取值，调用get()，传递键作为实参，值会被返回。 常用的映射类：HashMap、LinkedHashMap、TreeMap 还有一个HashTable类 HashMap实现了Map接口。它使用哈希表存储映射，即使对于比较大的集合，get()和put()的执行时间也保持不变。其声明如下： classHashMap HashMap类定义了以下构造方法： HashMap() HashMap(intcapacity) //指定容量，默认是16 HashMap(intcapacity, float fillRatio) //充填比率，0.0-1.0之间，默认0.75 LinkedHashMap扩展了Hashmap类，该类在内部使用一个链表维护条目添加到映射中的顺序，从而可以按照插入顺序迭代整个映射。 LinkedHashMap定义了以下构造方法： LinkedHashMap() LinkedHashMap(intcapacity) LinkedHashMap(intcapacity, float fillRatio) TreeMap类扩展了AbstractMap类，并实现了NavigableMap接口。该类使用树结构存储条目。TreeMap提供了有序存储键/值对的高效手段，并支持快速检索。应当注意，TreeMap确保其元素以键的升序存储。 TreeSet中的元素和TreeMap中的键，必须能够比较大小。这些元素的类一定实现了Comparable接口。 TreeMap类定义了以下构造方法： l TreeMap( ) l TreeMap(Comparator comp) //比较器对象作为参数 HashTable是一个“遗留类”类，与HashMap类似，也实现了Map接口。 HashTable与HashMap的主要区别： Vector和ArrayList的关系： 1、Hashtable是同步的、线程安全的，而HashMap不是同步的，没有实现线程安全。与Vector和ArrayList之间的区别类似。 2、HashMap允许将null作为一个条目的key或者value，当然只能有一个条目的键为null。而Hashtable不允许。 3、HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey。因为contains方法容易让人引起误解。 映射不是集合，Map不是继承自Collection接口，也没有继承Iterable接口。因此不能直接遍历映射。 注意： Map与Collection没有关系，键值对相关的接口和类是单独的体系。 Map.Entry是在Map接口的内部定义的接口，是内部接口。 在Map中存储的元素是键-值对，一个键-值对作为一个整体使用Map.Entry接口表示。Map.Entry定义的方法： K getKey() 返回该映射条目的键 V getValue() 返回该映射条目的值 V setValue(V v) 将这个映射条目的值设置为v 为了遍历映射需要采用变通的方法：获得映射的集合视图。 l 使用keySet()，返回包含映射中所有键的Set集合。 l 使用values()，返回包含映射中所有值的Collection对象 l 使用entrySet()方法，返回包含映射中所有元素（键-值对）的Set对象 条目 对于这三个集合视图都是基于映射的，修改其中的一个集合会影响其他集合。 异常也就是非正常情况，比如使用空的引用、数组下标越界、内存溢出错误等，这些都是意外的情况，背离我们程序本身的意图。 Java提供了异常机制来进行处理异常情况，通过异常机制来处理程序运行期间出现的错误。通过异常机制，可以更好地提升程序的健壮性。 Java提供了异常对象描述这类异常情况。 可以将异常通俗的理解为“陷阱”，程序运行出现异常，就是掉到陷阱了。 注意： Java异常是描述在一块代码中发生的异常情况(也就是错误)的对象。 通过案例引入异常的概念： int[]nums = null; nums= new int[] {0,1,2,3,4}; //某个元素为0、本行、元素数量小于5 for(inti=0; i<6; i++) System.out.println(12 / nums[i]); 第一种情况： try{ } catch(…){ } 大部分设计良好的catch子句，应当能够分辨出异常情况，然后继续执行，就好像错误根本没有发生一样。 异常处理过程： （1）当执行过程中遇到异常时，系统会创建并抛出一个异常（对象） （2）catch块尝试捕获该异常并处理。 （3）没有被捕获的异常最终都将由默认处理程序进行处理。默认处理程序会显示一个描述异常的字符串，输出异常发生点的跟踪栈，并终止程序。 提示： l 由try保护的语句必须使用花括号括起来(即，它们必须位于一个块中)。不能为单条语句使用try。catch块也不能省略花括号。 l try块中发生异常之后直接进入catch块，执行完catch块后也不会再返回到try块。因此，try块中发生异常之后的语句都不会再执行。 l 一个catch块可以捕获多个异常，为了使用多捕获，在catch子句中使用或运算符(|)分割每个异常。每个多捕获参数都被隐式地声明为final。(了解) l printStackTrace()方法，打印异常跟踪栈。 第二种情况：多条catch子句 try{ } catch(…){ } catch(…){ } 案例2：演示多个Catch 提示： l 执行了一条catch语句之后，会忽略其他catch语句，并继续执行try/catch块后面的代码。 l 当使用多条catch语句时，会按照顺序逐个查看catch块是否与当前的异常进行匹配。要重点记住异常子类必需位于它的所有超类之前。 l try及其catch语句构成了一个单元。catch子句的作用域被限制在由之前try语句指定的那些语句。 第三种情况：finally try(){ } /*可以有多个catch块*/ finally{ } 案例3：从字符串解析数值 提示： l 不管是否有异常抛出，都会执行finally块。 l 即使在try或catch块中有return语句，也会先执行finally块。 l 最多只能有一个finally块。 l 对于关闭文件句柄、以及释放资源，finally子句都是很有用的。 第四种情况： try(){ } catch(…){ } catch(…){ }… finally{ } 提示： 每个try语句至少需要有一个catch子句或一个finally子句。 try语句不能单独使用。 一条try语句可以位于另外一条try语句中。 如果内层的try语句没有为特定的异常提供catch处理程序，执行流程就会跳出该try语句，检查外层try语句的catch处理程序，查看异常是否匹配。这个过程会一直继续下去，直到找到了一条匹配的catch语句，或直到检查完所有的try语句。如果没有找到匹配的catch语句，则Java运行时系统会处理该异常。 提示： 当涉及方法调用时，可以能会出现不那么明显的try语句嵌套。 说明： 1、所有异常都继承自Throwable类 2、异常分为Error和Exception两大分支。 3、Exception又分为两大类： 运行时异常（非检查异常）、编译异常（检查异常） 提示：根据上下文，“异常”有两种含义 第一种：狭义上的含义，Exception及其子类 第二种：广义上的含义，Throwable及其子类 Error一般指与JVM相关的错误，如系统崩溃、虚拟机错误、动态链接失败等。 Exception表示程序要处理的异常。 Exception有一个重要子类RuntimeException。所有RuntimeException类及其子类的实例被称为运行时（Runtime）异常。运行时异常之外的异常，称为非运行时异常/编译异常。 Throwable重写了(由Object定义的)toString()方法，从而可以返回一个包含异常描述的字符串。可以使用println()语句显示这个描述。 Java的异常分为两大类：checked异常和unchecked异常。 l unchecked异常（非检查异常），也称运行时异常（RuntimeException），比如常见的NullPointerException、IndexOutOfBoundsException。对于运行时异常，java编译器不要求必须进行异常捕获处理或者抛出声明，由程序员自行决定。 l checked异常（检查异常），也称非运行时异常（运行时异常以外的异常就是非运行时异常）。Java认为Checked异常都是可以被处理（修复）的异常，所以Java程序必须显式处理Checked异常，否则无法通过编译。 含义：checked异常是指程序员比较进行检查，必须进行处理。 对于Checked异常的处理方式有如下两种： l 当前方法明确知道如何处理该异常，则应该使用try…catch块来捕获该异常，然后在对应的块中修复该异常。 l 当前方法不知道如何处理这种异常，则应该在定义该方法时声明抛出该异常。（throws关键字） 演示案例： 要求：看到异常类名，要知道表示哪种错误，知道属于哪类异常（运行时、编译） java.lang包中定义的unchecked异常（运行时异常） 异 常 含 义 ArithmeticException 算术运算（数学运算）错误，例如除零 ArrayIndexOutOfBoundsException 数组索引越界 ArrayStoreException 使用不兼容的类型为数组元素赋值 ClassCastException 无效的转换 EnumConstantNotPresentException 试图使用未定义的枚举值 IllegalArgumentException 使用非法实参调用方法 IllegalMonitorStateException 非法的监视操作，例如等待未锁定的线程 IllegalStateException 环境或应用程序处于不正确的状态 IllegalThreadStateException 请求的操作与当前线程状态不兼容 IndexOutOfBoundsException 某些类型的索引越界 NegativeArraySizeException 使用负数长度创建数组 NullPointerException 非法使用空引用 NumberFromatException 字符串到数字格式的无效转换 SecurityException 试图违反安全性 StringIndexOutOfBounds 试图在字符串边界之外进行索引 TypeNotPresentExcepton 未找到类型 UnsupportedOpetationException 遇到一个不支持的操作 常用的checked异常（编译异常），这类异常，程序必须进行处理 IOException //输入、输出异常 FileNotFoundException //文件不存在异常 SQLException //SQL异常 数据库访问相关 java.lang包中定义的Checked异常（了解） 异 常 含 义 ClassNotFoundException 未找到类 CloneNotSupportedException 试图复制没有实现Cloneable接口的对象 IllegalAccessException 对类的访问被拒绝 InstantiationException 试图为抽象类或接口创建对象 InterruptedException 一个线程被另一个线程中断 NoSuchFieldException 请求的字段不存在 NoSuchMethodException 请求的方法不存在 ReflectiveOperationException 与反射相关的异常的子类(该异常是由JDK 7新增的) 自己写类继承自Exception或RuntimeException Exception定义了四个构造函数。其中的两个支持链式异常，链式异常将在下一节描述。另外两个如下所示： Exception() Exception(Stringmsg) 对于自定义的异常类，必须先抛出（throw）自定义异常的对象，然后才能捕获catch(自定义异常对象)。 演示案例：CustomException 演示：自定义异常类、throw和throws 如果方法可能引发一个Checked异常，则必须在方法声明中提供throws子句列出了方法可能抛出的异常类型，从而方法的调用者能够保卫它们自己以防备该异常。 在throw语句之后的执行流会立即停止，所有后续语句都不会执行。然后检查最近的try块，查看是否存在和异常类型相匹配的catch语句。 throw和throws区别： l throw抛异常对象，应用在代码块内 l throws声明可能抛出的异常类型，在方法定义后面。 l 如果方法内使用throw抛出Checked异常对象，又没有进行try catch处理，则该方法定义同时需要使用throws指明抛出异常类型 public class TestException { static boolean a() throws Exception { b(); } static boolean b() throws Exception { c(); } static boolean c() throws Exception { try{ int i = 5/0; }catch(Exception e){ throw e; } return false; } public static void main(String [] args){ try{ a(); }catch(Exception e){ System.out.println(e.getMessage()); } } } 输入：外部源——>程序 输出：程序——>输出目标（文件） 外部源和输出目标：磁盘文件、网络连接、内存缓存 Java程序通过流执行I/O。流(stream)是一种抽象，它要么产生信息，要么使用信息。流通过Java的I/O系统链接到物理设备。 所有流的行为方式是相同的，尽管与它们链接的设备是不同的。因此，可以为任意类型的设备应用相同的I/O类和方法。这意味着可以将许多不同类型的输入：磁盘文件、键盘或网络socket，抽象为一个输入流。反之，一个输出流可以引用控制台、磁盘文件或网络连接。流是一种处理输入/输出的清晰方式，例如，代码中的所有部分都不需要理解键盘和网络之间的区别。 流是Java在由java.io包定义的类层次中实现的。各种流类 System.in标准输入流对象：接收键盘输入 System.out标准输出流对象：直接输出到控制台 File对象既可以表示一个文件，也可以表示一个路径/目录。 File对象描述了文件/目录本身的属性。File对象用于获取和操作与磁盘文件/目录关联的信息，例如权限、时间、日期以及目录路径，并且还可以浏览子目录层次。 File(StringdirectoryPath) //路径可以指向一个文件，也可指向一个目录 File(StringdirectoryPath, String filename) //主要用于创建表示文件的File对象 File(FiledirObj, String filename) //主要用于创建表示文件的File对象 File(URIuriObj) //URI表示网络上的一个文件 l boolean exists() //File对象所表示的文件或目录是否存 l String getName() //获取文件名或路径名 l String getPath() //返回整个路径（如果是文件的，还会包含文件名） l String getAbsolutePath() l boolean isFile() l boolean isDirectory() l boolean createNewFile() 创建新文件，只能创建文件，如果目录不存在，则异常 l boolean mkdir() 只能创建一层目录 make dirctory l boolean mkdirs() 可以创建多层目录 l boolean delete() 删除文件或文件夹（要求文件夹为空） l File[ ] listFiles() 返回值类型为 l String[] list(); l boolean canWrite() 判断文件对象表示的文件/目录是否可以写入 l boolean canRead() 判断文件对象表示的文件/目录是否可以读取 l long length() 返回文件的长度 提示： 数组：length属性，数组的长度 String：length()方法，字符串中字符的个数 File：length()方法，文件内容的长度(字节数) 注意：集合使用size()方法确定集合中元素的个数 提示： File类中重写了equals()方法，比较的文件路径 Java中的流是个抽象的概念，当程序需要从某个数据源读入数据的时候，就会开启一个数据流，数据源可以是文件、内存或网络等等。相反地，需要写出数据到某个数据源目的地的时候，也会开启一个数据流，这个数据源目的地也可以是文件、内存或网络等等。 Java中的流可以从不同的角度进行分类： l 按照流的方向不同：分为输入流和输出流。 l 按照处理数据单位的不同：分为字节流（8位）和字符流（16位）。 l 按照功能不同：分为节点流和处理流。 节点流：是可以从一个特定的数据源（节点）读写数据的流（例如文件，内存）。 处理流：是“连接”在已经存在的流（节点流或处理流）之上，通过对数据的处理为程序提供更为强大的读写功能。 对其他流类进行进一步的包装，提供附加功能，例如后面介绍的各种缓存流。 要求：给出一个类名，要知道是字符流还是字节流、是输入流还是输出流 1、Reader和Writer Reader和Writer是所有字符输入流和字符输出流的父类，抽象类 Reader类定义的常用方法： l int read() 读取单个字符。 l int read(char[] cbuf) 将字符读入数组。 l abstract int read(char[] cbuf, int off, int len) 将字符读入数组的某一部分。 Writer类定义的常用方法： l void write(char[] cbuf) 写入字符数组。 l abstract void write(char[]cbuf, int off, int len) 写入字符数组的某一部分。 l void write(int c) 写入单个字符。 l void write(Stringstr) 写入字符串。 l void write(String str, int off, int len) 写入字符串的某一部分。 2、FileReader和FileWriter FileReader类是Reader的子类，用于创建可以用于读取文件内容的Reader对象。 最常用的两个构造方法： FileReader(StringfilePath) FileReader(FilefileObj) 每个构造方法都会抛出FileNotFoundException异常 FileWriter类是Writer的子类，用于创建能够用于写入文件的Writer对象。 最常用的四个构造方法： FileWriter(StringfilePath) FileWriter(FilefileObj) FileWriter(StringfilePath, boolean append) FileWriter(FilefileObj, boolean append) 它们都会抛出IOException异常。如果append为true，则输出被追加到文件的末尾。 FileWriter对象的创建不依赖于已经存在的文件。当创建对象时，FileWriter会在打开文件之前为输出创建文件。 1、InputStream和OutputStream类 InputStream和OutputStream是所有字节输入流和字节输出流的父类，抽象类。 InputStream抽象类定义的常用方法： l int read() 读一次 返回一个字节对应的整数 l public int read(byte[]b)throws IOException从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中 l close() //关闭流，使用完流对象后必须关系 OutputStream抽象类定义的常用方法： l write(int b) l write(byte[] b) l close() 2、FileInputStream和FileOutputStream FileInputStream类是InputStream的子类，用于创建一个可以用于从文件读取内容的InputStream对象。 两个常用的构造方法： FileInputStream(StringfilePath) FileInputStream(FilefileObj) 都会抛出FileNotFoundException异常 FileOutputStream类是OutputStream的子类，用于创建能够用于向文件写入字节的OutputStream对象。它的四个构造方法如下所示： FileOutputStream(StringfilePath) FileOutputStream(File fileObj) FileOutputStream(String filePath,boolean append) FileOutputStream(File fileObj,boolean append) 它们都可能抛出FileNotFoundException异常。如果append为true，则以追加方式打开文件。 FileOutputStream对象的创建不依赖于已经存在的文件。当创建对象时，FileOutputStream会在打开文件之前创建文件。 3、DataOutputStream和DataInputStream（了解） 通过DataOutputStream和DataInputStream类，可以向流中写入基本类型数据或从流中读取基本类型数据。它们分别实现了DataOutput和DataInput接口。 DataOutputStream(OutputStreamoutputStream) //注意构造方法的参数 DataInputStream(InputStreaminputStream) 假如，希望将一个基本类型的数据写入到文件中。 FileOutputStream fs = new FileOutputStream(“D:\\123.txt”); DataOutputStream ds = new DataOutputStream(fs ); 缓存流属于处理流，是对其他流类增加一个内存缓存，以提高性能。即，缓存流是对其他流的进一步包装。 缓存流= 现有的流类+ 内存缓存 对于面向字节的流，缓存流将一个内存缓存附加到I/O系统。这种流允许Java在一定字节上执行多次I/O操作，从而提升性能。缓存的字节流类是BufferedInputStream和BufferedOutputStream。 1、BufferedInputStream类 缓存I/O是很常见的性能优化。Java的BufferedInputStream类允许将任何InputStream对象包装进一个缓存流中以提高性能。 BufferedInputStream类有两个构造方法： BufferedInputStream(InputStream inputStream) //使用默认缓存大小 BufferedInputStream(InputStream inputStream, int bufSize) //指定缓存大小 2、BufferedOutputStream类 除了增加了flush()方法之外，BufferedOutputStream与所有OutputStream类似，该方法用于确保将数据缓存写入被缓存的流中。 BufferedOutputStream是通过减少系统实际写数据的次数来提高性能的，因此可能需要调用flush()要求立即写入缓存中的所有数据。 Java中用于输出的缓存只是为了提高性能。下面是两个构造函数： BufferedOutputStream(OutputStream outputStream) BufferedOutputStream(OutputStream outputStream, int bufSize) 1、BufferedReader BufferedReader通过缓存输入提高性能。它具有两个构造方法： BufferedReader(ReaderinputStream) //默认缓存大小 BufferedReader(Reader inputStream, int bufSize) 关闭BufferedReader对象也会导致inputStream所指定的底层流被关闭。 提示： BufferedReader类提供了ReadLine()方法，用于读取一行。 //BufferedReader类，继承了read()方法 2、BufferedWriter BufferedWriter是缓存输出的Writer。使用BufferedWriter可以通过减少实际向输出设备物理地写入数据的次数来提高性能。 BufferedWriter具有以下这两个构造方法： BufferedWriter(WriteroutputStream) BufferedWriter(WriteroutputStream, int bufSize) BufferedWriter类也增加了flush()方法。 序列化（串行化）是将对象的状态写入到字节流的过程。反序列化是从流中回复这些对象。 如果希望将程序的状态保存到永久性存储区域(例如文件)这是很有用的。 只有实现了Serializable接口的类能够通过串行化功能进行保存和恢复。Serializable接口没有定义成员。它简单地用于指示类可以被串行化。如果类是可串行化的，它的所有子类也是可串行化的。 不能保存static变量。 ObjectOutput接口定义了writeObject()方法，它用于串行化对象。 ObjectInput接口定义readObject()方法，用于反串行化对象。 ObjectOutputStream类扩展了OutputStream类，并实现了ObjectOutput接口。它负责将对象写入到流中。该类的一个构造方法如下所示： ObjectOutputStream(OutputStream outStream) throws IOException ObjectInputStream类扩展了InputStream类，并实现了ObjectInput接口。ObjectInputStream负责从流中读取对象。该类的一个构造方法如下所示： ObjectInputStream(InputStreaminStream) throws IOException 形参inStream是从中读取串行化对象的输入流。 关闭ObjectInputStream对象会自动关闭inStream所指定的底层流。 l 进程：执行的程序。进程是重量级的任务，多任务一种形式。 l 线程：是进程中某个单一顺序的执行流。线程是轻量级的多任务 l 多进程：在操作系统中同时运行多个任务(程序) l 多线程：在同一应用程序（进程）中有多个执行流同时执行 l 线程的生命周期:一个线程从创建到执行完的整个过程 多线程的作用：通过使用多线程可以提高程序的性能。 Java中，一旦进入main()，就会自动创建一个主线程。为了实现多线程效果，其他的线程需要由程序员创建。 线程的优先级：优先级高的线程会执行，优先级相同的线程会交替执行。 线程的名称： 案例：MainThreadDemo 创建线程的两种方式： l 继承Thread类，重写父类run()方法 l 实现Runnable接口，实现run()方法 两种方式的比较： l 第一种：继承的方式简单，但是不利于扩展，java只允许单继承 l 第二种：开发比较麻烦，但是容易扩展，接口可以多个实现 注意线程的启动方式： 不是直接调用run()方法，而是通过Thread.Start()方法启动线程，Start()方法会在内部调用相应的run()方法。 run()是执行方法，start()是启动方法 start()启动不一定执行run()方法 案例：NewThread1 案例：NewThread2 当多个线程并发访问同一个资源对象时，需要考虑线程安全问题。 所谓同步是指多个线程不能同时访问共享对象。 实现线程安全：synchronized （1）方法加锁 public synchronized void a(){ //在该方法中可以访问共享的对象 } （2）代码块加锁 public void b(){ synchronized(共享对象){ i++; } } 线程可以处于许多不同的状态。可以调用Thread类定义的getState()方法获取线程的当前状态。该方法返回Thread.State类型的值。 值 状 态 NEW（被创建） 线程还没有开始运行 RUNNABLE（运行） 线程要么当前正在执行，要么当它获得CPU的访问权时将会执行 BLOCKED（阻塞） 线程因为正在等待所需要的锁而挂起执行 TIMED_WAITING（等待一段时间） 线程挂起执行一段指定的时间，例如当调用sleep()时就会处于这种状态。当调用wait()或join()的暂停版时也会进入这种状态 WAITING（等待） 线程因为发行了某些动作而挂起执行。例如，因为调用非暂停版的wait()或join()方法而等待时会处于这种状态 TERMINATED（终止） 线程已经完成执行 反射是在运行时获取类或对象的信息的能力。具体的讲：可以通过类名或对象获取该类的相关信息，例如类的属性和方法、类实现接口或继承父类。甚至可以通过反射在运行过程中实例化对象，动态调用方法。 反射是通过Class、Constructor、Field以及Method类实现的。这些类位java.lang.reflect包下。 在程序中使用某个类时，JVM首先需要将该类的class文件加载到内存，并为之创建一个java.lang.Class类型的对象。这个对象就是所谓的Class对象，通过该对象就可以获取该类的相关信息。 可以通过以下三种方式获取类的Class对象： l 类名.class //大部分时候使用这种方式 l 对象.getClass() l Class.forName(“类的全名”) //参数必须是类的全名 一旦获得了类的Class对象，就可以通过该Class对象获取类的相关信息了。 通过类的Class对象，可以获取类的属性、方法、构造方法等信息，这些信息分别用Field、Method、Constructor类型的对象表示。 获取Student类中所有的属性、方法、构造方法： Field[]fields = Student.class.getDeclaredFields(); //getFields() 公有的 Method[]methods = c1.getDeclaredMethods(); //getMethods() Constructor[]cs = c1.getDeclaredConstructors(); //getConstructor() 获取Student类中公有的属性、方法、构造方法： Field[]fields = Student.class.getFields(); Method[]methods = c1.getMethods(); Constructor[]cs = c1.getConstructors(); 此外还可以获取指定的属性、方法、构造器。 获得了类的Class对象后，还可以通过Class对象调用newInstance()方法创建该类的对象。 Class Student s = c1.newInstance(); //这种情况要求Student类提供了无参构造方法 创建对象的另外一种方法：通过Constructor对象。 java语言在java.net包中提供了许多类和接口，用于支持网络编程。 IP地址：唯一标识网络中的一台计算机 端口号：唯一标识计算机中的一个进程（运行的程序）。 InetAddress类：用于封装数字化的IP地址和该地址的域名。 TCP/IP套接字用于在Internet上的主机之间实现可靠的、双向的、连续的、点对点的、基于流的连接。 在Java中有两种类型的TCP套接字。 套接字对象就表示网络通信的端点。 Socket：用于客户端。 SeverSocket：用于服务端，被设计成“监听者”，它等待客户端进行连接。 Socket的两个构造方法： Socket(String hostName, int port) throws UnknownHostException, IOException 创建连接到命名的主机和端口的套接字 Socket(InetAddress ipAddress, int port) throws IOException 使用已存在的InetAddress对象和端口创建套接字 Oracle数据库：安装，SQL语言 JDBC 一套接口类，用于访问数据库 Servlet&Jsp 服务器中的Java程序，响应用户的请求 Jdbc+Servlet+Jsp 完成功能模块的增删改查（对数据库的操作）4.5 break和continue
课后作业
第5单元 数组
5.1 数组的概念
5.2 数组声明
5.3 数组创建与初始化
5.3.1 使用new创建数组
5.3.2 创建数组的三种方式
5.3.3 创建数组需要注意的问题
5.4 数组操作
5.5 数组排序
5.6 数组元素的类型
5.7 多维数组
5.7.1 二维数组的声明、创建
5.7.2 单独为第二维分配内存
5.7.3 为二维数组使用初始化器
5.8 Arrays
课后作业
第6单元 面向对象-类和对象
6.1 类与对象的概念
6.1.1 面向对象的概念
6.1.2 使用类和对象开发程序的基本步骤
6.1.3 类与对象
6.2 定义类
6.2.1 类的一般形式
6.2.2 类的属性
6.2.2 类的方法
6.3 对象的声明与创建
6.5 为引用变量赋值
6.6 构造器/构造方法
6.6.1 构造方法的语法
6.6.2 new运算符深入分析
6.7 this关键字
6.8 方法深入分析
6.8.1 方法定义
6.8.2 方法调用
6.8.3 参数传递
6.8.4 return
6.8.5 方法调用
课后练习：
第7单元 面向对象-封装
7.1 封装的概念
7.2 访问控制
7.2.1 包与访问范围
7.2.2 访问修饰符与访问范围
7.4 方法重载
7.4.1 方法重载基础
7.4.2 重载构造方法
7.5 static关键字(放到第六单元讲)
7.5.1 静态变量
7.5.2 静态代码块
7.5.3 静态方法
7.5.4 关于static的几点说明
第8单元 面向对象-继承
8.1 继承基础
8.1.1 继承的概念
8.1.2 继承的语法
8.1.3 对继承的说明
8.1.4 子类的构造方法
8.1.5 创建多级继承层次 //多继承（类不支持多继承）
8.1.6 超类引用变量可以引用子类对象
8.1.7 对象的转型
8.1.8 方法重写介绍
8.1.9 变量隐藏
8.2 super关键字
8.2.1 使用super()调用父类的构造方法
8.2.2 使用super访问父类中被子类隐藏的成员变量
8.3 Object
8.3.1 Object类介绍
8.3.2 对象相等性比较
8.3.3 Object类的常用方法
8.4 final
8.4.1 final修饰变量、方法、类
8.4.2 引用类型的常量
第9单元 面向对象—多态
9.1 多态的概念
9.2 方法重写
9.2.1 方法重写的规则
9.2.2 方法重写与方法重载的区别
9.2 动态方法调度与运行时多态
9.2.1 动态方法调度
9.2.2 运行时多态
9.2.3 多态的两种形式
9.3 多态实例
9.4 多态案例
9.4 抽象方法与抽象类
9.4.1 抽象方法
9.4.2 抽象类
第10单元 面向对象—接口
10.1 接口的概念与定义
10.2 接口中的属性和方法
10.3 接口的实现
10.4 接口继承
10.5 接口的实例
10.6 抽象类和接口的区别
第11单元 常用类
11.1 包装类
11.7.1 数值类型的包装器类
11.7.2 自动装箱与自动拆箱
11.7.3 数值与字符串形式之间的转换
11.7.4 数值类型包装器类中其他常用的常量和方法
11.7.5 Character包装器
11.7.6 Boolean包装器
11.2 String
11.2.1 String类介绍
11.2.2 String类的构造方法
11.2.3 字符串连接
11.2.4 字符串修改
11.2.5 字符串比较
11.2.5.1 字符串相等性比较
11.2.5.2 其他比较方法
11.2.6 字符串查找
11.2.7 提取字符与子串
11.2.8 其他字符串常用方法
11.3 StringBuffer和StringBuilder
11.3.1 StringBuffer与StringBuilder类介绍
11.3.2 StringBuffer类的构造方法
11.3.2 StringBuffer类的常用方法
11.3.3 长度与容量的概念
11.3.4 StringBuilder类
11.4 Math
11.4.1 Math介绍
11.4.2 Math类的常量
11.4.3 Math类的常用方法
11.5 Random
11.5.1 Random类介绍
11.5.2 常用方法
11.6 Date与Calendar
11.7.1 Date类
11.7.2 Calendar与GregorianCalendar类
第12单元 集合
12.1 集合概述
12.2 集合接口介绍
12.2.1 Collection接口
12.3 列表集合
12.3.1 List接口
12.3.2 Arraylist类
12.3.3 LinkedList类
12.3.4 Vector类
12.4 Set
12.4.1 Set接口
12.3.4 HashSet
12.3.5 LinkedHashSet类
12.3.6 TreeSet类
12.4.4 Set与List的区别
12.5 集合遍历
12.5.1 Iterable接口
12.5.2 Iterator接口
12.5.3 ListIterator接口（了解）
12.5.4 使用迭代器
12.5.5 增强的for循环
12.6 Comparable和Comparator接口
12.6.1 Comparable接口
12.6.2 Comparator接口
12.7 Collections类与集合算法
第13单元 映射
13.1 Map接口
13.2 映射类
13.2.1 HashMap
13.2.2 LinkedHashMap
13.2.3 TreeMap
13.2.4 HashTable类
13.3 映射的遍历
13.3.1 Map.Entry
13.3.2 获取映射的相关集合
第14单元 异常Exception
14.1 概念
14.2 异常处理基本流程
14.3 嵌套的try语句
14.4 异常类型
14.4.1 异常继承体系
14.4.2 Exception异常分类
14.4.3 常用异常
14.5 自定义异常
14.6 throws和throw
14.7 异常的传播
第15单元 File-IO流
15.1 I/O的概念和java.io包
15.2 File类
15.2.1 创建File对象
15.2.2 File类的常用方法
15.3 流
15.3.1 流的分类
15.3.2 IO流结构图
15.3.2 字符流
15.3.3 字节流
15.4 缓存流
15.4.1 缓存的字节流
15.4.2 缓存的字符流
15.5 序列化与反序列化
15.5.1 Serializable接口
15.5.2 ObjectOutput和ObjectInput接口
15.5.3 ObjectInputStream和ObjectOutputStream类
第16单元 反射&线程&网络编程
16.1 线程（Thread）
16.1.1 线程的概念
16.1.2 创建与启动线程
16.1.3 线程同步与线程安全
16.1.4 线程的状态
16.2 反射
16.2.1 反射的概念
16.2.2 类加载与Class对象
16.2.3 获取类的相关信息
16.1.4 使用反射生成并操作对象
16.3 网络编程
16.3.1 IP地址与端口号
16.3.2 套接字（Socket）
附录 下个阶段学习的内容