admin管理员组文章数量:1531794
2024年3月9日发(作者：)
毕业设计
题 目 Android手机电子书阅读器的设计与实现
Android手机电子书阅读器的设计与实现
The design and Implementation of the Android mobile phone e-book reader
Xxx
2
毕业设计（论文）原创性声明和使用授权说明
原创性声明
本人郑重承诺：所呈交的毕业设计（论文），是我个人在指导教师的指导下进行的研究工作及取得的成果。尽我所知，除文中特别加以标注和致谢的地方外，不包含其他人或组织已经发表或公布过的研究成果，也不包含我为获得
及其它教育机构的学位或学历而使用过的材料。对本研究提供过帮助和做出过贡献的个人或集体，均已在文中作了明确的说明并表示了谢意。
作 者 签 名： 日 期：
指导教师签名： 日 期：
使用授权说明
本人完全了解 大学关于收集、保存、使用毕业设计（论文）的规定，即：按照学校要求提交毕业设计（论文）的印刷本和电子版本；学校有权保存毕业设计（论文）的印刷本和电子版，并提供目录检索与阅览服务；学校可以采用影印、缩印、数字化或其它复制手段保存论文；在不以赢利为目的前提下，学校可以公布论文的部分或全部内容。
作者签名： 日 期：
I
学位论文原创性声明
本人郑重声明：所呈交的论文是本人在导师的指导下独立进行研究所取得的研究成果。除了文中特别加以标注引用的内容外，本论文不包含任何其他个人或集体已经发表或撰写的成果作品。对本文的研究做出重要贡献的个人和集体，均已在文中以明确方式标明。本人完全意识到本声明的法律后果由本人承担。
作者签名： 日期： 年 月 日
学位论文版权使用授权书
本学位论文作者完全了解学校有关保留、使用学位论文的规定，同意学校保留并向国家有关部门或机构送交论文的复印件和电子版，允许论文被查阅和借阅。本人授权 大学可以将本学位论文的全部或部分内容编入有关数据库进行检索，可以采用影印、缩印或扫描等复制手段保存和汇编本学位论文。
涉密论文按学校规定处理。
作者签名： 日期： 年 月 日
导师签名： 日期： 年 月 日
II
注 意 事 项
1.设计（论文）的内容包括：
1）封面（按教务处制定的标准封面格式制作）
2）原创性声明
3）中文摘要（300字左右）、关键词
4）外文摘要、关键词
5）目次页（附件不统一编入）
6）论文主体部分：引言（或绪论）、正文、结论
7）参考文献
8）致谢
9）附录（对论文支持必要时）
2.论文字数要求：理工类设计（论文）正文字数不少于1万字（不包括图纸、程序清单等），文科类论文正文字数不少于1.2万字。
3.附件包括：任务书、开题报告、外文译文、译文原文（复印件）。
4.文字、图表要求：
1）文字通顺，语言流畅，书写字迹工整，打印字体及大小符合要求，无错别字，不准请他人代写
2）工程设计类题目的图纸，要求部分用尺规绘制，部分用计算机绘制，所有图纸应符合国家技术标准规范。图表整洁，布局合理，文字注释必须使用工程字书写，不准用徒手画
3）毕业论文须用A4单面打印，论文50页以上的双面打印
4）图表应绘制于无格子的页面上
5）软件工程类课题应有程序清单，并提供电子文档
5.装订顺序
1）设计（论文）
2）附件：按照任务书、开题报告、外文译文、译文原文（复印件）次序装订
III
摘要
在这个信息化的时代，计算机越来越精致，手机也越来越智能化，所以，一个较好的应用软件在很大程度上能提升一个手机的品牌。而在智能手机上安装一个拥有丰富功能支持的电子书阅读器，更是我们刻不容缓的事情。
本设计采用Android平台，根据对手机电子书阅读器的客户需求分析和技术可行性分析，经过总体设计和详细设计编码测试等阶段，完成了电子书阅读器软件的设计。不仅实现了电子书阅读器最基本的阅读功能，而且还为用户提供了丰富的功能支持，包括找书，书签，自动翻页以及阅读界面设置的操作。而本次设计最大的特点则是通过屏幕触控实现了移动时的翻页特效。经过不断的测试与完善，电子书阅读器功能稳定，并且在真机上对其进行了测试与验证，基本上达到了用户的需求标准。
关键词： Android；电子书阅读器；屏幕触控；翻页；
IV
Abstract
In the time of information technology, with the increasingly sophisticated of computers and
more and more intelligent of mobile phones, a better application software can enhance a brand of
the phone to large extent. It is our urgent for us that installed on the smart-phone has a rich
functionality to support the e-book reader.
Based on the needs analysis of customers and technical feasibility analysis, I use the Android
platform to achieve the design of mobile phone’s e-book reader. After completing the overall design
and detailed design coding testing stage, I achieved the design of the e-book reader software. Not
only can the soft achieve the basic function of E-book reader, but also offer many other functions
for users, including books and bookmarks, flipping pages automatically and designing the reader.
The significant character of the design achieve the flipping page of mobile by touching screen
Through continuous testing and improvement, E-book reader is stable. The testing and verification
in real device has carried out to meet the customers’ requirements which have reached the standards
of the customers’ requirements.
Key words: Android; e-book Reader; Touch Screen; Flip
目 录
V
第1章 前言 ........................................................................................................................................ 1
1.1
课题提出的背景目的及意义 ................................................................................................... 1
1.1.1 课题提出的背景 ................................................................................................................ 1
1.1.2 课题提出的目的 ................................................................................................................ 1
1.1.3 课题提出的意义 ................................................................................................................ 1
1.2
设计思路及研究方法 ............................................................................................................... 2
1.2.1 设计思路 ............................................................................................................................ 2
1.2.2 研究方法 ............................................................................................................................ 2
第2章 需求分析 ................................................................................................................................ 2
2.1
软件的基本功能要求 ............................................................................................................... 3
2.2系统架构 .................................................................................................................................... 4
2.3
开发环境 ................................................................................................................................... 4
第3章 软件设计 ................................................................................................................................ 5
3.1
总体软件结构设计 ................................................................................................................... 5
3.2
接口设计 ................................................................................................................................... 7
3.2.1 外部接口 ............................................................................................................................ 7
3.2.2 内部接口 ............................................................................................................................ 8
3.3
数据库设计 ............................................................................................................................... 8
3.3.1 数据模式设计 .................................................................................................................... 8
3.3.2 数据表格设计 .................................................................................................................... 8
3.3.3 表的具体设计 .................................................................................................................... 9
3.3.4 数据字典 ............................................................................................................................ 9
3.4
软件设计模型 ......................................................................................................................... 10
3.5
代码设计 ................................................................................................................................. 11
3.6
软件维护设计 ......................................................................................................................... 12
第4 章 系统功能模块的设计与实现 ............................................................................................. 12
4.1
关键技术 ................................................................................................................................. 13
4.1.1 android平台及java语言 ................................................................................................. 13
4.1.2 中介软件 .......................................................................................................................... 13
4.1.3 四大组件 .......................................................................................................................... 14
4.1.4 sqlite3 数据库 .................................................................................................................. 14
VI
4.1.5 Tomcat服务器 .................................................................................................................. 14
4.2
欢迎界面的实现 ..................................................................................................................... 15
4.3
主控制类的实现 ..................................................................................................................... 15
4.4工具类的设计 .......................................................................................................................... 16
4.5
阅读界面的实现 ..................................................................................................................... 16
4.6
找书功能的实现 ..................................................................................................................... 17
4.7
书签功能的实现 ..................................................................................................................... 18
4.8
设置字体大小功能的实现 ..................................................................................................... 19
4.9
更换背景图片以及设置字体颜色功能的实现 ..................................................................... 20
4.10
音乐播放功能的实现 ........................................................................................................... 20
第5章 系统测试 .............................................................................................................................. 20
5.1
欢迎界面 ................................................................................................................................. 21
5.2
用户阅读界面 ......................................................................................................................... 21
毕业设计总结 .................................................................................................................................... 30
参考文献 ............................................................................................................................................ 31
附录一 核心代码 .............................................................................................................................. 32
附录二 毕业设计外文翻译（英文） .............................................................................................. 34
附录三 毕业设计外文翻译（中文） .............................................................................................. 42
致谢 .................................................................................................................................................... 48
VII
第1章 前言
1.1 课题提出的背景目的及意义
1.1.1 课题提出的背景
在这个信息化的时代， IT业已经成为世界发展的主流，我们对信息技术的依赖远远超过了对我们自己的依赖，计算机和手机已经成为我们日常生活中不可缺少的获得信息的渠道。正因为如此，各种各样的软件层出不穷，我们的生活也因为各种各样的软件变的更有滋有味。不缺乏娱乐性，也不缺乏教育意义，让我们从这些软件中受益匪浅，使我们看到了相比以前的巨大进步。同时，随着科技的发展，计算机越来越精致，手机也越来越智能化，所以我们的依赖性也越来越大，越来越离不开这些给我们提供日常信息的工具。手机也已不再仅仅是简单的人与人通话的工具，而是在很大程度上成为了我们获取信息的一个更好的渠道。一个好的软件，能够标志一个手机品牌的地位。所以，开发一款好的手机软件是相当必要的。以前我们看看杂志，小说都要去图书馆借阅，而且时间有限，很不方便；而现在是在电脑上或者手机上看杂志，看小说，文档。以此看来，一个好的手机阅读器软件的开发是相当有必要的。
1.1.2 课题提出的目的
此次设计的目的很明显，就是给予阅读者更大的便利性，阅读者不用再到处拿着一本厚厚的书籍，大大减少了读者的负担，只需要下载一本txt格式的电子书，放在sd卡里边，就是人们的生活百科。当然，有些下载不来的资料，还是需要翻阅书籍的。
1.1.3 课题提出的意义
计算机改变了人类的工作方式，互联网创造着全新的生活空间，我们接受信息的方式也正在发生深刻的质变。由于现在阅读器的越来越普及，我们每天清晨读报的习惯也在面对大资讯量的新闻网站时渐渐淡化，面对印刷出版物，我们仍视之为文化传承的载体，但不可抵挡的，是无纸化电子阅读时代的悄然临近。我们现在信息化的生活，充斥着信息的传递，但是，越来越多的人依赖于几乎朝夕相伴的手机。虽然，现在也出现了供人们阅读使用的电子书，但是这些电子书的功能很少很简单，仅仅是简简单单的供人们一行一行的阅览文字信息，或者是仅仅添加一个添加书签的小功能，根本远远不能满足人们的需求。于是，一个功能良好的全面的电子书阅读器越来越成为广大用户的追求。本软件是基于android系统智能手机开发的一款电子书阅读器软件，它有一个阅读主界面，主要用来阅读文档。其优越性表现在实现了从SD卡读取文档或从服务器端下载文档，自动翻页，添加书签，选择书签，清空书
1
签，设置背景音乐，设置背景图片，设置字体颜色，设置字体大小等功能。此外，给用户更清晰方便的界面，也是本软件的出发点之一。
1.2 设计思路及研究方法
1.2.1 设计思路
阅读器的设计流程主要是按照软件设计的一般流程：需求分析、概要设计、详细设计、测试与维护的基本流程来设计开发的。首先，从整体分析软件功能，将功能模块化；然后对每个模块进行调试。最后对各个模块进行系统集成。
通过几个月的观察，发现几乎所有的人都有手机，而且几乎有一半以上的人用手机来阅读资料。可是这些阅读软件不尽人意，而且一个好的阅读软件也还没有安装在智能手机上。本系统针对这一点进行了较仔细的分析，在老版的阅读软件基础之上进行改进，最后，对系统进行了实现和维护。
1.2.2 研究方法
本系统在整体框架研究方法采用的是问卷调查法和观察研究法。而在总体设计上采用的是结构化方法，在局部底层开发上为便于交流采用快速原型法。
问卷调查法也称问卷法，它是调查者运用统一设计的问卷向被选取的调查对象了解情况或征询意见的调查方法。观察研究法指根据既定的研究目的，对现象或行为做有计划与有系统的观察，并依观察的记录对现象或行为做客观性的描述和解释。
结构化系统的设计方法是在结构化程序设计思想基础上发展起来的，它的基本涵义是一个系统由层次化的程序模块构成，每一个模块只有一个入口和一个出口，每一个模块只归其上一级模块调用，并有模块连接的准则和构造模块的标准，而且用系统结构图来表达系统的结构，尽可能用最优的方式将系统内各部分组织起来。
第2章 需求分析
2
2.1 软件的基本功能要求
经过以上问卷调查和观察研究方法，在现行业务流程和数据分析的基础上基本上确定了系统的功能，设计也基本上达到了目标。根据软件设计的步骤，需求分析是软件设计成功的基础，也是必不可少的步骤。同时，也对软件的设计提出了具体的要求。在做足了充分的调查研究之后，基本可以确定软件的功能界面如下：
（1）刚打开软件时的欢迎动画界面。
（2）在没有阅读记录情况下打开软件时进入的软件说明界面。
（3）在主界面下单击“菜单”按钮后弹出的欢迎主菜单界面。
（4）找书选择界面，用来选择找书的途径。
（5）网络下载列表界面，用来列出服务器端可供下载的文档。
（6）下载完成提示界面，用户从服务器端完成指定文档下载任务时显示的界面。
（7）已存在要下载文件提示界面，当用户指定要下载的文档在SD卡中已存在时显示的界面。
（8）SD卡文件列表界面，列出SD卡中存在的所有资料。
（9）阅读界面，用来阅读文档的主界面，是整个阅读器设计核心部分。
（10）书签功能界面，用来选择与书签相关的具体操作。
（11）添加书签功能界面，将当前阅读到的位置以书签名和书页号的形式存至书签表，
方便下次阅读。
（12）选择书签功能界面，通过选择书签记录跳转至想要阅读的位置。
（13）删除书签功能界面，再不想要该条书签记录的情况下实现删除操作。
（14）自动翻页功能界面，实现不同时间间隔自动翻页的效果。
（15）设置界面，用来选择对阅读界面不同的设置。
（16）背景音乐界面，可在阅读的同时欣赏音乐，更大限度的提升。
（17）背景图片界面，用来设置不同的阅读界面风格，使阅读更为个性化。
（18）字体颜色界面，用来设置不同的阅读字体颜色，提升用户的视觉体验。
（19）字体大小界面，通过设置字体大小来满足实际应用中的多重需求。
基本说明如下：
本系统是一个电子书阅读器，主要包含一个主界面，用来实现阅读的功能。在阅读界面
3
时，点击menu，手机底部会出现四个选项：找书、书签、自动翻页、设置。点击找书选项会有两种操作可供选择，分别是在SD卡中找书和通过网络下载；点击书签选项会有三种操作可供选择，分别为添加书签、选择书签和清空书签，其中长按选择书签列表中的某条书签记录也可达到删除该条记录的目的；点击自动翻页选项会有四种操作可供选择，分别为每隔30秒、40秒、50秒自动翻页和停止自动翻页；点击设置选项会有四种操作可供选择，分别为设置背景音乐、设置背景图片、设置字体颜色和设置字体大小，为此用户可通过自己的喜好来设置不同阅读界面的风格，并且可以选择自己喜爱的音乐作为背景音乐，在阅读的同时欣赏。
2.2系统架构
本设计总体逻辑结构层次划分如图2.1所示。
电子书阅读器menu找书书签自动翻页设置SDCARD网络添加书签选择书签清空书签三十秒四十秒五十秒停止自动翻页背景音乐背景图片字体颜色字体大小
图2.1 功能结构图
2.3 开发环境
➢ 数据库
由于本设计和数据库密切相关，但是对数据库的要求不高，因此可用Android系统本身自带的Sqlite数据库。
➢ Android SDK与Eclipse开发的插件ADT
由于本设计是基于Android系统的，而Android开发环境的搭建是基于Eclipse的，因此需要下载Android SDK与Eclipse开发的插件ADT。
➢ 服务器
由于本设计需要用服务器来为其提供下载服务，而且对服务器的要求不高，因此在设计时用Tomcat作服务器。
4
第3章 软件设计
3.1 总体软件结构设计
打开电子书阅读器之后，软件会先查看上次阅读的最后记录，以此作为根据来进行判断
5
从而跳转至相应的阅读界面。然后用户就可在阅读界面下通过选择menu来执行想要的操作：找书、书签、自动翻页、设置。点击找书选项会有两种操作可供选择，分别是在SD卡中找书和通过网络下载；点击书签选项会有三种操作可供选择，分别为添加书签、选择书签和清空书签，其中长按选择书签列表中的某条书签记录也可达到删除该条记录的目的；点击自动翻页选项会有四种操作可供选择，分别为每隔30秒、40秒、50秒自动翻页和停止自动翻页；点击设置选项会有四种操作可供选择，分别为设置背景音乐、设置背景图片、设置字体颜色和设置字体大小，为此用户可通过自己的喜好来设置不同阅读界面的风格，并且可以选择自己喜爱的音乐作为背景音乐，在阅读的同时欣赏。
根据各个模块的不同功能，对本设计进行了层次结构的划分。在Eclipse下创建了一个名为Test的工程，工程的结构图如图3.1：
图3.1 软件工程结构图
该功能包是通过Android SDK自动生成的，主要包括以下内容：
（1）src源代码目录：该目录存放Android应用程序所有的源代码。该目录项有不同的包，包中对应开发的源代码，开发过程中的主要精力都集中在开发src目录下内容。
6
（2）gen文件夹目录：该目录存放了Eclipse的ADT插件自动生成的文件。实际上定义了一个R类，它包含了应用中用户界面、图像、字符串等各种资源与之相对应的资源编号（id）。这些资源编号都是系统自动生成的，即有一资源对象，系统就为此在R类中生成相应资源编号，好比一本字典。
（3）Res资源目录：该目录定义了drawable、layout及values 3个目录。
a. drawable目录：该目录下有drawable-hdpi，drawable-ldpi，drawable-mdpi3个文件夹，分别用来存放不同分辨率的图片资源，用于不同分辨率 的手机的开发，可以通过wable(id)获得该资源。
b. layout目录：该目录下包含了所有使用XML格式的界面描述文件。主要用于
表述应用程序的用户界面布局，也用于描述用户界面和接口组件。
c. values目录:该目录包含了使用XML格式的参数描述文件，也可以在此添加一些额外的资源，如字符串、颜色、样式和数组等。主要用于在代码中通过R类来调用它们，而不直接使用，这样可将代码和资源分开管理，便于维护。
除了以上文件夹外，还用一个文件，该文件是系统的控制文件，告诉系统如何处理创建的所有顶层项目，尤其是Activity，凡是需要用到的组件都要在此注册。同时该文件也是所有Android应用程序都需要的文件，其描述了程序包的全局变量，包括公开的应用程序组件和每个组件的实现类，什么样的数据可以操作，在什么地方可以运行等。
在这个文件中最重要的一个内容就是Intent过滤器，这些过滤器描述了何时、何种情况下让Activity启动。当一个Activity（或操作系统）想要执行一个动作，它将创建一个Intent对象。该对象包含了很多描述符，描述了想做的操作，像处理数据，数据的类型，以及一些其他的信息。Android将Intent对象中的所有公开的Intent过滤器比较，找到一个最能恰当处理请求的数据和动作的Activity。
3.2 接口设计
3.2.1 外部接口
在用户界面部分，根据需求分析结果，用户需要一个友善界面。在界面设计上，应做到简单明了，易于操作，并且要注意到界面的布局，应突出的显示重要以及出错信息。在界面设计部分，本系统按照Microsoft公司的用户界面设计标准，为用户提供友好、方便、直观、简洁的操作环境。
本系统采用了窗口继承的方式，使窗口有统一的界面风格。同时，对错误信息、提示信息进行标准化，尽量做到清晰明了。
7
3.2.2 内部接口
系统在功能模块的设计上，以“高内聚、低耦合”为设计目标。内部接口方面，各模块之间采用函数调用、参数传递、返回值的方式进行信息传递。具体参数的结构将在下面数据结构设计的内容中说明。接口传递的信息将是以数据结构封装的数据、参数传递或返回值的形式在各模块间传递。
3.3 数据库设计
3.3.1 数据模式设计
一共设计了3张表，是：
（1）阅读记录表（阅读记录的ID，书的路径，阅读记录数据）
（2）书签表（书签的ID，书签对应的阅读记录的ID，书签名，书页）
（3）上次阅读记录表（上次阅读记录的ID，书的路径，上次阅读到的书页，上次阅读时的字体）
数据库表的设计如下：
图3.2 数据库结构图
3.3.2 数据表格设计
本数据库用的是一个小型数据库sqlite3，在数据库中创建了三个表格。即BookRecord、BookMark和LastTimePage，分别用来存放阅读记录的数据、书签的数据和上次的阅读记录数据。具体内容如表3-1、表3-2和表3-3所示：
表3-1 阅读记录表
字段名称
rid
path
data
数据类型
Integer
文本
字节数组
字段大小
8
50
不定
是否主键
是
否
否
说明
阅读记录的ID
书的路径
预读记录数据
8
表3-2 书签表
字段名称
mid
ridfk
数据类型
Integer
Integer
字段大小
8
8
是否主键
是
否
说明
书签的ID
书签对应的阅读记录的ID
bmname
page
文本
Integer
50
8
否
否
书签名
书页
表3-3 上次阅读记录表
字段名称
lid
path
page
fontsize
数据类型
Integer
文本
Integer
Integer
字段大小
8
50
8
8
是否主键
是
否
否
否
说明
上次阅读的记录ID
书的路径
上次阅读到的页数
上次阅读的字体大小
3.3.3 表的具体设计
表名：BookRecord
表中字段名称：rid, path, data.
说明：用varchar类型存储path，blob类型存储相应的路径下的阅读过程，并规定rid为阅读记录表的主键。
表名：BookMark
表中字段名称：mid, ridfk, bmname, page.
说明：创建书签mid为integer类型主键，定义书签名字bmname为varchar类型，书页号page为integer类型的书签表。
表名：LastTimePage
表中字段名称：lid, path, page, fontsize.
说明：创建书签lid为integer型主键，定义路径path为varchar类型，书页号page为integer类型，字体大小为integer类型的上次阅读记录表。
3.3.4 数据字典
数据字典是物理数据库的具体体现。
表3-4 BookRecord数据字典
9
字段名
阅读记录的ID
书的路径
阅读记录数据
类型
整型
文本
字节数组
表3-5 BookMark数据字典
字段名
书签的ID
书签对应的阅读记录的ID
书签名
书页
类型
整型
整型
文本
整型
表3-6 LastTimePage数据字典
字段名
上次阅读记录的ID
书的路径
上次阅读到的页数
上次阅读时字体大小
类型
整型
文本
整型
整型
3.4 软件设计模型
建立系统数据模型的主要工具是实体——关联图，即E-R图。
E-R图的图形符号约定如下表：
表3-7 E-R图图形符号
10
图形符号说明 表示实体集合 表示属性 表示关系集 将属性连接到实体集或将实体集连接到联系集
阅读记录ID书的路径阅读记录数据阅读记录
图3.3 存储阅读记录的E-R图
图3.4 存储书签的E-R图
图 3.5 存储上次阅读记录的E-R图
3.5 代码设计
11
代码是按使用的目的，表示识别、分类、排序数据的数字、文字或符号。识别是将文件中存储数据区别开，或将文件中的数据按组区别开，识别主要用数据更新与查找。分类是根据数据编码中的定义对数据分类，用于检索数据或统计分析。排序是根据编码规则，按代码中规定的次序排序，用于输出与生成报表。
3.6 软件维护设计
采用MVC设计模式，将UI层和业务逻辑层分离开来，采用针对接口编程的方式，降低了代码之间的耦合度，便于软件的升级和程序性能的优化。
第4 章 系统功能模块的设计与实现
12
4.1 关键技术
4.1.1 android平台及java语言
以下图表展示了Android操作系统的主要组成部分：
图4.1 Android系统架构图
本系统是以java为编程语言，从接口到功能，灵活多变。主要运用的是Activity之间的相互跳转，然后利用Intent实现多个程序同时运行的效果。运行中如果某个Activity的画面被另一个Activity所取代，则这个Activity停止。本系统通过把View类与XML（可扩展标记语言）将用户界面放置在视图窗口，然后注册事件来完成相应的功能。例如，当视图要处理用户的点击事件的时候，android就要向框架注册一个OnClickListener等。本系统中触发事件都是通过这种来实现的。 Java语言是一种简单易用，面向对象的，可移植的语言。它具有很多的优越性和特点，比如：平台无关性，安全性，面向对象，健壮性等等。本系统就是在android平台上使用java语言完成的系统。
4.1.2 中介软件
中介软件是android操作系统应用程序的桥梁，主要分为函数和虚拟机。Android的数据存储采用sqlite3数据库系统，用户可以用ContentProvider类获取数据。android中数据存储技术主要有：文件存储、preference、sqlite、ContentProvider和网络存储，在本软件中主要使用到了文件存储、sqlite和ContentProvider，文件存储是以流的形式读写文件，可以以文格的格式，也可以以二进制的形式，在java语言中要使用流，则写入文件的对象必须进行序列
13
化，sqlite是嵌入式移动设备中常用的轻量级数据库，可看作计算机上使用的sql server、oracle数据库。本软件中，用户生词本中的数据都存在sqlite数据库中，而进行数据备份和恢复时则是用文件作为介质保存数据。
4.1.3 四大组件
Android的四大组件是支持android应用程序显示，跳转，服务和事件的重要工具，它们主要是：Activity（活动），Intent（意图），Service（服务），ContentProvider（内容提供器）。Activity是一个用户的界面基类，属于UI。一个Activity就是一个类，每个Activity类都需要继承Activity基类，并与其他控件结合使用。Intent实现Activity、service等之间的跳转和数据传输。Service是后台服务，为用户提供数据支持。ContentProvider负责数据的存储和读取。在android中，软件UI通常使用xml技术设计，而xml中控年的位置和状态则离不开布局的使用，android中常用的布局有5种，分别是：AbsoluteLayout、LinearLayout、RelativeLayout、FrameLayout、TableLayout，由于布局的使用，并且布局之间可以互相嵌套，使得android软件UI的设计变得非常灵活，即使是一些非常复杂的界面设计，只要合理的使用布局，也会使开发变得很容易。
4.1.4 sqlite3 数据库
Sqlite3是建立在android平台上的一个数据库，除了支持varchar（n）（可变字符），
char（n）（定长字符）等数据特性外，还支持空（NULL），整型（INTEGER），文本类型（TEXT）等数据类型。它的特点入下：轻量级（只需带上很小的动态库，就能享受它的全部功能）、独立性（使用不需要安装，在部署的时候能省去很多麻烦）、隔离性（数据库中所有的信息都包含在一个文件内，方便管理和维护）和安全性（可以同时读取数据，但同时只有一个能够写入数据）等特性。
4.1.5 Tomcat服务器
服务器的架设：
（1）在/下载合适版本的Tomcat。
（2）在/apache-tomcat-5.0.28/webapps目录下新建文件夹txt。
（3）在txt文件夹下创建文本文件txt_。
（4）在txt_下写入内容。
（5）根据txt_的内容，创建文本。
（6）打开/pache-tomcat-5.0.8/bin目录。
14
（7）打开/pache-tomcat-5.0.8/bin目录下的。
（8）打开浏览器，在地址栏输入localhost:8088/，效果如图4.2所示：
图4.2 bin目录图
4.2 欢迎界面的实现
本模块主要完成阅读器欢迎界面的渐变效果显示，在进入程序界面时首先调用。该功能的实现主要是通过绘制黑色矩形，然后对其进行平面贴图，并通过不断的更改图片的透明值来实现的。
4.3 主控制类的实现
ReaderActivity类是主要控制程序运行的类，实现了各个界面的有序切换，各个按钮和对话框的监听事件，加载了程序中用到的相关资源，有效地控制了程序的运行。
（1）onCreate方法是程序运行时，进入主界面前调用的方法，在此方法中对程序中用到的相关变量进行赋值，并为相关类创建对象，以方便调用。
（2）onKeyDownf方法是重写父类的onKeyDown方法，当按下不同的键时，此方法设计返回键（4号键）和Menu键（82号键），并且本设计中支持屏幕触控事件和键盘监听事件。
（3）onCreateOptionsMenu方法表示的是程序运行时，用户按下键盘上的Menu键后，显示的找书、书签、自动翻页和设置的按钮选项，当用户按下不同的键后，弹出相应的对话框。
（4）sendMessage方法表示各个界面相互跳转时调用的方法和不同线程之间传递消息的方法。
15
（5）isWhichTime方法用以判断是否为第一次打开程序，如果是，则程序中的变量值为默认值；若不是第一次打开，则获取上一次打开时设置的值。
（6） saveCurrentData和savePreference方法表示当程序退出、换书和第一次打开一本书时都要想数据库中BookRecord表中插入数据，第一次打开一本书时，向数据库中插入数据是因为，如果表中不存在当前书的信息，则无法存书签。
4.4工具类的设计
（1）Constant类存放了整个设计过程中，大部分类经常用到的常量值，如字体大小、
字体颜色、屏幕的宽和高等。将这些常量值放在一起，不但方便了设计，而且方便管理。
（2）加载文本的工具类TextLoadUtil的设计主要是为文本的读入提供方法。
4.5 阅读界面的实现
ReaderView类主要负责自适应屏、绘制阅读器的主界面、实现键盘和屏幕的触控事件以及实现翻页功能。
（1）surfaceCreated方法主要负责成员变量的初始化工作。
（2）onDraw方法负责标题、广告条、左右页面等图片的绘制。其中广告条的绘制是动态的，在广告条线程中值需要更改图片数据下标志值NUM。
（3）onTouchEvent方法负责处理屏幕触控事件，屏幕触控事件为移动是翻页特效的实现。
（4）drawPage方法负责根据阅读记录对象ReadRecord绘制左右两页面。
欢迎界面是第一次打开该软件？否是在说明界面退出了软件？否软件说明界面进入上次阅读到的阅读界面
图4.3 从用户进入软件到阅读界面时的流程图
16
确定文件读取的起始位置计算本页字数读取相应长度字符并制作bitmap图片显示生成左右相邻的两页图片用户点击点击屏幕左下角点击屏幕右下角跳转下一页面跳转上一页面
图4.4 用户在阅读界面时的操作流程图
当用户进行阅读界面的时候，首先阅读控制模块会根据用户之前阅读到的位置来确定载入电子书文本的起始位置，然后会根据手机终端屏幕大小和字体大小来确定该页应该显示多少文字。在获取文字长度之后，会读取相应长度的字符并以此为基础生成左右相邻两页内容的bitmap图片。用户在阅读的时候可以触摸屏幕的不同位置进行不同操作，左下角是往前翻页，右下角是往后翻页。
4.6 找书功能的实现
找书功能分为在SDCARD中和在网络中找书。
（1）在SDCARD中找书
用户可以将已有的txt格式的书放在SDCARD中，通过本阅读器的在SDCARD中找书的功能将书加载进阅读器进行阅读，具体步骤如下：按下Menu键，在主界面中弹出的选项中选择找书，弹出找书对话框，选中SDCARD，即可根据当前路径获得对应文件数组，并将数组中的所有文件加入到文件列表中，然后再为文件列表添加监听，从而实现在点击某一文件时跳转至对应页面的功能。
（2）在网络中找书
本阅读器不仅提供了在本地找书的功能，而且也支持在网络中找书。具体步骤如下：
当单击在网络中找书的按钮时，调用downTxt方法下载txt文档。
17
阅读界面用户点击找书SDCARD网络列出SDCARD中书的目录列出可下载目录选择要阅读的书选择要下载的书正在阅读的书？否跳至所选书最后一次阅读到的界面是SDCARD中已存在？否是返回当前阅读界面下载至SDCARD 提示信息：已下载
图4.5 用户找书时的操作流程图
4.7 书签功能的实现
（1）添加书签功能的实现
在本设计的书签功能中有很多漂亮的Dialog，这些Dialog是通过xml文件自己布局的或者是通过Java代码自定义实现的。其中文件设置了Dialog的背景图片和标题格式，是设置对话框属性的文件。在完成了输入书签对话框所需要继承的类、布局文件和对话框属性的文件之后，创建了书签输入对话框，并通过onPrepareDialog方法为自定义的输入书签对话框中的按钮添加了监听。
（2）选择书签功能的实现
选择书签对话框不同于添加书签对话框，是用Java代码实现的。具体的实现步骤如下：
a. 在数据库中取出所有书签的名字和页数的索引值，并分别放入两个数组tempname和temppage中，用来放入书签列表中显示。
b. 用Java代码编写列表对话框，并且为ListView添加内容适配器，将在数据库中取
18
出的书签名称和其对应的页数的索引加入到ListView中。
c. 当单击选择书签对话框中的某一项时，得到当前的页数，根据页数查找HashMap，找到相应的BookMark类的对象，从而知道要跳转到的页的索引值。
d. 当长时间按住选择书签对话框中的某一项时，弹出“是否删除这条记录”的对话框，如果单击“确定”按钮，则会删除这条记录，单击“取消”按钮则不会删除记录。
阅读界面用户点击书签添加书签选择书签清空书签输入书签名存在书签？是否否存在书签？确定列出书签列表提示信息：请先添加书签！提示信息：确定要清空所有书签？选择某一条书签记录长按某一条书签记录跳转至书签标记的阅读界面提示信息：确定要删除该条记录？
图4.6 书签功能操作流程图
4.8 设置字体大小功能的实现
字体大小对话框与选择书签对话框的设计基本相同，也是通过Java代码为对话框中控件的摆放形式设置布局。当单击小号、中号、大号字体后，如果当前字体与要变换的字体相同，则不发生变化，否则将字体的大小和中英文间距重新赋值，然后重新绘制当前界面。
字体大小变化后书签和HashMap的更新：
（1）updataBookMarkAndHashMap方法负责字体大小变化后，更新书签和HashMap。
19
（2）drawVirtualPage方法是字体大小变化后，书签和HashMap更新过程中，虚拟绘制主界面中每一页信息，并且为下一页的Left_Start的值赋值的方法。
4.9 更换背景图片以及设置字体颜色功能的实现
（1）更换背景图片功能的实现
a. 为了使对话框看起来更美观，为对话框中的按钮设置背景图，同时背景图与要设置背景一致，为用户提供参考。
b. 为按钮添加监听，使单击按钮后，可以实现更换阅读内容背景的图片。
c. 设置要更换的图片，并规定图片加载的属性，用到了PicLoadUtil 这个工具类的
方法来实现图片自适应。
d. 重新绘制左右两侧背景图片上的文字。
（2）设置字体颜色功能的实现
a. 为了使对话框看起来更美观，为对话框中的按钮设置背景图，同时背景图与要
设置字体颜色一致，为用户提供参考。
b. 为按钮添加监听，使单击按钮后，可以实现重新设置阅读界面字体颜色。
c. 完成字体颜色设置，返回到当前阅读界面继续阅读。
4.10 音乐播放功能的实现
（1）完成自定义对话框的设计。
（2）将曲目导入ListView，为其添加监听，同时实现控制音乐播放与停止的功能。
（3）当音乐播放器为空或正在播放曲目二，则更改播放曲目一，在为其设置播放模式后，播放曲目，否则是否播放器，最终返回阅读主界面。
第5章 系统测试
20
5.1 欢迎界面
打开本系统，首先进入的是欢迎界面，效果如图5.1和图5.2所示。
图5.1 欢迎动画界面1
图5.2 欢迎动画界面2
5.2 用户阅读界面
21
若为第一次打开软件，则在欢迎动画播放完后进入软件说明界面，效果如图5.3所示。
图5.3 软件说明界面
单击“菜单”按钮弹出主菜单，效果如图5.4所示。
图5.4 阅读界面的menu功能
在主菜单中单击“找书”按钮进入找书选择界面，效果如图5.5所示。
22
图5.5 找书界面
在找书选择界面，单击“网络”按钮，进入网络下载列表，效果如图5.6所示。
图5.6 网络下载列表界面
选择某一文本并单击，下载完毕后弹出提示信息，效果如图5.7所示。
23
图5.7 下载完成提示信息
如果下载文件已存在，弹出提示界面，效果如图5.8所示。
图5.8 存在要下载文件提示界面
在找书选择界面，单击“SDCARD”按钮，进入SDCARD文件列表，效果如图5.9所示。
24
图5.9 SDCARD文件列表界面
在SDCARD文件列表中选中某文本后，单击进入阅读界面，效果如图5.10所示。
图5.10 阅读界面
在主菜单中单击“书签”按钮进入书签功能界面，效果如图5.11所示。
25
图5.11 书签功能界面
在书签功能界面中单击“添加书签”按钮进入添加书签界面，效果如图5.12所示。
图5.12 添加书签界面
在书签功能界面中单击“选择书签”按钮进入选择书签界面，效果如图5.13所示。
26
图5.13 选择书签界面
在书签功能界面单击“清空书签”按钮进入清空书签界面，效果如图5.14所示。
图5.14 删除书签界面
在主菜单中单击“自动翻页”按钮进入自动翻页界面，效果如图5.15所示。
27
图5.15 自动翻页界面
在主菜单中单击“设置”按钮进入设置界面，效果如图5.16所示。
图5.16 设置界面
在设置界面中单击“背景音乐”按钮进入背景音乐界面，效果如图5.17所示。
28
图5.17 背景音乐界面
在设置界面中单击“背景图片”按钮进入背景图片界面，效果如图5.18所示。
图5.18 背景图片界面
在设置界面中单击“字体颜色”按钮进入字体颜色界面，效果如图5.19所示。
29
图5.19 字体颜色界面
在设置界面单击“字体大小”按钮进入字体大小界面，效果如图5.20所示。
图5.20 字体大小界面
毕业设计总结
30
经过测试，本设计的所有模块均可正常运行，并且达到了预期的效果。与此同时本设计还存在着很多的不足。在此，我对其特点和不足作些阐述。
特点：本设计以java为开发语言、sqlite3数据库作为后台支撑，很好的解决了实际开发中遇到的技术问题。本设计的界面特点：界面友好、易于操作维护，采用了大量的人机交互式操作，能很好的完成阅读的全过程，使浏览者一进入就可以独立的进行自己需要的操作，一目了然。本设计实现了从SDCARD找书或从服务器端下载新书，添加书签，选择书签，清空所有书签，清空某一条书签，自动翻页，设置背景音乐、背景图片，更改字体颜色、字体大小，加载广告信息的功能，能够让读者很顺利的达到阅读的目的，且不会影响阅读的进度，在很大程度上给予了极大的方便。通过最终的运行，可以达到省时的目的，方便，快捷，仿真翻页，记录阅读者最后一次阅读的信息并在下次打开时自动初始化到上次阅读到的界面是本设计最大的特点。
不足：在本设计中只有将服务器端的新书下载至SDCARD中才可供读者阅读，未能实现在线阅读的功能，不能充分利用资源；SDCARD中存储的文件名只能以英文的形式存在，从而使得在SDCARD找书界面中的书名只能以英文形式出现。
由于水平有限，难免有不足之处；设计中也还存在不完善之处，有待改进。
参考文献
31
[1] 杨丰盛.Android应用开发揭秘[M].北京:机械工业出版社,2010.1.
[2] 王家林.大话企业级Android应用开发实践[M].北京:电子工业出版社,2011.8.
[3] 王永松.Android平台开发之旅[M].北京:机械工业出版社,2001.1.
[4] 佘志龙.Android SDK开发范例大全[M].北京:人民邮电出版社,2010.6.
[5] 吴亚峰.Android应用案例开发大全[M].北京:人民邮电出版社,2012.10.
[6] 郭宏志. Android应用开发详解[M].北京:电子工业出版社,2010.
[7] 吴亚峰.Android核心技术与实例详解[M].北京:电子工业出版社,2010.10.
[8] 李芝兴.Java程序设计之网络编程[M].北京:清华大学出版社,2009.8.
[9] 张白一,崔尚森.面向对象程序设计[M].西安:西安电子科技大学出版,2006.01.
[10] 张孝祥.Java就业培训教程[M].北京:清华大学出版社,2007.07.
[11] 李兴华.Java开发实战经典[M].北京:清华大学出版社,2009.08.
[12] 李钟尉,周小彤.Java从入门到精通[M].北京:清华大学出版社,2010.07.
[13] 孙鑫.Java Web开发详解[M].北京:电子工业出版社,2006.04.
[14] 阎宏.Java与模式[M].北京:电子工业出版社,2002.10.
[15] 埃史尔,陈昊鹏.Java编程思想[M].北京:机械工业出版社,2007.06.
[16] 王世江,盖索林.Google Android开发入门指南[M].北京:人民邮电出版社,2009.11.
[17] 李刚.疯狂Android讲义[M].北京:电子工业出版社,2011.6.
[18] Reto sional Android2 Application Development[M].北京:清华大学出版社,
2010.12.
[19] Rick Rogers,Blake Meike,Ziqurd d应用开发[M].北京:人民邮电出版社,
2010.09.
[20] Grant Allen,Mike Definitive Guide to SQLite(Second Edition)[M].电子工业出版社,2012.01.
[21] 公磊,周聪.基于Android的移动终端应用程序开发与研究[J].计算机与现代化.
2008年,第8期.
[22] 刘卫国,Android的架构与应用开发研究[J].计算机系统应用.2008年,第11期.
[23] Android官方网站/reference/java/net/.
附录一 核心代码
建立BookRecord表的SQL语句：
32
static SQLiteDatabase sld;
public static void createOrOpenDatabase()
{
try
{
sld=tabase
(
"/data/data//recordself",
null,
_READWRITE|_IF_NECESSARY
);
String sql1="create table if not exists BookRecord"+
"("+
"rid INTEGER PRIMARY KEY AUTOINCREMENT,"+
"path varchar(50),"+
"data blob"+
");";
}
L(sql1);
}
catch(Exception e)
{
}
tackTrace();
建立BookMark表的SQL语句：
String sql2="create table if not exists BookMark"+
"("+
"mid INTEGER PRIMARY KEY
AUTOINCREMENT,"+
"ridfk INTEGER,"+
33
"bmname varchar(50),"+
"page INTEGER"+
");";
L(sql2);
建立LastTimePage表的SQL语句：
String sql3="create table if not exists LastTimePage"+
"("+
"lid INTEGER PRIMARY KEY AUTOINCREMENT,"+
"path varchar(50),"+
"page INTEGER,"+
"fontsize INTEGER"+
");";
L(sql3);
附录二 毕业设计外文翻译（英文）
The Java I/O System
Creating a good input/output (I/O) system is one of the more difficult tasks for a language
designer. This is evidenced by the number of different approaches.
The challenge seems to be in covering all possibilities. Not only are there different sources and
34
sinks of I/O that you want to communicate with (files, the console, network connections, etc.), but
you need to talk to them in a wide variety of ways (sequential, random-access, buffered, binary,
character, by lines, by words, etc.). The Java library designers attacked this problem by creating
lots of classes. In fact, there are so many classes for Java’s I/O system that it can be intimidating at
first (ironically, the Java I/O design actually prevents an explosion of classes). There was also a
significant change in the I/O library after Java i.o, when the original byte-oriented library was
supplemented with char-oriented, Unicode-based I/O classes. The nio classes (for "new I/O," a
name we’ll still be using years from now even though they were introduced in JDK 1.4 and so are
already "old") were added for improved performance and functionality. As a result, there are a fair
number of classes to learn before you understand enough of Java’s I/O picture that you can use it
properly. In addition, it’s rather important to understand the evolution of the I/O library, even if
your first reaction is "Don’t bother me with history, just show me how to use it!" The problem is
that without the historical perspective, you will rapidly become confused with some of the classes
and when you should and shouldn’t use them.
Input and output
Programming language I/O libraries often use the abstraction of a stream, which represents
any data source or sink as an object capable of producing or receiving pieces of data. The stream
hides the details of what happens to the data inside the actual I/O device.
The Java library classes for I/O are divided by input and output, as you can see by looking at
the class hierarchy in the JDK documentation. Through inheritance, everything derived from the
InputStream or Reader classes has basic methods called read( ) for reading a single byte or an array
of bytes. Likewise, everything derived from OutputStream or Writer classes has basic methods
called write( ) for writing a single byte or an array of bytes. However, you won’t generally use
these methods; they exist so that other classes can use them—these other classes provide a more
useful interface. Thus, you’ll rarely create your stream object by using a single class, but instead
will layer multiple objects together to provide your desired functionality (this is the Decorator
design pattern, as you shall see in this section). The fact that you create more than one object to
produce a single stream is the primary reason that Java’s I/O library is confusing.
It’s helpful to categorize the classes by their functionality. In Java l.o, the library designers
started by deciding that all classes that had anything to do with input would be inherited from
35
InputStream, and all classes that were associated with output would be inherited from
OutputStream.
Type of InputStream
InputStream’s job is to represent classes that produce input from different
sources can be:
1. An array of bytes.
2. A String obj ect.
3. A file.
4. A "pipe," which works like a physical pipe: You put things in at one end and they come out the
other.
5. A sequence of other streams, so you can collect them together into a single stream.
6. Other sources, such as an Internet connection. (This is covered in Thinking in Enterprise Java,
available at .)
Each of these has an associated subclass of InputStream. In addition, the FilterInputStream is
also a type of InputStream, to provide a base class for "decorator" classes that attach attribute or
useful interfaces to input streams.
Types of OutputStream
This category includes the classes that decide where your output will go: an array of bytes (but
not a String—presumably, you can create one using the array of bytes), a file, or a "pipe."
In addition, the FilterOutputStream provides a base class for "decorator" classes that attach
attributes or useful interfaces to output streams. This is discussed later.
Adding attributes and useful interfaces
Decorators were introduced in the Generics chapter, on page 717. The Java I/O library
requires many different combinations of features, and this is the justification for using the
Decorator design pattern.1 The reason for the existence of the "filter" classes in the Java I/O library
is that the abstract "filter" class is the base class for all the decorators. A decorator must have the
same interface as the object it decorates, but the decorator can also extend the interface, which
occurs in several of the "filter" classes.
There is a drawback to Decorator, however. Decorators give you much more flexibility while
you’re writing a program (since you can easily mix and match attributes), but they add complexity
36
to your code. The reason that the Java I/O library is awkward to use is that you must create many
classes—the "core" I/O type plus all the decorators—in order to get the single I/O object that you
want.
The classes that provide the decorator interface to control a particular InputStream or
OutputStream are the FilterlnputStream and FilterOutputStream, which don’t have very intuitive
names. FilterlnputStream and FilterOutputStream are derived from the base classes of the I/O
library, InputStream and OutputStream, which is a key requirement of the decorator (so that it
provides the common interface to all the objects that are being decorated).
Readers & Writers
Java 1.1 made significant modifications to the fundamental I/O stream library. When you see
the Reader and Writer classes, your first thought (like mine) might be that these were meant to
replace the InputStream and OutputStream classes. But that’s not the case. Although some aspects
of the original streams library are deprecated (if you use them you will receive a warning from the
compiler), the InputStream and OutputStream classes still provide valuable functionality in the
form of byte-oriented I/O, whereas the Reader and Writer classes provide Unicode-compliant,
character-based I/O. In addition:
1. Java 1.1 added new classes into the InputStream and OutputStream hierarchy, so it’s obvious
those hierarchies weren’t being replaced.
There are times when you must use classes from the "byte" hierarchy in combination with
classes in the "character" hierarchy. To accomplish this, there are "adapter" classes:
InputStreamReader converts an InputStream to a Reader, and OutputStreamWriter converts an
OutputStream to a Writer.
The most important reason for the Reader and Writer hierarchies is for internationalization.
The old I/O stream hierarchy supports only 8-bit byte streams and doesn’t handle the 16-bit
Unicode characters well. Since Unicode is used for internationalization (and Java’s native char is
16-bit Unicode), the Reader and Writer hierarchies were added to support Unicode in all I/O
operations. In addition, the new libraries are designed for faster operations than the old.
Standard I/O
The term standard I/O refers to the Unix concept of a single stream of information that is used
by a program (this idea is reproduced in some form in Windows and many other operating systems).
37
All of the program’s input can come from standard input, all of its output can go to standard output,
and all of its error messages can be sent to standard error. The value of standard I/O is that
programs can easily be chained together, and one program’s standard output can become the
standard input for another program. This is a powerful tool.
Reading from standard input
Following the standard I/O model, Java has , , and .
Throughout this book, you’ve seen how to write to standard output using , which is
already pre-wrapped as a PrintStream object. is likewise a PrintStream, but is
a raw InputStream with no wrapping. This means that although you can use and
right away, must be wrapped before you can read from it.
You’ll typically read input a line at a time using readLine( ). To do this, wrap in a
BufferedReader, which requires you to convert to a Reader using InputStreamReader.
Redirecting
The Java System class allows you to redirect the standard input, output, and error I/O streams
using simple static method calls:
setIn(InputStream)
setOut(PrintStream)
setErr(PrintStream)
Redirecting output is especially useful if you suddenly start creating a large amount of output
on your screen, and it’s scrolling past faster than you can read it.4 Redirecting input is valuable for
a command-line program in which you want to test a particular user-input sequence repeatedly.
New I/O
The Java "new" I/O library, introduced in JDK 1.4 in the .* packages, has one goal:
speed. In fact, the "old" I/O packages have been reimplemented using nio in order to take
advantage of this speed increase, so you will benefit even if you don’t explicitly write code with
nio. The speed increase occurs both in file I/O, which is explored here, and in network I/O, which
is covered in Thinking in Enterprise Java.
The speed comes from using structures that are closer to the operating system’s way of
performing I/O: channels and buffers. You could think of it as a coal mine; the channel is the mine
containing the seam of coal (the data), and the buffer is the cart that you send into the mine. The
38
cart comes back full of coal, and you get the coal from the cart. That is, you don’t interact directly
with the channel; you interact with the buffer and send the buffer into the channel. The channel
either pulls data from the buffer, or puts data into the buffer.
The only kind of buffer that communicates directly with a channel is a ByteBuffer—that is, a
buffer that holds raw bytes. If you look at the JDK documentation for ffer, you’ll
see that it’s fairly basic: You create one by telling it how much storage to allocate, and there are
methods to put and get data, in either raw byte form or as primitive data types. But there’s no way
to put or get an object, or even a String. It’s fairly low-level, precisely because this makes a more
efficient mapping with most operating systems.
Three of the classes in the "old" I/O have been modified so that they produce a FileChannel:
FileInputStream, FileOutputStream, and, for both reading and writing, RandomAccessFile. Notice
that these are the byte manipulation streams, in keeping with the low-level nature of nio. The
Reader and Writer character-mode classes do not produce channels, but the
ls class has utility methods to produce Readers and Writers from
channels.
Reading from an InputStream with FilterlnputStream
The FilterlnputStream classes accomplish two significantly different things. DatalnputStream
allows you to read different types of primitive data as well as String objects. (All the methods start
with "read," such as readByte( ), readFloat( ), etc.) This, along with its companion
DataOutputStream, allows you to move primitive data from one place to another via a stream.
The remaining FilterlnputStream classes modify the way an InputStream behaves internally:
whether it’s buffered or unbuffered, whether it keeps track of the lines it’s reading (allowing you to
ask for line numbers or set the line number), and whether you can push back a single character. The
last two classes look a lot like support for building a compiler (they were probably added to support
the experiment of "building a Java compiler in Java"), so you probably won’t use them in general
programming.
You’ll need to buffer your input almost every time, regardless of the I/O device you’re
connecting to, so it would have made more sense for the I/O library to have a special case (or
simply a method call) for unbuffered input rather than buffered input.
Writing to an OutputStream with FilterOutputStream
39
The complement to DatalnputStream is DataOutputStream, which formats each of the
primitive types and String objects onto a stream in such a way that any DatalnputStream, on any
machine, can read them. All the methods start with "write," such as writeByte( ), writeFloat( ), etc.
The original intent of PrintStream was to print all of the primitive data types and String objects
in a viewable format. This is different from DataOutputStream, whose goal is to put data elements
on a stream in a way that DatalnputStream can portably reconstruct them.
The two important methods in PrintStream are print( ) and println( ), which are overloaded to
print all the various types. The difference between print( ) and println( ) is that the latter adds a
newline when it’s done. BufferedOutputStream is a modifier and tells the stream to use buffering so
you don’t get a physical write every time you write to the stream.
Off by itself: RandomAccessFile
RandomAccessFile is used for files containing records of known size so that you can move
from one record to another using seek( ), then read or change the records. The records don’t have to
be the same size; you just have to determine how big they are and where they are placed in the file.
At first it’s a little bit hard to believe that RandomAccessFile is not part of the InputStream or
OutputStream hierarchy. However, it has no association with those hierarchies other than that it
happens to implement the DataInput and DataOutput interfaces (which are also implemented by
DataInputStream and DataOutputStream). It doesn’t even use any of the functionality of the
existing InputStream or OutputStream classes; it’s a completely separate class, written from scratch,
with all of its own (mostly native) methods. The reason for this may be that RandomAccessFile has
essentially different behavior than the other I/O types, since you can move forward and backward
within a file. In any event, it stands alone, as a direct descendant of Object.
Essentially, a RandomAccessFile works like a DataInputStream pasted together with a
DataOutputStream, along with the methods getFilePointer( ) to find out where you are in the file,
seek( ) to move to a new point in the file, and length( ) to determine the maximum size of the file.
In addition, the constructors require a second argument (identical to fopen( ) in C) indicating
whether you are just randomly reading ("r") or reading and writing ("rw"). There’s no support for
write-only files, which could suggest that RandomAccessFile might have worked well if it were
inherited from DataInputStream.
The seeking methods are available only in RandomAccessFile, which works for files only.
40
版权声明：本文标题：Android手机电子书阅读器的设计与实现设计说明书 内容由热心网友自发贡献，该文观点仅代表作者本人， 转载请联系作者并注明出处：https://m.elefans.com/xitong/1709938740a240464.html， 本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌抄袭侵权/违法违规的内容，一经查实，本站将立刻删除。
发表评论