基于安卓平台的飞机大战游戏毕业论文设计

基于安卓平台的飞机大战游戏

 

摘 要

 

自从第一台计算机研发以来，计算机行业得到了迅速的发展，成就了很多优秀的企业，例如国外的IBM,微软，GOOGLE,ARM,苹果等，国内的腾讯，阿里巴巴，百度等，而引领计算机行业的主要因素除了硬件的支撑外，就数操作系统了，而操作系统从Dos,UNIX，LINUX Windows等PC端正在逐渐向移动端转变如：从Linux到Android;从Unix到IOS;从Windows到Windows phone,主要还是因为移动端的便携性，轻巧性深受人们的喜爱，就在这样的移动互联网浪潮中，Android系统更是高达移动端操作系统80%的占有率，真可谓前景无限，而在Android平台的应用中游戏业务又占着最大的比例，所以本次选题为基于Android的飞机大战游戏，其主要目的研究移动互联网的发展趋势，对其未来的发展有深刻清晰的认识。

本论文主要阐述以面向对象的程序开发语言Java及Eclipse为开发工具，而基于智能手机Android系统之上的飞机大战游戏。首先简要介绍课题的研究背景、目的及意义，Android的发展历程、当前国内外的发展现状。然后介绍了Android平台开发环境及环境搭建，最后讲述了基于Android飞机大战游戏功能的实现。其功能模块如下：提供敌机的类模块，提供子弹的类模块，主界面模块，天空背景模块，检测子弹与敌机碰撞模块，检测，敌机与我拥有的战机碰撞木块等，除此以外还为用户提供更加人性化的设计和方便人员的操作流程。由于Android逐渐成为智能手机技术的主导，相信其基于Android的飞机大战游戏将会受到更大的欢迎。

 

关键字： 安卓，游戏，飞行射击，飞机

 

 

 

 

 

 

ABSTRACT

 

 

Since the first computer researched and development , the computer industry has been rapid development , that made a lot of excellent enterprise , such as : IBM , Microsoft ,  Google , ARM , Apple inc In a foreign country ; Tencent , Alibaba Group , Baidu In the domestic . Led by the computer industry in addition to hardware support, the main factors for operating system . And the operating system from Dos, UNIX, LINUX, Windows PC correct is gradually to mobile terminal such as: LINUX - > Android. Unix - > IOS; Windows - > Windows phone, mostly because the mobile end portability, and was deeply loved by people, in this kind of mobile Internet, in the tide of the Android system is as high as 80% of mobile terminal operating system share, really unlimited prospects, and in the application of the Android platform game business accounts for the largest proportion, so this topic is based on the Android plane war game, the development trend of mobile Internet, the main objective for its future development are clear understanding.

This thesis mainly expounds Java with object oriented programming language and Eclipse as the development tool, and the plane based on the intelligent mobile phone Android war games. First briefly introduced the research background, purpose and significance, the development of Android, the current domestic and foreign development present situation. And then introduced the Android platform development environment and the environment, finally tells the story of the realization of the function of Android plane war games. Its function module is as follows: enemy planes flying in and out of class module, provides the bullet class module, main interface module, the sky background module, detect bullet collision with the enemy aircraft module, detection, the enemy aircraft crash with my own wood, etc., in addition also provides users with more humanized design and convenient operation. Because the Android smartphone technology has become the dominant gradually, believe that the plane war game based on Android will be more welcome.

 

KEY WORDS: Android, Game,Flight shooter,Airplane

目  录

 

 

第1章  绪论 1

1.1 系统研究的背景及意义 1

1.2 国内外的发展现状 1

1.3 主要研究的内容 1

1.4 本文的组织结构 1

1.5 本章小结 2

1. 4

2.1系统的架构描述 4

2.2 友好的用户界面 6

2.3技术选型 7

2.4系统的开发环境 7

2.5 关键技术和工具简介 8

2.6 本章小节 9

1. 11

3.1 模块的划分 11

3.1.1 软件模块设计 11

3.1.2 软件功能模块 13

3.2 主界面设计 15

3.3 游戏界面设计 16

3.4 系统包及其资源规划 16

3.4.1 系统包管理如下 17

3.4.2 Sqlite数据库 17

3.4.3 Runable接口以及与Thread的区别 19

3.5 本章小结 22

1. 24

4.1 主界面的功能实现 24

4.1 游戏界面的功能实现 28

4.3 子弹类的设计 38

4.3 敌机类的设计 39

4.5本章小结 40

第5章  系统测试 41

5.1 软件测试的概念 41

5.2 系统的功能和安全测试 41

5.3 测试总结 44

第6章  总结 45

致 谢 46

参考文献 47

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

第1章  绪论

1.1 系统研究的背景及意义

在手机游戏的早期，大多数开发者都是想要玩转设备、学习技巧和快速攻关的狂热分子。但是，随着更多的开发者加入这个行业，手机游戏已经进化成涉及到专业设计师、构造师、开发者、产品经销商、律师、和艺术家在内的主导产品。这是行业走向成熟的必然趋势。尽管在某人的业余时间内要开发和推销简单的游戏更加困难，但是更多的专业商店将为许多人提供更多的就业机会。
    从手机软件的平台的种类，游戏玩家的心理，未来移动通信服务终端的发展，3G手机网络对手机软件游戏的影响，还有从J2ME手机游戏开发平台介绍的手机游戏的趋势和未来这种游戏的运营模式，这几方面的内容来看，手机游戏是未来游戏发展的趋势，其移动性、互连性，必定会带来网络游戏的风暴，这就使我们对这一个新兴的领域有了一定的概念，对指导我们建立一个手机软件开发培训的知识结构有一定的帮助，也是我们的一个发展契机。

本文基于Android系统设计一种轻松休闲的游戏软件，让用户可以使用手机轻松娱乐，因此项目研究和软件开发具有重要的实际应用价值。

1.2 国内外的发展现状

手机游戏(Mobile Game或Wireless Game)，是指消费者利用随身携带并具有无线网络联机功能的智能移动终端设备，能随时随地来进行的游戏。手机游戏最大的特点是其随时随地进行游戏的便利性。这些年来，手机游戏市场有了很大的发展，手机游戏已成为使用率最高的手机娱乐应用，占到各种手机娱乐应用比例的78.4%。在日本，手机游戏市场经历多年的稳定增长，市场规模已经超过了850 亿日元[1]。在美国，手机游戏作为美国手机用户最喜欢的移动应用之一，在iPhone和Android等智能终端推出后发展迅速。而在中国，根据易观智库产业数据库最新发布的《2010 年第4 季度中国手机游戏市场季度监测》数据显示，我国2010 年手机游戏市场规模已达到32.9 亿元，继续保持了较快的发展。

2011年以来Android实现了计算机诞生以来最快速度的增长，目前Android以每天85万新增激活数的速度快速征服世界，成为世界范围内占有率最高的智能手机操作系统。根据comScore的统计，2012年第一季度Android在北美的市场占有率又增长了3.7%达到51%；而根据赛诺的调研报告，Android系统在中国

的市场份额高达74.7%，而Android游戏在诞生之处就被很多人看好，便宜的价格，小巧的外观，游戏资源丰富，相对于传统主机来说，这些都是Android游戏机的优点，于是一批Android游戏陆续出现了，但事实证明Android游戏并非当初描绘的那样美好，开放的Android开发平台，导致了游戏质量和数量不那么尽如人意，所以在游戏的设计与研发过程中游戏的质量关一定要把好。

1.3 主要研究的内容

本设计项目主要完成一种基于Android开发的一款游戏软件。项目研究和软件设计遵循软件工程的方法，从需求分析，系统分析，概要设计，详细设计，软件编码调试，到验证测试，完成本软件整个过程的设计开发。项目研究和软件设计的具体任务包括：

（1）加深面向对象编程思想，巩固Java语言的设计模式，掌握Android开发的环境搭建。

（2）学习和研究Android平台环境和软件接口的设计。

（3）学习和研究Android平台多线程。

（4）学习和研究Android系统中用户界面的动态显示。

（5）学习并掌握Sqlite数据库。

（6）学习并掌握Android平台下动态游戏开发的重要知识点：SurfaceView。

1.4 本文的组织结构

第1章 绪论 本章主要介绍了课题的研究背景，课题研究的目的与意义，以及该项目所在领域国内外发展状况等，最后指出了本文工作内容及论文的组织结构。

第2章 软件需求分析和技术介绍 本章主要介绍了本系统的技术构架及课题的需求分析与说明，简单的介绍了项目应用的平台和开发环境，并解析了关键技术的含义。

第3章 系统概要设计 本章是本文比较重要的章节，详细的划分了整个项目的开发模块，及各个模块的功能设计，最后对整个项目的包结构和项目资源路径做了简单的剖析和介绍。

第4章 系统功能的实现 详细介绍开发流程，从建一个Android项目开始到最终完成软件开发的详细过程，介绍怎样检测飞机碰撞事件，怎样动态管理界面，怎样实现飞机飞行的效果。

第5章 系统测试 详细介绍了测试的概念、目的和方法，并介绍如何利用Android自带的测试工具了系统测试。

第6章 总结。

1.5 本章小结

详细介绍了Android游戏开发的国内外现状，以及本论文主要研究的方向和论文的整体结构，从本章中能够清楚的了解本论文的整体架构，对以后的各细节描述都有清晰的认识。

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

1. 2. 用户需求分析

2.1系统的架构描述

本项目主要面向游戏爱好者，要求项目不会占用太大的资源，并能够尽量沿用原有的相对成熟的java技术，与Android系统进行良好的整合。本设计主要讲述了飞机大战游戏的基本功能和基于Android平台的软件开发、接口的设计方法。设计最终达成了开始游戏、关闭音效、查看得分、退出游戏等Android游戏的基本功能。并且系统能够正常运行，各个页面交互性较好。在整个设计中基本运用基础的Android进行功能编程，其中主要利用了SurfaceView实现了动态界面显示，实现了飞机飞行和发射子弹等效果。在系统规划中先后系统功能结构图分析了系统所需的各种数据，详细的展现了系统的各个功能模块并给出了主要功能运行界面图。该游戏软件目前已有比较完善的管理与使用功能。对学习和工作中的学生和工作人员在闲暇时间放松的好软件。

本系统主要采用模型-视图-控制器MVC架构的设计模式。MVC架构是"Model-View-Controller"的缩写，中文翻译为"模型-视图-控制器"。MVC应用程序总是由这三个部分组成。Event(事件)导致Controller改变Model或View，或者同时改变两者。只要Controller改变了Models的数据或者属性，所有依赖的View都会自动更新。类似的，只要Controller改变了View，View会从潜在的Model中获取数据来刷新自己。整个系统的物理架构如下：界面SurfaceVIe，模型为常用的子弹飞机类，Controller为SurfaceHolder.callback结构中的回调函数。本系统是应用Android平台，Android是一个移动设备的软件平台，由Linux+Java构成的开源软件，提供包括SDK、Key Apps、Middleware、Linux Kernel四个部分在内的全套手机软件方案。开放了基于Linux内核以上的开发工具，从而保证了内容的可移植性和多样性。Android平台为我们开发应用程序提供了一套很好的框架，我们可以在这个平台的基础上开发不同的应用程序，也可以开发新的组件供应用程序调用。Android会同一系列核心应用程序包一起发布，该应用程序包包括email客户端，SMS短消息程，日历，地图，浏览器，联系人管理程序等。所有的应用程序都是使用JAVA语言编写的，本项目也是由java语言编写。开发人员也可以完全访问核心应用程序所使用的API框架。该应用程序的架构设计简化了组件的重用。任何一个应用程序都可以发布它的功能块并且任何其它的应用程序都可以使用其所发布的功能块(不过得遵循框架的安全性限制)。同样，该应用程序重用机制也使用户可以方便的替换程序组件。Android系统架构图如2-1图所示。

 

图2-1 android系统架构图

2.2 友好的用户界面

本游戏是直接面对用户的， 要求游戏能够提供良好的用户接口，易用的人机交互界面。要实现这一点，就要求软件应该尽量使用用户熟悉的术语和提示消息；针对用户可能出现的使用问题，要提供足够的提醒帮助功能，缩短用户对软件熟悉的过程。本项目采用Android平台，从Android的角度分析，Android的开发概括为两类：一是系统开发，包括底层Linux内核的裁剪和扩展、硬件驱动的开发和系统移植等，从业人员主要在工作在硬件厂商的公司里。二是应用开发，主要包括游戏开发、Android互联网客户端开发和工具软件开发。业内人士预言Android系统将成为手机操作系统领域的“windows”。一个好的功能强大系统，必须要进行完善而且全面的系统分析和友好设计。本项目中，之所以能够有计划地进行下去，的确也是缘于良好的系统分析，如若省略这一步直接编程，那难度必然加大，以至于在编程过程中又不得不回过头来进行系统分析，此时必然拖慢进度，打乱整个系统逻辑，其最终的成品也充满变数。本系统在性能功能上应达到如下需求：

1. (1)操作简单、界面友好: 完全控件式的页面布局。
2. (2)游戏的安全性，正在游戏中对可能发生的突发事件做出处理，例如，电话来了，或者有信息等。
3. (3)软件的响应速度要快，保证用户不会应为等待反馈时间过长而放弃本软件。
4. (4)软件的可靠性，能够真正的带给游戏者乐趣。

(5) 在结构上应具有很好的可扩展性，便于将来的功能扩展和维护。

根据以上功能，该系统主要以Android为操作平台，它提供了很大的自由空间，采用Java为开发语言，使系统开发更加方便快捷，本软件的目标即为成功、完整的体现该系统，让客户满意。

2.3技术选型

项目整体技术选型是这样的，飞机大战游戏开发过程中应用了java技术和Android SDK提供的类库，动态界面采用SurfaceView和一些XML文件-，后台控制使用了SurfaceHolder.callback接口的回调方法。常用的资源文件如子弹，和敌机，战机，背景图都通过ps自己处理，系统开始时就启动新线程，一直运行游戏，知道用户关闭为止。如下为整体流程图如下图2-2所示。

 

2.4系统的开发环境

2.4.1开发硬件要求

硬件平台：PIV CPU，主频2.8G，内存2G，的PC机或PC服务器。

操作系统：Microsoft Windows7

2.4.2系统的软件开发环境

集成开发环境：Eclipse3.6+JDK6.0+SDK2.1

数据库：MySQL5.0

编程语言：java

   开发模式：MVC模式 

 

   

                                      surfaceCreated

                R.java                         回调方法

    

  

 

 

  

 

 

 

图2-2  技术选型模型图

2.5 关键技术和工具简介

（1）Intent Intent负责对应用中一次操作的动作、动作涉及数据、附加数据进行描述，Android则根据此Intent的描述，负责找到对应的组件，将 Intent传递给调用的组件，并完成组件的调用。因此，Intent在这里起着一个媒体中介的作用，专门提供组件互相调用的相关信息，实现调用者与被调用者之间的解耦。

（2）ADT与SDK ADT为Android开发工具（Android Development Tools）简称，是在强大的、集成的环境Eclipse IDE中构建Android应用程序插件。ADT扩展了Eclipse的功能，让您快速建立新的Android项目，创建一个应用程序的用户界面，加上Android框架的API组件、调试应用程序使用Android SDK工具，以便APK分发给应用程序。SDK即Software Development Kit 的缩写，中文即“软件开发工具包”。广义上指辅助开发某一类软件的相关文档、范例和工具的集合。它可以简单的为某个程序设计语言提供应用程序接口 API的一些文件，但也可能包括能与某种嵌入式系统通讯的复杂的硬件。 

（3）SQLite数据库  SQLite是一款轻型的数据库，是遵守ACID的关系型数据库管理系统，它的设计目标是嵌入式的，而且目前已经在很多嵌入式产品中使用了它，它占用资源非常的低，在嵌入式设备中，可能只需要几百K的内存就够了。它能够支持Windows/Linux/Unix等等主流的操作系统，同时能够跟很多程序语言相结合，比如 Tcl、C#、PHP、Java等，还有ODBC接口，同样比起Mysql、PostgreSQL这两款开源世界著名的数据库管理系统来讲，它的处理速度比他们都快。SQLite第一个Alpha版本诞生于2000年5月。 至今已经有14个年头，SQLite也迎来了一个版本 SQLite 3已经发布。

（4）Activity   Activity是Android开发中非常重要的一个基础类。Activity提供了和用户交互的可视化界面，创建一个Activity一般是继承Activity类，并覆盖Activity的onCreate()方法。

（5）Eclipse与JDK  Eclipse是一个集成开发环境简称“IDE”，在Eclipse环境下开发JAVA程序可以大大提高效率，它提供的核心框架和可扩展的插件机制给广大的程序员提供了无限的便捷。JDK(Java Development Kit)是Sun Microsystems针对Java开发人员的产品，JDK 是整个Java的核心，包括了Java运行环境，Java工具和Java基础的类库。JDK是学好Java的第一步。

（6）SurfaceView  SurfaceView由于可以直接从内存或者DMA等硬件接口取得图像数据，因此是个非常重要的绘图容器，这次我就用两篇文章来介绍SurfaceView的用法。网上介绍SurfaceView的用法有很多，写法也层出不同，例如继承SurfaceView类，或者继承SurfaceHolder.Callback类等，这个可以根据功能实际需要自己选择，我这里就直接在普通的用户界面调用SurfaceHolder的lockCanvas和unlockCanvasAndPost。

2.6 本章小节

本章主要介绍了本系统的技术构架及在实际开发中的用户需求分析，简单的介绍了项目应用的平台和开发环境，并介绍了关键技术的含义。

 

 

 

 

 

 

3. 系统概要设计

系统的概要设计主要是针对系统的总体功能如何设计，如何划分模块，系统的数据库如何设计进行研究。它为系统的详细设计做铺垫。在系统的设计过程中起着非常重要的作用。系统设计是信息开发过程中的另一个重要阶段，在这一阶段中将根据前一阶段逻辑分析的结果，在系统分析报告的基础上，按照逻辑模型的要求，科学合理地进行新系统的设计。系统设计包含两个方面：首先是总体结构设计，其次是具体物理模型的设计。这个阶段的主要目标是将反映用户信息需求的系统逻辑方案转换成可以实施的基于计算机的物理方案，并为下一阶段的系统实施提供必要的技术资料。

本系统采用结构化设计的方法来实现系统总体功能，提高系统的各项指标，即将整个系统合理的划分成各个功能模块，正确地处理模块之间和模块内部的联系以及它们之间的调用关系和数据联系，定义各模块的内部结构，通过对模块的设计和模块之间关系的系统来实现整个系统的功能。

3.1 模块的划分

本系统整体划分为三个模块，分别为主界面，即Android游戏软件登录界面，游戏模块，游戏运行中的界面模块，用来处理用户触摸响应，还有得分统计模块，用来存储获的分数。

3.1.1 软件模块设计

用户界面是使用者最直接接触的东西，包括是否能够让客户很轻松、方便的使用，操作响应时间、主机连接时间、图片综合质量、首页布局质量、首页信息类型等。

一般来说，一个界面主要由下面几个因素构成：

(1)文字：文字元素是信息传达的主体部分。界面中的文字主要包括标题、信息、文字链接几种主要形式。标题和传统媒体中信息传达的基本作用相同，是内容的简概说明，一般比较醒目、优先编排。文字作为占据页面重要比率的元素，同时又是信息重要载体，它的字体、大小、颜色和排布对页面整体设计影响极大。

(2)图形：图形在界面中具有重要作用。合理的运用图形，可以生动直观、形象地表现设计主题。网页中常用的图形格式包括jpg和png，这两种格式压缩比高，得到了Android平台的支持，图形元素包括标题、背景、主图、链接图标四种。

(3)界面版式：版式是界面设计的重要组成部分，它将文字、图形等视觉元素进行组合配置，使页面整体视觉效果美观和谐，便于阅读，操作，实现信息传达的最佳效果。 

Android游戏系统的界面设计也是综合了文字，图形等元素。使每一个功能有文字与图片的共同描述，达到看图就大概知道此键是什么功能的目的，最终的目的还是为了使用者能够快速上手，不至于因为操作的不得当而放弃此系统。

3.1.2 软件功能模块

 

 图3-1  整体结构图

 

1. A)游戏模块：负责游戏运行的主线程，在一个Android 程序开始运行的时候，

会单独启动一个Process。默认的情况下，所有这个程序中的Activity或者Service（Service和 Activity只是Android提供的Components中的两种，除此之外还有Content Provider和Broadcast Receiver）都会跑在这个Process。  一个Android 程序默认情况下也只有一个Process，但一个Process下却可以有许多个Thread。在这么多Thread当中，有一个Thread，我们称之为UI Thread。UI Thread在Android程序运行的时候就被创建，是一个Process当中的主线程Main Thread，主要是负责控制UI界面的显示、更新和控件交互。在Android程序创建之初，一个Process呈现的是单线程模型，所有的任务都在一 个线程中运行。因此，我们认为，UI Thread所执行的每一个函数，所花费的时间都应该是越短越好。而其他比较费时的工作（访问网络，下载数据，查询数据库等），都应该交由子线程去执行， 以免阻塞主线程。那么，UI Thread如何和其他Thread一起工作呢？常用方法是：诞生一个主线程的Handler物件，当做Listener去让子线程能将讯息Push到主线程的Message Quene里，以便触发主线程的handlerMessage（）函数，让主线程知道子线程的状态，并在主线程更新UI。

B)页面布局模块（图形模块）：虽然有的游戏不需要不断的重新绘制屏幕，但是假设你想要的游戏需要不间断的绘制屏幕，这是个简单的概念并且你不需要去关注任何脏标记或者去关注在某些游戏状态改变的情况下重新绘制屏幕。我们已经知道UI线程不是一直不间断的运行的，而是在事件的驱动下有操作系统调度运行的。这就是我们为什么实例化第二个线程，也就是我们通常说的渲染线程，这个线程是由Graphics模块所创建，Graphics模块本身由应用模块在程序启动的时候实例化。渲染线程执行一个无限循环，由于应用程序的生命周期事件，它可能会被暂停或者恢复。作为开发者，你可以通过注册一个RenderListerner将这个线程与图形模块连接起来.在我们进入这些方法的详解之前，我先给你介绍一些细节：libgdx使用OpenGl ES，这个是移动设备上硬件加速图像渲染的工业标准。OpenGL ES同一个叫做EGL的东西一起使用，EGL负责设立一个窗口系统和图像硬件的链接，它创建一个渲染表面，用户可以添加一个用户界面组件到上面，图形硬件可以不通过使用UI工具包直接渲染。OpenGL ES自身额外的添加了一个叫做图形上下文的东西，他用于管理驻留在显存中的图形资源，举个例子：这些资源可以是一个纹理，它从本质上来说就是一张位图，OpenGLES将其建立在EGL的表面和背景，通过图形处理处理器获得高质量的图片。

C)游戏配置模块：对于音效的管理。

D)游戏介绍模块：游戏有智力游戏和活动性游戏之分，前者如下棋、积木、打牌等，后者如追逐、接力及利用球、棒、绳等器材进行的活动，多为集体活动，并有情节和规则，具有竞赛性。当前日常用语中的“游戏”多指各种平台上的电子游戏。电子游戏有单机版和网络游戏。

3.2 主界面设计

 

 

 

 

 

 

 

   

 

 

 

 

 

 

 

 

 

 

 

图3-2 主界面设计图

 

1. A)开始游戏：其中一个Activity，在其调用SetContentView()时，调用我们自己定义的游戏界面，该游戏界面使我们自己通过一个类实现的游戏界面，在该类中继承了SurfaceView，并实现了SurfaceHolder.callBack接口和runnable接口，在该类的回调函数surfaceCreated()中启动游戏线程并一直进行游戏直到出现失误时就关闭该线程。
2. B)退出游戏，关闭该应用，当我们玩游戏时，想休息会或者想退出游戏时点击该按钮，退出游戏
3. C)音效管理：可以管理在玩游戏时对背景音乐的管理
4. D)描述该软件的开发时间，开发人员和本软件的一些基本信息介绍。

 

3.3 游戏界面设计

采用分层管理，具体效果如3-3图所示：

 

图3-3 游戏界面图

3.4 系统包及其资源规划

在软件项目管理过程中一个关键的活动是制定项目计划，它是软件开发工作的第一步。 项目计划的目标是为项目负责人提供一个框架，使之能合理地估算软件项目开发所需的资源 、经费和开发进度，并控制软件项目开发过程按此计划进行。 在做计划时，必须就需要的人力、项目持续时间及成本作出估算。这种估算大多是参考 以前的花费作出的。软件项目计划包括二个任务：研究和估算。即通过研究确定该软件 项目的主要功能、性能和系统界面。

3.4.1 系统包管理如下

本游戏采用Eclipse中开发Android项目的默认框架，采用Eclipse开发的框架图如图3-4结构所示

 

图3-4 项目资源包管理

 

3.4.2 Sqlite数据库

SQLite数据库是一款轻型的数据库，它嵌入在Android系统中，由于没有数据库操作的图形界面和客户端，所以我们只能通过命令进入Android系统中，进行数据库的操作。Android给我们提供了一系列系统工具可以访问SQLite数据库。Android Debug Bridge（ADB）是Android的一个通用调试工具，它可以更新设备或模拟器中的代码，可以管理预定端口，可以在设备上运行shell命令，我们知道android是基于Linux内核，它的内部文件结构也是采用Linux文件组织方式，因此访问它的文件结构需要使用shell。这次我们就会用shell来访问android应用中的SQLite数据库文件。

1、运行cmd，切换到android-sdk目录，运行adb.exe，加上参数shell，出现#号就代表进入了shell命令模式，注意adb要在Android模拟器运行时才能进入shell。执行如下图3-5所示。

 

 

图3-5  进入shell命令模式

2、shell命令记住两个基本命令ls和cd，类似windows命令提示行中的dir和cd，代表列出当前目录下文件列表和进入到指定目录。了解这两个命令之后，就可以找到data/data/项目包名/databases。找到数据库文件，接下来就是使用sqlite管理工具来进行操作了。键入sqlite3+数据库名就进入了sqlite管理模式了。执行过程如下图3-6所示。

 

图3-6  进入sqlite管理模式

3.4.3 Runable接口以及与Thread的区别

在java中可有两种方式实现多线程，一种是继承Thread类，一种是实现Runnable接口；Thread类是在java.lang包中定义的。一个类只要继承了Thread类同时覆写了本类中的run()方法就可以实现多线程操作了，但是一个类只能继承一个父类，这是此方法的局限。

下面看例子：

package org.thread.demo;  

class MyThread extends Thread{  

private String name;  

public MyThread(String name) {  

super();  

this.name = name;  

}  

public void run(){  

for(int i=0;i<10;i++){  

System.out.println("线程开始："+this.name+",i="+i);  

}  

}  

}  

package org.thread.demo;  

public class ThreadDemo01 {  

public static void main(String[] args) {  

MyThread mt1=new MyThread("线程a");  

MyThread mt2=new MyThread("线程b");  

mt1.run();  

mt2.run();  

}  

} 

但是，此时结果很有规律，先第一个对象执行，然后第二个对象执行，并没有相互运行。在JDK的文档中可以发现，一旦调用start()方法，则会通过JVM找到run()方法。下面启动start()方法启动线程：

package org.thread.demo;  

public class ThreadDemo01 {  

public static void main(String[] args) {  

MyThread mt1=new MyThread("线程a");  

MyThread mt2=new MyThread("线程b");  

mt1.start();  

mt2.start();  

}  

}; 

这样程序可以正常完成交互式运行。那么为啥非要使用start();方法启动多线程呢？

在JDK的安装路径下，src.zip是全部的java源程序，通过此代码找到Thread中的start()方法的定义，可以发现此方法中使用了private native void start0();其中native关键字表示可以调用操作系统的底层函数，那么这样的技术成为JNI技术（java Native Interface）

Runnable接口

在实际开发中一个多线程的操作很少使用Thread类，而是通过Runnable接口完成。

public interface Runnable{  

public void run();  

} 

例子：

package org.runnable.demo;  

class MyThread implements Runnable{  

private String name;  

public MyThread(String name) {  

this.name = name;  

}

public void run(){  

for(int i=0;i<100;i++){  

System.out.println("线程开始："+this.name+",i="+i);  

}  

}  

}; 

但是在使用Runnable定义的子类中没有start()方法，只有Thread类中才有。此时观察Thread类，有一个构造方法：public Thread(Runnable targer)此构造方法接受Runnable的子类实例，也就是说可以通过Thread类来启动Runnable实现的多线程。（start()可以协调系统的资源）：

package org.runnable.demo;  

import org.runnable.demo.MyThread;  

public class ThreadDemo01 {  

public static void main(String[] args) {  

MyThread mt1=new MyThread("线程a");  

MyThread mt2=new MyThread("线程b");  

new Thread(mt1).start();  

new Thread(mt2).start();  

}  

} 

两种实现方式的区别和联系：

在程序开发中只要是多线程肯定永远以实现Runnable接口为主，因为实现Runnable接口相比继承Thread类有如下好处：

避免点继承的局限，一个类可以继承多个接口。

适合于资源的共享

以卖票程序为例，通过Thread类完成：

package org.demo.dff;  

class MyThread extends Thread{  

private int ticket=10;  

public void run(){  

for(int i=0;i<20;i++){  

if(this.ticket>0){  

System.out.println("卖票：ticket"+this.ticket--);  

}  

}  

}  

}; 

下面通过三个线程对象，同时卖票：

package org.demo.dff;  

public class ThreadTicket {  

public static void main(String[] args) {  

MyThread mt1=new MyThread();  

MyThread mt2=new MyThread();  

MyThread mt3=new MyThread();  

mt1.start();//每个线程都各卖了10张，共卖了30张票  

mt2.start();//但实际只有10张票，每个线程都卖自己的票  

mt3.start();//没有达到资源共享  

}  

} 

如果用Runnable就可以实现资源共享，下面看例子：

package org.demo.runnable;  

class MyThread implements Runnable{  

private int ticket=10;  

public void run(){  

for(int i=0;i<20;i++){  

if(this.ticket>0){  

System.out.println("卖票：ticket"+this.ticket--);  

}  

}  

}  

}  

package org.demo.runnable;  

public class RunnableTicket {  

public static void main(String[] args) {  

MyThread mt=new MyThread();  

new Thread(mt).start();//同一个mt，但是在Thread中就不可以，如果用同一  

new Thread(mt).start();//个实例化对象mt，就会出现异常  

new Thread(mt).start();  

}  

}; 

虽然现在程序中有三个线程，但是一共卖了10张票，也就是说使用Runnable实现多线程可以达到资源共享目的。

Runnable接口和Thread之间的联系：

public class Thread extends Object implements Runnable

发现Thread类也是Runnable接口的子类。

3.5 本章小结

本章详细的划分了整个项目的开发模块，及各个模块的详细设计，最后对整个项目的包结构和项目资源路径做了简单的剖析和介绍。

 

 

 

 

 

 

 

 

 

1. 4. 系统功能的实现

界面是呈现给用户的，一个界面呈现的友好性会决定用户是否会接受该系统，对于Android系统而言，界面的友好布局，信息的简单明了都至关重要。

4.1 主界面的功能实现

主界面的设计如下图4-1所示：

 

 

图4-1  系统主界面

 

在工程的res\layout目录下，创建了一个名称为”activity_main.xml”的

布局文件，该文件主要为生成主界面做配置，其布局文件代码如下：

1. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
2.     xmlns:tools="http://schemas.android.com/tools"
3.     android:layout_width="match_parent"
4.     android:layout_height="match_parent"
5.     android:background="@drawable/ba1"

1.     android:gravity="center_horizontal"
2.     android:orientation="vertical"
3.     android:paddingBottom="@dimen/activity_vertical_margin"
4.     android:paddingLeft="@dimen/activity_horizontal_margin"
5.     android:paddingRight="@dimen/activity_horizontal_margin"
6.     android:paddingTop="@dimen/activity_vertical_margin"
7.     tools:context=".MainActivity" >
8.     <ImageButton
9.         android:id="@+id/start"
10.         android:layout_width="156dip"
11.         android:layout_height="50dip"
12.         android:layout_marginTop="130dip"
13.         android:src="@drawable/startgame"
14.         android:background="@android:color/transparent"/>
15.     <ImageButton
16.         android:id="@+id/exit"
17.         android:layout_width="155dip"
18.         android:layout_height="50dip"
19.         android:layout_marginTop="10dip"
20.         android:src="@drawable/exitgame"
21.         android:background="@android:color/transparent" />
22.     <ImageButton
23.         android:id="@+id/close"
24.         android:layout_width="155dip"
25.         android:layout_height="50dip"
26.         android:layout_marginTop="10dip"
27.         android:src="@drawable/soundbut"
28.         android:background="@android:color/transparent" />
29.     <ImageButton
30.         android:id="@+id/about"
31.         android:layout_width="155dip"
32.         android:layout_height="50dip"
33.         android:layout_marginTop="10dip"
34.         android:src="@drawable/aboutour"
35.         android:background="@android:color/transparent" />
36. </LinearLayout>

                       主界面布局文件

主界面中有四个按钮分别为开始游戏，退出游戏，关闭音效，关于我们，其中每个按钮都绑定了一个监视器，当按下该按钮时，该监视器将触发点击事件，其中为开始按钮绑定的监视器如下:

1. 1.public class listener implements View.OnClickListener{
2. @Override
3. public void onClick(View v) {
4. intent=new Intent(this,viewActivity.class);
5. startActivity(intent);
6. }
7. 7.}

Intent对象介绍：

Intent（意图）主要是解决Android应用的各项组件之间的通讯。

Intent负责对应用中一次操作的动作、动作涉及数据、附加数据进行描述，Android则根据此Intent的描述，负责找到对应的组件，将 Intent传递给调用的组件，并完成组件的调用。因此，Intent在这里起着一个媒体中介的作用，专门提供组件互相调用的相关信息，实现调用者与被调用者之间的解耦。

例如，在一个联系人维护的应用中，当我们在一个联系人列表屏幕(假设对应的Activity为listActivity)上，点击某个联系人后，希望能够跳出此联系人的详细信息屏幕(假设对应的Activity为detailActivity)

为了实现这个目的，listActivity需要构造一个 Intent，这个Intent用于告诉系统，我们要做“查看”动作，此动作对应的查看对象是“某联系人”，然后调用startActivity (Intent intent)，将构造的Intent传入，系统会根据此Intent中的描述，到ManiFest中找到满足此Intent要求的Activity，系统会调用找到的 Activity，即为detailActivity，最终传入Intent，detailActivity则会根据此Intent中的描述，执行相应的操作。

其中startActivity(intent)将启动一个新的意图对象，代表一个新的Activity;在这里将启动游戏主Activity。

关闭音效的监视器如下：

1. public class close implements View.OnClickListener{
2. @Override
3. public void onClick(View v) {
4. if(parameter.getSoundflag()){
5. parameter.setSoundflag(false);
6. Toast.makeText(getApplicationContext(), "音效已近关闭", Toast.LENGTH_SHORT).show();
7. }else{
8. parameter.setSoundflag(true);
9. Toast.makeText(getApplicationContext(), "音效已近打开", Toast.LENGTH_SHORT).show();
10. }
11. }
12. }

在这里，我们通过配置文件的参数改变是否需要播放背景音乐，当有音乐时，点击时将会关闭音效，当没音效时，点击一下将会开启音效。其效果展示如下图

图4-2和图4-3所示：

    

图4-2 关闭音效界面 图4-3 打开音效界面

Toast 是一个 View 视图，快速的为用户显示少量的信息。 Toast 在应用程序上浮动显示信息给用户，它永远不会获得焦点，不影响用户的输入等操作，主要用于 一些帮助 / 提示。Toast是Android中用来显示显示信息的一种机制，和Dialog不一样的是，Toast是没有焦点的，而且Toast显示的时间有限，过一定的时间就会自动消失。

退出游戏按钮的监视器：

1. 1.public class listener1 implements View.OnClickListener{
2. @Override
3. public void onClick(View v) {
4. try{
5. MainActivity.this.finish();
6. } catch (Throwable e) {
7. // TODO 自动生成的 catch 块
8. e.printStackTrace();
9. }
10. }
11. }

其中finish()方法将关闭当前正在运行的Activity。

 

图4-4 关于我们的界面

关于我们按钮主要介绍了本软件的性质和软件编码者和其指导老师的简介，并标明了软件的版本号和开发的时间信息如图4-4所示，浏览全部的信息之后，用户可以点击返回主界面返回，或者使用手机自带的返回键返回到主界面。

关于我们按钮的监视器：

1. public class about implements View.OnClickListener{
2. @Override
3. public void onClick(View v) {
4. startActivity(aboutIntent);
5. }
6. }

在该点击事件里将启动管我们介绍的activity。

4.1 游戏界面的功能实现

实现的效果如下图图4-5所示：

 

图4-5 游戏运行界面

主界面的实现是通过SurfaceView实现的，SurfaceView继承自View，但它与View不同?View是在UI的主线程中更新画面，而SurfaceView是在一个新线程中更新画面。我们不可能写一个方法让主线程自己运动。View的特性决定了其不适合做动画，因为如果更新画面时间过长，那么主UI线程就会被正在画的函数阻塞。所以Android中通常用SurfaceView显示动画效果。

在对SurfaceView进行操作前Android为我们提供了一个十分好用的接口：SurfaceHolder.Callback接口。该接口中有三个抽象方法，这三个抽象方法是SurfaceView的三个生命周期： 

abstract void surfaceChanged(SurfaceHolder holder, int format, int w, int h)  

这个方法被回调，当SurfaceView界面发生改变时。

abstract void  surfaceCreated(SurfaceHolder holder)  

 这个方法被回调，当SurfaceView界面被创建时。

abstract void    surfaceDestroyed(SurfaceHolder holder)  

 这个方法被回调，当SurfaceView界面被销毁时。

控制SurfaceView的SurfaceHolder介绍

上一节的Surface概述中我曾经说过每一个Surface都有一个Canvas，而Surface自身控制自己的大小等等属性。但是Surface是如何控制自己的呢？在SurfaceView中一般通过使用SurfaceHolder类来控制Canvas在其surface上的操作。如何得到SurfaceHolder？其实很简单，在SurfaceView中提供了getHolder()方法。如果该surfaceView中还需要实现回调生命周期，那么holder还需要调用addCallback()方法为其添加回调声明周期。API如下：

abstract void  addCallback(SurfaceHolder.Callback callback)  

Add a Callback interface for this holder.  

SurfaceHolder中还有几个十分重要的方法：

lockCanvas()：该方法用于锁定画布，这样Surface中就可以指定back buffer中的画布是那一块了。之后就可以在画布上进行绘画，该方法的API如下：

abstract Canvas  lockCanvas()  

开始编辑像素在界面之上  

lockCanvas()方法是对整个Surface进行重绘，但是很多情况下，我们只需要对Surface的一小部分进行重画时，则使用lockCanvas(Rect dirty)更为明智。

lockCanvas(Rect dirty)通过其中的参数也可以看出，其只更新Rect部分的画面。API入下： 

abstract Canvas lockCanvas(Rect dirty)；   

以上两个方法是对Canvas进行锁定，当Canvas绘制完毕之后，Surface的front buffer就需要这个Surface进行显示。如果此时Canvas还在锁定状态，则Surface的front buffer将不能得到Canvas。所以此时应该在canvas绘画完毕之后，释放锁定。unlockCanvasAndPost(Canvas canvas)：用于释放出于锁定状态的Canvas。API如下：

Java代码  

abstract void unlockCanvasAndPost(Canvas canvas)；  

当完成在界面上的绘制时调用该方法解除画布锁定。

GameView的实现如下：

1. 1.package org.example.airplane;
2. 2.import java.io.InputStream;
3. 3.import java.util.Random;
4. 4.import android.app.Dialog;
5. 5.import android.content.Context;
6. 6.import android.content.Intent;
7. 7.import android.graphics.Bitmap;
8. 8.import android.graphics.BitmapFactory;
9. 9.import android.graphics.Canvas;
10. 10.import android.graphics.Color;
11. 11.import android.graphics.Paint;
12. 12.import android.view.MotionEvent;
13. 13.import android.view.SurfaceHolder;
14. 14.import android.view.SurfaceHolder.Callback;
15. 15.import android.view.SurfaceView;
16. 16.import android.widget.Toast;
17. {
18. //游戏结束的回调接口
19. public onEndOfGameInterface endinterface;
20. public static long grade=0; //屏幕宽和高
21. public int screenwidth=0;
22. public int screenheight=0;
23. //判断线程是否在运行
24. public boolean isrun=true;
25. //两张背景图的y坐标
26. public int y0=0;
27. public int y1=0;
28.  
29. //背景图
30. public Bitmap background=null;
31.  
32. //飞机坐标,飞机位图
33. public int airx=0;
34. public int airy=0;
35. public Bitmap myairplane=null;
36. //子弹
37. public  bullet Bullet[]=null;
38. public int bullet_maxnum=15;
39. public int index=0;
40. public int interval=100;
41. public long lasttime=0;
42. public Bitmap bitbullet[]=null;
43. */
44. //敌机
45. public Bitmap bitenemy[]=null;
46. public enemy Enemy[]=null;
47. public int enemy_maxnum=12;
48. //游戏线程
49. public Thread thread=null;
50. //画笔
51. public Paint paint=null;
52. public Paint paint1=null;
53. //画布常量
54. public Canvas canvas=null;
55. //为了得到一个画布，增加回调函数
56. public SurfaceHolder surfaceholder=null;
57.  
58. //上下文环境变量
59. public Context mcontext;
60. int bx,by,ex,ey;
61. public GameView(Context context) {
62. super(context);
63. }
64. public GameView(Context context,int width,int height) {
65. super(context);
66. //屏幕宽和高
67. screenwidth=width;
68. screenheight=height;
69. //画笔常量
70. paint=new Paint();
71. paint1=new Paint();
72. paint1.setTextSize(40);
73. paint1.setColor(Color.RED);
74. //环境变量
75. mcontext=context;
76. surfaceholder=getHolder();
77. surfaceholder.addCallback(this);
78. // TODO 自动生成的构造函数存根
79. init();
80. }
81. /**
82. * 读位图
83. * 
84. * @param context
85. * @param id
86. * @return
87. */
88. public void setOnEndOfGame(onEndOfGameInterface endInterface){
89. this.endinterface=endInterface;
90. }
91. public Bitmap readBitmap(Context context,int id)
92. {
93. BitmapFactory.Options opt=new BitmapFactory.Options();
94. opt.inPreferredConfig=Bitmap.Config.RGB_565;
95. opt.inInputShareable=true;
96. opt.inPurgeable=true;
97.  
98. InputStream is=context.getResources().openRawResource(id);
99. return BitmapFactory.decodeStream(is,null,opt);
100. }
101. public void init()
102. {
103. background=readBitmap(mcontext,R.drawable.map);
104. myairplane=readBitmap(mcontext,R.drawable.myairplane);
105. y1=background.getHeight();
106. airx=screenwidth/2;
107. airy=screenheight-100;
108. //敌机
109. Enemy=new enemy[enemy_maxnum];
110. bitenemy=new Bitmap[enemy_maxnum];
111. for(int i=0;i<enemy_maxnum;i++)
112. {
113. bitenemy[i]=readBitmap(mcontext,R.drawable.enemy);
114. Enemy[i]=new enemy(mcontext,bitenemy[i]);
115. Enemy[i].init(i*65, 50);
116. }
117. //子弹
118. bitbullet=new Bitmap[bullet_maxnum];
119. Bullet=new bullet[bullet_maxnum];
120. /*
121. */
122. for(int i=0;i<bullet_maxnum;i++)
123. {
124. bitbullet[i]=readBitmap(mcontext,R.drawable.bullet);
125. Bullet[i]=new bullet(mcontext,bitbullet[i]);
126. Bullet[i].init(airx+15, airy-10);
127. }
128. /*
129. */
130. }

 

1. @Override
2. public void run() {
3. // TODO 自动生成的方法存根
4.  
5. while(isrun)
6. {
7. try{
8. canvas=surfaceholder.lockCanvas();
9.  
10. Draw();
11. surfaceholder.unlockCanvasAndPost(canvas);
12. }catch(Exception e){
13.  
14. }
15. }
16. }
17. public void Draw()
18. {
19. drawbg();
20. updatebg();
21. }

 

1. private void drawbg() {
2. 153.//画背景图
3. canvas.drawBitmap(background, 0,y0, paint);
4. canvas.drawBitmap(background, 0,y1, paint);
5.  
6. canvas.drawBitmap(myairplane,airx,airy, paint);
   1. 1. /*
7. * 
8. * */
9. //画子弹
10. for(int i=0;i<bullet_maxnum;i++)
11. {
12. if(!Bullet[i].dieflag){
13. Bullet[i].DrawBullet(canvas, paint);
14. ｝
15. }
16.  
17. /**/
18. //画敌机
19. for(int i=0;i<enemy_maxnum;i++)
20. {
21. Enemy[i].DrawEnemy(canvas, paint);
22. }
23.  
24. //画得分
25. canvas.drawText("得分："+grade, 50f, screenheight-50, paint1);
26. }
27. private void updatebg() {
28. //背景向下拉
29. y0+=5;
30. y1+=5;
31. if(y0>=background.getHeight())
32. y0=-background.getHeight();
33. if(y1>=background.getHeight())
34. y1=-background.getHeight();
35. /*
36. * */
37. for(int i=0;i<bullet_maxnum;i++)
38. {
39. Bullet[i].update();
40. }
41. for(int i=0;i<enemy_maxnum;i++)
42. {
43. Enemy[i].update();
44. if(Enemy[i].enemyy>=screenheight||Enemy[i].dieflag==true)
45. {
46. Random r=new Random();
47. Enemy[i].init(r.nextInt(12)*65,0);
48. Enemy[i].dieflag=false;
49. }
50. }
51.  
52. long currenttime=System.currentTimeMillis();
53. if(index<bullet_maxnum)
54. {
55. if(currenttime-lasttime>=interval)
56. {
57. Bullet[index].init(airx+20, airy-20);
58. if(Bullet[index].dieflag){
59. Bullet[index].dieflag=false;
60. }
61. index++;
62. lasttime=currenttime;
63. }
64. }
65. else
66. {
67. index=0;
68. }
69.  
70. Collision();
71.  
72. }
73. public void Collision()
74. {

 

1. for(int i=0;i<bullet_maxnum;i++)
2. {
3. if(!Bullet[i].dieflag){
4. for(int j=0;j<enemy_maxnum;j++)
5. {
6.  
7. bx=Bullet[i].bulletx+8;
8. by=Bullet[i].bullety+20;
9. ex=Enemy[j].enemyx+30;
10. ey=Enemy[j].enemyy+30;
11.  
12. if(((ex-bx)*(ex-bx)+(ey-by)*(ey-by))<=1400)
13. {
14. Enemy[j].dieflag=true;
15. Bullet[i].dieflag=true;
16. grade=grade+100;
17. }
18. }
19. }
20. }
21.  
22. for(int i=0;i<enemy_maxnum;i++){
23. ex=Enemy[i].enemyx+30;
24. ey=Enemy[i].enemyy+30;
25. int sprt=(airx-ex)*(airx-ex)+(airy-ey)*(airy-ey);
26. if(sprt<=500){
27. surfaceDestroyed(surfaceholder);
28. }
29. }
30.  
31. }
32. public boolean onTouchEvent(MotionEvent event)
33. {
34. airx=(int) event.getX()-20;
35. airy=(int) event.getY()-30;
36. return true;
37. }
38.  

 

1. @Override
2. public void surfaceChanged(SurfaceHolder holder, int format, int width,int height) {
3. // TODO 自动生成的方法存根
4. }
5. @Override
6. public void surfaceCreated(SurfaceHolder holder) {
7. // TODO 自动生成的方法存根
8. isrun=true;
9. thread=new Thread(this);
10. thread.start();
11. }
12. @Override
13. public void surfaceDestroyed(SurfaceHolder holder) {
14. // TODO 自动生成的方法存根
15. thread=null;
16. isrun=false;
17. // Toast.makeText(mcontext, "恭喜你，获得了"+grade+"分！", Toast.LENGTH_LONG).show();
18. endinterface.onEndOfGame();
19.  
20. Intent in=new Intent(mcontext,LoseActivity.class);
21. mcontext.startActivity(in);
22. }
23. 286.}

当游戏完成之后，可以通过新的Activity查看成绩并返回主界面，该Activity

效果如下图图4-6所示：

          图4-6 游戏完成时界面                         图4-7 保存成绩图

查看成绩按钮可以让用户清楚的了解自己本局游戏中所获的的分数，并可以输入自己的姓名将成绩保存到本地的Sqlite数据库中，实现的原理是为该按钮绑定一个监视器，在监视器中实现数据库的操作，并向用户展示对话框,如图4-7所示。

查看历史记录按钮将数据库中的数据查询出来通过ListView显示在桌面上。其效果图如图4-8所示

 

图4-8 查看历史记录图

4.3 子弹类的设计

子弹所使用的资源图片： 

子弹类的Java代码设计：

1. package org.example.airplane;
2. import android.content.Context;
3. import android.graphics.Bitmap;
4. import android.graphics.Canvas;
5. import android.graphics.Paint;
6. public class bullet {
7. Bitmap bullet;
8. Context context;
9. public int bulletx=0;
10. public int bullety=0;
11. public int speed=15;
12. public boolean dieflag=false;
13. public bullet(Context context,Bitmap bitmap)
14. {
15. this.context=context;
16. bullet=bitmap;
17. }
18. public void init(int x,int y)
19. {
20. bulletx=x;
21. bullety=y;
22. }
23. public void DrawBullet(Canvas canvas,Paint paint)
24. {
25. canvas.drawBitmap(bullet, bulletx,bullety, paint);
26. }
27. public void update()
28. {
29. bullety-=speed;
30. }
31. }

4.3 敌机类的设计

模拟敌机的图片资源： 

敌机类的代码设计：

1. 1.package org.example.airplane;
2. 2.import android.content.Context;
3. 3.import android.graphics.Bitmap;
4. 4.import android.graphics.Canvas;
5. 5.import android.graphics.Paint;
6. 6.public class enemy {
7. public Bitmap enemy;
8. public Context context;
9. public int enemyx=0;
10. public int enemyy=0;
11. public int speed=8;
12. public boolean dieflag=false;
13. public enemy(Context context,Bitmap enemy)
14. {
15. this.context=context;
16. this.enemy=enemy;
17. }
18. public void init(int x,int y)
19. {
20. enemyx=x;
21. enemyy=y;
22. }
23. public void update()
24. {
25. enemyy+=speed;
26. }
27. public void DrawEnemy(Canvas canvas,Paint paint )
28. {
29. canvas.drawBitmap(enemy, enemyx, enemyy, paint);
30. }
31. 31.}

清单文件如下：

1. <?xml version="1.0" encoding="utf-8"?>
2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"
3.     package="org.example.airplane"
4.     android:versionCode="1"
5.     android:versionName="1.0" >
6.     <uses-sdk
7.         android:minSdkVersion="8"
8.         android:targetSdkVersion="17" />
9.     <application
10.         android:allowBackup="true"
11.         android:icon="@drawable/ic_launcher"
12.         android:label="@string/app_name"
13.         android:theme="@style/AppTheme" >
14.         <activity
15.             android:name="org.example.airplane.MainActivity"
16.             android:label="@string/app_name" >
17.             <intent-filter>
18.                 <action android:name="android.intent.action.MAIN" />
19.                 <category android:name="android.intent.category.LAUNCHER" />
20.             </intent-filter>
21.         </activity>
22.         <activity 
23.             android:name="org.example.airplane.viewActivity">
24.         </activity>
25.         <activity 
26.             android:name="org.example.airplane.aboutActivity">
27.         </activity>
28.         <activity 
29.             android:name="org.example.airplane.LoseActivity">
30.         </activity>
31.     </application>
32. </manifest>

 

4.5本章小结

主要介绍了主界面和游戏界面设计和实现，并在各个部分内容插叙讲述了各功能的具体实现点和实现技术，并成功的完成了软件的开发部分，能够在真机上流畅运行。

 

 

第5章  系统测试

5.1 软件测试的概念

软件测试就是利用测试工具按照测试方案和流程对产品进行功能和性能测试，甚至根据需要编写不同的测试工具，设计和维护测试系统，对测试方案可能出现的问题进行分析和评估。执行测试用例后，需要跟踪故障，以确保开发的产品适合需求。

软件测试的目的决定了如何去组织测试。如果测试的目的是为了尽可能多地找出错误，那么测试就应该直接针对软件比较复杂的部分或是以前出错比较多的位置。如果测试目的是为了给最终用户提供具有一定可信度的质量评价，那么测试就应该直接针对在实际应用中会经常用到的商业假设。不同的机构会有不同的测试目的，相同的机构也可能有不同测试目的，可能是测试不同区域或是对同一区域的不同层次的测试。

软件测试的方法和技术是多种多样的，甚至研发和测试在实际工作中都是分开进行，由于本人能力有限，只对系统进行了功能和安全健壮方面进行了测试。

5.2 系统的功能和安全测试

由于Android自带了测试工具和Debug模式，Android的编译和测试工具需要测试项目组织符合预订的结构：分别为Test case 类，Test case 包以及测试项目。JUnit 为Android的测试的基础，一般来说，一个JUint测试为一个用来测试一个应用某一部分的语句。 你可以将多个测试Test方法组织起来构成一个测试用例(Test case)，多个测试用例可以构成Test Suites 。 每个Test方法相对独立，一个测试类Test class包含一组相关的Test 或其它辅助方法。在系统安全方便我采用Android单元测试的方法，测试过程如下。

 

1. 一.Menifest.xml中加入测试需要的功能包和加入测试权限

1. <application>中加入：  
2. <uses-library android:name="android.test.runner" /> 
3. <application>外面加入：  
4. <uses-permission android:name="android.permission.RUN_INSTRUMENTATION" /> 
5. <instrumentation android:name="android.test.InstrumentationTestRunner" android:targetPackage="name.feisky.android.test" 
6. android:label="Test for my app"/> 

 

1. 二.编写单元测试代码：测试类必须继承自AndroidTestCase类

1. package name.feisky.android.test;  
2.  
3. import android.test.AndroidTestCase;  
4. import junit.framework.Assert;  
5. public class MyTest extends AndroidTestCase {  
6. private static final String Tag="MyTest";  
7.  
8. public void testSave() throws Throwable{  
9.       int i=4+8;  
10.       Assert.assertEquals(5,i);  
11. }  
12. public void testSomethingElse() throws Throwable {  
13.       Assert.assertTrue(1 + 1 == 12);  
14. }  
15. }  

1. 三.执行测试过程截图如5-1、5-2、5-3所示。

 

图5-1  声明单元测试

 

 

图5-2  测试代码方法的响应时间

 

 

图5-3  测试结果显示

本游戏测试的主要是检验在游戏运行的过程中是否能够按照Activity的生命周期正常运行，例如退出后，重新进入是否能够保存退出前的状态并继续运行；在游戏对战中是否能够正常产生敌机和发射子弹；战机死亡后是否能够正常关闭线程等。

 

5.3 测试总结

通过单元测试发现如果用户输入数据不合理比如数据输成自己或不存在数据程序会报各种错误及异常，直接导致软件崩溃。因此根据可能出现的问题进行了相关判断和提示，使系统更加强壮和友好。

项目测试结果表明，所设计软件各项功能模块都能正常运行，满足项目设计要求，项目研究和软件设计达到了预期目的。

 

第6章  总结

基于Android的飞机大战游戏是采用Android应用的核心技术及java语言常用开发模式完成，本系统实现了游戏流程中的所有功能，界面布局更加人性化，并有着良好的可扩展性。整体模式采用C/S架构开发，Android客户能够处理常用数据及业务逻辑，减轻了服务器端的压力。由于Android迅猛的发展，在Android平台开发的应用也将会成为主流，因此，该系统在这种大环境下应运而生，有着广阔的商业前景。

本系统从构思，设计到代码的实现与测试历时近三个月，通过对项目的思考与编码实现，使我对Android和java技术有了更深层次的了解，自己也清楚的感觉到自己对知识掌握的局限，尤其是在Android开发方面还要投入更多的精力去学习。通过大量的查阅资料和书籍让我对软件开发的流程有了一定的掌握，明白了软件开发的原理、流程和模式。这次的项目设计开发为今后的学习和工作产生了积极的意义。由于还是初学者，在项目设计中还有欠缺和考虑不周的地方，游戏还有待进一步研究和改善。

致 谢

论文完成之际，衷心感谢所有关心、帮助过作者的老师、同学、朋友们，尤其要向作者的导师黄国兵老师致以衷心的感谢。在项目运行和论文撰写工作中，黄老师对作者严格要求，认真指导，给予了很多鼓励和帮助，并提供了很多指导性的意见。在黄国兵老师的亲切关怀和悉心指导下作者顺利的完成了的项目设计和论文撰写。他严肃的科学态度，严谨的治学精神，精益求精的工作作风，对学术一丝不苟的高尚品德和人格魅力深深地感染和激励着作者，今后也会成为作者生活和工作追求的标榜。

最终也要感谢在设计期间给予作者帮助的同学，他们帮助解答了许多技术上的问题。同时也感谢其他老师在此期间的关怀和帮助，以及学院为作者提供良好的毕业设计环境。

 

 

参考文献

[1]  Rick Rogers，Blake Meike ，Zigurd Mednieks .Android应用开发 李耀亮译.人民邮电出版社.2010.9.

[2]  余志龙、陈昱勋、郑名杰Android SDK开发范例大全[M]. 北京人民邮电出社,2010

[3]  田珂，谢世波，方马.J2EE数据持久层的解决方案[J].计算机工程，2003

[4]  李刚，疯狂Android讲义第二版 电子工业出版社2013年7月

[5]  明日科技，Java从入门到精通 清华大学出版社2012年 9月  

[6] 高焕堂.Android 应用框架原理与程式设计36（第三版）[M].北京：清华大学出版社，2007.1

[7] 张利国，龚海平，王植萌.Android移动开发入门与进阶[M].北京：人民邮电出版社，2009.12

[8] 崔尚森，张白一．面向对象程序设计—Java(第二版)西安电子科技大学出版社，2006.1

[9] 黄德才．数据库原理及其应用教程(第二版)．科学出版社，2006

[10] 张桂珠 刘丽 陈爱国 Java面向对象程序设计（第2版）北京邮电大学出版社

[11] 毕广吉.Java程序设计实例教程[M]. 北京：冶金工业出版社，2007年

[12] 王保罗.Java面向对象程序设计[M]. 北京：清华大学出版社，2003年

[13] 林邦杰.彻底研究java.北京：电子工业出版社，2002年

[14] 王珊.萨师煊.数据库系统概论(第四版)[M].北京:高等教育出版社,2006

[15] 李飞.最新实用网络技术教程[M].西安:西安电子科技大学出版社