devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

小飞机大作战（Android Studio）+java语言_android studio课程设计java

作者：我家自动化 | 2024-07-08 09:14:14

赞

踩

android studio课程设计java
  1. 概述
    1. 课程设计概述

       移动平台应用程序技术课程主要学习针对目前手机、平板电脑等移动终端的软件开发。我们的课程主要是在Android Studio平台上进行，通过一学期的学习，基本了解和掌握了Android开发的主要组件和软件实现方法。

       这次的课程设计报告主要是完成了一个小飞机大作战的游戏软件，在用户移动终端联网的情况下，用户注册并且登录进入游戏，操控飞机击败敌机，获取得分的记录。

    1. 主要内容

       本次课程设计报告的主要内容包括以下几点：

       （1）对于所设计软件的需求分析。

       （2）搭建Android工程的开发环境、测试环境。

       （3）基本功能的实现，美化软件界面，提高用户输入操作性和界面显示友好性。

       （4）说明开发过程中使用的新技术，以及使用这些技术所需要注意的问题，以及解决了什么问题；

       （5）思考总结开发过程中的问题和想法，在此基础上考虑软件的可扩展性和性能优化。

  1. 系统需求分析
    1. 业务需求分析

       用户通过注册模块，获取到一个账号权限。通过账号登录到小飞机大作战软件的主界面，进行游玩获取分数。

小飞机大作战游戏中不仅可以上下左右操控飞机攻击敌人，还可以捡取掉落物品提升能力，类似回复血量或者增加火力等。攻击这一行为看似简单，实际上涉及到游戏中碰撞机制的设定。

    1. 模型需求分析

       虽然小飞机大作战是一个小应用，但是仍然需要对其模型进行详细的分析。如下图2-1所示：

 

图2-1 小飞机大作战模型需求分析

    1. 界面需求分析

       移动平台软件的界面友好是一个比较重要的方面，界面的友好是用户使用软件的先决条件。

       小飞机大作战的登录界面设计模仿QQ等聊天软件，为玩家显示账号密码输入框，下方提供注册及登录按钮。游戏主界面简洁显示出包括开始游戏、设置、背景等选项并在语句下放置气泡类型图片与背景区分开。

  1. 系统设计    
    1. 主要功能设计

       （1）布局文件

       小飞机大作战的页面有五个：登录注册页面、游戏菜单主页面、设置页面、背景页面以及排行榜页面。其中本节点主要讲解登录界面的布局设计。菜单界面使用LinearLayout布局，使用一个FrameLayout来承载播放背景视频的videoView控件，

登录注册页面上方是用户名与密码的TextView控件，页面中央是注册与登录按钮，如图3-1所示。

                                                               图3-1 注册界面布局

       （2）主配置文件

       由于这个应用需要使用服务器，所以需要特别在AndroidManifest.xml文件中注册应用访问网络的权限，如下所示：

<uses-permission android:name="android.permission.INTERNET"/>

    1. 网络通讯设计

       游戏用户的登录注册需要使用到服务器，使用Java提供的相关类，可以很方便的进行书写，它的代码如下。

package myserver;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.OutputStream;

import java.net.ServerSocket;

import java.net.Socket;

import java.util.ArrayList;

public class MyServer

{

 // 定义保存所有 Socket 的 ArrayList

 public static ArrayList<Socket>socketList= new

ArrayList<Socket>();

 public static void main(String[] args) throws IOException

 {

 ServerSocket ss = new ServerSocket(9920);

 System.out.println("服务器已准备好");

 

while(true)

 {

 //此行代码会阻塞，将一直等待别人的连接

 Socket s = ss.accept();

 System.out.println("连接一个客户端");

 socketList.add(s);

 // 每当客户端连接后启动一条 ServerThread 线程为该客户端服务

 new Thread(new ServerThread(s)).start();

 }

 }

}

// 负责处理每个线程通信的线程类

class ServerThread implements Runnable

{

 // 定义当前线程所处理的 Socket

 Socket s =null;

 // 该线程所处理的 Socket 所对应的输入流

 BufferedReader br =null;

 public ServerThread(Socket s) throws IOException

 {

 this.s = s;

 // 初始化该 Socket 对应的输入流

 br =new BufferedReader(new

InputStreamReader(s.getInputStream() ,"utf-8"));

 }

 public void run()

 {

 try{

 String content =readFromClient();

 // 采用循环不断从 Socket 中读取客户端发送过来的数据

 while (content !=null)

 {

                System.out.println(content);

 // 遍历 socketList 中的每个 Socket，

 // 将读到的内容向每个 Socket 发送一次

for (Socket s : MyServer.socketList)

 {

 OutputStream os = s.getOutputStream();

 os.write((content +"\n").getBytes("utf-8"));

 }

 content =readFromClient();

 }

 }

catch (IOException e)

 {

 e.printStackTrace();

 }

 }

 // 定义读取客户端数据的方法

 private String readFromClient()

 {

 try{

 return br.readLine();

 }

 // 如果捕捉到异常，表明该 Socket 对应的客户端已经关闭

 catch (IOException e)

 {

 System.out.println("发生异常");

 // 删除该 Socket

 MyServer.socketList.remove(s);

 }

 System.out.println("未读到数据");

 return null;

 }

}

    1. 数据库表设计

表3-1 登录用户admin表

字段名

数据类型

能否为空

说明

描述

name

varchar(20)

Not null

用户名或账号

password

varchar(20)

Not null

用户登录密码

  1. 系统实现
    1. 系统界面

 

    1. 系统程序实现
      1. WebServer服务端程序实现

（1）项目整体框架

 

（2）处理登录逻辑的数据访问层核心代码

  1. package myserver;
  2.  
  3.  
  4.  
  5. import java.io.BufferedReader;
  6.  
  7. import java.io.IOException;
  8.  
  9. import java.io.InputStreamReader;
  10.  
  11. import java.io.OutputStream;
  12.  
  13. import java.net.ServerSocket;
  14.  
  15. import java.net.Socket;
  16.  
  17. import java.util.ArrayList;
  18.  
  19.  
  20.  
  21. public class MyServer
  22.  
  23. {
  24.  
  25.  // 定义保存所有 Socket 的 ArrayList
  26.  
  27.  public static ArrayList<Socket>socketList= new
  28.  
  29. ArrayList<Socket>();
  30.  
  31.  public static void main(String[] args) throws IOException
  32.  
  33.  {
  34.  
  35.  ServerSocket ss = new ServerSocket(9920);
  36.  
  37.  System.out.println("服务器已准备好");
  38.  
  39.  while(true)
  40.  
  41.  {
  42.  
  43.  //此行代码会阻塞，将一直等待别人的连接
  44.  
  45.  Socket s = ss.accept();
  46.  
  47.  System.out.println("连接一个客户端");
  48.  
  49.  socketList.add(s);
  50.  
  51.  // 每当客户端连接后启动一条 ServerThread 线程为该客户端服务
  52.  
  53.  new Thread(new ServerThread(s)).start();
  54.  
  55.  }
  56.  
  57.  }
  58.  
  59. }
  60.  
  61. // 负责处理每个线程通信的线程类
  62.  
  63. class ServerThread implements Runnable
  64.  
  65. {
  66.  
  67.  // 定义当前线程所处理的 Socket
  68.  
  69.  Socket s =null;
  70.  
  71.  // 该线程所处理的 Socket 所对应的输入流
  72.  
  73.  BufferedReader br =null;
  74.  
  75.  public ServerThread(Socket s) throws IOException
  76.  
  77.  {
  78.  
  79.  this.s = s;
  80.  
  81.  // 初始化该 Socket 对应的输入流
  82.  
  83.  br =new BufferedReader(new
  84.  
  85. InputStreamReader(s.getInputStream() ,"utf-8"));
  86.  
  87.  }
  88.  
  89.  public void run()
  90.  
  91.  {
  92.  
  93.  try{
  94.  
  95.  String content =readFromClient();
  96.  
  97.  // 采用循环不断从 Socket 中读取客户端发送过来的数据
  98.  
  99.  while (content !=null)
  100.  
  101.  {
  102.  
  103.         System.out.println(content);
  104.  
  105.  // 遍历 socketList 中的每个 Socket，
  106.  
  107.  // 将读到的内容向每个 Socket 发送一次
  108.  
  109.  for (Socket s : MyServer.socketList)
  110.  
  111.  {
  112.  
  113.  OutputStream os = s.getOutputStream();
  114.  
  115.  os.write((content +"\n").getBytes("utf-8"));
  116.  
  117.  }
  118.  
  119.  content =readFromClient();
  120.  
  121.  }
  122.  
  123.  }
  124.  
  125.  catch (IOException e)
  126.  
  127.  {
  128.  
  129.  e.printStackTrace();
  130.  
  131.  }
  132.  
  133.  }
  134.  
  135.  // 定义读取客户端数据的方法
  136.  
  137.  private String readFromClient()
  138.  
  139.  {
  140.  
  141.  try{
  142.  
  143.  return br.readLine();
  144.  
  145.  }
  146.  
  147.  // 如果捕捉到异常，表明该 Socket 对应的客户端已经关闭
  148.  
  149.  catch (IOException e)
  150.  
  151.  {
  152.  
  153.  System.out.println("发生异常");
  154.  
  155.  // 删除该 Socket
  156.  
  157.  MyServer.socketList.remove(s);
  158.  
  159.  }
  160.  
  161.  System.out.println("未读到数据");
  162.  
  163.  return null;
  164.  
  165.  }
  166.  
  167. }
  168.  
  169. （3）处理登录逻辑的访问请求Servlet核心代码
  170.  
  171. public class MyServer
  172.  
  173. {
  174.  
  175.  // 定义保存所有 Socket 的 ArrayList
  176.  
  177.  public static ArrayList<Socket>socketList= new
  178.  
  179. ArrayList<Socket>();
  180.  
  181.  public static void main(String[] args) throws IOException
  182.  
  183.  {
  184.  
  185.  ServerSocket ss = new ServerSocket(9920);
  186.  
  187.  System.out.println("服务器已准备好");
  188.  
  189.  while(true)
  190.  
  191.  {
  192.  
  193.  //此行代码会阻塞，将一直等待别人的连接
  194.  
  195.  Socket s = ss.accept();
  196.  
  197.  System.out.println("连接一个客户端");
  198.  
  199.  socketList.add(s);
  200.  
  201.  // 每当客户端连接后启动一条 ServerThread 线程为该客户端服务
  202.  
  203.  new Thread(new ServerThread(s)).start();
  204.  
  205.  }
  206.  
  207.  }
  208.  
  209. }

（3）处理注册逻辑的数据访问层核心代码

  1. // 负责处理每个线程通信的线程类
  2.  
  3. class ServerThread implements Runnable
  4.  
  5. {
  6.  
  7.  // 定义当前线程所处理的 Socket
  8.  
  9.  Socket s =null;
  10.  
  11.  // 该线程所处理的 Socket 所对应的输入流
  12.  
  13.  BufferedReader br =null;
  14.  
  15.  public ServerThread(Socket s) throws IOException
  16.  
  17.  {
  18.  
  19.  this.s = s;
  20.  
  21.  // 初始化该 Socket 对应的输入流
  22.  
  23.  br =new BufferedReader(new
  24.  
  25. InputStreamReader(s.getInputStream() ,"utf-8"));
  26.  
  27.  }
  28.  
  29.  public void run()
  30.  
  31.  {
  32.  
  33.  try{
  34.  
  35.  String content =readFromClient();
  36.  
  37.  // 采用循环不断从 Socket 中读取客户端发送过来的数据
  38.  
  39.  while (content !=null)
  40.  
  41.  {
  42.  
  43.         System.out.println(content);
  44.  
  45.  // 遍历 socketList 中的每个 Socket，
  46.  
  47.  // 将读到的内容向每个 Socket 发送一次
  48.  
  49.  for (Socket s : MyServer.socketList)
  50.  
  51.  {
  52.  
  53.  OutputStream os = s.getOutputStream();
  54.  
  55.  os.write((content +"\n").getBytes("utf-8"));
  56.  
  57.  }
  58.  
  59.  content =readFromClient();
  60.  
  61.  }
  62.  
  63.  }
  64.  
  65.  catch (IOException e)
  66.  
  67.  {
  68.  
  69.  e.printStackTrace();
  70.  
  71.  }
  72.  
  73.  }
  74.  
  75.  // 定义读取客户端数据的方法
  76.  
  77.  private String readFromClient()
  78.  
  79.  {
  80.  
  81.  try{
  82.  
  83.  return br.readLine();
  84.  
  85.  }
  86.  
  87.  // 如果捕捉到异常，表明该 Socket 对应的客户端已经关闭
  88.  
  89.  catch (IOException e)
  90.  
  91.  {
  92.  
  93.  System.out.println("发生异常");
  94.  
  95.  // 删除该 Socket
  96.  
  97.  MyServer.socketList.remove(s);
  98.  
  99.  }
  100.  
  101.  System.out.println("未读到数据");
  102.  
  103.  return null;
  104.  
  105.  }
  106.  
  107. }
  108.  
  109. （5）处理注册逻辑的访问请求Servlet核心代码
  110.  
  111. class ClientThread implements Runnable
  112.  
  113. {
  114.  
  115.     private Socket s;
  116.  
  117.     // 定义向 UI 线程发送消息的 Handler 对象
  118.  
  119.     private Handler handler;
  120.  
  121.     // 定义接收 UI 线程的消息的 Handler 对象
  122.  
  123.     public Handler revHandler;
  124.  
  125.     // 该线程所处理的 Socket 所对应的输入流
  126.  
  127.     BufferedReader br =null;
  128.  
  129.     OutputStream os =null;
  130.  
  131.     public ClientThread(Handler handler)
  132.  
  133.     {
  134.  
  135.         this.handler = handler;
  136.  
  137.     }
  138.  
  139.     public void run()
  140.  
  141.     {
  142.  
  143.         try {
  144.  
  145.             //10.0.2.2 为本机的 ip 地址
  146.  
  147.             s =new Socket("10.0.2.2", 9920);
  148.  
  149.             br =new BufferedReader(new
  150.  
  151.                     InputStreamReader(s.getInputStream()));
  152.  
  153.             os =s.getOutputStream();
  154.  
  155.             // 启动一条子线程来读取服务器响应的数据
  156.  
  157.             new Thread()
  158.  
  159.             {
  160.  
  161.                 public void run()
  162.  
  163.                 {
  164.  
  165.                     String content =null;
  166.  
  167. // 不断读取 Socket 输入流中的内容
  168.  
  169.                     try{
  170.  
  171.                         while ((content
  172.  
  173.                                 =br.readLine()) !=null)
  174.  
  175.                         {
  176.  
  177.                             // 每当读到来自服务器的数据之后，发送消息通知程序界面显示该数据
  178.  
  179.                             Message msg =new
  180.  
  181.                                     Message();
  182.  
  183.                             msg.what = 0x123;
  184.  
  185.                             msg.obj = content;
  186.  
  187.  
  188.  
  189.                             handler.sendMessage(msg);
  190.  
  191.                         }
  192.  
  193.                     }
  194.  
  195.                     catch (IOException e)
  196.  
  197.                     {
  198.  
  199.                         e.printStackTrace();
  200.  
  201.                     }
  202.  
  203.                 }
  204.  
  205.             }.start();
  206.  
  207.             // 为当前线程初始化 Looper
  208.  
  209.             Looper.prepare();
  210.  
  211.             // 创建 revHandler 对象
  212.  
  213.             revHandler =new Handler(){
  214.  
  215.                 public void handleMessage(Message msg)
  216.  
  217.                 {
  218.  
  219.                     // 接收到 UI 线程中用户输入的数据
  220.  
  221.  
  222.  
  223.                         // 将用户在文本框内输入的内容写入网络
  224.  
  225.                         try
  226.  
  227.                         {
  228.  
  229.                             os.write((msg.obj.toString() + "\r\n").getBytes("utf-8"));
  230.  
  231.                         }
  232.  
  233.                         catch (Exception e)
  234.  
  235.                         {
  236.  
  237.                             e.printStackTrace();
  238.  
  239.                         }
  240.  
  241.                     }
  242.  
  243.  
  244.  
  245.             };
  246.  
  247.             // 启动 Looper
  248.  
  249.             Looper.loop();
  250.  
  251.         }
  252.  
  253.         catch (SocketTimeoutException e)
  254.  
  255.         {
  256.  
  257.             System.out.println("网络连接超时！！");
  258.  
  259.         }
  260.  
  261.         catch (Exception e)
  262.  
  263.         {
  264.  
  265.             e.printStackTrace();
  266.  
  267.         }
  268.  
  269.     }
  270.  
  271. }
      1. Android客户端程序实现
  2. 项目整体框架

（2）Register中的登录按钮点击事件

  1. reday.setOnClickListener(new View.OnClickListener() {
  2.  
  3.     public void onClick(View v) {
  4.  
  5.         String name = username.getText().toString().trim();
  6.  
  7.         String password = userpassword.getText().toString().trim();
  8.  
  9.         if(!TextUtils.isEmpty(name)&&!TextUtils.isEmpty(password)){
  10.  
  11.             mSQlite.add(name,password);
  12.  
  13.             Intent intent1 = new Intent(Register.this,MainActivity.class);
  14.  
  15.             startActivity(intent1);
  16.  
  17.             finish();
  18.  
  19.             Toast.makeText(Register.this,"注册成功",Toast.LENGTH_SHORT).show();
  20.  
  21.         }else {Toast.makeText(Register.this,"信息不完备，注册失败",Toast.LENGTH_SHORT).show();}
  22.  
  23.     }
  24.  
  25. });
  26.  
  27. mSQlite = new SQlite(Register.this);
  28.  
  29. back.setOnClickListener(new View.OnClickListener() {
  30.  
  31.     @Override
  32.  
  33.     public void onClick(View v) {
  34.  
  35.         String name = username.getText().toString().trim();
  36.  
  37.         String password = userpassword.getText().toString().trim();
  38.  
  39.         if (!TextUtils.isEmpty( name ) && !TextUtils.isEmpty( password )) {
  40.  
  41.             ArrayList<User> data = mSQlite.getAllDATA();
  42.  
  43.             boolean user = false;
  44.  
  45.             for (int i = 0; i < data.size(); i++) {
  46.  
  47.                 User userdata = data.get( i );   //可存储账号数量
  48.  
  49.                 if (name.equals( userdata.getName() ) && password.equals( userdata.getPassword() )) {
  50.  
  51.                     user = true;
  52.  
  53.                     break;
  54.  
  55.                 } else {
  56.  
  57.                     user = false;
  58.  
  59.                 }
  60.  
  61.             }
  62.  
  63.             if (user) {
  64.  
  65.                 Toast.makeText( Register.this, "登录成功", Toast.LENGTH_SHORT ).show();
  66.  
  67.                 Intent intent = new Intent( Register.this, MainActivity.class );
  68.  
  69.                 intent.putExtra( "username", name );
  70.  
  71.                 intent.putExtra( "password", password );  //展示账号密码功能
  72.  
  73.                 startActivity( intent );
  74.  
  75.                 finish();
  76.  
  77.             } else {
  78.  
  79.                 Toast.makeText( Register.this, "用户名或密码不正确", Toast.LENGTH_SHORT ).show();
  80.  
  81.             }
  82.  
  83.         } else {
  84.  
  85.             Toast.makeText( Register.this, "用户名或密码不能为空", Toast.LENGTH_SHORT ).show();
  86.  
  87.         }
  88.  
  89.     }
  90.  
  91. });

  1. Father_Object游戏核心碰撞机制
  1. public class Father_Object {
  2.  
  3.     public RectF rf=new RectF();//获取物体所在的矩形用于碰撞检测
  4.  
  5.     public int hp;//血量
  6.  
  7.     public int hurt;
  8.  
  9.     public float w,h;//物体的宽高
  10.  
  11.     public Bitmap img;//图片
  12.  
  13.     //用set方法设置该物体的位置
  14.  
  15.     public void setX(float x){
  16.  
  17.         rf.left=x;
  18.  
  19.         rf.right=x+w;
  20.  
  21.     }
  22.  
  23.     public void setY(float y){
  24.  
  25.         rf.top=y;
  26.  
  27.         rf.bottom=y+h;
  28.  
  29.     }
  30.  
  31.     //碰撞检测
  32.  
  33.     public boolean collision(Father_Object obj_z,Father_Object obj_bz,float px){//传入主动撞与被动撞两个对象，以及忽略像素
  34.  
  35.         px*=Static_data.scale;
  36.  
  37.         if(obj_z.rf.left-obj_bz.rf.left+px<=obj_bz.w&&obj_bz.rf.left-obj_z.rf.left+px<=obj_z.w){
  38.  
  39.             if(obj_z.rf.top-obj_bz.rf.top+px<=obj_bz.h&&obj_bz.rf.top-obj_z.rf.top+px<=obj_z.h){
  40.  
  41.                 return true;
  42.  
  43.             }
  44.  
  45.         }
  46.  
  47.         return false;
  48.  
  49.     }
  50.  
  51. }
  1. Buff类加载游戏道具
  1. public class Buff extends Father_Object implements Runnable {
  2.  
  3.     public int property;
  4.  
  5.     public int add_hp;
  6.  
  7.     private float direction =(float)(Math.random()*2)-1;//方向
  8.  
  9.     public Buff(){
  10.  
  11.         property = (int) (Math.random()*2+1);//随机生成1-2的2个整数
  12.  
  13.         w = 100*Static_data.scale;//乘比例
  14.  
  15.         h = 100*Static_data.scale;
  16.  
  17.         if(property==1){
  18.  
  19.             img = Static_data.buff1;//炮弹加成
  20.  
  21.         }
  22.  
  23.         if (property==2){
  24.  
  25.             img = Static_data.buff2;//生命加成
  26.  
  27.             add_hp = 50;
  28.  
  29.         }
  30.  
  31.         setX((float)( Math.random() * (Static_data.Screen_w - w)));//x是随机的
  32.  
  33.         setY(-h);
  34.  
  35.         Static_data.paint_list.add(this);//放进这个集合里才能被画出来
  36.  
  37.         new Thread(this).start();
  38.  
  39.     }
  40.  
  41.     @Override
  42.  
  43.     public void run() {
  44.  
  45.         boolean mark = false;//标记buff有没有碰到我
  46.  
  47.         while (true){
  48.  
  49.             try { Thread.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); }
  50.  
  51.             //如果碰到两边的墙壁，取反方向
  52.  
  53.             if (rf.left<=0||rf.right>=Static_data.Screen_w)
  54.  
  55.             direction=-direction;
  56.  
  57.             setX(rf.left+direction*10*Static_data.scale);
  58.  
  59.             setY(rf.top+2*Static_data.scale);
  60.  
  61.             try {
  62.  
  63.                 //这里判断有没有和我的飞机发生碰撞
  64.  
  65.                 My_plane mp = Static_data.my_Plane;
  66.  
  67.                 if (collision(this,mp,10)) {//判断碰撞
  68.  
  69.                     if(property==2)
  70.  
  71.                         mp.hp += add_hp;//我的飞机的生命+add buff
  72.  
  73.                     else mp.shell_buff++;
  74.  
  75.                     mark = true;//标记炮弹击中了我的飞机
  76.  
  77.                     Static_data.score+=50;
  78.  
  79.                     break;
  80.  
  81.                 }
  82.  
  83.                 if(mp.hp>200)//判断我的生命不超过200
  84.  
  85.                     mp.hp=200;
  86.  
  87.                 if (mp.shell_buff>3)//判断子弹加成不超过3
  88.  
  89.                     mp.shell_buff=3;
  90.  
  91.             } catch (Exception e) {
  92.  
  93.                 e.printStackTrace();
  94.  
  95.                 break;
  96.  
  97.             }
  98.  
  99.             //如果子弹击中我 或者超出屏幕范围跳出循环
  100.  
  101.             if (mark || rf.top>=Static_data.Screen_h) break;
  102.  
  103.         }
  104.  
  105.         Static_data.paint_list.remove(this);//从集合删除
  106.  
  107.     }
  108.  
  109.     }

  1. MusicService提供游戏音乐背景服务
  1. public class MusicService extends Service {
  2.  
  3.     static boolean isplay=true;//播放状态
  4.  
  5.     MediaPlayer mediaPlayer;
  6.  
  7.     public MusicService() {
  8.  
  9.     }
  10.  
  11.  
  12.  
  13.     @Override
  14.  
  15.     public IBinder onBind(Intent intent) {
  16.  
  17.         // TODO: Return the communication channel to the service.
  18.  
  19.         throw new UnsupportedOperationException("Not yet implemented");
  20.  
  21.     }
  22.  
  23.  
  24.  
  25.     @Override
  26.  
  27.     public void onCreate() {
  28.  
  29.         //创建 mediaPlayer对象，加载音乐
  30.  
  31.         mediaPlayer = MediaPlayer.create(this,R.raw.music);
  32.  
  33.         super.onCreate();
  34.  
  35.     }
  36.  
  37.  
  38.  
  39.     @Override
  40.  
  41.     public int onStartCommand(Intent intent, int flags, int startId) {
  42.  
  43.         if(!mediaPlayer.isPlaying()){
  44.  
  45.  
  46.  
  47.                 mediaPlayer.start();//播放音乐
  48.  
  49.             mediaPlayer.setOnCompletionListener(new MediaPlayer.OnCompletionListener() {
  50.  
  51.                 @Override
  52.  
  53.                 public void onCompletion(MediaPlayer mediaPlayer) {
  54.  
  55.                     mediaPlayer.start();
  56.  
  57.                 }
  58.  
  59.             });
  60.  
  61.                 isplay = mediaPlayer.isPlaying();
  62.  
  63.  
  64.  
  65.         }
  66.  
  67.         return super.onStartCommand(intent, flags, startId);
  68.  
  69.     }
  70.  
  71.  
  72.  
  73.     @Override
  74.  
  75.     public void onDestroy() {
  76.  
  77.         mediaPlayer.stop();//停止播放
  78.  
  79.         isplay = mediaPlayer.isPlaying();
  80.  
  81.         mediaPlayer.release();
  82.  
  83.         super.onDestroy();
  84.  
  85.     }
  86.  
  87. }

  1. Plane类加载所有飞机
  1. public void control_myPlane(){
  2.  
  3.     setOnTouchListener(new OnTouchListener() {
  4.  
  5.         @Override
  6.  
  7.         public boolean onTouch(View view, MotionEvent e) {
  8.  
  9.             if(e.getAction()== MotionEvent.ACTION_DOWN){//ACTION_DOWN：按下时
  10.  
  11.                 click_x=e.getX();
  12.  
  13.                 click_y=e.getY();
  14.  
  15.                 click_my_plane_x=Static_data.my_Plane.rf.left;
  16.  
  17.                 click_my_plane_y=Static_data.my_Plane.rf.top;
  18.  
  19.             }
  20.  
  21.             float move_x=click_my_plane_x+e.getX()-click_x;
  22.  
  23.             float move_y=click_my_plane_y+e.getY()-click_y;
  24.  
  25.             //我的飞机不能飞出屏幕
  26.  
  27.             move_x=move_x<Static_data.Screen_w-Static_data.my_Plane.w/2?move_x:Static_data.Screen_w-Static_data.my_Plane.w/2;
  28.  
  29.             move_x=move_x>-Static_data.my_Plane.w/2?move_x:-Static_data.my_Plane.w/2;
  30.  
  31.             move_y=move_y<Static_data.Screen_h-Static_data.my_Plane.h/2?move_y:Static_data.Screen_h-Static_data.my_Plane.h/2;
  32.  
  33.             move_y=move_y>-Static_data.my_Plane.h/2?move_y:-Static_data.my_Plane.h/2;
  34.  
  35.             Static_data.my_Plane.setX(move_x);
  36.  
  37.             Static_data.my_Plane.setY(move_y);
  38.  
  39.             return true;
  40.  
  41.         }
  42.  
  43.     });
  44.  
  45. }
  1. RankActivity中存放得分
  1. public class RankActivity extends AppCompatActivity {
  2.  
  3.  
  4.  
  5.     TextView tv_rank;
  6.  
  7.     @Override
  8.  
  9.     protected void onCreate(Bundle savedInstanceState) {
  10.  
  11.         super.onCreate(savedInstanceState);
  12.  
  13.         setContentView(R.layout.activity_rank);
  14.  
  15.  
  16.  
  17.         tv_rank = findViewById(R.id.tv_rank);
  18.  
  19. //        将读取的分数按“，”切割成字符数组
  20.  
  21.         String[] ScoreStrArr = getScore().split(",");
  22.  
  23. //        Log.i("score", "得分为： "+ScoreArr[0]);
  24.  
  25.         int[] ScoreIntArr = new int[ScoreStrArr.length];//定义一个int数组存分数
  26.  
  27.  
  28.  
  29.         for (int i=0;i<ScoreStrArr.length;i++){
  30.  
  31.             ScoreIntArr[i]= Integer.valueOf(ScoreStrArr[i]);//将字符串数组中的值转为int存到int型数组中
  32.  
  33.         }
  34.  
  35.         Arrays.sort(ScoreIntArr);//用sort函数排序（从小到大排）
  36.  
  37.         int count = 1;//计数器，我们只输出前10名
  38.  
  39.  
  40.  
  41.         String msg = "";//shuchu到前端的msg
  42.  
  43.         String saveMsg = "";//存入文件的msg
  44.  
  45.  
  46.  
  47. //        Log.i("score", "得分为： "+ScoreIntArr[0]);
  48.  
  49.         for (int i=ScoreIntArr.length-1;i>=0;i--){//因为是从小到大排，所以倒着输出
  50.  
  51.             msg +="NO."+count+"  :"+ScoreIntArr[i]+"\n";
  52.  
  53.             saveMsg += String.valueOf(ScoreIntArr[i])+",";
  54.  
  55.             count++;
  56.  
  57.             if (count>10)break;
  58.  
  59.         }
  60.  
  61.         tv_rank.setText(msg);
  62.  
  63.         //这里我们将排名重新存一下，把低分删除掉
  64.  
  65. //        Log.i("saveMsg", saveMsg);
  66.  
  67.         saveScore(saveMsg);
  68.  
  69.  
  70.  
  71.  
  72.  
  73.  
  74.  
  75.     }
  76.  
  77.     private void saveScore(String s) {
  78.  
  79.         FileOutputStream outputStream;
  80.  
  81.         BufferedWriter writer = null;
  82.  
  83.         try {
  84.  
  85.             //指定文件名和保存方式，Context.MODE_PRIVATE会覆盖文件，MODE_APPEND会追加文件内容
  86.  
  87.             outputStream = openFileOutput("rank", Context.MODE_PRIVATE);
  88.  
  89.             writer = new BufferedWriter(new OutputStreamWriter(outputStream));
  90.  
  91.             writer.write(s);//写入内容
  92.  
  93.             Log.e("save", "文件已保存");
  94.  
  95.         } catch (IOException e) {
  96.  
  97.             e.printStackTrace();
  98.  
  99.         } finally {
  100.  
  101.             try {
  102.  
  103.                 if (writer != null) {
  104.  
  105.                     writer.close();
  106.  
  107.                 }
  108.  
  109.             } catch (IOException e) {
  110.  
  111.                 e.printStackTrace();
  112.  
  113.             }
  114.  
  115.         }
  116.  
  117.     }
  118.  
  119.  
  120.  
  121.     private String getScore() {
  122.  
  123.         FileInputStream inputStream;
  124.  
  125.         BufferedReader reader = null;
  126.  
  127.         StringBuilder builder = new StringBuilder();
  128.  
  129.         try {
  130.  
  131.             inputStream = openFileInput("rank");
  132.  
  133.             reader = new BufferedReader(new InputStreamReader(inputStream));
  134.  
  135.             String line;
  136.  
  137.             while ((line = reader.readLine()) != null) {
  138.  
  139.                 builder.append(line);
  140.  
  141. //                tv_rank.setText(line);
  142.  
  143.             }
  144.  
  145.         } catch (IOException e) {
  146.  
  147.             e.printStackTrace();
  148.  
  149.             Log.e("IOException", "读取文件错误: " + e.toString());
  150.  
  151.         } finally {
  152.  
  153.             if (reader != null) {
  154.  
  155.                 try {
  156.  
  157.                     reader.close();
  158.  
  159.                 } catch (IOException e) {
  160.  
  161.                     e.printStackTrace();
  162.  
  163.                 }
  164.  
  165.             }
  166.  
  167.         }
  168.  
  169.         return builder.toString();
  170.  
  171.     }
  172.  
  173. }

  1. video视频配置
  1. public class video extends VideoView {
  2.  
  3.     public video(Context context) {
  4.  
  5.         super(context);
  6.  
  7.     }
  8.  
  9.  
  10.  
  11.     public video(Context context, AttributeSet attrs) {
  12.  
  13.         super(context, attrs);
  14.  
  15.     }
  16.  
  17.  
  18.  
  19.     public video(Context context, AttributeSet attrs, int defStyleAttr) {
  20.  
  21.         super(context, attrs, defStyleAttr);
  22.  
  23.     }
  24.  
  25.     @Override
  26.  
  27.     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
  28.  
  29.         int width = getDefaultSize(0, widthMeasureSpec);
  30.  
  31.         int height = getDefaultSize(0, heightMeasureSpec);
  32.  
  33.         setMeasuredDimension(width, height);
  34.  
  35.     }
  36.  
  37. }

  1. 系统测试
    1. 登录功能测试

表4-1 登录功能测试用例

测试项目

登录功能

测试编号

01

测试目的

登录信息的验证及容错处理

序号

测试内容

测试结果

测试结果是否合格

1

不输入任何内容

提示：请输入账号或密码

合格

2

只输入账号、不输入密码

提示：请输入账号或密码

合格

3

输入错误的账号密码

提示：账号或密码错误

合格

4

输入正确的账号密码

成功登录到聊天界面

合格

5

输入中文账号和密码

成功登录到聊天界面

合格

    1. 注册功能测试

表4-2 注册功能测试用例

测试项目

注册功能

测试编号

02

测试目的

注册信息的验证及容错处理

序号

测试内容

测试结果

测试结果是否合格

1

不输入任何内容

提示：请输入完整信息！

合格

2

只输入账号

提示：请输入完整信息！

合格

3

两次密码输入不一致

提示：两次密码不一致！

合格

4

注册已有账号

提示：请勿重复注册！

合格

5

注册新账号

提示：注册成功！

合格

    1. 游戏得分测试

表4-3 聊天功能测试用例

测试项目

分数记录功能

测试编号

03

测试目的

检验能否正确记录玩家数次分数

序号

测试内容

测试结果

测试结果是否合格

1

不得分

软件无异常，正常显示

合格

2

击败单架敌机

软件无异常，正常显示

合格

3

击败数个敌机

软件无异常，正常显示

合格

4

击败BOSS类飞机

软件无异常，正常显示

合格

5

通过一关

软件无异常，正常显示

合格

6

通过数关

软件无异常，正常显示

合格

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家自动化/article/detail/798253
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号