基于Android平台的游戏的设计与实现

摘 要

随着手机行业的发展，手机游戏以更简洁方便的形式深入人们的日常生活，成为人们在任何非工作场合的娱乐方式。“跳吧”是个老幼皆宜的小游戏，不仅能够让玩家放松心情、减轻压力，同时也能锻炼玩家眼力与手部灵活性。

本系统是基于Android操作系统开发的，利用Eclipse3.5环境和JAVA语言实现的。经过可行性研究，需求分析，总体设计，详细设计，编码实现和测试，从而实现了本系统的设计。本文对每一个开发环节进行了详细分析和和阐述。本系统实现的功能有主角移动功能、随机产生不同踏板和加分物品功能、血条功能、重力感应功能等。

本系统在Android SDK虚拟机和安卓真机ZTEU930HD下测试通过，界面友好，使用方便。

关键词 游戏设计;Android;Java

The Design and Implementation of Jumping Game Base On Android Platform

Author：Cao Jianqiang Tutor：Liu Aiqin

Abstract

With the development of the mobile phone industry, mobile games have more simple and convenient form in-depth people's daily lives, as people in any non-work occasions of entertainment. "Jumping game " is a small game for all ages, not only allows players to relax and reduce stress, but also to exercise player’s eyes and flexibility of player’s hand.

The system is based on the Android operating system developed, using Eclipse3.5 environment and JAVA language. After a feasibility study, requirements analysis, design, detailed design, coding and testing to achieve the design of the system.this paper have detailed analysis and elaboration for the each link of development . The system function can be achieved protagonist mobile features, randomly generated different footboard and processing of Bonus items function, blood of the function, gravity sensor function and so on.

This system has been tested under the Android SDK virtual machine and real machine ZTEU930HD ,friendly interface and easy to use.

Keywords game design; Android; Java

目 录

TOC \o "1-3" \h \u

第一章 系统概述 1

1.1 游戏开发背景及意义 1

1.1.1 开发背景 1

1.1.2 开发意义 1

1.2 开发平台介绍 2

1.2.1 Eclipse 2

1.2.2 ADT 2

1.2.3 JDK 2

1.3 Android操作系统结构 2

1.3.1 Android操作系统介绍 2

1.3.2 Android操作系统的优点 3

1.3.3 Android系统结构 3

1.3.4 Android应用程序组成部分 4

第二章 可行性分析 6

2.1编写目的 6

2.2 可行性研究任务 6

2.2.1技术可行性 6

2.2.2经济可行性 7

2.2.3操作可行性 7

2.3 可行性研究结论 7

第三章 需求分析 8

3.1需求分析的意义 8

3.2游戏功能需求 8

3.3可靠性和可用性需求 8

3.4 用例图 9

第四章 总体设计 10

4.1 总体设计的目标和意义 10

4.2 功能模块的划分 10

4.3 时序图 11

第五章 详细设计 12

5.1详细设计的目的和意义 12

5.2总程序流程图 12

5.3 随机产生踏板 14

5.4 血条参数的设置 15

5.5 加分物品的生成 15

5.6 主角连续动作的生成 16

5.7 主角与踏板关系的判断 16

5.8 主角与加分物品关系的判断 16

第六章 开发平台的搭建 17

6.1 JAVA虚拟机的安装 17

6.1.1JDK的安装 17

6.1.2 Java环境变量配置 18

6.2 Eclipse的安装 18

6.2.1 安装SDK 18

6.2.2 Eclipse的安装 19

第七章 编码实现 21

7.1 编码的目的 21

7.2 游戏截图 21

7.3 游戏功能的实现 22

7.3.1主角动作的实现 22

7.3.2随机产生踏板 23

7.3.3下一个踏板的生成 25

7.3.4随机生成加分物品 25

7.3.5处理主角和踏板的关系 26

7.3.6判断主角与加分物品的关系 28

7.3.7重力感应系统 29

7.3.8游戏难度的提升 29

7.3.9 设置实现 29

第八章 系统测试 31

8.1 测试的目的及意义 31

8.2测试步骤 32

8.2.1 模拟器测试 32

8.2.2 真机测试 34

8.3 测试结果分析 35

结束语 37

致 谢 38

参考文献 39

附录 外文翻译 40

系统概述

1.1 游戏开发背景及意义

1.1.1 开发背景

手机游戏的出现是为了娱乐心神，并随着移动终端和移动通信网络的不断进步，手机游戏也正在经历由简单到复杂的进化过程。从全球来看，移动终端的娱乐服务被认为是带动移动数据业务快速发展的重要力量。作为手机娱乐服务的重要内容之一，近年来，伴随着移动网络和移动终端性能的不断提高与完善，尤其是智能手机的出现，手机游戏业务呈现快速增长趋势。

近几年来，手机游戏快速发展的同时按内容可分为：角色扮演类、冒险类、格斗类、体育竞技类、电影改版类、棋牌类、益智类、模拟类。手机游戏种类已成为人类线上娱乐生活的不可缺少的最主流的载体而存在，各类智能手机伴随着PC网络游戏为基础、3网络的不断变化为措施的条件下大力迅猛发展手机网络游戏。虽然手机游戏的用户越来越多，丰富多彩的游戏种类给玩家带来了更多的选择，但是我国的手机游戏行业的发展现状并不乐观，主要因素有：（1）高质量游戏软件开发公司和人才的贫乏，导致无优秀游戏打入市场。（2）游戏创意的匮乏。大多游戏都只是一味的跟风，看到某个游戏成功赢得市场，便改换场景风格，人物造型、故事背景等，其游戏核心一沉不变的思维理念会使得玩家产生审美疲劳。

随着Android游戏的商业模式越来越凸显，人们对移动终端的休闲娱乐功能需求越来越大，移动终端上的游戏已成为成为现代人们娱乐生活中不可或缺的。游戏应用服务市场促使手机平台的不断提升而日新月异。在未来的游戏产品能否脱颖而出，一切取决于你能玩出什么花样来，这将激发更多的开发商和制作人员攻坚克难创作出高质量的作品，而面对手机游戏自身的趣味性、易掌握性、可中断性、交互性、游戏商家也将面临亘古未见得激烈竞争。由此可见，手机已是人们日常生活中密不或缺的休闲娱乐方式。

1.1.2 开发意义

在人们的生活中，大多数人都已离不开手机，而大多数手机用户选择智能手机，开发Android游戏旨在为人们日常生活添加更多的娱乐方式，此次设计出一个能够在任何环境任何时间放松心情娱乐心身的单机游戏，通过简单易操作的Android游戏帮助手机用户打发闲暇时间、娱乐心身、放松心情。

1.2 开发平台介绍

“跳吧”游戏开发平台为Eclipse4.3.2 + ADT22.6.2 + JDK1.7.0_51，模拟测试平台为Android SDK模拟器，真机测试平台为ZTEU930HD。

1.2.1 Eclipse

Eclipse是不仅仅是成为专门开发JAVA程序的IDE环境，根据Eclipse的体系结构，通过开发插件，它能扩展到任何语言的开发，甚至能成为图片绘制的工具。Eclipse是一个开放源代码的项目，任何人都可以下载 Eclipse 的源代码，并且在此基础上开发自己的功能插件。也就是说未来只要有人需要，就会有建立在Eclipse之上的C++，JAVA，Python等语言的开发插件出现。同时可以通过开发新的插件扩展现有插件的功能。可以无限扩展，而且有着统一的外观,操作和系统资源管理，这也正是 Eclipse的潜力所在。在本项目中，Eclipse正是通过第三方插件—ADT实现了开发 Android 应用。

1.2.2 ADT

ADT是英文 Android Development Tools 的简称，即Android开发工具包。

ADT是Eclipse中构建Android应用程序IDE插件，ADT扩展了Eclipse的功能，让开发人员快速建立新的Android项目、创建应用程序的用户界面。ADT可以帮助Eclipse找到Android sdk，再加上Android框架的API组件调试使用Android SDK工具，以便APK分发给应用程序。 ADT大大减轻Android应用程序的开发工作量，工具集成XML编辑器，将给开发人员一个令人难以置信的开发Android应用环境。使用ADT之前，必须确认已经安装了Eclipse以及同Eclipse IDE兼容版本的Android SDK。

1.2.3 JDK

JDK(Java Development Kit) 是 Java 语言的软件开发工具包(SDK)。有SE、EE、ME三个版本。

没有JDK的话，无法编译Java程序，如果想只运行Java程序，要确保已安装相应的JRE。

1.3 Android操作系统结构

1.3.1 Android操作系统介绍

Android是一种基于Linux的自由及开放源代码的操作系统，主要在移动设备上工作，如智能手机和平板电脑，由Google公司和开放手机联盟领导及开发。Android操作系统最初由Andy Rubin开发，主要支持手机。随后Google以Apache开源许可证的授权方式，发布了Android的源代码。第一部Android智能手机发布于2008年10月。Android逐渐扩展到平板电脑及其他领域上。

1.3.2 Android操作系统的优点

作为一个手机平台，Android 在技术上的优势主要有以下几点：

（1）全开放智能手机平台

（2）多硬件平台的支持

（3）使用众多的标准化技术

（4）核心技术完整，统一

（5）完善的 SDK 和文档

（6）完善的辅助开发工具

Android 的开发者可以在完备的开发环境中进行开发，Android 的官方网站也提供了丰富的文档、资料。这样有利于 Android 系统的开发和运行在一个良好的生态环境中。

1.3.3 Android系统结构

Android的系统结构如下图1.1所示：

图 1.1 Android系统结构

Android 的第 1 层次由 C 语言实现，第 2 层次由 C 和/C++实现，第 3、4 层次主要由 Java 代码实现。第 1 层次和第 2 层次之间，从 Linux 操作系统的角度来来看，是内核空间与用户空间的分界线，第 1 层次运行于内核空间，第 2、3、4 层次运行于用户空间。 第 2 层次和第 3 层次之间，是本地代码层和 Java 代码层的接口。第 3 层次和第 4 层次之间，是 Android 的系统 API 的接口，对于 Android 应用程序的开发，第 3 层次以下的内容是不可见的，仅考虑系统 API 即可。由于 Android 系统需要支持 Java 代码的运行，这部分内容是 Android 的运行环境（Runtime），由虚拟机和Java 基本类组成。对于 Android 应用程序的开发，主要关注第 3 层次和第 4 层次之间的接口。

1.3.4 Android应用程序组成部分

一般情况下，Android 应用程序由以下 4 种组件构成：

„ 活动（Activity）、广播接收器（BroadcastReceiver）、服务（Service）、内容提供者（Content Provider）。

活动是最基本的 Android 应用程序组件，在应用程序中，一个活动通常就是一个单独的用户界面。每一个活动都被实现为一个独立的类，并且从活动（Activity）基类中继承而来，活动类将会显示由视图（View）控件组成的用户接口，并对事件（Event）做出响应。大多数的应用程序都会有多个用户界面，因此便会有多个相应的活动。Android 的一个活动一般对应界面中的一个屏幕显示，可以理解成一个界面，每一个活动在界面上可以包含按钮、文本框等多种可视的 UI 元素。

Android 系统中的不同组件具有不同的生命周期。Android 根据每个进程中运行的组件以及组件的状态把进程放入一个重要性分级（importance hierarchy）中。Android 进程的重要性分级，可以理解成执行的优先级。活动的生命周期如图 1.2 所示。

运行活动的情景：当一个活动被启动时，活动中的 onCreate()、onStart()和 onResume()这 3 个方法被依次调用，活动对应的界面出现在屏幕上。

„ 活动被“覆盖”的情景：Android 的活动一般都占据一个完整的屏幕，从当前活动启动另外一个活动时，另一个活动将被启动到前台（Foreground），当前活动转入后台（Background），这时活动的 onPasuse()方法将被调用，活动转入后台运行。如果活动变为不可见，还将调用 onStop()方法。在转入后台onStop()是否被调用取决于活动是否被完全覆盖，在新的活动有透明部分时，转入后台的活动依然“可见”，其他情况下（较多数的情况）活动均进入不可见状态（被完全覆盖）。

„ 活动被恢复的情景：当界面上最前面的活动退出后，它所覆盖的活动将被恢复，这时 onResume()方法将被调用，活动重新转入前台运行。

„ 活动完全退出的情景：当使用回退（Back）按钮退出活动时，onDestroy()方法将被调用，活动关闭。如果系统缺少内存时，也会杀死（kill）后台的活动，其中优先杀死不可见的活动，可见的活动一般不会被杀死。

图 1.2 活动的生命周期

可行性分析

2.1编写目的

可行性研究的目的是目标系统是否值得去开发，怎样才能达到这个目的。

一个项目的开发需要仔细分析，看它在目前的情况下是否可行，如果一个项目开发它具有很好的背景和意义，但是在经济上或者是技术上是不可行的，那么它也只能称之为不能实现的项目。

2.2 可行性研究任务

2.2.1技术可行性

确保现有的技术是否能解决本该开发项目：系统采用JAVA语言开发，Eclipse作为Android开发环境。ADT插件提供了一系列图形用户界面组件进行界面编程，所以在技术上可行。Java是一种可以撰写跨平台应用软件的面向对象的程序设计语言，是由Sun Microsystems公司推出的Java程序设计语言和Java平台的总称。Java自面世后就非常流行，发展迅速，对C++语言形成了有力冲击。Java 技术具有卓越的通用性、高效性、平台移植性和安全性，广泛应用于个人PC、数据中心、游戏控制台、科学超级计算机、移动电话和互联网，同时拥有全球最大的开发者专业社群。在全球云计算和移动互联网的产业环境下，Java更具备了显著优势和广阔前景。

Java是目前使用最为广泛的网络编程语言之一。它具有简单，面向对象，稳定，与平台无关，解释型，多线程，动态等特点。Java语言有以下几点优点：

面向对象的编程更符合人的思维模式，使人们更容易编写程序。

内置对多线程的支持。

Java程序的安全性。当你准备从网络上下载一个程序时，你最大的担心是程序中含有恶意的代码，比如试图读取或删除本地机上的一些重要文件，甚至该程序是一个病毒程序等。当你使用支持Java的浏览器时，你可以放心地运行Java的小应用程序 Java Applet ，不必担心病毒的感染和恶意的企图，Java小应用程序将限制在 Java运行环境中，不允许它访问计算机的其它部分。

Java 程序的基本组成单元就是类，有些类是自己编写的，有一些是从类库中引入的，而类又是运行时动态装载的，这就使得 Java 可以在分布环境中动态地维护程序及类库，而不像 C++那样，每当其类库升级之后，相应的程序都必须重新修改，编译。

因此我觉得Java程序语言该技术已成熟，采用JAVA编程语言是可行的。

2.2.2经济可行性

由于“跳吧”游戏作为毕业设计进行开发，有本人亲自开发，成本不会太高，所以经济上是可行的。

2.2.3操作可行性

确定软件产品是否能够被最终的用户所接受，用户是否能操作最终的产品：该游戏在方便易操作的Android手机上运行，方便于玩家操作。

2.3 可行性研究结论

根据以上几个方面的研究，在技术上、经济上和操作上都是可行的，本项目可进行开发。

需求分析

3.1需求分析的意义

为了开发出真正的满足用户需求的软件产品，首先必须知道用户的需求。为软件需求的深入理解是软件开发工作获得成功的前提条件，不论人们把设计和编码工作做得如何出色，不能真正的满足用户需求的程序只会令用户失望，给开发者带来烦恼。

需求分析是软件定义时期的最后一个阶段，它的基本任务是准确地回答“系统必须做什么”这个问题。

3.2游戏功能需求

游戏能够实现让玩家在游戏中放松心神、减轻压力的作用，同时要求游戏中的精灵不断变换，锻炼玩家眼力与手部灵活性的功能。

要求“跳吧”游戏能实现以下功能：

主角移动功能。主角移动功能就是玩家利用手机重力感应系统对其进行左右移动操作。

产生踏板功能。系统可以随机产生不同类型的踏板，这些踏板分为：稳定踏板、带刺踏板、左/右移动踏板、弹簧踏板、不稳定踏板，并且这些踏板能够以一定的速度向屏幕顶部移动；同时，带刺踏板可以对主角造成一定的伤害，左/右移动踏板可以将主角向左/右移动，弹簧踏板会将主角向上弹起，不稳定踏板会在主角站在上面时破碎，稳定踏板不产生任何效果。

产生加分物品。系统会随机产生不同类型的加分物品，物品分值随物品类别不同而不同，且物品要停留一定时间再消失。

设置功能。能够对游戏进行一些简单的设置，这些设置包括音效设置、震动设置、主角移动速度设置、输入玩家名称。

血条功能。主角在踩到带刺踏板时，血条减少一定的值，当主角掉到屏幕下方时血条值归零。

排行榜功能。游戏可以跟据玩家的游戏得分按由高到低顺序进行排名次。

3.3可靠性和可用性需求

在游戏开发阶段要求在windows 7操作系统、JAVA编程语言、Eclipse平台下开发，在Android SDK虚拟机和ZTEU930HD真机下测试运行。

要求游戏能够在Android 4.0.0及其以上版本、RAM为512MB的安卓手机上稳定流畅运行，并要求游戏在运行过程中不能影响手机正常通信功能及用户手机上的其他应用功能。

3.4 用例图

在该游戏中玩家可操作游戏的功能有：通过重力感应对游戏主角进行左右移动、输入玩家名称、点击返回按钮、点击重新开始按钮、点击退出按钮、点击开始按钮、点击排行榜按钮、设置音效（开/关）、设置主角移动速度、设置震动效果。游戏用例图如图3.3 。

图 3.3 用例图

总体设计

4.1 总体设计的目标和意义

经过前面的需求分析，已经确定了系统要做什么，总体设计的目的是为了实现现在怎么做。总体设计的意义是为了更好地设计游戏让后续的工作更好地高质量工作。

4.2 功能模块的划分

该游戏有人物模块、踏板模块、设置模块、加分物品模块、血条模块、排行榜模块，其中在设置模块下包含有音效设置、震动效果设置、人物移动速度模块、输入玩家名称模块，其模块划分如下图4.1。

图 4.1 功能模块图

在主角移动模块中要实现主角移动动作时显示连续的效果；踏板模块是系统随机产生的，含有不同类型的踏板；在设置模块当中玩家可以根据自己的喜好进行音效设置（包含音效的开和关）、震动效果设置、输入玩家名称和主角移动速度的设置；在加分物品模块当中，系统会随机产生8中不同类型的加分物品，当主角捡到加分物品时游戏成绩增加，血条模块当中，每当主角受到伤害时血条值将会减少一定的值；排行榜模块是为了更好地显示玩家排名。

4.3 时序图

游戏大概操作流程为玩家点击游戏图标进入游戏主界面，然后点击开始游戏进行操作，等游戏结束后玩家在弹出的窗口输入玩家名称，然后点击结束按钮退出游戏，游戏时序图如图4.2 。

图4.2 时序图

详细设计

5.1详细设计的目的和意义

详细设计的目的是为了能够确定具体地实现所要求的系统，经过前面的分析和设计，现应该对目标系统得出详细的描述，并设计出详细的方案，以便让程序员能够写出更为高质量的程序代码。

5.2总程序流程图

系统总程序流程图如图5.1所示。

图 5.1 系统总流程图

系统开始时先进行判断是否为开始游戏、是否设置游戏参数、是否查看排名、是否退出游戏，然后系统根据选择进行相应的操作，如果选择是开始游戏则做出开始游戏的动作直到游戏结束并输入玩家名称，点击返回按钮；若选择为设置游戏则对游戏的各项参数进行设置，然后点击返回按钮；加入选择排名则系统显示玩家成绩与排名，然后点击返回按钮。

图 5.2 游戏流程图

游戏流程图如图5.2所示，当点击开始游戏时，系统判断玩家接触到的踏板类型，然后根据踏板的类型做出不同的效果，当玩家左右移动时碰到不稳定踏板时，踏板破碎；当为弹簧踏板时玩家被弹起；当为左右移动踏板时，玩家随踏板左右移动；当为带刺踏板时，玩家血条将会减少一定的值；当玩家血条为零或者玩家直接调到屏幕下面则游戏结束。

图 5.3 游戏设置流程图

当选择游戏设置时，玩家可以对游戏参数进行设置，其设置流程图如图5.3所示。

当选择设置音效时，在游戏设置界面，设置音效的开/关。当选择为设置人物移动速度时，在游戏设置界面通过左右滑动调节线条来调节游戏角色的移动速度，当选择为录入玩家的名称时在设置界面文本框内输入玩家的名称，然后点击退出按钮进行保存设置并退出到游戏主界面，或者当点击设置界面的返回按钮时返回游戏主界面。

5.3 随机产生踏板

系统随机产生0到19数字，当随机数在0-2之间时游戏生成不稳定踏板，随机数在3-5之间时游戏生成弹簧踏板，随机数在6-11之间时游戏生成带刺踏板，当随机数在12-13之间时游戏生成左移动踏板，当随机数在14-15之间时游戏生成右移动踏板，当随机数在16-19之间时游戏生成稳定踏板。其踏板产生机制如图5.4所示。

图 5.4 踏板的产生

5.4 血条参数的设置

为了游戏更加吸引玩家，同时考虑到游戏的难易程度，玩家在游戏中的心理作用，现将游戏的血条总参数设置为18，也就是说游戏主角的总生命值为18，当游戏主角每次收到伤害时，血条值减少3，也就是说每当玩家受到一次伤害时，游戏主角的生命值减少3，这样当玩家受到伤害6次游戏将结束，或者当玩家直接掉到屏幕下面时游戏主角的生命值为0，游戏结束。

5.5 加分物品的生成

为了游戏的有趣性，更好的让玩家放松，在游戏中得到更大的乐趣，设置加分机制，在游戏中将随机产生香蕉、蛋糕、西红柿、桃子、草莓、山果、梨子、面包。每个加分物品的分值如下：

面包 ——1 桃子 ——5

山果 ——4 草莓 ——6

西红柿——10 梨 ——12

香蕉 ——15 蛋糕 ——20

加分物品随机产生参数的设置，系统随机产生23个数，当随机数为0时游戏生成面包，当随机数为1时游戏生成蛋糕，随机数在2-4之间时游戏生成香蕉，随机数在5-7之间时游戏生成梨，当随机数在8-10之间时游戏生成西红柿，当随机数在11-13之间时游戏生成桃，当随机数在14-17之间时游戏生成草莓，当随机数在18-21之间时游戏生成山果。

5.6 主角连续动作的生成

首先利用if语句判断主角的状态是出于何种状态，，然后根据所处的状态将首张图片赋给主角判断形状的变量，然后在判断主角形状变量与下一张的关系，然后再将下一张图片赋给主角形状变量直到最后一张，最后通过循环语句和系统定时器来控制动作的发生和结束。

5.7 主角与踏板关系的判定

当系统随机生成六中不同类型的踏板时，如何判断主角与踏板发生碰撞呢？下面是解决主角与踏板关系的实现方法。

给主角定义一个主角状态变量、同时定义踏板类型变量。首先判断主角与踏板碰撞效果，利用if语句判断主句坐标与踏板坐标的关系，具体如下：

当主角最大Y轴值大于等于踏板Y轴最小值，同时主角Y轴最大值小于踏板Y轴最大值，同时主角最大X值大于踏板X轴最小值，并且主角X轴最小值小于踏板X轴最大值时为主角和踏板发生了碰撞。

然后再通过主角状态变量与踏板类型变量的关系来判断主角与何种踏板发生碰撞并作出相应的效果。

5.8 主角与加分物品关系的判定

判断主角与加分物品的关系和判断主角与踏板关系的方法基本相似，都是通过坐标进行判断，当主角最大Y轴值大于等于加分物品Y轴最小值，同时主角Y轴最大值小于加分物品Y轴最大值，同时主角最大X值大于加分物品X轴最小值，并且主角X轴最小值小于加分物品X轴最大值时为主角和加分物品发生了碰撞。

开发平台的搭建

6.1 JAVA虚拟机的安装

6.1.1JDK的安装

下载jdk1.7.0_51软件，打开软件进行安装，如图6.1、6.2。

图 6.1 JDK的安装

图 6.2 JDK完成安装

6.1.2 Java环境变量配置

1.打开我的电脑--属性--高级--环境变量 ，如图6.3。

图6.3 配置Java环境变量

2.新建系统变量JAVA_HOME 和CLASSPATH

变量名：JAVA_HOME

变量值：C:\Program Files\Java\jdk1.7.0

变量名：CLASSPATH

变量值：.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;

3. 选择“系统变量”中变量名为“Path”的环境变量，双击该变量，把JDK安装路径中bin目录的绝对路径，添加到Path变量的值中，并使用半角的分号和已有的路径进行分隔。

变量名：Path

变量值：%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;

6.2 Eclipse的安装

下载Eclipse4.3.2 、 ADT22.6.2 、Android SDK。

6.2.1 安装SDK

点击Android SDK进行安装，如图6.4。

图 6.4 安装SDK

完成安装后，打开SDK下载相应的Android操作系统版本，如图6.5。

图 6.5 安装Android操作系统

6.2.2 Eclipse的安装

1、点击Eclipse安装软件，根据提示进行安装，安装完成后，点击help-->install new software，然后点击add,在弹出的窗口中点击archive选择ADT所在路径，并在name除填入ADT名称，然后点击OK，根据提示进行安装ADT插件，如图 4.6。

图 6.6安装ADT插件

点击Window->preference，点击Android选择Browse选择sdk所在路径，点击apply然后点击OK，如图6.7。

图 6.7 添加SDK路径

编码实现

7.1 编码的目的

通过编码把软件设计结果翻译成Java语言的程序，同时也是对设计的进一步具体化，也是对所学知识的一个具体体现。

7.2 游戏截图

游戏截图如下图7.1，图7.2，图7.3，图7.4。

图7.1 游戏主界面 图 7.2 开始游戏界面

图 7.3 设置界面 图 7.4 游戏结束界面

7.3 游戏功能的实现

7.3.1主角动作的实现

主角每完成一个完整的动作是由好多个分解动作组成，比如主角向左移动时，是由好几个向左走动的单个动作构成，那么判断主角移动状态并形成连续的动作的算法如下：

public int getRoleSharp() {

if (mRoleStatus == UIModel.ROLE_STATUS_ON_FOOTBOARD) {

mRoleSharp = UIModel.ROLE_SHARP_STANDING;

return mRoleSharp;

}

mFrameCounter++;

if (mFrameCounter == mFrameDelay) {

mFrameCounter = 0;

if (mRoleStatus == UIModel.ROLE_STATUS_FREEFALL) {

if (mRoleSharp == UIModel.ROLE_SHARP_FREEFALL_NO1) {

mRoleSharp = UIModel.ROLE_SHARP_FREEFALL_NO2;

} else if (mRoleSharp == UIModel.ROLE_SHARP_FREEFALL_NO2) {

mRoleSharp = UIModel.ROLE_SHARP_FREEFALL_NO3;

} else if (mRoleSharp == UIModel.ROLE_SHARP_FREEFALL_NO3) {

mRoleSharp = UIModel.ROLE_SHARP_FREEFALL_NO4;

} else {

mRoleSharp = UIModel.ROLE_SHARP_FREEFALL_NO1;

}

} else if (mRoleStatus == UIModel.ROLE_STATUS_FREEFALL_RIGHT

|| mRoleStatus == UIModel.ROLE_STATUS_ON_FOOTBOARD_RIGHT) {

if (mRoleSharp == UIModel.ROLE_SHARP_MOVE_RIGHT_NO1) {

mRoleSharp = UIModel.ROLE_SHARP_MOVE_RIGHT_NO2;

} else if (mRoleSharp == UIModel.ROLE_SHARP_MOVE_RIGHT_NO2) {

mRoleSharp = UIModel.ROLE_SHARP_MOVE_RIGHT_NO3;

} else if (mRoleSharp == UIModel.ROLE_SHARP_MOVE_RIGHT_NO3) {

mRoleSharp = UIModel.ROLE_SHARP_MOVE_RIGHT_NO4;

} else {

mRoleSharp = UIModel.ROLE_SHARP_MOVE_RIGHT_NO1;

}

} else {

if (mRoleSharp == UIModel.ROLE_SHARP_MOVE_LEFT_NO1) {

mRoleSharp = UIModel.ROLE_SHARP_MOVE_LEFT_NO2;

} else if (mRoleSharp == UIModel.ROLE_SHARP_MOVE_LEFT_NO2) {

mRoleSharp = UIModel.ROLE_SHARP_MOVE_LEFT_NO3;

} else if (mRoleSharp == UIModel.ROLE_SHARP_MOVE_LEFT_NO3) {

mRoleSharp = UIModel.ROLE_SHARP_MOVE_LEFT_NO4;

} else {

mRoleSharp = UIModel.ROLE_SHARP_MOVE_LEFT_NO1;

}

}

}

return mRoleSharp;

}

7.3.2随机产生踏板

在游戏中随机生成20个随机数，并根据详细设计里的规则形成相应的踏板，其算法如下：

private void generateFootboard() {

int frameAmount = 1;

int frameDelay = 1;

int frameType = FOOTBOARD_TYPE_NORMAL;

switch (mRan.nextInt(20)) {

case 0:

case 1:

case 2:

frameType = FOOTBOARD_TYPE_UNSTABLE;

break;

case 3:

case 4:

case 5:

frameType = FOOTBOARD_TYPE_SPRING;

break;

case 6:

case 7:

case 8:

case 9:

case 10:

case 11:

frameType = FOOTBOARD_TYPE_SPIKED;

break;

case 12:

case 13:

frameType = FOOTBOARD_TYPE_MOVING_LEFT;

frameAmount = 2;

frameDelay = 15;

break;

case 14:

case 15:

frameType = FOOTBOARD_TYPE_MOVING_RIGHT;

frameAmount = 2;

frameDelay = 15;

break;

default:

frameType = FOOTBOARD_TYPE_NORMAL;}

mFootboardList.add(new Footboard(mRan.nextInt(mScreenAttribute.maxX

- BORDER_ATTRIBUTE_IMAGE_WIDTH), mScreenAttribute.maxY

+ ROLE_ATTRIBUTE_HEITH, BORDER_ATTRIBUTE_IMAGE_WIDTH,

BORDER_ATTRIBUTE_IMAGE_HEITH, frameType, frameAmount,

frameDelay));}

随机产生的踏板如图7.1所示。

图 7.1 随机产生的踏板

7.3.3下一个踏板的生成

当随机产生踏板时，在游戏当中还要有生成下一个踏板的算法，生成下一个踏板的算法如下所示：

public int nextFrame() {

try {

return mFrameCounter / mFrameDelay;

} finally {

mFrameCounter++;

if (mFrameCounter == mFrameAmount * mFrameDelay) {

mFrameCounter = 0;

}

}

7.3.4随机生成加分物品

根据详细设计规定，随机生成25个随机数，根据相关规定生成加分物品，实现算法如下：

private void generateFood() {

if (mCurFood.mTimeCounter > 0) {

return;

}

switch (mRan.nextInt(25)) {

case 0:

mCurFood.mFoodReward = FOOD_1;

break;

case 1:

mCurFood.mFoodReward = FOOD_2;

break;

case 2:

case 3:

case 4:

mCurFood.mFoodReward = FOOD_3;

break;

case 5:

case 6:

case 7:

mCurFood.mFoodReward = FOOD_4;

break;

case 8:

case 9:

case 10:

mCurFood.mFoodReward = FOOD_5;

break;

case 11:

case 12:

case 13:

mCurFood.mFoodReward = FOOD_6;

break;

case 14:

case 15:

case 16:

case 17:

mCurFood.mFoodReward = FOOD_7;

break;

case 18:

case 19:

case 20:

case 21:

mCurFood.mFoodReward = FOOD_8;

break;

default:

mCurFood.mFoodReward = FOOD_NONE;

return;

}

mCurFood.mMinX = mRan

.nextInt((mScreenAttribute.maxX - FOOD_ATTRIBUTE_IMAGE_SIZE));

mCurFood.mMinY = mRan

.nextInt((mScreenAttribute.maxY - FOOD_ATTRIBUTE_IMAGE_SIZE));

mCurFood.mMaxX = mCurFood.mMinX + FOOD_ATTRIBUTE_IMAGE_SIZE;

mCurFood.mMaxY = mCurFood.mMinY + FOOD_ATTRIBUTE_IMAGE_SIZE;

mCurFood.mTimeCounter = FOOD_ATTRIBUTE_DELAY_TIME;

}

随机产生的加分物品如下图7.2所示。

7.2 随机产生的加分物品

7.3.5处理主角和踏板的关系

在游戏当中要判断游戏主角与踏板发生碰撞，并在发生碰撞时做出相应的动作，若在没有发生碰撞时同样要发生的动作与效果的实现算法如下：

private void handleRoleAction() {

Role role = mRole;

for (Footboard footboard : mFootboardList) {

if((role.getMaxY()>=footboard.getMinY()&&role.getMaxY()<footboard.getMaxY())&&(role.getMaxX()>footboard.getMinX()&&role.getMinX() < footboard.getMaxX())) {if (role.getRoleStatus() == ROLE_STATUS_ON_FOOTBOARD||role.getRoleStatus()==ROLE_STATUS_ON_FOOTBOARD_RIGHT||role.getRoleStatus()== ROLE_STATUS_ON_FOOTBOARD_LEFT) {

if (footboard.getType() == FOOTBOARD_TYPE_SPRING) {

mRoleVelocityY = mFootboartVelocity

- GAME_ATTRIBUTE_GRAVITY_VELOCITY;

role.addY(-1 * GAME_ATTRIBUTE_PIXEL_DENSITY_Y);

updateRoleStatus(ROLE_STATUS_FREEFALL);

return;

}

if (footboard.getType() == FOOTBOARD_TYPE_MOVING_LEFT) {

role.addX(BOARD_ATTRIBUTE_LEFT_VELOCITY);

} else if (footboard.getType() == FOOTBOARD_TYPE_MOVING_RIGHT) {

role.addX(BOARD_ATTRIBUTE_RIGHT_VELOCITY);

} else if (footboard.getType() == FOOTBOARD_TYPE_UNSTABLE

&& footboard.isBoardBreak()) {

mFootboardList.remove(footboard);

}

updateRoleStatus(ROLE_STATUS_ON_FOOTBOARD);

} else {

// 主角第一次触板

mScore += mLevel;

mRoleVelocityY = mFootboartVelocity;

role.setVirtualY(footboard.getVirtualY()

- ROLE_ATTRIBUTE_HEITH

* GAME_ATTRIBUTE_PIXEL_DENSITY_Y);

if (footboard.getType() == FOOTBOARD_TYPE_SPIKED) {

mHP -= 3;

}

if (mHP <= 0) {

mGameStatus = GAME_STATUS_GAMEOVER;

}

updateRoleStatus(ROLE_STATUS_ON_FOOTBOARD);

switch (footboard.getType()) {

case FOOTBOARD_TYPE_UNSTABLE:

mEffectFlag = EFFECT_FLAG_UNSTABLE;

break;

case FOOTBOARD_TYPE_SPRING:

mEffectFlag = EFFECT_FLAG_SPRING;

break;

case FOOTBOARD_TYPE_SPIKED:

mEffectFlag = EFFECT_FLAG_SPIKED;

break;

case FOOTBOARD_TYPE_MOVING_LEFT:

case FOOTBOARD_TYPE_MOVING_RIGHT:

mEffectFlag = EFFECT_FLAG_MOVING;

break;

default:

mEffectFlag = EFFECT_FLAG_NORMAL;

}

}

return;

}

}

if (mRoleVelocityY < mFootboartVelocity) {

mRoleVelocityY += 3;

} else {

mRoleVelocityY = GAME_ATTRIBUTE_GRAVITY_VELOCITY;

}

updateRoleStatus(ROLE_STATUS_FREEFALL);

}

7.3.6判断主角与加分物品的关系

在该游戏中为了提高游戏的可玩性与娱乐性，设计有主角捡到加分物品可以加分的机制，当然不同的加分物品所加的分值不同，那么如何才能判断主角捡到加分物品呢？下面就是判断主角与加分物品关系的实现算法。

private void handleFood() {

Food food = mCurFood;

food.mTimeCounter--;

if (food.mFoodReward != FOOD_NONE && food.mTimeCounter > 0) {

if ((mRole.getMaxX()>food.mMinX&& mRole.getMinX() < food.mMaxX)

&& ((mRole.getMaxY() >= food.mMinY && mRole.getMaxY()< food.mMaxY) || (mRole.getMinY() > food.mMinY && mRole.getMinY() <= food.mMaxY))) {

mEffectFlag = EFFECT_FLAG_TOOLS;

mScore += food.mFoodReward;

food.mFoodReward = FOOD_NONE; }}}

7.3.7重力感应系统

注册重力感应监听

mSensorManager.registerListener(mSensorEventListener, mSensor,

SensorManager.SENSOR_DELAY_GAME);

注销重力感应监听

mSensorManager.unregisterListener(mSensorEventListener, mSensor);

7.3.8游戏难度的提升

private void increaseLevel() {

mLevel++;

if (mLevel < 18 || mLevel % 20 == 0) {

mFootboartVelocity -= 2;

int roleStatus = mRole.getRoleStatus();

if (roleStatus == ROLE_STATUS_ON_FOOTBOARD

|| roleStatus == ROLE_STATUS_ON_FOOTBOARD_RIGHT

|| roleStatus == ROLE_STATUS_ON_FOOTBOARD_LEFT) {

mRoleVelocityY = mFootboartVelocity;

}

7.3.9 设置实现

初始化音效：

soundPool = new SoundPool(10, AudioManager.STREAM_RING, 5);

soundPoolMap = new HashMap<Integer, Integer>();

soundPoolMap.put(UIModel.EFFECT_FLAG_NORMAL, soundPool.load(

getContext(), R.raw.normal, 1));

soundPoolMap.put(UIModel.EFFECT_FLAG_UNSTABLE, soundPool.load(

getContext(), R.raw.unstable, 1));

soundPoolMap.put(UIModel.EFFECT_FLAG_SPRING, soundPool.load(

getContext(), R.raw.spring, 1));

soundPoolMap.put(UIModel.EFFECT_FLAG_SPIKED, soundPool.load(

getContext(), R.raw.spiked, 1));

soundPoolMap.put(UIModel.EFFECT_FLAG_MOVING, soundPool.load(

getContext(), R.raw.moving, 1));

soundPoolMap.put(UIModel.EFFECT_FLAG_TOOLS, soundPool.load(

getContext(), R.raw.tools, 1));

播放音效：

private void playSoundEffect(int soundId) {

try {

AudioManager mgr = (AudioManager) getContext()

.getSystemService(Context.AUDIO_SERVICE);

float streamVolumeCurrent = mgr

.getStreamVolume(AudioManager.STREAM_RING);

float streamVolumeMax = mgr

.getStreamMaxVolume(AudioManager.STREAM_RING);

float volume = streamVolumeCurrent / streamVolumeMax;

soundPool.play(soundPoolMap.get(soundId), volume, volume, 1, 0,

1f);

} catch (Exception e) {

Log.d("PlaySounds", e.toString());

}

}

音效的设置如图7.3。

图 7.3 音效设置

系统测试

8.1 测试的目的及意义

系统测试是为了发现错误而执行程序的过程，成功的测试是发现了至今尚未发现的错误的测试。

测试的目的就是希望能以最少的人力和时间发现潜在的各种错误和缺陷。应根据开发各阶段的需求、设计等文档或程序的内部结构精心设计测试用例，并利用这些实例来运行程序，以便发现错误。信息系统测试应包括软件测试、硬件测试和网络测试。硬件测试、网络测试可以根据具体的性能指标来进行，此处所说的测试更多的是指软件测试。

系统测试是保证系统质量和可靠性的关键步骤，是对系统开发过程中的系统分析系统设计和实施的最后复查。根据测试的概念和目的，在进行信息系统测试时应遵循以基本原则。应尽早并不断地进行测试。测试不是在应用系统开发完之后才进行的。由于原始问题的复杂性、开发各阶段的多样性以及参加人员之间的协调等因素，使得毛开发各个阶段都有可能出现错误。因此，，测试应贯穿在开发的各个阶段，尽早纠正错误，消除隐患。

测试工作应该避免由原开发软件的人或小组承担，一方面，开发人员往往不愿召认自己的工作，总认为自己开发的软件没有错误；另一方面，开发人员的错误很对由本人测试出来，很容易根据自己编程的思路来制定测试思路，具有局限性。测试工作应由专门人员来进行，这样会更客观，更有效。

在测试程序时，不仅要检验程序是否做了该做的事，还要检验程序是否做了不该做的事。多余的工作会带来副作用，影响程序的效率，有时会带来潜在的危害或错误 。

严格按照测试计划来进行，避免测试的随意性。测试计划应包括测试内容、进度安排、人员安排、测试环境、测试工具和测试资料等。严格的按照测试计划可以；认证进度，使各方面都得以协调进行。

妥善保存测试计划、测试用例，作为软件文档的组成部分，为维护提供方便。

测试是开发过程中一个独立且非常重要的阶段，测试过程基本上与开发过程平行。

8.2测试步骤

8.2.1 模拟器测试

为了更好的测试游戏的可用性现用安卓模拟器进行测试，首先打开Eclipse软件，通过import将源代码导入工作区，然后点击工具栏的开始按钮打开模拟器进行运行，当游戏进入游戏主界面时按照以下步骤进行测试。

（1）点击“选项”播放背景音乐效果

结果：正常

（2）点击“选项”播放震动效果

结果：正常

（3）点击“选项”开始游戏前显示提示信息

结果：正常

（4）点击“选项”播放背景音乐效果

结果：正常

（5）点击“选项”播放背景音乐效果

结果：正常

（6）点击“选项”输入玩家名称

结果：正常

游戏结果如下图所示。

图 8.1 游戏主界面

图 8.2 设置选项界面

图 8.3 开始游戏界面

图 8.4 游戏结束界面

8.2.2 真机测试

由于考虑到模拟器的某些bug,所以要求在真机上进行测试，首先将游戏安装包通过手机数据线传到手机内存卡里面，然后在手机文件管理里找到游戏APK安装包点击安装，然后在手机界面打开游戏进行测试，测试结果截图如下：

8.5 真机游戏主界面 8.6 真机设置选项界面

8.7 真机排行榜界面 8.8 真机开始游戏界面

8.9 真机游戏结束界面

8.3 测试结果分析

经过模拟器和真机测试，本游戏实现了基本的功能，不过整体功能还不是很强大，游戏在很多方面还需要进一步完善与改进，对于游戏能够正常运行的结果很满意。

结束语

在我接到“基于Android的游戏开发”课题时，由于本人以前从来没有接触过游戏设计，所以我就意识到开发Android游戏任务的艰巨，刚开始着手开发游戏时有点迷茫和彷徨，后来通过老师的指导和在网上查找资料，逐渐找到了一些设计思路。

通过本次毕业设计让我了解到了Android游戏所涉及到的相关技术、方法，包括Android系统的基本架构与工作机制等。而且能够在Android开发平台上开发并演示一些基本软件，通过此次设计让我收获颇多。

首先，学到了很多新知识，并且能够将以前所学的知识、学习方法及思维方式学以致用。经过长时间的学习，进一步熟悉了Java程序设计语言。

其次，通过本次设计提高了我的动手能力，能够主动提出问题，遇到不会的知识点会主动查阅相关资料，通过实践想办法解决问题，深刻的意识到了“纸上得来终觉浅，绝知此事要躬行”的道理，也明白了实践是检验一切真理的唯一手段。

最后，提高了我对检索相关资料的能力。这次毕业设计过程中我查阅了很多资料，包括网络中的电子文档、电子书籍、网页及下载的视频教学课程；不但有中文资料还有英文资料。这些资料，使我的眼界更开阔，对课题的认识更加深刻，编写程序的时候思路更加清楚，少走了很多弯路。

回顾这个设计过程,我不仅学到了许多书本上以前没注意到的知识而且学到了书本外的知识。通过这次设计，能够晚上自己亲手开发的游戏，感觉很有成就感,这次设计不仅丰富了自己的实践技能而且扩展了本专业的知识面,使我受益非浅,同时也体验到了搞软件开发的困难度。在这次设计的同时,我又从中学到了不少珍贵的东西。但由于我对这样的软件开发还只是一个开始，了解的不多，这其中或许还有很多的不足，有些模块做得不是很好，有些功能还不能够完全的实现。因此做得不是很好，界面的设计及整体的布局还比较简单，没有突出特色出来，这是我这个系统的不足之处，也是我以后工作与学习中需要提升与完善的地方。

致 谢

在完成该设计时，我是无比的兴奋，因为多个月的努力终于有结果了，当然这还得感谢我的指导老师刘爱琴，她在毕业设计期间对本人给予了悉心指导和大力帮助。在我课题设计和论文撰写的过程中，对我进行了严格督促、认真检查和仔细批阅，而且关于我的课题也提出了很多富有启发性的意见和建议。

当然这也得感谢我班的同学，在精神上给予了我最大的鼓舞和帮助，我们共同监督共同学习和进步。

同时，感谢我身边的朋友，在本人程序设计和论文撰写最艰难时期，他们不断鼓励和帮助我。

最后，还要向我的家人表示深深的感谢，他们给予了我精神和物质上的支持，没有他们的帮助和关怀，也许我就无法顺利地完成这次毕业设计。

参考文献

[1] 雍俊海. Java程序设计.北京:清华大学出版社，2004年

[2] Horstmann ,C.S.著 ，叶乃文，杜永萍译.Java核心技术卷I：基础知识. 北京：机械工业出版社，2008年

[3]朱福喜，黄昊. Java项目开发与毕业设计指导.北京:清华大学出版社,2008年

[4]杨丰盛.Android应用开发揭秘.机械工业出版社，2010年

[5]Vladimir Silva 著,王恒 ,苏金国 译.精通Android游戏开发.机械工业出版社，2010年

[6]张海潘. 软件工程导论（第五版）.北京：清华大学出版社，2008年

附录 外文翻译

Introduction to Java

Java is designed to meet the challenges of application development in the context of heterogeneous, network-wide distributed environments. Paramount among these challenges is secure delivery of applications that consume the minimum of system resources, can run on any hardware and software platform, and can be extended dynamically.

Java originated as part of a research project to develop advanced software for a wide variety of network devices and embedded systems. The goal was to develop a small, reliable, portable, distributed, real-time operating platform. When the project started, C++ was the language of choice. But over time the difficulties encountered with C++ grew to the point where the problems could best be addressed by creating an entirely new language platform. Design and architecture decisions drew from a variety of languages such as Eiffel, SmallTalk, Objective C, and Cedar/Mesa. The result is a language platform that has proven ideal for developing secure, distributed, network based end-user applications in environments ranging from network-embedded devices to the World-Wide Web and the desktop.

The design requirements of Java are driven by the nature of the computing environments in which software must be deployed.

The massive growth of the Internet and the World-Wide Web leads us to a completely new way of looking at development and distribution of software. To live in the world of electronic commerce and distribution, Java must enable the development of secure, high performance, and highly robust applications on multiple platforms in heterogeneous, distributed networks.

Operating on multiple platforms in heterogeneous networks invalidates the traditional schemes of binary distribution, release, upgrade, patch, and so on. To survive in this jungle, Java must be architecture neutral, portable, and dynamically adaptable.

The Java system that emerged to meet these needs is simple, so it can be easily programmed by most developers; familiar, so that current developers can easily learn Java; object oriented, to take advantage of modern software development methodologies and to fit into distributed client-server applications; multithreaded, for high performance in applications that need to perform multiple concurrent activities, such as multimedia; and interpreted, for maximum portability and dynamic capabilities.

Together, the above requirements comprise quite a collection of buzzwords, so let’s examine some of them and their respective benefits before going on.

What’s completely new is the manner in which Java and its run-time system have combined them to produce a flexible and powerful programming system..

Developing your applications using Java results in software that is portable across multiple machine architectures, operating systems, and graphical user interfaces, secure, and high performance, With Java, your job as a software developer is much easier—you focus your full attention on the end goal of shipping innovative products on time, based on the solid foundation of Java. The better way to develop software is here, now, brought to you by the Java language platform.

Very dynamic languages like Lisp, TCL, and SmallTalk are often used for prototyping. One of the reasons for their success at this is that they are very robust—you don’t have to worry about freeing or corrupting memory.

Similarly, programmers can be relatively fearless about dealing with memory when programming in Java, The garbage collection system makes the programmer’s job vastly easier; with the burden of memory management taken off the programmer’s shoulders, storage allocation errors go away. Another reason commonly given that languages like Lisp, TCL, and SmallTalk are good for prototyping is that they don’t require you to pin down decisions early on—these languages are semantically rich.

Java has exactly the opposite property: it forces you to make explicit choices. Along with these choices come a lot of assistance—you can write method invocations and, if you get something wrong, you get told about it at compile time. You don’t have to worry about method invocation error.

The Java beginner must grasp 30 basic concepts

Basic concept

　1.In OOP the only relations is what the object’s interface, such as the computer seller he leaves alone internal structure of electrical source, but he is only concerned about that whether the power will be supplied to you, also so long as know can or not but is not how and why.All procedures are make up of certain attribute and the behavior object, the different object visit invokes through the function invocation, between the object all intercommunion are invoke through the method invocation, By object data encapsulation, enhances reuse rate very much..

2.In OOP the most important thought is class, the class is the template ,is a blueprint, construct an object from a class, namely construct an instance of the class.

3. Encapsulation: is that combines the data and the behavior in a package) and hides the data the realization process to the object user, in an object data is called its instance field.

　　4.Through expands a class to obtain a new class is called inheritance, but all classes are constructed by the object super root class of expansion, super root class of as follows can make the introduction.

　　5.Object 3 principal characteristics

　　Behavior--- explained this object can make what.

　　Tate--- when the object exerts the method object reflection.

　　Dentity--- and other similar behavior objects discrimination symbols.

　　Each object has only indentity and among three characteristics they affect mutually.

　　6. Relations among classes:

　　Use-a:Dependent relation

　　Has-a:Polymerization relation

　　Is-a: inheritor relation -- example:A class has inherited B class, this time A class not only has B class of method, but also has its own method(Individuality exists in general character)

　　7.Structure object use structure:Structure proposing, the structure is one special method, the structure object and to its initialization.

　　Example:A Data class of structure calls Data

　　New Data () --- structure a new object, also initialize current time.

　　Data happyday=new Data () --- an object evaluates an variable happyday, thus enables this object to be used many times, here be stated the cause variable and the object variable are different.

　　New returns the value is a quotation.

　　Constructor characteristic:The constructor may have 0, one or many parameters

　　The constructor and the class have the same name

A class may have many constructor. The constructor has not returned value

　 The constructor always be together used with the new operator

　　8. Over loading: When many methods have the same name when includes the different parameter, then has the over loading Which method does the compiler have to choose invokes.

　　9.Package : Java allow one or many classes to become together as group, is called package, to organizing duty easily, the standard Java storehouse divides into many packages Java.Lang java.Util java, net and so on, the package is layered and all java packages are in java and in a javax package.

　　10. Extendable thought: permit to construct new class on existing classes , when you extend the class which already existed, then you reuse this class of method and the field, at the same time you might add the new method and the field in the new class.

11.Expandable class:The expandable class fully manifested is-a to extend the relations The form is:Class (subclass) extends (base class).

　　12. Multi-modality: In java, the object variable is multi-modality But in java does not support multiple extend.

13.Dynamic combine: the mechanism of invoking object method mechanism.

　　 1) compiler examines object statement type and method name.

　　 2) the compiler examines that method invokes parameter type.

　　 3) static combine: If the method type is priavte static the final ,compiler can accurately know which method should invoke.

　　 4) when the procedure runs and uses dynamic combine to invoke a method, the method edition which then hypothesized machine must invoke x the object actual type which aims at to match.

　　 5) dynamic combine: is a very important characteristic, it can cause the procedure to change again may expand but does not need to translate has saved the code.

　 14.Final class:In order to prevent other people derive the new class from yours class, this class is cannot expanded.

15.The dynamic invocation spend longer time than the static invocation expenditure.

　　16.Abstract class:Stipulated or many abstract methods class of itself must define is abstract.

Example: Public abstract string getDescripition

　　17.In Java each class is be extended by object class.

　　18. equal and toString method in object class .

　　Equal uses in testing an object is whether equal with another object.

　　ToString returns to represent this object the string of character, each class can nearly over loading this method, in order to returns to the current condition the correct expression.

　　(The toString method is a very important method)

　　19.General programming:Any class of type all values all may replace with a object class of variable.

20.The array tabulates: The ArrayList dynamic array tabulates, is a class of storehouse, defines in java.In uitl package, but automatic control array size.

21.in class and class of object ,getclass method returns to the class type an example, when the procedure start contains can increase in the main method class, hypothesized confidential increase all classes which he needs, each increase class all must increase the class which it needs.

　　22.The class: class might dynamic operate the java code for the compilation the procedure to provide the formidable function reflection, this function was JavaBeans is specially useful, the use reflected Java to be able to support the VB programmer to be familiar with the use the tool.

　　procedure of analysis class ability is called the reflector, in Java to provide this function the package to call Java.Lang.The reflect reflection mechanism is extremely formidable.

　　1) when run analysis class ability.

　　2) when run searches observes a class of object.

　　3) realizes the general array operation code.

　　4) provides the method object.

　　But this mechanism mainly aims at the tool but not the application and the procedure.

　　In the reflection mechanism most important part is that permits class that you inspect structure. With to API includes:

　　Java.Lang.Reflect.Field returns to the field.

　　Java.Reflect.Method returns to the method.

　　Java.Lang.Reflect.Constructor returns to the parameter.

　　Method pointer: Java does not have the method pointer, makes a method address another method, may invoke it in behind, but the interface is the better solution.

　　23. interface: should showing class could do what but not to assign how to do, a class may realize one or many interfaces.

　　24.The interface is not a class, but is to conforms to a interface request class of set of standard.

　　If realizes a interface to need 2 steps:

　　1) the statement class needs to realize assigns the interface.

　　2) provides in the interface all methods definition.

　　Stated a class realizes a interface to need to use the implements key words

　　Class actionB implements Comparable its actionb needs to provide the CompareTo method, the interface is not the class, cannot use a new example interface.

　　25.A class only then a super class, but a class can realize many interfaces. In a Java important interface: Cloneable

　　26.The interface and call-back :to programs a commonly used pattern is call-back,in the pattern, you may refer when this class of pattern settled specific time occurs returns to adjusts on the object the method.

　　Example:ActionListener interface monitor.

　　Similar API includes:

　　Java.Swing.JOptionPane

　　Java.Swing.Timer

　　Java.Awt.Tookit

　　27.Object clone:The clone method is a object protection method, this meant your code cannot simple invoke it.

　　28.Inner class an inner class definition is the definition in another class.

　　The reason is:

1) an inner class object can visit founds its object realization, including private data.

　　2) about other classes in the same package in that, inner class can be hided.

　　3) the anonymous inner class may the very convenient definition accent.

　　In 4) uses the category to be possible the extremely convenient compilation event driver.

　　29.Agent class (proxy):

　　1) appointing all codes that interfaces request

　　2) all methods (toString equals) that object class define

　　30.Data type:Java is kind of emphasizing type language, each variable all must be declared its types at first, in java altogether has 8 basic types . four kinds are the long, two kinds are the float, one is the char, being used in the Unicode code char, Boolean.

1. java is simple

Java and C + + are very similar, but much simpler. All the high-level programming language features, is not absolutely necessary have been deleted. For example, Java does not overload operator, the title of the document, pre-processing, computing pointer, the structure of the joint, multi-dimensional array, templates and implicit type conversion. If you know a little C, C + + or Pascal, you will soon master Java. Here is a simple procedure JavaHelloWorld:

publicclassHelloInternet (

publicstaticvoidmain (Stringargv []) (

System. out. println ( "HelloIn-ternet!")

)

)

2. Java is object-oriented

Java is an object-oriented programming language. In addition to the simple types, such as digital and Boolean operators in addition, Java is an object of most. As with any object-oriented languages, Java code also organized by category. Each category provides a definition of the object behavior. Another type of succession can be a kind of behavior. In the category of the root level, often the target category. Java support for the single type of inherited hierarchy. This means that each category can only inherit one other category. Some of the language to allow multiple inheritance, but it may cause confusion and unnecessarily complicated language. For example, imagine that an object would inherit two completely different category. Java also supports the kind of summary of the interface. This allows programmers to define the interface methods, and do not have to rush immediately to determine the methods to achieve. A type of interface can be a number of purposes in order to truly multi-inheritance of a number of advantages. The implementation of an object can be any number of interfaces. IDL interface and Java interface very similar. Very easy to set up IDLJ compiler. In other words, Java can be used to create a CORBA object system distributed object system. In the view of many computer systems use IDL interface and CORBA objects, such compatibility is important.

3. Java is a type of static

In a Java program, it is essential to the definition used by the target (number of characters, such as an array) type. This will help programmers quickly found because the procedure when the compiler can detect the type of error. However, Java System objects are also dynamic types. A requirement for the type of dynamic is often possible, so programmers can write the procedures for different types of objects to do different things.

4. Is a Java-based compiler

When running Java programs, which were first compiled into byte code. Byte code is very similar to the machine instructions, so Java program is very efficient. However, the byte code does not specifically for a particular machine, so no need to recompile Java program can be in many different computer implementation. Java source code files were compiled into a category, which is equivalent to process byte code performance. In a Java class file, and an example for all of the variables are in the light of, and for the first time in the implementation of the code be resolved. This makes the code more common and more easily subject to revision, but still high.

5. Java is architecture neutral

Java language is the same for each computer. For example, simple types are the same: 32-bit integer always, always 64-bit long integers. It is strange, such as C and C + + programming language, and so fashionable it is not the case. As a result of these languages so the definition of freedom, each of the compiler and development environment will be different, so that this process nuisance become a transplant. Java programs can easily gain access to transplants, and there is no need to re-compile.

6. Java is a sound

Java program can not be caused by the collapse of the computer. Java careful testing of the system memory of each visit, make sure it is legitimate and will not cause any problems. However, even if the Java program may also be wrong. If there is some kind of unexpected things, the process will not collapse, and to abandon the exception. Procedures for such an exception would be found to address them. Traditional computer programs can access the full memory. May (unconsciously) to amend any of the value of memory, which will cause problems. Java program can only access memory to allow them access to those parts of the Java program can not modify it does not seek to change the value.

7. Java is a compact

As the Java is designed to run on a small computer, as a programming language for the system is relatively small. It effectively in more than 4MB of RAM to run on PC machine. Java translator occupied by only a few hundred KB. This translator for the Java platform independence and portability is reliable. Due to Java is very small, it is a very small computer memory, such as the Java-based PC, as well as television sets, ovens, telephone and home computer, and so on, it is ideal.

8. Java is a multi-threaded

Java program can run more than one thread. For example, it can be a thread in a time-consuming to complete the calculation, and other users to interact with the threads of dialogue. Therefore, users do not have to stop working, waiting for the Java computing time-consuming process. In the multi-threaded programming environment, it is often difficult because many things may occur at the same time. However, Java provides easy-to-use features simultaneously, so that the programming easier.

Java的介绍

Java是被设计用来解决在上下文分布式的异构网络中应用程序开发的问题。在这些复杂问题中，首要的是安全发布应用程序、消耗最小的系统资源、可以在任何硬件和软件平台上运行以及被动态地扩展。

Java最初是作为研发方案的一部分而开发的，这个研究方案是为了给广阔多样的网络设备和嵌入式系统开发高级的软件。目标是开发一个小巧的、可靠性高的、可移植的、分布式的、实时的操作系统平台。当这个方案开始的时候，C++是精选的语言，但是过了一段时间，用C++语言遇到的困难也随之增长，解决这些问题最好的办法是创造一个全新的语言平台。设计和体系结构的决定汲取了多种语言，例如Eiffel、 SmallTalk,、Objective C以及 Cedar/Mesa。结果证明这个语言平台是理想的，对于开发一个可靠性高的、可移植的、分布式的、基于终端用户网络的应用程序在多种环境中广泛搜索从嵌入网络的设备到万维网和桌上型电脑。

Java的需求设计通过自然状态的，在软件必须被配置的处理环境中被推动的。

因特网和万维网的巨大发展导致我们完全地以新的情形着眼于开发和发行软件。对于全球电子化的商业和销售发行的存在，Java必须使安全的，高性能的和非常健壮的应用程序在多平台异构的，分布式的网络中开发。

在异构的网络中，多平台上运行会使传统配置的二进制发送、释放、更新、补丁等等无效。为了在这些问题中幸存下来，Java必须是体系结构中立的、可移植的以及可以被动态的修改。

为满足以上的需求而开发的Java系统是简单的，所以它能够被绝大多数的程序员进行编程；熟悉的，所以当前的程序员学习Java语言是简单的；面向对象的，为了利用现代的软件开发方法学和适合分布式的客户机/服务器应用程序；多线程的，为了高性能在应用程序中需要执行多个并发的活动,例如多媒体；解释的，为了最大极限的可移植和动态的容量。

同时，以上的需求完全是由收集的时髦词语组成的，所以在开始以前让我们来查看它们中的一些和它们的各自的优点。

什么是完全新的，样式风格在Java语言和它的运行系统结合它们来产生一个灵通的且强大的编程系统。

在软件中，用Java语言开发的你的应用程序可以在多种机器总体结构、操作系统和图形用户接口之间移植。运用Java语言，诸如软件开发者的工作就会变得简单的多​——你会把你的全部精力都集中在最终的目标：准时运送革新的产品、基于可靠的构造的Java语言。较好的开发软件的方法在这里，现在，Java语言平台会带给你这些。

许多动态的语言像Lisp、TCL和 SmallTalk通常被应用于原型构造技术它们成功原因中的一个在于它们非常健壮——你没有必要去担心关于解除或破坏存储器。

同样的，程序员可以相对大胆的处理存储器，当在Java语言里面编程的时候。垃圾回收系统使程序员的工作大为容易，卸下了程序员肩上存储管理之负担，存储分配错误不再发生。

一般认为像Lisp, TCL, 和 SmallTalk这样一些语言十分适合于原型法的另一个理由，是因为它们不要求你受早期决定的约束——这些语言的语义是很丰富的。

Java语言有着严密的对应的属性：它促使你做出清楚的选择。伴随着这些选择带来了许多的协助——你可以写一个方法调用，而且如果你在编写时有一些错误的时候，在编译的时候将会被告知。你没有必要去担心关于方法调用的错误。

Java初学者需掌握的30个基本概念

基本概念：

1.OOP中唯一关系是什么是对象的接口，就像计算机的销售商不管电源内部结构是怎样的，它只关心能否给你提供电，也就是只要知道能或不能而不是知道怎样和为什么会有电。所有的程序是由一定的属性和行为对象组成的，不同的对象的访问通过函数调用来完成，对象间所有的交流都是通过方法调用，通过封装对象数据，很大限度上提高复用率。

2.OOP中最重要的思想是类，类是模板是蓝图，从类中构造一个对象，即创建了这个类的一个实例(instance)。

3.封装：就是把数据和行为结合起在一个包中，并对对象使用者隐藏数据的实现过程，一个对象中的数据叫他的实例字段(instance field)。

4.通过扩展一个类来获得一个新类叫继承(inheritance)，而所有的类都是由Object根超类扩展而得，根超类下文会做介绍。

5.对象的3个主要特性：

Behavior——说明这个对象能做什么。

Tate——当对象施加方法时对象的反映。

Dentity——与其他相似行为对象的区分标志。

每个对象有唯一的indentity 而这3者之间相互影响。

6.类之间的关系：

use-a ：依赖关系

has-a ：聚合关系

is-a ：继承关系——例:A类继承了B类，此时A类不仅有了B类的方法，还有其自己的方法(个性存在于共性中)。

7.构造对象使用构造器:构造器的提出，构造器是一种特殊的方法，构造对象并对其初始化。

例:Data类的构造器叫Data。

New Data()——构造一个新对象，且初始化当前时间。

Data happyday=new Data()——把一个对象赋值给一个变量happyday，从而使该对象能够多次使用，此处要声明的使变量与对象变量二者是不同的。

new返回的值是一个引用。

构造器特点:构造器可以有0个，一个或多个参数。

构造器和类有相同的名字。

一个类可以有多个构造器,构造器没有返回值,构造器总是和new运算符一起使用。

8.重载:当多个方法具有相同的名字而含有不同的参数时，便发生重载.编译器必须挑选出调用哪个方法。

9.包(package)Java允许把一个或多个类收集在一起成为一组，称作包，以便于组织任务，标准Java库分为许多包Java.lang java.util java，net等，包是分层次的所有的java包都在java和javax包层次内。

10.继承思想：允许在已经存在的类的基础上构建新的类，当你继承一个已经存在的类时，那么你就复用了这个类的方法和字段，同时你可以在新类中添加新的方法和字段。

11.扩展类：扩展类充分体现了is-a的继承关系，形式为：class (子类) extends (基类)。

12.多态：在java中，对象变量是多态的，而java中不支持多重继承。

13.动态绑定：调用对象方法的机制。

1）编译器检查对象声明的类型和方法名。

2）编译器检查方法调用的参数类型。

3）静态绑定：若方法类型为priavte static final 编译器会准确知道该调用哪个方法。

4）当程序运行并且使用动态绑定来调用一个方法时，那么虚拟机必须调用x所指向的对象的实际类型相匹配的方法版本。

5）动态绑定：是很重要的特性，它能使程序变得可扩展而不需要重编译已存代码。

14.final类：为防止他人从你的类上派生新类，此类是不可扩展的。

15.动态调用比静态调用花费的时间要长。

16.抽象类：规定一个或多个抽象方法的类本身必须定义为abstract。

例:：public abstract string getDescripition

17.Java中的每一个类都是从Object类扩展而来的。

18.object类中的equal和toString方法。

equal用于测试一个对象是否同另一个对象相等。

toString返回一个代表该对象的字符串，几乎每一个类都会重载该方法，以便返回当前状态的正确表示(toString 方法是一个很重要的方法)。

19.通用编程：任何类类型的所有值都可以同object类性的变量来代替。

20.数组列表：ArrayList动态数组列表，是一个类库，定义在java.uitl包中，可自动调节数组的大小。

21.class类 object类中的getclass方法返回class类型的一个实例，程序启动时包含在main方法的类会被加载，虚拟机要加载他需要的所有类，每一个加载的类都要加载它需要的类。

22.class类为编写可动态操纵java代码的程序提供了强大的功能反射，这项功能为JavaBeans特别有用，使用反射Java能支持VB程序员习惯使用的工具。

能够分析类能力的程序叫反射器，Java中提供此功能的包叫Java.lang.reflect反射机制十分强大。

1）在运行时分析类的能力。

2）在运行时探察类的对象。

3）实现通用数组操纵代码。

4）提供方法对象。

而此机制主要针对是工具者而不是应用及程序。

反射机制中的最重要的部分是允许你检查类的结构.用到的API有：

java.lang.reflect.Field 返回字段。

java.reflect.Method 返回方法。

java.lang.reflect.Constructor 返回参数。

方法指针:java没有方法指针，把一个方法的地址传给另一个方法，可以在后面调用它，而接口是更好的解决方案。

23.接口(Interface)说明类该做什么而不指定如何去做，一个类可以实现一个或多个interface。

24.接口不是一个类，而是对符合接口要求的类的一套规范。

若实现一个接口需要2个步骤：

1）声明类需要实现的指定接口。

2）提供接口中的所有方法的定义。

声明一个类实现一个接口需要使用implements 关键字。

class actionB implements Comparable 其actionb需要提供CompareTo方法，接口不是类，不能用new实例化一个接口。

25.一个类只有一个超类，但一个类能实现多个接口。Java中的一个重要接口：Cloneable。

26.接口和回调.编程一个常用的模式是回调模式，在这种模式中你可以指定当一个特定时间发生时回调对象上的方法。

例:ActionListener 接口监听。

类似的API有：

java.swing.JOptionPane

java.swing.Timer

java.awt.Tookit

27.对象clone:clone方法是object一个保护方法，这意味着你的代码不能简单的调用它。

28.内部类：一个内部类的定义是定义在另一个内部的类。

原因是：

1）一个内部类的对象能够访问创建它的对象的实现，包括私有数据。

2）对于同一个包中的其他类来说，内部类能够隐藏起来。

3）匿名内部类可以很方便的定义回调。

4）使用内部类可以非常方便的编写事件驱动程序。

29.代理类(proxy)：

1）指定接口要求所有代码。

2）object类定义的所有的方法(toString equals)。

30.数据类型：Java是强调类型的语言，每个变量都必须先申明它的类型，java中总共有8个基本类型：4种是整型，2种是浮点型，一种是字符型，被用于Unicode编码中的字符，布尔型。

1.Java是简单的

Java与C++极为相似，但却简单得多。高级编程语言的所有特性中，不是绝对需要的都已删去了。例如，Java没有算符过载、标题文件、预处理、指针运算、结构、联合、多维数组、模板及隐式类型变换。如果你知道一点C、C++或Pascal，你很快就会驾驭Java。这里是一个简单的JavaHelloWorld程序：

　　publicclassHelloInternet{

　　publicstaticvoidmain(Stringargv[]){

　　System。out。println(“HelloIn-ternet!”)

　　}

　　}

2.Java是面向对象的

Java是一种面向对象的编程语言。除了简单的类型，如数字和布尔算子之外，Java中的大部分都是对象。正如任何面向对象的语言一样，Java代码也按类组织。每个类定义一组规定对象行为的方法。一个类可以继承另一个类的行为。在类的根层次上，通常是类对象。Java支持单继承类层次结构。这就是说，每个类一次只能继承一个别的类。有些语言允许多继承性，但这可能造成混乱，使语言不必要地复杂化。例如，难以想像，一个对象会继承两个完全不同的类的行为。Java还支持摘要类的接口。这允许编程人员先定义接口的方法，而不必急于马上确定方法的实现。一个类可以施行多个接口，从而具有真正多继承性的许多优点。一个对象也可实施任意数量的接口。Java接口与IDL接口极其相似。很容易建立IDLJ编译器。这就是说，Java可用于CORBA对象系统来建立分布式对象系统。鉴于在许多计算机系统中都采用IDL接口和CORBA对象系统，这种兼容性是重要的。

3.Java是静态类型的

在一个Java程序中，必须定义所用对象(数字、字符、数组等)的类型。这有助于编程人员很快发现问题，因为当程序编译时可以检测类型错误。不过，Java系统中的对象也有动态类型。要求一个对象为动态类型往往是可能的，所以编程人员写的程序可以对不同类型的对象做不同的事。

4.Java是编译型的

当运行Java程序时，它首先被编译成字节代码。字节代码非常类似于机器指令，所以Java程序非常高效。然而，字节代码并不专对一种特定的机器，所以Java程序无需重新编译便可在众多不同的计算机上执行。Java源程序被编译成类文件，它相当于程序的字节代码表现。在一个Java类文件中，所有对方法及实例变量的参照均按名进行，并在第一次执行代码时加以分辨。这使得代码更通用，更不易受修改的影响，而仍具高效。

5.Java是体系结构中立的

Java语言对每种计算机都一样。比如，简单的类型都是不变的：整数总是32位，长整数总是64位。令人奇怪的是，诸如C及C++等时髦的编程语言却不是这样。由于这些语言定义如此自由，每种编译器及开发环境便各有不同了，这使程序的移植成为讨厌的问题。Java程序的移植却很容易，而且不需要进行重新编译。

6.Java是健全的

Java程序不可能造成计算机崩溃。Java系统仔细检测对内存的每次访问，确认它是合法的，而且不致引起任何问题。不过，即使Java程序也可能有错误。如果出现某种出乎意料之事，程序不会崩溃，而把该例外抛弃。程序会发现这类例外，并加以处理。传统的程序可以访问计算机的全部内存。程序可能(无意识地)修改内存中的任何值，这就会造成问题。Java程序只能访问内存中允许它们访问的那些部分，所以Java程序不可能修改不拟修改的值。

7.Java是小巧的

由于Java的设计是要在小的计算机上运行，作为一种编程语言来说其系统是相对较小的。它能有效地在4MB以上RAM的PC机上运行。Java翻译器只占用几百KB。这种翻译器对Java的平台无关性和可移植性是可靠的。由于Java很小，它对内存很小的计算机，如基于Java的PC机，以及电视机、烤箱、电话机及家用计算机等，是很理想的。

8.Java是多线程的

Java程序可以执行一个以上的线程。比如，它可以在一个线程中完成某一耗时的计算，而其它线程与用户进行交互对话。所以用户不必停止工作，等待Java程序完成耗时的计算。在多线程环境中的编程通常是困难的，因为许多东西可能同时出现。但是，Java提供了易于使用的同步特性，使编程更为方便。