Java基础大纲

《Java基础》
教学大纲

一、课程教学目标
（一）知识目标
1．熟练掌握Java语言开发环境的配置
2．掌握Java语言的基本语法与编码规范
3．熟练掌握数组和集合的概念
4．掌握面向对像思想
5．掌握Java常用类
6．掌握顺序、选择、循环等程序控制结构的概念
7．熟练掌握Java语言中的异常处理机制及对常见异常的处理
（二）能力目标

1. 会搭建和配置Java开发环境
2. 会编写、编译、调试、运行Java程序
3. 会使用程序控制结构的顺序结构、选择结构、循环结构完成业务功能。
4. 会使用面向对象的思想完成程序设计
5. 会使用数组和集合完成业务功能
6. 会使用Java的常用类
7. 会使用异常处理
   二、课程教学内容
   （一）教学内容及考核要求

第一单元 走进Java（4课时）

演示《5G移动大厅》
1.1 Java概述
1.1.1 什么是程序
1.1.2 什么是Java
1.1.3 Java的诞生、发展与现状
1.1.4 Java技术体系
1.1.5 Java语言特点
1.2 Java程序的运行机制
1.2.1 高级语言运行机制
1.2.2 Java程序运行机制 与JVM
1.2.3 JVM与跨平台
1.3 Java开发环境的搭建与配置
1.3.1 什么是JDK
1.3.2 什么是JRE
1.3.3 JDK、JRE和JVM之间的区别和联系
1.3.4 软件安装及环境变量设置
1.3.5 测试开发环境
1.4 第一个Java程序的开发
1.4.1 编写源代码
1.4.2 常用命令
1.4.3 编译源代码
1.4.4 解释执行字节码文件
1.4.5 Java基本语法格式
1.5 标识符
1.5.1 为什么使用标识符
1.5.2 什么是标识符
1.5.3 标识符的命名规范
1.5.4 关键字与保留字
知识目标：

1. 了解Java语言特点、发展历史和现状。
2. 掌握Java技术体系分类。
3. 理解Java基本语法格式。
4. 掌握常用的Java命令和Dos内部命令。
5. 理解Java的运行机制和跨平台原理。
6. 掌握标识符的命名规范。
7. 理解Java标识符和关键字。
   能力目标：
8. 会搭建及配置Java开发环境。
9. 会使用Java编写简单程序实现简单业务。
10. 会使用DOS内部命令结合Java命令编译并运行Java程序。
11. 熟练完成贯穿项目案例规定的功能模块。
    速度目标：
    1．代码量：200行。
    2．10分钟内使用记事本完成源代码的编译运行。
    3．20分钟内完成打印5G移动大厅主菜单、用户菜单和套餐类型菜单的功能。

第二单元 数据类型及集成开发环境（4课时）

2.1 数据类型和变量
2.1.1 为什么需要数据类型
2.1.2 什么是数据类型
2.1.3 什么是基本数据类型
2.1.4 变量
2.1.5基本数据类型和变量
2.2 数据类型转换
2.2.1 自动类型转换
2.2.2 强制类型转换
2.3 Eclipse工具
2.3.1为什么使用Eclipse
2.3.2什么是Eclipse
2.3.3如何使用Eclipse
2.4 Scanner类的使用
2.4.1 为什么需要读取控制台输入
2.4.2 什么是Scanner
2.4.3 如何使用Scanner读取控制台输入

知识目标：

1. 理解数据类型和基本数据类型的概念。
2. 理解变量的概念。
3. 理解集成开发环境的概念
4. 理解Scanner类的作用

能力目标：

1. 熟练掌握数据类型的使用和转换方式。
2. 能够正确定义变量。
3. 能够使用Eclipse编写Java程序
4. 能够实现读取控制台输入
   速度目标：
   1．代码量：300行。
   2．20分钟内使用Eclipse完成简易计算器功能。

第三单元 运算符及选择结构（4课时）

3.1 运算符与表达式
3.1.1 赋值运算符
3.1.2 算术运算符
3.1.3 比较运算符
3.1.4 逻辑运算符
3.1.5 位运算符
3.1.6 其他运算符
3.1.7 运算符优先级
3.2程序控制结构
3.2.1 什么是程序控制结构
3.2.2 程序控制结构的内涵与外延
3.3 选择结构
3.3.1 为什么使用选择结构
3.3.2 什么是选择结构
3.4 if选择结构
3.4.1 if但分支选择结构
3.4.2 if-else双分支选择结构
3.4.3 if-else if多分支选择结构
3.4.4 嵌套if选择结构
3.5 switch多分支选择结构
3.5.1 什么是switch多分支选择结构
3.5.2 如何使用switch多分支选择结构
3.5.3 switch多分支与多重if选择结构比较
知识目标：

1. 理解程序控制结构概念
2. 理解选择结构概念
3. 理解if选择结构工作原理
4. 理解switch结构工作原理
   能力目标：
5. 掌握if单分支选择结构
6. 掌握if-else双分支选择结构
7. 掌握if-else if多分支选择结构
8. 掌握嵌套if选择结构的使用
9. 掌握switch多分支选择结构的使用
   速度目标：
10. 代码量300行
11. 15分钟内编写代码根据高和底计算并输出三角形的面积。

第四单元 循环结构 （4课时）

4.1 循环结构
4.1.1 什么是循环结构
4.1.2 为什么要使用循环结构
4.2 while循环结构
4.2.1 什么是while循环结构
4.2.2 如何使用while循环结构
4.3 程序调试
4.3.1 为什么需要程序调试
4.3.2 什么是程序调试
4.3.3 如何进行程序调试
4.4 do-while循环结构
4.4.1 为什么需要do-while循环
4.4.2 什么是do-while循环
4.4.3 如何使用do-while循环
4.5 for循环结构
4.5.1 为什么要使用for循环结构
4.5.2 什么是for循环结构
4.5.3 如何使用for循环结构
4.5.4 for循环结构的嵌套使用
4.6 跳转语句
4.6.1 break语句
4.6.2 continue语句
知识目标：
1.准确理解循环和循环结构的概念。
2.掌握while循环语法和流程图。
3.掌握do-while循环语法和流程图。
4.掌握while和do-while循环的区别。
5.掌握for循环语法和流程图。
6.掌握break/continue语句的用法。
7.掌握循环嵌套的用法。
8.掌握break语句和continue语句的区别。
9.掌握调试简单程序错误的方法
能力目标：
1.能熟练使用 while循环结构。
2.能熟练使用 do-while循环结构。
3.能调试简单程序错误。
4.能熟练使用for循环结构。
5.能熟练使用循环嵌套结构。
6.能熟练使用break语句。
7.能熟练使用continue语句。
8.能实现《5G移动大厅》的主菜单交互功能模块。
速度目标：

1. 完成代码量：300行。
2. 20分钟内使用嵌套的for循环打印输出乘法表。
3. 30分钟内完成质数判断：通过屏幕输入一个整数，判断输入的整数是否是质数。

第五单元 数组(上)（4课时）

5.1 认识数组
5.1.1 为什么要使用数组
5.1.2 什么是数组
5.2 创建数组
5.2.1 数组的声明
5.2.2 数组的初始化
5.3 如何使用数组
5.3.1 数组元素的访问
5.3.2 确定数组的长度
5.3.3 数组的遍历
5.3.4 使用foreach遍历数组
5.4 数组的应用
5.4.1 计算数组的平均值
5.4.2 查找数组中指定元素
5.4.3 查找数组最大值
5.4.4 数组的排序
知识目标：

1. 掌握数组的概念。
2. 理解数组的优缺点。
3. 掌握一维数组的概念。
4. 掌握一维数组的声明和内存分配。
5. 掌握一维数组元素的四要素。
6. 掌握一维数组元素的赋值方法。
7. 掌握一维数组元素数组遍历的方法。
8. 掌握解决常见错误的方法。
9. 掌握增强foreach循环的使用方法。
10. 掌握查找数组元素的算法。
11. 掌握查找最大值和最小值的算法。
12. 掌握冒泡排序的原理。
13. 掌握如何使用Arrays类排序的方法。
    能力目标：
14. 会创建和初始化一维数组。
15. 会理解一维数组的内存分配。
16. 会对一维数组正确赋值。
17. 会遍历一维数组。
18. 会使用foreach增强for循环遍历一维数组。
19. 会对数组进行查找数组元素。
20. 会查找数组最大值和最小值。
21. 会用冒泡法对数组元素排序。
22. 会用Arrays类对数组排序。
    速度目标：
    1．代码量 400行。
23. 30分钟内完成数组的基本操作：定义一个一维数组并初始化，计算数组中所有元素的和及平均值、查找数组中的最大值和最小值。
    3．30分钟完成冒泡排序。
24. 30分钟完成5G移动大厅中批量生成用户信息、查看用户列表功能。

第六单元 数组(下)、 类和对象（上）（2课时）

6.1 二维数组
6.1.1 什么是二维数组
6.1.2 创建二维数组
6.1.3 二维数组的访问
6.2 多维数组
6.2.1 了解多维数组的概念
6.2.2 了解多维数组的创建和初始化
6.3 面向对象概述
6.3.1 为什么使用面向对象
6.3.2 什么是面向对象
6.3.3 面向对象的优势
6.4 对象
6.4.1 什么是对象
6.4.2 对象的属性和方法
6.5 类
6.5.1 什么是抽象
6.5.2 什么是类

知识目标：

1. 掌握二维数组的概念。
2. 掌握二维数组声明和初始化的方法。
3. 掌握二维数组元素的访问和数组遍历的方法。
4. 了解面向过程和面向对象的区别
5. 理解面向对象的概念
6. 理解对象的概念
7. 理解抽象的概念
8. 理解类的概念

能力目标：

1. 会创建和初始化二维数组。
2. 会遍历二维数组。
3. 会访问二维数组元素。
4. 会使用面向对象分析问题
5. 掌握如何抽象出类
   速度目标：
   1．代码量 400行。
6. 30分钟内完成二维数组的基本操作：定义一个二维数组并初始化，计算二维数组中所有元素的和。
7. 30分钟完成5G移动大厅中批量生成用户信息、查看用户列表功能、用户数据统计。

第七单元 类和对象（下）（4课时）

7.1 类和对象的使用
7.1.1 实现类的抽象
7.1.2 类和对象的关系
7.1.3 如何创建类
7.1.4 如何创建和使用对象
7.1.5 成员变量的默认值
7.2 类和对象使用案例
7.3 属性作为对象间关系
7.4 运行时数据区
7.4.1 运行时数据区简介
7.4.2 什么是引用数据类型
7.4.3 对象的赋值

知识目标：

1. 理解类和对象的关系
2. 了解对象与内存的关系
3. 理解引用数据类型的概念
   能力目标：
4. 掌握如何抽象出类
5. 掌握类的创建
6. 会创建和使用对象
7. 会使用类和对象解决简单问题
   速度目标：
   1．代码量 400行。
   2．40分钟内完成以下类的编写：
   网虫套餐类
   话唠套餐类
   超人套餐类
   消费信息类
   手机卡类

第八单元 方法和变量（上）（4课时）

8.1 成员方法概述
8.1.1 什么是成员方法
8.1.2 为什么使用成员方法
8.2 无参方法
8.2.1 如何定义无参方法
8.2.2 无参方法的调用
8.2.2.1同一个类方法互调
8.2.2.2不同类中方法互调
8.3 有参方法
8.3.1 为什么使用有参方法
8.3.2 有参方法的定义
8.3.3 调用有参方法
8.4 参数传递
8.4.1 参数传递的两种分类
8.4.2 当参数是基本数据类型
8.4.3 当参数是引用数据类型
8.5 递归
8.5.1 递归求和
8.5.2 递归特点归纳
8.6 返回值
8.6.1返回值的定义
8.6.2 调用无返回值方法
8.6.3 return关键字
8.6.4 调用有返回值方法
8.7 实例方法
8.7.1实例方法的定义
8.7.2实例方法的内涵及外延
知识目标：
1．掌握方法的构成要素。
2．掌握方法的定义。
3．掌握方法的调用。
4．理解参数的传递过程。
5. 理解递归调用。
6．掌握return关键子的作用。
能力目标：

1. 会使用无参方法。
2. 会定义基本数据类型的1个或多个参数的方法。
3. 会处理方法各种类型的返回值。
4. 会定义和调用实例方法。
   速度目标：
   1．代码量 400行。

第九单元 方法和变量（下）（4课时）

9.1 成员变量
9.1.1 什么是成员变量
9.1.2 成员变量的内涵和外延
9.1.3 使用成员变量
9.2 局部变量
9.1.1 什么是局部变量
9.1.2 局部变量的内涵和外延
9.1.3 使用局部变量
9.1.4 成员变量与局部变量的区别
9.3 修饰符
9.1.1 什么是修饰符
9.1.2 修饰符的内涵和外延
9.4 静态变量
9.4.1 什么是静态变量
9.4.2 静态变量的内涵
9.4.3 使用静态变量
9.5 静态方法
9.5.1 什么是静态方法
9.5.2 静态方法的内涵
9.5.3 使用静态方法
9.5.4 静态方法与实例方法的区别
9.6 静态代码块
9.6.1 什么是静态代码块
9.6.2 静态代码块的特点
9.6.3 使用静态块
9.7 JVM运行时数据区
9.8 类的生命周期
9.8.1 什么是类的生命周期
9.8.2 类生命周期的各个阶段
知识目标：
1．掌握成员变量和局部变量。
2．掌握修饰符的定义。
3．掌握static修饰成员、方法和代码块的执行特点。
4．掌握JVM运行时数据区
5. 理解类的生命周期
能力目标：
1．使用成员变量和局部变量。
2．熟练使用修饰符。
3．熟练使用static修饰成员、方法和代码块。
4．理解JVM运行时数据区
5. 理解类的生命周期
速度目标：

1. 代码量 400行。

第十单元 封装（上）（4课时）

10.1 封装概述
10.1.1 为什么需要封装
10.1.2 Java中的封装
10.1.3 什么是封装
10.2 包
10.2.1 为什么需要包
10.2.2 如何声明包
10.2.3 包和目录的关系
10.2.4 什么是包
10.2.5 如何导入包
10.2.6 Java常用包
10.3 访问修饰符
10.3.1 为什么需要访问修饰符
10.3.2 访问修饰符的使用及特点
10.3.3 什么是访问修饰符
10.4 构造方法
10.4.1 为什么使用构造方法
10.4.2 什么是构造方法
10.4.3 如何使用构造方法
10.4.4 构造方法和静态代码块
知识目标：

1. 理解封装的基本概念
2. 理解包的概念及其作用
3. 理解包和目录的关系
4. 理解访问修饰符的概念
5. 理解构造方法的概念
   能力目标
6. 掌握封装的使用
7. 掌握使用包实现项目管理
8. 掌握使用访问修饰符实现访问控制
9. 掌握构造方法的使用
   速度目标：
10. 代码量600行。
11. 10分钟完成学生类的编写，并进行合理的封装（添加有参构造器和无参数构造器、属性私有化）。
12. 20分钟为网虫套餐类、话唠套餐类、超人套餐类添加无参和有参构造方法，并实现属性的封装。

第十一单元 封装（下）、继承（上）（2课时）

11.1 重载
11.1.1 为什么使用重载
11.1.2 构造方法的重载
11.1.3 成员方法的重载
11.1.4 什么是重载
11.2 this
11.2.1 为什么使用this
11.2.2 this是什么
11.2.3 this关键字的使用
11.1 什么是继承
11.2 为什么使用继承
11.3 如何实现继承
11.4 继承中的方法重写
11.4.1 为什么需要方法重写
11.4.2 什么是重写
知识目标：

1. 理解重载的概念
2. 理解this关键字
3. 理解继承的概念、优点和语法规则。
4. 掌握为什么使用方法的重写。
5. 掌握重写的定义。
   能力目标
6. 掌握重载的使用
7. 掌握this关键字的使用
8. 能够实现子类重写父类的方法。
9. 能够在子类中调用父类的构造方法、属性和成员方法。
   速度目标：
10. 代码量600行。
11. 20分钟完成学生类的编写，通过重载实现构造方法和计算方法。

第十二单元 继承（下）（4课时）

12.1 继承中的方法重写
12.1.2 如何实现方法重写
12.1.3 重写与重载的区别
12.2 继承中构造方法的初始化顺序
12.3 使用super关键字
12.3.1 super关键字的作用
12.3.2 super关键字的使用
12.4 final修饰符
12.5 Object类
12.5.1 什么是Object类
12.5.2 Object类的常用方法
知识目标：

1. 掌握重写的概念、规则和作用。
2. 掌握重载与重写的区别。
3. 掌握在继承中super关键字作用。
4. 掌握继承下构造方法的执行过程。
5. 掌握final修饰变量、方法和类的特点。
6. 掌握Obejct类及其中的toString()和equals()方法的作用。
7. 了解Object中的常用方法。
   能力目标：
8. 能够实现子类重写父类的方法。
9. 能够在子类中调用父类的构造方法、属性和成员方法。
10. 能够使用final关键字阻止类的继承和方法的重写。
11. 能够实现基于继承的业务功能。
    速度目标：
12. 代码量600行。
13. 30分钟内完成Animal类、Dog类、Cat类的代码实现。其中Animal类是父类，该类中的属性有：名称、颜色；方法有：吃。Dog类和Cat继承自Animal类，在Dog类和Cat类中重写父类中的吃方法。
14. 30分钟内用继承的思想完成套餐类、超人套餐类、网虫套餐类和话唠套餐 类的编写。

第十三单元 多态（上）（4课时）

13.1 为什么使用多态
13.1.1 没有多态时的情况分析
13.1.2 使用多态带来的优点
13.2 多态的概念
13.2.1 多态的定义
13.2.2 多态的内涵与外延
13.3 引用数据类型转换
13.3.1 基本类型和引用类型转换对比
13.3.2 向上转型
13.3.3 向下转型和强制类型转换符
13.4 方法绑定
13.4.1 方法绑定的定义
13.4.2 方法绑定的内涵与外延
13.4.3 后期绑定的特点
13.4.4 java中不属于后期绑定的情况
13.5 运行时多态
13.5.1 运行时多态的概念
13.5.2 运行时多态的初步使用
13.5.3 运行时多态的前提
知识目标

1. 掌握多态的概念
2. 掌握多态的优点
3. 了解多态的两种形式
4. 掌握引用数据类型转换的规则
5. 了解绑定和后期绑定
6. 掌握运行时多态的前提
   能力目标
7. 能够实现方法重载实现多态。
8. 能够实现上下转型。
9. 能够实现运行时多态。
   速度目标：
10. 代码量600行。
11. 50分钟内完成以下多态案例：
    定义一个饲养员 Feeder，属性name，喂食行为方法：feed(Animal a);
    定义动物类Animal和它的子类Dog、Cat，在Dog类和Cat类中分别重写eat()方法。
    定义测试类，在测试类中分别创建一个Feeder、Dog和Cat类的对象；调用Feeder类对象的喂食方法中并分别传入Dog对象和Cat对象。要求输出结果分别为：狗吃骨头、猫吃鱼。

第十四单元 多态（下）、复习（4课时）

14.1 运行时多态
14.1.1 运行时多态的使用细节
14.1.2 运行时多态的进阶应用
14.2 instanceof运算符
14.2.1 instanceof运算符的概念
14.2.2 instanceof运算符的使用
14.3 多态的综合应用
14.4 复习
知识目标

1. 了解运行时多态的注意细节
2. 理解多态使用场合
3. 掌握instanceof运算符的作用
   能力目标
4. 能够实现instanceof运算符判断实例
5. 能够实现基于多态的业务功能。
   速度目标：
6. 代码量600行。
7. 50分钟内完成以下多态案例：
   定义一个饲养员 Feeder，属性name，喂食行为方法：feed(Animal a);
   定义动物类Animal和它的子类Dog、Cat，在Dog类和Cat类中分别重写eat()方法。
   定义测试类，在测试类中分别创建一个Feeder、Dog和Cat类的对象；调用Feeder类对象的喂食方法中并分别传入Dog对象和Cat对象。要求输出结果分别为：狗吃骨头、猫吃鱼。

第十五单元 抽象类和接口（上）（4课时）

15.1 抽象类
15.1.1什么是抽象类
15.1.2为什么需要抽象类
15.1.3抽象方法
15.2 接口
15.2.1 为什么需要接口
15.2.2 什么是接口
15.2.3 如何使用接口
15.2.4 接口的继承
15.3 抽象类和接口的区别

知识目标：
1．掌握abstract关键字。
2．掌握抽象类特点。
3．掌握抽象方法的定义。
4．掌握interface关键字 。
5．掌握接口的特点。
6．掌握接口中成员的特殊要求。
7．掌握接口的实现。
8．了解接口的继承。
9．理解抽象类和接口的异同点。
能力目标

1. 能够掌握抽象类的定义方法。
2. 能够掌握接口的定义方法。
   3.能够使用接口实现业务功能。
   速度目标：
   1．代码量600行
   2．50分钟内完成以下抽象类案例：
   （1）定义一个抽象的Animal类作为父类，属性：颜色、年龄、性别
   抽象方法：吃东西的方法
   抽象方法：输出所有信息的方法
   （2）定义一个Dog类，继承Animal类。
   Dog类的属性：忠诚度
   重写父类中的两个抽象方法
   （3）定义一个Cat类，继承Animal类
   Cat类的属性：灵力值
   重写父类中的两个抽象方法
   （4）编写测试类，分别定义Dog与Cat类的对象，赋值，并测试调用。

第十六单元 抽象类和接口（下）、常用类（上）（4课时）

16.1 使用抽象类实现运行时多态
16.2 使用接口实现运行时多态
16.3 帮助文档的使用
16.4 基本数据类型的包装类
16.4.1 什么是包装类
16.4.2 为什么要使用包装类
16.4.3 如何使用包装类
16.4.4 包装类和基本数据类型区别
知识目标：
1．理解基本类型与包装类的区别。
2．掌握各种包装类对象的创建方法。
3．掌握自动装箱与自动拆箱。
能力目标：

1. 能够使用抽象类实现基于多态的业务功能。
2. 能够使用接口实现基于多态的业务功能。
3. 会熟练使用API。
4. 会使用包装类实现字符串和数值之间的相互转换。
   速度目标：
5. 代码量600行。
6. 20分钟内完成以下抽象类案例：
   （1）定义一个抽象的Animal类作为父类，属性：颜色、年龄、性别
   抽象方法：吃东西的方法
   抽象方法：输出所有信息的方法
   （2）定义一个Dog类，继承Animal类。
   Dog类的属性：忠诚度
   重写父类中的两个抽象方法
   （3）定义一个Cat类，继承Animal类
   Cat类的属性：灵力值
   重写父类中的两个抽象方法
   （4）定义一个Feeder类，属性：年龄、性别、年龄
   方法：饲养动物的方法，参数类型为Animal，方法中输出饲养员的属性并调用传入的Animal对象的吃东西方法。
   （5）编写测试类，分别定义Feeder、Dog与Cat类的对象，赋值，并测试调用Feeder类的饲养动物方法，将Dog与Cat类的对象分别作为参数传入。
7. 20分钟内完成以下抽象类案例：
   （1）定义一个接口Eat
   抽象方法：吃东西的方法
   （2）定义一个Dog类，实现接口Eat
   Dog类的属性：名字、忠诚度
   实现接口中的吃东西的方法
   （3）定义一个Cat类，实现接口Eat
   实现接口中的吃东西的方法
   （4）定义一个Feeder类，属性：年龄、性别、年龄
   方法：饲养动物的方法，参数类型为Eat，方法中输出饲养员的属性并调用传入的对象的吃东西方法。
   （5）编写测试类，分别定义Feeder、Dog与Cat类的对象，赋值，并测试调用Feeder类的饲养动物方法，将Dog与Cat类的对象分别作为参数传入。

第十七单元 常用类（下）（4课时）

17.1 Java中的字符串
17.1.1 String类
17.1.2 String类的常用方法
17.1.3实现格式化显示
17.2 StringBuffer类
17.2.1 StringBuffer类的作用
17.2.2 StringBuffer类的应用
17.3 StringBuilder类
17.3.1 StringBuilder类的作用
17.3.2 如何使用StringBuilder类的应用
17.4 常用类
17.4.1 Math类
17.4.2 Date类
17.4.3 SimpleDateFormat类
知识目标：
1．掌握String类的常用方法（trim、substring、indexOf、split、length）。
2．理解StringBuffer与Sting的区别。
3．了解StringBuffer的常用方法（Append、toString）。
4．掌握Math类的常用方法（abs、round、ceil、floor）。
5.了解Date类和SimpleDateFormat的使用。
能力目标：

1. 会使用字符串处理各种具体问题。
2. 会使用Date及SimpleDateFormat类。
   速度目标：
3. 代码量400行。
4. 20分钟内完成以下案例：
   定义一个方法，含有字符串参数，分别统计字符串中字母，数字，特殊符号的个数，并打印。
5. 50分钟内完成以下案例：
   （1）定义学生类(Student)，该类的属性包括：姓名、年龄、成绩，重写toString()方法。
   （2）假定有一个保存学生成绩的字符串，其格式及内容为“张三,18,90.0;李四,19,82.5;王五,20,95.0;赵六,22,87.5”。
   （3）定义测试类（Test）。在测试类中根据上述字符串创建4个Student对象，每个学生对象的各属性值，通过分割字符串获取；打印输出每个学生对象的基本信息；计算所有学生的总成绩和平均成绩，并打印输出。

第十八单元 异常（4课时）

18.1 异常概述
18.1.1 什么是异常
18.1.2 常见的异常类
18.1.3 异常类的继承体系
18.2 异常处理
18.2.1 什么是异常处理
18.2.2 try-catch块
18.2.3 访问异常信息
18.2.4 finally块
18.2.5 多重catch块
18.3 声明和抛出异常
18.3.1 声明异常-throws
18.3.2 抛出异常-throw
18.3.3 throws和throw的区别
18.4 异常的分类
18.5自定义异常
知识目标：
1．理解异常的概念。
2．熟悉异常类的继承体系。
3．熟悉常见的异常类。
4．理解异常处理的概念。
5．理解try-catch-finally各个语句块的功能。
6．理解throws和throw的区别。
7．了解异常的分类。
能力目标
1．掌握使用try-catch处理异常。
2．会查看异常信息和进行异常的处理。
3．掌握使用try-catch-finally处理异常。
4．掌握多重catch的使用。
5．掌握常用异常类的使用。
6．掌握使用throws和throw声明和抛出异常。
7．会自定义异常类。
速度目标：
1．代码量500行。
2．10分钟完成自定义异常类编写
10分钟完成当套餐余量不足时的提示消息（使用自定义异常）
20分钟内完成贯穿案例主要代码的异常处理

第十九单元 案例（4课时）

19.1 java编码规范
19.2 javaDoc注释
19.2.1 什么是javaDoc
19.2.2 如何生成javaDoc文档
19.2.3 给贯穿案例加入javadoc注释，生成javaDoc文档
19.3 小组自主完成安排的项目任务（小组项目任务各不一样）
附录：
项目任务需求说明。

第二十单元 答辩（4课时）