Android_SDK开发菜鸟范例

　　　　Ｇｏｏｇｌｅ　Ａｎｄｒｏｉｄ　ＳＤＫ　开发范例大全

　　　　第二章：Ａｎｄｒｏｉｄ　初体验　Ａｎｄｒｏｉｄ　操作系统顶着　Ｇｏｏｇｌｅ　与　Ｏｐｅｎ　Ｈａｎｄｓｅｔ　Ａｌｌｉａｎｃｅ　的光环，让很多程序　员在　Ａｎｄｒｏｉｄ　手机还没上市之前，就开始紧追着官方文档、Ｅａｒｌｙ　ＳＤＫ　版本更新，　这是　ＩＴ　业界罕见的现象，因为大家都抱持着“不想输在起跑点上”的心态。这　也是手机发展的历史中，　第一次有机会让所有的程序员站在同一个　起跑点开始，　无论是　Ｊａｖａ　Ｗｏｒｌｄ　论坛、或是　Ｇｏｏｇｌｅ　官方的　Ｄｅｖｅｌｏｐｅｒ　Ｄｉｓｃｕｓｓｉｏｎ　Ｇｒｏｕｐ　都　见到相当热烈的讨论。　从这一章开始，将对　Ａｎｄｒｏｉｄ　的程序架构、程序　进入点、编译以及执行，　进行一系列的导航，而本书规划之初，并非针对　Ｊａｖａ　初学者或从未接触过程序　设计的朋友所设计，　故在这一章简要的　ｏｖｅｒｖｉｅｗ　当中，　则以快速掌握开发条件、　开发环境为目的，若你是第一次接触　Ｊａｖａ　程序语言，或从未写过面向对象程序　设计，建议你先学习　Ｊａｖａ　语言，打好基础后，　再回过头来进入本章。　接下来的内容分成五个部分：安装　Ａｎｄｒｏｉｄ　ＳＤＫ、创建　Ａｎｄｒｏｉｄ　手机开发项　目（Ｐｒｏｊｅｃｔ）、了解　Ａｎｄｒｏｉｄ　程序的生命周期，初探可视化的开发工具，最后　将应用程序部署到模拟器和　Ａｎｄｒｏｉｄ　手机上，为避免过于概念性的论述及篇幅　的浪费，所有操作练习皆以步骤的方法描述，只要跟着操作即可上手，在体验完　本章的内容之后，你就可以　开始本书范例的学习之旅了。　在开始之前，你需要先准备以下作业环境以及程序：　必备项目　Ｍｉｃｒｏｓｏｆｔ　Ｗｉｎｄｏｗｓ　ＸＰ／Ｍｉｃｒｏｓｏｆｔ　Ｗｉｎｄｏｗｓ　Ｖｉｓｔａ　操作系统　或　Ｍａｃ　ＯＳ　Ｘ　１０．４．８　或更新的版本（硬件必须是　ｘ８６　的版本）　或　Ｌｉｎｕｘ　Ａｎｄｒｏｉｄ　ＳＤＫ　１．０ｒ２　以上　（本书所有范例皆以　Ａｎｄｒｏｉｄ　ＳＤＫ　１．１ｒ１　为开发环境）　Ｊａｖａ　Ｄｅｖｅｌｏｐｍｅｎｔ　Ｋｉｔ（ＪＤＫ）ｖ６．０　以上　Ｅｃｌｉｐｓｅ　开发　ＩＤＥ　程序　（本书所有范例皆以　ｅｃｌｉｐｓｅ－ｊｅｅ－ｇａｎｙｍｅｄｅ－ＳＲ１－ｗｉｎ３２　版　本为编译环境）　自我检查　（ˇ）　　　　准备就绪之后，就可以前往　Ａｎｄｒｏｉｄ　官方网站　（ｈｔｔｐ：／／ｄｅｖｅｌｏｐｅｒ．ａｎｄｒｏｉｄ．ｃｏｍ／）下载　Ａｎｄｒｏｉｄ　ＳＤＫ，也可以到（　ｈｔｔｐ：／／ａｎｄｒｏｉｄａｐｐｄｏｃｓ．ａｐｐｓｐｏｔ．ｃｏｍ）去下载。

　　　　▲图　２－１　到　Ａｎｄｒｏｉｄ　官方网站下载　ＳＤＫ　下载后的　Ａｎｄｒｏｉｄ　ＳＤＫ　为压缩文件，请将它解压缩到磁盘中，例如下面的文　件夹：　Ｄ：＼ＳＤＫ＼ａｎｄｒｏｉｄ　而　Ｅｃｌｉｐｓｅ　编译　ＩＤＥ　环境中，需安装　ＡＤＴ（Ａｎｄｒｏｉｄ　Ｄｅｖｅｌｏｐｍｅｎｔ　Ｔｏｏｌｓ）　ｐｌｕｇ－ｉｎ，　此为　Ａｎｄｒｏｉｄ　的开发工具，　启动　Ｅｃｌｉｐｓｅ　后，　请运行“Ｈｅｌｐ—Ｓｏｆｔｗａｒｅ　Ｕｐｄａｔｅｓ＞＞Ｆｉｎｄ　ａｎｄ　Ｉｎｓｔａｌｌ”，并按下“Ａｄｄ　Ｓｉｔｅ”输入　ＡＤＴ　ｐｌｕｇ－ｉｎ　网址后　（如下），按下“Ｉｎｓｔａｌｌ”便开始自动下载安装：　ｈｔｔｐｓ：／／ｄｌ－ｓｓｌ．ｇｏｏｇｌｅ．ｃｏｍ／ａｎｄｒｏｉｄ／ｅｃｌｉｐｓｅ／

　　　　▲图　２－２　安装　ＡＤＴ　Ｐｌｕｇ－ｉｎ　下载后，安装向导会显示两项必须安装的程序：Ａｎｄｒｏｉｄ　Ｄｅｖｅｌｏｐｍｅｎｔ　Ｔｏｏｌｓ　与　Ａｎｄｒｏｉｄ　Ｅｄｉｔｏｒｓ。　　　　▲图　２－３　选择安装　Ａｎｄｒｏｉｄ　开发工具及编辑器

　　　　虽然　Ａｎｄｒｏｉｄ　ＡＤＴ　可以免费下载安装，但在使用上仍然有其局限性，跟一般　应用程序许可条款的签署类似。

　　　　▲图　２－４　同意使用　Ａｎｄｒｏｉｄ　软件开发条款　安装　ＡＤＴ　所需的时间不长，也可以在后台运行，不会影响现有的操作系统程　序。安装完毕后，需要重新启动　Ｅｃｌｉｐｓｅ，才能使用　Ａｎｄｒｏｉｄ　ＡＤＴ。

　　　　▲图　２－５　可以在后台运行安装　ＡＤＴ，并需要重新启动　Ｅｃｌｉｐｓｅ　至此　Ａｎｄｒｏｉｄ　ＳＤＫ　及　ＡＤＴ　已安装完毕，所有准备工作都已经就绪，随时可以　开始建立　Ａｎｄｒｏｉｄ　项目。　这一节将建立本书第一个　Ａｎｄｒｏｉｄ　项目，不过，在初次建立　Ａｎｄｒｏｉｄ　项目之　前，需要设置　Ａｎｄｒｏｉｄ　ＳＤＫ　的路径，让　Ｅｃｌｉｐｓｅ　可以找到　Ａｎｄｒｏｉｄ　ＳＤＫ，先执行　“Ｗｉｎｄｏｗ—Ｐｒｅｆｅｒｅｎｃｅｓ”。

　　　　▲图　２－６　运行　Ｅｃｌｉｐｓｅ　的　Ｐｒｅｆｅｒｅｎｃｅｓ　设置功能　点击“Ａｎｄｒｏｉｄ”的树状列表，单击“Ｂｒｏｗｓｅ”按钮，选择刚才解压的　Ａｎｄｒｏｉｄ　ＳＤＫ　的路径，而后按下“Ａｐｐｌｙ”设置让　Ｅｃｌｉｐｓｅ　引用的　ＳＤＫ　文件夹。

　　　　▲图　２－７　设置　Ａｎｄｒｏｉｄ　Ｐｒｅｆｅｒｅｎｃｅｓ　路径　Ａｎｄｒｏｉｄ　ＳＤＫ　的引用路径设置完成之后，就可以开始建立　Ｈｅｌｌｏ　Ｗｏｒｌｄ　这个　经典范例了；运行“Ｆｉｌｅ—Ｎｅｗ＞＞Ｐｒｏｊｅｃｔ”建立新项目。

　　　　▲图　２－８　建立新的项目　新建项目向导需要指定一种应用程序类型，故展开“Ａ

ｐａｇｅ　１

ｎｄｒｏｉｄ”后，点击　“Ａｎｄｒｏｉｄ　Ｐｒｏｊｅｃｔ”，按下“Ｎｅｘｔ”按钮继续。

　　　　▲图　２－９　选择建立项目类型为　Ａｎｄｒｏｉｄ　Ｐｒｏｊｅｃｔ　新建　Ａｎｄｒｏｉｄ　项目需输入项目名称（　Ｐｒｏｊｅｃｔ　ｎａｍｅ）　、Ｐａｃｋａｇｅ　ｎａｍｅ、　Ａｃｔｉｖｉｔｙ　ｎａｍｅ　以及　Ａｐｐｌｉｃａｔｉｏｎ　ｎａｍｅ，最后按下“Ｆｉｎｉｓｈ”按钮，项目随即建立完成。　　　　▲图　２－１０

　　　　输入项目名称及　Ｐａｃｋａｇｅ　ｎａｍｅ　建立新项目

　　　　到目前为止，新建　Ａｎｄｒｏｉｄ　项目已经完成，而且　这个新建立的程序也已经　可以运行，运行的方法是在“Ｐａｃｋａｇｅ　Ｅｘｐｌｏｒｅｒ”窗口里，点开刚建立好的　“ＨｅｌｌｏＷｏｒｌｄ”项目文件夹，　并在项目名称上单击鼠标右键，在功能菜单上运行　“Ｒｕｎ　Ａｓ＞Ａｎｄｒｏｉｄ　Ａｐｐｌｉｃａｔｉｏｎ”功能。　　　　▲图　２－１１

　　　　运行“Ｒｕｎ　Ａｓ—Ａｎｄｒｏｉｄ　Ａｐｐｌｉｃａｔｉｏｎ”功能

　　　　假若此时尚未将手机与计算机联机，那么　Ｅｃｌｐｉｓｅ　将打开默认的　Ａｎｄｒｏｉｄ　模　拟器（Ｅｍｕｌａｔｏｒ），运行画面就如同真的手机开机一样，随着计算机硬件环境的　不同，　运行模拟器也会有不同的性能表现，　开机之后，　随即打开刚建立好的　Ｈｅｌｌｏ　Ｗｏｒｌｄ　程序。　　　　▲图　２－１２

　　　　没写一行程序的　Ｈｅｌｌｏ　Ｗｏｒｌｄ

　　　　要退出被启动的“Ｈｅｌｌｏ　Ｗｏｒｌｄ”程序，可以按下手机模拟器上的退格键　（Ｂａｃｋｓｐａｃｅ）。　　　　▲图　２－１３

　　　　按下退格键离开程序，回到手机的桌面

　　　　虽然半行代码都没有写，但向导却帮忙写好了程序进入点、布局配置、字符　串常数、应用程序访问权限等，除了可作为程序模板之外，也是　Ａｎｄｒｏｉｄ　手机程　序的最佳学习范例。　让我们回过头来看看刚才　Ａｎｄｒｏｉｄ　项目建立向导帮忙做了哪些工作，以此来　了解　Ａｎｄｒｏｉｄ　应用程序的生命周期及其文件组成方式；首先，展开“Ｐａｃｋａｇｅ　Ｅｘｐｌｏｒｅｒ”窗口里的“ＨｅｌｌｏＷｏｒｌｄ”项目名称，可以看见如下数据结构的文件：　＋ＨｅｌｌｏＷｏｒｌｄ　＋－ｓｒｃ

　　　　＋－ｈｅｌｌｏｗｏｒｌｄ．ｉｒｄｃ．ｅｒａｃｏｍ．ｃｏｍ．ｃｎ　＋－ＨｅｌｌｏＷｏｒｌｄ．ｊａｖａ　＋－Ｒ．ｊａｖａ　＋－Ａｎｄｒｏｉｄ　Ｌｉｂｒａｒｙ　＋－ａｎｄｒｏｉｄ．ｊａｒ　－　Ｄ：＼ＳＤＫ＼ａｎｄｒｏｉｄ　＋－ａｓｓｅｔｓ　＋－ｒｅｓ　＋－ｄｒａｗａｂｌｅ　＋－ｉｃｏｎ．ｐｎｇ　＋－ｌａｙｏｕｔ　＋－ｍａｉｎ．ｘｍｌ　＋－ｖａｌｕｅｓ　＋－ｓｔｒｉｎｇｓ．ｘｍｌ　＋－ＡｎｄｒｏｉｄＭａｎｉｆｅｓｔ．ｘｍｌ　在展开的文件夹　层中，　“ｓｒｃ”、　“Ａｎｄｒｏｉｄ　Ｌｉｂｒａｒｙ”、　“ａｓｓｅｔｓ”、　“ｒｅｓ”　与“ＡｎｄｒｏｉｄＭａｎｉｆｅｓｔ．ｘｍｌ”同属一层，放置在“＼ｓｒｃ”里的为主程序、程序类　（ｃｌａｓｓ）；放置在“＼ｒｅｓ”里的为资源文件（Ｒｅｓｏｕｒｃｅ　Ｆｉｌｅｓ），如程序　ＩＣＯＮ　图标、布局文件（＼ｌａｙｏｕｔ）与常数（＼ｖａｌｕｅｓ）。　以此　Ｈｅｌｌｏ　Ｗｏｒｌｄ　程序为例，主程序为“ＨｅｌｌｏＷｏｒｌｄ．ｊａｖａ”，其内容与一　般　Ｊａｖａ　程序格式相类似：　ｐａｃｋａｇｅ　ｈｅｌｌｏｗｏｒｌｄ．ｉｒｄｃ．ｅｒａｃｏｍ．ｃｏｍ．ｃｎ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ａｐｐ．Ａｃｔｉｖｉｔｙ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｏｓ．Ｂｕｎｄｌｅ；　ｐｕｂｌｉｃ　ｃｌａｓｓ　ＨｅｌｌｏＷｏｒｌｄ　ｅｘｔｅｎｄｓ　Ａｃｔｉｖｉｔｙ　｛

　　　　／＊＊　Ｃａｌｌｅｄ　ｗｈｅｎ　ｔｈｅ　ａｃｔｉｖｉｔｙ　ｉｓ　ｆｉｒｓｔ　ｃｒｅａｔｅｄ．　＊／　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｒｅａｔｅ（Ｂｕｎｄｌｅ　ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）　｛　ｓｕｐｅｒ．ｏｎＣｒｅａｔｅ（ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）；　ｓｅｔＣｏｎｔｅｎｔＶｉｅｗ（Ｒ．ｌａｙｏｕｔ．ｍａｉｎ）；　｝　｝　主程　序里可看见　ＨｅｌｌｏＷｏｒｌｄ　类继承自　Ａｃｔｉｖｉｔｙ　类，在类中重写了　ｏｎＣｒｅａｔｅ（）　方法，在方法内以　ｓｅｔＣｏｎｔｅｎｔＶｉｅｗ（）　来设置这个　Ａｃｖｉｔｉｔｙ　要显示　的布局（Ｒ．ｌａｙｏｕｔ．ｍａｉｎ），使用布局配置“＼ｌａｙｏｕｔ＼ｍａｉｎ．ｘｍｌ”，布局文件是　以　ＸＭＬ　格式编　写的，内容如下：　＜？ｘｍｌ　ｖｅｒｓｉｏｎ＝＂１．０＂　ｅｎｃｏｄｉｎｇ＝＂ｕｔｆ－８＂？＞　

　　　　＜ＴｅｘｔＶｉｅｗ　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｗｉｄｔｈ＝＂ｆｉｌｌ＿ｐａｒｅｎｔ＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｈｅｉｇｈｔ＝＂ｗｒａｐ＿ｃｏｎｔｅｎｔ＂　ａｎｄｒｏｉｄ：ｔｅｘｔ＝＂＠ｓｔｒｉｎｇ／ｈｅｌｌｏ＂　／＞　

　　　　布局配置中设置了一个　ＴｅｘｔＶｉｅｗ　ＴＡＧ，用以配置文本标签　Ｗｉｄｇｅｔ，其内部　设置的　ａｎｄｒｏｉｄ：ｔｅｘｔ　属性，　则是要显示的文字内容，　引用“＠ｓｔｒｉｎｇ”里的　ｈｅｌｌｏ　字符串常数。　查看“ｖａｌｕｅｓ／ｓｔｒｉｎｇｓ．ｘｍｌ”字符串常数设置如下：　＜？ｘｍｌ　ｖｅｒｓｉｏｎ＝＂１．０＂　ｅｎｃｏｄｉｎｇ＝＂ｕｔｆ－８＂？＞　＜ｒｅｓｏｕｒｃｅｓ＞　Ｈｅｌｌｏ　Ｗｏｒｌｄ，　ＨｅｌｌｏＷｏｒｌｄ　ＨｅｌｌｏＷｏｒｌｄ　＜／ｒｅｓｏｕｒｃｅｓ＞　其中“ｈｅｌｌｏ”字符串变量的内容为“Ｈｅｌｌｏ　Ｗｏｒｌｄ，　ＨｅｌｌｏＷｏｒｌｄ”，这即

ｐａｇｅ　２

是　刚才看见的　Ｈｅｌｌｏ　Ｗｏｒｌｄ　程序显示的文字内容了。　Ａｎｄｒｏｉｄ　应用程序有以下三种类型：　ｌ　ｌ　ｌ　前端　Ａｃｔｉｖｉｔｙ（Ｆｏｒｅｇｒｏｕｎｄ　Ａｃｔｉｖｉｔｉｅｓ）。　后台服务（Ｂａｃｋｇｒｏｕｎｄ　Ｓｅｒｖｉｃｅｓ）。　间隔执行　Ａｃｔｉｖｉｔｙ（Ｉｎｔｅｒｍｉｔｔｅｎｔ　Ａｃｔｉｖｉｔｉｅｓ）。

　　　　前端　Ａｃｔｉｖｉｔｙ　就如同这个　Ｈｅｌｌｏ　Ｗｏｒｌｄ　一样，运行在手机前端程序中；后　台服务可能是看不见的系统服务（Ｓｙｓｔｅｍ　Ｓｅｒｖｉｃｅ）、系统　Ｂｒｏａｄｃａｓｔ（广播信　息）与　Ｒｅｃｅｉｖｅｒ（广播信息）接收器）；间隔执行　Ａｃｔｉｖｉｔｙ　则类似如进程　（Ｔｈｒｅａｄｉｎｇ）、Ｎｏｔｉｆｉｃａｔｉｏｎ　Ｍａｎａｇｅｒ　等等。　每一个　项目都有一个“ＡｎｄｒｏｉｄＭａｎｉｆｅｓｔ．ｘｍｌ”设置文件，里头包含这个　Ａｎｄｒｏｉｄ　应用程序具有哪些　Ａｃｔｉｖｉｔｙ、Ｓｅｒｖｉｃｅ　或者　Ｒｅｃｅｉｖｅｒ，先来看看　Ｈｅｌｌｏ　Ｗｏｒｌｄ　制作好的“ＡｎｄｒｏｉｄＭａｎｉｆｅｓｔ．ｘｍｌ”设置文件的内容描述：　＜？ｘｍｌ　ｖｅｒｓｉｏｎ＝＂１．０＂　ｅｎｃｏｄｉｎｇ＝＂ｕｔｆ－８＂？＞　＜ｍａｎｉｆｅｓｔ　ｘｍｌｎｓ：ａｎｄｒｏｉｄ＝＂ｈｔｔｐ：／／ｓｃｈｅｍａｓ．ａｎｄｒｏｉｄ．ｃｏｍ／ａｐｋ／ｒｅｓ／ａｎｄｒｏｉｄ＂　ｐａｃｋａｇｅ＝＂ｈｅｌｌｏｗｏｒｌｄ．ｉｒｄｃ．ｅｒａｃｏｍ．ｃｏｍ．ｔｗ＂　ａｎｄｒｏｉｄ：ｖｅｒｓｉｏｎＣｏｄｅ＝＂１＂

　　　　ａｎｄｒｏｉｄ：ｖｅｒｓｉｏｎＮａｍｅ＝＂１．０．０＂＞　　　　　＜ｃａｔｅｇｏｒｙ　ａｎｄｒｏｉｄ：ｎａｍｅ＝＂ａｎｄｒｏｉｄ．ｉｎｔｅｎｔ．ｃａｔｅｇｏｒｙ．ＬＡＵＮＣＨＥＲ＂　／＞　　　　＜／ｍａｎｉｆｅｓｔ＞　在　ｍａｎｉｆｅｓｔ　文件中有一个名为　ＨｅｌｌｏＷｏｒｌｄ　的　Ａｃｔｉｖｉｔｙ，设置其　ｉｎｔｅｎｔ－ｆｉｌｔｅｒ　的　ｃａｔｅｇｏｒｙ　ａｎｄｒｏｉｄ：ｎａｍｅ　为　＂ａｎｄｒｏｉｄ．ｉｎｔｅｎｔ．ｃａｔｅｇｏｒｙ．ＬＡＵＮＣＨＥＲ＂，写在　ｉｎｔｅｎｔ－ｆｉｌｔｅｒ　里是指定此　Ａｃｔｉｖｉｔｙ　为默认运行的主要　Ａｃｔｉｖｉｔｙ，除了在　ｍａｎｉｆｅｓｔ　文件中手动设置之外，　也可在　Ｅｃｌｉｐｓｅ　右击项目名称，运行“Ｒｕｎ　Ａｓ—Ｒｕｎ　Ｃｏｎｆｉｇｕｒａｔｉｏｎｓ”，设置　Ｌａｕｎｃｈ　Ａｃｔｉｏｎ：　　　　▲图　２－１４

　　　　设置项目要执行的　Ａｃｔｉｏｎ　方式或　Ａｃｔｉｖｉｔｙ

　　　　Ａｃｔｉｖｉｔｙ　类的应用程序有其默认运行的方式，　为了确保应用程序运行的优先　级，理解　Ａｃｔｉｖｉｔｙ　在手机运行时的生命周期，及其可视性（Ｖｉｓｉｂｌｅ）周期。　　　　▲图　２－１５

　　　　Ａｃｔｉｖｉｔｙ　自　ｏｎＳｔｏｐ　之后，程序即可被关闭

　　　　以　Ｈｅｌｌｏ　Ｗｏｒｌｄ　程序里继承自　Ａｃｔｉｖｉｔｒｙ　类开始，一旦程序被执行，即会照　以上流程顺序进行，若需要在　Ａｃｔｉｖｉｔｙ　程序里编写程序，默认常见的进入点为　重写　ｏｎＣｒｅａｔｅ（Ａｃｔｉｖｉｔｙ）或　ｏｎＳｔａｒｔ（Ｓｅｒｖｉｃｅ），重写的方式可通过　Ｅｃｌｉｐｓｅ　来选择，方法为将鼠标光标停　在继承自　Ａｃｔｉｖｉｔｙ　的空白处，单击鼠标右键展开菜单，点开执行　“Ｓｏｕｒｃｅ—Ｏｖｅｒｒｉｄｅ／Ｉｍｐｌｅｍｅｎｔ　Ｍｅｔｈｏｄｓ”功能。　　　　▲图　２－１６

　　　　执行“Ｓｏｕｒｃｅ—Ｏｖｅｒｒｉｄｅ／Ｉｍｐｌｅｍｅｎｔ　Ｍｅｔｈｏｄｓ”功能

　　　　在重写于实现方法的对话框中，点开“Ａｃｔｉｖｉｔｙ”树状列表，在其中找到了　ｏｎＣｒｅａｔｅ（Ｂｕｎｄｌｅ）方法，勾选前方的选择项（ＣｈｅｃｋＢｏｘ），再按下“ＯＫ”按钮即　可。　　　　▲图　２－１７

　　　　选择要重写的方法，向导会自动在主程序中描述重写内容

　　　　最后，　比较值得一提的是　ｏｎＲｅｓｕｍｅ（）　与　ｏｎＰａｕｓｅ（），　这两个方法为　Ａｃｔｉｖｉｔｙ　在　ｏｎＣｒｅａｔｅ　之后运行过程中的生命周期，当程序失去前端焦点、或者被关闭，　就会触发　Ａｃｔｉｖｉｔｙ　的　ｏｎＰａｕｓｅ（）　状态；当应用程序被再次唤醒，则会回到　ｏｎＲｅｓｕｍｅ（）　状态，故在编写与　Ｕｓｅｒ　互动的程序过程中，需注意　Ｕｓｅｒ　暂时离开　Ａｃｔｉｖｉｔｙ（或前往不同的　Ａｃｔｉｖｉｔｙ、不同的　Ｓｅｒｖｉｃｅ）前，需要处　理的工作都　会摆在　ｏｎＰａｕｓｅ（）　当中执行。以一个通过网络　ＦＴＰ　下载　ｍｐ３　的　Ａｃｔｉｖｉｔｙ　为例，

　　　　暂停下载工作可以写在　ｏｎＰａｕｓｅ　里，需要接续前一次的下载等处理，则由　ｏｎＲｅｓｕｍｅ　负责。　Ａｎｄｒｏｉｄ　手机有着华丽的机身、流畅的执行速度，唯一欠缺的就是“具有视　觉美感的　ＵＩ　设计员”，　但自　Ａｎｄｒｏｉｄ　ＳＤＫ　ｒｃ２０ａ　一路发展到　１．０＿ｒ２，　Ｏｐｅｎ　Ｈａｎｄｓｅｔ　Ａｌｌｉａｎｃｅ　提供的　ＡＤＴ　（Ａｎｄｒｏｉｄ　Ｄｅｖｅｌｏｐｍｅｎｔ　Ｔｏｏｌｓ），终于有了预览界面的功能，只要点开项目的　“ｒｅｓ—ｌａｙｏｕｔ”，双击　ｍａｉｎ．ｘｍｌ　运行“Ａｎｄｒｏｉｄ　Ｌａｙｏｕｔ　Ｅｄｉｔｏｒ”，或在其上　单击鼠标右键展开菜单单，执行“Ｏｐｅｎ　Ｗｉｔｈ—Ａｎｄｒｏｉｄ　Ｌａｙｏｕｔ　Ｅｄｉｔｏｒ”。　　　　▲图　２－１８

　　　　单击　ＸＭＬ　布局配置文件，选择以　Ａｎｄｒｏｉｄ　Ｌａｙｏｕｔ　Ｅｄｉｔｏｒ　编辑

　　　　Ａｎｄｒｏｉｄ　Ｅｄｉｔｏｒ　的功能虽然阳春，但至少还算齐备，具有文字模式与　ＵＩ　配　置模式可供切换，如下图的“Ｌａｙｏｕｔ”与“ｍａｉｎ．ｘｍｌ”页签切换所示。

ｐａｇｅ　３

　　　　▲图　２－１９

　　　　Ａｎｄｒｏｉｄ　Ｌａｙｏｕｔ　Ｅｄｉｔｏｒ　具有文字模式与　ＵＩ　配置模式可供切换编辑

　　　　目前的　ＡＤＴ　版本，虽然提供了预览接口功能，但没有　提供类似　Ｍｉｃｒｏｓｏｆｔ　Ｖｉｓｕａｌ　Ｓｔｕｄｉｏ　的拖拉界面组件开发工具，所以布局的配置虽然直观，但还是不

　　　　够自然，所幸，在　Ｇｏｏｇｌｅ　还未完整推出　ＧＵＩ　的拖拉工具之前，已有网友以　Ｊａｖａ　写出了好用的可视化　ＧＵＩ　布局拖拉工具程序：ＤｒｏｉｄＤｒａｗ。　ＤｒｏｉｄＤｒａｗ　目前是一个公开的　Ｇｏｏｇｌｅ　Ｃｏｄｅ，除了可以在线免费下载　（ｈｔｔｐ：／／ｃｏｄｅ．ｇｏｏｇｌｅ　．ｃｏｍ／ｐ／ｄｒｏｉｄｄｒａｗ／）使用到计算机端执行之外，也提供在线直接使用的版本　（ｈｔｔｐ：／／ｗｗｗ　．ｄｒｏｉｄｄｒａｗ．ｏｒｇ／）；ＤｒｏｉｄＤｒａｗ　同时还提供了源代码（Ｓｏｕｒｃｅ　Ｃｏｄｅ），可供程　序员自行参考或修改。　　　　▲图　２－２０

　　　　ＤｒｏｉｄＤｒａｗ　提供了可视化拖拉组件的方式设计布局期待未来　Ｇｏｏｇｌｅ　能将拖拉布局的功能纳入　Ａｎｄｒｏｉｄ　Ｅｄｉｔｏｒ　当中，如此一来　更能整合　Ａｎｄｒｏｉｄ　ＳＤＫ　以及开发环境的功能，且让我们拭目以待吧！　要部署程序在模拟器上运行，在先前　Ｈｅｌｌｏ　Ｗｏｒｌｄ　的程序已经看过了，在项　目名称上单击右键执行　Ａｎｄｒｏｉｄ　应用程序即可，但事实上，要将　Ａｎｄｒｏｉｄ　程序，　部署在手机环境中进行测试，方法也是相同的，同样调用“Ｒｕｎ　Ａｓ—Ａｎｄｒｏｉｄ　Ａｐｐｌｉｃａｔｉｏｎ”的方式执行，　不同的是，需要事先安装好　Ａｎｄｒｏｉｄ　的　ＵＳＢ　Ｄｒｉｖｅｒ，　并且通过　ＵＳＢ　联机至手机，在与手机联机的状况下，就可以让　Ｅｃｌｉｐｓｅ　在运行　Ａｎｄｒｏｉｄ　程序时，直接将程序部署于实机环境中执行。　Ａｎｄｒｏｉｄ　ＵＳＢ　驱动程序是随着　Ａｎｄｒｏｉｄ　ＳＤＫ　所提供的，每一个版本的　ＳＤＫ　都　可能有不同版本的　ＵＳＢ　Ｄｒｉｖｅｒ　Ｖｅｒｓｉｏｎ，其存放在以下　Ａｎｄｒｏｉｄ　ＳＤＫ　解开后的　参考位置，如：　Ｄ：＼ＳＤＫ＼ａｎｄｒｏｉｄ＼ｕｓｂ＿ｄｒｉｖｅｒ＼　安装的步骤是先将手机以　ＵＳＢ　与计算机连接，操作系统会找到名为　Ａｎｄｒｏｉｄ　Ｐｈｏｎｅ　的设备，但是却在装置管理员当中无法正确被识别，如下所示。

　　　　▲图　２－２１

　　　　操作系统找到名为　Ａｎｄｒｏｉｄ　Ｐｈｏｎｅ　的装置，但无法正确被识别

　　　　接着画面会跳出添加硬件向导，选择“从列表或指定位置安装（高级）”来　自行挑选驱动程序位置。　　　　▲图　２－２２

　　　　选择“从列表或指定位置安装”自己安装驱动程序

　　　　在“搜索和安装选项”的画面中，选择“不要搜索，我要自己选择要安装的　驱动程序”选项，选择“显示所有设备”后，按下“下一步”。　　　　▲图　２－２３

　　　　选择不要搜索系统数据，改以自行挑选硬件的方式

　　　　利用浏览按钮选择复制源为　Ａｎｄｒｏｉｄ　ＵＳＢ　Ｄｒｉｖｅｒ　程序路径：　　　　▲图　２－２４

　　　　选择　Ａｎｄｒｏｉｄ　ＳＤＫ　里所附的　ＵＳＢ　Ｄｒｉｖｅｒ

　　　　选择驱动程序后，于显示兼容硬件列表中选择“ＨＴＣ　Ｄｒｅａｍ　Ｃｏｍｐｏｓｉｔｅ　ＡＤＢ　Ｉｎｔｅｒｆａｃｅ”，程序将　Ａｎｄｒｏｉｄ　手机的　ＵＳＢ　ＡＤＢ　Ｉｎｔｅｒｆａｃｅ　安装完成。　　　　▲图　２－２５

　　　　安装　Ａｎｄｒｏｉｄ　ＵＳＢ　ＡＤＢ　Ｉｎｔｅｒｆａｃｅ　完成

　　　　设备管理器会自动新增一项　ＡＤＢ　Ｉｎｔｅｒｆａｃｅ　的项目，表示已经顺利安装了　Ａｎｄｒｏｉｄ　手机与计算机的联机。　　　　▲图　２－２６

　　　　顺利安装了　Ａｎｄｒｏｉｄ　手机与计算机的联机

　　　　安装完　ＡＤＢ　Ｉｎｔｅｒｆａｃｅ　之后，暂时还无法通过　Ｅｃｌｉｐｓｅ　将　Ａｎｄｒｏｉｄ　项目程序　部署至手机上，必须先将手机上的　ＵＳＢ　调试（Ｄｅｂｕｇ）模式打开，在手机上执行　“应用程序设置—开发＞＞ＵＳＢ　调试”。　　　　▲图　２－２７

　　　　将手机的　ＵＳＢ　调式模式打开

　　　　在　Ｅｃｌｉｐｓｅ　执行项目时，若程序发现先前已打开的模拟器与手机同时并存，　那么将会跳出　Ｄｅｖｉｃｅ　Ｃｈｏｏｓｅｒ　的窗口让开发者选择要部署的设备，下图为选择　Ａｎｄｒｏ

ｐａｇｅ　４

ｉｄ　Ｇ１　手机之后，于　Ｃｏｎｓｏｌｅ　里显示正确执行的　Ｌｏｇ　纪录。　　　　▲图　２－２８

　　　　上图中的警告为开发使用的是　ＳＤＫ　１．１　但手机是　ＳＤＫ　１．０　的警告

　　　　部署程序到手机上测试是最适合的方法，因为许多功能皆需要手机才能进行　测试，如　ＷｉＦｉ　驱动程序、平衡感应器、电池剩余计量等等。　看完了本章介绍的内容，相信各位已快速掌握了　Ａｎｄｒｏｉｄ　ＳＤＫ　的安装方法、　Ｅｃｌｉｐｓｅ　开发环境的设置、使用可视化布局开发工具，以及试写了一个　Ａｎｄｒｏｉｄ　Ｈｅｌｌｏ　Ｗｏｒｌｄ　的应用程序（咳～虽然一行程序都没写～），最后将程序部署于实　机上运行，这是每一位　Ａｎｄｒｏｉｄ　程序员都必须快速掌握的重点，也是进入本书范　例必须要具备的基本操作能力。　接下来将是丰富精彩的范例系列，相信通过边学　边操作，你将获得更多宝贵的实战经验，祝大家学习愉快！

　　　　第三章：用户人机界面　　　　范例说明

　　　　前一章写了　Ｈｅｌｌｏ　Ｗｏｒｌｄ　之后，一直觉得没有写半行代码对不起自己，所以在本章人机　界面一开始，则延续　Ｈｅｌｌｏ　Ｗｏｌｒｄ　的气势，进行与　ＴｅｘｔＶｉｅｗ　文字标签的第一次接触。在此范　例中，将会在　Ｌａｙｏｕｔ　中创建　ＴｅｘｔＶｉｅｗ　对象，并学会定义　ｒｅｓ／ｖａｌｕｅｓ／ｓｔｒｉｎｇｓ．ｘｍｌ　里的字符串　常数，最后通过　ＴｅｘｔＶｉｅｗ　的　ｓｅｔＴｅｘｔ　方法，在预加载程序之初，更改　ＴｅｘｔＶｉｅｗ　文字。　　　　运行结果

　　　　▲图　３－１　认识　ＴｅｘｔＶｉｅｗ．ｓｅｔＴｅｘｔ　更改默认　Ｌａｙｏｕｔ　里定义的文本字符串　　　　范例程序

　　　　ｓｒｃ／ｉｒｄｃ．ｅｘ０３＿０１／ＥＸ０３＿０１．ｊａｖａ

　　　　主程序示范以　ｓｅｔＴｅｘｔ　方法，输出　Ｓｔｒｉｎｇ　类型的字符串变量。

　　　　ｐａｃｋａｇｅ　ｉｒｄｃ．ｅｘ０３＿０１；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ａｐｐ．Ａｃｔｉｖｉｔｙ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｏｓ．Ｂｕｎｄｌｅ；　／＊必须引用　ｗｉｄｇｅｔ．ＴｅｘｔＶｉｅｗ　才能在程序里声明　ＴｅｘｔＶｉｅｗ　对象＊／　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＴｅｘｔＶｉｅｗ；　ｐｕｂｌｉｃ　ｃｌａｓｓ　ＥＸ０３＿０１　ｅｘｔｅｎｄｓ　Ａｃｔｉｖｉｔｙ　｛

　　　　／＊必须引用　ｗｉｄｇｅｔ．ＴｅｘｔＶｉｅｗ　才能在程序里声明　ＴｅｘｔＶｉｅｗ　对象＊／　ｐｒｉｖａｔｅ　ＴｅｘｔＶｉｅｗ　ｍＴｅｘｔＶｉｅｗ０１；

　　　　／＊＊　Ｃａｌｌｅｄ　ｗｈｅｎ　ｔｈｅ　ａｃｔｉｖｉｔｙ　ｉｓ　ｆｉｒｓｔ　ｃｒｅａｔｅｄ．　＊／　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｒｅａｔｅ（Ｂｕｎｄｌｅ　ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）　｛　ｓｕｐｅｒ．ｏｎＣｒｅａｔｅ（ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）；

　　　　／＊　载入　ｍａｉｎ．ｘｍｌ　Ｌａｙｏｕｔ，此时　ｍｙＴｅｘｔＶｉｅｗ０１：ｔｅｘｔ　为　ｓｔｒ＿１　＊／　ｓｅｔＣｏｎｔｅｎｔＶｉｅｗ（Ｒ．ｌａｙｏｕｔ．ｍａｉｎ）；

　　　　／＊　使用　ｆｉｎｄＶｉｅｗＢｔＩｄ　函数，利用　ＩＤ　找到该　ＴｅｘｔＶｉｅｗ　对象　＊／　ｍＴｅｘｔＶｉｅｗ０１　＝　（ＴｅｘｔＶｉｅｗ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＴｅｘｔＶｉｅｗ０１）；

　　　　Ｓｔｒｉｎｇ　ｓｔｒ＿２　＝　＂欢迎来到　Ａｎｄｒｏｉｄ　的　ＴｅｘｔＶｉｅｗ　世界……＂；　ｍＴｅｘｔＶｉｅｗ０１．ｓｅｔＴｅｘｔ（ｓｔｒ＿２）；　｝　｝

　　　　ｒｅｓ／ｌａｙｏｕｔ／ｍａｉｎ．ｘｍｌ

　　　　以　ａｎｄｒｏｉｄ：ｉｄ　命名　ＴｅｘｔＶｉｅｗ　的　ＩＤ　为　ｍＴｅｘｔＶｉｅｗ０１；在较旧的版本写法与　１．０　的不同，　请特别留意。

　　　　＜？ｘｍｌ　ｖｅｒｓｉｏｎ＝＂１．０＂　ｅｎｃｏｄｉｎｇ＝＂ｕｔｆ－８＂？＞

　　　　＜ＴｅｘｔＶｉｅｗ　ａｎｄｒｏｉｄ：ｉｄ＝＂＠＋ｉｄ／ｍｙＴｅｘｔＶｉｅｗ０１＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｗｉｄｔｈ＝＂ｗｒａｐ＿ｃｏｎｔｅｎｔ＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｈｅｉｇｈｔ＝＂ｗｒａｐ＿ｃｏｎｔｅｎｔ＂　ａｎｄｒｏｉｄ：ｔｅｘｔ＝＂＠ｓｔｒｉｎｇ／ｓｔｒ＿１＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｘ＝＂６１ｐｘ＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｙ＝＂６９ｐｘ＂　＞　＜／ＴｅｘｔＶｉｅｗ＞　　　　　扩展学习

　　　　ＴｅｘｔＶｉｅｗ　里的　ｓｅｔＴｅｘｔ　方法支持以下多态构造方法：

　　　　ｐｕｂｌｉｃ　ｆｉｎａｌ　ｖｏｉｄ　ｓｅｔＴｅｘｔ（ＣｈａｒＳｅｑｕｅｎｃｅ　ｔｅｘｔ）　ｐｕｂｌｉｃ　ｆｉｎａｌ　ｖｏｉｄ　ｓｅｔＴｅｘｔ（ｉｎｔ　ｒｅｓｉｄ）　ｐｕｂｌｉｃ　ｖｏｉｄ　ｓｅｔＴｅｘｔ（ＣｈａｒＳｅｑｕｅｎｃｅ　ｔｅｘｔ，　ＴｅｘｔＶｉｅｗ．ＢｕｆｆｅｒＴｙｐｅ　ｔｙｐｅ）　ｐｕｂｌｉｃ　ｆｉｎａｌ　ｖｏｉｄ　ｓｅｔＴｅｘｔ（ｉｎｔ　ｒｅｓｉｄ，　ＴｅｘｔＶｉｅｗ．ＢｕｆｆｅｒＴｙｐｅ　ｔｙｐｅ）　ｐｕｂｌｉｃ　ｆｉｎａｌ　ｖｏｉｄ　ｓｅｔＴｅｘｔ（ｃｈａｒ［］　ｔｅｘｔ，　ｉｎｔ　ｓｔａｒｔ，　ｉｎｔ　ｌｅｎ）

　　　　在此，以最后　ｓｅｔＴｅｘｔ（ｃｈａｒ［］　ｔｅｘｔ，　ｉｎｔ　ｓｔａｒｔ，　ｉｎｔ　ｌｅｎ）　为例，第一个参数为　ｃｈａｒ　数组作为输　出依　据，第二个参数为从哪一个元素索引开始选取，第三个参

ｐａｇｅ　５

数则为要取出多少个元素，请看以　下的例子：

　　　　ｃｈａｒ　ｃｈａｒ＿１［］　＝　ｎｅｗ　ｃｈａｒ［５］；　ｃｈａｒ＿１［０］　＝　＇Ｄ＇；　ｃｈａｒ＿１［１］　＝　＇ａ＇；　ｃｈａｒ＿１［２］　＝　＇ｖ＇；　ｃｈａｒ＿１［３］　＝　＇ｉ＇；　ｃｈａｒ＿１［４］　＝　＇ｄ＇；　ｍＴｅｘｔＶｉｅｗ０１．ｓｅｔＴｅｘｔ（ｃｈａｒ＿１，１，３）；

　　　　如上述程序所示，输出的结果是“ａｖｉ”，因为从第　１　个元素索引开始，共取　３　个元素；　最　后则要提醒你，ＴｅｘｔＶｉｅｗ．ｓｅｔＴｅｘｔＶｉｅｗ　不支持　ＨＴＭＬ　ＴＡＧ　的输出，所以即便写成这样：

　　　　ｍＴｅｘｔＶｉｅｗ０１．ｓｅｔＴｅｘｔ（＂戴维　的博客＂）；

　　　　实际　输出时，　也就是纯文本而已，并不会作　ＨＴＭＬ　ＴＡＧ　的转换。但若撇开　ＨＴＭＬ　ＴＡＧ　之外（如“＜”开头的标记）　，在　ＴｅｘｔＶｉｅｗ　里加上了　ａｎｄｒｏｉｄ：ａｕｔｏＬｉｎｋ＝＂ａｌｌ＂，那么正文中若有网　址　（ｈｔｔｐ：／／）　，是可以被显示的，以下这个范例就交给你自己实现看看。　　　　＜ＴｅｘｔＶｉｅｗ

　　　　ｘｍｌｎｓ：ａｎｄｒｏｉｄ＝＂ｈｔｔｐ：／／ｓｃｈｅｍａｓ．ａｎｄｒｏｉｄ．ｃｏｍ／ａｐｋ／ｒｅｓ／ａｎｄｒｏｉｄ＂

　　　　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｗｉｄｔｈ＝＂ｆｉｌｌ＿ｐａｒｅｎｔ＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｈｅｉｇｈｔ＝＂ｗｒａｐ＿ｃｏｎｔｅｎｔ＂　ａｎｄｒｏｉｄ：ａｕｔｏＬｉｎｋ＝＂ａｌｌ＂　ａｎｄｒｏｉｄ：ｔｅｘｔ＝＂请访问戴维的博客：ｈｔｔｐ：／／ｓｈｏｐ．ｔｅａｃ．ｉｄｖ．ｔｗ／ＭｙＢｌｏｇ／＂　／＞　　　　范例说明

　　　　在之前的范例运行结果，窗口的底色一律是“深黑色”，这是　ＳＤＫ　默认的颜色，要更改　Ａｃｔｉｖｉｔｙ　里的窗口底色有许多方法，　最简单的方法就是将颜色色码事先定义在　ｄｒａｗａｂｌｅ　当中，

　　　　当程序　ｏｎＣｒｅａｔｅ　创建的同时，加载预先定义的画面颜色。　此范例程序的设计方式是在　ｄｒａｗａｂｌｅ　里指定　Ｌａｙｏｕｔ　的背景色（ＢａｃｋＧｒｏｕｎｄ）为白色，　但这里的“白色”（颜色色码为＃ＦＦＦＦＦＦＦＦ）预先定义在　ｄｒａｗａｂｌｅ　当中，当程序运行时，背景　就会变为白色。　这是指定　Ａｃｔｉｖｉｔｙ　Ｌａｙｏｕｔ　背景颜色最简单的方法，在范例最末，则将示范如何创建色彩　板（ｃｏｌｏｒ　ｔａｂｌｅ）　，让　Ａｎｄｒｏｉｄ　手机程序可以像使用“常数”般直接取用，并反应在应用程序的　运行阶段。　　　　运行结果

　　　　▲图　３－２　使用　ｄｒａｗａｂｌｅ　设置颜色常数，应用于程序运行时的结果　　　　范例程序

　　　　ｓｒｃ／ｉｒｄｃ．ｅｘ０３＿０２／ＥＸ０３＿０２．ｊａｖａ

　　　　程序继承自　Ａｃｔｉｖｉｔｙ　类，　并在重写　ｏｎＣｒｅａｔｅ　创建之初，　直接显示　Ｒ．ｌａｙｏｕｔ．ｍａｉｎ　ｍａｉｎ．ｘｍｌ）　（　这个页面安排的布局配置。

　　　　ｐａｃｋａｇｅ　ｉｒｄｃ．ｅｘ０３＿０２；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ａｐｐ．Ａｃｔｉｖｉｔｙ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｏｓ．Ｂｕｎｄｌｅ；　ｐｕｂｌｉｃ　ｃｌａｓｓ　ＥＸ０３＿０２　ｅｘｔｅｎｄｓ　Ａｃｔｉｖｉｔｙ

　　　　｛　／＊＊　Ｃａｌｌｅｄ　ｗｈｅｎ　ｔｈｅ　ａｃｔｉｖｉｔｙ　ｉｓ　ｆｉｒｓｔ　ｃｒｅａｔｅｄ．　＊／　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｒｅａｔｅ（Ｂｕｎｄｌｅ　ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）　｛　ｓｕｐｅｒ．ｏｎＣｒｅａｔｅ（ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）；　ｓｅｔＣｏｎｔｅｎｔＶｉｅｗ（Ｒ．ｌａｙｏｕｔ．ｍａｉｎ）；　｝　｝　　　　ｒｅｓ／ｌａｙｏｕｔ／ｍａｉｎ．ｘｍｌ

　　　　在页面布局上，使用了　２　个　ＴｅｘｔＶｉｅｗ　对象，以及　２　个　ＥｄｉｔＴｅｘｔ　对象，关键在于　ａｎｄｒｏｉｄ：　ｂａｃｋｇｒｏｕｎｄ＝＂＠ｄｒａｗａｂｌｅ／ｗｈｉｔｅ＂　让程序背景变成了白色，而　ａｎｄｒｏｉｄ：ｔｅｘｔＣｏｌｏｒ＝＂＠ｄｒａｗａｂｌｅ／　ｄａｒｋｇｒａｙ＂　将　ＴｅｘｔＶｉｅｗ　里　的　文　字　颜　色　（　ｔｅｘｔＣｏｌｏｒ　）　设　为　灰　色　，　当　中　“＠ｄｒａｗａｂｌｅ／ｗｈｉｔｅ”及　“＠ｄｒａｗａｂｌｅ／ｄａｒｋｇｒａｙ”　的　写　法　则　是　参　考　事　先　于　ｄｒａｗａｂｌｅ　里　定　义　好　的　颜　色　常　数　，　将　在　ｒｅｓ／ｖａｌｕｅｓ／ｃｏｌｏｒ．ｘｍｌ　里看见颜色的定义描述。

　　　　＜？ｘｍｌ　ｖｅｒｓｉｏｎ＝＂１．０＂　ｅｎｃｏｄｉｎｇ＝＂ｕｔｆ－８＂？＞　　＜ＴｅｘｔＶｉｅｗ

　　　　ａｎｄｒｏｉｄ：ｉｄ＝＂＠＋ｉｄ／ｗｉｄｇｅｔ２８＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｗｉｄｔｈ＝＂ｗｒａｐ＿ｃｏｎｔｅｎｔ＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｈｅｉｇｈｔ＝＂ｗｒａｐ＿ｃｏｎｔｅｎｔ＂　ａｎｄｒｏｉｄ：ｔｅｘｔ＝＂＠ｓｔｒｉｎｇ／ｓｔｒ＿ｉｄ＂　ａｎｄｒｏｉｄ：ｔｅｘｔＣｏｌｏｒ＝＂＠ｄｒａｗａｂｌｅ／ｄａｒｋｇｒａｙ＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｘ＝＂６１ｐｘ＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｙ＝＂６９ｐｘ＂　＞　＜／ＴｅｘｔＶｉｅｗ＞　＜ＴｅｘｔＶｉｅｗ　ａｎｄｒｏｉｄ：ｉｄ＝＂＠＋ｉｄ／ｗｉｄｇｅｔ２９＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｗｉｄｔｈ＝＂ｗｒａｐ＿ｃｏｎｔｅｎｔ＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｈｅｉｇｈｔ＝＂ｗｒａｐ＿ｃｏｎｔｅｎｔ＂　ａｎｄｒｏｉｄ：ｔｅｘｔ＝＂＠ｓｔｒｉｎｇ／ｓｔｒ＿ｐｗｄ＂　ａｎｄｒｏｉｄ：ｔｅｘｔＣｏｌｏｒ＝＂＠ｄｒａｗａｂｌｅ／ｄａｒｋｇｒａｙ＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｘ＝＂６１ｐｘ＂　ａｎｄｒ

ｐａｇｅ　６

ｏｉｄ：ｌａｙｏｕｔ＿ｙ＝＂１５８ｐｘ＂　＞　＜／ＴｅｘｔＶｉｅｗ＞　＜ＥｄｉｔＴｅｘｔ　ａｎｄｒｏｉｄ：ｉｄ＝＂＠＋ｉｄ／ｗｉｄｇｅｔ３１＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｗｉｄｔｈ＝＂１２０ｄｉｐ＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｈｅｉｇｈｔ＝＂ｗｒａｐ＿ｃｏｎｔｅｎｔ＂　ａｎｄｒｏｉｄ：ｔｅｘｔＳｉｚｅ＝＂１８ｓｐ＂

　　　　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｘ＝＂１１４ｐｘ＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｙ＝＂５７ｐｘ＂　＞　＜／ＥｄｉｔＴｅｘｔ＞　＜ＥｄｉｔＴｅｘｔ　ａｎｄｒｏｉｄ：ｉｄ＝＂＠＋ｉｄ／ｗｉｄｇｅｔ３０＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｗｉｄｔｈ＝＂１２０ｄｉｐ＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｈｅｉｇｈｔ＝＂ｗｒａｐ＿ｃｏｎｔｅｎｔ＂　ａｎｄｒｏｉｄ：ｔｅｘｔＳｉｚｅ＝＂１８ｓｐ＂　ａｎｄｒｏｉｄ：ｐａｓｓｗｏｒｄ＝＂ｔｒｕｅ＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｘ＝＂１１２ｐｘ＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｙ＝＂１４２ｐｘ＂　＞　＜／ＥｄｉｔＴｅｘｔ＞　　　　　扩展学习

　　　　事先将　定义好的颜色代码（ｃｏｌｏｒ　ｃｏｄｅ）以　ｄｒａｗａｂｌｅ　的名称（ｎａｍｅ）存放于　ｒｅｓｏｕｒｃｅｓ　当中，这是开发　Ａｎｄｒｏｉｄ　程序的好习惯，正如同字符串常数一样，颜色也是可　以事先定义　好的。在本范例中学会了使用　ｄｒａｗａｂｌｅ　的　ｒｅｓｏｕｒｃｅ　的定义方法：

　　　　＜ｄｒａｗａｂｌｅ　ｎａｍｅ＝ｃｏｌｏｒ＿ｎａｍｅ＞ｃｏｌｏｒ＿ｖａｌｕｅ＜／ｄｒａｗａｂｌｅ＞

　　　　定义好的　ｄｒａｗａｂｌｅ　ｎａｍｅ　常数，必须存放于　ｒｅｓ／ｖａｌｕｅｓ　下面，作为资源取用，但定义好的　背景颜色并非只能当作是“默认”颜色声明使用，　在程序的事件里，　是可以通过程序来更改的，　如以下程序所示：

　　　　Ｒｅｓｏｕｒｃｅｓ　ｒｅｓｏｕｒｃｅｓ　＝　ｇｅｔＢａｓｅＣｏｎｔｅｘｔ（）．ｇｅｔＲｅｓｏｕｒｃｅｓ（）；　Ｄｒａｗａｂｌｅ　ＨｉｐｐｏＤｒａｗａｂｌｅ　＝　ｒｅｓｏｕｒｃｅｓ．ｇｅｔＤｒａｗａｂｌｅ（Ｒ．ｄｒａｗａｂｌｅ．ｗｈｉｔｅ）；

　　　　ＴｅｘｔＶｉｅｗ　ｔｖ　＝　（ＴｅｘｔＶｉｅｗ）ｆｉｎｄＶｉｅｗＢｙＩＤ（Ｒ．ｉｄ．ｔｅｘｔ）；　ｔｖ．ｓｅｔＢａｃｋｇｒｏｕｎｄ（ＨｉｐｐｏＤｒａｗａｂｌｅ）；　　　　范例说明

　　　　上一个范例通过　Ｄｒａｗａｂｌｅ　来定义颜色常数，但实际设计中最常用的方法，则是使用程　序控制　ＴｅｘｔＶｉｅｗ　或其它对象的背景色（ｓｅｔＢａｃｋｇｒｏｕｎｄＤｒａｗａｂｌｅ　方法）　如判断对象被点击时　，　的背景色亮起、当失去焦点时，又恢复成原来的背景色等等。　以下的范例，将扩展前一个范例的实现，预先在　Ｌａｙｏｕｔ　当中设计好两个　ＴｅｘｔＶｉｅｗ，并　在　ｏｎＣｒｅａｔｅ　同时，　通过两种程序描述方法，　实时更改原来　Ｌａｙｏｕｔ　里　ＴｅｘｔＶｉｅｗ　的背景色以　及　文字颜色，最后学会使用　Ａｎｄｒｏｉｄ　默认的颜色常数（ｇｒａｐｈｉｃｓ．Ｃｏｌｏｒ）来更改文字的前景色。　　　　运行结果

　　　　▲图　３－３　通过　ｓｅｔＢａｃｋｇｒｏｕｎｄＤｒａｗａｂｌｅ　方法更改　ＴｅｘｔＶｉｅｗ　的背景色以及　ｇｒａｐｈｉｃｓ．Ｃｏｌｏｒ　更改前景色　　　　范例程序

　　　　ｓｒｃ／ｉｒｄｃ．ｅｘ０３＿０３／ＥＸ０３＿０３．ｊａｖａ

　　　　程序里新建两个类成员变量：　ｍＴｅｘｔＶｉｅｗ０１　与　ｍＴｅｘｔＶｉｅｗ０２，这两个变量在　ｏｎＣｒｅａｔｅ　之初，以　ｆｉｎｄＶｉｅｗＢｙＩｄ　方法使之初始化为　ｌａｙｏｕｔ（ｍａｉｎ．ｘｍｌ）里的　ＴｅｘｔＶｉｅｗ　对象。在当中　使用了　Ｒｅｓｏｕｒｃｅ　类以及　Ｄｒａｗａｂｌｅ　类，分别创建了　ｒｅｓｏｕｒｃｅｓ　对象以及　ＨｉｐｐｏＤｒａｗａｂｌｅ　对象，　并　将　前　一　个　范　例　中　所　创　建　的　Ｒ．ｄｒａｗａｂｌｅ．ｗｈｉｔｅ　以　ｇｅｔＤｒａｗａｂｌｅ　方　法　加　载　，　最　后　则　调　用　了　ｓｅｔＢａｃｋｇｒｏｕｎｄＤｒａｗａｂｌｅ　来更改　ｍＴｅｘｔＶｉｅｗ０１　的文字底纹。更改　ＴｅｘｔＶｉｅｗ　里的文字，则使用　了　ｓｅｔＴｅｘｔ　方法。

　　　　在　ｍＴｅｘｔＶｉｅｗ０２　当中，使用了　ｇｒａｐｈｉｃｓ．Ｃｏｌｏｒ　里的颜色常数，接着，再利用　ｓｅｔＴｅｘｔＣｏｌｏｒ　更改文字的前景色。

　　　　ｐａｃｋａｇｅ　ｉｒｄｃ．ｅｘ０３＿０３；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ａｐｐ．Ａｃｔｉｖｉｔｙ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｃｏｎｔｅｎｔ．ｒｅｓ．Ｒｅｓｏｕｒｃｅｓ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｇｒａｐｈｉｃｓ．Ｃｏｌｏｒ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｇｒａｐｈｉｃｓ．ｄｒａｗａｂｌｅ．Ｄｒａｗａｂｌｅ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｏｓ．Ｂｕｎｄｌｅ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＴｅｘｔＶｉｅｗ；　ｐｕｂｌｉｃ　ｃｌａｓｓ　ＥＸ０３＿０３　ｅｘｔｅｎｄｓ　Ａｃｔｉｖｉｔｙ　｛　ｐｒｉｖａｔｅ　ＴｅｘｔＶｉｅｗ　ｍＴｅｘｔＶｉｅｗ０１；　ｐｒｉｖａｔｅ　ＴｅｘｔＶｉｅｗ　ｍＴｅｘｔＶｉｅｗ０２；

　　　　／＊＊　Ｃａｌｌｅｄ　ｗｈｅｎ　ｔｈｅ　ａｃｔｉｖｉｔｙ　ｉｓ　ｆｉｒｓｔ　ｃｒｅａｔｅｄ．　＊／　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｒｅａｔｅ（Ｂｕｎｄｌｅ　ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）　｛　ｓｕｐｅｒ．ｏｎＣｒｅａｔｅ（ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）；　ｓｅｔＣｏｎｔｅｎｔＶｉｅｗ（Ｒ．ｌａｙｏｕｔ．ｍａｉｎ）；

　　　　ｍＴｅｘｔＶｉｅｗ０１　＝　（ＴｅｘｔＶｉｅｗ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＴｅｘｔＶｉｅｗ０１）；　ｍＴｅｘｔＶｉｅｗ０１．ｓｅｔＴｅｘｔ（＂我是应用　Ｄｒａｗａｂｌｅ　背景色的戴维文本。＂）；

ｐａｇｅ　７

　　　　Ｒｅｓｏｕｒｃｅｓ　ｒｅｓｏｕｒｃｅｓ　＝　ｇｅｔＢａｓｅＣｏｎｔｅｘｔ（）．ｇｅｔＲｅｓｏｕｒｃｅｓ（）；　Ｄｒａｗａｂｌｅ　ＨｉｐｐｏＤｒａｗａｂｌｅ　＝　ｒｅｓｏｕｒｃｅｓ．ｇｅｔＤｒａｗａｂｌｅ（Ｒ．ｄｒａｗａｂｌｅ．ｗｈｉｔｅ）；　ｍＴｅｘｔＶｉｅｗ０１．ｓｅｔＢａｃｋｇｒｏｕｎｄＤｒａｗａｂｌｅ（ＨｉｐｐｏＤｒａｗａｂｌｅ）；

　　　　ｍＴｅｘｔＶｉｅｗ０２　＝　（ＴｅｘｔＶｉｅｗ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＴｅｘｔＶｉｅｗ０２）；

　　　　／＊下使用　Ｃｏｌｏｒ．ＭＡＧＥＮＴＡ　指定文本的颜色为紫红色＊／　ｍＴｅｘｔＶｉｅｗ０２．ｓｅｔＴｅｘｔＣｏｌｏｒ（Ｃｏｌｏｒ．ＭＡＧＥＮＴＡ）；　｝　｝　　　　扩展学习

　　　　Ｒｅｓｏｕｒｃｅｓ　ｒｅｓｏｕｒｃｅｓ　＝　ｇｅｔＢａｓｅＣｏｎｔｅｘｔ（）．ｇｅｔＲｅｓｏｕｒｃｅｓ（）；　Ｄｒａｗａｂｌｅ　ＨｉｐｐｏＤｒａｗａｂｌｅ　＝　ｒｅｓｏｕｒｃｅｓ．ｇｅｔＤｒａｗａｂｌｅ（Ｒ．ｄｒａｗａｂｌｅ．ｗｈｉｔｅ）；　　　　上述这　２　行代码，在前一版本中的写法是这样的：

　　　　Ｒｅｓｏｕｒｃｅｓ．ｒｅｓｏｕｒｃｅｓ　＝　ｇｅｔＤｒａｗａｂｌｅ（Ｒ．ｄｒａｗａｂｌｅ．ｓｏｌｉｄ＿ｒｅｄ）；　Ｄｒａｗａｂｌｅ　ＨｉｐｐｏＤｒａｗａｂｌｅ　＝　ｒｅｓｏｕｒｃｅｓ．ｇｅｔＤｒａｗａｂｌｅ（Ｒ．ｄｒａｗａｂｌｅ．ｗｈｉｔｅ）；

　　　　但　是在　１．０　之　后的版本，　Ｒｅｓｏｕｒｃｅｓ　不　再支持直接使用　．ｇｅｔＤｒａｗａｂｌｅ　方　法直接取　用　ｄｒａｗａｂｌｅ，而必须先取得基类的　Ｃｏｎｔｅｘｔ　才行。　此外，在程序里使用了　Ｃｏｌｏｒ．ＭＡＧＥＮＴＡ　让　ＴｅｘｔＶｉｅｗ　里的文字变成了粉红色，事实上，　在　Ａｎｄｒｏｉｄ　里还有以下　１２　种常见的颜色：

　　　　Ｃｏｌｏｒ．ＢＬＡＣＫ　Ｃｏｌｏｒ．ＢＬＵＥ　Ｃｏｌｏｒ．ＣＹＡＮ　Ｃｏｌｏｒ．ＤＫＧＲＡＹ

　　　　Ｃｏｌｏｒ．ＧＲＡＹ　Ｃｏｌｏｒ．ＧＲＥＥＮ　Ｃｏｌｏｒ．ＬＴＧＲＡＹ　Ｃｏｌｏｒ．ＭＡＧＥＮＴＡ　Ｃｏｌｏｒ．ＲＥＤ　Ｃｏｌｏｒ．ＴＲＡＮＳＰＡＲＥＮＴ　Ｃｏｌｏｒ．ＷＨＩＴＥ　Ｃｏｌｏｒ．ＹＥＬＬＯＷ

　　　　这些颜色常数是定义在　ａｎｄｒｏｉｄ．ｇｒａｐｈｉｃｓ．Ｃｏｌｏｒ　里的：　　　　类型　ｉｎｔ　ｉｎｔ　ｉｎｔ　ｉｎｔ　ｉｎｔ　ｉｎｔ　ｉｎｔ　ｉｎｔ　ｉｎｔ　ｉｎｔ　ｉｎｔ　ｉｎｔ

　　　　常数　ＢＬＡＣＫ　ＢＬＵＥ　ＣＹＡＮ　ＤＫＧＲＡＹ　ＧＲＡＹ　ＧＲＥＥＮ　ＬＴＧＲＡＹ　ＭＡＧＥＮＴＡ　ＲＥＤ　ＴＲＡＮＳＰＡＲＥＮＴ　ＷＨＩＴＥ　ＹＥＬＬＯＷ

　　　　值　－１６７７７２１６　－１６７７６９６１　－１６７１１６８１　－１２３０３２９２　－７８２９３６８　－１６７１１９３６　－３３５５４４４　－６５２８１　－６５５３６　０　－１　－２５６

　　　　色码　０ｘｆｆ００００００　０ｘｆｆ００００ｆｆ　０ｘｆｆ００ｆｆｆｆ　０ｘｆｆ４４４４４４　０ｘｆｆ８８８８８８　０ｘｆｆ００ｆｆ００　０ｘｆｆｃｃｃｃｃｃ　０ｘｆｆｆｆ００ｆｆ　０ｘｆｆｆｆ００００　０ｘ００００００００　０ｘｆｆｆｆｆｆｆｆ　０ｘｆｆｆｆｆｆ００　　　　范例说明

　　　　从一开始自　Ｌａｙｏｕｔ　里通过　Ｒｅｓｏｕｒｃｅ　初始　化　ＴｅｘｔＶｉｅｗ　的文字，到程序中动态更　改　ＴｅｘｔＶｉｅｗ　文字，但要如何在代码里取得　Ｒｅｓｏｕｒｃｅ　的字符串呢？在　Ａｎｄｒｏｉｄ　里，确实是有些　方　法可以直接以　Ｒ．ｓｔｒｉｎｇ．＊直接转换　ＩＤ　为　Ｓｔｒｉｎｇ，不过，这样的数据类型转换是非常规甚至　是不妥的，正确的方法是利用　Ｃｏｎｔｅｘｔ．ｇｅｔＳｔｒｉｎｇ　方法来取得存放在　ｇｌｏｂａｌ　里的　Ｒｅｓｏｕｒｃｅ　ＩＤ。　以下这个范例将示范如何在程序运行时（ｒｕｎｔｉｍｅ）　，通过　ＣｈａｒＳｅｑｕｅｎｃｅ　依据　Ｒｅｓｏｕｒｃｅ　ＩＤ　取　出字符串，并正确更改　ＴｅｘｔＶｉｅｗ　的文字。　　　　运行结果

　　　　▲图　３－４　通过　ｊａｖａ．ｌａｎｇ．ＣｈａｒＳｅｑｕｅｎｃｅ　这个　Ｉｎｔｅｒｆａｃｅ　来取得存放在　ｇｌｏｂａｌ　里的　Ｒｅｓｏｕｒｃｅ　ＩＤ　　　　范例程序

　　　　ｓｒｃ／ｉｒｄｃ．ｅｘ０３＿０４／ＥＸ０３＿０４．ｊａｖａ

　　　　主程序的差异主要是在更改　ｍＴｅｘｔＶｉｅｗ０２　的文字时　（ｓｅｔＴｅｘｔ　方法）　合并了　ｓｔｒ＿３　与　ｓｔｒ＿２　，　这两个不同对象，由于　ｓｅｔＴｅｘｔ　方法同时支持　ＣｈａｒＳｅｑｕｅｎｃｅ　与　Ｓｔｒｉｎｇ　类型的参数，故在此示　范不同数据类型的字符串进行同步输出。

　　　　ｐａｃｋａｇｅ　ｉｒｄｃ．ｅｘ０３＿０４；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ａｐｐ．Ａｃｔｉｖｉｔｙ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｏｓ．Ｂｕｎｄｌｅ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＴｅｘｔＶｉｅｗ；　ｐｕｂｌｉｃ　ｃｌａｓｓ　ＥＸ０３＿０４　ｅｘｔｅｎｄｓ　Ａｃｔｉｖｉｔｙ　｛　ｐｒｉｖａｔｅ　ＴｅｘｔＶｉｅｗ　ｍＴｅｘｔＶｉｅｗ０２；

　　　　／＊＊　Ｃａｌｌｅｄ　ｗｈｅｎ　ｔｈｅ　ａｃｔｉｖｉｔｙ　ｉｓ　ｆｉｒｓｔ　ｃｒｅａｔｅｄ．　＊／　＠Ｏｖｅｒｒｉｄｅ

　　　　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｒｅａｔｅ（Ｂｕｎｄｌｅ　ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）　｛　ｓｕｐｅｒ．ｏｎＣｒｅａｔｅ（ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）；　ｓｅｔＣｏｎｔｅｎｔＶｉｅｗ（Ｒ．ｌａｙｏｕｔ．ｍａｉｎ）；

　　　　ｍＴｅｘｔＶｉｅｗ０２　＝　（ＴｅｘｔＶｉｅｗ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＴｅｘｔＶｉｅｗ０２）；　ＣｈａｒＳｅｑｕｅｎｃｅ　ｓｔｒ＿２　＝　ｇｅｔＳｔｒｉｎｇ（Ｒ．ｓｔｒｉｎｇ．ｓｔｒ＿２）；

　　　　Ｓｔｒｉｎｇ　ｓｔｒ＿３　＝　＂我是程序里调用　Ｒｅｓｏｕｒｃｅ　的＂；　ｍＴｅｘｔＶｉｅｗ０２．ｓｅｔＴｅｘｔ（ｓｔｒ＿

ｐａｇｅ　８

３　＋　ｓｔｒ＿２）；　｝　｝

　　　　ｒｅｓ／ｌａｙｏｕｔ／ｍａｉｎ．ｘｍｌ

　　　　为了作　为对比，在　ｍａｉｎ．ｘｍｌ　里创建了两个　ＴｅｘｔＶｉｅｗ，并采　ＬｉｎｅａｒＬａｙｏｕｔ　的方式配置，　一上一下，在运行结果中　ｉｄ　为　ｍｙＴｅｘｔＶｉｅｗ０１　的　ＴｅｘｔＶｉｅｗ　并没有任何文字的更改，维持一　开始的　ｓｔｒ＿１　参考字符串常数里的文字）　但在程序运行后，　为　ｍｙＴｅｘｔＶｉｅｗ０２　的　ＴｅｘｔＶｉｅｗ　（　，　ｉｄ　则作了文字的实时更改。　　　　＜？ｘｍｌ　ｖｅｒｓｉｏｎ＝＂１．０＂　ｅｎｃｏｄｉｎｇ＝＂ｕｔｆ－８＂？＞　

　　　　＜ＴｅｘｔＶｉｅｗ　ａｎｄｒｏｉｄ：ｉｄ＝＂＠＋ｉｄ／ｍｙＴｅｘｔＶｉｅｗ０１＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｗｉｄｔｈ＝＂ｗｒａｐ＿ｃｏｎｔｅｎｔ＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｈｅｉｇｈｔ＝＂ｗｒａｐ＿ｃｏｎｔｅｎｔ＂　ａｎｄｒｏｉｄ：ｔｅｘｔ＝＂＠ｓｔｒｉｎｇ／ｓｔｒ＿１＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｘ＝＂３０ｐｘ＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｙ＝＂５０ｐｘ＂　＞　＜／ＴｅｘｔＶｉｅｗ＞　＜ＴｅｘｔＶｉｅｗ　ａｎｄｒｏｉｄ：ｉｄ＝＂＠＋ｉｄ／ｍｙＴｅｘｔＶｉｅｗ０２＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｗｉｄｔｈ＝＂ｗｒａｐ＿ｃｏｎｔｅｎｔ＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｈｅｉｇｈｔ＝＂ｗｒａｐ＿ｃｏｎｔｅｎｔ＂　ａｎｄｒｏｉｄ：ｔｅｘｔ＝＂＠ｓｔｒｉｎｇ／ｓｔｒ＿２＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｘ＝＂３０ｐｘ＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｙ＝＂７０ｐｘ＂　＞　＜／ＴｅｘｔＶｉｅｗ＞　　　　　扩展学习

　　　　虽然在　ｖａｌｕｅｓ／ｓｔｒｉｎｇｓ．ｘｍｌ　里定义了默认的字符串常数，需留意若遭遇如　“？”、“＇”、“＼”等　符号时，必须使用转义字符（＼）　，如下：　　　　＼？　　　　＼＇　＼＼　　　　范例说明

　　　　在开发手机应用程序时，　除了底层对　ＡＰＩ　的掌握度之外，　最重要的仍是对屏幕分辨率的　概念，因各家手机厂商所采用的屏幕尺寸不同，ｕｓｅｒ　ＵＩ　接口呈现及布局自然也各异。　尽管　Ａｎｄｒｏｉｄ　可设置为随着窗口大小调整缩放比　例，但即便如此，手机程序设计人员　还是必须知道手机屏幕的边界，以避免缩放造成的布局（Ｌａｙｏｕｔ）变形问题。这个范例非常　的简短，只需几行程序即可取　得手机的分辨率，当中的关键则是　ＤｉｓｐｌａｙＭｅｔｒｉｃｓ　类的应用。　　　　运行结果

　　　　▲图　３－５　取得　Ａｎｄｒｏｉｄ　手机的实际屏幕分辨率　　　　范例程序

　　　　ｓｒｃ／ｉｒｄｃ．ｅｘ０３＿０５／ＥＸ０３＿０５．ｊａｖａ

　　　　在　ａｎｄｒｏｉｄ．ｕｔｉｌ　底下的　ＤｉｓｐｌａｙＭｅｔｒｉｃｓ　对象，记录了一些常用的信息，包含了显示信息、　大小、维度、字体等等；在使用时，请记得引用　ａｎｄｒｏｉｄ．ｕｔｉｌ．ＤｉｓｐｌａｙＭｅｔｒｉｃｓ。值得一提的是　ＤｉｓｐｌａｙＭｅｔｒｉｃｓ　对象里的　ｗｉｄｔｈＰｉｘｅｌｓ　及　ｈｅｉｇｈｔＰｉｘｅｌｓ　字段为整数类型，在以下的程序当中，　并没有对其作字符串类型的转换，因为字符串连接运算符的缘故，所以输出　ｓｔｒＯｐｔ　为字符　串。

　　　　ｐａｃｋａｇｅ　ｉｒｄｃ．ｅｘ０３＿０５；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ａｐｐ．Ａｃｔｉｖｉｔｙ；

　　　　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｏｓ．Ｂｕｎｄｌｅ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｕｔｉｌ．ＤｉｓｐｌａｙＭｅｔｒｉｃｓ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＴｅｘｔＶｉｅｗ；　ｐｕｂｌｉｃ　ｃｌａｓｓ　ＥＸ０３＿０５　ｅｘｔｅｎｄｓ　Ａｃｔｉｖｉｔｙ　｛　ｐｒｉｖａｔｅ　ＴｅｘｔＶｉｅｗ　ｍＴｅｘｔＶｉｅｗ０１；

　　　　／＊＊　Ｃａｌｌｅｄ　ｗｈｅｎ　ｔｈｅ　ａｃｔｉｖｉｔｙ　ｉｓ　ｆｉｒｓｔ　ｃｒｅａｔｅｄ．　＊／　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｒｅａｔｅ（Ｂｕｎｄｌｅ　ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）　｛　ｓｕｐｅｒ．ｏｎＣｒｅａｔｅ（ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）；　ｓｅｔＣｏｎｔｅｎｔＶｉｅｗ（Ｒ．ｌａｙｏｕｔ．ｍａｉｎ）；

　　　　／＊　必须引用　ａｎｄｒｏｉｄ．ｕｔｉｌ．ＤｉｓｐｌａｙＭｅｔｒｉｃｓ　＊／　ＤｉｓｐｌａｙＭｅｔｒｉｃｓ　ｄｍ　＝　ｎｅｗ　ＤｉｓｐｌａｙＭｅｔｒｉｃｓ（）；　ｇｅｔＷｉｎｄｏｗＭａｎａｇｅｒ（）．ｇｅｔＤｅｆａｕｌｔＤｉｓｐｌａｙ（）．ｇｅｔＭｅｔｒｉｃｓ（ｄｍ）；　　　　Ｓｔｒｉｎｇ　ｓｔｒＯｐｔ　＝　＂手机屏幕分辨率为：＂　＋　ｄｍ．ｗｉｄｔｈＰｉｘｅｌｓ　＋　＂　×　＂　＋　ｄｍ．ｈｅｉｇｈｔＰｉｘｅｌｓ；

　　　　ｍＴｅｘｔＶｉｅｗ０１　＝　（ＴｅｘｔＶｉｅｗ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＴｅｘｔＶｉｅｗ０１）；　ｍＴｅｘｔＶｉｅｗ０１．ｓｅｔＴｅｘｔ（ｓｔｒＯｐｔ）；　｝　　　　｝

　　　　扩展学习

　　　　程序一开始所创建的　ＤｉｓｐｌａｙＭｅｔｒｉｃｓ　对　象（程序中的　ｄｍ）　，不需要传递任何参数（构　造时）　，但在调用　ｇｅｔＷｉｎｄｏｗＭａｎａｇｅｒ（）之后，会取得现有的　Ａｃｔｉｖｉｔｙ　的　Ｈａｎｄｌｅｒ，此时，调　用　ｇｅｔＤｅｆａｕｌｔＤｉｓｐｌａｙ　方法将取得的宽高维度存放于　Ｄｉｓｐ

ｐａｇｅ　９

ｌａｙＭｅｔｒｉｃｓ　对象　ｄｍ　中，而取得的宽　高维度是　以像素为单位（Ｐｉｘｅｌ）　，“像素”所指的是“绝对像素”而非“相对像素”。　　　　范例说明

　　　　老是要一个个指定文字的大小、颜色也不是办法，有没　有类似　ＣＳＳ　样式的方法可用来　指定颜色、大小呢？事实上是有的，在　Ａｎｄｒｏｉｄ　程序开发过程中，也可以通过样式（Ｓｔｙｌｅ）　的方式，初始化　ＴｅｘｔＶｉｅｗ　的文本颜色、大小；当然这个范例只是抛砖引玉，在　Ｌａｙｏｕｔ　当中　的任何对象（以　ＸＭＬ　定义）都可以用样式化的方式来更改其外观。　在以下的范例中，将创建两个　ＴｅｘｔＶｉｅｗ　作为对比，使其呈现两种不同的样式差异作为　练习，而　Ｓｔｙｌｅ　的写法与先前介绍到的颜色常数（ｃｏｌｏｒ．ｘｍｌ）相同，同样是定义在　ｒｅｓ／ｖａｌｕｅｓ　下面，但其　ＸＭＬ　定义的方式不同来看看以下这个范例练习。

　　　　运行结果

　　　　▲图　３－６　利用　Ｓｔｙｌｅ　来初始化　ＴｅｘｔＶｉｅｗ　　　　范例程序

　　　　ｓｒｃ／ｉｒｄｃ．ｅｘ０３＿０６／ＥＸ０３＿０６．ｊａｖａ

　　　　主程序看起来非常干净，只有加载　Ｒ．ｌａｙｏｕｔ．ｍａｉｎ　定义布局内容而已，但由于定义在

　　　　ｍａｉｎ．ｘｍｌ　里的语句不同，自然也有不同的样貌呈现。

　　　　ｐａｃｋａｇｅ　ｉｒｄｃ．ｅｘ０３＿０６；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ａｐｐ．Ａｃｔｉｖｉｔｙ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｏｓ．Ｂｕｎｄｌｅ；　ｐｕｂｌｉｃ　ｃｌａｓｓ　ＥＸ０３＿０６　ｅｘｔｅｎｄｓ　Ａｃｔｉｖｉｔｙ　｛　／＊＊　Ｃａｌｌｅｄ　ｗｈｅｎ　ｔｈｅ　ａｃｔｉｖｉｔｙ　ｉｓ　ｆｉｒｓｔ　ｃｒｅａｔｅｄ．　＊／　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｒｅａｔｅ（Ｂｕｎｄｌｅ　ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）　｛　ｓｕｐｅｒ．ｏｎＣｒｅａｔｅ（ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）；　ｓｅｔＣｏｎｔｅｎｔＶｉｅｗ（Ｒ．ｌａｙｏｕｔ．ｍａｉｎ）；　｝　｝

　　　　ｒｅｓ／ｌａｙｏｕｔ／ｍａｉｎ．ｘｍｌ

　　　　诚如先前所述，初始化　ＴｅｘｔＶｉｅｗ　时，指定　Ｓｔｙｌｅ　属性，使其应用　ｓｔｙｌｅ．ｘｍｌ　里事先定义好　的样式。

　　　　＜？ｘｍｌ　ｖｅｒｓｉｏｎ＝＂１．０＂　ｅｎｃｏｄｉｎｇ＝＂ｕｔｆ－８＂？＞　

　　　　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｈｅｉｇｈｔ＝＂ｆｉｌｌ＿ｐａｒｅｎｔ＂　＞　　＜ＴｅｘｔＶｉｅｗ　ｓｔｙｌｅ＝＂＠ｓｔｙｌｅ／ＤａｖｉｄＳｔｙｌｅＴｅｘｔ１＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｗｉｄｔｈ＝＂ｆｉｌｌ＿ｐａｒｅｎｔ＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｈｅｉｇｈｔ＝＂ｗｒａｐ＿ｃｏｎｔｅｎｔ＂　ａｎｄｒｏｉｄ：ｇｒａｖｉｔｙ＝＂ｃｅｎｔｅｒ＿ｖｅｒｔｉｃａｌ｜ｃｅｎｔｅｒ＿ｈｏｒｉｚｏｎｔａｌ＂　ａｎｄｒｏｉｄ：ｔｅｘｔ＝＂＠ｓｔｒｉｎｇ／ｓｔｒ＿ｔｅｘｔ＿ｖｉｅｗ１＂　／＞　　＜ＴｅｘｔＶｉｅｗ　ｓｔｙｌｅ＝＂＠ｓｔｙｌｅ／ＤａｖｉｄＳｔｙｌｅＴｅｘｔ２＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｗｉｄｔｈ＝＂ｆｉｌｌ＿ｐａｒｅｎｔ＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｈｅｉｇｈｔ＝＂ｗｒａｐ＿ｃｏｎｔｅｎｔ＂　ａｎｄｒｏｉｄ：ｇｒａｖｉｔｙ＝＂ｃｅｎｔｅｒ＿ｖｅｒｔｉｃａｌ｜ｃｅｎｔｅｒ＿ｈｏｒｉｚｏｎｔａｌ＂　ａｎｄｒｏｉｄ：ｔｅｘｔ＝＂＠ｓｔｒｉｎｇ／ｓｔｒ＿ｔｅｘｔ＿ｖｉｅｗ２＂　／＞　

　　　　ｒｅｓ／ｖａｌｕｅｓ／ｓｔｙｌｅ．ｘｍｌ

　　　　在此的　ｓｔｙｌｅ．ｘｍｌ　就是这个范例的关键之处了，当中定义了两个样式名称，分别　为　ＤａｖｉｄＳｔｙｌｅＴｅｘｔ１　与　ＤａｖｉｄＳｔｙｌｅＴｅｘｔ２；留意　于　　＜／ｒｅｓｏｕｒｃｅｓ＞　　　　扩展学习

　　　　ｓｔｙｌｅ　与　ｃｏｌｏｒ　的　ＸＭＬ　语法相类似，皆需要先声明　ｘｍｌ　的版本以及　ｅｎｃｏｄｉｎｇ　为　ＵＴＦ－８，　但其内的　ｒｅｓｏｕｒｃｅｓ　则需要以　ｓｔｙｌｅｎａｍｅ　作为样式名称，在最内层才是以　ｉｔｅｍ　定义样式的范　围，其语法如下：　　　　范例说明

　　　　按钮在许多　Ｗｉｎｄｏｗｓ　窗口应用程序中，是最常见到的控件（　Ｃｏｎｔｒｏｌｓ）　，此控件也常在　网页设计里出现，诸如网页注册窗体、应用程序里的“确定”等等。　而按钮所触发的事件处理，我们称为　Ｅｖｅｎｔ　Ｈａｎｄｌｅｒ，只不过在　Ａｎｄｒｏｉｄ　当中，按钮事件　是由系统的　Ｂｕｔｔｏｎ．ＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ　所控制，熟悉　Ｊａｖａ　程序设计的读者对　ＯｎＸｘｘＬｉｓｔｅｎｅｒ　应　该不陌生。以下的范例将示范如何在　Ａｃｔｉｖｉｔｙ　里布局一个按钮（Ｂｕｔｔｏｎ）　，并设计这个按钮的

　　　　事件处理函数，当点击　按钮的同时，更改　ＴｅｘｔＶｉｅｗ　里的文字。　　　　运行结果

　　　　▲图　３－７　Ａｎｄｒｏｉｄ　手机的实际画面运行结果　　　　范例程序

ｐａｇｅ　１０

　　　　ｓｒｃ／ｉｒｄｃ．ｅｘ０３＿０７／Ｅｘ０３＿０７．ｊａｖａ

　　　　一开始，必须先在　Ｌａｙｏｕｔ　当中布局一个　Ｂｕｔｔｏｎ　及一个　ＴｅｘｔＶｉｅｗ　对象，找不到这两个组　件的话，系统会无法运行下去，在开发阶段会造成编译错误。　其次在　主程序中，请留意　ｏｎＣｒｅａｔｅ　里创建的　Ｂｕｔｔｏｎ．ＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ　事件，这也是触发　按　钮　时　会　运　行　的　程　序　段　落　；　但　由　于　Ｅｃｌｉｐｓｅ　无　法　自　动　加　载　默　认　的　传　递　参　数　（　ｎｅｗ　Ｂｕｔｔｏｎ．ＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（））　，所以，在编写程序描述时，必须自行键入新创建的按钮所需　的　ＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（）　事件，如下所示：

　　　　ｐａｃｋａｇｅ　ｉｒｄｃ．ｅｘ０３＿０７；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ａｐｐ．Ａｃｔｉｖｉｔｙ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｏｓ．Ｂｕｎｄｌｅ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｖｉｅｗ．Ｖｉｅｗ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．Ｂｕｔｔｏｎ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＴｅｘｔＶｉｅｗ；　ｐｕｂｌｉｃ　ｃｌａｓｓ　ＥＸ０３＿０７　ｅｘｔｅｎｄｓ　Ａｃｔｉｖｉｔｙ　　　　｛　ｐｒｉｖａｔｅ　Ｂｕｔｔｏｎ　ｍＢｕｔｔｏｎ１；　ｐｒｉｖａｔｅ　ＴｅｘｔＶｉｅｗ　ｍＴｅｘｔＶｉｅｗ１；

　　　　／＊＊　Ｃａｌｌｅｄ　ｗｈｅｎ　ｔｈｅ　ａｃｔｉｖｉｔｙ　ｉｓ　ｆｉｒｓｔ　ｃｒｅａｔｅｄ．　＊／　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｒｅａｔｅ（Ｂｕｎｄｌｅ　ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）　｛　ｓｕｐｅｒ．ｏｎＣｒｅａｔｅ（ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）；　ｓｅｔＣｏｎｔｅｎｔＶｉｅｗ（Ｒ．ｌａｙｏｕｔ．ｍａｉｎ）；

　　　　ｍＢｕｔｔｏｎ１　＝（Ｂｕｔｔｏｎ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＢｕｔｔｏｎ１）；　ｍＴｅｘｔＶｉｅｗ１　＝　（ＴｅｘｔＶｉｅｗ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＴｅｘｔＶｉｅｗ１）；

　　　　ｍＢｕｔｔｏｎ１．ｓｅｔＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（ｎｅｗ　Ｂｕｔｔｏｎ．ＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（）　｛　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｌｉｃｋ（Ｖｉｅｗ　ｖ）　｛　／／　ＴＯＤＯ　Ａｕｔｏ－ｇｅｎｅｒａｔｅｄ　ｍｅｔｈｏｄ　ｓｔｕｂ　ｍＴｅｘｔＶｉｅｗ１．ｓｅｔＴｅｘｔ（＂Ｈｉ，　Ｅｖｅｒｙｏｎｅ！！＂）；　｝　｝）；　｝　　　　｝

　　　　扩展学习

　　　　本范例中只有一个按钮，但在　Ａｃｔｉｖｉｔｙ　里，其实可以布局数个按钮，只需要在　Ｌａｙｏｕｔ　里多配置一个按钮对象，以下的程序将创建两个按钮事件作为示范：

　　　　ｐａｃｋａｇｅ　ｉｒｄｃ．ｅｘ０３＿０７；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ａｐｐ．Ａｃｔｉｖｉｔｙ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｏｓ．Ｂｕｎｄｌｅ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｖｉｅｗ．Ｖｉｅｗ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．Ｂｕｔｔｏｎ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＴｅｘｔＶｉｅｗ；　ｐｕｂｌｉｃ　ｃｌａｓｓ　ＥＸ０３＿０７　ｅｘｔｅｎｄｓ　Ａｃｔｉｖｉｔｙ　｛　ｐｒｉｖａｔｅ　Ｂｕｔｔｏｎ　ｍＢｕｔｔｏｎ１；　ｐｒｉｖａｔｅ　Ｂｕｔｔｏｎ　ｍＢｕｔｔｏｎ２；　ｐｒｉｖａｔｅ　ＴｅｘｔＶｉｅｗ　ｍＴｅｘｔＶｉｅｗ１；

　　　　／＊＊　Ｃａｌｌｅｄ　ｗｈｅｎ　ｔｈｅ　ａｃｔｉｖｉｔｙ　ｉｓ　ｆｉｒｓｔ　ｃｒｅａｔｅｄ．　＊／　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｒｅａｔｅ（Ｂｕｎｄｌｅ　ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）　｛　ｓｕｐｅｒ．ｏｎＣｒｅａｔｅ（ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）；　ｓｅｔＣｏｎｔｅｎｔＶｉｅｗ（Ｒ．ｌａｙｏｕｔ．ｍａｉｎ）；

　　　　ｍＢｕｔｔｏｎ１　＝（Ｂｕｔｔｏｎ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＢｕｔｔｏｎ１）；　ｍＢｕｔｔｏｎ２　＝（Ｂｕｔｔｏｎ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＢｕｔｔｏｎ２）；　ｍＴｅｘｔＶｉｅｗ１　＝　（ＴｅｘｔＶｉｅｗ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＴｅｘｔＶｉｅｗ１）；

　　　　ｍＢｕｔｔｏｎ１．ｓｅｔＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（ｎｅｗ　Ｂｕｔｔｏｎ．ＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（）　｛　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｌｉｃｋ（Ｖｉｅｗ　ｖ）　｛　／／　ＴＯＤＯ　Ａｕｔｏ－ｇｅｎｅｒａｔｅｄ　ｍｅｔｈｏｄ　ｓｔｕｂ　ｍＴｅｘｔＶｉｅｗ１．ｓｅｔＴｅｘｔ（＂Ｈｉ，　Ｅｖｅｒｙｏｎｅ！！＂）；　｝　｝）；

　　　　ｍＢｕｔｔｏｎ２．ｓｅｔＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（ｎｅｗ　Ｂｕｔｔｏｎ．ＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（）　｛　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｌｉｃｋ（Ｖｉｅｗ　ｖ）　｛　／／　ＴＯＤＯ　Ａｕｔｏ－ｇｅｎｅｒａｔｅｄ　ｍｅｔｈｏｄ　ｓｔｕｂ　ｍＴｅｘｔＶｉｅｗ１．ｓｅｔＴｅｘｔ（＂Ｈｉ，　Ｄａｖｉｄ！！＂）；　｝　｝）；　｝　　　　｝

　　　　最后来谈谈按钮事件里被重写的　ｏｎＣｌｉｃｋ（Ｖｉｅｗ　ｖ）　函数，　此函数唯一的参数是　Ｖｉｅｗ　类型　的变量　ｖ，这个变量所指的是来自父层（ｐａｒｅｎｔ）的　ＣｏｎｔｅｎｔＶｉｅｗ，亦即通过“ｖ．＊”可以更改其　父层的　Ｖｉｅｗ　状态或属性。　　　　范例说明

　　　　在网页的世界里，想要在两个网页间做转换，只要利用　超链接（ＨｙｐｅｒＬｉｎｋ）就可以实　现，　但在手机的世界里，　要如何实现手机页面之间的转换呢？最简单的方式就是改变　Ａｃｔｉｖｉｔｙ　的　Ｌａｙｏｕｔ！在　这个范例里头，将布局两个　Ｌａｙｏｕｔ，分别为　Ｌａｙｏｕｔ１（ｍａｉｎ．ｘｍｌ）与　Ｌａｙｏｕｔ２　（ｍｙｌａｙｏｕｔ．ｘｍｌ）　，默认载入的　Ｌａｙｏｕｔ　为　ｍａｉｎ．ｘｍｌ，且在　Ｌａｙｏｕｔ１　当中创建一个按钮，当点　击按钮时，显示第二个　Ｌａｙｏｕｔ（ｍｙｌａｙｏｕｔ．ｘｍｌ）　；同样地，在　Ｌａｙｏｕｔ２　里也设计一个按钮，　当点击第二个　Ｌａｙｏｕｔ　的按钮之后，则显示回原来的　Ｌａｙｏｕｔ１，现在就来示范如何在两个页面　之间互相切换。　　　　运行结果

ｐａｇｅ　１１

　　　　▲图　３－８　手机页面　Ｌａｙｏｕｔ　间的切换　　　　范例程序

　　　　ｓｒｃ／ｉｒｄｃ．ｅｘ０３＿０８／ＥＸ０３＿０８．ｊａｖａ

　　　　主程序　中，预加载的　Ｌａｙｏｕｔ　是　ｍａｉｎ．ｘｍｌ，屏幕上显示的是黑色背景的“Ｔｈｉｓ　ｉｓ　Ｌａｙｏｕｔ　１！！”，在第一个　Ｌａｙｏｕｔ　上的按钮被点击的同时，改变　Ａｃｔｉｖｉｔｙ　的　Ｌａｙｏｕｔ　为　ｍｙｌａｙｏｕｔ．ｘｍｌ，　屏

　　　　幕上显示变为白色背景的　“Ｔｈｉｓ　ｉｓ　Ｌａｙｏｕｔ　２！！”，并利用　Ｂｕｔｔｏｎ　点击时，调用方法的不同做两　个　Ｌａｙｏｕｔ　间的切换。

　　　　ｐａｃｋａｇｅ　ｉｒｄｃ．ｅｘ０３＿０８；　／＊　ｉｍｐｏｒｔ　相关　ｃｌａｓｓ　＊／　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ａｐｐ．Ａｃｔｉｖｉｔｙ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｏｓ．Ｂｕｎｄｌｅ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｖｉｅｗ．Ｖｉｅｗ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．Ｂｕｔｔｏｎ；　ｐｕｂｌｉｃ　ｃｌａｓｓ　ＥＸ０３＿０８　ｅｘｔｅｎｄｓ　Ａｃｔｉｖｉｔｙ　｛　／＊＊　Ｃａｌｌｅｄ　ｗｈｅｎ　ｔｈｅ　ａｃｔｉｖｉｔｙ　ｉｓ　ｆｉｒｓｔ　ｃｒｅａｔｅｄ．　＊／　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｒｅａｔｅ（Ｂｕｎｄｌｅ　ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）　｛　ｓｕｐｅｒ．ｏｎＣｒｅａｔｅ（ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）；　／＊　载入　ｍａｉｎ．ｘｍｌ　Ｌａｙｏｕｔ　＊／　ｓｅｔＣｏｎｔｅｎｔＶｉｅｗ（Ｒ．ｌａｙｏｕｔ．ｍａｉｎ）；

　　　　／＊　以　ｆｉｎｄＶｉｅｗＢｙＩｄ（）取得　Ｂｕｔｔｏｎ　对象，并添加　ｏｎＣｌｉｃｋＬｉｓｔｅｎｅｒ　＊／　Ｂｕｔｔｏｎ　ｂ１　＝　（Ｂｕｔｔｏｎ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｂｕｔｔｏｎ１）；　ｂ１．ｓｅｔＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（ｎｅｗ　Ｂｕｔｔｏｎ．ＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（）　｛　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｌｉｃｋ（Ｖｉｅｗ　ｖ）　｛　　　　ｊｕｍｐＴｏＬａｙｏｕｔ２（）；　｝　｝）；　｝

　　　　／＊　ｍｅｔｈｏｄ　ｊｕｍｐＴｏＬａｙｏｕｔ２：将　ｌａｙｏｕｔ　由　ｍａｉｎ．ｘｍｌ　切换成　ｍｙｌａｙｏｕｔ．ｘｍｌ　＊／　ｐｕｂｌｉｃ　ｖｏｉｄ　ｊｕｍｐＴｏＬａｙｏｕｔ２（）　｛　／＊　将　ｌａｙｏｕｔ　改成　ｍｙｌａｙｏｕｔ．ｘｍｌ　＊／　ｓｅｔＣｏｎｔｅｎｔＶｉｅｗ（Ｒ．ｌａｙｏｕｔ．ｍｙｌａｙｏｕｔ）；

　　　　／＊　以　ｆｉｎｄＶｉｅｗＢｙＩｄ（）取得　Ｂｕｔｔｏｎ　对象，并添加　ｏｎＣｌｉｃｋＬｉｓｔｅｎｅｒ　＊／　Ｂｕｔｔｏｎ　ｂ２　＝　（Ｂｕｔｔｏｎ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｂｕｔｔｏｎ２）；　ｂ２．ｓｅｔＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（ｎｅｗ　Ｂｕｔｔｏｎ．ＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（）　｛　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｌｉｃｋ（Ｖｉｅｗ　ｖ）　｛　ｊｕｍｐＴｏＬａｙｏｕｔ１（）；　｝　｝）；　｝

　　　　／＊　ｍｅｔｈｏｄ　ｊｕｍｐＴｏＬａｙｏｕｔ１：将　ｌａｙｏｕｔ　由　ｍｙｌａｙｏｕｔ．ｘｍｌ　切换成　ｍａｉｎ．ｘｍｌ　＊／　ｐｕｂｌｉｃ　ｖｏｉｄ　ｊｕｍｐＴｏＬａｙｏｕｔ１（）

　　　　｛　／＊　将　ｌａｙｏｕｔ　改成　ｍａｉｎ．ｘｍｌ　＊／　ｓｅｔＣｏｎｔｅｎｔＶｉｅｗ（Ｒ．ｌａｙｏｕｔ．ｍａｉｎ）；

　　　　／＊　以　ｆｉｎｄＶｉｅｗＢｙＩｄ（）取得　Ｂｕｔｔｏｎ　对象，并添加　ｏｎＣｌｉｃｋＬｉｓｔｅｎｅｒ　＊／　Ｂｕｔｔｏｎ　ｂ１　＝　（Ｂｕｔｔｏｎ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｂｕｔｔｏｎ１）；　ｂ１．ｓｅｔＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（ｎｅｗ　Ｂｕｔｔｏｎ．ＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（）　｛　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｌｉｃｋ（Ｖｉｅｗ　ｖ）　｛　ｊｕｍｐＴｏＬａｙｏｕｔ２（）；　｝　｝）；　｝　｝

　　　　ｒｅｓ／ｌａｙｏｕｔ／ｍａｉｎ．ｘｍｌ

　　　　为了凸显　Ｌａｙｏｕｔ　间切换的效果，　特别改变两个　Ｌａｙｏｕｔ　的背景色及输出文字。　ｍａｉｎ．ｘｍｌ　在　中定义其背景色为黑色，输出文字为“Ｔｈｉｓ　ｉｓ　Ｌａｙｏｕｔ　１！！”。　　　　＜？ｘｍｌ　ｖｅｒｓｉｏｎ＝＂１．０＂　ｅｎｃｏｄｉｎｇ＝＂ｕｔｆ－８＂？＞　　＜ＴｅｘｔＶｉｅｗ　ａｎｄｒｏｉｄ：ｉｄ＝＂＠＋ｉｄ／ｔｅｘｔ１＂　ａｎｄｒｏｉｄ：ｔｅｘｔＳｉｚｅ＝＂２４ｓｐ＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｗｉｄｔｈ＝＂１８６ｐｘ＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｈｅｉｇｈｔ＝＂２９ｐｘ＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｘ＝＂７０ｐｘ＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｙ＝＂３２ｐｘ＂　ａｎｄｒｏｉｄ：ｔｅｘｔ＝＂＠ｓｔｒｉｎｇ／ｌａｙｏｕｔ１＂　＞　＜／ＴｅｘｔＶｉｅｗ＞　　　　　　　ｒｅｓ／ｌａｙｏｕｔ／ｍｙｌａｙｏｕｔ．ｘｍｌ

　　　　在　ｍｙｌａｙｏｕｔ．ｘｍｌ　中定义其背景色为白色，输出文字为“Ｔｈｉｓ　ｉｓ　Ｌａｙｏｕｔ　２！！”。

　　　　＜？ｘｍｌ　ｖｅｒｓｉｏｎ＝＂１．０＂　ｅｎｃｏｄｉｎｇ＝＂ｕｔｆ－８＂？＞　　＜ＴｅｘｔＶｉｅｗ　ａｎｄｒｏｉｄ：ｉｄ＝＂＠＋ｉｄ／ｔｅｘｔ２＂　ａｎｄｒｏｉｄ：ｔｅｘｔＳｉｚｅ＝＂２４ｓｐ＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｗｉｄｔｈ＝＂１８６ｐｘ＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｈｅｉｇｈｔ＝＂２９ｐｘ＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｘ＝＂７０ｐｘ＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｙ＝＂３２ｐｘ＂　ａｎｄｒｏｉｄ：ｔｅｘｔＣｏｌｏｒ＝＂＠ｄｒａｗａｂｌｅ／ｂｌａｃｋ＂　ａｎｄｒｏｉｄ：ｔｅｘｔ＝＂＠ｓｔｒｉｎｇ／ｌａｙｏｕｔ２＂　＞　＜／ＴｅｘｔＶｉｅｗ＞　　　　　　　扩展学习

　　　　运用改变　Ａｃｔｉｖｉｔｙ　Ｌａｙｏｕｔ　这个技巧，就可做出手机页面转换的效果，当然亦可搭配之前　介绍过的　Ｓｔｙｌｅ　与　Ｔｈｅｍｅ　的设置，进行更加灵活的布局配置运用，例如，让用户自行决定要　使用的系统样式、背景及文字颜色等，接着直接应用来改变布局。　再者，　利用　ｓｅｔＣｏｎｔｅｎｔＶｉｅｗ　来置换页面，还有一个特别的优点，即所有程序里的变量　皆存在相同的状态，无论是类成员变量、类函数等等，皆可以在一个　Ａｃｔｉｖｉ

ｐａｇｅ　１２

ｔｙ　的状态中直接　取得，并没有参数传递的问题。打个比喻：Ｌａｙｏｕｔ１　收集了用户输入的信用卡卡号等付款信　息，在“下一步”显示　Ｌａｙｏｕｔ２　使之显示订单信息，让用户进行确认，并在点击按钮后，调用　Ｌａｙｏｕｔ３　进行刷卡　Ｇａｔｅｗａｙ　的授权操作，这当中皆没有需要传递的变量，　其手法是将所需　要的字段数据，以类成员变量作如下声明：

　　　　ｐｕｂｌｉｃ　ｃｌａｓｓ　ＥＸ０３＿０８　ｅｘｔｅｎｄｓ　Ａｃｔｉｖｉｔｙ　｛　ｐｕｂｌｉｃ　Ｓｔｒｉｎｇ　ｃｏｌＶａｒ１；　ｐｕｂｌｉｃ　Ｓｔｒｉｎｇ　ｃｏｌＶａｒ２；　ｐｕｂｌｉｃ　Ｓｔｒｉｎｇ　ｃｏｌＶａｒ３；　／＊＊　Ｃａｌｌｅｄ　ｗｈｅｎ　ｔｈｅ　ａｃｔｉｖｉｔｙ　ｉｓ　ｆｉｒｓｔ　ｃｒｅａｔｅｄ．　＊／　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｒｅａｔｅ（Ｂｕｎｄｌｅ　ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）　｛

　　　　／＊　下面的程序略　＊／　　　　范例说明

　　　　前一个范例介绍了如何运用切换　Ｌａｙｏｕｔ　的方式，　进行手机页面间的转换。如果要转换　的页面并不单只是背景、颜色或文字内容的不同，而是　Ａｃｔｉｖｉｔｙ　的置换，那就不是单单改变　Ｌａｙｏｕｔ　就能完成的，　尤其是需要传递的变量不像网页可以通过　Ｃｏｏｋｉｅ　或　Ｓｅｓｓｉｏｎ，在程序　里要移交主控权到另外一个　Ａｃｔｉｖｉｔｙ，光靠先前的　Ｌａｙｏｕｔ　技巧是办　不到的。　那要如何解决　Ａｃｔｉｖｉｔｙ　控制权的移交呢？在　Ａｎｄｒｏｉｄ　的程序设计中，可在主程序里使用　ｓｔａｒｔＡｃｔｉｖｉｔｙ（）　这个方法来调用另一个　Ａｃｔｉｖｉｔｙ（主程序本身即是一个　Ａｃｔｉｖｉｔｙ）　，但当中的关　键并不在　ｓｔａｒｔＡｃｔｉｖｉｔｙ　这个方法，而是　Ｉｎｔｅｎｔ　这个特有的对象，Ｉｎｔｅｎｔ　就如同其英文字义，　是“想要”或“意图”之意，在主　Ａｃｔｉｖｉｔｙ　当中，告诉程序自己是什么，并想要前往哪　里，这就　是　Ｉｎｔｅｎｔ　对象所处理的事了。本范例并没有特别的　Ｌａｙｏｕｔ　布局，而是直接在主　Ａｃｔｉｖｉｔｙ　（Ａｃｔｉｖｉｔｙ１）当中部署一个按钮，　当点击按钮的同时，告诉主　Ａｃｔｉｖｉｔｙ　前往　Ａｃｔｉｖｉｔｙ２，并　在　Ａｃｔｉｖｉｔｙ２　里创建一个回到　Ａｃｔｉｖｉｔｙ１　的按钮，　本范例将利用此简易　的程序描述，　示范如何　在一个　Ａｃｔｉｖｉｔｙ　中调用另一个　Ａｃｔｉｖｉｔｙ　的手法。

　　　　运行结果

　　　　▲图　３－９　在两个　Ａｃｔｉｖｉｔｙ　间做切换　　　　范例程序

　　　　ｓｒｃ／ｉｒｄｃ．ｅｘ０３＿０９／ＥＸ０３＿０９．ｊａｖａ

　　　　主程序　中加载的　Ｌａｙｏｕｔ　为　ｍａｉｎ．ｘｍｌ，　屏幕上显示的是黑色背景的“Ｔｈｉｓ　ｉｓ　Ａｃｔｉｖｉｔｙ　１！！”，

　　　　在　Ｂｕｔｔｏｎ　被点击时调用另一个　Ａｃｔｉｖｉｔｙ（ＥＸ０３＿０９＿１，参考　ＡｎｄｒｏｉｄＭａｎｉｆｅｓｔ．ｘｍｌ　里的说明）　，　并将主　Ａｃｔｉｖｉｔｙ　关闭　ｆｉｎｉｓｈ（），接着将主控权交给下一个　Ａｃｔｉｖｉｔｙ，即　Ａｃｔｉｖｉｔｙ２。

　　　　ｐａｃｋａｇｅ　ｉｒｄｃ．ｅｘ０３＿０９；　／＊　ｉｍｐｏｒｔ　相关　ｃｌａｓｓ　＊／　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ａｐｐ．Ａｃｔｉｖｉｔｙ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｏｓ．Ｂｕｎｄｌｅ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｖｉｅｗ．Ｖｉｅｗ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．Ｂｕｔｔｏｎ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｃｏｎｔｅｎｔ．Ｉｎｔｅｎｔ；　ｐｕｂｌｉｃ　ｃｌａｓｓ　ＥＸ０３＿０９　ｅｘｔｅｎｄｓ　Ａｃｔｉｖｉｔｙ　｛　／＊＊　Ｃａｌｌｅｄ　ｗｈｅｎ　ｔｈｅ　ａｃｔｉｖｉｔｙ　ｉｓ　ｆｉｒｓｔ　ｃｒｅａｔｅｄ．　＊／　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｒｅａｔｅ（Ｂｕｎｄｌｅ　ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）　｛　ｓｕｐｅｒ．ｏｎＣｒｅａｔｅ（ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）；　／＊　载入　ｍａｉｎ．ｘｍｌ　Ｌａｙｏｕｔ　＊／　ｓｅｔＣｏｎｔｅｎｔＶｉｅｗ（Ｒ．ｌａｙｏｕｔ．ｍａｉｎ）；

　　　　／＊　以　ｆｉｎｄＶｉｅｗＢｙＩｄ（）取得　Ｂｕｔｔｏｎ　对象，并添加　ｏｎＣｌｉｃｋＬｉｓｔｅｎｅｒ　＊／　Ｂｕｔｔｏｎ　ｂ１　＝　（Ｂｕｔｔｏｎ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｂｕｔｔｏｎ１）；　ｂ１．ｓｅｔＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（ｎｅｗ　Ｂｕｔｔｏｎ．ＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（）　｛　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｌｉｃｋ（Ｖｉｅｗ　ｖ）

　　　　｛　／＊　ｎｅｗ　一个　Ｉｎｔｅｎｔ　对象，并指定要启动的　ｃｌａｓｓ　＊／　Ｉｎｔｅｎｔ　ｉｎｔｅｎｔ　＝　ｎｅｗ　Ｉｎｔｅｎｔ（）；　ｉｎｔｅｎｔ．ｓｅｔＣｌａｓｓ（ＥＸ０３＿０９．ｔｈｉｓ，　ＥＸ０３＿０９＿１．ｃｌａｓｓ）；

　　　　／＊　调用一个新的　Ａｃｔｉｖｉｔｙ　＊／　ｓｔａｒｔＡｃｔｉｖｉｔｙ（ｉｎｔｅｎｔ）；　／＊　关闭原本的　Ａｃｔｉｖｉｔｙ　＊／　ＥＸ０３＿０９．ｔｈｉｓ．ｆｉｎｉｓｈ（）；　｝　｝）；　｝　｝　　　　ｓｒｃ／ｉｒｄｃ．ｅｘ０３＿０９／ＥＸ０３＿０９＿１．ｊａｖａ

　　　　ＥＸ０３＿０９＿１．ｊａｖａ　程序是第二个　Ａｃｔｉｖｉｔｙ　的主程序，其加载的　Ｌａｙｏｕｔ　为　ｍｙｌａｙｏｕｔ．ｘｍｌ，　屏幕上所显示的是白色背景的　“Ｔｈｉｓ　ｉｓ　Ａｃｔｉｖｉｔｙ　２！！”，当主　Ａｃｔｉｖｉｔｙ（Ａｃｔｉｖｉｔｙ１）调用这个　Ａｃｔｉｖｉｔｙ（Ａｃｔｉｖｉｔｙ２）后，同样为　Ｂｕｔｔｏｎ　添加　ｏｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（），使　Ｂｕｔｔｏｎ　被点击时，重新　调用　Ａｃｔｉｖｉｔｙ１（ＥＸ０３＿０９）　，并将　Ａ

ｐａｇｅ　１３

ｃｔｉｖｉｔｙ２（ＥＸ０３＿０９＿１）关闭（ｆｉｎｉｓｈ（））　。

　　　　ｐａｃｋａｇｅ　ｉｒｄｃ．ｅｘ０３＿０９；　／＊　ｉｍｐｏｒｔ　相关　ｃｌａｓｓ　＊／　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ａｐｐ．Ａｃｔｉｖｉｔｙ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｏｓ．Ｂｕｎｄｌｅ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｃｏｎｔｅｎｔ．Ｉｎｔｅｎｔ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｖｉｅｗ．Ｖｉｅｗ；

　　　　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．Ｂｕｔｔｏｎ；　ｐｕｂｌｉｃ　ｃｌａｓｓ　ＥＸ０３＿０９＿１　ｅｘｔｅｎｄｓ　Ａｃｔｉｖｉｔｙ　｛　／＊＊　Ｃａｌｌｅｄ　ｗｈｅｎ　ｔｈｅ　ａｃｔｉｖｉｔｙ　ｉｓ　ｆｉｒｓｔ　ｃｒｅａｔｅｄ．　＊／　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｒｅａｔｅ（Ｂｕｎｄｌｅ　ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）　｛　ｓｕｐｅｒ．ｏｎＣｒｅａｔｅ（ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）；　／＊　载入　ｍｙｌａｙｏｕｔ．ｘｍｌ　Ｌａｙｏｕｔ　＊／　ｓｅｔＣｏｎｔｅｎｔＶｉｅｗ（Ｒ．ｌａｙｏｕｔ．ｍｙｌａｙｏｕｔ）；

　　　　／＊　以　ｆｉｎｄＶｉｅｗＢｙＩｄ（）取得　Ｂｕｔｔｏｎ　对象，并添加　ｏｎＣｌｉｃｋＬｉｓｔｅｎｅｒ　＊／　Ｂｕｔｔｏｎ　ｂ２　＝　（Ｂｕｔｔｏｎ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｂｕｔｔｏｎ２）；　ｂ２．ｓｅｔＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（ｎｅｗ　Ｂｕｔｔｏｎ．ＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（）　｛　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｌｉｃｋ（Ｖｉｅｗ　ｖ）　｛　／＊　ｎｅｗ　一个　Ｉｎｔｅｎｔ　对象，并指定要启动的　ｃｌａｓｓ　＊／　Ｉｎｔｅｎｔ　ｉｎｔｅｎｔ　＝　ｎｅｗ　Ｉｎｔｅｎｔ（）；　ｉｎｔｅｎｔ．ｓｅｔＣｌａｓｓ（ＥＸ０３＿０９＿１．ｔｈｉｓ，　ＥＸ０３＿０９．ｃｌａｓｓ）；

　　　　／＊　调用一个新的　Ａｃｔｉｖｉｔｙ　＊／　ｓｔａｒｔＡｃｔｉｖｉｔｙ（ｉｎｔｅｎｔ）；　／＊　关闭原本的　Ａｃｔｉｖｉｔｙ　＊／

　　　　ＥＸ０３＿０９＿１．ｔｈｉｓ．ｆｉｎｉｓｈ（）；　｝　｝）；　　　　｝　｝

　　　　ｒｅｓ／ｌａｙｏｕｔ／ｍａｉｎ．ｘｍｌ

　　　　为了凸显　Ａｃｔｉｖｉｔｙ　间切换的效果，特别将两个　Ｌａｙｏｕｔ　的背景及输出文字有所区别。在　ｍａｉｎ．ｘｍｌ　中定义其背景色为黑色，输出文字为“Ｔｈｉｓ　ｉｓ　Ａｃｔｉｖｉｔｙ　１！！”。

　　　　＜？ｘｍｌ　ｖｅｒｓｉｏｎ＝＂１．０＂　ｅｎｃｏｄｉｎｇ＝＂ｕｔｆ－８＂？＞　　＜ＴｅｘｔＶｉｅｗ　ａｎｄｒｏｉｄ：ｉｄ＝＂＠＋ｉｄ／ｔｅｘｔ１＂　ａｎｄｒｏｉｄ：ｔｅｘｔＳｉｚｅ＝＂２４ｓｐ＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｗｉｄｔｈ＝＂１８６ｐｘ＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｈｅｉｇｈｔ＝＂２９ｐｘ＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｘ＝＂７０ｐｘ＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｙ＝＂３２ｐｘ＂　　　　ａｎｄｒｏｉｄ：ｔｅｘｔ＝＂＠ｓｔｒｉｎｇ／ａｃｔ１＂　＞　＜／ＴｅｘｔＶｉｅｗ＞　　　　　　　ｒｅｓ／ｌａｙｏｕｔ／ｍｙｌａｙｏｕｔ．ｘｍｌ

　　　　在　ｍｙｌａｙｏｕｔ．ｘｍｌ　中定义其背景色为白色，输出文字为“Ｔｈｉｓ　ｉｓ　Ａｃｔｉｖｉｔｙ　２！！”。

　　　　＜？ｘｍｌ　ｖｅｒｓｉｏｎ＝＂１．０＂　ｅｎｃｏｄｉｎｇ＝＂ｕｔｆ－８＂？＞　　＜ＴｅｘｔＶｉｅｗ

　　　　ａｎｄｒｏｉｄ：ｉｄ＝＂＠＋ｉｄ／ｔｅｘｔ２＂　ａｎｄｒｏｉｄ：ｔｅｘｔＳｉｚｅ＝＂２４ｓｐ＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｗｉｄｔｈ＝＂１８６ｐｘ＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｈｅｉｇｈｔ＝＂２９ｐｘ＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｘ＝＂７０ｐｘ＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｙ＝＂３２ｐｘ＂　ａｎｄｒｏｉｄ：ｔｅｘｔＣｏｌｏｒ＝＂＠ｄｒａｗａｂｌｅ／ｂｌａｃｋ＂　ａｎｄｒｏｉｄ：ｔｅｘｔ＝＂＠ｓｔｒｉｎｇ／ａｃｔ２＂　＞　＜／ＴｅｘｔＶｉｅｗ＞　　　

　　　　ＡｎｄｒｏｉｄＭａｎｉｆｅｓｔ．ｘｍｌ

　　　　由于本范例中添加了一个　Ａｃｔｉｖｉｔｙ，所以必须在　ＡｎｄｒｏｉｄＭａｎｉｆｅｓｔ．ｘｍｌ　中定义一个新的　ａｃｔｉｖｉｔｙ，并给予名称　ｎａｍｅ，否则程序将无法编译运行。

　　　　＜？ｘｍｌ　ｖｅｒｓｉｏｎ＝＂１．０＂　ｅｎｃｏｄｉｎｇ＝＂ｕｔｆ－８＂？＞　＜ｍａｎｉｆｅｓｔ　ｘｍｌｎｓ：ａｎｄｒｏｉｄ＝＂ｈｔｔｐ：／／ｓｃｈｅｍａｓ．ａｎｄｒｏｉｄ．ｃｏｍ／ａｐｋ／ｒｅｓ／ａｎｄｒｏｉｄ＂　ｐａｃｋａｇｅ＝＂ｉｒｄｃ．ｅｘ０３＿０９＂　ａｎｄｒｏｉｄ：ｖｅｒｓｉｏｎＣｏｄｅ＝＂１＂　ａｎｄｒｏｉｄ：ｖｅｒｓｉｏｎＮａｍｅ＝＂１．０．０＂＞　　　　　＜ｃａｔｅｇｏｒｙ　ａｎｄｒｏｉｄ：ｎａｍｅ＝＂ａｎｄｒｏｉｄ．ｉｎｔｅｎｔ．ｃａｔｅｇｏｒｙ．ＬＡＵＮＣＨＥＲ＂　／＞　　　　　＜／ｍａｎｉｆｅｓｔ＞　　　　扩展学习

　　　　当系统中新添加　Ａｃｔｉｖｉｔｙ　时，必须在　ＡｎｄｒｏｉｄＭａｎｉｆｅｓｔ．ｘｍｌ　里定义一个新的　ａｃｔｉｖｉｔｙ：

　　　　否则系统将会因为找不到　Ａｃｔｉｖｉｔｙ　而发生编译错误。　另外，当程序中出现两个以上的　Ａｃｔｉｖｉｔｙ　时，系统要如何决定主程序是哪一支（ｅｎｔｒｙ　ｐｏｉｎｔ）呢？以本范例来说，ＡｎｄｒｏｉｄＭａｎｉｆｅｓｔ．ｘｍｌ　中　Ａｃｔｉｖｉｔｙ　ＥＸ０３＿０９　的定义如下：

　　　　＜ｃａｔｅｇｏｒｙ　ａｎｄｒｏｉｄ：ｎａｍｅ＝＂ａｎｄｒｏｉｄ．ｉｎｔｅｎｔ．ｃａｔｅｇｏｒｙ．ＬＡＵＮＣＨＥＲ＂　／＞　　

　　　　其中有一行为　＜ｃａｔｅｇｏｒｙ　ａｎｄｒｏｉｄ：ｎａｍｅ＝＂ａｎｄｒｏｉｄ．ｉｎｔｅｎｔ．ｃａｔｅｇｏｒｙ．ＬＡＵＮＣＨＥＲ＂　／＞，这就代　表程序启动时，会先运行　ＥＸ０３＿０９　这个　Ａｃｔｉｖｉｔｙ，而非　ＥＸ０３＿０９＿１。需注意的是，这个参数　必须要被定义，如果　ｘｍｌ　中没有一支　Ａｃｔｉｖｉｔｙ　有设置这个参数，则程序将不会被运行。　此外，在两支　Ｊａｖａ　程序中的最后一行都调用了　ｆｉｎｉｓｈ（）　这个方法，它代表这个　Ａｃｔｉｖｉｔｙ　已运作完毕，当系统接收到这个命令时，即会

ｐａｇｅ　１４

关闭此　Ａｃｔｉｖｉｔｙ，所以此时点击模拟器的返回　（Ｂａｃｋ）键，并不　会回到上一个　Ａｃｔｉｖｉｔｙ　的画面，如果要让模拟器的返回键有回上一页的　效果，　可以将此行程序注释掉。　同理，　当两个　Ａｃｔｉｖｉｔｙ　在切换时，　并非真的　只有两个　Ａｃｔｉｖｉｔｙ　在切换，而是在点击按钮时，再重新调用起一个新的　Ａｃｔｉｖｉｔｙ。　　　　范例说明

　　　　在上一个范例里，介绍了如何在　Ａｃｔｉｖｉｔｙ　中调　用另一个　Ａｃｔｉｖｉｔｙ，但若需要在调用另外　一个　Ａｃｔｉｖｉｔｙ　的同时传递数据，那么就需要利用　ａｎｄｒｏｉｄ．ｏｓ．Ｂｕｎｄｌｅ　对象封装数据的能　力，　将欲传递的数据或参数，通过　Ｂｕｎｄｌｅ　来传递不同　Ｉｎｔｅｎｔ　之间的数据。　本范例的设计为一个简易表单的范例，在　Ａｃｔｉｖｉｔｙ１　中收集　Ｕｓｅｒ　输入的数据，在离开　Ａｃｔｉｖｉｔｙ１　的同时，　Ｕｓｅｒ　选择的结果传递至下一个　Ａｃｔｉｖｉｔｙ２，　将　以一个简单　ＢＭＩ“标准体重计　算器”示范如何传递数据到下一个　Ａｃｔｉｖｉｔｙ　里。　　　　运行结果　　　　▲图　３－１０

　　　　在两个　Ａｃｔｉｖｉｔｙ　间做数据的传递　　　　范例程序

　　　　ｓｒｃ／ｉｒｄｃ．ｅｘ０３＿１０／ＥＸ０３＿１０．ｊａｖａ

　　　　在　第一　个　Ａｃｔｉｖｉｔｙ１　主　程序中，定义了　“性　别”选　项的　ＲａｄｉｏＧｒｏｕｐ　以　及输入身高的　“ＥｄｉｔＴｅｘｔ”，并运用　Ｉｎｔｅｎｔ　及　Ｂｕｎｄｌｅ　对象，　在调用　Ａｃｔｉｖｉｔｙ２（ＥＸ０３＿１０＿１）时，同时将数据　传入。关于　ＥｄｉｔＴｅｘｔ　对象的使用在此仅供参考，详细的应用以及属性方法，将会在未来　讨　论控件时，再详细解说。

　　　　ｐａｃｋａｇｅ　ｉｒｄｃ．ｅｘ０３＿１０；　／＊　ｉｍｐｏｒｔ　相关　ｃｌａｓｓ　＊／　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ａｐｐ．Ａｃｔｉｖｉｔｙ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｃｏｎｔｅｎｔ．Ｉｎｔｅｎｔ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｏｓ．Ｂｕｎｄｌｅ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｖｉｅｗ．Ｖｉｅｗ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．Ｂｕｔｔｏｎ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＥｄｉｔＴｅｘｔ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＲａｄｉｏＢｕｔｔｏｎ；

　　　　ｐｕｂｌｉｃ　ｃｌａｓｓ　ＥＸ０３＿１０　ｅｘｔｅｎｄｓ　Ａｃｔｉｖｉｔｙ　｛　／＊＊　Ｃａｌｌｅｄ　ｗｈｅｎ　ｔｈｅ　ａｃｔｉｖｉｔｙ　ｉｓ　ｆｉｒｓｔ　ｃｒｅａｔｅｄ．　＊／　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｒｅａｔｅ（Ｂｕｎｄｌｅ　ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）　｛　ｓｕｐｅｒ．ｏｎＣｒｅａｔｅ（ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）；　／＊　载入　ｍａｉｎ．ｘｍｌ　Ｌａｙｏｕｔ　＊／　ｓｅｔＣｏｎｔｅｎｔＶｉｅｗ（Ｒ．ｌａｙｏｕｔ．ｍａｉｎ）；

　　　　／＊　以　ｆｉｎｄＶｉｅｗＢｙＩｄ（）取得　Ｂｕｔｔｏｎ　对象，并添加　ｏｎＣｌｉｃｋＬｉｓｔｅｎｅｒ　＊／　Ｂｕｔｔｏｎ　ｂ１　＝　（Ｂｕｔｔｏｎ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｂｕｔｔｏｎ１）；　ｂ１．ｓｅｔＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（ｎｅｗ　Ｂｕｔｔｏｎ．ＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（）　｛　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｌｉｃｋ（Ｖｉｅｗ　ｖ）　｛　／＊取得输入的身高＊／　ＥｄｉｔＴｅｘｔ　ｅｔ　＝　（ＥｄｉｔＴｅｘｔ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｈｅｉｇｈｔ）；　ｄｏｕｂｌｅ　ｈｅｉｇｈｔ＝Ｄｏｕｂｌｅ．ｐａｒｓｅＤｏｕｂｌｅ（ｅｔ．ｇｅｔＴｅｘｔ（）．ｔｏＳｔｒｉｎｇ（））；　／＊取得选择的性别＊／　Ｓｔｒｉｎｇ　ｓｅｘ＝＂＂；　ＲａｄｉｏＢｕｔｔｏｎ　ｒｂ１　＝　（ＲａｄｉｏＢｕｔｔｏｎ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｓｅｘ１）；　ｉｆ（ｒｂ１．ｉｓＣｈｅｃｋｅｄ（））　｛　　　　ｓｅｘ＝＂Ｍ＂；　｝　ｅｌｓｅ　｛　ｓｅｘ＝＂Ｆ＂；　｝　／＊ｎｅｗ　一个　Ｉｎｔｅｎｔ　对象，并指定　ｃｌａｓｓ＊／　Ｉｎｔｅｎｔ　ｉｎｔｅｎｔ　＝　ｎｅｗ　Ｉｎｔｅｎｔ（）；　ｉｎｔｅｎｔ．ｓｅｔＣｌａｓｓ（ＥＸ０３＿１０．ｔｈｉｓ，ＥＸ０３＿１０＿１．ｃｌａｓｓ）；

　　　　／＊ｎｅｗ　一个　Ｂｕｎｄｌｅ　对象，并将要传递的数据传入＊／　Ｂｕｎｄｌｅ　ｂｕｎｄｌｅ　＝　ｎｅｗ　Ｂｕｎｄｌｅ（）；　ｂｕｎｄｌｅ．ｐｕｔＤｏｕｂｌｅ（＂ｈｅｉｇｈｔ＂，ｈｅｉｇｈｔ）；　ｂｕｎｄｌｅ．ｐｕｔＳｔｒｉｎｇ（＂ｓｅｘ＂，ｓｅｘ）；　　　　／＊将　Ｂｕｎｄｌｅ　对象　ａｓｓｉｇｎ　给　Ｉｎｔｅｎｔ＊／　ｉｎｔｅｎｔ．ｐｕｔＥｘｔｒａｓ（ｂｕｎｄｌｅ）；　　　　／＊调用　Ａｃｔｉｖｉｔｙ　ＥＸ０３＿１０＿１＊／　ｓｔａｒｔＡｃｔｉｖｉｔｙ（ｉｎｔｅｎｔ）；　｝　｝）；　｝　｝　　　　ｓｒｃ／ｉｒｄｃ．ｅｘ０３＿１０／ＥＸ０３＿１０＿１．ｊａｖａ

　　　　那么，　在　Ａｃｔｉｖｉｔｙ２（ＥＸ０３＿１０＿１）要如何接收来自　Ａｃｔｉｖｉｔｙ１（ＥＸ０３＿１０）传递来的数　据呢？试想，在　Ａｃｔｉｖｉｔｙ１　是以　Ｂｕｎｄｌｅ　封装对象，自然在　Ａｃｔｉｖｉｔｙ２　亦是以　Ｂｕｎｄｌｅ　的方式解　开封装的数据；　程序中以　ｇｅｔＩｎｔｅｎｔ（）．ｇｅｔＥｘｔｒａｓ（）　方法取得随着　Ｂｕｎｄｌｅ　对象传递过来的性别与　身高，经过计算之后，显示在屏幕上。　　　　ｐａｃｋａｇｅ　ｉｒｄｃ．ｅｘ０３＿１０；　／＊　ｉｍｐｏｒｔ　相关　ｃｌａｓｓ　＊／　ｉｍｐｏｒｔ　ｊａｖａ．ｔｅｘｔ．ＤｅｃｉｍａｌＦｏｒｍａｔ；　ｉｍｐｏｒｔ　ｊａｖａ．ｔｅｘｔ．ＮｕｍｂｅｒＦｏｒｍａｔ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ａｐｐ．Ａｃｔｉｖｉｔｙ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｏｓ．Ｂｕｎｄｌｅ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＴｅｘｔＶｉｅｗ；　ｐｕｂｌｉｃ　ｃｌａｓｓ　ＥＸ０３＿１０＿１　ｅｘｔｅｎｄｓ　Ａｃｔｉｖｉｔｙ　｛　／＊＊　Ｃａｌｌｅｄ　ｗｈｅｎ　ｔｈｅ　ａｃｔｉｖｉｔｙ　ｉｓ　ｆｉｒｓｔ　ｃｒｅａｔｅｄ．　＊／　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｒｅａｔｅ（Ｂｕｎｄｌｅ　ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）　｛　ｓｕｐｅｒ．ｏｎＣｒｅａｔｅ（ｓａ

ｐａｇｅ　１５

ｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）；　／＊　加载　ｍａｉｎ．ｘｍｌ　Ｌａｙｏｕｔ　＊／　ｓｅｔＣｏｎｔｅｎｔＶｉｅｗ（Ｒ．ｌａｙｏｕｔ．ｍｙａｌｙｏｕｔ）；

　　　　／＊　取得　Ｉｎｔｅｎｔ　中的　Ｂｕｎｄｌｅ　对象　＊／　Ｂｕｎｄｌｅ　ｂｕｎｄｅ　＝　ｔｈｉｓ．ｇｅｔＩｎｔｅｎｔ（）．ｇｅｔＥｘｔｒａｓ（）；

　　　　／＊　取得　Ｂｕｎｄｌｅ　对象中的数据　＊／　Ｓｔｒｉｎｇ　ｓｅｘ　＝　ｂｕｎｄｅ．ｇｅｔＳｔｒｉｎｇ（＂ｓｅｘ＂）；　ｄｏｕｂｌｅ　ｈｅｉｇｈｔ　＝　ｂｕｎｄｅ．ｇｅｔＤｏｕｂｌｅ（＂ｈｅｉｇｈｔ＂）；

　　　　／＊　判断性别　＊／　Ｓｔｒｉｎｇ　ｓｅｘＴｅｘｔ＝＂＂；　ｉｆ（ｓｅｘ．ｅｑｕａｌｓ（＂Ｍ＂））　｛　ｓｅｘＴｅｘｔ＝＂男性＂；　｝　ｅｌｓｅ　｛　ｓｅｘＴｅｘｔ＝＂女性＂；　｝

　　　　／＊　取得标准体重　＊／　Ｓｔｒｉｎｇ　ｗｅｉｇｈｔ＝ｔｈｉｓ．ｇｅｔＷｅｉｇｈｔ（ｓｅｘ，　ｈｅｉｇｈｔ）；

　　　　／＊　设置输出文字　＊／　ＴｅｘｔＶｉｅｗ　ｔｖ１＝（ＴｅｘｔＶｉｅｗ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｔｅｘｔ１）；　ｔｖ１．ｓｅｔＴｅｘｔ（＂你是一位＂＋ｓｅｘＴｅｘｔ＋＂＼ｎ　你的身高是＂　＋ｈｅｉｇｈｔ＋＂厘米＼ｎ　你的标准体重是＂＋ｗｅｉｇｈｔ＋＂公斤＂）；　｝

　　　　／＊　四舍五入的　ｍｅｔｈｏｄ　＊／　ｐｒｉｖａｔｅ　Ｓｔｒｉｎｇ　ｆｏｒｍａｔ（ｄｏｕｂｌｅ　ｎｕｍ）　｛　ＮｕｍｂｅｒＦｏｒｍａｔ　ｆｏｒｍａｔｔｅｒ　＝　ｎｅｗ　ＤｅｃｉｍａｌＦｏｒｍａｔ（＂０．００＂）；　Ｓｔｒｉｎｇ　ｓ＝ｆｏｒｍａｔｔｅｒ．ｆｏｒｍａｔ（ｎｕｍ）；　ｒｅｔｕｒｎ　ｓ；　｝　／＊　以　ｆｉｎｄＶｉｅｗＢｙＩｄ（）取得　Ｂｕｔｔｏｎ　对象，并添加　ｏｎＣｌｉｃｋＬｉｓｔｅｎｅｒ　＊／　ｐｒｉｖａｔｅ　Ｓｔｒｉｎｇ　ｇｅｔＷｅｉｇｈｔ（Ｓｔｒｉｎｇ　ｓｅｘ，ｄｏｕｂｌｅ　ｈｅｉｇｈｔ）　｛　Ｓｔｒｉｎｇ　ｗｅｉｇｈｔ＝＂＂；　ｉｆ（ｓｅｘ．ｅｑｕａｌｓ（＂Ｍ＂））　｛　ｗｅｉｇｈｔ＝ｆｏｒｍａｔ（（ｈｅｉｇｈｔ－８０）＊０．７）；　｝　ｅｌｓｅ　｛　ｗｅｉｇｈｔ＝ｆｏｒｍａｔ（（ｈｅｉｇｈｔ－７０）＊０．６）；　｝　ｒｅｔｕｒｎ　ｗｅｉｇｈｔ；　｝　｝　　　　ｒｅｓ／ｌａｙｏｕｔ／ｍｙｌａｙｏｕｔ．ｘｍｌ

　　　　ｍｙｌａｙｏｕｔ．ｘｍｌ　为（ＥＸ０３＿１０＿１）的　Ｌａｙｏｕｔ，定义了显示计算结果的　ＴｅｘｔＶｉｅｗ。　　　　＜？ｘｍｌ　ｖｅｒｓｉｏｎ＝＂１．０＂　ｅｎｃｏｄｉｎｇ＝＂ｕｔｆ－８＂？＞　　＜ＴｅｘｔＶｉｅｗ　ａｎｄｒｏｉｄ：ｉｄ＝＂＠＋ｉｄ／ｔｅｘｔ１＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｗｉｄｔｈ＝＂ｗｒａｐ＿ｃｏｎｔｅｎｔ＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｈｅｉｇｈｔ＝＂ｗｒａｐ＿ｃｏｎｔｅｎｔ＂　ａｎｄｒｏｉｄ：ｔｅｘｔＳｉｚｅ＝＂２０ｓｐ＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｘ＝＂５０ｐｘ＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｙ＝＂７２ｐｘ＂　＞　＜／ＴｅｘｔＶｉｅｗ＞　

　　　　ＡｎｄｒｏｉｄＭａｎｉｆｅｓｔ．ｘｍｌ

　　　　由于本范例中有两个　Ａｃｔｉｖｉｔｙ，所以文件中必须有两个　ａｃｔｉｖｉｔｙ　的声明，否则系统将无法　运行，请看以下的描述。

　　　　＜？ｘｍｌ　ｖｅｒｓｉｏｎ＝＂１．０＂　ｅｎｃｏｄｉｎｇ＝＂ｕｔｆ－８＂？＞　＜ｍａｎｉｆｅｓｔ

　　　　ｘｍｌｎｓ：ａｎｄｒｏｉｄ＝＂ｈｔｔｐ：／／ｓｃｈｅｍａｓ．ａｎｄｒｏｉｄ．ｃｏｍ／ａｐｋ／ｒｅｓ／ａｎｄｒｏｉｄ＂　ｐａｃｋａｇｅ＝＂ｉｒｄｃ．ｅｘ０３＿１０＂　ａｎｄｒｏｉｄ：ｖｅｒｓｉｏｎＣｏｄｅ＝＂１＂　ａｎｄｒｏｉｄ：ｖｅｒｓｉｏｎＮａｍｅ＝＂１．０．０＂＞　　　　　＜ｃａｔｅｇｏｒｙ　ａｎｄｒｏｉｄ：ｎａｍｅ＝＂ａｎｄｒｏｉｄ．ｉｎｔｅｎｔ．ｃａｔｅｇｏｒｙ．ＬＡＵＮＣＨＥＲ＂　／＞　　　　　＜／ｍａｎｉｆｅｓｔ＞　　　　扩展学习

　　　　Ｂｕｎｄｌｅ　对象针对了不同的数据类型提供了许多的方法，　例如，　此范例中传递　Ｓｔｒｉｎｇ　类型　的数据，使用的方法为　Ｂｕｎｄｌｅ．ｐｕｔＳｔｒｉｎｇ（ｓｔｒｉｎｇＮａｍｅ，ｓｔｒｉｎｇＶａｌｕｅ）：

　　　　ｂｕｎｄｌｅ．ｐｕｔＤｏｕｂｌｅ（＂ｓｅｘ＂，ｓｅｘ）；

　　　　而　要　传　递　Ｄｏｕｂｌｅ　类　型　的　数　Ｂｕｎｄｌｅ．ｐｕｔＤｏｕｂｌｅ（ｄｏｕｂｌｅＮａｍｅ，ｄｏｕｂｌｅＶａｌｕｅ），如下：　据　，　使　用　的　方　法　为　　　　ｂｕｎｄｌｅ．ｐｕｔＳｔｒｉｎｇ（＂ｈｅｉｇｈｔ＂，ｈｅｉｇｈｔ）；

　　　　反　之　，　若　要　由　Ｂｕｎｄｌｅ　对　象　中　取　出　数　据　，　则　使　用　Ｂｕｎｄｌｅ．ｇｅｔＳｔｒｉｎｇ（ｓｔｒｉｎｇＮａｍｅ）　、　Ｂｕｎｄｌｅ．ｇｅｔＤｏｕｂｌｅ（ｄｏｕｂｌｅＮａｍｅ）　等相对应的方法即可。　除了上述简单的传递类型之外，　尚有　Ｓｔｒｉｎｇ［］　与　ＡｒｒａｙＬｉｓｔ　等封装的方式可供使　用　参考。

　　　　范例说明

　　　　上一个范例中，　好不容易将数据从　Ａｃｔｉｖｉｔｙ１　传递至　Ａｃｔｉｖｉｔｙ２，　如果要再回到　Ａｃｔｉｖｉｔｙ１，　数据该不会要再封装一次吧？而且前一个　Ａｃｔｉｖｉｔｙ１　早就被程序　ｄｅｓｔｒｏｙ　了，　倘若　在　Ａｃｔｉｖｉｔｙ１　最后以　ｆｉｎｉｓｈ（）　结束程序，再通过　Ａｃｔｉｖｉｔｙ２　将数据采用　Ｂｕｎｄｌｅ　的方式通过新打开　Ａｃｔｉｖｉｔｙ１　传递参数，这样的做法虽然也可以恢复　Ｕｓｅｒ　输入的数据，　但是并不符合我们的期待，尤其　是　Ｕｓｅｒ　曾经输入过的数据，如果不小心点击回到上一页，数据就消失不见，这就不妙了。　有鉴于科技始终来自于人性，如果要在次页面加上一个　“回上页”的按钮，而非通过模　拟器的回复

ｐａｇｅ　１６

键，且回上页后又能保留之前输入的相关信息，那么就必须使　用　ｓｔａｒｔＡｃｔｉｖｉｔｙＦｏｒＲｅｓｕｌｔ（）来　唤起一个　Ａｃｔｉｖｉｔｙ。利用这个方法，前一个　Ａｃｔｉｖｉｔｙ１　便会有一个等　待次　Ａｃｔｉｖｉｔｙ２　的返回，而返回的数据就可以达到我们想要的结果。　　　　运行结果

　　　　图　３－１１　将数据返回到前一个　Ａｃｔｉｖｉｔｙ　　　　范例程序

　　　　ｓｒｃ／ｉｒｄｃ．ｅｘ０３＿１１／ＥＸ０３＿１１．ｊａｖａ

　　　　在　Ａｃｔｉｖｉｔｙ１　主程序中调用　Ａｃｔｉｖｉｔｙ　的方法更改成　ｓｔａｒｔＡｃｔｉｖｉｔｙＦｏｒＲｅｓｕｌｔ（ｉｎｔｅｎｔ，０），　其中　０　为下一个　Ａｃｔｉｖｉｔｙ　要返回值的依据，可指定为自行定义的参考标识符（　Ｉｄｅｎｔｉｆｉｅｒ）　。程序覆　盖了　ｏｎＡｃｔｉｖｉｔｙＲｅｓｕｌｔ（）　这个方法，令程序在收到　ｒｅｓｕｌｔ　后，再重新加载写回原本输入的值。

　　　　ｐａｃｋａｇｅ　ｉｒｄｃ．ｅｘ０３＿１１；　／＊　ｉｍｐｏｒｔ　相关　ｃｌａｓｓ　＊／　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ａｐｐ．Ａｃｔｉｖｉｔｙ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｃｏｎｔｅｎｔ．Ｉｎｔｅｎｔ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｏｓ．Ｂｕｎｄｌｅ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｖｉｅｗ．Ｖｉｅｗ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．Ｂｕｔｔｏｎ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＥｄｉｔＴｅｘｔ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＲａｄｉｏＢｕｔｔｏｎ；　ｐｕｂｌｉｃ　ｃｌａｓｓ　ＥＸ０３＿１１　ｅｘｔｅｎｄｓ　Ａｃｔｉｖｉｔｙ　｛　ｐｒｉｖａｔｅ　ＥｄｉｔＴｅｘｔ　ｅｔ；　ｐｒｉｖａｔｅ　ＲａｄｉｏＢｕｔｔｏｎ　ｒｂ１；　ｐｒｉｖａｔｅ　ＲａｄｉｏＢｕｔｔｏｎ　ｒｂ２；　　　　／＊＊　Ｃａｌｌｅｄ　ｗｈｅｎ　ｔｈｅ　ａｃｔｉｖｉｔｙ　ｉｓ　ｆｉｒｓｔ　ｃｒｅａｔｅｄ．　＊／　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｒｅａｔｅ（Ｂｕｎｄｌｅ　ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）

　　　　｛　ｓｕｐｅｒ．ｏｎＣｒｅａｔｅ（ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）；　／＊　载入　ｍａｉｎ．ｘｍｌ　Ｌａｙｏｕｔ　＊／　ｓｅｔＣｏｎｔｅｎｔＶｉｅｗ（Ｒ．ｌａｙｏｕｔ．ｍａｉｎ）；

　　　　／＊　以　ｆｉｎｄＶｉｅｗＢｙＩｄ（）取得　Ｂｕｔｔｏｎ　对象，并添加　ｏｎＣｌｉｃｋＬｉｓｔｅｎｅｒ　＊／　Ｂｕｔｔｏｎ　ｂ１　＝　（Ｂｕｔｔｏｎ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｂｕｔｔｏｎ１）；　ｂ１．ｓｅｔＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（ｎｅｗ　Ｂｕｔｔｏｎ．ＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（）　｛　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｌｉｃｋ（Ｖｉｅｗ　ｖ）　｛　／＊取得输入的身高＊／　ｅｔ　＝　（ＥｄｉｔＴｅｘｔ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｈｅｉｇｈｔ）；　ｄｏｕｂｌｅ　ｈｅｉｇｈｔ＝Ｄｏｕｂｌｅ．ｐａｒｓｅＤｏｕｂｌｅ（ｅｔ．ｇｅｔＴｅｘｔ（）．ｔｏＳｔｒｉｎｇ（））；　／＊取得选择的性别＊／　Ｓｔｒｉｎｇ　ｓｅｘ＝＂＂；　ｒｂ１　＝　（ＲａｄｉｏＢｕｔｔｏｎ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｓｅｘ１）；　ｒｂ２　＝　（ＲａｄｉｏＢｕｔｔｏｎ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｓｅｘ２）；　ｉｆ（ｒｂ１．ｉｓＣｈｅｃｋｅｄ（））　｛　ｓｅｘ＝＂Ｍ＂；　｝　ｅｌｓｅ　｛　　　　ｓｅｘ＝＂Ｆ＂；　｝

　　　　／＊ｎｅｗ　一个　Ｉｎｔｅｎｔ　对象，并指定　ｃｌａｓｓ＊／　Ｉｎｔｅｎｔ　ｉｎｔｅｎｔ　＝　ｎｅｗ　Ｉｎｔｅｎｔ（）；　ｉｎｔｅｎｔ．ｓｅｔＣｌａｓｓ（ＥＸ０３＿１１．ｔｈｉｓ，ＥＸ０３＿１１＿１．ｃｌａｓｓ）；

　　　　／＊ｎｅｗ　一个　Ｂｕｎｄｌｅ　对象，并将要传递的数据传入＊／　Ｂｕｎｄｌｅ　ｂｕｎｄｌｅ　＝　ｎｅｗ　Ｂｕｎｄｌｅ（）；　ｂｕｎｄｌｅ．ｐｕｔＤｏｕｂｌｅ（＂ｈｅｉｇｈｔ＂，ｈｅｉｇｈｔ）；　ｂｕｎｄｌｅ．ｐｕｔＳｔｒｉｎｇ（＂ｓｅｘ＂，ｓｅｘ）；　　　　／＊将　Ｂｕｎｄｌｅ　对象　ａｓｓｉｇｎ　给　Ｉｎｔｅｎｔ＊／　ｉｎｔｅｎｔ．ｐｕｔＥｘｔｒａｓ（ｂｕｎｄｌｅ）；

　　　　／＊调用　Ａｃｔｉｖｉｔｙ　ＥＸ０３＿１１＿１＊／　ｓｔａｒｔＡｃｔｉｖｉｔｙＦｏｒＲｅｓｕｌｔ（ｉｎｔｅｎｔ，０）；　｝　｝）；　｝　　　　／＊　覆盖　ｏｎＡｃｔｉｖｉｔｙＲｅｓｕｌｔ（）＊／　＠Ｏｖｅｒｒｉｄｅ　ｐｒｏｔｅｃｔｅｄ　ｖｏｉｄ　ｏｎＡｃｔｉｖｉｔｙＲｅｓｕｌｔ（ｉｎｔ　ｒｅｑｕｅｓｔＣｏｄｅ，　ｉｎｔ　ｒｅｓｕｌｔＣｏｄｅ，

　　　　Ｉｎｔｅｎｔ　ｄａｔａ）　｛　ｓｗｉｔｃｈ　（ｒｅｓｕｌｔＣｏｄｅ）　｛　ｃａｓｅ　ＲＥＳＵＬＴ＿ＯＫ：　／＊　取得来自　Ａｃｔｉｖｉｔｙ２　的数据，并显示于画面上　＊／　Ｂｕｎｄｌｅ　ｂｕｎｄｅ　＝　ｄａｔａ．ｇｅｔＥｘｔｒａｓ（）；　Ｓｔｒｉｎｇ　ｓｅｘ　＝　ｂｕｎｄｅ．ｇｅｔＳｔｒｉｎｇ（＂ｓｅｘ＂）；　ｄｏｕｂｌｅ　ｈｅｉｇｈｔ　＝　ｂｕｎｄｅ．ｇｅｔＤｏｕｂｌｅ（＂ｈｅｉｇｈｔ＂）；　　　　ｅｔ．ｓｅｔＴｅｘｔ（＂＂＋ｈｅｉｇｈｔ）；　ｉｆ（ｓｅｘ．ｅｑｕａｌｓ（＂Ｍ＂））　｛　ｒｂ１．ｓｅｔＣｈｅｃｋｅｄ（ｔｒｕｅ）；　｝　ｅｌｓｅ　｛　ｒｂ２．ｓｅｔＣｈｅｃｋｅｄ（ｔｒｕｅ）；　｝　ｂｒｅａｋ；　ｄｅｆａｕｌｔ：　ｂｒｅａｋ；　｝　｝　　　　｝

　　　　ｓｒｃ／ｉｒｄｃ．ｅｘ０３＿１１／ＥＸ０３＿１１＿１．ｊａｖａ

　　　　在　Ａｃｔｉｖｉｔｙ２　的主程序中，设计当　Ｂｕｔｔｏｎ　被点击时，将　Ｂｕｎｄｌｅ　对象与结果返回给前一个　Ａｃｔｉｖｉｔｙ１。

　　　　ｐａｃｋａｇｅ　ｉｒｄｃ．ｅｘ０３＿１１；　／＊　ｉｍｐｏｒｔ　相关　ｃｌａｓｓ　＊／　ｉｍｐｏｒｔ　ｊａｖａ．ｔｅｘｔ．ＤｅｃｉｍａｌＦｏｒｍａｔ；　ｉｍｐｏｒｔ　ｊａｖａ．ｔｅｘｔ．ＮｕｍｂｅｒＦｏｒｍａｔ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ａｐｐ．Ａｃｔｉｖｉｔｙ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｃｏｎｔｅｎｔ．Ｉｎｔｅｎｔ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｏｓ．Ｂｕｎｄｌｅ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｖｉｅｗ．Ｖｉｅｗ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．Ｂｕｔｔｏｎ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＴｅｘｔＶｉｅｗ；　ｐｕｂｌｉｃ　ｃｌａｓｓ　ＥＸ０３＿１１＿１　ｅｘｔｅｎｄｓ　Ａｃｔｉｖｉｔｙ　｛　Ｂｕｎｄｌｅ　ｂｕｎｄｅ；　Ｉｎｔｅｎｔ　ｉｎｔｅｎｔ；　／＊＊　Ｃａｌｌｅｄ　

ｐａｇｅ　１７

ｗｈｅｎ　ｔｈｅ　ａｃｔｉｖｉｔｙ　ｉｓ　ｆｉｒｓｔ　ｃｒｅａｔｅｄ．　＊／　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｒｅａｔｅ（Ｂｕｎｄｌｅ　ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）　｛　ｓｕｐｅｒ．ｏｎＣｒｅａｔｅ（ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）；

　　　　／＊　载入　ｍｙｌａｙｏｕｔ．ｘｍｌ　Ｌａｙｏｕｔ　＊／　ｓｅｔＣｏｎｔｅｎｔＶｉｅｗ（Ｒ．ｌａｙｏｕｔ．ｍｙａｌｙｏｕｔ）；　　　　／＊　取得　Ｉｎｔｅｎｔ　中的　Ｂｕｎｄｌｅ　对象　＊／　ｉｎｔｅｎｔ＝ｔｈｉｓ．ｇｅｔＩｎｔｅｎｔ（）；　ｂｕｎｄｅ　＝　ｉｎｔｅｎｔ．ｇｅｔＥｘｔｒａｓ（）；

　　　　／＊　取得　Ｂｕｎｄｌｅ　对象中的数据　＊／　Ｓｔｒｉｎｇ　ｓｅｘ　＝　ｂｕｎｄｅ．ｇｅｔＳｔｒｉｎｇ（＂ｓｅｘ＂）；　ｄｏｕｂｌｅ　ｈｅｉｇｈｔ　＝　ｂｕｎｄｅ．ｇｅｔＤｏｕｂｌｅ（＂ｈｅｉｇｈｔ＂）；

　　　　／＊　判断性别　＊／　Ｓｔｒｉｎｇ　ｓｅｘＴｅｘｔ＝＂＂；　ｉｆ（ｓｅｘ．ｅｑｕａｌｓ（＂Ｍ＂））　｛　ｓｅｘＴｅｘｔ＝＂男性＂；　｝　ｅｌｓｅ　｛　ｓｅｘＴｅｘｔ＝＂女性＂；　｝

　　　　／＊　取得标准体重　＊／　Ｓｔｒｉｎｇ　ｗｅｉｇｈｔ＝ｔｈｉｓ．ｇｅｔＷｅｉｇｈｔ（ｓｅｘ，　ｈｅｉｇｈｔ）；

　　　　／＊　设置输出文字　＊／　ＴｅｘｔＶｉｅｗ　ｔｖ１＝（ＴｅｘｔＶｉｅｗ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｔｅｘｔ１）；　ｔｖ１．ｓｅｔＴｅｘｔ（＂你是一位＂＋ｓｅｘＴｅｘｔ＋＂＼ｎ　你的身高是＂＋ｈｅｉｇｈｔ＋　＂厘米＼ｎ　你的标准体重是＂＋ｗｅｉｇｈｔ＋＂公斤＂）；

　　　　／＊　以　ｆｉｎｄＶｉｅｗＢｙＩｄ（）取得　Ｂｕｔｔｏｎ　对象，并添加　ｏｎＣｌｉｃｋＬｉｓｔｅｎｅｒ　＊／　Ｂｕｔｔｏｎ　ｂ１　＝　（Ｂｕｔｔｏｎ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｂｕｔｔｏｎ１）；　ｂ１．ｓｅｔＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（ｎｅｗ　Ｂｕｔｔｏｎ．ＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（）　｛　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｌｉｃｋ（Ｖｉｅｗ　ｖ）　｛　／＊　返回　ｒｅｓｕｌｔ　回上一个　ａｃｔｉｖｉｔｙ　＊／　ＥＸ０３＿１１＿１．ｔｈｉｓ．ｓｅｔＲｅｓｕｌｔ（ＲＥＳＵＬＴ＿ＯＫ，　ｉｎｔｅｎｔ）；　　　　／＊　结束这个　ａｃｔｉｖｉｔｙ　＊／　ＥＸ０３＿１１＿１．ｔｈｉｓ．ｆｉｎｉｓｈ（）；　｝　｝）；　｝　　　　／＊　四舍五入的　ｍｅｔｈｏｄ　＊／　ｐｒｉｖａｔｅ　Ｓｔｒｉｎｇ　ｆｏｒｍａｔ（ｄｏｕｂｌｅ　ｎｕｍ）　｛

　　　　ＮｕｍｂｅｒＦｏｒｍａｔ　ｆｏｒｍａｔｔｅｒ　＝　ｎｅｗ　ＤｅｃｉｍａｌＦｏｒｍａｔ（＂０．００＂）；　Ｓｔｒｉｎｇ　ｓ＝ｆｏｒｍａｔｔｅｒ．ｆｏｒｍａｔ（ｎｕｍ）；　ｒｅｔｕｒｎ　ｓ；　｝　／＊　以　ｆｉｎｄＶｉｅｗＢｙＩｄ（）取得　Ｂｕｔｔｏｎ　对象，并添加　ｏｎＣｌｉｃｋＬｉｓｔｅｎｅｒ　＊／　ｐｒｉｖａｔｅ　Ｓｔｒｉｎｇ　ｇｅｔＷｅｉｇｈｔ（Ｓｔｒｉｎｇ　ｓｅｘ，ｄｏｕｂｌｅ　ｈｅｉｇｈｔ）　｛　Ｓｔｒｉｎｇ　ｗｅｉｇｈｔ＝＂＂；　ｉｆ（ｓｅｘ．ｅｑｕａｌｓ（＂Ｍ＂））　｛　ｗｅｉｇｈｔ＝ｆｏｒｍａｔ（（ｈｅｉｇｈｔ－８０）＊０．７）；　｝　ｅｌｓｅ　｛　ｗｅｉｇｈｔ＝ｆｏｒｍａｔ（（ｈｅｉｇｈｔ－７０）＊０．６）；　｝　ｒｅｔｕｒｎ　ｗｅｉｇｈｔ；　｝　｝　　　　ｒｅｓ／ｌａｙｏｕｔ／ｍｙｌａｙｏｕｔ．ｘｍｌ

　　　　ｍｙｌａｙｏｕｔ．ｘｍｌ　为　Ａｃｔｉｖｉｔｙ２　（ＥＸ０３＿１１＿１）　Ｌａｙｏｕｔ，　的　其中定义了显示计算结果的　ＴｅｘｔＶｉｅｗ　与回上一页的　Ｂｕｔｔｏｎ　按钮。　　　　＜？ｘｍｌ　ｖｅｒｓｉｏｎ＝＂１．０＂　ｅｎｃｏｄｉｎｇ＝＂ｕｔｆ－８＂？＞

　　　　＜ＴｅｘｔＶｉｅｗ　ａｎｄｒｏｉｄ：ｉｄ＝＂＠＋ｉｄ／ｔｅｘｔ１＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｗｉｄｔｈ＝＂ｗｒａｐ＿ｃｏｎｔｅｎｔ＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｈｅｉｇｈｔ＝＂ｗｒａｐ＿ｃｏｎｔｅｎｔ＂　ａｎｄｒｏｉｄ：ｔｅｘｔＳｉｚｅ＝＂２０ｓｐ＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｘ＝＂５０ｐｘ＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｙ＝＂７２ｐｘ＂　＞　＜／ＴｅｘｔＶｉｅｗ＞　　　　　　　ＡｎｄｒｏｉｄＭａｎｉｆｅｓｔ．ｘｍｌ

　　　　范例中有两个　Ａｃｔｉｖｉｔｙ，所以　ＡｎｄｒｏｉｄＭａｎｉｆｅｓｔ．ｘｍｌ　里必须有这两个　ａｃｔｉｖｉｔｙ　的声明，否　则系统将无法运行。

　　　　＜？ｘｍｌ　ｖｅｒｓｉｏｎ＝＂１．０＂　ｅｎｃｏｄｉｎｇ＝＂ｕｔｆ－８＂？＞　＜ｍａｎｉｆｅｓｔ　ｘｍｌｎｓ：ａｎｄｒｏｉｄ＝＂ｈｔｔｐ：／／ｓｃｈｅｍａｓ．ａｎｄｒｏｉｄ．ｃｏｍ／ａｐｋ／ｒｅｓ／ａｎｄｒｏｉｄ＂　ｐａｃｋａｇｅ＝＂ｉｒｄｃ．ｅｘ０３＿１１＂　ａｎｄｒｏｉｄ：ｖｅｒｓｉｏｎＣｏｄｅ＝＂１＂　ａｎｄｒｏｉｄ：ｖｅｒｓｉｏｎＮａｍｅ＝＂１．０．０＂＞　　　　　＜ｃａｔｅｇｏｒｙ　ａｎｄｒｏｉｄ：ｎａｍｅ＝＂ａｎｄｒｏｉｄ．ｉｎｔｅｎｔ．ｃａｔｅｇｏｒｙ．ＬＡＵＮＣＨＥＲ＂　／＞　　　　　＜／ｍａｎｉｆｅｓｔ＞　　　　扩展学习

　　　　范例中为了在回到上一页时，能够显示之前所输入的数　据，故将原本传递次　Ａｃｔｉｖｉｔｙ　的　Ｉｎｔｅｎｔ　（里面包含了有数据的　Ｂｕｎｄｌｅ　对象）　再重新返回给主　Ａｃｔｉｖｉｔｙ１。　如果要在次　Ａｃｔｉｖｉｔｙ２　中返回其它的数据，　例如，　经过计算后的结果、　数据，　此时只需将要返回的数据再放入　Ｂｕｎｄｌｅ　对象中即可达成。　此外，以本范例　而言，其实使用　ｓｔａｒｔＡｃｔｉｖｉｔｙ（）也可达成同样的结果，仅需在主　Ａｃｔｉｖｉｔｙ　被　ｃｒｅａｔｅ　时去判断　Ｉｎｔｅｎｔ　内有没有数据，有的话，　就将数据带入；没有的话，就带入空值　（ｎｕｌｌ）　。但程序还需要再做有无值的比较，较为繁琐，既然　Ａｎｄｒｏｉｄ　ＡＰＩ　中有提供更好用的　方法，何来不用的道理？更何况如果系统不是只有几行代码，而是几十行、几百行代码，　那　时头可就大了！　　　　第四章：史上超豪华的手机控件　　　　范例说明

　　　　ＥｄｉｔＴｅｘｔ　Ｗｉｄｇｅｔ　的设计是为了等待　Ｕｓｅｒ　输入而准备的，那么在　Ｕｓｅｒ　输入的同时，又该　如何拦截所输入的文字呢？Ａｎｄｒｏｉｄ　的多数　Ｗｉｄｇｅｔ　都有　ｓｅｔＯｎＫｅｙＬｉｓｔ

ｐａｇｅ　１８

ｅｎｅｒ　事件，　以此　Ｌｉｓｔｅｎｅｒ　捕捉　Ｕｓｅｒ　输入的键盘事件。　接着，本范例将以　ＥｄｉｔＴｅｘｔ　与　ＴｅｘｔＶｉｅｗ　示范如何在捕捉　Ｕｓｅｒ　键盘输入文字的同时，实　时取得文字，同步显示于　ＴｅｘｔＶｉｅｗ，类似手机版的　Ａｊａｘ　效果，实时输入实时输出。　　　　运行结果

　　　　▲图　４－１　在　ＥｄｉｔＴｅｘｔ　输入的数据，立即出现在　ＴｅｘｔＶｉｅｗ　里面　　　　范例程序

　　　　ｓｒｃ／ｉｒｄｃ．ｅｘ０４＿０１／ＥＸ０４＿０１．ｊａｖａ

　　　　主程序　中唯一也是关键之处，便是利用　ＥｄｉｔＴｅｘｔ．ＯｎＫｅｙＬｉｓｔｅｎｅｒ　来拦截　ＥｄｉｔＴｅｘｔ　的键盘　输入事件，仅需在其中重写　ｏｎＫｅｙ（）　方法，在　ｏｎＫｅｙ（）　方法中，将　ＥｄｉｔＴｅｘｔ．ｇｅｔＴｅｘｔ（）　取出　的文字，显示于　ＴｅｘｔＶｉｅｗ　当中，是一个简单易懂的范例练习。

　　　　ｐａｃｋａｇｅ　ｉｒｄｃ．ｅｘ０４＿０１；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ａｐｐ．Ａｃｔｉｖｉｔｙ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｏｓ．Ｂｕｎｄｌｅ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｖｉｅｗ．ＫｅｙＥｖｅｎｔ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｖｉｅｗ．Ｖｉｅｗ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＥｄｉｔＴｅｘｔ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＴｅｘｔＶｉｅｗ；　ｐｕｂｌｉｃ　ｃｌａｓｓ　ＥＸ０４＿０１　ｅｘｔｅｎｄｓ　Ａｃｔｉｖｉｔｙ　｛　／＊声明　ＴｅｘｔＶｉｅｗ、ＥｄｉｔＴｅｘｔ　对象＊／　ｐｒｉｖａｔｅ　ＴｅｘｔＶｉｅｗ　ｍＴｅｘｔＶｉｅｗ０１；　ｐｒｉｖａｔｅ　ＥｄｉｔＴｅｘｔ　ｍＥｄｉｔＴｅｘｔ０１；

　　　　／＊＊　Ｃａｌｌｅｄ　ｗｈｅｎ　ｔｈｅ　ａｃｔｉｖｉｔｙ　ｉｓ　ｆｉｒｓｔ　ｃｒｅａｔｅｄ．　＊／　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｒｅａｔｅ（Ｂｕｎｄｌｅ　ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）　｛　ｓｕｐｅｒ．ｏｎＣｒｅａｔｅ（ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）；

　　　　ｓｅｔＣｏｎｔｅｎｔＶｉｅｗ（Ｒ．ｌａｙｏｕｔ．ｍａｉｎ）；

　　　　／＊取得　ＴｅｘｔＶｉｅｗ、ＥｄｉｔＴｅｘｔ＊／　ｍＴｅｘｔＶｉｅｗ０１　＝　（ＴｅｘｔＶｉｅｗ）ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＴｅｘｔＶｉｅｗ）；　ｍＥｄｉｔＴｅｘｔ０１　＝　（ＥｄｉｔＴｅｘｔ）ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＥｄｉｔＴｅｘｔ）；

　　　　／＊设置　ＥｄｉｔＴｅｘｔ　用　ＯｎＫｅｙＬｉｓｔｅｎｅｒ　事件来启动＊／　ｍＥｄｉｔＴｅｘｔ０１．ｓｅｔＯｎＫｅｙＬｉｓｔｅｎｅｒ（ｎｅｗ　ＥｄｉｔＴｅｘｔ．ＯｎＫｅｙＬｉｓｔｅｎｅｒ（）　｛　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｂｏｏｌｅａｎ　ｏｎＫｅｙ（Ｖｉｅｗ　ａｒｇ０，　ｉｎｔ　ａｒｇ１，　ＫｅｙＥｖｅｎｔ　ａｒｇ２）　｛　／／　ＴＯＤＯ　Ａｕｔｏ－ｇｅｎｅｒａｔｅｄ　ｍｅｔｈｏｄ　ｓｔｕｂ　／＊设置　ＴｅｘｔＶｉｅｗ　显示　ＥｄｉｔＴｅｘｔ　所输入的内容＊／　ｍＴｅｘｔＶｉｅｗ０１．ｓｅｔＴｅｘｔ（ｍＥｄｉｔＴｅｘｔ０１．ｇｅｔＴｅｘｔ（））；　ｒｅｔｕｒｎ　ｆａｌｓｅ；　｝　｝）；　｝　｝　　　　延伸学习

　　　　这个实时输入实时显示的效果可以扩展在许多手机应用　程序中，可以试着　在　ＯｎＫｅｙＬｉｓｔｅｎｅｒ（）　里做实时文字过滤效果，例如：当　Ｕｓｅｒ　输入不雅的文字时，可以提示　Ｕｓｅｒ　不接受部分关键字，以输入　Ｓｈｉｔ　为例，在　ＴｅｘｔＶｉｅｗ　就会出　现：Ｓｈ＊ｔ，此种做法可以过滤掉

　　　　不雅文字的出现。　此外，不仅是　Ｗｉｄｇｅｔ　才有　ｓｅｔＯｎＫｅｙＬｉｓｔｅｎｅｒ　方法可以重写，事实上，在　Ｖｉｅｗ　里也有　Ｖｉｅｗ．ｓｅｔＯｎＫｅｙＬｉｓｔｅｎｅｒ，也就是捕捉　Ｕｓｅｒ　点击键盘时的　事件处理，但请特别注意，需拦截　这个事件，即　Ｖｉｅｗ　要取得焦点（Ｆｏｃｕｓ）才能触发　ｏｎＫｅｙＤｏｗｎ　事件。最后提醒你，旧版本　当中的　Ｖｉｅｗ．ｓｅｔＫｅｙＬｉｓｔｅｎｅｒ　类已经被删除，１．０ｒ２　版之后，已经改用　Ｖｉｅｗ．ｓｅｔＯｎＫｅｙＬｉｓｔｅｎｅｒ（）　方法替换。　　　　范例说明

　　　　延续前一章按钮事件的应用范例，重新设计一个具有背景图的按钮，让按钮有美观的背　景图片，只是这次不使用先前的　Ｂｕｔｔｏｎ　Ｗｉｄｇｅｔ，而是改以　ＩｍａｇｅＢｕｔｔｏｎ　Ｗｉｄｇｅｔ　来显示。　将按钮背景图预先　Ｉｍｐｏｒｔ　至　Ｄｒａｗａｂｌｅ　里（＊．ｐｎｇ　图形文件）　，利用这些图片，作为　ＩｍａｇｅＢｕｔｔｏｎ　的背景图，为了做对照，在　Ｌａｙｏｕｔ　配置一个“一般按钮”，运行结果画面中，可　以明显看出图片按钮与一般按钮在外观上的差异。　要　设　置　ＩｍａｇｅＢｕｔｔｏｎ　背　景　图　有　许　多　方　法　，　此　程　序　使　用　的　方　法　是　ＩｍａｇｅＢｕｔｔｏｎ．ｓｅｔＩｍａｇｅＲｅｓｏｕｒｃｅ（），需要传递的参数即是　ｒｅｓ／ｄｒａｗａｂｌｅ／　下面的　Ｒｅｓｏｕｒｃｅ　ＩＤ，　除　了设置背景图片的方法外，程序需要用到　ｏｎＦｏｃｕｓＣｈａｎｇｅ　与　ｏｎＣｌｉｃｋ　等按钮事件作为按钮事　件点击之后的处理，最后通过　ＴｅｘｔＶｉｅｗ　来显示目前图片按钮的状态为　ｏｎＣｌｉｃｋ、ｏｎＦｏｃｕｓ，　或　ｏｆｆＦｏｃｕｓ，并且同步更新按钮的背景图，让　Ｕｓｅｒ　有动态交互的感　觉。　　　　运行结果

　　　　▲图　４－２　随着　Ｆｏｃｕｓ　与　Ｃｌｉｃｋ　动作，画面上的图片与文字会告知你目前图片　按钮的状态

ｐａｇｅ　１９

　　　　范例程序

　　　　ｓｒｃ／ｉｒｄｃ．ｅｘ０４＿０２／ＥＸ０４＿０２．ｊａｖａ

　　　　主　程　序　构　造　三　个　对　象　ＩｍａｇｅＢｕｔｔｏｎ　、　Ｂｕｔｔｏｎ　与　ＴｅｘｔＶｉｅｗ　，　并　在　ＩｍａｇｅＢｕｔｔｏｎ　上　设　置　ｏｎＦｏｃｕｓＣｈａｎｇｅＬｉｓｔｅｎｅｒ　与　ｏｎＣｌｉｃｋＬｉｓｔｅｎｅｒ，并实现　Ｉｍａｇｅ　Ｂｕｔｔｏｎ　图片的置换。　ＩｍａｇｅＢｕｔｔｏｎ．ｓｅｔＯｎＦｏｃｕｓＣｈａｎｇｅＬｉｓｔｅｎｅｒ（）　是处理　Ｕｓｅｒ　点击图片按钮之后需要处理的关　键，当点击图片按钮的瞬间，以　ＩｍａｇｅＢｕｔｔｏｎ．ｓｅｔＩｍａｇｅＲｅｓｏｕｒｃｅ（）　来更换背景图片。

　　　　ｐａｃｋａｇｅ　ｉｒｄｃ．ＥＸ０４＿０２；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ａｐｐ．Ａｃｔｉｖｉｔｙ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｏｓ．Ｂｕｎｄｌｅ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｖｉｅｗ．Ｖｉｅｗ；　／＊使用　ＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ　与　ＯｎＦｏｃｕｓＣｈａｎｇｅＬｉｓｔｅｎｅｒ　来区分按钮的状态＊／　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｖｉｅｗ．Ｖｉｅｗ．ＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｖｉｅｗ．Ｖｉｅｗ．ＯｎＦｏｃｕｓＣｈａｎｇｅＬｉｓｔｅｎｅｒ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．Ｂｕｔｔｏｎ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＩｍａｇｅＢｕｔｔｏｎ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＴｅｘｔＶｉｅｗ；　ｐｕｂｌｉｃ　ｃｌａｓｓ　ＥＸ０４＿０２　ｅｘｔｅｎｄｓ　Ａｃｔｉｖｉｔｙ　｛　／＊声明三个对象变量（图片按钮，按钮，与　ＴｅｘｔＶｉｅｗ）＊／　ｐｒｉｖａｔｅ　ＩｍａｇｅＢｕｔｔｏｎ　ｍＩｍａｇｅＢｕｔｔｏｎ１；　ｐｒｉｖａｔｅ　Ｂｕｔｔｏｎ　ｍＢｕｔｔｏｎ１；　ｐｒｉｖａｔｅ　ＴｅｘｔＶｉｅｗ　ｍＴｅｘｔＶｉｅｗ１；

　　　　／＊＊　Ｃａｌｌｅｄ　ｗｈｅｎ　ｔｈｅ　ａｃｔｉｖｉｔｙ　ｉｓ　ｆｉｒｓｔ　ｃｒｅａｔｅｄ．　＊／　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｒｅａｔｅ（Ｂｕｎｄｌｅ　ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）　｛　ｓｕｐｅｒ．ｏｎＣｒｅａｔｅ（ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）；　ｓｅｔＣｏｎｔｅｎｔＶｉｅｗ（Ｒ．ｌａｙｏｕｔ．ｍａｉｎ）；

　　　　／＊通过　ｆｉｎｄＶｉｅｗＢｙＩｄ　构造三个对象＊／　ｍＩｍａｇｅＢｕｔｔｏｎ１　＝（ＩｍａｇｅＢｕｔｔｏｎ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＩｍａｇｅＢｕｔｔｏｎ１）；　ｍＢｕｔｔｏｎ１＝（Ｂｕｔｔｏｎ）ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＢｕｔｔｏｎ１）；　ｍＴｅｘｔＶｉｅｗ１　＝　（ＴｅｘｔＶｉｅｗ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＴｅｘｔＶｉｅｗ１）；

　　　　／＊通过　ＯｎＦｏｃｕｓＣｈａｎｇｅＬｉｓｔｅｎｅｒ　来响应　ＩｍａｇｅＢｕｔｔｏｎ　的　ｏｎＦｏｕｓ　事件＊／　ｍＩｍａｇｅＢｕｔｔｏｎ１．ｓｅｔＯｎＦｏｃｕｓＣｈａｎｇｅＬｉｓｔｅｎｅｒ（ｎｅｗ　ＯｎＦｏｃｕｓＣｈａｎｇｅＬｉｓｔｅｎｅｒ（）　｛　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＦｏｃｕｓＣｈａｎｇｅ（Ｖｉｅｗ　ａｒｇ０，　ｂｏｏｌｅａｎ　ｉｓＦｏｃｕｓｅｄ）　｛　／／　ＴＯＤＯ　Ａｕｔｏ－ｇｅｎｅｒａｔｅｄ　ｍｅｔｈｏｄ　ｓｔｕｂ

　　　　／＊若　ＩｍａｇｅＢｕｔｔｏｎ　状态为　ｏｎＦｏｃｕｓ　改变　ＩｍａｇｅＢｕｔｔｏｎ　的图片　＊　并改变　ｔｅｘｔＶｉｅｗ　的文字＊／　ｉｆ　（ｉｓＦｏｃｕｓｅｄ＝＝ｔｒｕｅ）

　　　　｛　ｍＴｅｘｔＶｉｅｗ１．ｓｅｔＴｅｘｔ（＂图片按钮状态为：Ｇｏｔ　Ｆｏｃｕｓ＂）；　ｍＩｍａｇｅＢｕｔｔｏｎ１．ｓｅｔＩｍａｇｅＲｅｓｏｕｒｃｅ（Ｒ．ｄｒａｗａｂｌｅ．ｉｃｏｎｆｕｌｌ）；　｝　／＊若　ＩｍａｇｅＢｕｔｔｏｎ　状态为　ｏｆｆＦｏｃｕｓ　改变　ＩｍａｇｅＢｕｔｔｏｎ　的图片　＊并改变　ｔｅｘｔＶｉｅｗ　的文字＊／　ｅｌｓｅ　｛　ｍＴｅｘｔＶｉｅｗ１．ｓｅｔＴｅｘｔ（＂图片按钮状态为：Ｌｏｓｔ　Ｆｏｃｕｓ＂）；　ｍＩｍａｇｅＢｕｔｔｏｎ１．ｓｅｔＩｍａｇｅＲｅｓｏｕｒｃｅ（Ｒ．ｄｒａｗａｂｌｅ．ｉｃｏｎｅｍｐｔｙ）；　｝　｝　｝）；

　　　　／＊通过　ｏｎＣｌｉｃｋＬｉｓｔｅｎｅｒ　来响应　ＩｍａｇｅＢｕｔｔｏｎ　的　ｏｎＣｌｉｃｋ　事件＊／　ｍＩｍａｇｅＢｕｔｔｏｎ１．ｓｅｔＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（ｎｅｗ　ＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（）　｛　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｌｉｃｋ（Ｖｉｅｗ　ｖ）　｛　／／　ＴＯＤＯ　Ａｕｔｏ－ｇｅｎｅｒａｔｅｄ　ｍｅｔｈｏｄ　ｓｔｕｂ　／＊若　ＩｍａｇｅＢｕｔｔｏｎ　状态为　ｏｎＣｌｉｃｋ　改变　ＩｍａｇｅＢｕｔｔｏｎ　的图片　＊　并改变　ｔｅｘｔＶｉｅｗ　的文字＊／　ｍＴｅｘｔＶｉｅｗ１．ｓｅｔＴｅｘｔ（＂图片按钮状态为：Ｇｏｔ　Ｃｌｉｃｋ＂）；　ｍＩｍａｇｅＢｕｔｔｏｎ１．ｓｅｔＩｍａｇｅＲｅｓｏｕｒｃｅ（Ｒ．ｄｒａｗａｂｌｅ．ｉｃｏｎｆｕｌｌ）；　　　　｝　｝）；

　　　　／＊通过　ｏｎＣｌｉｃｋＬｉｓｔｅｎｅｒ　来响应　Ｂｕｔｔｏｎ　的　ｏｎＣｌｉｃｋ　事件＊／　ｍＢｕｔｔｏｎ１．ｓｅｔＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（ｎｅｗ　ＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（）　｛　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｌｉｃｋ（Ｖｉｅｗ　ｖ）　｛　／／　ＴＯＤＯ　Ａｕｔｏ－ｇｅｎｅｒａｔｅｄ　ｍｅｔｈｏｄ　ｓｔｕｂ　／＊若　Ｂｕｔｔｏｎ　状态为　ｏｎＣｌｉｃｋ　改变　ＩｍａｇｅＢｕｔｔｏｎ　的图片　＊　并改变　ｔｅｘｔＶｉｅｗ　的文字＊／　ｍＴｅｘｔＶｉｅｗ１．ｓｅｔＴｅｘｔ（＂图片按钮状态为：Ｌｏｓｔ　Ｆｏｃｕｓ＂）；　ｍＩｍａｇｅＢｕｔｔｏｎ１．ｓｅｔＩｍａｇｅＲｅｓｏｕｒｃｅ（Ｒ．ｄｒａｗａｂｌｅ．ｉｃｏｎｅｍｐｔｙ）；　｝　｝）；　｝　｝　　　　扩展学习

　　　　除了在运行时用　ｏｎＦｏｃｕｓ（）　与　ｏｎＣｌｉｃｋ（）　事件来设置按钮背景图片外，Ａｎｄｒｏｉｄ　的　ＭＶＣ　设计理念，可以让程序运行之初就以　ｘｍｌ　定义的方式来初始化　ＩｍａｇｅＢｕｔｔｏｎ　的背景图，仅需　先将图片导入　ｒｅｓ／ｄｒａｗａｂｌｅ。　设　置　方　法　为　在　ｒｅｓ／ｄｒａｗａｂｌｅ　下　自　行　定　义　一　个　ｘｍｌ　，　主　要　针　对　按　钮　的　ｓｔａｔｅ＿ｆｏｃｕｓｅｄ　、　ｓｔａｔｅ＿ｐｒｅｓｓｅｄ　与　ｄｒａｗａｂｌｅ　属性作设置，如下所示：　　　　ｄｒａｗａｂｌｅ／ａｄｖａｎｃｅｄｂｕｔｔｏｎ．ｘｍｌ

　　　　＜？ｘｍｌ　ｖｅｒｓｉｏｎ＝＂１．０＂　ｅｎｃｏｄｉｎｇ＝＂ｕｔｆ－８＂？＞　　　　　　

　　　　然后，在　ｍａｉｎ．ｘｍｌ　中将　ａｄｖａｎｃｅｄｂｕｔｔｏｎ　赋值给　Ｂｕｔｔｏｎ　组件中　ｂａｃｋｇｒｏｕｎｄ

ｐａｇｅ　２０

　的属性。

　　　　ｌａｙｏｕｔ／ｍａｉｎ．ｘｍｌ

　　　　如此一来，即可达到如同本范例程序所展示的效果。　　　　范例说明

　　　　Ｔｏａｓｔ　是　Ａｎｄｒｏｉｄ　专属的提示小对象，它的　使用方式相当简单，但用途却很广泛，基本　上，　Ｔｏａｓｔ　就是一个简短的小信息，　将要告诉用户的信息，　以一个浮动在最上层的　Ｖｉｅｗ　显示，　显示　Ｔｏａｓｔ　之　后，静待几秒后便会自动消失，最常见的应用就是音量大小的调整，当点击　音量调整钮之后，会看见跳出的音量指示　Ｔｏａｓｔ　对象，等待调整完之后便会消失。　通过　Ｔｏａｓｔ　的特性，可以在不影响用户通话或聆听音乐情况下，显示要给　Ｕｓｅｒ　的信息。　对于程序员来说，它也是一个非常好用的　ｄｅｂｕｇ　工具，可以在任何程序运行时，通过　Ｔｏａｓｔ　的方式，显示运行变量或手机环境的概况。　本范例使用一个　ＥｄｉｔＴｅｘｔ　控件来接受用户输入　的文字，以及配置　Ｂｕｔｔｏｎ　按钮　Ｗｉｄｇｅｔ，　点击按钮时，将　ＥｄｉｔＴｅｘｔ　里的文字，以　Ｔｏａｓｔ．ｍａｋｅＴｅｘｔ（）的方法让文字显示于　Ｔｏａｓｔ　对象中，　这段文字会在显示一段时间后自动消失，读者可借此体验一下　Ｔｏａｓｔ　对象的使用与显示。　　　　运行结果

　　　　▲图　４－３　在　ＥｄｉｔＴｅｘｔ　字段中填写文字，点击按钮送出后，会发出　Ｔｏａｓｔ　信息　　　　范例程序

　　　　ｓｒｃ／ｉｒｄｃ．ｅｘ０４＿０３／ＥＸ０４＿０３．ｊａｖａ

　　　　主程序需要构建两个控件　ＥｄｉｔＴｅｘｔ　与　Ｂｕｔｔｏｎ，在　Ｂｕｔｔｏｎ　的　ｏｎＣｌｉｃｋ（）　方法中使用　Ｔｏａｓｔ　对象的　ｍａｋｅＴｅｘｔ（）　方法来显示输入的文字。

　　　　ｐａｃｋａｇｅ　ｉｒｄｃ．ＥＸ０４＿０３；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ａｐｐ．Ａｃｔｉｖｉｔｙ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｏｓ．Ｂｕｎｄｌｅ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｔｅｘｔ．Ｅｄｉｔａｂｌｅ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｖｉｅｗ．Ｖｉｅｗ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｖｉｅｗ．Ｖｉｅｗ．ＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．Ｂｕｔｔｏｎ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＥｄｉｔＴｅｘｔ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．Ｔｏａｓｔ；　ｐｕｂｌｉｃ　ｃｌａｓｓ　ＥＸ０４＿０３　ｅｘｔｅｎｄｓ　Ａｃｔｉｖｉｔｙ

　　　　｛　／＊＊　Ｃａｌｌｅｄ　ｗｈｅｎ　ｔｈｅ　ａｃｔｉｖｉｔｙ　ｉｓ　ｆｉｒｓｔ　ｃｒｅａｔｅｄ．　＊／　／＊声明两个对象变量（按钮与编辑文字）＊／　ｐｒｉｖａｔｅ　Ｂｕｔｔｏｎ　ｍＢｕｔｔｏｎ；　ｐｒｉｖａｔｅ　ＥｄｉｔＴｅｘｔ　ｍＥｄｉｔＴｅｘｔ；　　　　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｒｅａｔｅ（Ｂｕｎｄｌｅ　ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）　｛　ｓｕｐｅｒ．ｏｎＣｒｅａｔｅ（ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）；　ｓｅｔＣｏｎｔｅｎｔＶｉｅｗ（Ｒ．ｌａｙｏｕｔ．ｍａｉｎ）；

　　　　／＊通过　ｆｉｎｄＶｉｅｗＢｙＩｄ（）取得对象　＊／　ｍＢｕｔｔｏｎ＝（Ｂｕｔｔｏｎ）ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＢｕｔｔｏｎ）；　ｍＥｄｉｔＴｅｘｔ＝（ＥｄｉｔＴｅｘｔ）ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＥｄｉｔＴｅｘｔ）；

　　　　／＊设置　ｏｎＣｌｉｃｋＬｉｓｔｅｎｅｒ　给　Ｂｕｔｔｏｎ　对象聆听　ｏｎＣｌｉｃｋ　事件＊／　ｍＢｕｔｔｏｎ．ｓｅｔＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（ｎｅｗ　ＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（）　｛　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｌｉｃｋ（Ｖｉｅｗ　ｖ）　｛　／／　ＴＯＤＯ　Ａｕｔｏ－ｇｅｎｅｒａｔｅｄ　ｍｅｔｈｏｄ　ｓｔｕｂ

　　　　／＊声明字符串变量并取得用户输入的　ＥｄｉｔＴｅｘｔ　字符串＊／　Ｅｄｉｔａｂｌｅ　Ｓｔｒ；　Ｓｔｒ＝ｍＥｄｉｔＴｅｘｔ．ｇｅｔＴｅｘｔ（）；

　　　　／＊使用系统标准的　ｍａｋｅＴｅｘｔ（）方式来产生　Ｔｏａｓｔ　信息＊／　Ｔｏａｓｔ．ｍａｋｅＴｅｘｔ（　ＥＸ０４＿０３．ｔｈｉｓ，　＂你的愿望　＂＋Ｓｔｒ．ｔｏＳｔｒｉｎｇ（）＋＂已送达耶诞老人信箱＂，　　　　Ｔｏａｓｔ．ＬＥＮＧＴＨ＿ＬＯＮＧ）．ｓｈｏｗ（）；

　　　　／＊清空　ＥｄｉｔＴｅｘｔ＊／　ｍＥｄｉｔＴｅｘｔ．ｓｅｔＴｅｘｔ（＂＂）；　｝　｝）；　｝　｝　　　　扩展学习

　　　　Ｔｏａｓｔ　显示后会在一定时间内消失，在　Ｔｏａｓｔ　构造参数中的第二个参数为显示的时间常　数，可设置为　ＬＥＮＧＴＨ＿ＬＯＮＧ　或　ＬＥＮＧＴＨ＿ＳＨＯＲＴ，前者提示时间较长，后者较短，作为　传递　ｍａｋｅＴｅｘｔ（）　方法的参数使用。　当然，你也可以使用重写　Ｔｏａｓｔ　对象的方法，自定义　Ｔｏａｓｔ　显示的　Ｌａｙｏｕｔ，以不同于系　统内置的方式显示客制化的　Ｔｏａｓｔ　对象，如要在　Ｔｏａｓｔ　里显示图片（Ｄｒａｗａｂｌｅ）　，方式如下：

　　　　Ｔｏａｓｔ　ｍＴｏａｓｔ０１　＝　ｎｅｗ　Ｔｏａｓｔ（ｔｈｉｓ）；　ＩｍａｇｅＶｉｅｗ　ｍＶｉｅｗ０１　＝　ｎｅｗ　ＩｍａｇｅＶｉｅｗ（ｔｈｉｓ）；

　　　　ｍＶｉｅｗ０１．ｓｅｔＩｍａｇｅＲｅｓｏｕｒｃｅ（Ｒ．ｄｒａｗａｂｌｅ．ｉｃｏｎ）；　ｍＴｏａｓｔ０１．ｓｅｔＶｉｅｗ（ｍＶｉｅｗ０１）；　ｍＴｏａｓｔ０１．ｓｈｏｗ（）；

ｐａｇｅ　２１

　　　　或显示自定义的　Ｌａｙｏｕｔ　Ｗｉｄｇｅｔ（如　ＴｅｘｔＶｉｅｗ）　，则写法如下：

　　　　Ｔｏａｓｔ　ｍＴｏａｓｔ０１　＝　ｎｅｗ　Ｔｏａｓｔ（ｔｈｉｓ）；　ＴｅｘｔＶｉｅｗ　ｍＶｉｅｗ０１＝ｎｅｗ　ＴｅｘｔＶｉｅｗ（ｔｈｉｓ）；　ｍＶｉｅｗ０１．ｓｅｔＴｅｘｔ（＂ＴｏａｓｔＷｏｒｄｓ＂）；　ｍＴｏａｓｔ０１．ｓｅｔＶｉｅｗ（ｍＶｉｅｗ０１）；　ｍＴｏａｓｔ０１．ｓｈｏｗ（）；

　　　　或者通过　ＡｌｅｒｔＤｉａｌｏｇ．Ｂｕｉｌｄｅｒ　来创建类似　Ｔｏａｓｔ　的信息对象，读者可以实现看看，比较　两者有何不同：

　　　　ＡｌｅｒｔＤｉａｌｏｇ　ｍＡＤｉａｌｏｇ０１　＝ｎｅｗ　ＡｌｅｒｔＤｉａｌｏｇ．Ｂｕｉｌｄｅｒ（ｔｈｉｓ）　ｍＡＤｉａｌｏｇ０１．ｓｅｔＴｉｔｌｅ（＂Ａｎｄｒｏｉｄ　提示＂）；　ｍＡＤｉａｌｏｇ０１．ｓｅｔＭｅｓｓａｇｅ（＂ｔｈｉｓ　ｉｓ　ａ　ｍｅｓｓａｇｅ＂）；　ｍＡＤｉａｌｏｇ０１．ｓｈｏｗ（）；　　　　范例说明

　　　　所有的网络服务在　Ｕｓｅｒ　使用之前，都需要签署同意条款，在手机应用程序、手机游戏　的　设　计　经　验　中　，　常　看　见　ＣｈｅｃｋＢｏｘ　在　同　意　条　款　情　境　的　使　用　，　其　选　取　的　状　态　有　两　种　ｉｓＣｈｅｃｋｅｄ＝ｔｒｕｅ　与　ｉｓＣｈｅｃｋｅｄ＝ｆａｌｓｅ。　以下范例将设计一个　ＴｅｘｔＶｉｅｗ　放入条款文字，在下方配置一个　ＣｈｅｃｋＢｏｘ　Ｗｉｄｇｅｔ　作为　选取项，通过　Ｂｕｔｔｏｎ．ｏｎＣｌｉｃｋＬｉｓｔｅｎｅｒ　按钮事件处理，取得　Ｕｓｅｒ　同意条款的状态。　当　ＣｈｅｃｋＢｏｘ．ｉｓＣｈｅｃｋｅｄ　为　ｔｒｕｅ，更改　ＴｅｘｔＶｉｅｗ　的文字内容为“你已接受同意！！”，当未　选取　ＣｈｅｃｋＢｏｘ　时，Ｂｕｔｔｏｎ　是不可以选择的（被　Ｄｉｓａｂｌｅｄ）　。　　　　运行结果

　　　　▲图　４－４　未勾选“我同意”时，“确定”按钮是不可以按的　　　　范例程序

　　　　ｓｒｃ／ｉｒｄｃ．ｅｘ０４＿０４／ＥＸ０４＿０４．ｊａｖａ

　　　　利用　ＣｈｅｃｋＢｏｘ．ＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ　里的事件来判断　Ｂｕｔｔｏｎ　该不该显示，其方法就是判　断　Ｂｕｔｔｏｎ．Ｅｎａｂｌｅｄ　的值；在一开始时，默认参数为　ｆａｌｓｅ，当有点击　ＣｈｅｃｋＢｏｘ　时，Ｂｕｔｔｏｎ　参数　就修改为　ｔｒｕｅ。

　　　　ｐａｃｋａｇｅ　ｉｒｄｃ．ｅｘ０４＿０４；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ａｐｐ．Ａｃｔｉｖｉｔｙ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｏｓ．Ｂｕｎｄｌｅ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｖｉｅｗ．Ｖｉｅｗ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．Ｂｕｔｔｏｎ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＣｈｅｃｋＢｏｘ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＴｅｘｔＶｉｅｗ；　ｐｕｂｌｉｃ　ｃｌａｓｓ　ＥＸ０４＿０４　ｅｘｔｅｎｄｓ　Ａｃｔｉｖｉｔｙ

　　　　｛　／＊＊　Ｃａｌｌｅｄ　ｗｈｅｎ　ｔｈｅ　ａｃｔｉｖｉｔｙ　ｉｓ　ｆｉｒｓｔ　ｃｒｅａｔｅｄ．　＊／

　　　　／＊声明　ＴｅｘｔＶｉｅｗ、ＣｈｅｃｋＢｏｘ、Ｂｕｔｔｏｎ　对象＊／　ｐｕｂｌｉｃ　ＴｅｘｔＶｉｅｗ　ｍｙＴｅｘｔＶｉｅｗ１；　ｐｕｂｌｉｃ　ＴｅｘｔＶｉｅｗ　ｍｙＴｅｘｔＶｉｅｗ２；　ｐｕｂｌｉｃ　ＣｈｅｃｋＢｏｘ　ｍｙＣｈｅｃｋＢｏｘ；　ｐｕｂｌｉｃ　Ｂｕｔｔｏｎ　ｍｙＢｕｔｔｏｎ；

　　　　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｒｅａｔｅ（Ｂｕｎｄｌｅ　ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）　｛　ｓｕｐｅｒ．ｏｎＣｒｅａｔｅ（ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）；　ｓｅｔＣｏｎｔｅｎｔＶｉｅｗ（Ｒ．ｌａｙｏｕｔ．ｍａｉｎ）；

　　　　／＊取得　ＴｅｘｔＶｉｅｗ、ＣｈｅｃｋＢｏｘ、Ｂｕｔｔｏｎ＊／　ｍｙＴｅｘｔＶｉｅｗ１　＝　（ＴｅｘｔＶｉｅｗ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＴｅｘｔＶｉｅｗ１）；　ｍｙＴｅｘｔＶｉｅｗ２　＝　（ＴｅｘｔＶｉｅｗ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＴｅｘｔＶｉｅｗ２）；　ｍｙＣｈｅｃｋＢｏｘ　＝　（ＣｈｅｃｋＢｏｘ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＣｈｅｃｋＢｏｘ）；　ｍｙＢｕｔｔｏｎ　＝　（Ｂｕｔｔｏｎ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＢｕｔｔｏｎ）；

　　　　／＊将　ＣｈｅｃｋＢｏｘ、Ｂｕｔｔｏｎ　默认为未选择状态＊／　ｍｙＣｈｅｃｋＢｏｘ．ｓｅｔＣｈｅｃｋｅｄ（ｆａｌｓｅ）；　ｍｙＢｕｔｔｏｎ．ｓｅｔＥｎａｂｌｅｄ（ｆａｌｓｅ）；

　　　　ｍｙＣｈｅｃｋＢｏｘ．ｓｅｔＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（ｎｅｗ　ＣｈｅｃｋＢｏｘ．ＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（）　｛　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｌｉｃｋ（Ｖｉｅｗ　ｖ）　｛　／／　ＴＯＤＯ　Ａｕｔｏ－ｇｅｎｅｒａｔｅｄ　ｍｅｔｈｏｄ　ｓｔｕｂ　ｉｆ（ｍｙＣｈｅｃｋＢｏｘ．ｉｓＣｈｅｃｋｅｄ（））　｛　／＊设置　Ｂｕｔｔｏｎ　为不能选择对象＊／　ｍｙＢｕｔｔｏｎ．ｓｅｔＥｎａｂｌｅｄ（ｔｒｕｅ）；　ｍｙＴｅｘｔＶｉｅｗ２．ｓｅｔＴｅｘｔ（＂＂）；　｝　ｅｌｓｅ　｛　／＊设置　Ｂｕｔｔｏｎ　为可以选择对象＊／　ｍｙＢｕｔｔｏｎ．ｓｅｔＥｎａｂｌｅｄ（ｆａｌｓｅ）；　ｍｙＴｅｘｔＶｉｅｗ１．ｓｅｔＴｅｘｔ（Ｒ．ｓｔｒｉｎｇ．ｔｅｘｔ１）；　／＊在　ＴｅｘｔＶｉｅｗ２　里显示出＂请勾选我同意＂＊／　ｍｙＴｅｘｔＶｉｅｗ２．ｓｅｔＴｅｘｔ（Ｒ．ｓｔｒｉｎｇ．ｎｏ）；　｝　｝　｝）；　　　　ｍｙＢｕｔｔｏｎ．ｓｅｔＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（ｎｅｗ　Ｂｕｔｔｏｎ．ＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（）　｛　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｌｉｃｋ（Ｖｉｅｗ　ｖ）　｛　／／　ＴＯＤＯ　Ａｕｔｏ－ｇｅｎｅｒａｔｅｄ　ｍｅｔｈｏｄ　ｓｔｕｂ　ｉｆ（ｍｙＣｈｅｃｋＢｏｘ．ｉｓＣｈｅｃｋｅｄ（））　｛　ｍｙＴｅｘｔＶｉｅｗ１．ｓｅｔＴｅｘｔ（Ｒ．ｓｔｒｉｎｇ．ｏｋ）；　｝ｅｌｓｅ　｛　｝　｝　｝）；　　　　｝　｝

　　　　扩展学习

　　　　ＣｈｅｃｋＢｏｘ　在默认内容为空白时（没有任何默认的提示文字下）　，可设置提示　

ｐａｇｅ　２２

Ｕｓｅｒ　的文　字，　其调用的方法为　ＣｈｅｃｋＢｏｘ．ｓｅｔＨｉｎｔ（）　方法；　在扩展学习的范例练习，　是抓取　Ｒ．ｓｔｒｉｎｇ．ｈｅｌｌｏ　这个字符串常数，其与默认　ＣｈｅｃｋＢｏｘ　文字的结果是相同的，试试看：

　　　　ｍｙＴｅｘｔＶｉｅｗ１　＝　（ＴｅｘｔＶｉｅｗ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＴｅｘｔＶｉｅｗ１）；　ｍｙＴｅｘｔＶｉｅｗ２　＝　（ＴｅｘｔＶｉｅｗ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＴｅｘｔＶｉｅｗ２）；　ｍｙＣｈｅｃｋＢｏｘ　＝　（ＣｈｅｃｋＢｏｘ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＣｈｅｃｋＢｏｘ）；

　　　　ｍｙＢｕｔｔｏｎ　＝　（Ｂｕｔｔｏｎ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＢｕｔｔｏｎ）；　ｍｙＣｈｅｃｋＢｏｘ．ｓｅｔＣｈｅｃｋｅｄ（ｆａｌｓｅ）；　／＊利用　ｓｅｔＨＩＴ　抓取　ｓｔｒｉｎｇｓ　里面的值＊／　ＣｈａｒＳｅｑｕｅｎｃｅ　ｈｉｎｔ　＝　ｇｅｔＳｔｒｉｎｇ（Ｒ．ｓｔｒｉｎｇ．ｈｅｌｌｏ）；　ｍｙＣｈｅｃｋＢｏｘ．ｓｅｔＨｉｎｔ（ｈｉｎｔ）；　／＊设置文字颜色＊／　ｍｙＣｈｅｃｋＢｏｘ．ｓｅｔＨｉｎｔＴｅｘｔＣｏｌｏｒ（Ｃｏｌｏｒ．ＲＥＤ）；　　　　范例说明

　　　　你使用消费券了吗？消费券只有　３６００　元，但是想要　买的东西却是无穷多（∞）　。这个　范例程序要示范的是　ＣｈｅｃｋＢｏｘ．ｓｅｔＯｎＣｈｅｃｋｅｄＣｈａｎｇｅＬｉｓｔｅｎｅｒ，在程序中设计三个　ＣｈｅｃｋＢｏｘ　核取项，分别表示三种物品列表，当　Ｕｓｅｒ　勾选其中一个物品，就在　ＴｅｘｔＶｉｅｗ　里显示已选择　的物品列表。　程　序　的　关　键　在　同　时　聆　听　三　个　ＣｈｅｃｋＢｏｘ．ＯｎＣｈｅｃｋｅｄＣｈａｎｇｅＬｉｓｔｅｎｅｒ　的　状　态　，　并　在　ＣｈｅｃｋＢｏｘ．ｏｎＣｈｅｃｋｅｄ（）　方法中，重组所有被勾选的物品文字。　　　　运行结果

　　　　▲图　４－５　勾选不同的　ＣｈｅｃｋＢｏｘ，　ＣｈｅｃｋＢｏｘ　的文字会在　ＴｅｘｔＶｉｅｗ　中显示出来　该

　　　　范例程序

　　　　ｓｒｃ／ｉｒｄｃ．ｅｘ０４＿０５／ＥＸ０４＿０５．ｊａｖａ

　　　　主　程　序　的　重　点　在　于　构　造　三　个　ＣｈｅｃｋＢｏｘ　的　对　象　，　以　及　一　个　ＴｅｘｔＶｉｅｗ　对　象　，　并　通　过　ｓｅｔＯｎＣｈｅｃｋｅｄＣｈａｎｇｅＬｉｓｔｅｎｅｒ　实现　ｏｎＣｈｅｃｋｅｄＣｈａｎｇｅｄ（）　方法来更新　ＴｅｘｔＶｉｅｗ　文字。

　　　　ｐａｃｋａｇｅ　ｉｒｄｃ．ＥＸ０４＿０５；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ａｐｐ．Ａｃｔｉｖｉｔｙ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｏｓ．Ｂｕｎｄｌｅ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＣｈｅｃｋＢｏｘ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＣｏｍｐｏｕｎｄＢｕｔｔｏｎ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＴｅｘｔＶｉｅｗ；　ｐｕｂｌｉｃ　ｃｌａｓｓ　ＥＸ０４＿０５　ｅｘｔｅｎｄｓ　Ａｃｔｉｖｉｔｙ　｛　／＊声明对象变量＊／　ｐｒｉｖａｔｅ　ＴｅｘｔＶｉｅｗ　ｍＴｅｘｔＶｉｅｗ１；　ｐｒｉｖａｔｅ　ＣｈｅｃｋＢｏｘ　ｍＣｈｅｃｋＢｏｘ１；　ｐｒｉｖａｔｅ　ＣｈｅｃｋＢｏｘ　ｍＣｈｅｃｋＢｏｘ２；　ｐｒｉｖａｔｅ　ＣｈｅｃｋＢｏｘ　ｍＣｈｅｃｋＢｏｘ３；

　　　　／＊＊　Ｃａｌｌｅｄ　ｗｈｅｎ　ｔｈｅ　ａｃｔｉｖｉｔｙ　ｉｓ　ｆｉｒｓｔ　ｃｒｅａｔｅｄ．　＊／　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｒｅａｔｅ（Ｂｕｎｄｌｅ　ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）　｛　ｓｕｐｅｒ．ｏｎＣｒｅａｔｅ（ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）；

　　　　ｓｅｔＣｏｎｔｅｎｔＶｉｅｗ（Ｒ．ｌａｙｏｕｔ．ｍａｉｎ）；

　　　　／＊通过　ｆｉｎｄＶｉｅｗＢｙＩｄ　取得　ＴｅｘｔＶｉｅｗ　对象并调整文字内容＊／　ｍＴｅｘｔＶｉｅｗ１　＝　（ＴｅｘｔＶｉｅｗ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＴｅｘｔＶｉｅｗ１）；　ｍＴｅｘｔＶｉｅｗ１．ｓｅｔＴｅｘｔ（＂你所选择的项目有：　＂）；

　　　　／＊通过　ｆｉｎｄＶｉｅｗＢｙＩｄ　取得三个　ＣｈｅｃｋＢｏｘ　对象＊／　ｍＣｈｅｃｋＢｏｘ１＝（ＣｈｅｃｋＢｏｘ）ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＣｈｅｃｋＢｏｘ１）；　ｍＣｈｅｃｋＢｏｘ２＝（ＣｈｅｃｋＢｏｘ）ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＣｈｅｃｋＢｏｘ２）；　ｍＣｈｅｃｋＢｏｘ３＝（ＣｈｅｃｋＢｏｘ）ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＣｈｅｃｋＢｏｘ３）；

　　　　／＊设置　ＯｎＣｈｅｃｋｅｄＣｈａｎｇｅＬｉｓｔｅｎｅｒ　给三个　ＣｈｅｃｋＢｏｘ　对象＊／　ｍＣｈｅｃｋＢｏｘ１．ｓｅｔＯｎＣｈｅｃｋｅｄＣｈａｎｇｅＬｉｓｔｅｎｅｒ（ｍＣｈｅｃｋＢｏｘＣｈａｎｇｅｄ）；　ｍＣｈｅｃｋＢｏｘ２．ｓｅｔＯｎＣｈｅｃｋｅｄＣｈａｎｇｅＬｉｓｔｅｎｅｒ（ｍＣｈｅｃｋＢｏｘＣｈａｎｇｅｄ）；　ｍＣｈｅｃｋＢｏｘ３．ｓｅｔＯｎＣｈｅｃｋｅｄＣｈａｎｇｅＬｉｓｔｅｎｅｒ（ｍＣｈｅｃｋＢｏｘＣｈａｎｇｅｄ）；　｝

　　　　／＊声明并构造　ｏｎＣｈｅｃｋｅｄＣｈａｎｇｅＬｉｓｔｅｎｅｒ　对象＊／　ｐｒｉｖａｔｅ　ＣｈｅｃｋＢｏｘ．ＯｎＣｈｅｃｋｅｄＣｈａｎｇｅＬｉｓｔｅｎｅｒ　ｍＣｈｅｃｋＢｏｘＣｈａｎｇｅｄ　＝　ｎｅｗ　ＣｈｅｃｋＢｏｘ．ＯｎＣｈｅｃｋｅｄＣｈａｎｇｅＬｉｓｔｅｎｅｒ（）　｛　／＊ｉｍｐｌｅｍｅｎｔ　ｏｎＣｈｅｃｋｅｄＣｈａｎｇｅｄ　方法＊／　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｈｅｃｋｅｄＣｈａｎｇｅｄ（ＣｏｍｐｏｕｎｄＢｕｔｔｏｎ　ｂｕｔｔｏｎＶｉｅｗ，

　　　　ｂｏｏｌｅａｎ　ｉｓＣｈｅｃｋｅｄ）　｛　／／　ＴＯＤＯ　Ａｕｔｏ－ｇｅｎｅｒａｔｅｄ　ｍｅｔｈｏｄ　ｓｔｕｂ　／＊通过　ｇｅｔＳｔｒｉｎｇ（）取得　ＣｈｅｃｋＢｏｘ　的文字字符串＊／　Ｓｔｒｉｎｇ　ｓｔｒ０＝＂所选的项目为：　＂；　Ｓｔｒｉｎｇ　ｓｔｒ１＝ｇｅｔＳｔｒｉｎｇ（Ｒ．ｓｔｒｉｎｇ．ｓｔｒ＿ｃｈｅｃｋｂｏｘ１）；　Ｓｔｒｉｎｇ　ｓｔｒ２＝ｇｅｔＳｔｒｉｎｇ（Ｒ．ｓｔｒｉｎｇ．ｓｔｒ＿ｃｈｅｃｋｂｏｘ２）；　Ｓｔｒｉｎｇ　ｓｔｒ３＝ｇｅｔＳｔｒｉｎｇ（Ｒ．ｓｔｒｉｎｇ．ｓｔｒ＿ｃｈｅｃｋｂｏｘ３）；　Ｓｔｒｉｎｇ　ｐｌｕｓ＝＂；＂；　

ｐａｇｅ　２３

Ｓｔｒｉｎｇ　ｒｅｓｕｌｔ＝＂但是超过预算啰！！＂；　Ｓｔｒｉｎｇ　ｒｅｓｕｌｔ２＝＂还可以再多买几本喔！！＂；　　　　／＊任一　ＣｈｅｃｋＢｏｘ　被勾选后，该　ＣｈｅｃｋＢｏｘ　的文字会改变　ＴｅｘｔＶｉｅｗ　的文字内　容　＊　三个对象总共八种情境＊／　ｉｆ（ｍＣｈｅｃｋＢｏｘ１．ｉｓＣｈｅｃｋｅｄ（）＝＝ｔｒｕｅ　＆　ｍＣｈｅｃｋＢｏｘ２．ｉｓＣｈｅｃｋｅｄ（）＝＝ｔｒｕｅ　＆　ｍＣｈｅｃｋＢｏｘ３．ｉｓＣｈｅｃｋｅｄ（）＝＝ｔｒｕｅ）　｛　ｍＴｅｘｔＶｉｅｗ１．ｓｅｔＴｅｘｔ（ｓｔｒ０＋ｓｔｒ１＋ｐｌｕｓ＋ｓｔｒ２＋ｐｌｕｓ＋ｓｔｒ３＋ｒｅｓｕｌｔ）；　｝　ｅｌｓｅ　ｉｆ（ｍＣｈｅｃｋＢｏｘ１．ｉｓＣｈｅｃｋｅｄ（）＝＝ｆａｌｓｅ　＆　ｍＣｈｅｃｋＢｏｘ２．ｉｓＣｈｅｃｋｅｄ（）＝＝ｔｒｕｅ　＆　ｍＣｈｅｃｋＢｏｘ３．ｉｓＣｈｅｃｋｅｄ（）＝＝ｔｒｕｅ）　｛

　　　　ｍＴｅｘｔＶｉｅｗ１．ｓｅｔＴｅｘｔ（ｓｔｒ０＋ｓｔｒ２＋ｐｌｕｓ＋ｓｔｒ３＋ｒｅｓｕｌｔ）；　｝　ｅｌｓｅ　ｉｆ（ｍＣｈｅｃｋＢｏｘ１．ｉｓＣｈｅｃｋｅｄ（）＝＝ｔｒｕｅ　＆　ｍＣｈｅｃｋＢｏｘ２．ｉｓＣｈｅｃｋｅｄ（）＝＝ｆａｌｓｅ　＆　ｍＣｈｅｃｋＢｏｘ３．ｉｓＣｈｅｃｋｅｄ（）＝＝ｔｒｕｅ）　｛　ｍＴｅｘｔＶｉｅｗ１．ｓｅｔＴｅｘｔ（ｓｔｒ０＋ｓｔｒ１＋ｐｌｕｓ＋ｓｔｒ３＋ｒｅｓｕｌｔ）；　｝　ｅｌｓｅ　ｉｆ（ｍＣｈｅｃｋＢｏｘ１．ｉｓＣｈｅｃｋｅｄ（）＝＝ｔｒｕｅ　＆　ｍＣｈｅｃｋＢｏｘ２．ｉｓＣｈｅｃｋｅｄ（）＝＝ｔｒｕｅ　＆　ｍＣｈｅｃｋＢｏｘ３．ｉｓＣｈｅｃｋｅｄ（）＝＝ｆａｌｓｅ）　｛　ｍＴｅｘｔＶｉｅｗ１．ｓｅｔＴｅｘｔ（ｓｔｒ０＋ｓｔｒ１＋ｐｌｕｓ＋ｓｔｒ２＋ｒｅｓｕｌｔ）；　｝　ｅｌｓｅ　ｉｆ（ｍＣｈｅｃｋＢｏｘ１．ｉｓＣｈｅｃｋｅｄ（）＝＝ｆａｌｓｅ　＆　ｍＣｈｅｃｋＢｏｘ２．ｉｓＣｈｅｃｋｅｄ（）＝＝ｆａｌｓｅ　＆　ｍＣｈｅｃｋＢｏｘ３．ｉｓＣｈｅｃｋｅｄ（）＝＝ｔｒｕｅ）　｛　ｍＴｅｘｔＶｉｅｗ１．ｓｅｔＴｅｘｔ（ｓｔｒ０＋ｓｔｒ３＋ｐｌｕｓ＋ｒｅｓｕｌｔ２）；　｝　ｅｌｓｅ　ｉｆ（ｍＣｈｅｃｋＢｏｘ１．ｉｓＣｈｅｃｋｅｄ（）＝＝ｆａｌｓｅ　＆　ｍＣｈｅｃｋＢｏｘ２．ｉｓＣｈｅｃｋｅｄ（）＝＝ｔｒｕｅ　＆　ｍＣｈｅｃｋＢｏｘ３．ｉｓＣｈｅｃｋｅｄ（）＝＝ｆａｌｓｅ）　｛　ｍＴｅｘｔＶｉｅｗ１．ｓｅｔＴｅｘｔ（ｓｔｒ０＋ｓｔｒ２）；

　　　　｝　ｅｌｓｅ　ｉｆ（ｍＣｈｅｃｋＢｏｘ１．ｉｓＣｈｅｃｋｅｄ（）＝＝ｔｒｕｅ　＆　ｍＣｈｅｃｋＢｏｘ２．ｉｓＣｈｅｃｋｅｄ（）＝＝ｆａｌｓｅ　＆　ｍＣｈｅｃｋＢｏｘ３．ｉｓＣｈｅｃｋｅｄ（）＝＝ｆａｌｓｅ）　｛　ｍＴｅｘｔＶｉｅｗ１．ｓｅｔＴｅｘｔ（ｓｔｒ０＋ｓｔｒ１）；　｝　ｅｌｓｅ　ｉｆ（ｍＣｈｅｃｋＢｏｘ１．ｉｓＣｈｅｃｋｅｄ（）＝＝ｆａｌｓｅ　＆　ｍＣｈｅｃｋＢｏｘ２．ｉｓＣｈｅｃｋｅｄ（）＝＝ｆａｌｓｅ　＆　ｍＣｈｅｃｋＢｏｘ３．ｉｓＣｈｅｃｋｅｄ（）＝＝ｆａｌｓｅ）　｛　ｍＴｅｘｔＶｉｅｗ１．ｓｅｔＴｅｘｔ（ｓｔｒ０）；　｝　｝　｝；　｝　　　　扩展学习

　　　　读者可以将　ＯｎＣｈｅｃｋｅｄＣｈａｎｇｅＬｉｓｔｅｎｅｒ　改为　ＯｎＴｏｕｃｈＬｉｓｔｅｎｅｒ（屏幕触控事件）　，方法如　下：

　　　　ｐｒｉｖａｔｅ　ＣｈｅｃｋＢｏｘ．ＯｎＴｏｕｃｈＬｉｓｔｅｎｅｒ　ｍＣｈｅｃｋＢｏｘＴｏｕｃｈ　＝　ｎｅｗ　ＣｈｅｃｋＢｏｘ．ＯｎＴｏｕｃｈＬｉｓｔｅｎｅｒ（）　｛　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｂｏｏｌｅａｎ　ｏｎＴｏｕｃｈ（Ｖｉｅｗ　ｖ，　ＭｏｔｉｏｎＥｖｅｎｔ　ｅｖｅｎｔ）　　　　｛　／／　ＴＯＤＯ　Ａｕｔｏ－ｇｅｎｅｒａｔｅｄ　ｍｅｔｈｏｄ　ｓｔｕｂ　／＊　判断在触控笔指压此控件时的状态　＊／　ｉｆ（ｍＣｈｅｃｋＢｏｘ１．ｉｓＣｈｅｃｋｅｄ（）＝＝ｆａｌｓｅ）　｛　／＊当触控笔放开后的动作＊／　｝　ｅｌｓｅ　ｉｆ（ｍＣｈｅｃｋＢｏｘ１．ｉｓＣｈｅｃｋｅｄ（）＝＝ｔｒｕｅ）　｛　／＊当触控笔压下后的动作＊／　｝　ｒｅｔｕｒｎ　ｆａｌｓｅ；　｝　｝；

　　　　请试着比较　ＯｎＣｈｅｃｋｅｄＣｈａｎｇｅＬｉｓｔｅｎｅｒ　与　ＯｎＴｏｕｃｈＬｉｓｔｅｎｅｒ　在使用上的差异。　　　　范例说明

　　　　接下来要介绍的是　ＲａｄｉｏＧｒｏｕｐ　的组事件。　ＲａｄｉｏＧｒｏｕｐ　可将各自不同的　ＲａｄｉｏＢｕｔｔｏｎ　设　限于同一个　Ｒａｄｉｏ　按钮组，　同属一个　ＲａｄｉｏＧｒｏｕｐ　组里的按钮，　只能做出单一选择（单选题）　，　虽然前一章曾经介绍过　ＲａｄｉｏＧｒｏｕｐ　与　ＲａｄｉｏＢｕｔｔｏｎ，　但当时使用的是　Ｂｕｔｔｏｎ　事件，　在此要示　范“点击”的同时就运行事件　处理，不再需要按钮（Ｂｕｔｔｏｎ）的辅助了。　先设计一个　ＴｅｘｔＶｉｅｗ　Ｗｉｄｇｅｔ，以及一个　ＲａｄｉｏＧｒｏｕｐ，并于该　ＲａｄｉｏＧｒｏｕｐ　内放置两个　ＲａｄｉｏＢｕｔｔｏｎ，默认为都不选择，在程序运行阶段，利用　ｏｎＣｈｅｃｋｅｄＣｈａｎｇｅｄ　作为启动事件装　置，让　Ｕｓｅｒ　选择其中一个按钮时，显示被选择的内容，最后将　ＲａｄｉｏＢｕｔｔｏｎ　的选项文字显示　于　ＴｅｘｔＶｉｅｗ　当中。　　　　运行结果

　　　　▲图　４－６　点击帅哥或美女按钮的同时，会立即显示事件结果　　　　范例程序

　　　　ｓｒｃ／ｉｒｄｃ．ｅｘ０４＿０６／ＥＸ０４＿０６．ｊａｖａ

　　　　利用　ＯｎＣｈｅｃｋｅｄＣｈａｎｇｅＬｉｓｔｅｎｅｒ　来启动　ＲａｄｉｏＧｒｏｕｐ　的事件，　随后将被勾选的　ＲａｄｉｏＢｕｔｔｏｎ　（ｍＲａｄｉｏ１．ｇｅｔＴｅｘｔ（））的文字显示于　ＴｅｘｔＶｉｅｗ。

　　　　ｐａｃｋａｇｅ　ｉｒｄｃ．ｅｘ０４＿０６；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ａｐｐ．Ａｃｔｉｖｉｔｙ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｏｓ．Ｂｕｎｄｌｅ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＲａｄｉｏＢｕｔｔｏｎ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＲａｄｉｏＧｒｏｕｐ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＴｅｘｔＶｉｅｗ；　ｐｕｂｌｉｃ　ｃｌａｓｓ　ＥＸ０４＿０６　ｅｘｔｅｎｄｓ　Ａｃｔｉｖｉｔｙ　　　　｛　ｐｕｂｌｉｃ　ＴｅｘｔＶｉｅｗ　ｍＴｅｘｔＶｉｅｗ１；　ｐｕｂｌｉｃ　ＲａｄｉｏＧｒｏｕｐ　ｍＲａｄｉｏＧｒｏｕｐ１；　ｐｕｂｌｉｃ　ＲａｄｉｏＢｕｔｔｏｎ　ｍＲａｄｉｏ１，ｍＲａｄｉｏ２；

　　　　／＊＊　Ｃａｌｌｅｄ　ｗｈｅｎ　ｔｈｅ　ａｃｔｉｖｉｔｙ　ｉｓ　ｆｉｒｓｔ　ｃｒｅａｔｅｄ．　＊／　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｒｅａｔｅ（Ｂｕｎｄｌｅ　ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）　｛　ｓｕｐｅｒ．ｏｎＣｒｅａｔｅ（ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ

ｐａｇｅ　２４

）；　ｓｅｔＣｏｎｔｅｎｔＶｉｅｗ（Ｒ．ｌａｙｏｕｔ．ｍａｉｎ）；

　　　　／＊取得　ＴｅｘｔＶｉｅｗ、ＲａｄｉｏＧｒｏｕｐ、ＲａｄｉｏＢｕｔｔｏｎ　对象＊／　ｍＴｅｘｔＶｉｅｗ１　＝　（ＴｅｘｔＶｉｅｗ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＴｅｘｔＶｉｅｗ）；　ｍＲａｄｉｏＧｒｏｕｐ１　＝　（ＲａｄｉｏＧｒｏｕｐ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＲａｄｉｏＧｒｏｕｐ）；　ｍＲａｄｉｏ１　＝　（ＲａｄｉｏＢｕｔｔｏｎ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＲａｄｉｏＢｕｔｔｏｎ１）；　ｍＲａｄｉｏ２　＝　（ＲａｄｉｏＢｕｔｔｏｎ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＲａｄｉｏＢｕｔｔｏｎ２）；

　　　　／＊ＲａｄｉｏＧｒｏｕｐ　用　ＯｎＣｈｅｃｋｅｄＣｈａｎｇｅＬｉｓｔｅｎｅｒ　来运行＊／　ｍＲａｄｉｏＧｒｏｕｐ１．ｓｅｔＯｎＣｈｅｃｋｅｄＣｈａｎｇｅＬｉｓｔｅｎｅｒ（ｍＣｈａｎｇｅＲａｄｉｏ）；　｝

　　　　ｐｒｉｖａｔｅ　ＲａｄｉｏＧｒｏｕｐ．ＯｎＣｈｅｃｋｅｄＣｈａｎｇｅＬｉｓｔｅｎｅｒ　ｍＣｈａｎｇｅＲａｄｉｏ　＝　ｎｅｗ　ＲａｄｉｏＧｒｏｕｐ．ＯｎＣｈｅｃｋｅｄＣｈａｎｇｅＬｉｓｔｅｎｅｒ（）

　　　　｛　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｈｅｃｋｅｄＣｈａｎｇｅｄ（ＲａｄｉｏＧｒｏｕｐ　ｇｒｏｕｐ，　ｉｎｔ　ｃｈｅｃｋｅｄＩｄ）　｛　／／　ＴＯＤＯ　Ａｕｔｏ－ｇｅｎｅｒａｔｅｄ　ｍｅｔｈｏｄ　ｓｔｕｂ　ｉｆ（ｃｈｅｃｋｅｄＩｄ＝＝ｍＲａｄｉｏ１．ｇｅｔＩｄ（））　｛　／＊把　ｍＲａｄｉｏ１　的内容传到　ｍＴｅｘｔＶｉｅｗ１＊／　ｍＴｅｘｔＶｉｅｗ１．ｓｅｔＴｅｘｔ（ｍＲａｄｉｏ１．ｇｅｔＴｅｘｔ（））；　｝　ｅｌｓｅ　ｉｆ（ｃｈｅｃｋｅｄＩｄ＝＝ｍＲａｄｉｏ２．ｇｅｔＩｄ（））　｛　／＊把　ｍＲａｄｉｏ２　的内容传到　ｍＴｅｘｔＶｉｅｗ１＊／　ｍＴｅｘｔＶｉｅｗ１．ｓｅｔＴｅｘｔ（ｍＲａｄｉｏ２．ｇｅｔＴｅｘｔ（））；　｝　｝　｝；　｝　　　　扩展学习

　　　　在扩展学习里，请加上两个　Ｂｕｔｔｏｎ　在其中，一个为回答，另一个为清除　ＲａｄｉｏＢｕｔｔｏｎ　的　选择状态。程序有随机设置的答案选项，当　Ｕｓｅｒ　点击回答按钮时，比较答案是否正确，若　正确，则以　ＡｌｅｒｔＤｉａｌｏｇ　对话窗口显示答案结果。　　　　ａｎｓｗｅｒＢｕｔｔｏｎ．ｓｅｔＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（ｎｅｗ　Ｂｕｔｔｏｎ．ＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（）　｛

　　　　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｌｉｃｋ（Ｖｉｅｗ　ｖ）　｛　ｎｅｗ　ＡｌｅｒｔＤｉａｌｏｇ．Ｂｕｉｌｄｅｒ（ＴＥＳＴ＿５６．ｔｈｉｓ）　．ｓｅｔＩｃｏｎ（Ｒ．ｄｒａｗａｂｌｅ．ｉｃｏｎ）　．ｓｅｔＴｉｔｌｅ（Ｒ．ｓｔｒｉｎｇ．ａｂｏｕｔ＿ｄｉａｌｏｇ＿ｔｉｔｌｅ）　．ｓｅｔＰｏｓｉｔｉｖｅＢｕｔｔｏｎ（Ｒ．ｓｔｒｉｎｇ．ａｂｏｕｔ＿ｄｉａｌｏｇ＿ｏｋ，　ｎｕｌｌ）　．ｓｅｔＭｅｓｓａｇｅ（Ｒ．ｓｔｒｉｎｇ．ａｂｏｕｔ＿ｄｉａｌｏｇ＿ｔｈａｎｋｓ）　．ｃｒｅａｔｅ（）；　｛　｝　｝）．ｓｈｏｗ（）；　｝

　　　　在清除　Ｂｕｔｔｏｎ．ｏｎＣｌｉｃｋＬｉｓｔｅｎｅｒ　的事件处理中，只需将被选择的　ＲａｄｉｏＢｕｔｔｏｎ　取消掉，回　到等待回答的状态。　　　　ｍＲａｄｉｏＧｒｏｕｐ１．ｃｌｅａｒＣｈｅｃｋ（）；　　　　范例说明

　　　　在设计此范例之前，必须先准备三张图片（两张外框　图、一张内框图）　，将这三张图片　放在　ｒｅｓ／ｄｒａｗａｂｌｅ　下面，在此使用的图片为　ＰＮＧ　图形文件，而图案大小最好是调整成手机　屏幕大小，或者依据手机　的分辨率，动态调整　ＩｍａｇｅＶｉｅｗ　的大小。稍后的范例将介绍如何　调整　ＩｍａｇｅＶｉｅｗ　的大小，这里就不赘述了。　准　备　好　之　后　，　开　始　做　这　个　酷　炫　的　专　业　相　框　应　用　程　序　，　在　Ｌａｙｏｕｔ　当　中　创　建　了　两　个　ＩｍａｇｅＶｉｅｗ，且以绝对坐标的方式“堆栈”在一起，在其下方放上两个按钮（Ｂｕｔｔｏｎ）　，按钮的　目的是为了要用来切换图片，创建完成后，要在　Ｂｕｔｔｏｎ　事件里处理置换图片的动作。　程序目的为点击　Ｂｕｔｔｏｎ１，ＩｍａｇｅＶｉｅｗ１　会出现　ｒｉｇｈｔ　的图片，点击　Ｂｕｔｔｏｎ２，ＩｍａｇｅＶｉｅｗ１　会出现　ｌｅｆｔ　的图片，而　ＩｍａｇｅＶｉｅｗ２　皆为固定不动（文件名叫　ｏａ）　，这个范例并不难，很快　就会知道葫芦里卖的是什么药了，先来看看范例运行结果。　　　　运行结果

　　　　▲图　４－７　点击按钮后，会更换　ＩｍａｇｅＶｉｅｗ（外框）图片　　　　范例程序

　　　　ｓｒｃ／ｉｒｄｃ．ｅｘ０４＿０７／ＥＸ０４＿０７．ｊａｖａ

　　　　此程序的关键地方在于　ｇｅｔＲｅｓｏｕｒｃｅｓ（）　这个方法，这个方法负责访问　Ｒｅｓｏｕｒｃｅ　ＩＤ，无论　是访问资源里的图文件、　文字都要用到　ｇｅｔＲｅｓｏｕｒｃｅｓ（）；　在此使用　ｇｅｔＲｅｓｏｕｒｃｅｓ（）．ｇｅｔＤｒａｗａｂｌｅ（）　来载入　ｒｅｓ／ｄｒａｗａｂｌｅ　里的图文件，并将图片放置在　ＩｍａｇｅＶｉｅｗ　当中。

　　　　ｐａｃｋａｇｅ　ｉｒｄｃ．ｅｘ０４＿０７；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ａｐｐ．Ａｃｔｉｖｉｔｙ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｏｓ．Ｂｕｎｄｌｅ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｖｉｅｗ．Ｖｉｅｗ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．Ｂｕｔｔｏｎ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＩｍａｇｅＶｉｅｗ；　ｐｕｂｌｉｃ　ｃｌａｓｓ　ＥＸ０４＿０７　ｅｘｔｅｎｄｓ　Ａｃｔｉｖｉｔｙ

　　　　｛　／＊声明　Ｂｕｔｔｏｎ、ＩｍａｇｅＶｉｅｗ　对象＊／　ｐｒｉｖａｔｅ　ＩｍａｇｅＶｉｅｗ　ｍＩｍａｇｅＶｉｅｗ０１；　ｐｒｉｖａｔｅ　ＩｍａｇｅＶｉｅｗ　ｍＩｍａｇｅＶｉｅｗ０２；　ｐｒｉｖａｔｅ　Ｂｕｔｔｏｎ　ｍＢｕｔｔｏｎ０１；　ｐｒｉｖａｔｅ　Ｂｕｔｔｏｎ　ｍＢｕｔｔｏｎ０２；

ｐａｇｅ　２５

　　　　／＊＊　Ｃａｌｌｅｄ　ｗｈｅｎ　ｔｈｅ　ａｃｔｉｖｉｔｙ　ｉｓ　ｆｉｒｓｔ　ｃｒｅａｔｅｄ．　＊／　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｒｅａｔｅ（Ｂｕｎｄｌｅ　ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）　｛　ｓｕｐｅｒ．ｏｎＣｒｅａｔｅ（ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）；　ｓｅｔＣｏｎｔｅｎｔＶｉｅｗ（Ｒ．ｌａｙｏｕｔ．ｍａｉｎ）；

　　　　／＊取得　Ｂｕｔｔｏｎ、ＩｍａｇｅＶｉｅｗ　对象＊／　ｍＩｍａｇｅＶｉｅｗ０１　＝　（ＩｍａｇｅＶｉｅｗ）ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＩｍａｇｅＶｉｅｗ１）；　ｍＩｍａｇｅＶｉｅｗ０２　＝　（ＩｍａｇｅＶｉｅｗ）ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＩｍａｇｅＶｉｅｗ２）；　ｍＢｕｔｔｏｎ０１　＝　（Ｂｕｔｔｏｎ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＢｕｔｔｏｎ１）；　ｍＢｕｔｔｏｎ０２　＝　（Ｂｕｔｔｏｎ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＢｕｔｔｏｎ２）；

　　　　／＊设置　ＩｍａｇｅＶｉｅｗ　背景图＊／　ｍＩｍａｇｅＶｉｅｗ０１．ｓｅｔＩｍａｇｅＤｒａｗａｂｌｅ（ｇｅｔＲｅｓｏｕｒｃｅｓ（）．　ｇｅｔＤｒａｗａｂｌｅ（Ｒ．ｄｒａｗａｂｌｅ．ｒｉｇｈｔ））；　ｍＩｍａｇｅＶｉｅｗ０２．ｓｅｔＩｍａｇｅＤｒａｗａｂｌｅ（ｇｅｔＲｅｓｏｕｒｃｅｓ（）．

　　　　ｇｅｔＤｒａｗａｂｌｅ（Ｒ．ｄｒａｗａｂｌｅ．ｏａ））；

　　　　／＊用　ＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ　事件来启动＊／　ｍＢｕｔｔｏｎ０１．ｓｅｔＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（ｎｅｗ　Ｂｕｔｔｏｎ．ＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（）　｛　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｌｉｃｋ（Ｖｉｅｗ　ｖ）　｛　／＊当启动后，ＩｍａｇｅＶｉｅｗ　立刻换背景图＊／　ｍＩｍａｇｅＶｉｅｗ０１．ｓｅｔＩｍａｇｅＤｒａｗａｂｌｅ（ｇｅｔＲｅｓｏｕｒｃｅｓ（）．　ｇｅｔＤｒａｗａｂｌｅ（Ｒ．ｄｒａｗａｂｌｅ．ｒｉｇｈｔ））；　｝　｝）；

　　　　ｍＢｕｔｔｏｎ０２．ｓｅｔＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（ｎｅｗ　Ｂｕｔｔｏｎ．ＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（）　｛　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｌｉｃｋ（Ｖｉｅｗ　ｖ）　｛　ｍＩｍａｇｅＶｉｅｗ０１．ｓｅｔＩｍａｇｅＤｒａｗａｂｌｅ（ｇｅｔＲｅｓｏｕｒｃｅｓ（）．　ｇｅｔＤｒａｗａｂｌｅ（Ｒ．ｄｒａｗａｂｌｅ．ｌｅｆｔ））；　｝　｝）；　　　　｝　｝

　　　　ｒｅｓ／ｌａｙｏｕｔ／ｍａｉｎ．ｘｍｌ

　　　　创建两个　ＩｍａｇｅＶｉｅｗ，一个为外框、另一个为内框，需注意的是，图片需要做一个排序　堆栈顺序，将前景图放在上方（以　ＡｂｓｏｌｕｔｅＬａｙｏｕｔ）　，将背景图放在前景图的下方，这是最　简单的堆栈顺序方法。

　　　　＜？ｘｍｌ　ｖｅｒｓｉｏｎ＝＂１．０＂　ｅｎｃｏｄｉｎｇ＝＂ｕｔｆ－８＂？＞　　　　　　　　　　　　　　延伸学习

　　　　学会　ＩｍａｇｅＶｉｅｗ　之后，　在延伸学习里，　便可试着将两个　ＩｍａｇｅＢｕｔｔｏｎ　Ｗｉｄｇｅｔ　堆栈在一起，　如此一来，不但有背景图，还有按钮事件。

　　　　接着，你就　可以自由发挥了。ＩｍａｇｅＢｕｔｔｏｎ　的使用方法已经介绍过，而堆栈的技巧可参　考这个范例程序，比较不同的地方就是只要点击图片，即可直接做换图的动　作，不需要再　点击面的　Ｂｕｔｔｏｎ　做更换，需要注意的是图片大小要作调整，不然可能会与　ＩｍａｇｅＢｕｔｔｏｎ　不合　喔！　　　　范例说明

　　　　Ｓｐｉｎｎｅｒ　就是下拉菜单，也等于　ｓｗｉｎｇ　的　ｃｏｍｂｏ　ｂｏｘ、ｈｔｍｌ　的　，由于手机画面有　限，要在有限的范围选择项目，下拉菜单是唯一、也是较好的选择。　Ａｎｄｒｏｉｄ　提供的　Ｓｐｉｎｎｅｒ　Ｗｉｄｇｅｔ　的下拉菜单已经非常好用了，样式也还适用。但本范例　的示范重点在于自定义下拉菜单里的样式，其关键在于调用　ｓｅｔＤｒｏｐＤｏｗｎＶｉｅｗＲｅｓｏｕｒｃｅ　方　法，以　ＸＭＬ　的方式定义下拉菜单要显示的模样。本范例除了自定义下拉菜单，还用程序设　计了一段动画，　Ｕｓｅｒ　以触控的方式点击这个自定义的　Ｓｐｉｎｎｅｒ　时，　当　会以一段动画提示　Ｕｓｅｒ。　　　　运行结果

　　　　▲图　４－８　自定义　Ｓｐｉｎｎｅｒ　的下拉菜单模式，具有圆角的效果　　　　范例程序

　　　　ｓｒｃ／ｉｒｄｃ．ｅｘ０４＿０８／ＥＸ０４＿０８．ｊａｖａ

　　　　在　ｎｅｗ　ＡｒｒａｙＡｄａｐｔｅｒ　中，我们使用　ＡｒｒａｙＡｄａｐｔｅｒ（Ｃｏｎｔｅｘｔ　ｃｏｎｔｅｘｔ，　ｉｎｔ　ｔｅｘｔＶｉｅｗＲｅｓｏｕｒｃｅＩｄ，　Ｔ［］　ｏｂｊｅｃｔｓ）　这个　Ｃｏｎｓｔｒｕｃｔｏｒ，ｔｅｘｔＶｉｅｗＲｅｓｏｕｒｃｅＩｄ　使用　Ａｎｄｒｏｉｄ　提供的　ＲｅｓｏｕｒｃｅＩＤ，ｏｂｊｅｃｔｓ　为必须传递的字符串数　组（Ｓｔｒｉｎｇ　Ａｒｒａｙ）　。　Ａｄａｐｔｅｒ　的　ｓｅｔＤｒｏｐＤｏｗｎＶｉｅｗＲｅｓｏｕｒｃｅ　可以设置下拉菜单的显示方式，将该　ｘｍｌ　定义在　ｒｅｓ／ｌａｙｏｕｔ　目　录　下　面　，　可　针　对　下　拉　菜　单　中　的　ＴｅｘｔＶｉｅｗ　进　行　设　置　，　如　同　本　程　序　里　的　Ｒ．ｌａｙｏｕｔ．ｍｙｓｐｉｎｎｅｒ＿ｄｒｏｐｄｏｗｎ　即为自定义的下拉菜单　ＴｅｘｔＶｉｅｗ　样式。除了改变　下拉菜单样　式外，也对　Ｓｐｉｎｎｅｒ　做了一点动态效果，点击　Ｓｐｉｎｎｅｒ　时，晃动　Ｓｐｉｎｎｅｒ　再出现下拉菜单　（ｍｙＡｎｉｍａｔｉｏｎ）　。

　　　　ｐａｃｋａｇｅ　ｉｒｄｃ．ｅｘ０４＿０８；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ａｐｐ．Ａｃｔｉｖｉｔｙ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｏｓ．

ｐａｇｅ　２６

Ｂｕｎｄｌｅ；

　　　　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｖｉｅｗ．ＭｏｔｉｏｎＥｖｅｎｔ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｖｉｅｗ．Ｖｉｅｗ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｖｉｅｗ．ａｎｉｍａｔｉｏｎ．Ａｎｉｍａｔｉｏｎ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｖｉｅｗ．ａｎｉｍａｔｉｏｎ．ＡｎｉｍａｔｉｏｎＵｔｉｌｓ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＡｄａｐｔｅｒＶｉｅｗ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＡｒｒａｙＡｄａｐｔｅｒ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＴｅｘｔＶｉｅｗ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＬｉｓｔＶｉｅｗ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．Ｓｐｉｎｎｅｒ；　ｐｕｂｌｉｃ　ｃｌａｓｓ　ＥＸ０４＿０８　ｅｘｔｅｎｄｓ　Ａｃｔｉｖｉｔｙ　｛　ｐｒｉｖａｔｅ　ｓｔａｔｉｃ　ｆｉｎａｌ　Ｓｔｒｉｎｇ［］　ｃｏｕｎｔｒｉｅｓＳｔｒ　＝　｛　＂北京市＂，　＂上海市＂，　＂天津市＂，　＂重庆市＂　｝；　ｐｒｉｖａｔｅ　ＴｅｘｔＶｉｅｗ　ｍｙＴｅｘｔＶｉｅｗ；　ｐｒｉｖａｔｅ　Ｓｐｉｎｎｅｒ　ｍｙＳｐｉｎｎｅｒ；　ｐｒｉｖａｔｅ　ＡｒｒａｙＡｄａｐｔｅｒ　ａｄａｐｔｅｒ；　Ａｎｉｍａｔｉｏｎ　ｍｙＡｎｉｍａｔｉｏｎ；　／＊＊　Ｃａｌｌｅｄ　ｗｈｅｎ　ｔｈｅ　ａｃｔｉｖｉｔｙ　ｉｓ　ｆｉｒｓｔ　ｃｒｅａｔｅｄ．　＊／　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｒｅａｔｅ（Ｂｕｎｄｌｅ　ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）　｛　ｓｕｐｅｒ．ｏｎＣｒｅａｔｅ（ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）；　／＊　载入　ｍａｉｎ．ｘｍｌ　Ｌａｙｏｕｔ　＊／　ｓｅｔＣｏｎｔｅｎｔＶｉｅｗ（Ｒ．ｌａｙｏｕｔ．ｍａｉｎ）；

　　　　／＊　以　ｆｉｎｄＶｉｅｗＢｙＩｄ（）取得对象　＊／　ｍｙＴｅｘｔＶｉｅｗ　＝　（ＴｅｘｔＶｉｅｗ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＴｅｘｔＶｉｅｗ）；　ｍｙＳｐｉｎｎｅｒ　＝　（Ｓｐｉｎｎｅｒ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＳｐｉｎｎｅｒ）；　ａｄａｐｔｅｒ　＝　ｎｅｗ　ＡｒｒａｙＡｄａｐｔｅｒ（ｔｈｉｓ，　ａｎｄｒｏｉｄ．Ｒ．ｌａｙｏｕｔ．ｓｉｍｐｌｅ＿ｓｐｉｎｎｅｒ＿ｉｔｅｍ，　ｃｏｕｎｔｒｉｅｓＳｔｒ）；　／＊　ｍｙｓｐｉｎｎｅｒ＿ｄｒｏｐｄｏｗｎ　为自定义下拉菜单样式定义在　ｒｅｓ／ｌａｙｏｕｔ　目录下　＊／　ａｄａｐｔｅｒ．ｓｅｔＤｒｏｐＤｏｗｎＶｉｅｗＲｅｓｏｕｒｃｅ（Ｒ．ｌａｙｏｕｔ．ｍｙｓｐｉｎｎｅｒ＿ｄｒｏｐｄｏｗｎ）；　／＊　将　ＡｒｒａｙＡｄａｐｔｅｒ　添加　Ｓｐｉｎｎｅｒ　对象中　＊／　ｍｙＳｐｉｎｎｅｒ．ｓｅｔＡｄａｐｔｅｒ（ａｄａｐｔｅｒ）；　／＊　将　ｍｙＳｐｉｎｎｅｒ　添加　ＯｎＩｔｅｍＳｅｌｅｃｔｅｄＬｉｓｔｅｎｅｒ　＊／　ｍｙＳｐｉｎｎｅｒ．ｓｅｔＯｎＩｔｅｍＳｅｌｅｃｔｅｄＬｉｓｔｅｎｅｒ　（ｎｅｗ　Ｓｐｉｎｎｅｒ．ＯｎＩｔｅｍＳｅｌｅｃｔｅｄＬｉｓｔｅｎｅｒ（）　｛　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＩｔｅｍＳｅｌｅｃｔｅｄ　（ＡｄａｐｔｅｒＶｉｅｗ＜？＞　ａｒｇ０，　Ｖｉｅｗ　ａｒｇ１，　ｉｎｔ　ａｒｇ２，　ｌｏｎｇ　ａｒｇ３）　｛　／＊　将所选　ｍｙＳｐｉｎｎｅｒ　的值带入　ｍｙＴｅｘｔＶｉｅｗ　中　＊／　ｍｙＴｅｘｔＶｉｅｗ．ｓｅｔＴｅｘｔ（＂选择的是＂　＋　ｃｏｕｎｔｒｉｅｓＳｔｒ［ａｒｇ２］）；　／＊　将　ｍｙＳｐｉｎｎｅｒ　显示　＊／　ａｒｇ０．ｓｅｔＶｉｓｉｂｉｌｉｔｙ（Ｖｉｅｗ．ＶＩＳＩＢＬＥ）；　｝　　　　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＮｏｔｈｉｎｇＳｅｌｅｃｔｅｄ（ＡｄａｐｔｅｒＶｉｅｗ＜？＞　ａｒｇ０）　｛　／／　ＴＯＤＯ　Ａｕｔｏ－ｇｅｎｅｒａｔｅｄ　ｍｅｔｈｏｄ　ｓｔｕｂ　｝　｝）；　／＊　取得　Ａｎｉｍａｔｉｏｎ　定义在　ｒｅｓ／ａｎｉｍ　目录下　＊／　ｍｙＡｎｉｍａｔｉｏｎ　＝　ＡｎｉｍａｔｉｏｎＵｔｉｌｓ．ｌｏａｄＡｎｉｍａｔｉｏｎ（ｔｈｉｓ，　Ｒ．ａｎｉｍ．ｍｙ＿ａｎｉｍ）；　／＊　将　ｍｙＳｐｉｎｎｅｒ　添加　ＯｎＴｏｕｃｈＬｉｓｔｅｎｅｒ　＊／　ｍｙＳｐｉｎｎｅｒ．ｓｅｔＯｎＴｏｕｃｈＬｉｓｔｅｎｅｒ（ｎｅｗ　Ｓｐｉｎｎｅｒ．ＯｎＴｏｕｃｈＬｉｓｔｅｎｅｒ（）　｛　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｂｏｏｌｅａｎ　ｏｎＴｏｕｃｈ（Ｖｉｅｗ　ｖ，　ＭｏｔｉｏｎＥｖｅｎｔ　ｅｖｅｎｔ）　｛　／＊　将　ｍｙＳｐｉｎｎｅｒ　运行　Ａｎｉｍａｔｉｏｎ　＊／　ｖ．ｓｔａｒｔＡｎｉｍａｔｉｏｎ（ｍｙＡｎｉｍａｔｉｏｎ）；　／＊　将　ｍｙＳｐｉｎｎｅｒ　隐藏　＊／　ｖ．ｓｅｔＶｉｓｉｂｉｌｉｔｙ（Ｖｉｅｗ．ＩＮＶＩＳＩＢＬＥ）；　ｒｅｔｕｒｎ　ｆａｌｓｅ；　｝　｝）；　ｍｙＳｐｉｎｎｅｒ．ｓｅｔＯｎＦｏｃｕｓＣｈａｎｇｅＬｉｓｔｅｎｅｒ（ｎｅｗ　Ｓｐｉｎｎｅｒ．ＯｎＦｏｃｕｓＣｈａｎｇｅＬｉｓｔｅｎｅｒ（）　｛

　　　　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＦｏｃｕｓＣｈａｎｇｅ（Ｖｉｅｗ　ｖ，　ｂｏｏｌｅａｎ　ｈａｓＦｏｃｕｓ）　｛　／／　ＴＯＤＯ　Ａｕｔｏ－ｇｅｎｅｒａｔｅｄ　ｍｅｔｈｏｄ　ｓｔｕｂ　｝　｝）；　｝　｝　　　　ｒｅｓ／ｌａｙｏｕｔ／ｍｙｓｐｉｎｎｅｒ＿ｄｒｏｐｄｏｗｎ．ｘｍｌ

　　　　改变下拉菜单样子的　ｘｍｌ，里面所使用的组件为　ＴｅｘｔＶｉｅｗ。

　　　　＜？ｘｍｌ　ｖｅｒｓｉｏｎ＝＂１．０＂　ｅｎｃｏｄｉｎｇ＝＂ｕｔｆ－８＂？＞　＜ＴｅｘｔＶｉｅｗ　ｘｍｌｎｓ：ａｎｄｒｏｉｄ＝＂ｈｔｔｐ：／／ｓｃｈｅｍａｓ．ａｎｄｒｏｉｄ．ｃｏｍ／ａｐｋ／ｒｅｓ／ａｎｄｒｏｉｄ＂　ａｎｄｒｏｉｄ：ｉｄ＝＂＠＋ｉｄ／ｔｅｘｔ１＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｗｉｄｔｈ＝＂ｗｒａｐ＿ｃｏｎｔｅｎｔ＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｈｅｉｇｈｔ＝＂２４ｓｐ＂　ａｎｄｒｏｉｄ：ｓｉｎｇｌｅＬｉｎｅ＝＂ｔｒｕｅ＂　ｓｔｙｌｅ＝＂？ａｎｄｒｏｉｄ：ａｔｔｒ／ｓｐｉｎｎｅｒＤｒｏｐＤｏｗｎＩｔｅｍＳｔｙｌｅ＂　／＞　　　　ｒｅｓ／ａｎｉｍ／ｍｙ＿ａｎｉｍ．ｘｍｌ

　　　　Ａｎｄｒｏｉｄ　的动画（ａｎｉｍａｔｉｏｎ）由四种类型（ｔｙｐｅ）所组成：ａｌｐｈａ、ｓｃａｌｅ、ｔｒａｎｓｌａｔｅ，以及　ｒｏｔａｔｅ，以下的自定义动画将使用当中的两种。　　　　＜？ｘｍｌ　ｖｅｒｓｉｏｎ＝＂１．０＂　ｅｎｃｏｄｉｎｇ＝＂ｕｔｆ－８＂？＞　　　　　　扩展学习

　　　　Ａｎｉｍａｔｉｏｎ　主要有两种动态方式，　一种是　ｔｗｅｅｎｅｄ　ａｎｉｍａｔｉｏｎ　（渐变动画）　另一种是　ｆｒａｍｅ　，　ｂｙ　ｆｒａｍｅ　ａｎｉｍａｔｉｏｎ（画面转换动画）　。ｔｗｅｅｎｅｄ　ａｎｉｍａｔｉｏｎ　则有以下四种基本转换方式：　　　　ｌ　ｌ　ｌ　ｌ

　　　　ＡｌｐｈａＡｎｉｍａｔｉｏｎ　（ｔｒａｎｓｐａｒｅｎｃｙ　ｃｈａｎｇｅｓ）：透明度转换　ＲｏｔａｔｅＡｎｉｍａｔｉｏｎ　（ｒｏｔａｔｉｏｎｓ）：旋转转换　ＳｃａｌｅＡｎｉｍａｔｉｏｎ　（ｇｒｏｗｉｎｇ　ｏｒ　ｓｈｒｉｎｋｉｎｇ）：缩放转换　ＴｒａｎｓｌａｔｅＡｎｉｍａｔｉｏｎ　（ｐｏｓｉｔｉｏｎ　ｃｈａｎｇｅｓ）：位置转换

ｐａｇｅ　２７

　　　　定义好你想要的动画　ｘｍｌ　后，用　ＡｎｉｍａｔｉｏｎＵｔｉｌｓ．ｌｏａｄＡｎｉｍａｔｉｏｎ　将动画加载，在想要加上　动态效果的组件中使用　ｓｔａｒｔＡｎｉｍａｔｉｏｎ　方法。　　　　范例说明

　　　　前面的范例对　Ｓｐｉｎｎｅｒ　的自定义菜单、交互事件已大致掌握了设计方法，但在　Ａｎｄｒｏｉｄ　的　Ｓｐｉｎｎｅｒ　里的元素，若要动态增减　Ｓｐｉｎｎｅｒ　下拉菜单的选项，就必须利用　ＡｒｒａｙＬｉｓｔ　的依赖　性来完成。　以下范例将设计一个　ＥｄｉｔＴｅｘｔ，当　Ｕｓｅｒ　输　入了新的文字，在点击“添加”按钮的同时，　就会将输入的值添加　Ｓｐｉｎｎｅｒ（至下拉菜单的最后一项）　，接着　Ｓｐｉｎｎｅｒ　会停留在刚添加好的　选项上；当　点击“删除”按钮，则删除选择的　Ｓｐｉｎｎｅｒ　选项，常应用于未知　Ｓｐｉｎｎｅｒ　选项数量　的　Ｔｏ－Ｄｏ　Ｌｉｓｔ、或添加维护市县数据等等。　　　　运行结果

　　　　▲图　４－９　随　Ｕｓｅｒ　的输入文字，可动态添加／删除的　Ｓｐｉｎｎｅｒ　菜单　　　　范例程序

　　　　ｓｒｃ／ｉｒｄｃ．ｅｘ０４＿０９／ＥＸ０４＿０９．ｊａｖａ

　　　　Ｓｐｉｎｎｅｒ　添加了　ＯｎＩｔｅｍＳｅｌｅｃｔｅｄＬｉｓｔｅｎｅｒ　事件，当点击下拉菜单后，将值带到上方　的　ＴｅｘｔＶｉｅｗ。上一个范例在　ｎｅｗ　ａｄａｐｔｅｒ　时传入　Ｓｔｒｉｎｇ　数组，这次因为要添加及删除　ａｄａｐｔｅｒ，　所以要传入的是　ＡｒｒａｙＬｉｓｔ，否则，在添加删除时会出现错误。　　　　ｐａｃｋａｇｅ　ｉｒｄｃ．ｅｘ０４＿０９；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ａｐｐ．Ａｃｔｉｖｉｔｙ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｏｓ．Ｂｕｎｄｌｅ；

　　　　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｖｉｅｗ．Ｖｉｅｗ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＡｄａｐｔｅｒＶｉｅｗ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＡｒｒａｙＡｄａｐｔｅｒ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．Ｂｕｔｔｏｎ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＥｄｉｔＴｅｘｔ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．Ｓｐｉｎｎｅｒ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＴｅｘｔＶｉｅｗ；　ｉｍｐｏｒｔ　ｊａｖａ．ｕｔｉｌ．ＡｒｒａｙＬｉｓｔ；　ｉｍｐｏｒｔ　ｊａｖａ．ｕｔｉｌ．Ｌｉｓｔ；　ｐｕｂｌｉｃ　ｃｌａｓｓ　ＥＸ０４＿０９　ｅｘｔｅｎｄｓ　Ａｃｔｉｖｉｔｙ　｛　ｐｒｉｖａｔｅ　ｓｔａｔｉｃ　ｆｉｎａｌ　Ｓｔｒｉｎｇ［］　ｃｏｕｎｔｒｉｅｓＳｔｒ　＝　｛　＂北京市＂，　＂上海市＂，　＂天津市＂，　＂重庆市＂　｝；　ｐｒｉｖａｔｅ　ＴｅｘｔＶｉｅｗ　ｍｙＴｅｘｔＶｉｅｗ；　ｐｒｉｖａｔｅ　ＥｄｉｔＴｅｘｔ　ｍｙＥｄｉｔＴｅｘｔ；　ｐｒｉｖａｔｅ　Ｂｕｔｔｏｎ　ｍｙＢｕｔｔｏｎ＿ａｄｄ；　ｐｒｉｖａｔｅ　Ｂｕｔｔｏｎ　ｍｙＢｕｔｔｏｎ＿ｒｅｍｏｖｅ；　ｐｒｉｖａｔｅ　Ｓｐｉｎｎｅｒ　ｍｙＳｐｉｎｎｅｒ；　ｐｒｉｖａｔｅ　ＡｒｒａｙＡｄａｐｔｅｒ　ａｄａｐｔｅｒ；　ｐｒｉｖａｔｅ　Ｌｉｓｔ　ａｌｌＣｏｕｎｔｒｉｅｓ；　／＊＊　Ｃａｌｌｅｄ　ｗｈｅｎ　ｔｈｅ　ａｃｔｉｖｉｔｙ　ｉｓ　ｆｉｒｓｔ　ｃｒｅａｔｅｄ．　＊／　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｒｅａｔｅ（Ｂｕｎｄｌｅ　ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）　｛

　　　　ｓｕｐｅｒ．ｏｎＣｒｅａｔｅ（ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）；　／＊　载入　ｍａｉｎ．ｘｍｌ　Ｌａｙｏｕｔ　＊／　ｓｅｔＣｏｎｔｅｎｔＶｉｅｗ（Ｒ．ｌａｙｏｕｔ．ｍａｉｎ）；　ａｌｌＣｏｕｎｔｒｉｅｓ　＝　ｎｅｗ　ＡｒｒａｙＬｉｓｔ（）；　ｆｏｒ　（ｉｎｔ　ｉ　＝　０；　ｉ　＜　ｃｏｕｎｔｒｉｅｓＳｔｒ．ｌｅｎｇｔｈ；　ｉ＋＋）　｛　ａｌｌＣｏｕｎｔｒｉｅｓ．ａｄｄ（ｃｏｕｎｔｒｉｅｓＳｔｒ［ｉ］）；　｝　／＊　ｎｅｗ　ＡｒｒａｙＡｄａｐｔｅｒ　对象并将　ａｌｌＣｏｕｎｔｒｉｅｓ　传入　＊／　ａｄａｐｔｅｒ　＝　ｎｅｗ　ＡｒｒａｙＡｄａｐｔｅｒ（ｔｈｉｓ，　ａｎｄｒｏｉｄ．Ｒ．ｌａｙｏｕｔ．ｓｉｍｐｌｅ＿ｓｐｉｎｎｅｒ＿ｉｔｅｍ，　ａｌｌＣｏｕｎｔｒｉｅｓ）；　ａｄａｐｔｅｒ　．ｓｅｔＤｒｏｐＤｏｗｎＶｉｅｗＲｅｓｏｕｒｃｅ　（ａｎｄｒｏｉｄ．Ｒ．ｌａｙｏｕｔ．ｓｉｍｐｌｅ＿ｓｐｉｎｎｅｒ＿ｄｒｏｐｄｏｗｎ＿ｉｔｅｍ）；　／＊　以　ｆｉｎｄＶｉｅｗＢｙＩｄ（）取得对象　＊／　ｍｙＴｅｘｔＶｉｅｗ　＝　（ＴｅｘｔＶｉｅｗ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＴｅｘｔＶｉｅｗ）；　ｍｙＥｄｉｔＴｅｘｔ　＝　（ＥｄｉｔＴｅｘｔ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＥｄｉｔＴｅｘｔ）；　ｍｙＢｕｔｔｏｎ＿ａｄｄ　＝　（Ｂｕｔｔｏｎ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＢｕｔｔｏｎ＿ａｄｄ）；　ｍｙＢｕｔｔｏｎ＿ｒｅｍｏｖｅ　＝　（Ｂｕｔｔｏｎ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＢｕｔｔｏｎ＿ｒｅｍｏｖｅ）；　ｍｙＳｐｉｎｎｅｒ　＝　（Ｓｐｉｎｎｅｒ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＳｐｉｎｎｅｒ）；　／＊　将　ＡｒｒａｙＡｄａｐｔｅｒ　添加　Ｓｐｉｎｎｅｒ　对象中　＊／　ｍｙＳｐｉｎｎｅｒ．ｓｅｔＡｄａｐｔｅｒ（ａｄａｐｔｅｒ）；　／＊　将　ｍｙＢｕｔｔｏｎ＿ａｄｄ　添加　ＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ　＊／　ｍｙＢｕｔｔｏｎ＿ａｄｄ．ｓｅｔＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（ｎｅｗ　Ｂｕｔｔｏｎ．ＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（）

　　　　｛　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｌｉｃｋ（Ｖｉｅｗ　ａｒｇ０）　｛　Ｓｔｒｉｎｇ　ｎｅｗＣｏｕｎｔｒｙ　＝　ｍｙＥｄｉｔＴｅｘｔ．ｇｅｔＴｅｘｔ（）．ｔｏＳｔｒｉｎｇ（）；　／＊　先比较添加的值是否已存在，不存在才可添加　＊／　ｆｏｒ　（ｉｎｔ　ｉ　＝　０；　ｉ　＜　ａｄａｐｔｅｒ．ｇｅｔＣｏｕｎｔ（）；　ｉ＋＋）　｛　ｉｆ　（ｎｅｗＣｏｕｎｔｒｙ．ｅｑｕａｌｓ（ａｄａｐｔｅｒ．ｇｅｔＩｔｅｍ（ｉ）））　｛　ｒｅｔｕｒｎ；　｝　｝　ｉｆ　（！ｎｅｗＣｏｕｎｔｒｙ．ｅｑｕａｌｓ（＂＂））　｛　／＊　将值添加至　ａｄａｐｔｅｒ　＊／　ａｄａｐｔｅｒ．ａｄｄ（ｎｅｗＣｏｕｎｔｒｙ）；　／＊　取得添加的值的位置　＊／　ｉｎｔ　ｐｏｓｉｔｉｏｎ　＝　ａｄａｐｔｅｒ．ｇｅｔＰｏｓｉｔｉｏｎ（ｎｅｗＣｏｕｎｔｒｙ）；　／＊　将　Ｓｐｉｎｎｅｒ　选择在添加的值的位置　＊／　ｍｙＳｐｉｎｎｅｒ．ｓｅｔＳｅｌｅｃｔｉｏｎ（ｐｏｓｉｔｉｏｎ）；　／＊　将　ｍｙＥｄｉｔＴｅｘｔ　清空　＊／　ｍｙＥｄｉｔＴｅｘｔ．ｓｅｔＴｅｘｔ（＂＂）；　｝

　　　　｝　｝）；　／＊　将　ｍｙＢｕｔｔｏｎ＿ｒｅｍｏｖｅ　添加　ＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ　＊／　ｍｙＢｕｔｔｏｎ＿ｒｅｍｏｖｅ．ｓ

ｐａｇｅ　２８

ｅｔＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（ｎｅｗ　Ｂｕｔｔｏｎ．ＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（）　｛　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｌｉｃｋ（Ｖｉｅｗ　ａｒｇ０）　｛　ｉｆ　（ｍｙＳｐｉｎｎｅｒ．ｇｅｔＳｅｌｅｃｔｅｄＩｔｅｍ（）　！＝　ｎｕｌｌ）　｛　／＊　删除　ｍｙＳｐｉｎｎｅｒ　的值　＊／　ａｄａｐｔｅｒ．ｒｅｍｏｖｅ（ｍｙＳｐｉｎｎｅｒ．ｇｅｔＳｅｌｅｃｔｅｄＩｔｅｍ（）．ｔｏＳｔｒｉｎｇ（））；　／＊　将　ｍｙＥｄｉｔＴｅｘｔ　清空　＊／　ｍｙＥｄｉｔＴｅｘｔ．ｓｅｔＴｅｘｔ（＂＂）；　ｉｆ　（ａｄａｐｔｅｒ．ｇｅｔＣｏｕｎｔ（）　＝＝　０）　｛　／＊　将　ｍｙＴｅｘｔＶｉｅｗ　清空　＊／　ｍｙＴｅｘｔＶｉｅｗ．ｓｅｔＴｅｘｔ（＂＂）；　｝　｝　｝　｝）；　／＊　将　ｍｙＳｐｉｎｎｅｒ　添加　ＯｎＩｔｅｍＳｅｌｅｃｔｅｄＬｉｓｔｅｎｅｒ　＊／　ｍｙＳｐｉｎｎｅｒ．ｓｅｔＯｎＩｔｅｍＳｅｌｅｃｔｅｄＬｉｓｔｅｎｅｒ

　　　　（ｎｅｗ　Ｓｐｉｎｎｅｒ．ＯｎＩｔｅｍＳｅｌｅｃｔｅｄＬｉｓｔｅｎｅｒ（）　｛　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＩｔｅｍＳｅｌｅｃｔｅｄ（ＡｄａｐｔｅｒＶｉｅｗ＜？＞　ａｒｇ０，　Ｖｉｅｗ　ａｒｇ１，　ｉｎｔ　ａｒｇ２，　ｌｏｎｇ　ａｒｇ３）　｛　／＊　将所选　ｍｙＳｐｉｎｎｅｒ　的值带入　ｍｙＴｅｘｔＶｉｅｗ　中　＊／　ｍｙＴｅｘｔＶｉｅｗ．ｓｅｔＴｅｘｔ（ａｒｇ０．ｇｅｔＳｅｌｅｃｔｅｄＩｔｅｍ（）．ｔｏＳｔｒｉｎｇ（））；　｝　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＮｏｔｈｉｎｇＳｅｌｅｃｔｅｄ（ＡｄａｐｔｅｒＶｉｅｗ＜？＞　ａｒｇ０）　｛　｝　｝）；　｝　｝　　　　扩展学习

　　　　ｓｅｔＤｒｏｐＤｏｗｎＶｉｅｗＲｅｓｏｕｒｃｅ　主要是设置　Ｕｓｅｒ　点击　Ｓｐｉｎｎｅｒ　后出现的下拉菜单样式，除了　前一个范例使用自设方式改变　ＴｅｘｔＶｉｅｗ　内容之外，ａｎｄｒｏｉｄ　亦提供两种基本的样式：　　　　ｌ

　　　　ａｎｄｒｏｉｄ．Ｒ．ｌａｙｏｕｔ．ｓｉｍｐｌｅ＿ｓｐｉｎｎｅｒ＿ｉｔｅｍ：ＴｅｘｔＶｉｅｗ　的下拉菜单。

　　　　ｌ　ａｎｄｒｏｉｄ．Ｒ．ｌａｙｏｕｔ．ｓｉｍｐｌｅ＿ｓｐｉｎｎｅｒ＿ｄｒｏｐｄｏｗｎ＿ｉｔｅｍ：除了有　ＴｅｘｔＶｉｅｗ，右边有　ｒａｄｉｏ　的下拉菜单。

　　　　查看　Ａｎｄｒｏｉｄ　源代码中的　ｓｉｍｐｌｅ＿ｓｐｉｎｎｅｒ＿ｄｒｏｐｄｏｗｎ＿ｉｔｅｍ．ｘｍｌ，内容如下：　　　　＜？ｘｍｌ　ｖｅｒｓｉｏｎ＝＂１．０＂　ｅｎｃｏｄｉｎｇ＝＂ｕｔｆ－８＂？＞　＜ＴｅｘｔＶｉｅｗ　ｘｍｌｎｓ：ａｎｄｒｏｉｄ＝＂ｈｔｔｐ：／／ｓｃｈｅｍａｓ．ａｎｄｒｏｉｄ．ｃｏｍ／ａｐｋ／ｒｅｓ／ａｎｄｒｏｉｄ＂　ａｎｄｒｏｉｄ：ｉｄ＝＂＠ａｎｄｒｏｉｄ：ｉｄ／ｔｅｘｔ１＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｗｉｄｔｈ＝＂ｆｉｌｌ＿ｐａｒｅｎｔ＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｈｅｉｇｈｔ＝＂？ａｎｄｒｏｉｄ：ａｔｔｒ／ｌｉｓｔＰｒｅｆｅｒｒｅｄＩｔｅｍＨｅｉｇｈｔ＂　ａｎｄｒｏｉｄ：ｓｉｎｇｌｅＬｉｎｅ＝＂ｔｒｕｅ＂　ｓｔｙｌｅ＝＂？ａｎｄｒｏｉｄ：ａｔｔｒ／ｓｐｉｎｎｅｒＤｒｏｐＤｏｗｎＩｔｅｍＳｔｙｌｅ＂　／＞

　　　　以下为自定义修改后，适用于　ｓｐｉｎｎｅｒ　的　Ｌａｙｏｕｔ：

　　　　＜？ｘｍｌ　ｖｅｒｓｉｏｎ＝＂１．０＂　ｅｎｃｏｄｉｎｇ＝＂ｕｔｆ－８＂？＞　＜ＴｅｘｔＶｉｅｗ　ｘｍｌｎｓ：ａｎｄｒｏｉｄ＝＂ｈｔｔｐ：／／ｓｃｈｅｍａｓ．ａｎｄｒｏｉｄ．ｃｏｍ／ａｐｋ／ｒｅｓ／ａｎｄｒｏｉｄ＂　ａｎｄｒｏｉｄ：ｉｄ＝＂＠ａｎｄｒｏｉｄ：ｉｄ／ｔｅｘｔ１＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｗｉｄｔｈ＝＂ｆｉｌｌ＿ｐａｒｅｎｔ＂　ａｎｄｒｏｉｄ：ｌａｙｏｕｔ＿ｈｅｉｇｈｔ＝＂１２ｓｐ＂　ａｎｄｒｏｉｄ：ｓｉｎｇｌｅＬｉｎｅ＝＂ｔｒｕｅ＂　ｓｔｙｌｅ＝＂？ａｎｄｒｏｉｄ：ａｔｔｒ／ｓｐｉｎｎｅｒＤｒｏｐＤｏｗｎＩｔｅｍＳｔｙｌｅ＂　ａｎｄｒｏｉｄ：ｔｅｘｔＳｉｚｅ＝＂１０ｓｐ＂　／＞　　　　范例说明

　　　　还记得在第三章“简单的　Ｇａｌｌｅｒｙ　相片画廊”范　例，为了简化问题，使用了　Ａｎｄｒｏｉｄ　默认　的　Ｉｃｏｎ　作为　Ｇａｌｌｅｒｙ　显示的内容吗？现在，将数张　ＰＮＧ　图片导入　Ｄｒａｗａｂｌｅ　当中，并于　ｏｎＣｒｅａｔｅ　的同时，载入于　Ｇａｌｌｅｒｙ　Ｗｉｄｇｅｔ　中，试着再添加一个　ＯｎＩｔｅｍＣｌｉｃｋ　的事件，以取得

　　　　图片的　ＩＤ　编号来响应用户点击图片时的状态，完成　Ｇａｌｌｅｒｙ　的高级使用。本范例　的另一个　重点，就是如何设置　Ｇａｌｌｅｒｙ　图片的宽高以及放置图片　Ｌａｙｏｕｔ　的大小，在此我们改写一个继　承自　ＢａｓｅＡｄａｐｔｅｒ　的　ＩｍａｇｅＡｄａｐｔｅｒ　容器来存放图片，通过　ＩｍａｇｅＶｉｅｗ．ｓｅｔＳｃａｌｅＴｙｐｅ（）　的方法　来改变图片的显示，再通过　ｓｅｔＬａｙｏｕｔＰａｒａｍｓ（）　方法来改变　Ｌａｙｏｕｔ　的宽高。　　　　运行结果

　　　　▲图　４－１０　程序启动后会显示　ｒｅｓ／ｄｒａｗａｂｌｅ　中的图片，点击任一图片会　Ｔｏａｓｔ　该图片的编号　　　　范例程序

　　　　ｓｒｃ／ｉｒｄｃ．ｅｘ０４＿１０／ＥＸ０４＿１０．ｊａｖａ

　　　　主程序有两大重点，　第一、　ＩｍａｇｅＡｄａｐｔｅｒ　继承　ＢａｓｅＡｄａｐｔｅｒ　ｃｌａｓｓ　的未实现方法的重写　是　构造，第二、则是　Ｇａｌｌｅｒｙ　的　ＯｎＩｔｅｍＣｌｉｃｋ（）　方法与图片及　Ｌａｙｏｕｔ　宽高设置。

　　　　ｐａｃｋａｇｅ　ｉｒｄｃ．ＥＸ０４＿１０；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ａｐｐ．Ａｃｔｉｖｉｔｙ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｏｓ．Ｂｕｎｄｌｅ；　／＊　本范例需使用到的　ｃｌａｓｓ　＊／　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｃｏｎｔｅｎｔ．Ｃｏｎｔｅｘｔ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｃｏｎｔｅｎｔ．ｒｅｓ．ＴｙｐｅｄＡｒｒａｙ；

ｐａｇｅ　２９

　　　　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｖｉｅｗ．Ｖｉｅｗ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｖｉｅｗ．ＶｉｅｗＧｒｏｕｐ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＡｄａｐｔｅｒＶｉｅｗ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＢａｓｅＡｄａｐｔｅｒ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．Ｇａｌｌｅｒｙ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＩｍａｇｅＶｉｅｗ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．Ｔｏａｓｔ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＡｄａｐｔｅｒＶｉｅｗ．ＯｎＩｔｅｍＣｌｉｃｋＬｉｓｔｅｎｅｒ；　ｐｕｂｌｉｃ　ｃｌａｓｓ　ＥＸ０４＿１０　ｅｘｔｅｎｄｓ　Ａｃｔｉｖｉｔｙ　｛　／＊＊　Ｃａｌｌｅｄ　ｗｈｅｎ　ｔｈｅ　ａｃｔｉｖｉｔｙ　ｉｓ　ｆｉｒｓｔ　ｃｒｅａｔｅｄ．　＊／　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｒｅａｔｅ（Ｂｕｎｄｌｅ　ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）　｛　ｓｕｐｅｒ．ｏｎＣｒｅａｔｅ（ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）；　ｓｅｔＣｏｎｔｅｎｔＶｉｅｗ（Ｒ．ｌａｙｏｕｔ．ｍａｉｎ）；　／＊通过　ｆｉｎｄＶｉｅｗＢｙＩｄ　取得＊／　Ｇａｌｌｅｒｙ　ｇ　＝　（Ｇａｌｌｅｒｙ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙｇａｌｌｅｒｙ）；　／＊　添加一　ＩｍａｇｅＡｄａｐｔｅｒ　并设置给　Ｇａｌｌｅｒｙ　对象　＊／　ｇ．ｓｅｔＡｄａｐｔｅｒ（ｎｅｗ　ＩｍａｇｅＡｄａｐｔｅｒ（ｔｈｉｓ））；

　　　　／＊　设置一个　ｉｔｅｍｃｌｉｃｋＬｉｓｔｅｎｅｒ　并　Ｔｏａｓｔ　被点击图片的位置　＊／　ｇ．ｓｅｔＯｎＩｔｅｍＣｌｉｃｋＬｉｓｔｅｎｅｒ（ｎｅｗ　ＯｎＩｔｅｍＣｌｉｃｋＬｉｓｔｅｎｅｒ（）　｛

　　　　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＩｔｅｍＣｌｉｃｋ　（ＡｄａｐｔｅｒＶｉｅｗ＜？＞　ｐａｒｅｎｔ，　Ｖｉｅｗ　ｖ，　ｉｎｔ　ｐｏｓｉｔｉｏｎ，　ｌｏｎｇ　ｉｄ）　｛　Ｔｏａｓｔ．ｍａｋｅＴｅｘｔ　（ＥＸ０４＿１０．ｔｈｉｓ，　ｇｅｔＳｔｒｉｎｇ（Ｒ．ｓｔｒｉｎｇ．ｍｙ＿ｇａｌｌｅｒｙ＿ｔｅｘｔ＿ｐｒｅ）　＋　ｐｏｓｉｔｉｏｎ＋　ｇｅｔＳｔｒｉｎｇ（Ｒ．ｓｔｒｉｎｇ．ｍｙ＿ｇａｌｌｅｒｙ＿ｔｅｘｔ＿ｐｏｓｔ），　Ｔｏａｓｔ．ＬＥＮＧＴＨ＿ＳＨＯＲＴ）．ｓｈｏｗ（）；　｝　｝）；　｝

　　　　／＊　改写　ＢａｓｅＡｄａｐｔｅｒ　自定义一　ＩｍａｇｅＡｄａｐｔｅｒ　ｃｌａｓｓ　＊／　ｐｕｂｌｉｃ　ｃｌａｓｓ　ＩｍａｇｅＡｄａｐｔｅｒ　ｅｘｔｅｎｄｓ　ＢａｓｅＡｄａｐｔｅｒ　｛　／＊声明变量＊／　ｉｎｔ　ｍＧａｌｌｅｒｙＩｔｅｍＢａｃｋｇｒｏｕｎｄ；　ｐｒｉｖａｔｅ　Ｃｏｎｔｅｘｔ　ｍＣｏｎｔｅｘｔ；

　　　　／＊ＩｍａｇｅＡｄａｐｔｅｒ　的构造器＊／　ｐｕｂｌｉｃ　ＩｍａｇｅＡｄａｐｔｅｒ（Ｃｏｎｔｅｘｔ　ｃ）　｛　ｍＣｏｎｔｅｘｔ　＝　ｃ；

　　　　／＊　使用在　ｒｅｓ／ｖａｌｕｅｓ／ａｔｔｒｓ．ｘｍｌ　中的＜ｄｅｃｌａｒｅ－ｓｔｙｌｅａｂｌｅ＞定义

　　　　＊　的　Ｇａｌｌｅｒｙ　属性．＊／　ＴｙｐｅｄＡｒｒａｙ　ａ　＝　ｏｂｔａｉｎＳｔｙｌｅｄＡｔｔｒｉｂｕｔｅｓ（Ｒ．ｓｔｙｌｅａｂｌｅ．Ｇａｌｌｅｒｙ）；

　　　　／＊取得　Ｇａｌｌｅｒｙ　属性的　Ｉｎｄｅｘ　ｉｄ＊／　ｍＧａｌｌｅｒｙＩｔｅｍＢａｃｋｇｒｏｕｎｄ　＝　ａ．ｇｅｔＲｅｓｏｕｒｃｅＩｄ　（Ｒ．ｓｔｙｌｅａｂｌｅ．Ｇａｌｌｅｒｙ＿ａｎｄｒｏｉｄ＿ｇａｌｌｅｒｙＩｔｅｍＢａｃｋｇｒｏｕｎｄ，　０）；　　　　／＊让对象的　ｓｔｙｌｅａｂｌｅ　属性能够反复使用＊／　ａ．ｒｅｃｙｃｌｅ（）；　｝

　　　　／＊　重写的方法　ｇｅｔＣｏｕｎｔ，返回图片数目　＊／　ｐｕｂｌｉｃ　ｉｎｔ　ｇｅｔＣｏｕｎｔ（）　｛　ｒｅｔｕｒｎ　ｍｙＩｍａｇｅＩｄｓ．ｌｅｎｇｔｈ；　｝

　　　　／＊　重写的方法　ｇｅｔＩｔｅｍＩｄ，返回图像的数组　ｉｄ　＊／　ｐｕｂｌｉｃ　Ｏｂｊｅｃｔ　ｇｅｔＩｔｅｍ（ｉｎｔ　ｐｏｓｉｔｉｏｎ）　｛　ｒｅｔｕｒｎ　ｐｏｓｉｔｉｏｎ；　｝　ｐｕｂｌｉｃ　ｌｏｎｇ　ｇｅｔＩｔｅｍＩｄ（ｉｎｔ　ｐｏｓｉｔｉｏｎ）　｛　　　　ｒｅｔｕｒｎ　ｐｏｓｉｔｉｏｎ；　｝

　　　　／＊　重写的方法　ｇｅｔＶｉｅｗ，返回一　Ｖｉｅｗ　对象　＊／　ｐｕｂｌｉｃ　Ｖｉｅｗ　ｇｅｔＶｉｅｗ　（ｉｎｔ　ｐｏｓｉｔｉｏｎ，　Ｖｉｅｗ　ｃｏｎｖｅｒｔＶｉｅｗ，　ＶｉｅｗＧｒｏｕｐ　ｐａｒｅｎｔ）　｛　／＊产生　ＩｍａｇｅＶｉｅｗ　对象＊／　ＩｍａｇｅＶｉｅｗ　ｉ　＝　ｎｅｗ　ＩｍａｇｅＶｉｅｗ（ｍＣｏｎｔｅｘｔ）；　／＊设置图片给　ｉｍａｇｅＶｉｅｗ　对象＊／　ｉ．ｓｅｔＩｍａｇｅＲｅｓｏｕｒｃｅ（ｍｙＩｍａｇｅＩｄｓ［ｐｏｓｉｔｉｏｎ］）；　／＊重新设置图片的宽高＊／　ｉ．ｓｅｔＳｃａｌｅＴｙｐｅ（ＩｍａｇｅＶｉｅｗ．ＳｃａｌｅＴｙｐｅ．ＦＩＴ＿ＸＹ）；　／＊重新设置　Ｌａｙｏｕｔ　的宽高＊／　ｉ．ｓｅｔＬａｙｏｕｔＰａｒａｍｓ（ｎｅｗ　Ｇａｌｌｅｒｙ．ＬａｙｏｕｔＰａｒａｍｓ（１３６，　８８））；　／＊设置　Ｇａｌｌｅｒｙ　背景图＊／　ｉ．ｓｅｔＢａｃｋｇｒｏｕｎｄＲｅｓｏｕｒｃｅ（ｍＧａｌｌｅｒｙＩｔｅｍＢａｃｋｇｒｏｕｎｄ）；　／＊返回　ｉｍａｇｅＶｉｅｗ　对象＊／　ｒｅｔｕｒｎ　ｉ；　｝

　　　　／＊构建一　Ｉｎｔｅｇｅｒ　ａｒｒａｙ　并取得预加载　Ｄｒａｗａｂｌｅ　的图片　ｉｄ＊／　ｐｒｉｖａｔｅ　Ｉｎｔｅｇｅｒ［］　ｍｙＩｍａｇｅＩｄｓ　＝　｛

　　　　Ｒ．ｄｒａｗａｂｌｅ．ｐｈｏｔｏ１，　Ｒ．ｄｒａｗａｂｌｅ．ｐｈｏｔｏ２，　Ｒ．ｄｒａｗａｂｌｅ．ｐｈｏｔｏ３，　Ｒ．ｄｒａｗａｂｌｅ．ｐｈｏｔｏ４，　Ｒ．ｄｒａｗａｂｌｅ．ｐｈｏｔｏ５，　Ｒ．ｄｒａｗａｂｌｅ．ｐｈｏｔｏ６，　｝；　｝　｝　　　　ｒｅｓ／ｖａｌｕｅｓ／ａｔｔｒｓ．ｘｍｌ

　　　　定义　ｌａｙｏｕｔ　外部　ｒｅｓｏｕｒｃｅ　的　ｘｍｌ　文件，用来改变　ｌａｙｏｕｔ　的背景图。　　　　＜？ｘｍｌ　ｖｅｒｓｉｏｎ＝＂１．０＂　ｅｎｃｏｄｉｎｇ＝＂ｕｔｆ－８＂？＞　＜ｒｅｓｏｕｒｃｅｓ＞　＜ｄｅｃｌａｒｅ－ｓｔｙｌｅａｂｌｅ　ｎａｍｅ＝＂Ｇａｌｌｅｒｙ＂＞　　＜／ｄｅｃｌａｒｅ－ｓｔｙｌｅａｂｌｅ＞　＜／ｒｅｓｏｕｒｃｅｓ＞　　　　扩展学习

　　　　在　Ａｎｄｒｏｉｄ：ＳｃａｌｅＴｙｐｅ　中定义了下列常数可供使用，　通过“ＯｂｊｅｃｔＶｉｅｗ．ＳｃａｌｅＴｙｐｅ　常数名称”　的方式，就可以改变图片的显示方式。　　　　常数名称　Ｍａｔｒｉｘ　ｆｉｔＸＹ　ｆｉｔＳｔａｒｔ　ｆｉｔＣｅｎｔｅｒ　　　　值　０　１　２　３

　　　　ｆｉｔＥｎｄ　ｃｅｎｔｅｒ　ｃｅｎｔｅｒＣｒｏｐ　ｃｅｎｔｅｒＩｎｓｉｄｅ

ｐａｇｅ　３０

　　　　４　５　６　７

　　　　另外，在主程序中，我们使用了下面这一段写法：

　　　　ＴｙｐｅｄＡｒｒａｙ　ａ　＝　ｏｂｔａｉｎＳｔｙｌｅｄＡｔｔｒｉｂｕｔｅｓ（Ｒ．ｓｔｙｌｅａｂｌｅ．Ｇａｌｌｅｒｙ）；

　　　　这是一个引用自制　ｌａｙｏｕｔ　元素的用法，必须在　ｒｅｓ／ｖａｌｕｅｓ　下面添加一个　ａｔｔｒｓ．ｘｍｌ，并在　其　中　定　义　＜ｄｅｃｌａｒｅ－ｓｔｙｌｅａｂｌｅ＞　标　签　ＴＡＧ，　目　的　是　自　定　义　ｌａｙｏｕｔ　的　背　景　风　格　，　并　且　通过　ＴｙｐｅＡｒｒａｙ　的特性，让相同的　Ｌａｙｏｕｔ　元素可以重复用于每一张图片。　　　　范例说明

　　　　大家都应该用过操作系统中的文件搜索功能吧！它可以　快速帮我们找到想要的文件。　如果要在手机制作一个文件搜索的功能，　又该如何实现呢？其实这个功能并不困难，　Ｊａｖａ　Ｉ／Ｏ　的　ＡＰＩ　中提供了　ｊａｖａ．ｉｏ．Ｆｉｌｅ　对象，只要利用　Ｆｉｌｅ　对象的方法，再搭配　Ａｎｄｒｏｉｄ　的　ＥｄｉｔＴｅｘｔ、　ＴｅｘｔＶｉｅｗ　等对象，　就可以轻松做出一个手机的文件搜索引擎。　本范例中使用　ＥｄｉｔＴｅｘｔ、Ｂｕｔｔｏｎ　与　ＴｅｘｔＶｉｅｗ　三种对象来实现此功能，用户将要搜索的　文件名称或关键字输入　ＥｄｉｔＴｅｘｔ　中，　点击　Ｂｕｔｔｏｎ　后，　程序会在根目录中寻找符合的文件，　并　将搜索结果显示于　ＴｅｘｔＶｉｅｗ　中；如果找不到符合的文件，则显示找不到文件。　　　　运行结果　　　　▲图　４－１１

　　　　快速搜索手机根目录中的文件　　　　范例程序

　　　　ｓｒｃ／ｉｒｄｃ．ｅｘ０４＿１１／ＥＸ０４＿１１．ｊａｖａ

　　　　范例中以　ｊａｖａ．ｉｏ．Ｆｉｌｅ　对象来取得根目录下的文件，经过比较后，将符合结果的文件路径　写入　ＴｅｘｔＶｉｅｗ　中，若要在　ＴｅｘｔＶｉｅｗ　中换行，需使用　＼ｎ　来作换行符号。

　　　　ｐａｃｋａｇｅ　ｉｒｄｃ．ｅｘ０４＿１１；　／＊　ｉｍｐｏｒｔ　相关　ｃｌａｓｓ　＊／　ｉｍｐｏｒｔ　ｊａｖａ．ｉｏ．Ｆｉｌｅ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ａｐｐ．Ａｃｔｉｖｉｔｙ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｏｓ．Ｂｕｎｄｌｅ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｖｉｅｗ．Ｖｉｅｗ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．Ｂｕｔｔｏｎ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＥｄｉｔＴｅｘｔ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＴｅｘｔＶｉｅｗ；　ｐｕｂｌｉｃ　ｃｌａｓｓ　ＥＸ０４＿１１　ｅｘｔｅｎｄｓ　Ａｃｔｉｖｉｔｙ　｛　／＊声明对象变量＊／　ｐｒｉｖａｔｅ　Ｂｕｔｔｏｎ　ｍＢｕｔｔｏｎ；　ｐｒｉｖａｔｅ　ＥｄｉｔＴｅｘｔ　ｍＫｅｙｗｏｒｄ；　ｐｒｉｖａｔｅ　ＴｅｘｔＶｉｅｗ　ｍＲｅｓｕｌｔ；

　　　　／＊＊　Ｃａｌｌｅｄ　ｗｈｅｎ　ｔｈｅ　ａｃｔｉｖｉｔｙ　ｉｓ　ｆｉｒｓｔ　ｃｒｅａｔｅｄ．　＊／　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｒｅａｔｅ（Ｂｕｎｄｌｅ　ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）

　　　　｛　ｓｕｐｅｒ．ｏｎＣｒｅａｔｅ（ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）；　／＊　载入　ｍａｉｎ．ｘｍｌ　Ｌａｙｏｕｔ　＊／　ｓｅｔＣｏｎｔｅｎｔＶｉｅｗ（Ｒ．ｌａｙｏｕｔ．ｍａｉｎ）；

　　　　／＊　初始化对象　＊／　ｍＫｅｙｗｏｒｄ＝（ＥｄｉｔＴｅｘｔ）ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍＫｅｙｗｏｒｄ）；　ｍＢｕｔｔｏｎ＝（Ｂｕｔｔｏｎ）ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍＢｕｔｔｏｎ）；　ｍＲｅｓｕｌｔ＝（ＴｅｘｔＶｉｅｗ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍＲｅｓｕｌｔ）；

　　　　／＊　将　ｍＢｕｔｔｏｎ　添加　ｏｎＣｌｉｃｋＬｉｓｔｅｎｅｒ　＊／　ｍＢｕｔｔｏｎ．ｓｅｔＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（ｎｅｗ　Ｂｕｔｔｏｎ．ＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（）　｛　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｌｉｃｋ（Ｖｉｅｗ　ｖ）　｛　／＊取得输入的关键字＊／　Ｓｔｒｉｎｇ　ｋｅｙｗｏｒｄ　＝　ｍＫｅｙｗｏｒｄ．ｇｅｔＴｅｘｔ（）．ｔｏＳｔｒｉｎｇ（）；　ｉｆ（ｋｅｙｗｏｒｄ．ｅｑｕａｌｓ（＂＂））　｛　ｍＲｅｓｕｌｔ．ｓｅｔＴｅｘｔ（＂请勿输入空白的关键字！！＂）；　｝　ｅｌｓｅ　｛　ｍＲｅｓｕｌｔ．ｓｅｔＴｅｘｔ（ｓｅａｒｃｈＦｉｌｅ（ｋｅｙｗｏｒｄ））；　　　　｝　｝　｝）；　｝

　　　　／＊　搜索文件的　ｍｅｔｈｏｄ　＊／　ｐｒｉｖａｔｅ　Ｓｔｒｉｎｇ　ｓｅａｒｃｈＦｉｌｅ（Ｓｔｒｉｎｇ　ｋｅｙｗｏｒｄ）　｛　Ｓｔｒｉｎｇ　ｒｅｓｕｌｔ＝＂＂；　Ｆｉｌｅ［］　ｆｉｌｅｓ＝ｎｅｗ　Ｆｉｌｅ（＂／＂）．ｌｉｓｔＦｉｌｅｓ（）；　ｆｏｒ（　Ｆｉｌｅ　ｆ　：　ｆｉｌｅｓ　）　｛　ｉｆ（ｆ．ｇｅｔＮａｍｅ（）．ｉｎｄｅｘＯｆ（ｋｅｙｗｏｒｄ）＞＝０）　｛　ｒｅｓｕｌｔ＋＝ｆ．ｇｅｔＰａｔｈ（）＋＂＼ｎ＂；　｝　｝　ｉｆ（ｒｅｓｕｌｔ．ｅｑｕａｌｓ（＂＂））　ｒｅｓｕｌｔ＝＂找不到文件！！＂；　ｒｅｔｕｒｎ　ｒｅｓｕｌｔ；　｝　｝　　　　扩展学习

　　　　在本范例中，ｓｅａｒｃｈＦｉｌｅ（Ｓｔｒｉｎｇ　ｋｅｙｗｏｒｄ）　这个方法的功用为搜索根目录下符合关键字的

　　　　文件，在搜索文件的过程中，只搜索根目录中的文件，并没有再对子目录下的文件作进一步　的比较，如果要再强化这个　文件搜索的功能，让它也能搜索包含子目录

ｐａｇｅ　３１

下的所有文件，可　以在程序中利用　Ｆｉｌｅ．ｉｓＤｉｒｅｃｔｏｒｙ（）　这个方法来判断其是否为目录。如果是的话，就继续往下　一层寻找；不是的话，就终止向下寻找的动作。这个做法在后面的范例中会有详细的示范，　要注意的是手机　硬件环境是否能负荷程序做大规模的文件搜索，毕竟手机的硬件配备（处　理器、内存）是比不上一般计算机的。　另外，　在范例中仅针对关键字做了空白检查，　在比较文　件名称时也没有忽略大小写　（要　大小写完全符合才搜索的出来）　，如果要让这个搜索功能更完备，当然可以多做一点变化，　例如，检查关键字是否包含特殊的字符、　可选择比较文件时是否忽略大小写、可选择要搜　索的文件类型，甚至是可自己指定要搜索的目录等等，就看各位要如何运用了。　　　　范例说明

　　　　Ａｎｄｒｏｉｄ　默　认　的　按　钮　通　常　都　是　方　方　正　正　的　，　也　许　前　面　的　范　例　已　经　看　过　如　何　通　过　ＩｍａｇｅＢｕｔｔｏｎ　来置换按钮背景图片了，但本范例的练习则是在两个按钮之间的交互，点击　Ａ　按钮，恢复　Ｂ　按钮图片；点击　Ｂ　按钮，恢复　Ａ　按钮的图片。使用的方法为点击的瞬间置换　图片，置换的图片方式与先前介绍的相同　（ＩｍａｇｅＢｕｔｔｏｎ．ｓｅｔＩｍａｇｅＤｒａｗａｂｌｅ）　。　程序项目预先　ｉｍｐｏｒｔ　了三张图　片：ｐ１．ｐｎｇ、ｐ２．ｐｎｇ　以及　ｐ３．ｐｎｇ，而在　ｏｎＣｒｅａｔｅ（）　时，　画面　Ｌａｙｏｕｔ　上的两个　ＩｍａｇｅＢｕｔｔｏｎ　各自显示　ｐ１．ｐｎｇ　以及　ｐ２．ｐｎｇ，当点击其一按钮，则改变　自己的图片为　ｐ３．ｐｎｇ，并还原另　一按钮的为默认的图文件，以按钮事件及图文件置换的方　式来提醒　Ｕｓｅｒ　现在所“选择”的图像按钮为何。　　　　运行结果　　　　▲图　４－１２

　　　　被点击的　ＩｍａｇｅＢｕｔｔｏｎ　因变换图片而被　Ｈｉｇｈｔｌｉｇｈｔ　出来　　　　范例程序

　　　　ｓｒｃ／ｉｒｄｃ．ｅｘ０４＿１２／ＥＸ０４＿１２．ｊａｖａ

　　　　范例程序主要通过　ｓｅｔＩｍａｇｅＤｒａｗａｂｌｅ　方法来改变按钮的图片，图片是放在　ｒｅｓ／ｄｒａｗａｂｌｅ　目录下面。而　ＩｍａｇｅＢｕｔｔｏｎ．ｓｅｔＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（）　的角色则是本程序的关键，通过同时换两个　按钮的图片来表示被选择的图片，是一种类似被选择的假象手法，常应用于切换开关（Ｔｕｒｎ　Ｏｎ／Ｔｕｒｎ　Ｏｆｆ）之用。

　　　　ｐａｃｋａｇｅ　ｉｒｄｃ．ｅｘ０４＿１２；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ａｐｐ．Ａｃｔｉｖｉｔｙ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｏｓ．Ｂｕｎｄｌｅ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｖｉｅｗ．Ｖｉｅｗ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．Ｂｕｔｔｏｎ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＩｍａｇｅＢｕｔｔｏｎ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＴｅｘｔＶｉｅｗ；　ｐｕｂｌｉｃ　ｃｌａｓｓ　ＥＸ０４＿１２　ｅｘｔｅｎｄｓ　Ａｃｔｉｖｉｔｙ　｛　ＴｅｘｔＶｉｅｗ　ｍｙＴｅｘｔＶｉｅｗ；　ＩｍａｇｅＢｕｔｔｏｎ　ｍｙＩｍａｇｅＢｕｔｔｏｎ＿１；　ＩｍａｇｅＢｕｔｔｏｎ　ｍｙＩｍａｇｅＢｕｔｔｏｎ＿２；　／＊＊　Ｃａｌｌｅｄ　ｗｈｅｎ　ｔｈｅ　ａｃｔｉｖｉｔｙ　ｉｓ　ｆｉｒｓｔ　ｃｒｅａｔｅｄ．　＊／　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｒｅａｔｅ（Ｂｕｎｄｌｅ　ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）　｛　ｓｕｐｅｒ．ｏｎＣｒｅａｔｅ（ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）；　／＊　载入　ｍａｉｎ．ｘｍｌ　Ｌａｙｏｕｔ　＊／

　　　　ｓｅｔＣｏｎｔｅｎｔＶｉｅｗ（Ｒ．ｌａｙｏｕｔ．ｍａｉｎ）；　／＊　以　ｆｉｎｄＶｉｅｗＢｙＩｄ（）取得　ＴｅｘｔＶｉｅｗ　及　ＩｍａｇｅＢｕｔｔｏｎ　对象　＊／　ｍｙＴｅｘｔＶｉｅｗ　＝　（ＴｅｘｔＶｉｅｗ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＴｅｘｔＶｉｅｗ）；　ｍｙＩｍａｇｅＢｕｔｔｏｎ＿１＝（ＩｍａｇｅＢｕｔｔｏｎ）ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＩｍａｇｅＢｕｔｔｏｎ＿１）；　ｍｙＩｍａｇｅＢｕｔｔｏｎ＿２＝（ＩｍａｇｅＢｕｔｔｏｎ）ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＩｍａｇｅＢｕｔｔｏｎ＿２）；　／＊　ｍｙＩｍａｇｅＢｕｔｔｏｎ＿１　添加　ＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ　＊／　ｍｙＩｍａｇｅＢｕｔｔｏｎ＿１．ｓｅｔＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（ｎｅｗ　Ｂｕｔｔｏｎ．ＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（）　｛　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｌｉｃｋ（Ｖｉｅｗ　ｖ）　｛　ｍｙＴｅｘｔＶｉｅｗ．ｓｅｔＴｅｘｔ（＂你点击的是　ｍｙＩｍａｇｅＢｕｔｔｏｎ＿１＂）；　／＊　点击　ｍｙＩｍａｇｅＢｕｔｔｏｎ＿１　时将　ｍｙＩｍａｇｅＢｕｔｔｏｎ＿１　图片置换成　ｐ３　图片　＊／　ｍｙＩｍａｇｅＢｕｔｔｏｎ＿１．ｓｅｔＩｍａｇｅＤｒａｗａｂｌｅ（ｇｅｔＲｅｓｏｕｒｃｅｓ（）．ｇｅｔＤｒａｗａｂｌｅ（　Ｒ．ｄｒａｗａｂｌｅ．ｐ３））；　／＊　点击　ｍｙＩｍａｇｅＢｕｔｔｏｎ＿１　时将　ｍｙＩｍａｇｅＢｕｔｔｏｎ＿２　图片置换成　ｐ２　图片　＊／　ｍｙＩｍａｇｅＢｕｔｔｏｎ＿２．ｓｅｔＩｍａｇｅＤｒａｗａｂｌｅ（ｇｅｔＲｅｓｏｕｒｃｅｓ（）．ｇｅｔＤｒａｗａｂｌｅ（　Ｒ．ｄｒａｗａｂｌｅ．ｐ２））；　｝　｝）；　／＊　ｍｙＩｍａｇｅＢｕｔｔｏｎ＿２　添加　ＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ　＊／　ｍｙＩｍａｇｅＢｕｔｔｏｎ＿２．ｓｅｔＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（ｎｅｗ　Ｂｕｔｔｏｎ．ＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（）　｛

　　　　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｌｉｃｋ（Ｖｉｅｗ　ｖ）　｛　ｍｙＴｅｘｔＶｉｅｗ．ｓｅｔＴｅｘｔ（＂你点击的是　ｍｙＩｍａｇｅＢｕｔｔｏｎ＿２＂）；　／＊　点击　ｍｙＩｍａｇｅＢｕｔｔｏｎ＿２　时将　ｍｙＩｍａｇｅＢｕｔｔｏｎ＿１　图片置换成　ｐ１　图片　＊／　ｍｙＩｍａｇｅＢｕｔｔｏｎ＿１．ｓｅｔＩｍａｇｅＤｒａｗａｂｌｅ（ｇｅｔＲｅｓｏｕｒｃｅｓ（）．ｇｅｔＤｒａｗａｂｌｅ（　Ｒ．ｄｒａｗａｂｌｅ．ｐ１））；　／＊　点击　ｍｙＩｍａｇｅＢｕｔｔｏｎ＿２　时将　ｍｙＩｍａｇｅＢｕｔｔｏｎ＿２　图片置换成　ｐ３　图片　＊／　ｍｙＩｍａｇｅＢｕｔｔｏｎ＿２．ｓｅｔＩｍａｇｅＤｒａｗａｂｌｅ（ｇｅｔＲｅｓｏｕｒｃｅｓ（）．ｇｅｔＤｒａｗａｂｌｅ（　Ｒ．ｄｒａｗａｂｌｅ．ｐ

ｐａｇｅ　３２

３））；　｝　｝）；　｝　｝　　　　扩展学习

　　　　除了自己在　ｒｅｓ／ｄｒａｗａｂｌｅ　放置图片方式外，　也可以用系统　Ａｎｄｒｏｉｄ　操作系统默认的图片，　如打电话、简短提示的图标等等，只要修改　ｍａｉｎ．ｘｍｌ　里　ＩｍａｇｅＢｕｔｔｏｎ　的属性：

　　　　ａｎｄｒｏｉｄ：ｓｒｃ＝＂＠ｄｒａｗａｂｌｅ／ｐ１＂　　　　将其改成

　　　　ａｎｄｒｏｉｄ：ｓｒｃ＝＂＠ａｎｄｒｏｉｄ：ｄｒａｗａｂｌｅ／ｓｙｍ＿ａｃｔｉｏｎ＿ｃａｌｌ＂

　　　　看到了吗？标识“＠ａｎｄｒｏｉｄ：”就表示是引用　ａｎｄｒｏｉｄ　所提供，而非自行导入的。

　　　　范例说明

　　　　通过　Ｇｏｏｇｌｅ　上网搜索时，只要输入几个文字，就会显示可能的关键字让你挑选，这种

　　　　效果在　Ａｎｄｒｏｉｄ　中是非常容易达到的。事实上，Ａｎｄｒｏｉｄ　的　ＡｕｔｏＣｏｍｐｌｅｔｅＴｅｘｔＶｉｅｗ　Ｗｉｄｇｅｔ，　只要搭配　ＡｒｒａｙＡｄａｐｔｅｒ　就能设计出类似　Ｇｏｏｇｌｅ　搜索提示的效果。　本范例先在　Ｌａｙｏｕｔ　当中布局一个　ＡｕｔｏＣｏｍｐｌｅｔｅＴｅｘｔＶｉｅｗ　Ｗｉｄｇｅｔ，然后通过预先设置好　的　字　符　串　数　组　，　将　此　字　符　串　数　组　放　入　ＡｒｒａｙＡｄａｐｔｅｒ　，　最　后　利　用　ＡｕｔｏＣｏｍｐｌｅｔｅＴｅｘｔＶｉｅｗ．ｓｅｔＡｄａｐｔｅｒ　方法，　就可以让　ＡｕｔｏＣｏｍｐｌｅｔｅＴｅｘｔＶｉｅｗ　Ｗｉｄｇｅｔ　具有自动完　成提示的功能。例如，只要输入　ａｂ，就会自动带出包含　ａｂ　的所有字符串列表。　　　　运行结果　　　　▲图　４－１３

　　　　只要输入　ａｂ，就会自动带出所有包含　ａｂ　的字符串列表　　　　范例程序

　　　　ｓｒｃ／ｉｒｄｃ．ｅｘ０４＿１３／ＥＸ０４＿１３．ｊａｖａ

　　　　本范例　程序主要示范　ＡｕｔｏＣｏｍｐｌｅｔｅＴｅｘｔＶｉｅｗ　用法，再次使用到　ＡｒｒａｙＡｄａｐｔｅｒ，只要是　有　下　拉　菜　单　的　项　目　，　都　必　须　使　用　到　ＡｒｒａｙＡｄａｐｔｅｒ　对　象　。　此　外　，　将　ＡｒｒａｙＡｄａｐｔｅｒ　添　加　ＡｕｔｏＣｏｍｐｌｅｔｅＴｅｘｔＶｉｅｗ　对象中，所使用的方法为　ｓｅｔＡｄａｐｔｅｒ，当中传输唯一的参数类型即为　字符串类型的　ＡｒｒａｙＡｄａｐｔｅｒ。　　　　ｐａｃｋａｇｅ　ｉｒｄｃ．ｅｘ０４＿１３；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ａｐｐ．Ａｃｔｉｖｉｔｙ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｏｓ．Ｂｕｎｄｌｅ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＡｒｒａｙＡｄａｐｔｅｒ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＡｕｔｏＣｏｍｐｌｅｔｅＴｅｘｔＶｉｅｗ；

　　　　ｐｕｂｌｉｃ　ｃｌａｓｓ　ＥＸ０４＿１３　ｅｘｔｅｎｄｓ　Ａｃｔｉｖｉｔｙ　｛　ｐｒｉｖａｔｅ　ｓｔａｔｉｃ　ｆｉｎａｌ　Ｓｔｒｉｎｇ［］　ａｕｔｏＳｔｒ　＝　ｎｅｗ　Ｓｔｒｉｎｇ［］　｛　＂ａ＂，　＂ａｂｃ＂，　＂ａｂｃｄ＂，　＂ａｂｃｄｅ＂　｝；　／＊＊　Ｃａｌｌｅｄ　ｗｈｅｎ　ｔｈｅ　ａｃｔｉｖｉｔｙ　ｉｓ　ｆｉｒｓｔ　ｃｒｅａｔｅｄ．　＊／　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｒｅａｔｅ（Ｂｕｎｄｌｅ　ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）　｛　ｓｕｐｅｒ．ｏｎＣｒｅａｔｅ（ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）；　／＊　载入　ｍａｉｎ．ｘｍｌ　Ｌａｙｏｕｔ　＊／　ｓｅｔＣｏｎｔｅｎｔＶｉｅｗ（Ｒ．ｌａｙｏｕｔ．ｍａｉｎ）；　／＊　ｎｅｗ　ＡｒｒａｙＡｄａｐｔｅｒ　对象并将　ａｕｔｏＳｔｒ　字符串数组传入　＊／　ＡｒｒａｙＡｄａｐｔｅｒ　ａｄａｐｔｅｒ　＝　ｎｅｗ　ＡｒｒａｙＡｄａｐｔｅｒ（ｔｈｉｓ，　ａｎｄｒｏｉｄ．Ｒ．ｌａｙｏｕｔ．ｓｉｍｐｌｅ＿ｄｒｏｐｄｏｗｎ＿ｉｔｅｍ＿１ｌｉｎｅ，　ａｕｔｏＳｔｒ）；　／＊　以　ｆｉｎｄＶｉｅｗＢｙＩｄ（）取得　ＡｕｔｏＣｏｍｐｌｅｔｅＴｅｘｔＶｉｅｗ　对象　＊／　ＡｕｔｏＣｏｍｐｌｅｔｅＴｅｘｔＶｉｅｗ　ｍｙＡｕｔｏＣｏｍｐｌｅｔｅＴｅｘｔＶｉｅｗ　＝　（ＡｕｔｏＣｏｍｐｌｅｔｅＴｅｘｔＶｉｅｗ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＡｕｔｏＣｏｍｐｌｅｔｅＴｅｘｔＶｉｅｗ）；　／＊　将　ＡｒｒａｙＡｄａｐｔｅｒ　添加　ＡｕｔｏＣｏｍｐｌｅｔｅＴｅｘｔＶｉｅｗ　对象中　＊／　ｍｙＡｕｔｏＣｏｍｐｌｅｔｅＴｅｘｔＶｉｅｗ．ｓｅｔＡｄａｐｔｅｒ（ａｄａｐｔｅｒ）；　｝　｝　　　　扩展学习

　　　　有个类　似　ＡｕｔｏＣｏｍｐｌｅｔｅＴｅｘｔＶｉｅｗ　的对象，称为　ＭｕｌｔｉＡｕｔｏＣｏｍｐｌｅｔｅＴｅｘｔＶｉｅｗ，它继承了

　　　　ＡｕｔｏＣｏｍｐｌｅｔｅＴｅｘｔＶｉｅｗ，差别在于它可以在输入框一直增加新的选择值，其编写方式也有些　不同，一定要　ｓｅｔＴｏｋｅｎｉｚｅｒ，否则会　出现错误，以下范例是传入　ＣｏｍｍａＴｏｋｅｎｉｚｅｒ　类，结果　会将原本选择框里的值往后加逗号及空白。

　　　　ｐａｃｋａｇｅ　ｉｒｄｃ．ｅｘ０４＿１３；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ａｐｐ．Ａｃｔｉｖｉｔｙ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｏｓ．Ｂｕｎｄｌｅ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＡｒｒａｙＡｄａｐｔｅｒ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＡｕｔｏＣｏｍｐｌｅｔｅＴｅｘｔＶｉｅｗ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＭｕｌｔｉＡｕｔｏＣｏｍｐｌｅｔｅＴｅｘｔＶｉｅｗ；　ｐｕｂｌｉｃ　ｃｌａｓ

ｐａｇｅ　３３

ｓ　ＥＸ０４＿１３　ｅｘｔｅｎｄｓ　Ａｃｔｉｖｉｔｙ　｛　ｐｒｉｖａｔｅ　ｓｔａｔｉｃ　ｆｉｎａｌ　Ｓｔｒｉｎｇ［］　ａｕｔｏＳｔｒ　＝　ｎｅｗ　Ｓｔｒｉｎｇ［］　｛　＂ａ＂，　＂ａｂｃ＂，　＂ａｂｃｄ＂，　＂ａｂｃｄｅ＂　｝；　／＊＊　Ｃａｌｌｅｄ　ｗｈｅｎ　ｔｈｅ　ａｃｔｉｖｉｔｙ　ｉｓ　ｆｉｒｓｔ　ｃｒｅａｔｅｄ．　＊／　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｒｅａｔｅ（Ｂｕｎｄｌｅ　ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）　｛　ｓｕｐｅｒ．ｏｎＣｒｅａｔｅ（ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）；　／＊　载入　ｍａｉｎ．ｘｍｌ　Ｌａｙｏｕｔ　＊／　ｓｅｔＣｏｎｔｅｎｔＶｉｅｗ（Ｒ．ｌａｙｏｕｔ．ｍａｉｎ＿１）；　／＊　ｎｅｗ　ＡｒｒａｙＡｄａｐｔｅｒ　对象并将　ａｕｔｏＳｔｒ　字符串数组传入　＊／　ＡｒｒａｙＡｄａｐｔｅｒ　ａｄａｐｔｅｒ　＝　ｎｅｗ　ＡｒｒａｙＡｄａｐｔｅｒ（ｔｈｉｓ，　ａｎｄｒｏｉｄ．Ｒ．ｌａｙｏｕｔ．ｓｉｍｐｌｅ＿ｄｒｏｐｄｏｗｎ＿ｉｔｅｍ＿１ｌｉｎｅ，　ａｕｔｏＳｔｒ）；　／＊　以　ｆｉｎｄＶｉｅｗＢｙＩｄ（）取得　ＭｕｌｔｉＡｕｔｏＣｏｍｐｌｅｔｅＴｅｘｔＶｉｅｗ　对象　＊／

　　　　ＭｕｌｔｉＡｕｔｏＣｏｍｐｌｅｔｅＴｅｘｔＶｉｅｗ　ｍｙＡｕｔｏＣｏｍｐｌｅｔｅＴｅｘｔＶｉｅｗ　＝　（ＭｕｌｔｉＡｕｔｏＣｏｍｐｌｅｔｅＴｅｘｔＶｉｅｗ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＡｕｔｏＣｏｍｐｌｅｔｅＴｅｘｔＶｉｅｗ）；　／＊　将　ＡｒｒａｙＡｄａｐｔｅｒ　添加　ＡｕｔｏＣｏｍｐｌｅｔｅＴｅｘｔＶｉｅｗ　对象中　＊／　ｍｙＡｕｔｏＣｏｍｐｌｅｔｅＴｅｘｔＶｉｅｗ．ｓｅｔＡｄａｐｔｅｒ（ａｄａｐｔｅｒ）；　ｍｙＡｕｔｏＣｏｍｐｌｅｔｅＴｅｘｔＶｉｅｗ．ｓｅｔＴｏｋｅｎｉｚｅｒ　（ｎｅｗ　ＭｕｌｔｉＡｕｔｏＣｏｍｐｌｅｔｅＴｅｘｔＶｉｅｗ．ＣｏｍｍａＴｏｋｅｎｉｚｅｒ（））；　｝　｝　　　　范例说明

　　　　Ａｎｄｒｏｉｄ　里的　ＡｎａｌｏｇＣｌｏｃｋ　Ｗｉｄｇｅｔ　是一个时钟对象，本范例将配置一个小时钟，并在其　下放置一个　ＴｅｘｔＶｉｅｗ，为了做对照，上面放置的为模拟时钟，下面的　ＴｅｘｔＶｉｅｗ　则模拟电子　时钟，将　ＡｎａｌｏｇＣｌｏｃｋ　的时间以数字钟形式显示。　本范例的重点，在在　ａｎｄｒｏｉｄ．ｏｓ．Ｈａｎｄｌｅｒ、ｊａｖａ．ｌａｎｇ．Ｔｈｒｅａｄ　以及　ａｎｄｒｏｉｄ．ｏｓ．Ｍｅｓｓａｇｅ　三对　象的整合应用，通过产生　Ｔｈｒｅａｄ　对象，在进程内同步调用　Ｓｙｓｔｅｍ．ｃｕｒｒｅｎｔＴｉｍｅＭｉｌｌｉｓ（）　取得　系统时间，　并通过　Ｍｅｓｓａｇｅ　对象来通知　Ｈａｎｄｌｅｒ　对象，　Ｈａｎｄｌｅｒ　则扮演联系　Ａｃｔｉｖｉｔｙ　与　Ｔｈｒｅａｄ　之间的桥梁，在收到　Ｍｅｓｓａｇｅ　对象后，将时间变量的值，显示于　ＴｅｘｔＶｉｅｗ　当中，产生数字　时钟的外观与功能。　　　　运行结果

　　　　▲图　４－１４　示数字钟

　　　　程序启动后，除了　ＡｎａｌｏｇＣｌｏｃｋ　会显示目前系统时间外，下方会显　　　　范例程序

　　　　ｓｒｃ／ｉｒｄｃ．ｅｘ０４＿１４／ＥＸ０４＿１４．ｊａｖａ

　　　　主程序需要另外加载　Ｊａｖａ　的　Ｃａｌｅｎｄａｒ　与　Ｔｈｒｅａｄ　对象，在　ｏｎＣｒｅａｔｅ（）　中构造　Ｈａｎｄｌｅｒ　与　Ｔｈｒｅａｄ　两对象，并实现　ｈａｎｄｅｌＭｅｓｓａｇｅ（）　与　ｒｕｎ（）　两个方法，如下所述：

　　　　ｐａｃｋａｇｅ　ｉｒｄｃ．ＥＸ０４＿１４；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ａｐｐ．Ａｃｔｉｖｉｔｙ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｏｓ．Ｂｕｎｄｌｅ；　／＊这里我们需要使用　Ｈａｎｄｌｅｒ　类与　Ｍｅｓｓａｇｅ　类来处理进程＊／　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｏｓ．Ｈａｎｄｌｅｒ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｏｓ．Ｍｅｓｓａｇｅ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＡｎａｌｏｇＣｌｏｃｋ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＴｅｘｔＶｉｅｗ；　／＊需要使用　Ｊａｖａ　的　Ｃａｌｅｎｄａｒ　与　Ｔｈｒｅａｄ　类来取得系统时间＊／

　　　　ｉｍｐｏｒｔ　ｊａｖａ．ｕｔｉｌ．Ｃａｌｅｎｄａｒ；　ｉｍｐｏｒｔ　ｊａｖａ．ｌａｎｇ．Ｔｈｒｅａｄ；　ｐｕｂｌｉｃ　ｃｌａｓｓ　ＥＸ０４＿１４　ｅｘｔｅｎｄｓ　Ａｃｔｉｖｉｔｙ　｛　／＊声明一常数作为判别信息用＊／　ｐｒｏｔｅｃｔｅｄ　ｓｔａｔｉｃ　ｆｉｎａｌ　ｉｎｔ　ＧＵＩＮＯＴＩＦＩＥＲ　＝　０ｘ１２３４；

　　　　／＊声明两个　ｗｉｄｇｅｔ　对象变量＊／　ｐｒｉｖａｔｅ　ＴｅｘｔＶｉｅｗ　ｍＴｅｘｔＶｉｅｗ；　ｐｕｂｌｉｃ　ＡｎａｌｏｇＣｌｏｃｋ　ｍＡｎａｌｏｇＣｌｏｃｋ；

　　　　／＊声明与时间相关的变量＊／　ｐｕｂｌｉｃ　Ｃａｌｅｎｄａｒ　ｍＣａｌｅｎｄａｒ；　ｐｕｂｌｉｃ　ｉｎｔ　ｍＭｉｎｕｔｅｓ；　ｐｕｂｌｉｃ　ｉｎｔ　ｍＨｏｕｒ；

　　　　／＊声明关键　Ｈａｎｄｌｅｒ　与　Ｔｈｒｅａｄ　变量＊／　ｐｕｂｌｉｃ　Ｈａｎｄｌｅｒ　ｍＨａｎｄｌｅｒ；　ｐｒｉｖａｔｅ　Ｔｈｒｅａｄ　ｍＣｌｏｃｋＴｈｒｅａｄ；　／＊＊　Ｃａｌｌｅｄ　ｗｈｅｎ　ｔｈｅ　ａｃｔｉｖｉｔｙ　ｉｓ　ｆｉｒｓｔ　ｃｒｅａｔｅｄ．　＊／　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｒｅａｔｅ（Ｂｕｎｄｌｅ　ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）　｛　ｓｕｐｅｒ．ｏｎＣｒｅａｔｅ（ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）；　ｓｅｔＣｏｎｔｅｎｔＶｉｅｗ（Ｒ．ｌａｙｏｕｔ．ｍａｉｎ）；

　　　　／＊通过　ｆｉｎｄＶｉｅｗＢｙＩｄ　取得两个　ｗｉｄｇｅｔ　对象＊／　ｍＴｅｘｔＶｉｅｗ＝（ＴｅｘｔＶｉｅｗ）ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＴｅｘｔＶｉｅｗ）；　ｍＡｎａｌｏｇＣｌｏｃｋ＝（ＡｎａｌｏｇＣｌｏｃｋ）ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＡｎａｌｏｇＣｌｏｃｋ）；

　　　　／＊通过　Ｈａｎｄｌｅｒ　来接收进程所传递的信息并更新　ＴｅｘｔＶｉｅｗ＊／　ｍＨａｎｄｌｅｒ　＝　ｎｅｗ　Ｈａｎｄｌｅｒ（）　｛　ｐｕｂｌｉｃ　ｖｏｉｄ　ｈａｎｄｌｅＭｅｓｓａｇｅ（Ｍｅｓｓａｇｅ　ｍｓｇ）　｛　／＊这里是处理信息的方法＊／　ｓｗｉｔｃｈ　（ｍｓｇ．ｗｈａｔ）　｛　ｃａｓｅ　ＥＸ０４＿１４．ＧＵＩＮＯＴＩＦＩＥＲ：　／＊　在这处理要　ＴｅｘｔＶｉｅｗ　

ｐａｇｅ　３４

对象　Ｓｈｏｗ　时间的事件　＊／　ｍＴｅｘｔＶｉｅｗ．ｓｅｔＴｅｘｔ（ｍＨｏｕｒ＋＂　：　＂＋ｍＭｉｎｕｔｅｓ）；　ｂｒｅａｋ；　｝　ｓｕｐｅｒ．ｈａｎｄｌｅＭｅｓｓａｇｅ（ｍｓｇ）；　｝　｝；

　　　　／＊通过进程来持续取得系统时间＊／　ｍＣｌｏｃｋＴｈｒｅａｄ＝ｎｅｗ　ＬｏｏｐｅｒＴｈｒｅａｄ（）；　　　　ｍＣｌｏｃｋＴｈｒｅａｄ．ｓｔａｒｔ（）；　｝

　　　　／＊改写一个　Ｔｈｒｅａｄ　Ｃｌａｓｓ　用来持续取得系统时间＊／　ｃｌａｓｓ　ＬｏｏｐｅｒＴｈｒｅａｄ　ｅｘｔｅｎｄｓ　Ｔｈｒｅａｄ　｛　ｐｕｂｌｉｃ　ｖｏｉｄ　ｒｕｎ（）　｛　ｓｕｐｅｒ．ｒｕｎ（）；　ｔｒｙ　｛　ｄｏ　｛　／＊取得系统时间＊／　ｌｏｎｇ　ｔｉｍｅ　＝　Ｓｙｓｔｅｍ．ｃｕｒｒｅｎｔＴｉｍｅＭｉｌｌｉｓ（）；　／＊通过　Ｃａｌｅｎｄａｒ　对象来取得小时与分钟＊／　ｆｉｎａｌ　Ｃａｌｅｎｄａｒ　ｍＣａｌｅｎｄａｒ　＝　Ｃａｌｅｎｄａｒ．ｇｅｔＩｎｓｔａｎｃｅ（）；　ｍＣａｌｅｎｄａｒ．ｓｅｔＴｉｍｅＩｎＭｉｌｌｉｓ（ｔｉｍｅ）；　ｍＨｏｕｒ　＝　ｍＣａｌｅｎｄａｒ．ｇｅｔ（Ｃａｌｅｎｄａｒ．ＨＯＵＲ）；　ｍＭｉｎｕｔｅｓ　＝　ｍＣａｌｅｎｄａｒ．ｇｅｔ（Ｃａｌｅｎｄａｒ．ＭＩＮＵＴＥ）；

　　　　／＊让进程休息一秒＊／　Ｔｈｒｅａｄ．ｓｌｅｅｐ（１０００）；　／＊重要关键程序：取得时间后发出信息给　Ｈａｎｄｌｅｒ＊／

　　　　Ｍｅｓｓａｇｅ　ｍ　＝　ｎｅｗ　Ｍｅｓｓａｇｅ（）；　ｍ．ｗｈａｔ　＝　ＥＸ０４＿１４．ＧＵＩＮＯＴＩＦＩＥＲ；　ＥＸ０４＿１４．ｔｈｉｓ．ｍＨａｎｄｌｅｒ．ｓｅｎｄＭｅｓｓａｇｅ（ｍ）；　｝ｗｈｉｌｅ（ＥＸ０４＿１４．ＬｏｏｐｅｒＴｈｒｅａｄ．ｉｎｔｅｒｒｕｐｔｅｄ（）＝＝ｆａｌｓｅ）；　／＊当系统发出中断信息时停止本循环＊／　｝　ｃａｔｃｈ（Ｅｘｃｅｐｔｉｏｎ　ｅ）　｛　ｅ．ｐｒｉｎｔＳｔａｃｋＴｒａｃｅ（）；　｝　｝　｝　｝　　　　扩展学习

　　　　其实要达到本范例效果的代码应该只有两行，　也就是将笔者对于　ＴｅｘｔＶｉｅｗ　与进程　Ｔｈｒｅａｄ　的处理，改为使用　ｗｉｄｇｅｔ．ＤｉｇｉｔａｌＣｌｏｃｋ　的方式，写法如下：

　　　　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＡｎａｌｏｇＣｌｏｃｋ　ｍＤｉｇｉｔａｌＣｌｏｃｋ　＝（ＤｉｇｉｔａｌＣｌｏｃｋ）ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｍｙＤｉｇｉｔａｌＣｌｏｃｋ）；

　　　　而本程序使用　ＴｅｘｔＶｉｅｗ　来模拟　ＤｉｇｉｔａｌＣｌｏｃｋ　的做法，实际上，也是参考　ＡｎａｌｏｇＣｌｏｃｋ　与　ＤｉｇｉｔａｌＣｌｏｃｋ　这两个　ｗｉｄｇｅｔ　的程序代码所做的练习，对于将来实现　Ｔｉｍｅｒ　相关的小对象，　会　有所帮助。　Ａｎｄｒｏｉｄ　提供了　Ｓｙｓｔｅｍ．ｃｕｒｒｅｎｔＴｉｍｅＭｉｌｌｉｓ（）、　ｕｐｔｉｍｅＭｉｌｌｉｓ（）、　ｅｌａｐｓｅｄＲｅａｌｔｉｍｅ（）这三种不同　特性的　Ｓｙｓｔｅｍ　Ｃｌｏｃｋ　给开发者使用。本范例使用　Ｓｙｓｔｅｍ．ｃｕｒｒｅｎｔＴｉｍｅＭｉｌｌｉｓ（）　就是标准的　Ｃｌｏｃｋ　用法，需要搭配真实的日期与时间使用，另外两者则是适用于　ｉｎｔｅｒｖａｌ　与　ｅｌａｐｓｅ　ｔｉｍｅ　来控制程序与　ＵＩ　之用，读者可以自己练习看看。　　　　范例说明

　　　　许多的网络服务，例如网络订票、网络订房、网络订旅程、或在注册会员输入基本　数据时，都会需要用户输入日期与时间格式的数据，有些网站会提供贴心的小功能：直接由　万年历上来选择日期与时间，选择完毕，就会自动将日期与时间带入需要填写的字段中。　Ａｎｄｒｏｉｄ　有没有提供类似的组件可以实现这样的功能呢？答案是肯定的！　在这个范例中，　将示范以　Ａｎｄｒｏｉｄ　ＡＰＩ　中提供的　ＤａｔｅＰｉｃｋｅｒ　与　ＴｉｍｅＰｉｃｋｅｒ　两种对象来实现动态输入日期与时　间的功能。　范例中使用了　ＤａｔｅＰｉｃｋｅｒ、　ＴｉｍｅＰｉｃｋｅｒ　与　ＴｅｘｔＶｉｅｗ　三种对象，以　ＴｅｘｔＶｉｅｗ　来显示日期　与时间，　默认带入目前系统的日期与时间，　ＤａｔｅＰｉｃｋｅｒ　与　ＴｉｍｅＰｉｃｋｅｒ　可让用户动态调整日期　与时间，当用户调整了　ＤａｔｅＰｉｃｋｅｒ　的日期或　ＴｉｍｅＰｉｃｋｅｒ　时间时，则　ＴｅｘｔＶｉｅｗ　中所显示的　日　期与时间亦会跟着改变。　　　　运行结果　　　　▲图　４－１５

　　　　由手机屏幕上动态输入日期与时间　　　　范例程序

　　　　ｓｒｃ／ｉｒｄｃ．ｅｘ０４＿１５／ＥＸ０４＿１５．ｊａｖａ

　　　　程　序　中　以　ｕｐｄａｔｅＤｉｓｐｌａｙ（）　这　个　方　法　来　设　置　ＴｅｘｔＶｉｅｗ　中　所　显　示　的　日　期　时　间　，　以　ｊａｖａ．ｕｔｉｌ．Ｃａｌｅｎｄａｒ　对象来取得目前的系统时间，并预先带入　ＴｅｘｔＶｉｅｗ　中。　当用户　更改了　ＤａｔｅＰｉｃｋｅｒ　里的年、月、日时，将触发　ＤａｔｅＰｉｃｋｅｒ　的　ｏｎＤａｔｅＣｈａｎｇｅ（）　事　件，运行　ｕｐｄａｔｅＤｉｓｐｌａｙ（）　来重新设置　ＴｅｘｔＶｉｅｗ　中显示的日期；同样的原理，当用户更改了

　　　　ＴｉｍｅＰｉｃｋｅｒ　里的时间，　会触发　ＴｉｍｅＰｉｃｋｅｒ　的　ｏｎＴｉｍｅＣｈａｎｇｅ（）　事件，　运行　ｕｐｄａｔｅＤｉｓｐｌａｙ（）　来　重新设置　ＴｅｘｔＶｉｅｗ　中显示的时间。

　　　　ｐａｃｋａｇｅ　ｉｒｄｃ．ｅｘ０４＿１５；　／＊　ｉｍｐｏｒｔ　相关　ｃｌａｓｓ　＊／　ｉｍｐｏｒｔ　ｊａｖａ．ｕｔｉｌ．Ｃａｌｅｎｄ

ｐａｇｅ　３５

ａｒ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ａｐｐ．Ａｃｔｉｖｉｔｙ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｏｓ．Ｂｕｎｄｌｅ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＴｅｘｔＶｉｅｗ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＤａｔｅＰｉｃｋｅｒ；　ｉｍｐｏｒｔ　ａｎｄｒｏｉｄ．ｗｉｄｇｅｔ．ＴｉｍｅＰｉｃｋｅｒ；　ｐｕｂｌｉｃ　ｃｌａｓｓ　ＥＸ０４＿１５　ｅｘｔｅｎｄｓ　Ａｃｔｉｖｉｔｙ　｛　／＊声明日期及时间变量＊／　ｐｒｉｖａｔｅ　ｉｎｔ　ｍＹｅａｒ；　ｐｒｉｖａｔｅ　ｉｎｔ　ｍＭｏｎｔｈ；　ｐｒｉｖａｔｅ　ｉｎｔ　ｍＤａｙ；　ｐｒｉｖａｔｅ　ｉｎｔ　ｍＨｏｕｒ；　ｐｒｉｖａｔｅ　ｉｎｔ　ｍＭｉｎｕｔｅ；　／＊声明对象变量＊／　ＴｅｘｔＶｉｅｗ　ｔｖ；　ＴｉｍｅＰｉｃｋｅｒ　ｔｐ；　ＤａｔｅＰｉｃｋｅｒ　ｄｐ；

　　　　／＊＊　Ｃａｌｌｅｄ　ｗｈｅｎ　ｔｈｅ　ａｃｔｉｖｉｔｙ　ｉｓ　ｆｉｒｓｔ　ｃｒｅａｔｅｄ．　＊／

　　　　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｒｅａｔｅ（Ｂｕｎｄｌｅ　ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）　｛　／＊取得目前日期与时间＊／　Ｃａｌｅｎｄａｒ　ｃ＝Ｃａｌｅｎｄａｒ．ｇｅｔＩｎｓｔａｎｃｅ（）；　ｍＹｅａｒ＝ｃ．ｇｅｔ（Ｃａｌｅｎｄａｒ．ＹＥＡＲ）；　ｍＭｏｎｔｈ＝ｃ．ｇｅｔ（Ｃａｌｅｎｄａｒ．ＭＯＮＴＨ）；　ｍＤａｙ＝ｃ．ｇｅｔ（Ｃａｌｅｎｄａｒ．ＤＡＹ＿ＯＦ＿ＭＯＮＴＨ）；　ｍＨｏｕｒ＝ｃ．ｇｅｔ（Ｃａｌｅｎｄａｒ．ＨＯＵＲ＿ＯＦ＿ＤＡＹ）；　ｍＭｉｎｕｔｅ＝ｃ．ｇｅｔ（Ｃａｌｅｎｄａｒ．ＭＩＮＵＴＥ）；

　　　　ｓｕｐｅｒ．ｏｎＣｒｅａｔｅ（ｓａｖｅｄＩｎｓｔａｎｃｅＳｔａｔｅ）；　／＊　载入　ｍａｉｎ．ｘｍｌ　Ｌａｙｏｕｔ　＊／　ｓｅｔＣｏｎｔｅｎｔＶｉｅｗ（Ｒ．ｌａｙｏｕｔ．ｍａｉｎ）；

　　　　／＊取得　ＴｅｘｔＶｉｅｗ　对象，并调用　ｕｐｄａｔｅＤｉｓｐｌａｙ（）　来设置显示的初始日期时间＊／　ｔｖ＝　（ＴｅｘｔＶｉｅｗ）　ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｓｈｏｗＴｉｍｅ）；　ｕｐｄａｔｅＤｉｓｐｌａｙ（）；

　　　　／＊取得　ＤａｔｅＰｉｃｋｅｒ　对象，以　ｉｎｉｔ（）　设置初始值与　ｏｎＤａｔｅＣｈａｎｇｅＬｉｓｔｅｎｅｒ（）　＊／　ｄｐ＝（ＤａｔｅＰｉｃｋｅｒ）ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｄＰｉｃｋｅｒ）；　ｄｐ．ｉｎｉｔ（ｍＹｅａｒ，ｍＭｏｎｔｈ，ｍＤａｙ，ｎｅｗ　ＤａｔｅＰｉｃｋｅｒ．ＯｎＤａｔｅＣｈａｎｇｅｄＬｉｓｔｅｎｅｒ（）

　　　　｛　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＤａｔｅＣｈａｎｇｅｄ（ＤａｔｅＰｉｃｋｅｒ　ｖｉｅｗ，ｉｎｔ　ｙｅａｒ，　ｉｎｔ　ｍｏｎｔｈＯｆＹｅａｒ，ｉｎｔ　ｄａｙＯｆＭｏｎｔｈ）　｛　ｍＹｅａｒ＝ｙｅａｒ；　ｍＭｏｎｔｈ＝　ｍｏｎｔｈＯｆＹｅａｒ；　ｍＤａｙ＝ｄａｙＯｆＭｏｎｔｈ；　／＊调用　ｕｐｄａｔｅＤｉｓｐｌａｙ（）来改变显示日期＊／　ｕｐｄａｔｅＤｉｓｐｌａｙ（）；　｝　｝）；

　　　　／＊取得　ＴｉｍｅＰｉｃｋｅｒ　对象，并设置为　２４　小时制显示＊／　ｔｐ＝（ＴｉｍｅＰｉｃｋｅｒ）ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｔＰｉｃｋｅｒ）；　ｔｐ．ｓｅｔＩｓ２４ＨｏｕｒＶｉｅｗ（ｔｒｕｅ）；

　　　　／＊ｓｅｔＯｎＴｉｍｅＣｈａｎｇｅｄＬｉｓｔｅｎｅｒ，并重写　ｏｎＴｉｍｅＣｈａｎｇｅｄ　ｅｖｅｎｔ＊／　ｔｐ．ｓｅｔＯｎＴｉｍｅＣｈａｎｇｅｄＬｉｓｔｅｎｅｒ（ｎｅｗ　ＴｉｍｅＰｉｃｋｅｒ．ＯｎＴｉｍｅＣｈａｎｇｅｄＬｉｓｔｅｎｅｒ（）　｛　＠Ｏｖｅｒｒｉｄｅ　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＴｉｍｅＣｈａｎｇｅｄ（ＴｉｍｅＰｉｃｋｅｒ　ｖｉｅｗ，　ｉｎｔ　ｈｏｕｒＯｆＤａｙ，

　　　　ｉｎｔ　ｍｉｎｕｔｅ）　｛　ｍＨｏｕｒ＝ｈｏｕｒＯｆＤａｙ；　ｍＭｉｎｕｔｅ＝ｍｉｎｕｔｅ；　／＊调用　ｕｐｄａｔｅＤｉｓｐｌａｙ（）来改变显示时间＊／　ｕｐｄａｔｅＤｉｓｐｌａｙ（）；　｝　｝）；　｝

　　　　／＊设置显示日期时间的方法＊／　ｐｒｉｖａｔｅ　ｖｏｉｄ　ｕｐｄａｔｅＤｉｓｐｌａｙ（）　｛　ｔｖ．ｓｅｔＴｅｘｔ（　ｎｅｗ　ＳｔｒｉｎｇＢｕｉｌｄｅｒ（）．ａｐｐｅｎｄ（ｍＹｅａｒ）．ａｐｐｅｎｄ（＂／＂）　．ａｐｐｅｎｄ（ｆｏｒｍａｔ（ｍＭｏｎｔｈ　＋　１））．ａｐｐｅｎｄ（＂／＂）　．ａｐｐｅｎｄ（ｆｏｒｍａｔ（ｍＤａｙ））．ａｐｐｅｎｄ（＂　＂）

　　　　．ａｐｐｅｎｄ（ｆｏｒｍａｔ（ｍＨｏｕｒ））．ａｐｐｅｎｄ（＂：＂）　．ａｐｐｅｎｄ（ｆｏｒｍａｔ（ｍＭｉｎｕｔｅ））　）；　｝　　　　／＊日期时间显示两位数的方法＊／　ｐｒｉｖａｔｅ　Ｓｔｒｉｎｇ　ｆｏｒｍａｔ（ｉｎｔ　ｘ）　　　　｛　Ｓｔｒｉｎｇ　ｓ＝＂＂＋ｘ；　ｉｆ（ｓ．ｌｅｎｇｔｈ（）＝＝１）　ｓ＝＂０＂＋ｓ；　ｒｅｔｕｒｎ　ｓ；　｝　｝　　　　扩展学习

　　　　本范例的重点在于学习如何使用　ＤａｔｅＰｉｃｋｅｒ　与　ＴｉｍｅＰｉｃｋｅｒ　对象来达成动态调整日期与　时间的功能，　眼尖的读者应该发现，　在范例中，　ＤａｔｅＰｉｃｋｅｒ　实现　ＯｎＤａｔｅＣｈａｎｇｅｄＬｉｓｔｅｎｅｒ（）　的　方法与　ＴｉｍｅＰｉｃｋｅｒ　实现　ＯｎＴｉｍｅＣｈａｎｇｅｄＬｉｓｔｅｎｅｒ（）　的方法是不太相同的。ＤａｔｅＰｉｃｋｅｒ　对象以　ｉｎｉｔ（）　这个方法来指定　ＤａｔｅＰｉｃｋｅｒ　初始的年、月、日及　ＯｎＤａｔｅＣｈａｎｇｅｄＬｉｓｔｅｎｅｒ（）　的事件；　而　ＴｉｍｅＰｉｃｋｅｒ　对象则是直接以　ｓｅｔＯｎＴｉｍｅＣｈａｎｇｅｄＬｉｓｔｅｎｅｒ（）　事件来处理时间改变时程序要做的　操作。　在　旧　版　的　Ａｎｄｒｏｉｄ　ＳＤＫ　（　１．０ｒ２　版　以　前　的　ＳＤＫ　版　本　）　中　，　ＤａｔｅＰｉｃｋｅｒ　对　象　有　提　供　ｓｅｔＯｎＤａｔｅＣｈａｎｇｅｄＬｉｓｔｅｎｅｒ（）　这个方法，但是在新版的　ＳＤＫ（１．０ｒ２）　，这个方法被删除了，　所　以要实现　ＯｎＤａｔｅＣｈａｎｇｅｄＬｉｓｔｅｎｅｒ（）　时，必须以　ｉｎｉｔ（）　方式来重写　ＯｎＤａｔｅＣｈａｎｇｅｄＬｉｓｔｅｎｅｒ（）；　而　ＴｉｍｅＰｉｃｋｅｒ　则直接以　ｓｅｔＯｎＴｉｍｅＣｈａｎｇｅｄＬｉｓｔｅｎｅｒ（）　来实现即可。　Ａｎｄｒｏｉｄ　ＡＰＩ　另外提供了其它的对象来实现动态修改日期时间的功能：ＤａｔｅＰｉｃｋｅｒＤｉａｌｏｇ　与　ＴｉｍｅＰｉｃｋｅｒＤｉａｌｏｇ。这两种类型的对象最大　的差别在于　ＤａｔｅＰｉｃｋｅｒ　与　ＴｉｍｅＰｉｃｋｅｒ　是直接　显示在屏幕画面上，　ＤａｔｅＰｉｃｋｅｒＤｉａｌｏｇ　与　ＴｉｍｅＰｉｃｋｅｒＤｉａｌｏｇ　对象则是以跳出　Ｄｉａｌｏｇ　的方式　而　来显示，如下图所示。　　　　▲图　４－１６

　　　　ＤａｔｅＰｉｃｋｅｒＤｉａｌｏｇ　与　ＴｉｍｅＰｉｃｋｅｒＤｉａｌｏｇ

　　　　ＤａｔｅＰｉｃｋｅｒＤｉａｌｏｇ　与　ＴｉｍｅＰｉｃｋｅｒＤｉａｌｏｇ　的实现方式又为何？以下提供简单的

ｐａｇｅ　３６

范例供各位　参考：

　　　　／＊　取得更改日期的　Ｂｕｔｔｏｎ，添加　ｏｎＣｌｉｃｋＬｉｓｔｅｎｅｒ　＊／　Ｂｕｔｔｏｎ　ｄＢｕｔｔｏｎ＝（Ｂｕｔｔｏｎ）ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｄＰｉｃｋｅｒ）；　ｄＢｕｔｔｏｎ．ｓｅｔＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（ｎｅｗ　Ｖｉｅｗ．ＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（）　｛　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｌｉｃｋ（Ｖｉｅｗ　ｖ）　｛　／＊　ｏｎＣｌｉｃｋ　时跳出　ＤａｔｅＰｉｃｋｅｒＤｉａｌｏｇ　＊／　ｎｅｗ　ＤａｔｅＰｉｃｋｅｒＤｉａｌｏｇ（ＥＸ０４＿１５＿１．ｔｈｉｓ，　ｎｅｗ　ＤａｔｅＰｉｃｋｅｒＤｉａｌｏｇ．ＯｎＤａｔｅＳｅｔＬｉｓｔｅｎｅｒ（）　｛　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＤａｔｅＳｅｔ（ＤａｔｅＰｉｃｋｅｒ　ｖｉｅｗ，ｉｎｔ　ｙｅａｒ，　ｉｎｔ　ｍｏｎｔｈＯｆＹｅａｒ，ｉｎｔ　ｄａｙＯｆＭｏｎｔｈ）　｛　／＊　这里放更新日期的方法　＊／　｝　｝，ｍＹｅａｒ，ｍＭｏｎｔｈ，ｍＤａｙ）．ｓｈｏｗ（）；　｝　｝）；

　　　　／＊　取得更改时间的　Ｂｕｔｔｏｎ，添加　ｏｎＣｌｉｃｋＬｉｓｔｅｎｅｒ　＊／　Ｂｕｔｔｏｎ　ｔＢｕｔｔｏｎ＝（Ｂｕｔｔｏｎ）ｆｉｎｄＶｉｅｗＢｙＩｄ（Ｒ．ｉｄ．ｔＰｉｃｋｅｒ）；　ｔＢｕｔｔｏｎ．ｓｅｔＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（ｎｅｗ　Ｖｉｅｗ．ＯｎＣｌｉｃｋＬｉｓｔｅｎｅｒ（）

　　　　｛　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＣｌｉｃｋ（Ｖｉｅｗ　ｖ）　｛　／＊　ｏｎＣｌｉｃｋ　时跳出　ＴｉｍｅＰｉｃｋｅｒＤｉａｌｏｇ　＊／　ｎｅｗ　ＴｉｍｅＰｉｃｋｅｒＤｉａｌｏｇ（ＥＸ０４＿１５＿１．ｔｈｉｓ，　ｎｅｗ　ＴｉｍｅＰｉｃｋｅｒＤｉａｌｏｇ．ＯｎＴｉｍｅＳｅｔＬｉｓｔｅｎｅｒ（）　｛　ｐｕｂｌｉｃ　ｖｏｉｄ　ｏｎＴｉｍｅＳｅｔ（ＴｉｍｅＰｉｃｋｅｒ　ｖｉｅｗ，ｉｎｔ　ｈｏｕｒＯｆＤａｙ，　ｉｎｔ　ｍｉｎｕｔｅ）　｛　／＊　这里放更新时间的方法　＊／　｝　｝，ｍＨｏｕｒ，ｍＭｉｎｕｔｅ，ｔｒｕｅ）．ｓｈｏｗ（）；　｝　｝）；

　　　　不论是　ＤａｔｅＰｉｃｋｅｒ、ＴｉｍｅＰｉｃｋｅｒ，或　ＤａｔｅＰｉｃｋｅｒＤｉａｌｏｇ、ＴｉｍｅＰｉｃｋｅｒＤｉａｌｏｇ，都可以实现动　态更改日期时间的功能，要用哪一种方式来实现，端视各位的应用程序需要啰！

ｐａｇｅ　３７