Android基础——Activity生命周期以及观察者模式应用

合集下载

Android之Activity生命周期详细介绍

Android之Activity生命周期详细介绍Android之Activity生命周期史无前例的详细介绍，新手必必必看。

Android的Activity生命周期是一个非常重要的知识点，但是由于Activity的状态众多，而且状态直接的切换类型也十分的众多，导致Activity的方法很多，这就给新手学习并理解Activity造成了一定的难度，如果你能认真读完我这一篇博文，那么我相信你一定能对Activity的理解达到一个崭新的高度，ok，下面是我对Activity的理解。

要想透彻的理解Activity，那么必须了解一个计算机的名词，“堆栈”，因为Activity的状态切换方式十分类似于数据结构中的堆栈。

1、首先介绍什么是堆栈，及其特点。

2、介绍Activity的七个状态方法。

3、结合堆栈，详解Activity状态直接的切换和各个方法的调用。

1）、下面我来介绍一下什么是“堆栈”。

堆栈可以简单的理解成一个的“竹筒”，只不过种竹筒是一端封闭另一端开启的，如图所示：透过这个竹筒我们不难发现，因为堆栈的一端是封闭的，所以要想往里面放东西，必须从一端放，取的时候也只能从一端取，就是这堆栈最重要的特点，“后进先出”。

2）、下面我要介绍的是Activity的七个状态方法。

附官方文档图一张：然后附我代码一篇：package cn.blue.life;import android.app.Activity;import android.content.Intent;import android.os.Bundle;import android.util.Log;import android.view.View;import android.view.View.OnClickListener;import android.widget.Button;public class LifteActivity extends Activity {Button bt;protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState);this.setContentView(yout.main);bt=(Button) this.findViewById(R.id.bt);bt.setText("第一个activity");bt.setOnClickListener(new OnClickListener() {public void onClick(View v) {Intent intent=newIntent(LifteActivity.this,LifteActivitySecond.class);startActivity(intent);}});Log.i("Mytag","First----onCreate");}protected void onDestroy() {Log.i("Mytag","First----onDestroy");super.onDestroy();}protected void onPause() {Log.i("Mytag","First----onPause");super.onPause();}protected void onRestart() {Log.i("Mytag","First----onRestart");super.onRestart();}protected void onResume() {Log.i("Mytag","First----onResume");super.onResume();}protected void onStart() {Log.i("Mytag","First----onStart");super.onStart();}protected void onStop() {Log.i("Mytag","First----onStop");super.onStop();}// protected void onRestoreInstanceState(Bundle savedInstanceState) {// Log.i("Mytag","First----onRestoreInstanceState"); // super.onRestoreInstanceState(savedInstanceState); // }// protected void onSaveInstanceState(Bundle outState) { // Log.i("Mytag","First----onSaveInstanceState");// super.onSaveInstanceState(outState);// }}onCreate(Bundle savedInstanceState)onStart()onResume()onPause()onStop()onDestroy()onRestart()onCreate(Bundle savedInstanceState)Activity的初始化，也就是一个全新的Activity开始时，调用该方法onStart()Activity的启动，当你能够看到Activity时，启动该方法，onResume()当Activity获取用户焦点将要与用户交互时调用此方法，此时activity在activity栈的栈顶，用户输入已经可以传递给它onPause()当系统要启动一个其他的activity时调用（其他的activity显示之前），这个方法被用来提交那些持久数据的改变、停止动画、和其他占用CPU资源的东西。

两分钟彻底让你明白Android_Activity生命周期(图文)

两分钟彻底让你明白Android Activity生命周期(图文)! 收藏大家好，今天给大家详解一下Android中Activity的生命周期，我在前面也曾经讲过这方面的内容，但是像网上大多数文章一样，基本都是翻译Android API，过于笼统，相信大家看了，会有一点点的帮助，但是还不能完全吃透，所以我今天特意在重新总结一下.首先看一下Android api中所提供的Activity生命周期图(不明白的，可以看完整篇文章，在回头看一下这个图，你会明白的):Activity其实是继承了ApplicationContext这个类，我们可以重写以下方法，如下代码:为了便于大家更好的理解，我简单的写了一个Demo,不明白Activity周期的朋友们，可以亲手实践一下，大家按照我的步骤来。

第一步:新建一个Android工程，我这里命名为ActivityDemo.第二步:修改ActivityDemo.java(我这里重新写了以上的七种方法，主要用Log打印),代码如下:第三步:运行上述工程,效果图如下(没什么特别的):核心在Logcat视窗里,如果你还不会用Logcat你可以看一下我的这篇文章Log图文详解(Log.v,Log.d,Log.i,Log.w,Log.e)，我们打开应用时先后执行了onCreate()->onStart()->onResume三个方法，看一下LogCat视窗如下:BACK键：当我们按BACK键时，我们这个应用程序将结束，这时候我们将先后调用onPause()->onStop()->onDestory()三个方法，如下图所示:HOME键:当我们打开应用程序时，比如浏览器，我正在浏览NBA新闻，看到一半时，我突然想听歌，这时候我们会选择按HOME键，然后去打开音乐应用程序，而当我们按HOME的时候，Activity先后执行了onPause()->onStop()这两个方法，这时候应用程序并没有销毁。

Android开发中Activity的生命周期及加载模式详解

Android开发中Activity的⽣命周期及加载模式详解本⽂给⼤家介绍Activity的⽣命周期，如果⼤家学习过iOS的⼩伙伴的话，Activity的⽣命周期和iOS中ViewController的⽣命周期⾮常类似。

⽣命周期，并不难理解。

⼀个⼈的⽣命周期莫过于⽣⽼病死，花⼉的⽣命周期就是花开花谢了。

在Android中Activity的⽣命周期莫过于Activity的创建到消亡的过程了。

本篇博客就会介绍Activity⽣命周期中的不同阶段，通过实例的形式来窥探⼀下Activity的⽣命周期。

搞明⽩Activity的⽣命周期是⾄关重要的，因为只有搞明⽩每个⽣命周期的每个阶段，你才能在不同段做不同的事情。

接下来我们将通过⼀个实例来介绍Activity的⽣命周期，在这个Demo中会有⼀个MainActivity, MainActivity就是App启动后第⼀个显⽰的Activity。

在MainActivity上有⼀个按钮，点击这个按钮就会跳转到SecondActivity，点击返回键就会从SecondActivity中返回到MainActivity中，再点击返回键就会退出App。

通过这⼀些列的Activity的切换，我们将通过打印Log的⽅式来进⾏观察Activity的⽣命周期。

⼀.代码编写其实这篇博客的代码是⾮常简单的，就是重写Activity⽣命周期不同阶段的⽅法，然后在⽅法中进⾏Log的打印，从⽽来标记这个⽣命周期的阶段。

⽽Demo的UI也是灰常的简单的，所以Activity的layout⽂件就不做过多的赘述了。

接下来看⼀下两个Activity中的关键代码。

1.下⽅的代码是MainActivity中的关键代码，对Activity⽣命周期的不同阶段进⾏重写，然后打印⽇志，标记出是哪个Activity中的哪个⽅法。

在onCreate()⽅法中通过id获取Button, 然后给按钮绑定上单击事件，点击button时跳转到SecondActivity中。

Android实验报告—Android框架及Activity 生命周期程序设计

Android框架及Activity 生命周期程序设计实验目的:本实验的目的是使学生深入了解Android程序框架结构、了解Android组件的生命周期中各状态的变化关系、掌握Android应用程序的调试方法和工具。

通过程序设计, 掌握Activity的三种生命周期：全生命周期、可视生命周期和活动生命周期；每种生命周期中包含的不同的事件回调函数, 以及它们的作用和调用顺序, 深入理解Activity的生命周期过程。

实验要求:根据下图, 设计程序解释不同的事件回调函数在Activity的三种生命周期的作用如何。

[实现提示]1.建立Android工程, 其中工程名称: ActivityLifeCycle你的学号包名称：.bistu.你的班级号.ActivityLifeCycle你的学号Activity名称: ActivityLifeCycle你的学号如: 电技1001班学号后三位为123的学生, 应将包名称设为:.bistu.dj1001.ActivityLifeCycle1232、工程建立完毕后, 可以不进行界面设计, 即不必修改main.xml文件, 直接编写Java文件3.通过在生命周期函数中添加“日志点”的方法进行调试4、为了显示结果易于观察和分析, 在LogCat设置过滤器LifeCycleFilter测试过程在程序运行过程, 通过点击模拟器上的“返回键”, 生命周期中事件回调函数的执行顺序及作用是函数的调用顺序: onSaveInstanceState ()→onPause()→onStop() →onRestart()→onStart()→onResume()；调用onSaveInstanceState()函数保存Activity状态；调用onPause()和onStop(), 停止对不可见Activity的更新；调用onRestart()恢复需要界面上需要更新的信息；调用onStart()和onResume()重新显示Activity, 并接受用户交互。

AndroidActivity的生命周期详细介绍

AndroidActivity的⽣命周期详细介绍Android Activity的⽣命周期详细介绍⽣命周期描述的是⼀个类从创建（new出来）到死亡（垃圾回收）的过程中会执⾏的⽅法。

在这个过程中，会针对不同的⽣命阶段调⽤不同的的⽅法。

Activity是Android中四⼤组件之⼀，是最常见的应⽤组件，也是⽤的最多的组件，它能够提供⼀个界⾯与⽤户进⾏交互。

Activity从创建到销毁有多种状态，从⼀种状态到另⼀种状态时会激发相应的回调⽅法，这些回调⽅法包括：onCreate onDestory onStart onStop onResume onPause。

这些⽅法都是两两对应的，onCreate-->创建与onDestory-->销毁；onStart-->可见与onStop-->不可见；onResume-->可编辑（焦点）和onPause-->未获得焦点。

最后还有⼀个⽅法是onRestart，这个⽅法在什么时候调⽤呢？当Activity被onStop后，但是并没有onDestory，即并没有被销毁时，⽤户重新回到当前Activity时，就调⽤onRestart⽅法，这⾥就不再是调⽤onCreate⽅法了。

public class MainActivity extends ActionBarActivity {private final static String TAG = "MainActivity";@Override// Activity被创建时调⽤protected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(yout.activity_main);Log.e(TAG, "onCreate.......");}@Override// 该状态⽤户可见，但是⽤户还不能与之进⾏交互protected void onStart() {super.onStart();Log.e(TAG, "onStart.......");}@Override// 该状态是Activity获得⽤户焦点，⽤户可以与之进⾏交互protected void onResume() {super.onResume();Log.e(TAG, "onResume.......");}@Override//与onResume对应，当Activity失去焦点时调⽤protected void onPause() {super.onPause();Log.e(TAG, "onPause.......");}@Override//与onStart对应，当Activity不可见时调⽤protected void onStop() {super.onStop();Log.e(TAG, "onStop.......");}@Override//与onCreate对应，当Activity被销毁时调⽤protected void onDestroy() {super.onDestroy();Log.e(TAG, "onDestroy.......");}@Override//Activity从后台重新回到前台调⽤protected void onRestart() {super.onRestart();Log.e(TAG, "onRestart.......");}}Activity的完整⽣命周期：oncreate-->onstart-->onresume-->onpause-->onstop-->ondestory。

AndroidActivity的生命周期与启动模式全面解读

AndroidActivity的⽣命周期与启动模式全⾯解读⽬录Activity概述Activity⽣命周期⽣命周期的调⽤顺序演⽰Activity的启动模式启动模式的设置standard（默认standard）singleTopsingleTasksingleInstanceActivity概述• Activity（活动）是Android应⽤程序中最基本的组成单位。

• Activity主要负责创建显⽰窗⼝，⼀个Activity对象通常就代表了⼀个单独的屏幕。

• Activity是⽤户唯⼀可以看得到的组件，⽤来与⽤户进⾏交互的。

• Activity是通过⼀个Activity栈来进⾏管理，当前显⽰的Activity被放到栈顶。

Activity⽣命周期⽣命周期的调⽤顺序⼀、启动activity，然后按返回键退出。

onCreate()->onStart()->onResume()onPause()->onStop()->onDestory()⼆、启动activity，按Home键显⽰桌⾯，再点程序图标进⼊应⽤程序。

onCreate()->onStart()->onResume()onPause()->onStop()onRestart()->onStart()->onResume()三、启动activityA,再启动activityBAonCreate()->AonStart()->AonResume()AonPause()BonCreate()->BonStart()->BonResume()演⽰package com.qingsu.yingguday06;import androidx.appcompat.app.AppCompatActivity;import ponentName;import android.content.Intent;import android.os.Bundle;import android.util.Log;import android.view.View;import android.widget.Button;public class MainActivity extends AppCompatActivity implements View.OnClickListener { private Button mBtIntent,mBtIntentOne,mBtIntentTwo,mBtIntentThree;@Overrideprotected void onCreate(Bundle savedInstanceState) {Log.d("TAG","onCreate");super.onCreate(savedInstanceState);setContentView(yout.activity_main);initView();mBtIntent.setOnClickListener(this);}private void initView(){mBtIntent = findViewById(R.id.bt_intentmain);}@Overrideprotected void onStart() {Log.d("TAG","onStart");super.onStart();}@Overrideprotected void onResume() {Log.d("TAG","onResume");super.onResume();}@Overrideprotected void onPause() {Log.d("TAG","onPause");super.onPause();}@Overrideprotected void onStop() {Log.d("TAG","onStop");super.onStop();}@Overrideprotected void onRestart() {Log.d("TAG","onRestart");super.onRestart();}@Overrideprotected void onDestroy() {Log.d("TAG","onDestroy");super.onDestroy();}@Overridepublic void onClick(View v) {switch (v.getId()){case R.id.bt_intentmain:startActivity(intent);;break;default:break;}}}package com.qingsu.yingguday06;import androidx.appcompat.app.AppCompatActivity;import android.content.Intent;import android.os.Bundle;import android.util.Log;import android.view.View;import android.widget.Button;public class HomeActivity extends AppCompatActivity {Button mBtHome,mBtIntentB;@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);Log.d("TAG","BonCreate");setContentView(yout.activity_home);setTitle("页⾯B");mBtHome = findViewById(R.id.bt_intenthome);mBtIntentB = findViewById(R.id.bt_intentB);mBtHome.setOnClickListener(new View.OnClickListener() {@Overridepublic void onClick(View v) {Intent intent = new Intent(HomeActivity.this,MainActivity.class); startActivity(intent);}});mBtIntentB.setOnClickListener(new View.OnClickListener() {@Overridepublic void onClick(View v) {Intent intent = new Intent(HomeActivity.this,HomeActivity.class); startActivity(intent);}});}@Overrideprotected void onStart() {Log.d("TAG","BonStart");super.onStart();}@Overrideprotected void onResume() {Log.d("TAG","BonResume");super.onResume();}@Overrideprotected void onPause() {Log.d("TAG","BonPause");super.onPause();}@Overrideprotected void onStop() {Log.d("TAG","BonStop");super.onStop();}@Overrideprotected void onRestart() {Log.d("TAG","BonRestart");super.onRestart();}@Overrideprotected void onDestroy() {Log.d("TAG","onDestroy");super.onDestroy();}}Activity的启动模式standard（默认standard）、singleTop、singleTask、singleInstance 启动模式的设置清单⽂件中在活动声明中加⼊launchMode属性默认为standard⽅式 android:launchMode="singleTask"<activity android:name=".MainActivity"android:launchMode="singleTask"><intent-filter><action android:name="android.intent.action.MAIN" /><category android:name="UNCHER" /></intent-filter></activity>standard（默认standard）⼀直⼊栈⼀直创建新的ActivitysingleTop当前页⾯中创建当前页⾯不会新创建ActivitysingleTask当Activity存在则会将其置顶，Activity上⾯的栈则会被弹出！即Activity上⾯的Activity会销毁！singleInstance每⼀个Activity都是唯⼀的当Activity存在不会新建新的Activity到此这篇关于Android Activity的⽣命周期与启动模式全⾯解读的⽂章就介绍到这了,更多相关Android Activity 启动模式内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持！。

浅谈Android的Activity运行流程(生命周期)

浅谈Android的Activity运行流程（生命周期）关于Android的Activity运行流程，我们可以写一些程序来直观的查看Activity的运行流程。

在这里我们使用Log工具来获取Activity运行日志。

假如我们新建一个Android项目，ProcessActivity.java代码如下：public class ProcessActivity extends Activity {private static final String tag="徐守威";@Overridepublic void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);//setContentView(yout.main);Log.v(tag, "onCreate...");}@Overrideprotected void onRestart() {// TODO Auto-generated method stubsuper.onRestart();Log.v(tag, "onRestart...");}@Overrideprotected void onStart() {// TODO Auto-generated method stubsuper.onStart();Log.v(tag, "onStart...");}@Overrideprotected void onResume() {// TODO Auto-generated method stubsuper.onResume();Log.v(tag, "onResume...");}@Overrideprotected void onPause() {// TODO Auto-generated method stubsuper.onPause();Log.v(tag, "onPause...");}@Overrideprotected void onStop() {// TODO Auto-generated method stubsuper.onStop();Log.v(tag, "onStop...");}@Overrideprotected void onDestroy() {// TODO Auto-generated method stubsuper.onDestroy();Log.v(tag, "onDestroy...");}}我们为Activity的哥哥状态添加了“Log”记录消息。

浅析Android之Activity生命周期

浅析Android之Activity生命周期作者：杨碎明孙文高来源：《知识文库》2018年第07期理解Android的活动（Activity）生命周期是对一个智能机开发人员工非常重要的。

只有这样，才能确保对一个逻辑的用户的应用程序有效管理其资源。

Android中的应用程序（app）并不能管理自已的生命周期，而是由系统进行统一的管理。

1引言在现实生活中，经常会用手机打电话，发短信，玩游戏等，这就需要与手机界面进行交互，用户与程序的交互是能通过Activity完成的，活动就是Android程序的表现层，展示可视化的用户界面，并接收与用户交互所产生的界面事件活动。

活动可表现以下四个状态：分别是运行（Running）状态、暂停（paused）状态、停止（Stopped）状态和销毁（Destroyed）状态。

活动的生命周期就是它所在进程的生命周期。

分为三类：可视生命周期，前台生命周期、和完整生命周期。

2活动交互机制2.1 活动的四个状态1）当用户界面在它在屏幕前台时，它是激活或运行状态。

它就是响应用户操作的Activity。

2）当一个界面上面有另外一个Activity，使它失去了焦点但仍然对用户可视时，这个界面实质上处于暂停状态。

在它之上的Activity如果没有完全遮盖整个手机屏幕，或者是透明的，被暂停的Activity仍然对用户可见，并且是存活状态。

3）当它完全被另一个Activity覆盖时则处于停止状态。

它仍然保留所有的状态和成员信息，然而对用户是不可见的。

所以它的窗口将被隐藏，如果其它地方需要内存，则系统经常会杀死这个Activity。

4）销毁状态，不在以上三个状态中的活动，如活动已被回收或启动。

3 Activity生命周期3.1 活动的生命周期因为活动直接涉及与用户交互界面的处理，而任意时刻与用户交互的界面只有一个，所以Android针对活动的管理采用了具有层次感的栈数据结构。

活动栈保存了已经启动并且没有终止的活动，并遵循“先进后出”的原则。

android：activity活动的生命周期

android：activity活动的⽣命周期掌握活动的⽣命周期对任何 Android 开发者来说都⾮常重要，当你深⼊理解活动的⽣命周期之后，就可以写出更加连贯流畅的程序，并在如何合理管理应⽤资源⽅⾯，你会发挥的游刃有余。

你的应⽤程序将会拥有更好的⽤户体验。

2.4.1 返回栈经过前⾯⼏节的学习，我相信你已经发现了这⼀点，Android 中的活动是可以层叠的。

我们每启动⼀个新的活动，就会覆盖在原活动之上，然后点击 Back 键会销毁最上⾯的活动，下⾯的⼀个活动就会重新显⽰出来。

其实 Android 是使⽤任务（Task）来管理活动的，⼀个任务就是⼀组存放在栈⾥的活动的集合，这个栈也被称作返回栈（Back Stack）。

栈是⼀种后进先出的数据结构，在默认情况下，每当我们启动了⼀个新的活动，它会在返回栈中⼊栈，并处于栈顶的位置。

⽽每当我们按下 Back 键或调⽤ finish()⽅法去销毁⼀个活动时，处于栈顶的活动会出栈，这时前⼀个⼊栈的活动就会重新处于栈顶的位置。

系统总是会显⽰处于栈顶的活动给⽤户。

⽰意图 2.19 展⽰了返回栈是如何管理活动⼊栈出栈操作的。

图 2.192.4.2 活动状态每个活动在其⽣命周期中最多可能会有四种状态。

1. 运⾏状态当⼀个活动位于返回栈的栈顶时，这时活动就处于运⾏状态。

系统最不愿意回收的就是处于运⾏状态的活动，因为这会带来⾮常差的⽤户体验。

2. 暂停状态当⼀个活动不再处于栈顶位置，但仍然可见时，这时活动就进⼊了暂停状态。

你可能会觉得既然活动已经不在栈顶了，还怎么会可见呢？这是因为并不是每⼀个活动都会占满整个屏幕的，⽐如对话框形式的活动只会占⽤屏幕中间的部分区域，你很快就会在后⾯看到这种活动。

处于暂停状态的活动仍然是完全存活着的，系统也不愿意去回收这种活动（因为它还是可见的，回收可见的东西都会在⽤户体验⽅⾯有不好的影响），只有在内存极低的情况下，系统才会去考虑回收这种活动。

Android开发艺术探索笔记——第一章：Activity的生命周期和启动模式

Android开发艺术探索笔记——第一章：Activity的生命周期和启动模式一.序作为这本书的第一章，主席还是把Activity搬上来了，也确实，和Activity打交道的次数基本上是最多的，而且他的内容和知识点也是很多的，非常值得我们优先把他掌握，Activity 中文翻译过来就是”活动”的意思，但是主席觉得这样翻译有些生硬，直接翻译成“界面”可能更好，的确，Activity主要也是用于UI效果的呈现，不过两者翻译都不为过，我们知其意就行了，正常情况下，我们除了Window,Dialog,Toast，我们还能见到的就只有Activity 了，他需要setContentView()去绑定一个视图View作为效果的呈现，然而，作为一本高质量的进阶书。

肯定不会去围绕着入门知识讲解，本章的侧重点在于对Activity使用过程中搞不清楚的概念，生命周期和启动模式已经IntentFilter的匹配规则分析，毕竟Activity在异常状态下的生命周期是多样化的，至于Activity的启动模式和各种各样的Flags,更是让很多人摸不着头脑，还有隐式启动Activity中也有着复杂的Intent匹配过程，所以我们还是一步步的去学习下去，真正的了解Activity这个小家伙！二.Activity的生命周期全面分析Activity的生命周期，本章主要讲解两个方面典型情况下的生命周期异常情况下的生命周期典型情况是指用户参与的情况下，Activity所经过的生命周期的变化，异常情况下的话，就有多种可能了，比如系统回收或者由于当前设备的Configuration发生改变从而导致Activity被销毁重建，异常情况下的生命周期的关注点和典型情况下有些不同，所以要分开来描述才能描述的清楚些1.典型情况下的生命周期分析在正常的情况下，生命周期会经历以下的生命周期onCreate：表示Activity正在被创建，这是生命周期的第一个方法，在这个方法中，我们可以做一些初始化的工作，比如调用onContentView去加载界面布局资源，初始化Activity所需数据等onRestart:表示Activity正在重新启动，一般情况下，当当前Activity从不可见重新变为可见时，onRestart就会被调用，这总情况一般是用户行为所导致的，比如用户按home键切换到桌面或者用户打开了一个新的Activity，这时当前的Activity就会被暂停，也就是onPause 和onStop方法被执行了，接着用户又回到了这个Activity，就会出现这种情况onStart:表示Activity正在被启动，即将开始，这个时候Activity已经可见了，但是还没有出现在前台，还无法和用户交互，这个时候我们可以理解为Activity已经启动了，但是我们还没有看见onResume:表示Activity已经可见了，并且出现在前台，并开始活动了，要注意这个和onStart 的对比，这两个都表示Activity已经可见了，但是onStart的时候Activity还处于后台，onResume的时候Activity才显示到前台onPause:表示Activity正在停止，正常情况下，紧接着onStop就会被调用，在特殊情况下，如果这个时候再快速的回到当前Activity，那么onResume就会被调用，主席的理解是这个情况比较极端，用户操作很难重现这个场景，此时可以做一些数据存储，停止动画等工作，但是注意不要太耗时了，因为这样会影响到新的Activity的显示，onPause必须先执行完，新Activity的onResume才会执行onStop:表示Activity即将停止，同样可以做一些轻量级的资源回收，但是不要太耗时了onDestroy:表示Activity即将被销毁，这是Activity生命周期的最后一个回调，在这里我们可以做一些最后的回收工作和资源释放正常情况下，Activity的常用生命周期用官网的一张图就足够表示了这里附加几个说明1.针对一个特定的Activity，第一次启动，回调如下：onCreate ——> onStart ——> onResume2.当用户打开新的Activity或者切换到桌面的时候，回调如下：onPause ——> onStop ——> 这里有一种特殊的情况就是，如果新的Activity采取了透明的主题的话，那么当前Activity 不会回调onStop3.当用户再次回到原来的Activity，回调如下：onRestart ——> onStart ——> onResume4.d当用户按back键的时候回调如下：onPause ———> onStop ——> onDestroy5.当Activity被系统回收的时候再次打开，生命周期回调方法和1是一样的，但是你要注意一下就是只是生命周期一样，不代表所有的进程都是一样的，这个问题等下回详细分析6.从整个生命周期来说，onCreate和onDestroy是配套的,分别标示着Activity的创建和销毁，并且只可能有一次调用，从Activity是否可见来说，onStart和onStop是配套的，随着用户的操作和设备屏幕的点亮和熄灭，这两个方法可能被调用多次，从Activity是否在前台来说，onResume和onPause是配套的，随着用户操作或者设备的点亮和熄灭，这两个方法可能被多次调用这里提出两个问题1.onStart和onResume，onPause和onStop从描述上都差不多，对我们来说有什么实质性的不同呢？2.假设当前Activity为A，如果用户打开了一个新的Activity为B，那么B的onResume和A 的onPause谁先执行尼？我们先来回答第一个问题，从实际使用过程来说，onStart和onResume，onPause和onStop 看起来的确差不多，甚至我们可以只保留其中的一对，比如只保留onStart和onStop，既然如此，那为什么Android系统还会提供看起来重复的接口呢？根据上面的分析，我们知道，这两个配对的回调分别代表不同的意义，onStart和onStop是从Activity是否可见这个角度来回调的，除了这种区别，在实际的使用中，没有其他明显的区别第二个问题，我们就要从源码的角度来分析以及得到解释了，关于Activity的工作原理会在本书后续章节进行讲解，这里我们大致的了解即可，从Activity的启动过程来看，我们来看一下系统的源码，Activity启动过程的源码相当复杂，设计到了Instrumentation,Activit和ActivityManagerService（AMS），这里不详细分析这一过程，简单理解，启动Activity的请求会由 Instrumentation 来处理，然后他通过Binder向AMS发请求，AMS内部维护着一个ActivityStack，并负责栈内的Activity的状态同步，AMS通过ActivityThread去同步Activity的状态从而完成生命周期方法的调用，在ActivityStack中的resumeTopActivityLnnerLocked方法中，有这么这段代码//we need to start pausing the current activity so the top one can be resumedboolean dontWaitForPause = (.flags& ActivityInfo.FLAG_RESUME_WHILE_PAUSING)!=0;boolean pausing = mStackSupervisor.pauseBackStacks(userLeaving, KeyStore.TrustedCertificateEntry,dontWaitForPause);if(mResumedActivity != null){pausing != startPaUSINGlOCAKED(userLeaving,false,true,dontWaitForPause);if(DEBUG_STA TES){Slog.d(TAG,"resumeTopActivityLocked:pausing" + mResumedActivity);}}从上述的代码中我们可以看出，在新Activity启动之前，栈顶的Activity需要先onPause后，新的Activity才能启动，最终，在ActvityStackSupervisor中的realStartActivityLocked方法中，会调用如下代码app.thread.scheduleLaunchActivity(newIntent(r.intent),r.appToken,System.identityHashCode(r),,newConfiguration(mService.mConfiguration),pat,r.task.voiceInteractor,app.repProcState,r.icicle,r.persistentState,results,new Intents,!andResume,mService.isNextTransitionForward(),profilerInfo);我们都知道，在这个app.thread的类型是IApplicationThread的具体实现实在ActivityTread 中,所以，这段代码实际上遇到了ActivityThread当中，，即ApplicationThread的scheduleLaunchActivity方法，而scheduleLaunchActivity方法最终会完成生命周期的调用过程，因此可以得出结论，是旧Activity县onPause，然后新的Activityy再启动至于ApplicationThread的scheduleLaunchActivity方法为什么会完成新Activity的生命周期，请看接下来的代码，scheduleLaunchActivty为什么会完成新的Activtyprivate void handlerLaunchActivity(ActivityClientRecord r, Intent customIntent){//if we are getting ready to gc after going to the background,well we are back active so skip itunscheduleGcIdler();mSomeActivitiesChanged =true;if(r.profilerInfo != null){mProfiler.setProfiler(r.profilerInfo);mProfiler.startProfiling;}//Make sure we are running with the most recent confighandlerConfigurationChanged(null,null);if(localLOGV)Slog.vTAG,"Handling launch of"+r);//在这里新Activity被创建出来，其onCreate和onStart被调用Activity a = PerformLaunchActivity(r,customIntent);if(a != null){r.createdConfig = new Configuration(mConfiguration);Bundle oldState = r.start;handlerResumeActivity(r.token,false,r.isForward,!r.activity.mFinished && r.startsNotResumed);}//省略...}c从上面的分析可以看出，当新的Activity启动的时候，旧的Activity的onPause方法会先执行，然后才启动新的Activity，到底是不是这样尼？我们可以写一个小栗子来验证一下，如下是两个Activity的代码，在MainActivity中点击按钮可以跳转到SecondActivity，同时为了分析生命周期，我们把log日志也打出来MainActivitypackage com.liuguilin.activitysample;import android.content.Intent;import android.os.Bundle;import android.support.v7.app.AppCompatActivity;import android.util.Log;import android.view.View;public class MainActivity extends AppCompatActivity {public static final String TAG = "MainActivity";@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(yout.activity_main);findViewById(R.id.btnTo).setOnClickListener(new View.OnClickListener() { @Overridepublic void onClick(View view) {startActivity(new Intent(MainActivity.this, SecondActivity.class));}});}@Overrideprotected void onPause() {super.onPause();Log.i(TAG, "onPause");}@Overrideprotected void onStop() {super.onStop();Log.i(TAG, "onStop");}}SecondActivitypackage com.liuguilin.activitysample;import android.os.Bundle;import android.support.v7.app.AppCompatActivity;import android.util.Log;/*** Created by lgl on 16/8/24.*/public class SecondActivity extends AppCompatActivity {private static final String TAG = "SecondActivity";@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(yout.activity_second);Log.i(TAG, "onCreate");}@Overrideprotected void onStart() {super.onStart();Log.i(TAG, "onStart");}@Overrideprotected void onResume() {super.onResume();Log.i(TAG, "onResume");}}这样我们可以观察到他的生命周期通过这个生命周期我们可以观察到，旧的Activity的onPause先调用，然后新的Activity才启动，这也证实了我们上面的分析原理，也许有人问，你只是分析了Andorid5.0的源码，你怎么所有的版本源码逻辑都相同，的确，我们不能把所有的版本都概括，但是作为Android 的一个运行过程的基本逻辑，随着版本的更新并不会很大的改变，因为Android也需要兼容性，，不能说在同一个版本上运行有两种不同的逻辑，那根本不可能，关于这一点，我们要把握一个度，就是对于Android的基本运行机制，的不同，Android不能在onPause中做重量级的操作，因为必须在onPause执行完成以后新的Activity才能Resume，从这一点我们也间接性的证明了我们的结论，通过分析这个问题，我们知道onPause和onStop都不能做耗时的操作，尤其是onPause，这也意味着，我们应当尽量的在onStop中做操作，从而使新的Activity尽快显示出来并且换到前后台三.异常情况下的生命周期分析上一节我们分析的是正常事情下的生命周期，但是我们写程序也不要理想化，居多的问题就是出在异常情况下，我们知道,Activity除了受用户操作导致的正常生命周期的调度，同时还会存在一些异常的情况，比如当资源相关的系统配置发生改变以及系统内存不足的时候，Activity就有可能被杀死，下面我们具体来分析下这几种情况1.情况1：资源相关的系统配置发生改变导致Activity被杀死并重新创建理解这个问题，首先要对系统的资源加载有一定的了解，这里就不详细分析系统资源加载的机制了，但是我们简单说明一下，拿最简单的图片来说，当我们把一张图片挡在drawable 中的时候，就可以通过Resources去获取这张图片了，同时为了兼容不同的设备，我们可能还需要在其他一些目录下放置不同的图片，比如drawable-xhdpi之类的，当应用程序启动时，系统会根据当前设备的情况去加载合适的Resources资源，比如说横屏手机和竖屏手机会拿着两张不同的图片（设定了landscape或者portrait状态下的图片），比如之前Activity处于竖屏，我们突然旋转屏幕，由于系统配置发生了改变，在默认情况下，Activity会被销毁并且重新创建，当然我们也可以阻止系统重新创建我们的Activity默认情况下，如果我们的Activity不做特殊处理，那么当系统配置发生改变之后，Activity 就会销毁并且重新创建，可以看图当系统配置发生改变的时候，Activity会被销毁，其onPause，onStop,onDestroy均会被调用，同时由于Activity是异常情况下终止的，系统会调用onSaveInstanceState来保存当前Activity 的状态，这个方法调用的时机是在onStop之前，他和onPause没有既定的时序关系，他即可能在onPause之前调用，也有可能在之后调用，需要强调的是，这个方法只出现在Activity 被异常终止的情况下，正常情况下是不会走这个方法的吗，当我们onSaveInstanceState保存到Bundler对象作为参数传递给onRestoreInstanceState和onCreate方法，因此我们可以通过onRestoreInstanceState和onCreate方法来判断Activity是否被重建。

Android Activity的生命周期及应用示例

杨教授工作室，版权所1有，盗版必究， 1/38页
杨教授工作室精心创作的优秀程序员职业提升必读系列资料
1.1 Android Activity 的生命周期及应用示例
1.1.1 Android Activity 的生命周期 1、熟悉手机应用的特殊性
如果与 J2EE WEB 组件进行对比，可以把 Android 应用程序中的 Activity 理解成一个 JSP 页面文件或者也可以把它理解成 J2SE 应用程序中的一个 JFrame 窗口。但在深入地学习 Android 应用程序相关技术之前，需要了解手机应用程序与普通的 PC 应用程序在执行方式的差别，手机应用程序的特殊性主要是指如下方面：
杨教授工作室精心创作的优秀程序员职业提升必读系列资料
目录
1.1 Android Activity 的生命周期及应用示例..........................................................................2 1.1.1 Android Activity 的生命周期.................................................................................. 2 1.1.2 Activity 生命周期的执行顺序实验........................................................................5 1.1.3 LogCat 的主要功能.................................................................................................. 8 1.1.4 Activity 栈.................................................................................................................. 9 1.1.5 熟悉 Android 应用框架中相关的组件包和相关的文件...................................13 1.1.6 AndroidManifest.xml 文件中的典型标签的含义............................................... 30 1.1.7 XML 布局配置及应用示例...................................................................................31

Android学习总结（一）——Activity的基本概念与Activity的生命周期

Android学习总结（⼀）——Activity的基本概念与Activity的⽣命周期⼀、Activity的基本概念 Activity是Android的四⼤组件之⼀，它是⼀种可以包含⽤户界⾯的组件，主要⽤于和⽤户进⾏交互，⽐如打电话，照相，发送邮件，或者显⽰⼀个地图！Activity⽤于显⽰⽤户界⾯，⽤户通过Activity交互完成相关操作，⼀个App允许有多个Activity。

⼆、Activity的⽣命周期 Activity⽣命周期是每⼀个Android开发者都必须掌握的，当我们深⼊理解活动的⽣命周期之后，就可以写出更加连贯流畅的程序，让我们的程序拥有更好的⽤户体验2.1、Activity的⽣命周期图2.2、Activity的四种状态每个Activity在其⽣命周期中最多可能会有四种状态。

1.运⾏状态当⼀个Activity位于返回栈（关于返回栈的概念下⾯再介绍）的栈顶时，这时Activity就处于运⾏状态，系统会将处于栈顶的Activity显⽰给⽤户。

2.暂停状态当⼀个Activity不再处于栈顶位置，但仍然可见，这时Activity就进⼊了暂停状态。

初学者可能会有这样的疑问，既然Activity都已经不在栈顶了，怎么会还可见呢，这是因为并不是每⼀个Activity都会占满整个屏幕的，⽐如对话框形式的Activity只会占⽤屏幕中间的部分区域。

3.停⽌状态当⼀个Activity不再处于栈顶位置，并且完全不可见的时候，就进⼊了停⽌状态。

4.销毁状态当⼀个Activity从返回栈中移除后就变成了销毁状态。

2.3、Android返回栈 Android是使⽤任务（Task）来管理Activity的，⼀个任务就是⼀组存放在栈⾥的Activity集合，这个栈被称作返回栈，栈（堆栈）是⼀种先进后出的数据结构，这⾥顺便提⼀下另⼀种常见的数据结构：队列，队列是⼀种先进先出的数据结构。

每当启动⼀个新的Activity时，它会被放⼊返回栈中，并处于栈顶的位置。

Android中Activity的生命周期

说来惭愧，虽然已经做了一年多的android开发，但是最近被人问起activity的生命周期的时候，却感觉自己并不能很自信很确定的回答对方的问题，对activity的生命周期的理解还不透彻啊。

既然发现了问题，那咱就得解决问题，不就个生命周期，能有多复杂。

首先看看android developers 网上的activity的生命周期图：activity启动的时候：onCreate ---> onStart ---> onResume 这个过程不用多说，大家都知道。

这里主要讲讲: 何时onPause, 何时onStop，何时onDestory；以及恢复的时候，何时onRestart，何时onResume。

为了方便说明这里把当前activity称为MainActivity，其他的activity称为SecondActivity、ThirdActivity等等。

通过上图的我们可以看出activity从running状态跳转到onPause状态的原因是：Another activity comes into the foreground. 也就是说有另外一个actvity被启动并运行了，比如说MainActivity通过startActivity启动了SecondActivity，那么SecondActivity就在ui视图的最顶层了，而MainActivity 不再是最顶层的activity了，此时就会onPause了，此时我们依稀还能看到MainActivity，只是MainActivity已经站在他人之后了。

而当MainActivity完全被SecondActivity挡住，完全看不见的时候，此时MainActivity就会onStop了。

我们看看上图从onPause到onStop的原因是：the activity is no longer visiable. 也就是说此时MainActivity完全不可见了，从这里我们可以猜测当按下home键的时候，当前activity就会处于onStop的状态。

Activity的生命周期及各生命周期方法的作用

Activity的⽣命周期及各⽣命周期⽅法的作⽤⼀、Activity的⽣命周期中各个⽅法的作⽤ onCreate(): 做Activity上所需要数据的初始化⼯作。

onStart(): 显⽰Activity界⾯，此时⽤户对界⾯可见但不可交互。

onResume(): 此时⽤户可与应⽤进⾏交互，做你想做的事。

onPause(): 此时⽤户可见但不可交互的，或者说此时界⾯没有焦点，例如弹出⼀个对话框。

onstop(): 此时界⾯变得不可见，被下⼀个activity覆盖或者最⼩化了。

onDestroy(): 这是activity被⼲掉前最后⼀个被调⽤⽅法了。

⼆、调⽤⽣命周期⽅法的过程1.启动Activity时：onCreate()-->onStart()-->onResume() -->与⽤户交互2.onPause()-->onResume() onPause()：此时可见不可交互，⼀般是跳出对话框之类的。

此时要在这⾥保存你的⼀些数据---短暂性的数据, 因为这个时候程序的优先级降低，有可能被系统收回。

返回的时候调⽤ onResume()，在 onResume()读取所保存的数据。

注意：这个⽅法⾥做的事情时间要短，因为下⼀个activity():不会等到这个⽅法完成才启动3.onPause()-->onStop()-->onStart()-->onResume() 不可见到可见并交互⼀般是在Activity最⼩化或者被其他Activity覆盖的时候---此时Activity不可见，重新调⽤Activity的过程（这⾥指 Activity没有被系统⼲掉的情况）; 另：如果此时该被覆盖的Activity被系统⼲掉了的话，⼀般都是重新启动Activity了，周期也就从头再来。

4.onPause()-->onStop()-->onDestroy() 这是Activity被⼲掉的过程。

Android课件之Activity生命周期详解

Activity的生命周期概述
1
onCreate()
当Activity被创建时，系统会调用此方法。一般在此方法中进行初始化操作，如设置布局、获取资源等。
2
onStart()和onResume()
当Activity可见时，系统会依次调用这两个方法。可以在这里做一些准备工作和交互操作。
3
onPause()和onStop()
这两个方法主要用于保存和恢复Activity的状态，如屏幕旋转、内存不足等情况下保存和恢复数据。
Activity的启动模式
Activity的启动模式决定了它的行为和与其他Activity的关系。
Standard模式详解
每次启动都创建新的实例。
SingleTop模式详解
如果Activity位于栈顶，不会创建新的实例，直接使用旧的实例。
Android课件之Activity生命周期详解
在这个课件中，我们将详细讲解Android中的Activity生命周期，从何定义 Activity到Activity的启动模式，以及如何最佳处理逻辑和优化性能。
Activity是什么
首先，让我们来了解Activity是什么。Activity是Android应用程序的基本组件，它代表了应用程序的一个窗口，用户可以在其中进行交互。
根据不同的生命周期方法的调用时机，我们可以在这些方法中处理相关逻辑，如初始化、更新UI、保存数据等。
Activity的生命周期对内存和性能的影响
了解Activity的生命周期对于优化内存和性能非常重要，合理地管理和处理生命周期可以减少资源占用和提高用户体验。
最佳实践和注意事项
在开发中，有一些最佳实践和注意事项可以帮助我们更好地使用和管理Activity的生命周期，提高开发效率和应用性能。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

Android系统架构
Android目录结构
1.src目录
src目录中存放的是该项目的源代码，其内部结构会根据用户所声明的包自动组织，该
目录的组织方式为src/com/jiang/Main.java,程序员在项目开发过程中，大部分时间是对该目录下的源代码文件进行编写。

2.gen目录
该目录的文件是ADT自动生成的，并不需要人为地去修改，实际上该目录下只定义了一个R.java文件，该文件相当于项目的字典，项目中用户界面、字符串、图片、声音等资源都会在该类中创建其唯一的ID，当项目中使用这些资源时，会通过该类得到资源的引用。

3.Android2.2
该目录中存放的是该项目支持的JAR包，同时还包含项目打包时需要的META-INF目录。

4.assets目录
该目录用于存放项目相关的资源文件，例如文本文件等，在程序中可以使用”getResources.getAssets().open(“text.txt”)”得到资源文件的输入流InputStream对象。

5.res目录
该目录用于存放应用程序中经常使用的资源文件，包括图片、声音、布局文件及参数描述文件等，包括多个目录，其中以drawable开头的三个文件夹用于存储.png、.9.png、.jpg 等图片资源。

layout文件夹存放的是应用程序的布局文件。

raw用于存放应用程序所用到的声音等资源。

value存放的则是所有XML格式的资源描述文件，例如字符串资源的描述文件strings.xml、样式的描述文件style.xml、颜色描述文件colors.xml、尺寸描述文件dimens.xml，以及数组描述文件arrays.xml等。

6.AndroidManifest.xml文件
该文件为应用程序定义了全局的配置信息。

这个文件列出了应用程序所提供的功能，包括四大组件、版本、权限等等。

在这个文件中，你可以指定应用程序使用到的服务(如电话服务、互联网服务、短信服务、GPS服务等等)。

另外当你新添加一个Activity的时候，也需要在这个文件中进行相应配置，只有配置好后，才能调用此Activity。

android:versionCode是给设备程序识别版本(升级)。

android:versionName是给用户看的。

7.default.properties文件
该文件为项目的配置文件，不需要认为改动，系统会自动为其进行管理，其中主要描述了该项目的版本等信息。

Activity生命周期
Activity简介
Activity是应用程序的表示层，一个活动通常就是一个单独的屏幕。

应用程序中的每个屏幕显示都通过继承和扩展类Activity来实现。

Activity利用View来实现应用程序的GUI，而我们的手机用户则直接通过GUI和应用程序做交互，如应用程序通过GUI向用户显示信息，用户通过GUI向应用程序发出指令和响应。

Activity生命周期
Back 键与Home键
back键默认行为是finish处于前台的Activity的即Activity的状态为Destroy状态为止，再次启动该Activity是从onCreate开始的(不会调用onSaveInstanceState方法)。

Home键默认是stop前台的Activity即状态为onStop为止而不是Destroy,若再次启动它，会调用onSaveInstanceState方法，保持上次Activity的状态则是从OnRestart开始的---->onStart()--->onResume()。

关于onSaveInstanceState
是在Activity即将被销毁时调用，(按home或者Ac跳转会调用，在onPause()前)
注意：如果在B的整个生命周期里A的用户界面状态都没有被破坏的话，系统是不会调用a ctivity A的onSaveInstanceState(Bundle)的。

Activity通过Activity栈方式管理
Activity是Android程序的表现层。

程序的每一个显示屏幕就是一个Activity。

正在运行的Activity处在栈的最顶端，它是运行状态的。

当有新的Activity进入屏幕最上端时，原来的Activity就会被压入第二层。

如果他的屏幕没有被完全遮盖，那么他处于Paused状态，如果他被遮盖那么处于Stop状态。

不管处于任何一层，都可能在系统觉得资源不足时被强行关闭，当然关闭时栈底的程序最先被关闭。

进程释放优先级
①前台进程：
正在前台运行的进程，说明用户当前正通过该进程与系统进行交互，所以该进程为最重要的进程②可视进程：
一般还是显示在屏幕上，但是用户并没有直接与之进行交互
③服务进程：
拥有Service的进程，该进程一般是在后台为用户服务。

④后台进程：
包含一个不可视的Activity，缺少该进程并不会影响用户对系统的体验。

⑤空进程
机制服务的
观察者模式在Android 中的应用观察者模式
观察者模式是软体设计模式的一种。

在此种模式中，一个目标物件管理所有相依于它的观察者物件，并且在它本身的状态改变时主动发出通知。

实现过程：“注册——通知——撤销注册”
1、观察者
（Observer ）将自己注册到被观察对象（Subject ）中，被观察对象将观察者存放在一个容器（Container ）里。

2、被观察对象
被观察对象发生了某种变化，从容器中得到所有注册过的观察者，将变化通知观察者。

3、撤销观察
观察者告诉被观察者要撤销观察，被观察者从容器中将观察者去除。

观察者将自己注册到被观察者的容器中时，被观察者不应该过问观察者的具体类型，而是应该使用观察者的接口。

这样的优点是：假定程序中还有别的观察者，那么只要这个观察者也是相同的接口实现即可。

一个被观察者可以对应多个观察者，当被观察者发生变化的时候，他可以将消息一一通知给所有的观察者。

基于接口，而不是具体的实现——这一点为程序提供了更大的灵活性。

Android 事件处理
A ．
1. 为
如
B.
2. 件监听器
C
3. 当监听器对象接收到事件对象之后，系统会调用监听器中相应的事件处理方法来处理事
件并作出相应。

示例代码：
常用的事件接口
OnClickListener 处理点击事件。

重写的方法：
OnClick(View v)
参数：v是事件源控件
OnLongClickListener 处理View长按事件。

重写的方法：
OnLongClick(View v)
参数：v是事件源控件
OnFocusChangeListener用来处理控件焦点发生改变(失去或获得)的事件。

重写的方法：
OnFocusChange (View v,Boolean hasFocus)
参数：v同上
hasFocus是否获得焦点
OnKeyListener通过对某个View注册该监听，当View获得焦点并有键盘事件时，便会触发该接口中的回调方法。

重写的方法：
OnKey(View v,int keyCode,KeyEvent event)
参数:v同上
keyCode为手机键盘的键盘码
event为键盘事件封装类对象，包含了事件的详细信息，如事件类型等。

OnTouchListener用来处理手机屏幕事件的监听接口，当为View的范围内触摸按下、抬起或滑动等动作都会触发该事件。

重写的方法：
OnTouch(View v,MotionEvent event)
参数：v同上
event为事件封装类对象，封装了触发时间的详细信息，同样包括事件的类型、触发时间等信息。

使用event.getAction==MotionEvent.ACTION_XXX的形
式(还要重写XXX对应的方法)。