第一篇：Visual Basic程序设计备课教案
Visual Basic程序设计备课教案
总学时：40学时
本章学时：2
章 节 第一章Visual Basic编程环境与预定义对象 教学目的 和
教学要求
1、了解Visual Basic程序设计课程的性质及地位
2、了解Visual Basic程序设计课程的课程结构
3、了解Visual Basic发展
4、了解Visual Basic的可视化与事件驱动特点
5、掌握Visual Basic 6.0的安装、启动和运行
6、掌握Visual Basic 6.0及开发集成环境主要组成部分及其使用
7、初步掌握Visual Basic 6.0中的对象、窗体和控件的基本设置和使用 通过本章学习，让学生初步建立起面向对象程序设计的概念。教 学 重
点
难
点 重点、难点及对学生要求（包括掌握、熟悉、了解、自学）
一、重点内容
1、Visual Basic程序设计课程的性质及地位
2、Visual Basic 6.0及集成开发环境
3、Visual Basic 6.0中的对象、窗体和控件的设置和使用
4、简单Visual Basic程序示例
二、难点内容
1、可视化与事件驱动
2、对象的三个基本要素（属性、事件和方法）
3、理解面向对象程序设计的思想
三、对学生的要求
1、要求掌握的内容
（1）VB系统的启动与退出（2）VB的特点、应用及分类
（3）VB集成开发环境的主要组成部分及其使用
（4）Visual Basic 6.0中的对象、窗体和控件的基本设置和使用
2、要求熟悉的内容
（1）熟悉在视图菜单中打开各种常用窗口（2）熟悉VB开发集成环境
3、要求了解的内容
VB的功能及特点
四、例题
使用VB建立一个简单应用程序，让学生理解和体会面向对象程序设计的概念，熟悉VB集成开发环境。教学进程
（含章节
教学内容、学时分配、教学方法、辅助手段）
教学进程（含章节教学内容、学时分配）
1、前言
0.5学时
2、可视化与事件驱动语言
0.3学时
3、安装、启动与退出Visual Basic
0.2学时
4、Visual Basic 编程环境
0.2学时
5、对象
0.3学时
6、窗体
0.3学时
7、控件
0.2学时 教学方法和辅助教学手段： 多媒体教学+上机实验
作 业
上机操作熟悉Visual Basic集成开发环境。主要 参考资料 全国计算机等级考试二级VISUAL BASIC教程
袁琪等 中国水利水电出版社
2005年
Visual Basic 程序设计 唐大仕等编
清华大学出版社
2003年
Visual Basic 程序设计
王汉新等编
科学出版社 2003年 Visual Basic 语言程序设计(修订版)刘炳文编 高等教育出版社 2002年
Visual Basic程序设计 刘瑞新等编 电子工业出版社
2003年 备注 启发、引导加案例演示，注重教与学的双向互动，强调激发学生的参与意识。结合第五章内容，给学生灌输控件的思想。
章 节 第二章
简单程序设计 教学目的 和
教学要求 教学目的和要求：
1、理解面向对象程序设计的方法
2、掌握命令按钮控件的常用属性、事件和方法及其使用
3、掌握开发一个简单应用程序的一般步骤。教 学
重
点
难
点
一、重点内容
1、Visual Basic语言字符集及编码规则
2、开发一个简单应用程序的一般步骤
3、命令按钮的属性和方法
二、难点内容
1、用Visual Basic设计程序的方法
2、命令按钮的属性和方法
三、对学生的要求
1、要求掌握的内容
（1）Visual Basic的语句规定
（2）命令按钮控件的常用属性、事件和方法及其使用（3）开发一个简单的Visual Basic程序的一般步骤
2、要求熟悉的内容（1）Visual Basic的语句规定
（2）命令按钮的基本属性：Name、Height、Width、Top、Left、Enabled、Visible、Font 常用属性：Caption、Default、Cancel、Value、Picture、Style、ToolTipText 常用方法（Move、Setfocus）常用事件（click）
四、例题
使用VB建立一个简单应用程序，让学生理解和体会开发一个简单的Visual Basic程序的一般步骤。教学进程（含章节
教学内容、学时分配、教学方法、辅助手段）
教学进程（含章节教学内容、学时分配）
1、语句
0.2学时
2、命令按钮控件
0.8学时
3、简单Visual Basic程序设计
0.8学时
4、程序的保存、装入和运行
0.2学时 教学方法和辅助教学手段： 多媒体教学+上机实验
作 业 P35习题2.1，2.3，2.5 主要
参考资料 全国计算机等级考试二级VISUAL BASIC教程
袁琪等 中国水利水电出版社
2005年
Visual Basic 程序设计 唐大仕等编
清华大学出版社
2003年
Visual Basic 程序设计
王汉新等编
科学出版社 2003年 Visual Basic 语言程序设计(修订版)刘炳文编 高等教育出版社 2002年
Visual Basic程序设计 刘瑞新等编 电子工业出版社
2003年 备注 启发、引导加案例演示，注重教与学的双向互动，强调激发学生的参与意识。在此章使学生慢慢有面向对象的程序设计思想。掌握常用的属性，vb工程的构成以及程序的调试，同时通过例子使学生掌握一些编程技巧。
学时：40学时
本章学时：5
章 节 第三章
数据类型、运算符与表达式
教学目的 和 教学要求 教学目的和要求：
1、理解变量与常量的概念、掌握其定义和使用
2、了解各种常用数据类型的数据在内存中的存放形式
3、掌握各种运算符、表达式的使用方法
4、掌握常用内部函数的使用
教 学 重
点
难
点 重点、难点及对学生要求（包括掌握、熟悉、了解、自学）
一、重点内容
1、普通常量：整型、长整型、单精度、双精度、字符型、逻辑型、货币型、日期型
2、符号常量的格式：
Const 常量名 [As 类型] =常数表达式 或：Const[类型符号]= 常数表达式
3、算术运算符、字符运算符、关系运算符、逻辑运算符
4、Dim语句显式声明变量
5、用函数的sqr()、exp()、rnd()、val()、str()、Fix（）等的使用
二、难点内容
1、算术运算符：、mod的用法
2、逻辑运算符：not、and、or的用法
3、%、&、!、#、@ 等符号的含义
4、变量的概念和本质
5、常用内部函数的使用
三、对学生的要求
1、要求掌握的内容（1）各种运算符号的使用 ^、-、*、/、、mod、+、-（2）常用函数的使用
Abs(N)、Cos(N)、Sin(N)、Exp(N)、Log(N)、Sqr(N)、Rnd[(N)]、Sgn(N)、Fix(N)、Int(N)、len()、Left$()、Right()、Mid$()
2、要求熟悉的内容
各种关系运算与逻辑运算的表达
3、要求了解的内容（1）系统常量的含义
（2）各种常用数据类型的数据在内存中的存放形式（3）各种数据类型的表示范围
四、例题
利用第一章Visual Basic编程环境中的即时窗，结合本章内容进行小程序段的演示 教学进程
（含章节
教学内容、学时分配、教学方法、辅助手段）教学进程（含章节教学内容、学时分配）
1、基本（标准）数据类型
0.5学时
2、常量和变量
0.5学时
3、内部函数
学时
4、运算符与表达式
学时
5、习题讲解
学时 教学方法和辅助教学手段： 多媒体教学+上机实验 作 业 P64 选择题 主要
参考资料 2005年 全国计算机等级考试二级VISUAL BASIC教程
袁琪等 中国水利水电出版社 Visual Basic 程序设计 唐大仕等编
清华大学出版社
2003年
Visual Basic 程序设计
王汉新等编
科学出版社 2003年 Visual Basic 语言程序设计(修订版)刘炳文编 高等教育出版社 2002年
Visual Basic程序设计 刘瑞新等编 电子工业出版社
2003年 备注 启发、引导加案例演示，注重教与学的双向互动，强调激发学生的参与意识。此章是Visual Basic语言设计的基础，要求学生熟练掌握各项基础知识。利用学到的知识熟练书写表达式。在此章结束之后考核学生本章习题完成情况，讲评习题。
总学时：40学时
本章学时：2
章 节 第四章
数据输入输出 教学目的 和
教学要求 教学目的和要求：
1、掌握Visual Basic文本数据的输入/输出方法、控件
2、掌握Visual Basic图形数据的输入/输出控件
3、掌握用户交互函数和过程 教 学 重
点
难
点 重点、难点及对学生要求（包括掌握、熟悉、了解、自学）
一、重点内容
1、输入/输出语句及控件
2、Msgbox和InputBox函数
3、图形数据输入输出控件
二、难点内容
1、inputbox()、msgbox()的使用
2、文本框与标签使用
3、图片框与图像框的区别及使用
三、对学生的要求
1、要求掌握的内容
（1）Print语句输出格式
（2）inputbox()函数、msgbox()过程（3）标签、文本框、图片框、图像框控件
2、要求熟悉的内容
（1）inputbox()过程、msgbox()函数（2）文本输入输出控件
3、要求了解的内容
（1）与Print方法有关的函数和方法（2）字形的设置方法
四、例题
P56-75例4.1-4.12 教学进程（含章节
教学内容、学时分配、教学方法、辅助手段）教学进程（含章节教学内容、学时分配）
1、文本数据输出
0.3学时
2、文本数据输入输出对话框
0.5学时
3、文本数据输入输出控件
0.5学时
4、图形数据输入输出控件
0.5学时
5、字形
0.2学时 教学方法和辅助教学手段： 多媒体教学+上机实验
作 业 P77习题 4.1，4.12，4.15 主要 参考资料 2005年 全国计算机等级考试二级VISUAL BASIC教程
袁琪等 中国水利水电出版社
Visual Basic 程序设计 唐大仕等编
清华大学出版社
2003年
Visual Basic 程序设计
王汉新等编
科学出版社 2003年
Visual Basic 语言程序设计(修订版)刘炳文编 高等教育出版社 2002年
Visual Basic程序设计 刘瑞新等编 电子工业出版社
2003年 备注 启发、引导加案例演示，注重教与学的双向互动，强调激发学生的参与意识。重点讲解程序设计的基本思想和掌握用户交互函数和过程。让学生建立计算机解决问题的思维。
总学时：40学时
本章学时：4
章 节 第五章
常用控件 教学目的
和
教学要求 教学目的和要求：
1、掌握单选按钮、复选框、框架、列表框、组合框、滚动条和时钟等标准控件的常用属性、方法和事件的使用
2、了解ActiveX控件和系统对象的使用方法
3、了解焦点设置与Tab顺序 教 学
重
点
难
点 重点、难点及对学生要求（包括掌握、熟悉、了解、自学）
一、重点内容
掌握单选按钮、复选框、框架、列表框、组合框、滚动条和时钟等标准控件的常用属性、方法和事件的使用
二、难点内容
组合框和列表框及其使用
三、对学生的要求
1、要求掌握的内容
（1）单选钮、复选框的主要属性（Caption、Alignment、value、Style），事件（Click）（2）框架的重要属性（Caption、Enable、Visible）
（3）列表框、组合框的主要属性（List、ListIndex、ListCount、Sorted、Text），常用方法（AddItem、Remove、Clear）
（4）列表框特有的重要属性（Multiselect、Selected、Columns）（5）组合框特有的重要属性（style）
（6）滚动条的重要属性（Max、Min、SmallChange、LargeChange、Value），常用事件（Scroll、Change）
（7）时钟的重要属性（Interval、Enabled），唯一的事件（Timer事件）
2、要求熟悉的内容
单选钮、复选框、框架、列表框、组合框、滚动条和时钟等标准控件的常用属性、方法和事件的使用
3、要求了解的内容（（1）ActiveX控件和系统对象的使用方法（2）焦点设置与Tab顺序
四、例题
课本例5.1－例5.10 教学进程（含章节
教学内容、学时分配、教学方法、辅助手段）教学进程（含章节教学内容、学时分配）
1、复选框和单选框按钮
1学时
2、列表框和组合框
1学时
3、滚动条
0.5学时
4、计时器
0.5学时
5、框架
0.5学时
6、ActiveX控件
0.3学时
7、焦点与Tab顺序
0.2学时 辅助教学手段：
多媒体教学+上机实验
作 业 P99习题 5.2、5.6、5.7 主要
参考资料 全国计算机等级考试二级VISUAL BASIC教程
袁琪等 中国水利水电出版社
2005年
Visual Basic 程序设计 唐大仕等编
清华大学出版社
2003年
Visual Basic 程序设计
王汉新等编
科学出版社 2003年 Visual Basic 语言程序设计(修订版)刘炳文编 高等教育出版社 2002年
Visual Basic程序设计 刘瑞新等编 电子工业出版社
2003年
备注 启发、引导加案例演示，注重教与学的双向互动，强调激发学生的参与意识。
学生对滚动条的形式容易与文本框滚动条属性设置混淆，需结合具体的题目进行比对讲解，以澄清认识。
总学时：40学时
本章学时：7
章 节 第六章
Visual Basic控制结构 教学目的 和
教学要求 教学目的和要求：
1、掌握选择程序设计结构的基本特点、IF语句的三种结构、掌握Select Case语句结构
2、掌握Do…Loop循环语句、当循环控制结构、For循环结构
3、理解常用的几种嵌套结构 教 学 重
点
难
点 重点、难点及对学生要求（包括掌握、熟悉、了解、自学）
一、重点内容
1、If语句的三种结构、Select Case语句结构
2、循环结构中的Do…Loop循环语句
3、For循环语句与 Do…Loop循环语句的比较
4、嵌套的使用
5、常用算法：累加、连乘、求素数、穷举法、递推法、求最值
二、难点内容
1、多分支条件结构
2、嵌套结构
3、Do…Loop循环语句的各种语法形式
4、Do…Loop循环语句中能使循环退出的条件
5、多种循环的流程控制
三、对学生的要求
1、要求掌握的内容（1）选择结构的概念（2）If语句的三种形式
（3）Select Case语句结构
（4）循环结构的概念及执行过程（5）DO循环结构（6）FOR循环结构（7）嵌套结构（8）常用算法
2、要求熟悉的内容（1）If语句的三种形式（2）Select Case语句结构（3）DO循环结构（4）FOR循环结构（5）嵌套结构
3、要求了解的内容（1）goto语句的作用（2）Exit语句的作用
四、例题
课本例6.1－例6.7 教学进程
（含章节
教学内容、学时分配、教学方法、辅助手段）教学进程（含章节教学内容、学时分配）
1、选择控制结构
1学时
2、多分支控制结构
1学时
3、循环控制结构
3学时
4、习题讲解
2学时 教学方法和辅助教学手段： 多媒体教学+上机实验
作 业 P116习题6.5，6.10，6.12 主要 参考资料 2005年 全国计算机等级考试二级VISUAL BASIC教程
袁琪等 中国水利水电出版社
Visual Basic 程序设计 唐大仕等编
清华大学出版社
2003年
Visual Basic 程序设计
王汉新等编
科学出版社 2003年
Visual Basic 语言程序设计(修订版)刘炳文编 高等教育出版社 2002年
Visual Basic程序设计 刘瑞新等编 电子工业出版社
2003年 备注 启发、引导加案例演示，注重教与学的双向互动，强调激发学生的参与意识。学生对Select Case的测试表达式的形式容易与 if –then语句混淆，需结合具体的题目进行比对讲解，以澄清认识。
总学时：40学时
本章学时：4 章 节 第七章
复合数据类型 教学目的
和
教学要求 教学目的和要求：
1、明确数组的用途，即什么问题应该考虑应用数组进行求解
2、掌握一维数组和二维数组的定义及引用方法、动态数组的使用方法、控件数组的建立与应用方法、数组的基本操作及相关算法
3、掌握记录的定义、记录的嵌套、记录变量的初始化及其引用、记录数组使用方法
4、掌握集合的概念以及集合成员的添加、删除和检索 教 学 重
点
难
点 重点、难点及对学生要求（包括掌握、熟悉、了解、自学）
一、重点内容
1、静态数组的定义及引用
2、动态数组的定义及引用
3、常用算法：分类统计、排序（选择法、冒泡法）、插入、删除
4、记录的类型和记录变量的初始化及引用
5、集合的添加、删除和检索
二、难点内容
1、动态数组的定义及引用
2、排序问题：选择法排序、冒泡法排序
3、二维数组的定义及引用
4、数组、控件数组、记录数组的区别与联系
5、集合的添加、删除和检索
三、对学生的要求
1、要求掌握的内容（1）静态数组的定义及引用（2）动态数组的定义及引用（3）数组常用算法
（4）记录数组的定义及引用
2、要求熟悉的内容
（1）数组的定义及引用
（2）Lbound函数和Ubound函数（3）常用算法
3、要求了解的内容（1）控件数组（2）Array函数
四、例题
课本例7.1－例7.5 教学进程
（含章节
教学内容、学时分配、教学方法、辅助手段）授课主要内容及学时分配：
1、数组
0.6学时
2、数组的基本操作
0.6学时
3、控件数组
0.6学时
4、记录
0.5学时
5、记录数组
0.5学时
6、集合 0.2学时
7、习题
1学时 教学方法和辅助教学手段：
多媒体教学+上机实验
作 业 P129习题7.1，7.2，7.5，7.10 主要
参考资料 2005年
Visual Basic 程序设计 唐大仕等编
清华大学出版社
2003年
Visual Basic 程序设计
王汉新等编
科学出版社 2003年
Visual Basic 语言程序设计(修订版)刘炳文编 高等教育出版社 2002年
Visual Basic程序设计 刘瑞新等编 电子工业出版社
2003年
备注 启发、引导加案例演示，注重教与学的双向互动，强调激发学生的参与意识。重点讲述排序算法。全国计算机等级考试二级VISUAL BASIC教程
袁琪等 中国水利水电出版社
总学时：40学时
本章学时：6
章 节 第八章
过程 教学目的 和
教学要求 教学目的和要求：
1、掌握Sub子程序和Function函数过程的定义和调用方法
2、掌握传址和传值两种参数传递方式的区别及其用途、熟悉数组参数的使用方法
3、了解过程的嵌套调用和递归调用的执行过程
4、掌握常用算法常用算法和鼠标、键盘事件
5、了解拖放 教 学
重
点
难
点 重点、难点及对学生要求（包括掌握、熟悉、了解、自学）
一、重点内容
1、Sub子程序和Function函数过程的定义和调用方法
2、传址和传值两种参数传递方式的区别及其用途
3、数组参数的使用方法
4、常用算法：数值转换、加密和解密、顺序查找、二分查找
5、鼠标、键盘事件
二、难点内容
1、传址和传值两种参数传递方式的区别及其用途
2、数组参数的使用方法
三、对学生的要求
1、要求掌握的内容
（1）Sub子程序和Function函数过程的定义和调用方法（2）传址和传值两种参数传递方式的区别及其用途（3）数组参数的使用方法
（4）常用算法常用算法和鼠标、键盘事件
2、要求熟悉的内容（1）过程的嵌套调用（2）字符处理应用（3）数组参数的使用方法
3、要求了解的内容
（1）了解和递归调用的执行过程（2）了解过程作用域的有关概念（3）拖放
四、例题
课本例8.1－8.8
教学进程（含章节 教学内容、学时分配、教学方法、辅助手段）教学进程（含章节教学内容、学时分配）
1、Sub过程
0.5学时
2、Function过程
0.5学时
3、参数传送
0.6学时
4、对象参数
0.6学时
5、递归
0.6学时
6、键盘事件过程
0.5学时
7、鼠标事件过程
0.5学时
8、拖放
0.2学时
9、习题讲解
2学时 教学方法和辅助教学手段： 多媒体教学+上机实验
作 业 P171习题8.2，8.5，8.10 主要
参考资料 全国计算机等级考试二级VISUAL BASIC教程
袁琪等 中国水利水电出版社
2005年
Visual Basic 程序设计 唐大仕等编
清华大学出版社
2003年
Visual Basic 程序设计
王汉新等编
科学出版社 2003年
Visual Basic 语言程序设计(修订版)刘炳文编 高等教育出版社 2002年
Visual Basic程序设计 刘瑞新等编 电子工业出版社
2003年
备注 启发、引导加案例演示，注重教与学的双向互动，强调激发学生的参与意识。重点讲解Sub过程和Function过程的定义、调用及参数传递方式。培养学生结构化程序设计的思想。
总学时：40学时
本章学时：2
章 节 第九章
菜单、对话框与工具栏 教学目的 和
教学要求 教学目的和要求：
1、掌握通用对话框的调用
2、掌握菜单编辑器应用
3、熟悉菜单应用程序设计
4、了解工具栏设计方法 教 学
重
点
难
点 重点、难点及对学生要求（包括掌握、熟悉、了解、自学）
一、重点内容
1、通用对话框的使用
2、菜单的设计及其使用
二、难点内容
1、通用对话框的使用
2、菜单的设计
3、下拉菜单的设计
4、弹出菜单的设计
三、对学生的要求
1、要求掌握的内容（1）菜单的设计（2）菜单的使用
2、要求熟悉的内容
（1）通用对话框的使用（2）熟悉菜单应用程序设计
3、要求了解的内容 工具栏设计方法
四、例题 例9.1-9.6 教学进程（含章节
教学内容、学时分配、教学方法、辅助手段）教学进程（含章节教学内容、学时分配）
1、下拉式菜单
0.6学时
2、弹出式菜单
0.5学时
3、对话框程序设计
0.6学时
4、工具栏
0.3学时 教学方法和辅助教学手段： 多媒体教学+上机实验
作 业 P196习题9.7，9.10，9.12 主要
参考资料 全国计算机等级考试二级VISUAL BASIC教程
袁琪等 中国水利水电出版社
2005年
Visual Basic 程序设计 唐大仕等编
清华大学出版社
2003年
Visual Basic 程序设计
王汉新等编
科学出版社 2003年
Visual Basic 语言程序设计(修订版)刘炳文编 高等教育出版社 2002年
Visual Basic程序设计 刘瑞新等编 电子工业出版社
2003年
备注 启发、引导加案例演示，注重教与学的双向互动，强调激发学生的参与意识。通过本章学习，让学生掌握界面设计的方法和步骤。
总学时：40学时
本章学时：2
章 节 第十章
文件 教学目的
和
教学要求 教学目的和要求：
1、了解文件的概念
2、掌握顺序文件、随机文件的读写操作
3、掌握文件系统控件的属性和方法
4、了解文件对象模型 教 学 重
点
难
点
一、重点内容
顺序文件、随机文件的读写操作、文件系统控件
二、难点内容
顺序文件、随机文件的读写操作
三、对学生的要求
1、要求掌握的内容
（1）掌握顺序文件、随机文件的读写操作（2）掌握文件系统控件的属性和方法
2、要求熟悉的内容
顺序文件、随机文件的读写操作
3、要求了解的内容（1）文件的概念（2）文件对象模型
四、例题
课本例10.1－例10.9 教学进程
（含章节
教学内容、学时分配、教学方法、辅助手段）教学进程（含章节教学内容、学时分配）
1、文件概述
0.2学时
2、顺序文件
0.6学时
3、随机文件
0.5学时
4、文件控制系统
0.5学时
4、文件对象模型
0.2学时 教学方法和辅助教学手段： 多媒体教学+上机实验
作 业 P228 10.2，10.3，10.12 主要
参考资料 全国计算机等级考试二级VISUAL BASIC教程
袁琪等 中国水利水电出版社
2005年
Visual Basic 程序设计 唐大仕等编
清华大学出版社
2003年
Visual Basic 程序设计
王汉新等编
科学出版社 2003年
Visual Basic 语言程序设计(修订版)刘炳文编 高等教育出版社 2002年
Visual Basic程序设计 刘瑞新等编 电子工业出版社
2003年
备注 启发、引导加案例演示，注重教与学的双向互动，强调激发学生的参与意识。在此章使学生掌握Visual Basic进行文件读写的使用方法
总学时：40学时
本章学时：2
章 节 第十一章
多窗口程序与环境应用 教学目的 和
教学要求 教学目的和要求：
1、认识Visual Basic多重传窗体系统
2、理解Visual Basic多重窗体的建立方法、应用、有关多重窗体控制的语句和函数
3、了解多文档界面、Visual Basic工程结构、系统对象
4、掌握闲置循环、DoEvents语句、变量和过程的作用域。教 学 重
点
难
点 重点、难点及对学生要求（包括掌握、熟悉、了解、自学）
一、重点内容
1、Visual Basic多重窗体的建立方法、应用、有关多重窗体控制的语句和函数
2、闲置循环、DoEvents语句、变量和过程的作用域
二、难点内容
1、变量和过程的作用域
2、多文档界面的建立，多文档界面的应用
3、变量和过程的作用域
三、对学生的要求
1、要求掌握的内容
闲置循环、DoEvents语句、变量和过程的作用域。
2、要求熟悉的内容
Visual Basic多重窗体的建立方法、应用、有关多重窗体控制的语句和函数
3、要求了解的内容
文档界面、Visual Basic工程结构、系统对象
四、例题
例题11.1－11.2 教学进程
（含章节
教学内容、学时分配、教学方法、辅助手段）教学进程（含章节教学内容、学时分配）
1、建立多窗体应用程序
0.6学时
2、Visual Basic工程结构
0.2学时
3、闲置循环与DoEvents语句
0.5学时
4、变量和过程的作用域
0.5 学时
5、系统对象
0.2学时 教学方法和辅助教学手段： 多媒体教学+上机实验
作 业 P80程序设计题 1，2，5 主要
参考资料 2005年 全国计算机等级考试二级VISUAL BASIC教程
袁琪等 中国水利水电出版社 Visual Basic 程序设计 唐大仕等编
清华大学出版社
2003年
Visual Basic 程序设计
王汉新等编
科学出版社 2003年 Visual Basic 语言程序设计(修订版)刘炳文编 高等教育出版社 2002年
Visual Basic程序设计 刘瑞新等编 电子工业出版社
2003年 备注 启发、引导加案例演示，注重教与学的双向互动，强调激发学生的参与意识。重点讲解变量和过程的作用域。
总学时：40学时
本章学时：2 章 节 第十二章
图形程序设计
教学目的 和
教学要求 教学目的和要求：
1、理解对象坐标系统
2、掌握常用的绘图方法及PaintPicture方法画圆
3、了解颜色及图形漫游 教 学
重
点
难
点 重点、难点及对学生要求（包括掌握、熟悉、了解、自学）
一、重点内容
1、常用的绘图方法
2、PaintPicture方法画圆
二、难点内容
点、直线、矩形、圆等图形的绘制方法。
三、对学生的要求
1、要求掌握的内容
对象的坐标系统、点、直线、矩形、圆等图形的绘制
2、要求熟悉的内容 常用的绘图方法
3、要求了解的内容 颜色及图形漫游
四、例题 课本例12.1-12.10 教学进程（含章节
教学内容、学时分配、教学方法、辅助手段）
教学进程（含章节教学内容、学时分配）
1、对象坐标系统
0.6学时
2、常用绘图方法
0.6学时
3、颜色
0.2学时
4、用PaintPicture方法画圆
0.4学时
5、图形漫游
0.2学时 辅助教学手段：
多媒体教学+上机实验 作 业 P271 12.1-12.5 主要
参考资料 全国计算机等级考试二级VISUAL BASIC教程
袁琪等 中国水利水电出版社 2005年
Visual Basic 程序设计 唐大仕等编
清华大学出版社
2003年
Visual Basic 程序设计
王汉新等编
科学出版社 2003年 Visual Basic 语言程序设计(修订版)刘炳文编 高等教育出版社 2002年
Visual Basic程序设计 刘瑞新等编 电子工业出版社
2003年 备注 启发、引导加案例演示，注重教与学的双向互动，强调激发学生的参与意识。
第二篇：《VisualBasic程序设计》课程教学大纲
天津广播电视大学开放教育计算机网络技术专业、计算机信息管理（专科）
《VisualBasic程序设计》课程教学大纲
第一部分大纲说明
一、课程的性质与任务
VisualBasic程序设计课程是中央广播电视大学计算机相关专业的统设（统服）必修课，4学分，72学时，其中实验36学时，开设一学期。
课程的主要内容包括：可视化编程理论概述，VB可视化编程初步，应用程序接口设计及代码编写，VB高级语言技巧，文件处理应用程序设计方法，图形图像和多媒体应用程序设计方法，数据库应用程序设计方法，网络应用程序设计方法，调试与错误处理，Com和ActiveX应用。
通过本课程的学习，使学生掌握可视化程序设计方法和VB程序设计的编程技巧，具备用VB语言进行应用系统开发的初步能力。
二、与相关课程的关系
本课程是中央电大计算机相关专业的统设（统服）必修课。其先修课为计算机应用基础。
三、课程的教学要求
1．掌握VisualBasic语言的语法和VisualBasic程序的基本结构。
2．掌握程序设计方法。
3．掌握程序调试和错误处理的方法。
4．理解可视化编程和面向对象的概念。
5．了解ActiveX的简单应用。
四、课程的教学方法和教学形式建议
1．本课程的特点是：概念多、实践性强、涉及面广，因此建议采用在计算机教室（或计算机多媒体教室）进行讲授的教学形式，讲授、实验与课堂讨论相结合。
2．为加强和落实动手能力的培养，应保证上机机时不少于本教学大纲规定的实验学时。
3．应充分利用网络技术进行授课、答疑和讨论。
五、课程教学要求的层次
本课程的教学要求分为掌握、理解和了解三个层次。掌握是在理解的基础上加以灵活应用；理解是能正确表达有关概念和方法的含义，并且能够进行简单分析和判断；了解即能正确判别有关概念和方法。
在期末考核试卷中（涵盖实验内容），掌握的内容约占总分数的60%，理解的内容约占30%，了解的内容约占10%。
第二部分媒体使用与教学过程建议
一、课程学时分配
课程教学总学时数为72学时，4学分，其中实验课学时为36。各章学时分配如下：
章 教学内容
授课学时 实验学时 2 4 6 5 3 2 2 4 5 5 8 4 2 2 36 第一章 可视化编程理论概述 第二章 VB可视化编程初步
第三章 应用程序接口设计及代码编写 第四章 VB高级语言技巧
第五章 文件处理应用程序设计方法
第六章 图形图像和多媒体应用程序设计方法 4 第七章 数据库应用程序设计方法 第八章 网络应用程序设计方法 第九章 调试与错误处理 第十章 Com和ActiveX应用 合计 3 2 1 36
二、多种媒体教材的总体说明
本课程使用的教学媒体有：文字教材、录像教材、CAI课件和网上教学。
1．文字教材：主要教学媒体，是本课程教与学和考核的基本依据，对其他教学媒体起纽带作用，具有导学功能。文字教材采用分立式，包括主教材和实验教材。
2．录像教材：辅媒体，讲授课程的重点、难点以及在面授教学中难以实现的教学内容，是对文字教材的强化和补充。
3．CAI课件：自测练习，应用程序开发演练，通过交互式教学的特点，以解决学生在自学中遇到的疑难问题。
4．网上教学：教学辅导、答疑，阶段性总结和复习等。
三、教学环节
以文字教材为基础，通过录像教材、CAI课件等辅助教学媒体强化教学的重、难点内容，并通过实验课的训练，加深学生对课程内容的理解，掌握用VB语言进行程序开发的方法和技术。网上教学与教学进度同步，辅以办学试点单位教师的面授辅导，提高教学质量。
四、考核
本课程的考核采用期末终结性考核和形成性考核两种考核方式，期末终结性考核由中央电大根据教学大纲统一命题，占课程总成绩的80%，形成性考核以平时作业的形式完成，占课程总成绩的20%。
第三部分 教学内容和教学要求
第一章可视化编程理论概述（2学时）
一、教学内容：
1．“加法运算”应用程序实例分析
2．VB集成开发环境介绍
3．几种流行的可视化编程工具比较
4．面向对象的概念
二、教学要求：
1．掌握VB工程的概念及管理方法
2．掌握在VB集成环境中获得帮助的方法
3．理解可视化编程的概念和特点
4．了解目前流行的可视化语言的种类和主要特点
5．了解面向对象的概念及其基本机制
第二章VB可视化编程初步（4学时）
一、教学内容：
1．创建第一个应用程序：时钟程序
2．程序代码分析
3．窗体及基本控件
3．事件驱动
4．时钟程序分析
二、教学要求：
1．掌握VB应用程序开发的一般步骤。
2．掌握命令按钮、文本框和标签的使用和MsgBox函数的用法。
3．理解赋值语句和变量的概念。
4．理解对象、属性、方法和事件的概念及其之间的区别和联系。
5．理解事件驱动的原理。
6.了解时钟程序的工作原理
第三章应用程序接口设计及代码编写（6学时）
一、教学内容：
1．“简单的计算器”应用程序任务
2．可视化界面设计基础
3．可视化界面高级设计
4．代码设计基础
5．工程化思想及编程风格
二、教学要求：
1．掌握可视化界面设计的方法
2．掌握变量和常量的作用域、作用范围及用法
3．掌握运算符及流程控制语句的用法
4．理解工程化思想和编程风格
5．理解常用函数的使用方法
6．了解窗体设计的基本原则
7．了解“简单计算器”程序设计过程
第四章VB高级语言技巧（5学时）
一、教学内容：
1．“多功能计算器”应用程序任务
2．数组的使用
3．过程和函数的定义和调用
4．键盘使用技巧
5．鼠标使用技巧
二、教学要求：
1．掌握数组的使用方法
2．掌握键盘、鼠标的使用技巧
3．掌握过程和函数的定义和调用方法
4．掌握API函数的调用方法
5．了解枚举及自定义数据类型
6．了解“多功能计算器”程序设计过程
第五章文件处理应用程序设计方法（3学时）
一、教学内容：
1．“文件管理器”应用程序任务
2．文件系统控件及相关语句
3．标准文件输入/输出
二、教学要求：
1．掌握文件读写的基本方法
2．掌握与文件处理相关的语句和函数的用法
3．理解文件系统控件的基本功能
4．了解“文件管理器”应用程序的开发过程
第六章图形图像和多媒体应用程序设计方法（4学时）
一、教学内容：
1．“指针式时钟”和“VCD播放器”应用程序任务
2．VB坐标系统和颜色
3．相关控件介绍
4．绘图方法
5．图像处理的基本方法
6．播放多媒体信息的基本方法
二、教学要求：
1．掌握图形图像的基本处理方法。
2．理解VB坐标系统的原理。
3．理解“指针式时钟”程序的设计方法
4．理解“VCD播放器”程序设计的方法
5．了解播放多媒体信息的基本方法
第七章数据库应用程序设计方法（6学时）
一、教学内容：
1．“成绩查询”程序任务
2．VB数据对象及数据库访问机制概述
3．数据库控件和可视化数据管理器
4．报表设计
二、教学要求：
1．掌握VB数据库应用程序的基本框架
2．掌握SQL操纵数据的方法
3．理解使用VB数据库引擎操纵数据库的方法
4．理解VB数据对象及数据库访问机制
5．理解数据绑定控件的基本用法
6．了解使用Excel输出报表的方法
7．了解第三方报表控件的引用方法
8．了解DataReport、CrystalReport的使用方法
9．了解可视化数据管理器的使用方法
10．了解“成绩查询”程序的设计过程
第八章网络应用程序设计方法（3学时）
一、教学内容：
1．“网络聊天”程序任务
3．Winsocket控件及网络应用程序设计基础
2．其他网络应用程序设计
二、教学要求：
1．掌握Winsock控件的基本用法
2．了解网络应用程序设计的基础知识
3．了解“网络聊天”应用程序的开发过程
第九章调试与错误处理（2学时）
一、教学内容：
1．程序错误分类
2．程序调试方法
3．错误捕获及处理方法
二、教学要求：
1．掌握程序调试的基本方法
2．掌握错误捕获及处理的基本方法
3．了解程序错误的分类
第十章Com和ActiveX应用（1学时）
一、教学内容：
1．COM简介
2．ActiveX简介
3．COM对象的类型
4．ActiveX与COM的关系
二、教学要求：
1．了解ActiveXEXE组件开发应用方法；
2．了解ActiveXDLL组件开发应用方法；
3．了解ActiveX控件开发应用方法
第四部分 实验内容和实验要求
实验一：VisualBasic开发环境（2学时）
一、实验内容：
（1）VisualBasic6.0的安装、启动与退出
（2）定制VisualBasiv6.0的集成开发环境
（3）创建一个简单应用程序
二、实验要求：
1．了解VisualBasic（简称VB）对计算机系统的软、硬件要求。
2．练习VisualBasic6.0的安装，掌握启动与退出VisualBasic6.0的方法。
3．熟悉VisualBasic集成开发环境，掌握工具栏、属性窗口、工程资源管理器窗口、窗体布局窗口、代码编辑器窗口的使用。
实验二：简单程序设计（2学时）
一、实验内容：
（1）球表面积和球的体积的程序设计
（2）窗体的新建、属性设置
（3）身份验证程序设计
（4）创建“计时秒表”窗体程序
二、实验要求：
1．掌握建立和运行VisualBasic应用程序的基本步骤。
2．掌握文本框、标签、命令按纽的使用。
3．掌握MsgBox的使用和赋值语句的正确书写规则。
实验三：菜单设计（2学时）
一、实验内容：
（1）下拉式菜单设计
（2）弹出式菜单
（3）工具栏设计
二、实验要求：
1．掌握菜单编辑器的使用
2．掌握下拉式菜单和弹出式菜单的设计方法。
3．了解工具栏的设计方法。
实验四：鼠标、键盘、API函数调用（4学时）
一、实验内容：
（1）键盘错位程序
（2）实验键盘使用技巧
（3）鼠标事件应用
（4）窗体总在最前端实验
（5）百叶窗图形特效实验
二、实验要求：
1.掌握鼠标和键盘有关事件的使用方法
2.熟悉API函数的引用和调用方法
实验五：文件管理程序设计（5学时）
一、实验内容：
（1）Word文件查找显示程序
（2）文件读写程序
二、实验要求：
1．掌握文件管理程序相关控件的使用方法
2．掌握文件管理程序相关函数和过程的使用方法
3．掌握文件管理类程序开发的方法 实验六：绘图和多媒体应用（5学时）
一、实验内容：
（1）三角函数曲线的绘制
（2）常见几何图形绘制
（3）CD播放器程序设计
（4）API函数在多媒体中的应用
二、实验要求：
1．掌握建立图形坐标系的方法。
2．掌握VB的图形控件和图形方法以及常见几何图形的绘制。
3．掌握用多媒体控件制作简单多媒体播放器的方法。
4．了解API函数在多媒体中的应用。
实验七：数据库应用程序设计（8学时）
一、实验内容：
（1）数据绑定控件的使用方法
（2）VB数据库引擎访问数据库的方法
（3）SQL操纵数据库的方法
二、实验要求：
1．掌握利用SQL语句，通过ADO数据对象管理数据库的方法
2．理解数据库实用程序的框架体系
3．了解数据报表的制作方法 实验八：网络应用程序设计（4学时）
一、实验内容：
WinSocket控件的使用方法
二、实验要求：
1．掌握Winsock控件的使用方法
2．了解网络聊天程序的原理
实验九：简单程序调试及错误处理（2学时）
一、实验内容：
（1）程序调试实验
（2）错误捕获及处理实验
二、实验要求：
1．掌握断点的设置、监视、跟踪等程序调试方法
2．掌握OnErrorGoto、OnErrorResumeNext等语句的使用
3．理解Error对象的作用
实验十：ActiveX的简单应用（2学时）
一、实验内容：
1．ActiveXEXE组件编程
2．ActiveXDLL组件编程
二、实验要求：
1．了解ActiveXEXE组件的开发和使用方法
2．了解ActiveXDLL组件的开发和使用方法
第三篇：visualbasic程序设计教程-第四版-刘炳文编著-清华大学
Visual Basic 程序设计教程 部分习题参考
第四版刘炳文编著清华大学出版社 第五章
5.4、从键盘上输入4个数，编写程序，计算并输出这4个数的和及平均值。通过inputbox函数输入数据，在窗体上显示和及平均值。Dim a as single For i=1 to 4
a=inputbox（“请输入一个数：”，“数据输入”）
sum=sum+a
n=n+1
avg=sum/n next i print “和是：”,sum print “平均值是：”，avg 5.5、编写程序，要求用户输入下列信息：姓名、年龄、通信地址、邮政编码、电话，然后将输入的数据用适当的格式在窗体上显示出来。Dim a as variant Fontsize=20 a=inputbox（“请输入姓名：”，“数据输入”）print “姓名：”；a a=inputbox（“请输入年龄：”，“数据输入”）print “年龄：”；a a=inputbox（“请输入通信地址：”，“数据输入”）print “通信地址：”；a a=inputbox（“请输入邮政编码：”，“数据输入”）print “邮政编码：”；a a=inputbox（“请输入电话：”，“数据输入”）print “电话：”；a 5.7．设a=5，b=2.5，c=7.8，编程序计算：
y=（πab）/（a+bc）程序：
Dim a as single，b as single，c as single a=5 b=2.5 c=7.8 pi=3.14 y=（pi*a*b）/（a+b*c）print “结果是：”;y 5.8、输入以秒为单位表示的时间，编写程序，将其转换为几日几时几秒。Dim a as long，d as integer，h as integer，s as integer a=inputbox（“请输入秒数：”，“数据输入”）d=int（a/86400）h=int（（a-d*86400）/3600）s=a-d*86400-h*3600 print d；“日”；h；“时”；s；“秒”
5.9、自由落体位移公式为：s=gt2/2+v0t 其中v0为初始速度，g为重力加速度，t为经历的时间，编写程序，求位移量s。设v0=4.8m/s，t=0.5s，g=9.81m/s2，在程序中把g定义为符号常量，用inputbox函数输入v0和t两个变量的值。
Dim v as single，t as single，s as single g=9.81 v= inputbox（“请输入初始速度：”，“数据输入”）v=val（v）t=inputbox（“请输入经历的时间：”，“数据输入”）t=val（t）s=g*t*t/2+v*t print “位移量是：”;s 第七章
7.1．编程计算并输出S的值:s=2+4+6+8+„+100 dim i,s as integer s=0 for i=2 to 100 step 2 s=s+i next print s 7.2、我国现有人口为13亿，设年增长率为1%，编写程序，计算多少年后增加到20亿。Private Sub Form_click()Dim p As Double Dim r As Single Dim n As Integer p = 130000000 r = 0.01 n = 0 Do While p <= 200000000 p = p *(1 + r)n = n + 1 Loop Print n;“年后”;“中国人口增加到”;p End Sub 7.3、给定三角形的3条边长，计算三角形的面积。编写程序：首先判断给出的3条边能否构成三角形，如可以构成，则计算并输出三角形的面积，否则要求重新输入。当输入-1时结束程序。
Dim a as single；b as single；c as single Start: a = inputbox(“请输入第一条边长-1结束：”,”数据输入”)a=val（a）if a=-1 then
end end if b=inputbox（“请输入第二条边长”，“数据输入”）b=val（b）c=inputbox（“请输入第三条边长”，“数据输入”）c=val（c）
if a+b<=c or a+c<=b or b+c<=a then
msgbox（“您输入的三条边长不能构成三角形，请重新输入！”）
goto start else
l=（a+b+c）/2
s=sqr（l*（l-a）*（l-b）*（l-c））end if print “三角形的面积为：”；s 7.5、编写程序，打印如下所示的“数字金字塔”
1 2 1
…… 2 3 4 5 6 7 8 9 8 7 6 5 4 3 2 1 Private Sub Form_Click()Dim a(1 To 5)As Integer For j = 1 To 5 a(j)= j Next j For i = 1 To 5 Print Tab(301 If j > i Then Print a(2 * i2
For J = I + 1 To Maxi)* 2);a(i, 3i
If w(j, 1)> w(j + 1, 1)Then
a1 = w(j, 0)
a2 = w(j, 1)
w(j, 0)= w(j + 1, 0)
w(j, 1)= w(j + 1, 1)
w(j + 1, 0)= a1
w(j + 1, 1)= a2
End If
Next j Next i For i = 0 To 9 Print w(i, 0)Next Print “名次” & “
运动员” & “
成绩” For i = 0 To 9
Print “ ” & i + 1 & “
” & Format(w(i, 0), “000”)& “
” & w(i, 1)Next End Sub Private Sub Form_Load()For i = 0 To 9
w(i, 0)= InputBox(“请输入第” & i + 1 & “运动员的编号”)
w(i, 1)= InputBox(“请输入第” & i + 1 & “运动员的成绩”)Next Command1.Caption = “名次排列” End Sub 8.10．VB编写程序，建立并输出一个10*10的矩阵，该矩阵两条对角线元素为1，其余元素均为0 Private Sub Form_Click()
Dim a(1 To 10, 1 To 10)As Integer
For i = 1 To 10
For j = 1 To 10
a(i, j)= 0
If i = j Then a(i, j)= 1
If i + j = 11 Then a(i, j)= 1
Print a(i, j);“ ”;
Next j
Next i End Sub 8.12.杨辉三角形每一行是(x+y)的n次方的展开式的各项系数。例如第一行系数是1；第二行1，1；第三行1，2，1„„请编写程序输出n=10的杨辉三角形 Option Base 1 Private Sub Command1_Click()Dim a()As Double m = InputBox(“请输入行数 ”, “输入”, 0)ReDim a(m, m)As Double For i = 1 To m a(i, 1)= 1 For j = 1 To m
a(j, j)= 1
If j >= 2 And j <= i1, j1, j)
End If Next j Next i For i = 1 To m For j = 1 To m
If i >= j Then Print Tab(j * 4);Str(a(i, j));
End If Next j Print Next i End Sub
第四篇：java程序设计教案
《Java程序设计》
授 课 人：授课班级：电子商务专业
授
课
教
案
第一章
Java语言简介
教学目的要求
了解Java的基本特点和用途 掌握如何下载Java SDK软件包 了解设置Java程序的开发环境SDK 如何运行Java程序 了解Java的概貌 主要内容
Java语言的发展历程； Java语言的特点； Java语言的开发工具；
Java应用程序和小程序； Java程序的注释方法； 写Java程序的风格规范。
重点内容
Java语言的特点； Java语言的开发工具；
Java应用程序和小程序；
难点内容
无
课时分配
1课时 教学方法
讲授法、演示法、对比法 讲授内容提要
1.1
Java语言的发展简介
1991年Sun Mircosystem 公司成立了一个Green项目开发小组，Jame Gosling 为组长； 设计Java 采用虚拟机代码（Virtual Machine Code），即.class文件，它通过解释器运行 ； 1995年5月Sun Mircosystem 公司对外正式发布Java1.0；
Java2 用途：适用于各种应用开发，尤其是网络应用，网络服务和嵌入式系统。1.2
Java语言的特点 1．简单性 2．面向对象 3．网络适用性 4．健壮性 5．安全性
6．平台无关性 7．可移植性 8．解释型 9．高性能 10．多线程 11．动态性 12．丰富的类库 13．嵌入浏览器运行
1.3
Java类库的概念 1.4
网络浏览器 1.5
Java开发工具
NetBeans： 这个集成环境可以方便地进行程序的编辑、编译、生成和运行。J2sdk :
http:// java.sun.com免费下载;Visual J++ 6.0 / 8.0： VJ++还吸收了VB集成开发环境IDE的特征，是一个强有力的Java程序开发工具。Jcreator
Eclipse(MyEclipse)等
1.6
Java程序的分类 基于控制台的应用程序；
基于浏览器运行的小程序applet。
小程序与应用程序的区别是：小程序必须依赖一个HTML文件和支持Java的网络浏览器。老师演示小程序和applet程序
应用程序举例(程序1-1)： public class hello {
public static void main(String args[ ]){
System.out.println(“Hello Java!”);
} }
小程序举例(程序1-2)：
import java.awt.Graphics;
// 注意该行的含义 import java.applet.Applet;public class sayhello extends Applet {
public void paint(Graphics g){
g.drawString(“Hello Java!”,35,30);
} }
小程序对应的HTML文件：
1.7
1.8 对Java程序的解释
编写Java程序的风格要求 课堂练习：
请编写一个应用程序输出你自己的学号和姓名 课外练习（作业）： 下载并安装J2SDK； 设置系统环境变量 下载并安装MyEclipse 熟悉MyEclipse的开发环境
第2章
数据类型、运算符和表达式
教学目的要求
掌握字符常量和符号表示的常量的概念和应用 掌握整形、浮点型、字符型和布尔型变量的概念和应用 掌握数据的概念 理解参数传递方式
学会逻辑运算符、算术运算符和位运算符的使用方法
主要内容
常量：包括字面常量和符号表示的常量； 变量：整形、浮点型、字符型和布尔型； 数组：Java的数组属于类类型； 参数传递方式；
运算符：包括逻辑运算符、算术运算符和位运算符等；
重点内容
整形、浮点型、字符型和布尔型变量的概念和应用； 符常量和符号表示的常量的概念和应用
难点内容
参数传递方式
课时分配
2课时 教学方法
讲授法、演示法、对比法、实验验证法 讲授内容提要
2.1
常量
整形常量：采用八进制、十进制、十六进制表示，但不能采用二进制表示，和C/C++中的一样。
浮点常量：采用十进制或科学记数法表示。在缺省情况下一个浮点数是double型。布尔常量：true和false，它们不是数，不能进行算术运算。字符常量：与C/C++中的表示类似
。字符串常量：Java中字符串常量是对象。
2.2
变量
变量的命名原则是：以字母（’a’„’z’和 ’A’„’Z’）、下划线（‘_’）和‘$’符号开头的，由字母、数字（’0’„’9’）、下划线和‘$’构成的一个符号序列。
例如，a，_a，NameOfStudent，$10均是合法变量名，而-a和9a是非法变量名。关键字不能用作变量名(见表2-1)注意：Java对变量是区分大小写.2.2.1
整形类型的变量 字节（byte）型，8个位。
短整形(short)，占16个位。整形(int)，占32个位。
长整形(long int)，占64个位。
Java中的整形最值均有符号。例如程序2-1测试最值：
public class Test_Int {
// 程序2-1 测试整形变量的最值
public static void main(String [ ] args){
System.out.println(Byte.MAX_VALUE);
System.out.println(Byte.MIN_VALUE);
System.out.println(Short.MAX_VALUE);System.out.println(Short.MIN_VALUE);
System.out.println(Integer.MAX_VALUE);
System.out.println(Integer.MIN_VALUE);
System.out.println(Long.MAX_VALUE);
System.out.println(Long.MIN_VALUE);
} }
注意： byte、short、int、long是原子类型，而Byte、Short、Integer和Long分别是四种原子类型对应的类类型。
2.2.2
字符类型变量
Java字符量的长度为16个位，表示范围是从‘u0000’ 到 ‘uffff’ 即从0 到 65535； Character是char类型对应的类类型 ； 最大值 Character.MAX_VALUE ； 最小值 Character.MIN_VALUE ； 2.2.3
浮点类型变量 分类：float和double。
Float、Double 是对应的类类型 ；
Float.MAX_VALUE、Float.MIN_VALUE是最值。Float.POSITIVE_INFINITY 和
Float.NEGATIVE_INFINITY是正/负无限大。2.2.4
布尔类型变量
boolean变量取值：true和false ；
true和false不能转换成任何数值表示，true不是1，false也不是0。
2.2.5
原子类型变量的生存空间
一个变量的生存空间是由两个大括号决定的 范围。下列写法在C/C++中是正确的，但在Java中是错误的(注意)。{
int x=1;{ int x=0;// 错误 } }
2.3
变量赋值问题
如果类中定义的原子类型变量，未给出初值，那么它们将有缺省值 ：byte、short、int 和long变量的缺省值是0；char、float、double和boolean变量的缺省值分别是’u0’、0.0f、0.0d和false。
方法内定义的局部变量，应当对其赋值，否则无法通过编译。例如： // 程序2-4 class Test {
// 定义一个类
int Value;// 类中的变量未赋值，缺省就是0 } public class Test_Var{ public static void main(String [ ] args){
int x=100;
// 必须赋值，否则无法通过编译
Test obj=new Test();// 对象赋值
System.out.println(obj.Value +“
”+x);
} } 2.4
数组
Java数组是系统定义类Array 的子类； 数组的分类同C/C++：一维和多维。
2.4.1
一维数组
定义数组的格式 ：int a[ ] ； 或
int[ ] a ；其值是null ；
在定义数组时不能指定大小。a仅是一个引用，代表一个数组名，但没有对应的空间。产生数组空间的方法有两种 ：
在定义时直接赋值：int a[ ]={1,2,3};
通过new分配空间： int a[ ]=new int[10];public class Test_Array{
public static void main(String [ ] args){
int a[ ]={1,2,3}, b[ ];
b= a;
for(int i=0;i<3;i++)b[ i ]++;
for(int i=0;i<3;i++)System.out.println(a[i]);
} }
public class Test_Array{
public static void main(String [ ] args){
int a[ ]={1,2,3}, b[ ];
b = new int[6];
System.out.println(“b数组长度 = ” + b.length);
for(int i=0;i System.out.print(b[i]+“ ”); } } 注意：(1)获得数组元素的个数：数组名.length； (2)一个整形数组若仅仅采用new分配空间，而没有对其赋值，那么每个元素的值是0 注意：Java数组名是一个引用，当将一个数组名赋值给另一个数组时，实际上是名字的复制 2.5 Java中的参数传递方式 Java的参数传递的形式有两种：基本类型按值传递，对象类型按引用传递； 通过return语句从方法中返回时，基本类型总是以值的方式返回，而对象总是以引用方式返回。例如程序2-8 ： class test{ int x;} public class Test_Paras { static test fun(test o,int y){ o.x=20; } } y=1; return o;public static void main(String [ ] args){ test obj1 , obj2;int Val = 3;obj1=new test();obj1.x=100; obj2=fun(obj1,Val); System.out.println(obj1.x+“ ”+ obj2.x+“ ”+Val); } 2.6 Java的运算符 主要包括： 算术运算符、关系运算符、逻辑运算符、位运算符和三元条件运算符。2.6.1 算术运算符 算术运算符：+、-、*、/、%、++和--，与C/C++基本相同。 %运算符不但可以对整形数据运算，而且可以对浮点型数据运算。例如：3.14 % 2.5的值约等于0.64 ； 隠式数据类型转换： 当整型与浮点型数据进行混合运算时，表达式中的数据类型会进行相应的自动转换，规则为：byte->short->int->long->float->double。 这种转换规则也适应于赋值语句，当赋值符左右两侧变量类型不一致时，只要转换过程中不丢失数据，便进行自动转换。 class number { int x;} public class relationalOperator{ public static void main(String args[ ]){ } number n1,n2; n1=new number(); n2=new number();n1.x=1; n2.x=1;if(n1.x==n2.x) System.out.println(“对象的数据成员x相等！”); if(n1==n2) System.out.println(“n1和n2是一个对象！”);else System.out.println(“n1和n2不是一个对象！”);} 2.6.2 关系运算符 关系运算符不能同其它类型的变量一同 参与运算，例如假设a,b,c是三个整形的变量，那么 a=b==c 是 正确 OR 错误？ ； 关系运算符用于对象时，是判别两个引用是否代表同一个对象。而不是判断两个引用所指向的对象是否同属一个类。 2.6.3 逻辑运算符 逻辑运算符有&&、|| 和!，分别是与、或和非。运算结果是true或false； 逻辑运算有求值“短路”现象，例如程序2-11 ： public class shortCut { static boolean testOne(int x){ System.out.println(x+“ < ”+1+“ ” +(x<1));return x < 1;} static boolean testTwo(int x){ System.out.println(x+“ < ”+1+“ ” +(x<2));return x < 2; } public static void main(String [ ] args){ } if(testOne(6)&& testTwo(1))System.out.println(“表达式为真”);else System.out.println(“表达式为假”); } 2.6.4 位运算符 位运算符：&、|、^、~、<<、>>，分别称为位与、或、异或、左移、右移； Java引入一个专门用于逻辑右移运算符>>>，它采用了所谓的零扩展技术，不论原值是正或负，一律在高位补0。例如： int a=-2 , b; b=a>>>30;2.6.5 三元条件运算符 语法格式：（exp）?(exp1)：(exp2)； Java要求：(exp1)与(exp2)必须同类型。2.6.6 “+”运算符 Java对“+”进行了重载，可以将任何类型的对象（包含原子类型）转化为String类型。例如： int x=1;char ch='A';double d=9.8;System.out.println(“Result: ”+x+ch+9.8);课堂练习： 课外练习（作业）： P32 3、4、6题。 第3章 控制语句 教学目的要求 了解Java程序的结构，学习使用各种语句结构来控制程序的流程，完成程序的功能任务。 主要内容 Java的分支语句； 循环控制语句； break和continue语句； 带标号的break和continue语句。 重点内容 Java的分支语句； 循环控制语句； break和continue语句； 难点内容 循环控制语句； break和continue语句； 课时分配 3课时 教学方法 讲授法、演示法、对比法、实验验证法 讲授内容提要 3.1 分支语句 if-else语句； switch-case语句。 3.1.1 if 语句 if语句的语法格式 同C/C++； 条件表达式必须是布尔类型，例如： 下面的写法在C/C++中是合法的，但在Java中却是非法的 ： int i=10;if(i) ...程序3-1描述了用applet从文本框获取数据，然后将比较的结果显示出来。 // 程序 3-1 import java.awt.*;import java.applet.*; public class compareNumbers extends Applet{ Label lab1,lab2;TextField input1,input2; int num1,num2;public void init(){ lab1=new Label(“输入第1个整数”); input1=new TextField(10); lab2=new Label(“输入第2个整数”);input2=new TextField(10); add(lab1); add(input1);add(lab2);add(input2);} public boolean action(Event e , Object o){ } if(e.target==input1 || e.target==input2){ num1=Integer.parseInt(input1.getText()); num2=Integer.parseInt(input2.getText()); if(num1 switch 语句 switch语句的语法结构 同C/C++； switch后面的表达式类型必须是字符类型或整形 ； case后面的常量不能重复 ； 程序3-3采用小程序实现将学生的百分制成绩转换为优、良，中、及格和不通过五个等级： // 程序3-3 import java.awt.*;import java.applet.*; public class scoreConvert extends Applet{ Label prompt; TextField input;int Excellent,Good,Middle,Pass,Failure;public void init(){ prompt=new Label(“输入成绩”); } public void paint(Graphics g){ g.drawString(“各等级的人数:”,25,40);g.drawString(“优秀 : ”+Excellent,25,55);g.drawString(“良好 : ”+Good,25,70);g.drawString(“中等 : ”+Middle,25,85);g.drawString(“及格 : ”+Pass,25,100);g.drawString(“不通过: ”+Failure,25,115);input=new TextField(2);add(prompt);add(input);} public boolean action(Event e , Object o){ int score=Integer.parseInt(input.getText()); showStatus(“"); input.setText(”“); switch(score/10){ case 10: case 9: Excellent++; break;case 8: Good++; break;case 7: Middle++; break;case 6: Pass++; break;case 5: case 4: case 3: case 2: case 1: case 0: Failure++; break;default: showStatus(”输入有误，重新输入!“); } repaint(); return true;} } 程序3-3需要注意的地方 在action（）方法中调用的repaint()方法，是一个系统方法，它具有自动调用paint()方法的能力，从而实现对网页的刷新。3.2 循环控制语句 Java中的循环控制语句有三种，分别是：while，do-while和for语句;循环体内的语句会反复执行，直到控制布尔表达式的值变为false为止。3.2.1 while语句 while语句格式： while(Boolean-Expression) StatementS 程序示例3-4 略 3.2.2 do-while语句 do-while语句的语法格式如下： do{ Statement }while(Boolean-Expression); 程序3-5 如下： // 产生一个大于0.9的随机数为止 public class GenerateDoubleNumbers { public static void main(String args[ ]){ } double d;do{ d=Math.random();System.out.println(d); }while(d<0.9);} 3.2.3 for语句 for语句语法格式如下： for(ForInitopt;Boolean-Expression;ForUpdateopt) Statement // 程序3-6输出一个*三角形 public class printGraphics extends Applet{ public void paint(Graphics g){ int xpos,ypos=0; for(int row=6;row>=1;row--){ xpos=25;ypos+=15; } for(int column=1;column<=row;column++){ } g.drawString(”*“,xpos,ypos);xpos+=7; } } 3.3 break语句和continue语句 3.3.1 不带标号的break语句和continue语句 break语句可以跳出包含它的最内层的循环，不再执行剩余的语句； continue语句停止执行当前的循环，回到循环处，开始执行下一轮的循环。这些特性和C/C++的功能一样。for(int i=1;i<10;i++) { if(i%3==0) continue; else System.out.println(”i = “+i); } for(int i=1;i<10;i++) { if(i%3==0) break; else System.out.println(”i = “+i); } 课堂练习： 1、仔细分析下面程序，写出程序的最终运行结果。public class s_switch { public static void main(String args[]) { int ch=8; int r=10; switch(ch-1){ case 7: r=r+3; case 8: r=r+5; case 9: r=r+6;break; default:; } System.out.println(”r=“+r); } } 2、随机产生26个英文字母a~z，直到大于u为止。用while和for语句实现。 课外练习（作业）： P44 1—4 第4章 Java的类 教学目的要求 理解面向对象编程的基本概念 了解类的封装方法 如何创建类和对象 了解成员变量和成员方法的特性 学习使用OOP方式进行程序设计 深刻理解类的继承性和多态性 主要内容 类的定义和使用； 方法的定义和使用； 实例变量和局部变量； 构造方法； 方法的覆盖和重载； 关键字this的用法； 继承的概念和应用； 组合与继承； 抽象方法和抽象类； 对象类型转换； 访问权限限制符：public、private、protected。 重点内容 类的定义和使用； 方法的定义和使用； 构造方法； 方法的覆盖和重载； 关键字this的用法； 继承的概念和应用； 组合与继承； 抽象方法和抽象类； 对象类型转换； 难点内容 构造方法； 方法的覆盖和重载； 继承的概念和应用； 组合与继承； 抽象方法和抽象类 课时分配 8课时 教学方法 讲授法、演示法、对比法、实验验证法、学生讨论法 讲授内容提要 4.1 类与对象 在Java程序中，除原子类型的变量以外都是对象，连Java程序本身也不例外。 类是面向对象程序设计的基础，OO始终是围绕着对象的封装性、继承性和多态性展开讨论的。 4.1.1 类与对象的区别 类是一个抽象的概念，对象是一个具体的概念。 类是在一组对象的基础上，通过抽象和概括获得的一个概念。 对象是由数据和方法紧密结合的一个封装体，具有信息隐藏的能力。 对象可以通过方法（函数）与其它对象进行通信，但并不知道这些方法的实现细节。4.1.2 Java和C编程思想的区别 C是结构化的编程语言，以函数为编程单元，程序员把注意力集中在编写函数上。Java是面向对象的编程语言，以类为编程单元，程序员的精力集中在对类的设计上。 对象将实例变量（instance variable）和对数据的操作（即方法）约束在一起，类似一个独立的程序，易于扩充，易于维护，代码可复用。 4.1.3 如何定义类 类是对象的模板，它定义了对象的结构和操作数据的方法。public class Sayhello extends Applet { public void paint(Graphics g){ int xPos=35; int yPos=30; g.drawString(”Hello Java!“,xPos,yPos); } } 定义类的通用格式如下： class className extends superClassName{ type instance-vairbale1;return-type methodName1(parameter-list){ method-body;} } public class Hello { public static void main(String args[ ]){ System.out.println(”Hello Java!“); } } 系统类Object是整个类层次结构中的根。 如果我们要定义Object的子类，可以不指明extends Object，默认情况下一个类就是Object类的子类。 类内定义的变量称为实例变量，函数称为方法； Java将类的定义和类的实现放在一起，便于系统维护。例如： class point { // Object类的子类 int x , y; void init(int a, int b){ int i=0; x=a; y=b; } } 4.1.4 对象和引用 对象是客观存在的变量，对象的引用就是对象的名字，例如：Point p1;创建对象：p1=new Point(); 一个对象可以有多个别名; p2=p1;将一个变量设置为null，表明该变量不代表任何对象 : p1 = null; 每个对象都有自己的变量，改变一个对象的实例变量并不影响到另外一个对象。例如： class Point { // 程序4-1 int x , y; void init(int a, int b){ x=a; y=b; } } public class TwoPoint{ public static void main(String [ ]args){ Point p1= new Point(), p2= new Point(); p1.x=10;p2.x=30;p1.y=20;p2.y=40;System.out.println(”x = “+ p1.x +” y= “+p1.y);System.out.println(”x = “+ p2.x +” y= “+p2.y); } } 4.2 方法 方法是一个功能模块，类似C中的函数； 方法和实例变量都必须定义在类内，方法是类的功能接口 ； 定义方法的原则：方法应当只执行单一的任务，并且方法名能有效地表达该任务； 方法的返回值类型、方法名和参数表共同称之为方法的特征。调用方法的格式：引用.方法名(参数表);例如： Point p1=new point()，p2=new point();Point p3=p2;p1.init(10,20);//仅对p1对象的x和y进行赋值 p2.init(30,40);//仅对p2对象的x和y进行赋值 对象是客观存在的变量，对象的引用就是对象的名字，例如：point p1;创建对象：p1=new point(); 一个对象可以有多个别名; p2=p1;将一个变量设置为null，表明该变量不代表任何对象 : p1 = null; 每个对象都有自己的变量，改变一个对象的实例变量并不影响到另外一个对象。 4.3 实例变量和局部变量 class Loc { // 程序4-2 int x=1;// 实例变量 void printLocVar(){ int x=25;// 局部变量 } System.out.println(”n x is :“+x); ++x; System.out.println(” x is :“+x); void printInstanceVar(){ System.out.println(”n x is :“+x); x*=10; System.out.println(x is :”+x);} } public class TestInstanceVar { // 程序的主类 public static void main(String args[ ]){ System.out.println(“ x is :”+x); obj.printLocVar(); obj.printInstanceVar(); System.out.println(“ x is :”+x); loc obj=new Loc(); int x=5; // 局部变量 x } } 4.3 实例变量和局部变量 Java中的变量分为两种：类内定义的实例变量，方法中定义的局部变量。 在同一个作用域内，不允许定义两个同名的局部变量。 局部变量可以掩盖实例变量。 实例变量属于对象，它描述了对象的属性，随着对象的存在而存在； 局部变量是随着方法的调用而存在，一旦方法调用结束，局部变量也就消亡了。4.4 构造方法 构造方法的功能是在创建对象时初始化对象的实例变量； 讨论：构造方法的特点： 无返回值，无void 方法名与类名相同 仅在创建对象时调用 class point { // 程序4-3 } public class createPoint { public static void main(String args[ ]){ point p= new point(10,20); System.out.println(p.x +“ ”+p.y);} int x, y;point(int a, int b){ } x=a;y=b; } 如果类中没有定义构造方法，编译器会自动创建一个缺省的、不带参数的构造方法。构造方法是在对象创建之后，new操作完成前被调用的。 4.5 方法重载 方法重载是在一个类中定义二个或多个同名的方法，但方法的参数个数或类型不完全相同；例如： class point { int x, y;point(int a, int b){ x=a;y=b;} point(){ x=-1;y=-1;} point(double a, int b){ x=(double)a;y=b;} } 方法重载的一个误区：是靠返回值区别重载，即定义多个方法，它们的名称和形参类型完全相同，但返回值不同，这是不允许的； 4.6 关键字this this指代对象，是对当前对象的一个引用。例如： class IntVector { // 程序4-6 int v[ ]; boolean equals(IntVector other){ if(this == other)return true; return false;} } class testIntVector { public static void main(String args[ ]){ IntVector t1=new IntVector()，t3=new IntVector()，t2=t1; System.out.println(t1.equals(t2)); System.out.println(t3.equals(t2)); } } Java中的级连调用，仍是指代当前对象的this。例如：// 程序4-7 import java.awt.*;import java.applet.*; class time{ private int hour, min, sec; time(){ setHour(0);setMin(0); setSec(0);} time setHour(int h){ hour=((h>=0 && h<24)? h: 0);return this;} time setMin(int m){ min=((m>=0 && m<60)? m: 0); return this;} time setSec(int s){ sec=((s>=0 && s<60)? s: 0); return this;} String tostring(){ return hour+“:”+min+“:”+sec;} public class timeToString extends Applet{ private time t; public void init(){ } t=new time();} public void paint(Graphics g){ t.setHour(18).setMin(30).setSec(20); } g.drawString(“ time:”+t.tostring(),25,45);} 在构造方法内部使用this，它用于指代另外一个构造方法，但不能指代非构造方法。例如： class point { } 4.7 继承 继承是软件重用的一种形式，可以提高系统的性能； 继承语法： class className extends superClassName{ 各实例变量和方法的定义 } 例如： class point{ int x, y; point(int x, int y){ this.x=x;this.y=y;} point(){ this.x=0; this.y=0;} } class circle extends point{ int radius; circle(int r, int x, int y){ radius=r; this.x=x; this.y=y; } } Java不支持多继承，但支持多接口； 子类的对象也是其超类的对象，反之未必； 继承具有传递性： B继承于A，C又继承于B，则C也继承了A中的实例变量和方法。 关键字super 构造方法是一种特殊的方法，子类不能继承超类的构造方法，但子类构造方法可以通过super调用超类的构造方法。int x, y;point(){ this(-1,-1);} point(int a, int b){ x=a;y=b;} 当创建子类对象时，首先执行超类构造方法，然后执行子类的构造方法。例如： class point{ // 程序4-8 int x, y; point(int x, int y){ } } class circle extends point{ int radius; circle(int r, int x, int y){ super(x, y); radius=r; System.out.println(“子类构造函数被调用！”); this.x=x;this.y=y; System.out.println(“父类构造函数被调用！”); } } public class testInherence { public static void main(String args[ ]){ circle c1; c1=new circle(1,1,1); } } 再次讨论构造方法 若父类没有定义构造方法，那么对父类数据的初始化将采用系统缺省的构造方法；例如： class point{ int x, y; } class circle extends point{ int radius; circle(int r, int x, int y){ this.x=x; this.y=y; radius=r; } } 若父类定义有缺省构造方法，那么子类可根据自己的需要设置自己的构造方法。例如： class point{ int x, y; point(){ this(0,0); } point(int x, int y){ this.x=x;this.y=y; } } class circle extends point{ // 注意子类的构造函数 int radius; circle(int r, int x, int y){ radius=r;} } 若父类定义的构造方法都是有参的，那么子类构造方法必须通过super调用父类构造方法，class point{ private int x, y; point(int x, int y){ this.x=x; this.y=y; } } class circle extends point{ int radius; circle(int r, int x, int y){ super(x, y); radius=r; } } 4.8 方法的覆盖 方法的覆盖发生在父类和子类之间，若子类中定义的某个方法的特征，与父类中定义的某个方法的特征完全一样，那么就说子类中的这个方法覆盖了父类对应的那个方法。 4.8.1 覆盖与重载的区别 重载可以出现在一个类中，也可以出现在父类与子类的继承关系中，并且重载方法的特征一定不完全相同。 覆盖特点：子类中的方法特征与父类定义的对应方法的特征完全一样。例如： // 程序4-9 class point{ int x, y; point(){ this(0,0);} point(int x, int y){ this.x=x;this.y=y; } double area(){ return 0;} } class circle extends point{ int radius; circle(int r, int x, int y){super(x, y); radius=r; } double area(){ return Math.PI*radius*radius;} } public class testOverWrite { public static void main(String args[ ]){ } circle c1; c1=new circle(1,1,1); System.out.println(c1.area());} 4.8.2 方法的动态调用 Java的所有对象运行时都有一个类型标识(RTTI：Run-Time Type Identification)，该标识记录了每个对象所属于的类。Java用此标识在运行时选择正确的方法。例如： // 程序4-11 class point{ int x, y; point(){ this(0,0);} point(int x, int y){ this.x=x;this.y=y; } double area(){ return 0;} } class circle extends point{ int radius; circle(int r, int x, int y){ super(x, y); radius=r;} double area(){ // 覆盖了父类的area方法 return Math.PI*radius*radius; } } public class dynamicalCall { public static void main(String args[ ]){ point p[ ]={new point(2,2), new circle(1,1,1)}; for(int i=0;i System.out.print(“类名： ”+ } p[i].getClass().getName());System.out.print(“父类：”+ p[i].getClass().getSuperclass());System.out.println(“ 面积： ”+ } p[i].area());} 子类对象调用方法时: (1)子类检查是否具有同名和同参数类型的方法，若有则调用该方法，否则继续执行。 (2)到父类中寻找同名和同参数类型的方法，若有则调用该方法。若找不到，将产生编译错误。 对象决定自己到底该调用哪个方法，取决于该对象在继承链中的位置。 4.9 多态性不适合继承链中的实例变量 引用.方法：根据多态性调用； 引用.实例变量：根据引用的类型调用。即：多态性仅仅适用于方法的调用，而不适合实例变量。例如： class Base{ // 程序4-12 int x=1;void print(){ System.out.println(“当前类为 ”+ } this.getClass().getName());System.out.println(“对象的x= ”+this.x); } class Derived extends Base{ } int x=2;void print(){ System.out.println(“当前类为 ”+ } this.getClass().getName());System.out.println(“对象的x= ”+this.x); public class confusions{ public static void main(String [ ] args){ Base obj=new Derived(); } } obj.print();System.out.println(“对象的x= ”+obj.x); 4.10 finalize Java的垃圾回收器具有自动回收垃圾的能力。 垃圾回收器是一个优先级比较低的线程，在系统空闲时运行。 在对象被回收之前，有时需要执行一些特殊的操作，例如保存文件、清除屏幕等，这时就要用Java的finalize方法。例如： class point{ // 程序4-13 int x, y; point(int a, int b){ } x=a;y=b;System.out.println(“point constructor:”+getString()); public void finalize(){ // 注意该方法 System.out.println(“point finalizer:”+getString()); } String getString(){ return “x=”+x+“ y=”+y; } } class circle extends point{ int radius; circle(int r, int a, int b){ super(a,b);radius=r;System.out.println(“circle constructor:”+getString()); } public void finalize(){ System.out.println(“circle finalizer:”+getString()); } String getString(){ return super.getString()+“ radius=”+radius; } } public class testFinalize { public static void main(String args[ ]){ point c1,c2;c1=new circle(1,1,1);c2=new circle(2,2,2);c1=null;c2=null;System.gc(); } } 4.11 static static修饰变量（与C中的不同）； static修饰方法（与C中的不同）； 4.11.1 static变量 static变量是指这样的成员变量：不管在程序运行中生成多少个该类的对象，它们都共享该变量。 即使没有创建对象，该变量仍然存在。因此，static变量又称为类变量。定义格式为：static type variableName; static变量和一般的实例变量不同，在构造方法中不能对它进行初始化。例如： class point{ // 程序4-14 static int count;int x, y;static{ // 静态初始化块 } } count=0;System.out.println(“static variable is initialized!”); point(int a, int b){ count++;x=a; y=b; System.out.println(“Call point constructor!”);} public class testStaticVariable { public static void main(String args[ ]){ point c1=new point(0,0); System.out.println(“There are ”+ } 4.11.2 static方法 (可举例说明Math类的PI和sqrt等，为什么要用静态变量。)static方法是类中的成员方法，它属于整个类，即使不创建任何对象，也可使用静态方法。调用静态方法格式：类名.方法名（参数）； 在子类中不能覆盖父类中定义的静态方法。 静态方法中只能出现静态变量和其它静态方法。并且还不能使用this和super。例如： class point{ // 程序4-15 static int count; int x, y; static{ count=0;System.out.println(“static variable is initialized!”); // 定义静态变量 } point.count +“ points”); } point(int a, int b){ count++;x=a;y=b; System.out.println(“Call point constructor!”); } static int getCount(){ // 静态方法 return count; } } public class testStaticMethod { public static void main(String args[ ]){ } point c1=new point(0,0);point c2=new point(1,1); System.out.println(“There are ”+ point.getCount()+“ points”);} 4.12 关键字final 在实例变量、局部变量和方法的形参定义之前加上final，那么这个变量值只能被引用，而不能修改。 final修饰的局部变量和实例变量必须给出初值，因为它修饰的变量代表一个常量。例如： class Base{ // 程序4-16 final int x=1; // 形式1：修饰实例变量 } public class finalVariables{ public static void main(String [ ] args){ final int var=100;// 形式3：修饰局部变量 } Base obj=new Base(); obj.print(var);void print(final int y){ // 形式2：修饰参数 // y=0; // 错误 } System.out.println(x+y); } 在方法定义前加上final，该方法就不能被子类覆盖，成为终极方法 ； 包含终极方法的类仍然可以被子类继承，子类虽然不能覆盖父类中的终极方法，但可以重载该方法。例如： class Base{ final int x=1; } class Derived extends Base { void print(){ // 重载了父类中的print方法 } System.out.println(x);final void print(int y){ } // 父类中的final方法 System.out.println(x+y);} 4.12.3 final类 在一个类定义前加上final，意味着这个类就不能被其它类继承，成为终极类。 系统类基本上都是final类，如String类。 将class定义为final是为了杜绝继承，类中的方法自然都变成了终极方法。例如： final class Base{ // 声明为final类 final int x=1; void print(final int y){ System.out.println(x+y); } } // 错误：不能继承final 修饰的Base类 class Derived extends Base { } 4.13 组合与继承 面向对象中的软件重用表现为两种形式：继承和对象组合。 设计这类程序的关键是构造方法：子类构造方法调用父类构造、成员对象的初始化。class date{ // 程序4-17 int year, mon,day; date(int y, int m, int d){ year=y; mon=(m>0 && m<13)?m:1;day=checkday(d); } int checkday(int d){ int daydisp[ ]={0,31,28,31,30,31,30,31,31,30,31,30,31}; if(d>0 && d<=daydisp[mon]) return d; if(mon==2 && d==29 &&(year%400==0 || year%4==0&& year%100!=0)) return d;return 1; } String tostring(){ return year+“/”+mon+“/”+day;} } class employee{ // 雇员类 long id;date birthday; 例如： employee(long no, int year, int mon, int day){ id=no; // 设置组合对象 } String tostring(){ return id+“ , ”+birthday.tostring();} birthday=new date(year,mon,day);} class manager extends employee { // 经理类 double basePay; String tostring(){ return basePay+“ , ”+super.tostring();} } public class compositionAndInherence { } public static void main(String [ ] args){ manager boss; } boss=new manager(1001,1971,11,5);System.out.println(boss.tostring()); manager(long no, int y, int m, int d){ super(no,y,m,d); // 调用父类构造函数 } basePay=1000; 4.14 抽象类和抽象方法 抽象方法：仅有方法特征，但没有代码； 抽象类：包含抽象方法的类。 抽象类的作用：提供一种适当的超类，子类通过继承实现父类中的抽象方法。 抽象类不能用final修饰。 抽象类体现了多态性，通过继承可以从抽象类派生出具有相似操作的子类。例如： abstract instrument abstract void play()继承 wind void play()继承 继承 stringed void play()percussion void play()继承 继承 woodwind void play()brass void play() // 程序4-18 abstract class instrument{ abstract void play();} // wind不是抽象类 class wind extends instrument{ void play(){ System.out.println(“wind play!”);} } // percussion也不是抽象类 class percussion extends instrument{ void play(){ System.out.println(“percussion play!”);} } // stringed也不是抽象类 class stringed extends instrument{ void play(){ System.out.println(“stringed play!”);} } class woodWind extends wind{ // 覆盖父类中的play方法 void play(){System.out.println(“woodWind play!”);} } class brass extends wind{ // 覆盖了父类中的play方法 void play(){ System.out.println(“brass play!”);} } public class music { static void tuneAll(instrument e[ ]){ } for(int i=0;i e[i].play(); // 抽象方法 public static void main(String [ ] args){ instrument orchestra[ ] = new instrument[5];int i=0; orchestra[i++]=new wind();orchestra[i++]=new percussion();orchestra[i++]=new stringed();orchestra[i++]=new woodWind();orchestra[i++]=new brass();tuneAll(orchestra); } } 程序运行结果： wind play!percussion play!stringed play!woodWind play!brass play! 4.15 对象的类型转换 4.15.1 向上类型转换 从子类向父类转换，在继承图中是向上移动，通常称为向上类型转换。 类型向上转换是安全的，因为这是从特殊类型到通用类型的转换。 进行向上类型转换时，出现的唯一问题是可能丢失子类中定义的方法和变量。例如： // 程序4-19 class point{ int x, y; point(int x, int y){ this.x=x;this.y=y;} int getX(){ return x;} } class circle extends point{ int radius;circle(int r, int x, int y){ super(x, y);radius=r;} double area(){ return Math.PI*radius*radius; } } public class testUpCasting { } public static void main(String [ ] args){ circle c=new circle(1,1,1);point p=c;// 注意：p和c的类型不同 } System.out.println(p.getX());4.15.2 向下类型转换 从父类向子类转换，在继承图中是向下移动，称为向下类型转换。 类型向下转换是不安全的，因为这是从一般类型到特殊类型的转换。例如： public static void main(String [ ] args){ } 4.16 访问权限限制 Java提供的访问权限修饰符有四个，即public、private、protected和友元； 修饰符要置于每个类成员（实例变量和成员方法）的定义之前，且仅能控制它所修饰的那个成员。 4.16.1 友员 缺省修饰符的情况就是友员。友员修饰符意味着同一个目录（包）中的所有类都可以访问这种类型的成员。 friendly不属于Java关键字，是C++的一个关键字。 例如： public class Base{ // 该类位于Base.java文件中 int friend_data=1;// 友员数据成员 } // 该类位于Derived.java文件中 public class Derived extends Base{ Base p=new Base(); // 访问Base类中的friend_data } 4.16.2 public 成员 不管两个类是否位于同一个目录中，一个类总可以访问另一个类的public成员。 public还可以用于修饰主类，文件名必须与主类名一致。除此之外，其它3个修饰符都不能用于修饰类，只能修饰成员。例如： public class Base{ public int friend_data=1;// public成员 } void dataUse(){ System.out.println(“data=”+p.friend_data); } point p=new point(1,1);circle c;c=p; //注意：此处编译时出错 c=(circle)p;//注意：此处运行时出错 System.out.println(c.area()); public class Derived extends Base{ public Base p=new Base(); public void dataUse(){ } 4.16.3 private成员 private成员的特性：除了其所在类能够访问该成员以外，其它类都不能访问它。 在多人合作开发一个系统的过程中，private可以让你自由使用自己定义的成员，无须担心与其他人写的类相冲突。例如： // 程序4-20 class Base{ private Base(){ } public class testPrivate { public static void main(String args[ ]){ // Base p=new Base(); // 编译有错 } } Base p = Base.makeBase();} // 注意 } System.out.println(“data=”+p.friend_data);} static Base makeBase(){ return new Base(); 4.16.4 protected成员 protected与继承有关，这种类型的成员可以被子类访问。 同一个包内的非子类，也可以访问这种类型的成员。即：protected天生就具有友元权限，例如： // 程序4-21 class Base{ // 该类位于Base.java文件中 int friend_data=1; // 友元成员 public int public_data=2; // public成员 private int private_data=3;// private成员 protected int protected_data=4;// protected成员 } class Derived extends Base{ // Derived.java文件 Base a=new Base();void dataUse(){ } System.out.println(a.friend_data);System.out.println(a.public_data);// System.out.println(a.private_data);System.out.println(a.protected_data);} // 将主类存放在testData.java文件中 public class testData { public static void main(String args[ ]){ } Derived d=new Derived();d.dataUse(); } 访问权限总结 课堂练习： 1、定义一个Student类： 该类的功能有：可以保存、修改和获取学生的姓名、学号等。可以设置学生的英语成绩、数学成绩、Java成绩，并能计算平均分、最高分和最低分。 2、以下代码定义了一个类，请指出其中三条不合法的代码行（行号参见注释）。 class Test22{ //1 //7 } static float fac1(boolean f){ return f?u:v;} //8 float fac2(boolean f){ return f?u:v;} //9 float u; //2 static float v; //3 static void setUV(boolean f){ //4 u=fac1(f); //5 v=fac2(!f); //6 } 课外练习（作业）： P87 1、3、4、6 第5章 接口和包 教学目的要求 掌握接口的定义和使用 了解接口与抽象类的异同点 掌握包的定义和使用 主要内容 接口的定义和使用 包的定义和使用 重点内容 接口的定义和使用 包的定义和使用 难点内容 无 1课时 课时分配 教学方法 讲授法、演示法 讲授内容提要 5.1 接口 引入接口的原因：在程序设计中经常遇到这样一个问题：有些类互不相关，但却具有相似的方法。并且这些方法在各个类中的实现互不相同。我们不能为这些类定义一个共同的父类，但又希望在程序中体现出它们共同的接口。 5.1.1 接口的定义和应用 接口是一系列常量和空方法的集合，它提供了多个类共同的方法，但不限制每个类如何实现这些方法。 Java允许一个类同时实现多个接口，相当于实现多继承的功能。声明一个接口的语法格式： [public] interface interfaceName [extends super-interface-List]{ type ConstantName=value; type MethodName(Parameter lists);} 例如： interface Sortable{ // 定义一个接口 int Compare(Sortable s);} 接口中不能声明任何变量和构造方法。 如果一个类实现多个接口，应该在接口名之间用逗号隔开。 当一个类实现接口时，必须实现接口中给出的空方法，若实现接口的类是一个抽象类，可以把实现接口的任务交给子类去实现。例如： // 程序5-1 interface Sortable{ // 定义一个接口 int Compare(Sortable s);} class Sort{ // 定义一个排序类，仅有一个静态的方法 public static void SelectSort(Sortable a[ ]){ int i, j, k;Sortable temp; for(i=0;i // 选择排序 k=i; for(j=i+1;j if(a[k].Compare(a[j])<0)k=j; temp=a[i];a[i]=a[k];a[k]=temp;} } } class Student implements Sortable{ // 定义一个学生类 private int score; Student(int x){score=x;} // 实现接口Sortable中的方法 public int Compare(Sortable s){ Student st=(Student)s; // 类型强制转换 return score-st.score;} public String toString(){ return “score=”+score;} } class Rectangle implements Sortable{ // 矩形类也实现了接口 } public class interfaceTest { public static void main(String args[ ]){ Student stud[ ]=new Student[20];int i;private int length,width; Rectangle(int x,int y){ length=x;width=y;} int area(){return length*width;} public int Compare(Sortable s){ // 实现接口 } public String toString(){ return “area=”+area();} Rectangle rec=(Rectangle)s; // 类型强制转换 return area()-rec.area(); for(i=0;i stud[i]=new Student（(int)(Math.random()*100));Sort.SelectSort(stud); // 排序 for(i=0;i System.out.println(stud[i].toString());Rectangle R[ ]=new Rectangle[10];for(i=0;i R[i]=newRectangle（(int)(Math.random()*10)，(int)(Math.random()*10));Sort.SelectSort(R); // 排序 for(i=0;i System.out.println(R[i].toString()); } } 接口中定义的变量实际上是常量，必须给出它们的初始值，实现接口的类可以自由引用这些常量。例如： // 程序5-2的部分 interface constant { int int int int EXCELLENT=5; GOOD=4; PASS=3; FAIL=2;} 在类中实现接口中方法时，方法的特征必须和接口中声明的方法特征保持一致； 实现方法时必须在方法前加上public； 若一个类没有对接口中的方法具体实现，那么必须将该类声明为abstract类。例如： interface inter { // 接口 } void methodA(); abstract class Derived1 implements inter { // 此处不需要写出methodA()的原型 } class Derived2 extends Derived1{ public void methodA(){ // 实现方法 } } System.out.println(“Hi,methodA”);5.1.2 接口和抽象类的异同点 接口和抽象类的相同点： (1)都有空的方法，都必须在子类中实现这些方法。 (2)都不能用new关键字来创建这两种类型的对象。 (3)都可以具有继承关系。 (4)接口和类一样可以具有public属性。接口和抽象类的不同点： (1)在抽象类中，空的方法必须加abstract关键字，而在接口中不需要。 (2)在抽象类中，除空的方法外，可以定义实例变量和非空的方法，而在接口中，只能定义常量和空的方法。 (3)接口允许多继承，类仅支持单继承。 5.2 包 在Java中可以将自己写的类，按一定的方法归属于不同的子目录中（包）。 在缺省情况下，Java将所有的类归属一个缺省包中。在不同的包中可以有同名的类存在。 Java中的包与C++中的名字空间相似。 5.2.1 package语句 package语句告诉编译器当前类属于哪个包。如果没有package语句，类就存放在无名的缺省包中（即当前目录中）。 引进包的概念主要是为了名字冲突。 格式: package pkgl[．pkg2[．pkg3]]； 5.2.2 import语句 import语句位于package语句之后，类的定义之前;格式：import package1[.package2].(class-name | *)； 采用*号不影响程序的运行性能，但会影响编译速度。指明具体类比引入整个包更为合理。5.2.3 包应用举例 package Base; // 将该类存放在d:myjavaBase包中 public class Base { int friend_data=1;// 友元成员 public int public_data=2;// public成员 private int private_data=3;// private成员 protected int protected_data=4;// protected成员 } package Derived; // 将Base类存放在Derived包中 import Base.*; // 需要使用Base包中的类 public class Derived extends Base{ Base a=new Base(); // 为了让testData类能调用该方法，修改为public // 不能访问 public void dataUse(){ // System.out.println(a.friend_data); System.out.println(a.public_data); // System.out.println(a.private_data); // 不能访问 // System.out.println(a.protected_data);// 不能访问 } } // testData.java文件的内容如下： import Derived.*; //需要使用Derived包中的类 // 该类位于工作目录，不需要package语句 public class testData { public static void main(String args[ ]){ } } Derived d=new Derived(); d.dataUse(); 课堂练习： 课外练习（作业）： P108 3~6 第6章 字符串处理 教学目的要求 掌握字符串的分类； 掌握内容不可改变的字符串类String； 掌握字符串常量； 掌握内容可以改变的字符串类StringBuffer； 掌握字符串应用。 主要内容 字符串的分类； 内容不可改变的字符串类String； 字符串常量； 内容可以改变的字符串类StringBuffer； 字符串应用。 重点内容 掌握内容不可改变的字符串类String； 掌握内容可以改变的字符串类StringBuffer； 掌握字符串应用。 难点内容 String和StringBuffer的区别和联系 课时分配 2课时 教学方法 讲授法、演示法、对比法、实验验证法 讲授内容提要 6.1 字符串的分类 java.lang包中定义了 String和StringBuffer两个类； 在运行中值不会改变的字符串，用String类存储；值会改变的字符串用StringBuffer类来存储。 两个类都有final修饰，这样可以优化字符串的操作。 6.2 String类 String类的定义原型 ： public final class java.lang.String extends java.lang.Object { … } 6.2.1 字符串常量 字符串常量属于String类型;相同的字符串常量属于同一个对象，占用同一块空间，例如: // 程序6-1 public class TestConstString{ public static void main(String args[ ]){ } } String str1=“Hello”, str2=“Hello”; System.out.println(str1==str2);System.out.println(“Java”==“Java”);6.2.2 创建String类对象 用new运算符，并调用构造函数创建这种类型的对象，常见构造函数如下： 1.public String()采用该构造函数创建一个不含字符的空对象。例如： String str =new String(); 2.public String(char value[ ]) 将字符数组的内容转换为字符串，并赋予新建的对象。例如： char a[ ]={'J','a','v','a'};String str=new String(a);3.public String(char value[ ], int offset, int count) 例如：char a[ ]={'J','a','v','a'}; String str=new String(a,1,2); // 字符串str的内容是“av” 4.public String(String value) 采用value对象的值构造一个新的string对象。 例如： String str1=“Java”;String str2=new String(“Java”); System.out.println(str2); System.out.println(str1==str2); 5.public String(StringBuffer Buffer)注意采用字符串常量初始化一个String引用的问题。例如： String str = “abc”;相当于： char data[ ] = {'a', 'b', 'c'};String str = new String(data);应用举例，注意程序6-2的输出结果： public class TestString{ // 程序6-2 public static void main(String args[ ]){ String s1=“Java”, s2=“Java”;String s3=new String(s1); System.out.println(“ s1==s2 is ”+(s1==s2));System.out.println(“ s1==s3 is ”+(s1==s3));s1=“ABC”;s2=“DEFG”;System.out.println(“ s1==s2 is ”+(s1==s2));s1=s2; System.out.println(“ s1==s2 is ”+(s1==s2));} } 6.2.3 String类常用方法 1.public int length(): 求串长。例如： String str=“Java” ； System.out.println(str.length());2.public char charAt(int index) 提取指定位置上的字符。 3.public int compareTo(String anotherString) 对字符串内容按字典序进行大小比较。例如： public class SortStringArrary{ // 程序6-3 public static void main(String args[ ]){ String str,s[ ]={“Computer”,“CHINA”,“world”,“U.S.A”}; int i,j,k; System.out.print(“排序之前：”);for(i=0;i System.out.print(“t”+s[i]);for(i=0;i for(k=i,j=i+1;j if(s[k].compareTo(s[j])>0) k=j; str=s[i]; s[i]=s[k]; s[k]=str;// 注意该行的含义 } System.out.print(“n排序之后：”);for(i=0;i System.out.print(“t”+s[i]); } } 4.char[ ] toCharArray() 将String对象转换到一个字符数组中，例如： String s=“Hello,Java!”; char a[ ]; a=s.toCharArray(); for(int i=6;i System.out.print(a[i]);5.public boolean equals(String anString) 比较两个字符串对象的内容是否相等。 6.public boolean equalsIgnoreCase(String anotherString) 以忽略大小写方式，比较两个字符串对象的内容是否相等。 注意：equals()方法与“==” 之间的区别。例如： public class ConfuseQuestion{ // 程序6-5 public static void main(String args[ ]){ String s1=“java”; String s2=new String(s1); String s3=s2; } } System.out.println(s1.equals(s2));System.out.println(s2.equals(s3));System.out.println(s2==s3);System.out.println(s2.equals(s3));7.public int indexOf(int ch / String str) 在字符串中搜索字符或子串，返回字符或子串在String对象中从左边起首次出现的位置。如果没有出现，返回-1。 8.public String substring(int begin, int end) 提取string对象中从begin开始，到end-1结束的子串，返回提取的子串。 9.public String concat(String str)将str对象接到调用对象的后面，返回新串。例如： String s1=“Hello ” , s2=“Java” , s3;s3=s1.concat(s2); System.out.println(s3);注意：如果参数str为空（null），则concat方法不创建新串，而仅仅返回当前串，10.public String replace(char oldChar, char newChar) 将String对象中所有的oldChar字符替换为newChar，返回替换后的新串。例如： String path=“d:/myjava/documents”; System.out.println(path.replace('/' , '')); public String toString() 返回当前字符串对象本身。 12.public static String valueOf(各种类型 f) 将各种数据类型转换成一个相应的字符串表示，该方法是一个static方法。 程序6-6演示了valueOf()方法的应用。 程序6-7自学。 public class TestValueOf{ // 程序6-6 public static void main(String args[ ]){ char a[ ]={'A','B','C','D','E','F'}; int i=123456;float f=3.14159f;boolean b=true;Object o=null;System.out.println(String.valueOf(a));System.out.println(String.valueOf(a,2,3));System.out.println(String.valueOf(i));System.out.println(String.valueOf(f));System.out.println(String.valueOf(b)); System.out.println(String.valueOf(o));} } 6.2.4 Java应用程序的命令行参数 应用程序可以通过main方法的String数组，访问由解释器传递的命令行参数。例如： public class ShowMainArguments{ //程序6-8 public static void main(String args[ ]){ for(int i = 0;i < args.length;i++) System.out.println(args[ i ]); } } 6.3 StringBuffer类 StringBuffer类对象是一个内容可以改变的字符串。可以减少由于少量字符的插人而引起的空间分配问题。 StringBuffer类的原型： public final class java.lang.StringBuffer extends java.lang.Object { … } StringBuffer类对象有一块缓冲区，字符串被存放在缓冲区中，缓冲区的大小可以随程序的需要进行调整。缓冲区的大小称为对象的容量。 当修改对象的内容时，只要StringBuffer对象包含的字符个数没有超出容量，就不会分配新的空间，而直接在原空间内进行修改。若字符的个数超出了容量，该对象会自动调整其容量，从而适应新的存储。 6.3.1 创建StringBuffer类对象 StringBuffer类的构造函数有三种方式： 1.public StringBuffer()创建一个内容为空的StringBuffer对象，容量为16。 例如：StringBuffer s=new StringBuffer();2.public StringBuffer(int length)初始内容为空，容量为length指定的大小。注意：length应大于等于0，不能为负数，否则会产生异常。例如： StringBuffer s2=new StringBuffer(2);3.public StringBuffer(String str) 初始内容和参数str的内容相同，容量为参数str的长度加上16。例如： String s1=“Java”; StringBuffer s2=new StringBuffer(s1);则s2的容量是20，内容是“Java”。 6.3.2 StringBuffer类常用方法 1.public int length() 返回字符串的长度 2.public int capacity() 返回缓冲区大小 3.public void setLength(int newLength) 指定对象的长度，将对象的内容进行裁减。如果参数小于对象的长度，则将对象截断；如果参数大于等于对象的长度，则填充空字符('u0')扩充新增加的部分。 4.public void ensureCapacity(int NewCapacity) 设定对象的缓冲区的大小，若参数 小于对象的容量，则新的设置将不起作用，也就是说容量只能扩大而不能缩小。 程序6-9演示了这几个方法的具体应用。 public class TestCapacity{ // 程序6-9 public static void main(String args[ ]){ String s=“Java”; StringBuffer str=new StringBuffer(s);System.out.println(“Length=”+str.length());System.out.println(“Capacity=”+str.capacity());str.setLength(8); // 设置长度为8 str.ensureCapacity(80);// 设置容量为80 System.out.println(“nstr= ”+str);System.out.println(“Length = ”+str.length());System.out.println(“capacity = ”+str.capacity()); str.setLength(3); str.ensureCapacity(20);System.out.println(“nstr= ”+str);System.out.println(“Length = ”+str.length());System.out.println(“capacity = ”+str.capacity()); } } 5.public void setCharAt(int index, char ch) 将参数index指定位置上的字符，设置成参数ch 指定的字符。例如： StringBuffer str=new StringBuffer(“Hello,Java”); str.setCharAt(3,'L'); 则str的内容变成了“HelLo,Java” 6.public StringBuffer append(多种数据类型) 将其它类型的数据添加到StringBuffer对象的尾部，返回修改后的StringBuffer对象。 例如：StringBuffer s1,s2=new StringBuffer(); s1=s2;// s1和s2代表同一个对象 s2.append(3.14).append(' ').append(“Java”); System.out.println(s1==s2); // 输出true System.out.println(s1); // 输出3.14 Java 7.public String toString() 该方法把StringBuffer对象的内容复制到一个新的String类对象中，返回这个新的String类对象。例如程序6-10。 public class BufferToString{ // 程序6-10 public static void main(String args[ ]){ String s1;StringBuffer s2=new StringBuffer(“Hello ”);s1=s2.append(“Java!”).toString();System.out.println(“s1=”+s1+“"+”s2=“+s2); } } 8.public StringBuffer insert(int offset, 多种类型 b)该方法是将一个其它类型的对象b插入到offset指定的位置。例如： StringBuffer str=new StringBuffer(” Java!“); // 将字符串”Hello“插入到下标为0的位置 str.insert(0,”Hello“); System.out.println(”str= “+str);输出结果为： str= Hello Java! 6.4 略 应用举例 课堂练习： 无 课外练习（作业）： P119 2、3、4 第7章 异常处理 教学目的要求 了解异常的层次结构； 掌握异常处理语句； 了解自定义异常； 了解异常处理中常用的调试方法。主要内容 异常的层次结构； 异常处理语句； 自定义异常； 异常处理中常用的调试方法。 重点内容 异常处理语句； 难点内容 无 课时分配 1课时 教学方法 讲授法、演示法、对比法、实验验证法 讲授内容提要 7.1 异常的层次结构 Throwable是异常类的根节点，定义在java.lang包，它的子类也定义在该包中； Error代表系统错误类，由系统直接处理； Exception类及其子类是在程序中可捕捉到的异常。见图7.1 Throwable Error achineError … AW TError LinkageError VirtualM RuntimeException ArithmeticException ArrayIndexO utO fBoundsException … Interrupted Exception AWTException IOException Exception FileNotFoundException… EOFException 1.java.lang.ArithmeticException 0作除数（包括模），将产生这类异常。例如：int x=0 , y; y=100/x; 2.java.lang.ArrayIndexOutOfBoundsException 例如：int a[ ]=new int[10]; a[10]=0; 3.java.lang.ArrayStoreException 例如：int a[ ]=new int[10]; boolean b[ ]=new boolean[10]; System.arraycopy(a,0,b,3,6);//有异常 4.java.lang.ClassCastException 例如： Object obj=new Object(); int a[ ]=(int[ ])(obj); 5.java.lang.IndexOutOfBoundsException 例如：char ch=”ABC“.charAt(99); 注意: 2 是5的子类。 6.java.lang.NegativeArraySizeException 例如： int a[ ]=new int[-10]; 7.java.lang.NullPointerException 例如：int a[ ]=null; System.out.print(a.length);7.2 异常处理语句 缺省的异常处理的情况，例如： public class DefaultException{ // 程序7-1 public static void main(String args[ ]){ int a,b=0; a=2/b; // 此处有异常 System.out.println(“a=”+a);// 不运行此行 } } 异常处理语句有try、catch、finally、throw和throws。异常处理的形式为： try{ 程序执行体 }catch(异常类型1 异常对象1){ 异常处理程序体1 }catch(异常类型2 异常对象2){ 异常处理程序体2 }finally { 异常处理结束前的执行程序体 } 7.2.1 try和catch语句 try语句指明可能产生异常的代码段;catch语句在try语句之后，用于捕捉异常，一个try语句可以有多个catch语句与之匹配。异常处理以后，程序从try语句代码段后继续执行。例如：程序7-2。public class TryCatchTest{ // 程序7-2 public static void main(String args[ ]){ int a=99,b=0,c; try{ System.out.println(”产生异常之前“);c=a/b; // 该行有异常 System.out.println(”产生异常之后“);}catch(ArrayIndexOutOfBoundsException e){ System.out.println(”处理下标越界异常“);}catch(ArithmeticException e){ System.out.println(”处理算术异常“);} System.out.println(”异常处理结束“); } } 注意：用catch语句捕捉异常时，若找不到相匹配的catch语句，将执行缺省的异常处理。例如： int a=99,b=0,c; try{ c=a/b;//产生的异常和捕捉的异常类型不一致 }catch(ArrayIndexOutOfBoundsException e){ System.out.println(”处理异常“); } 注意：当有多个catch语句时，系统依照先后顺序逐个检查。例如： try{ c=a/b; }catch(ArithmeticException e){ System.out.println(”Divided by zero“);}catch(RuntimeException e){ System.out.println(”Divided by zero“);} 7.2.2 finally语句 无论是否产生异常，finally语句指明的代码一定被执行。例如： public class testFinally{ // 程序7-3 public static void main(String args[ ]){ int a,b=0; for(int i=0;i<=3;i++){ System.out.println(”Test No: “+(i+1));try{ switch(i){ } case 0: a=3/b; break;case 1: int c[ ]=new int[10]; c[10]=0; break;case 2: char ch=”ABC“.charAt(99); break;case 3: return;}catch(ArithmeticException e){ System.out.println(“零作除数！”); }catch(ArrayIndexOutOfBoundsException e){ System.out.println(”数组下标越界！“);}catch(IndexOutOfBoundsException e){ System.out.println(”下标越界！“);}finally{ System.out.println(”在finally块中！“); } } 7.2.3 throw语句 throw语句用于指出当前行有异常，当程序执行到throw语句时，流程就转到相匹配的异常处理语句，所在的方法也不再返回值。 throw语句可以将异常对象提交给调用者，以进行再次处理。例如：程序7-4。public class ThrowException{ // 程序7-4 public static void Test(){ try{ int c[ ]=new int[10];c[10]=0;}catch(ArrayIndexOutOfBoundsException e){ System.out.println(”t 数组下标越界！“); } } throw e; // 异常抛出点 //System.out.println(“t产生异常后!”); 该行无法通过编译 } } public static void main(String args[ ]){ try{ Test();}catch(IndexOutOfBoundsException e){ System.out.println(”t 下标越界！“);}finally{ System.out.println(”t 在finally块中！“);} } } 7.2.4 throws语句 throws语句指明方法中可能要产生的异常类型，由调用者进行异常处理。例如： import java.io.*; // 程序7-6 public class testThrows { public static String readString()throws IOException{ int ch;String r=”“;boolean done=false; while(!done){ ch=System.in.read(); } if(ch<0 || ch==0xd) done=true;else r = r +(char)ch; return r; } public static void main(String args[ ]){ String str; try{ str=readString();}catch(IOException e){ System.out.println(”产生了输出/输出异常“); return;} System.out.println(”整数是："+Integer.parseInt(str)); } } 建议：在多人合作写程序时，一个方法中产生的异常，最好在该方法中进行处理，不要将异常传播给其他人处理。 7.3 自定义异常类 通过继承Exception类或它的子类，实现自定义异常类； 对于自定义异常，必须采用throw语句抛出异常，这种类型的异常不会自行产生。总体上分为两步： 第1步：定义异常类。例如： class userException extends Exception{ int n=0; // 计数器 我的《最强大脑》 ——初识程序设计 一、教材分析 本节课的教学内容是初中8年级信息技术教材第9章《程序设计》第1节的内容。本节课所涉及的内容都是程序设计语言中的基本要素，虽然概念性的知识较多，但是本课的学习将为后续内容的学习打下基础，并且掌握程序的基础知识也是学好程序设计的关键。本课准备结合“乘方计算器”程序实例来让学生了解程序设计的一般过程，理解“对象”“事件”等概念。 二、学情分析 本节课虽然是第9章《程序设计》第1节的内容。学生在此之前没有接触过程序设计，因此如果让学生直接编写程序有一定的难度，因此本节课主要是让学生从建立程序界面、设置对象属性开始，体验用VB编写程序的完整步骤。第1节概念性的内容较多，学生第一次接触VB，学习任务不宜过难，还是以激发学生学习兴趣为主，初步体会如何用程序实现算法，并且通过完成学习任务的经验理解“对象”“事件”等概念的含义。 三、教学目标： 1、知识与技能 1）理解程序的含义。 2）了解VB窗口的组成，掌握建立程序界面、设置对象属性的基本方法。 3）掌握编写程序的一般过程 4）理解“对象”“属性”和“事件”的含义。 2、过程与方法 1）通过“乘方计算器”程序的模仿，让学生体验VB编写程序的完整步骤。 2）通过对“乘方计算器”程序的分析，让学生体验用程序实现算法。 3、情感态度与价值观 通过“乘方计算器”程序的演示，激发学生学习程序设计的兴趣。 4、行为与创新 逐步养成良好的程序设计习惯 四、教学过程 1、导入 (教师播放周玮参加《最强大脑》的视频） 师：视频中的主人公名叫周玮，患有先天性智力障碍，但是他对数字有着极强的敏感度，能够用大脑对任何自然数进行高次乘方或者开方运算，被称为“中国雨人”。 师：同学们想一想如果让你们算出一组数据的乘方，同学们能不能算的出来 生： 师：那么这个时候计算机能帮助我们做什么呢？曾经当我们需要统计数据的时候我们可以使用电子表格软件，当我们需要修饰文字的时候我们可以使用word，当我们需要修饰图片的时候我们可以使用美图秀秀或者PS软件，但是要解决计算乘方的问题，我们还没有一个专门的软件，这个时候我们就需要学习程序设计，自己制作一个软件，老师在课前制作了一些小软件，我们一起来看一下（教师演示乘方 解方程组 画图还有贪吃蛇软件） 那么如何设计程序呢？ 今天老师就以乘方计算器为例子就和同学们一起学习《初识程序设计》 2、认识程序 师：在认识程序之前，我们先来认识程序这个概念，我相信程序这个名词，对于我们同学们来说既熟悉又陌生，熟悉的是我们经常会用到这个词语，陌生的是很少有同学准确的能够说出它的意思。其实程序就在我们身边，同学们早晨起床、刷牙、洗脸吃早饭上学，晚上回来打开书包，拿出作业，写作业，最后将作业放回书包中，这些分步骤按顺序解决一个问题就是程序，课本上程序的概念是执行一些有序的指令完成一项具体的工作，这些有序的指令就是程序，所谓程序设计就是将解决一个问题的过程，分步骤的设计出来。那么所谓的计算机程序实际上就是让计算机按照步骤解决一个问题 3认识VB 师：计算机设计程序的软件有很多，我们今天主要学习的是VB，我们打开开始菜单，点击VB，选择标准exe程序，打开VB程序，这个就是VB的界面，上面的为菜单，左侧的工具箱，中间的区域为窗体，窗体的作用就是用来设计我们程序的操作界面的，当程序的操作界面中需要一些控件时我们可以从左侧的工具箱中选中相应的工具，在窗体中拖动出来，拖动出来的控件我们就不能称之为控件了，它有一个专门的名称叫做“对象”常用的对象有三种lable（标签对象）text（文本框对象）和command（按钮对象），现在同学们将学件中VB文件打开，打开VB文件的时候，同学们请注意我们先打开后缀名为frm的文件，然后点击窗体文件夹加载窗体，打开文件后同学们将窗体区域和我们刚刚操作的乘方计算器的操作界面比较是不是有点类似啊，只不过这个窗体缺少一个command按钮对象还有就是有的对象上的文字不一样，缺少按钮对象我们可以点击工具箱中的command控件，然后在窗体中拖动出来，那么如何改变对象显示的样子呢，这里我们要介绍到第二个概念属性，对象大小，颜色，显示的文字以及显示文字的字体都是属于属性，那么对象的属性在哪里修改呢，在界面的右侧有一个属性窗口，这里是控制对象的属性，比如说我要改变这个对象的属性，我先选中这个对象，然后在属性窗口中找到这个对象的名称，注意名称就代表这个对象，然后打开学件网页中的属性表格按照表格中的要求修改，好的，现在同学们，你们根据老师演示的方法，将窗体改成我们需要的样子。修改的时候思考这样一个问题，caption font 和text属性分别有什么样的作用。 布置任务一：根据表格改变属性 4、输入代码 师：是不是界面设计好了，我们这个程序就能用了呢？(教师演示测试程序)生： 师：我们还需要在程序中输入相对应的指令，这些指令就是告诉计算机该怎么做，我们称这些指令为代码。 我们先来分析一下这个程序：第一步我们得随机给出一个底数，第二步随机给出一个指数，构成一个完整的幂，第三步指数是几，就用多少个底数相乘，第四步算出答案，四个步骤相对应的就是4剧代码，第一句，a=text1.text，text1是指文本框1，text指的是文本框1的text属性，text属性用来表示文本框中所输入的数字，那么第一句话我们可以翻译成用字母a表示文本框1中所输入的数字，用字母b表示文本框2中所输入的数字，字母c等于a的b次方，计算幂，最后文本框3中所得输出的数字就是c，现在我们把这段代码输入程序后台（教师演示进入后台程序，有的同学刚刚设置属性时不小心在后台有代码，我们可以将其全部删掉。）生:出现错误 师：为什么出现错误？因为老师在输入数字之后还有一个动作才能够得到答案，也就是说这个动作触发了程序执行这段代码，那么这个触发程序执行的动作我们称之为事件，所以我们编写代码的的时候单纯的程序代码还不够，我们还需要选择对象和事件，对象时谁这个计算按钮，计算按钮的名称是什么command1在通用中选择comand1 事件是单击那么选择单击click，默认的就是click，然后将代码复制到这两行代码之间。然后我们再来试运行程序，就可以完成了，如果运行的没有问题，就可以结束运行，保存程序（教师演示保存程序）生: 师：最后老师还要提醒同学们，触发程序运行的动作叫做事件，但是对象不仅仅只有click这一个事件，我们还可以选择其他事件，比如说。。 5、总结 今天这节课老师和同学们一起理解了程序的含义，认识了VB软件并尝试编写了一个小程序，那么这个程序是不是就完美了呢？如果在我的数值过大的话，它还能算出正常的结果吗？那么这又是什么原音造成的呢？下节课我们继续学习解决这个问题。第五篇：初识程序设计教案
点击咨询 