程序博客网 > 开扒淘宝高端定制店

Android实战简易教程<七>（Activity的启动模式）

来源：互联网 发布：开扒淘宝高端定制店 编辑：程序博客网 时间：2024/06/06 16:31

在介绍四种启动模式之前，先介绍一下Task栈的相关知识，task是一个具有栈结构的容器，可以放置多个Activity实例。

启动一个应用，系统就会为之创建一个task，来放置根Activity；默认情况下，一个Activity启动另一个Activity时，两个Activity是放置在同一个task中的，后者被压入前者所在的task栈，当用户按下后退键，后者从task被弹出，前者又显示在幕前，特别是启动其他应用中的Activity时，两个Activity对用户来说就好像是属于同一个应用；系统task和task之间是互相独立的，当我们运行一个应用时，按下Home键回到主屏，启动另一个应用，这个过程中，之前的task被转移到后台，新的task被转移到前台，其根Activity也会显示到幕前，过了一会之后，在此按下Home键回到主屏，再选择之前的应用，之前的task会被转移到前台，系统仍然保留着task内的所有Activity实例，而那个新的task会被转移到后台，如果这时用户再做后退等动作，就是针对该task内部进行操作了。

下面介绍一下启动模式，启动模式一共有四种：standard、singleTop、singleTask、singleInstance，可以在AndroidManifest.xml文件中通过给<activity>标签指定android:launchMode属性来选择启动模式，下面来逐个研究。

一、standard模式

standard是默认启动方式，所有活动会自动使用这种模式。Android使用Task栈来管理活动的，在本模式下，每当启动一个新的活动，它就会在Task栈中入栈，并处于栈顶位置。对于该模式下，系统不会在乎是否这个活动已经在栈中，每次启动都会创建该活动的一个新的实例。下面我们通过程序观察一下：

[java] view plaincopy
  1. package org.yayun.demo;  
  2.   
  3. import android.app.Activity;  
  4. import android.content.Intent;  
  5. import android.os.Bundle;  
  6. import android.util.Log;  
  7. import android.view.View;  
  8. import android.view.View.OnClickListener;  
  9. import android.widget.Button;  
  10.   
  11. public class MainActivity extends Activity {  
  12.     private Button btnButton;  
  13.     public void onCreate(Bundle savedInstanceState) {  
  14.         super.onCreate(savedInstanceState); // 生命周期方法  
  15.         Log.d("MainActivity",this.toString());  
  16.         super.setContentView(R.layout.main); // 设置要使用的布局管理器  
  17.           
  18.     btnButton=(Button)findViewById(R.id.btn);  
  19.     btnButton.setOnClickListener(new OnClickListener() {  
  20.           
  21.         public void onClick(View v) {  
  22.             Intent intent=new Intent(MainActivity.this,MainActivity.class);  
  23.             startActivity(intent);  
  24.               
  25.         }  
  26.     });  
  27.   
  28.     }  
  29. }  


运行程序连续点击三次按钮，观察一下logcat:

可以看出每点击一次按钮就产生一个新的活动，此时返回栈中有四个MainActivity,连续按四次返回键才能退出程序。看一下模拟原理示意图：

二、singleTop模式

从字面意思来理解，当活动处于栈顶且已经存在时即不再入栈，当不处于栈顶时，则继续入栈。通过实例来验证一下我们观点的正确性。

修改AndroidManifest.xml中MainActivity的启动模式：

[html] view plaincopy
  1. <?xml version="1.0" encoding="utf-8"?>  
  2. <manifest   
  3.     xmlns:android="http://schemas.android.com/apk/res/android"  
  4.     package="org.yayun.demo"   
  5.     android:versionCode="1"   
  6.     android:versionName="1.0">  
  7.     <uses-sdk android:minSdkVersion="10" />  
  8.     <application   
  9.         android:icon="@drawable/icon"   
  10.         android:label="@string/app_name">  
  11.         <activity   
  12.             android:name=".MainActivity"   
  13.             android:launchMode="singleTop"  
  14.             android:label="@string/app_name">  
  15.             <intent-filter>  
  16.                 <action android:name="android.intent.action.MAIN" />  
  17.                 <category android:name="android.intent.category.LAUNCHER" />  
  18.             </intent-filter>  
  19.         </activity>  
  20.     </application>  
  21.       
  22. </manifest>  


然后重新运行程序,此时再点击按钮只会产生一个Activity:

下面我们测试，当MainActivity不处于栈顶时的情形：

1.修改MainActivity.java代码如下：

[java] view plaincopy
  1. package org.yayun.demo;  
  2.   
  3. import android.app.Activity;  
  4. import android.content.Intent;  
  5. import android.os.Bundle;  
  6. import android.util.Log;  
  7. import android.view.View;  
  8. import android.view.View.OnClickListener;  
  9. import android.widget.Button;  
  10.   
  11. public class MainActivity extends Activity {  
  12.     private Button btnButton;  
  13.     public void onCreate(Bundle savedInstanceState) {  
  14.         super.onCreate(savedInstanceState); // 生命周期方法  
  15.         Log.d("MainActivity",this.toString());  
  16.         super.setContentView(R.layout.main); // 设置要使用的布局管理器  
  17.           
  18.     btnButton=(Button)findViewById(R.id.btn);  
  19.     btnButton.setOnClickListener(new OnClickListener() {  
  20.           
  21.         public void onClick(View v) {  
  22.             Intent intent=new Intent(MainActivity.this,SecondActivity.class);  
  23.             startActivity(intent);  
  24.               
  25.         }  
  26.     });  
  27.   
  28.     }  
  29. }  


2.SecondActivity.java代码如下：

[java] view plaincopy
  1. package org.yayun.demo;  
  2.   
  3. import android.app.Activity;  
  4. import android.content.Intent;  
  5. import android.os.Bundle;  
  6. import android.util.Log;  
  7. import android.view.View;  
  8. import android.view.View.OnClickListener;  
  9. import android.widget.Button;  
  10.   
  11. public class SecondActivity extends Activity {  
  12.     private Button button;  
  13.     public void onCreate(Bundle savedInstanceState) {  
  14.         super.onCreate(savedInstanceState); // 生命周期方法  
  15.         Log.d("SecondMainActivity",this.toString());  
  16.         super.setContentView(R.layout.second); // 设置要使用的布局管理器  
  17.     button=(Button)findViewById(R.id.btn);  
  18.     button.setOnClickListener(new OnClickListener() {  
  19.           
  20.         public void onClick(View v) {  
  21.             Intent intent=new Intent(SecondActivity.this,MainActivity.class);//跳到MainActivity  
  22.             startActivity(intent);  
  23.               
  24.         }  
  25.     });  
  26.       
  27.   
  28.     }  
  29. }  


先点击MainActivity里的按钮跳到SecondActivity，然后再点击SecondActivity里的按钮跳到MainActivity，我们来观察logcat:

一共启动了两次MainActivity，这时你按返回按钮，应该先返回SecondActivity,再按返回按钮返回MainActivity，再按返回按钮程序退出，看一下模拟原理示意图：

三、singleTask模式

使用本模式可以很好的解决重复创建栈顶活动的问题，当活动的启动模式指定为singleTask，每次启动该活动时系统首先会在Task栈中检查是否存在该活动的实例，如果发现已经存在则直接使用该实例，并把这个活动之上的活动统统出栈，如果没有发现则创建一个实例。

1.将MainActivity的启动模式修改为：

[html] view plaincopy
  1. <?xml version="1.0" encoding="utf-8"?>  
  2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"  
  3.     package="org.yayun.demo"  
  4.     android:versionCode="1"  
  5.     android:versionName="1.0" >  
  6.   
  7.     <uses-sdk android:minSdkVersion="10" />  
  8.   
  9.     <application  
  10.         android:icon="@drawable/icon"  
  11.         android:label="@string/app_name" >  
  12.         <activity  
  13.             android:name=".MainActivity"  
  14.             android:label="@string/app_name"  
  15.             android:launchMode="singleTask" >  
  16.             <intent-filter>  
  17.                 <action android:name="android.intent.action.MAIN" />  
  18.   
  19.                 <category android:name="android.intent.category.LAUNCHER" />  
  20.             </intent-filter>  
  21.         </activity>  
  22.         <activity android:name=".SecondActivity" >  
  23.         </activity>  
  24.     </application>  
  25.   
  26. </manifest>  

 

2.在MainActivity中覆写onRestart()方法：

[java] view plaincopy
  1. @Override  
  2. protected void onRestart() {  
  3.     super.onRestart();  
  4.     Log.d("MainActivity","onRestart");  
  5. }  


3.在SecondActivity中覆写onDestroy()方法：

[java] view plaincopy
  1. @Override  
  2.     protected void onDestroy() {  
  3.         super.onDestroy();  
  4.         Log.d("SecondActivity","onDestroy");  
  5.     }  


4.运行实例，首先点击MainActivity里的按钮跳到SecondActivity，然后点击SecondActivity里的按钮跳到MainActivity。查看logcat:

 

 从打印信息中可以看出，在SecondActivity中启动MainActivity时会发现栈中已经存在一个MainActivity实例了，并且在SecondActivity的下面，于是SecondActivity会从返回栈中出栈，而MainActivity重新成了栈顶活动，因此MainActivity的onRestart()方法和SecondActivity的onDestroy()方法得以执行。这时你只用点击一次返回按钮就能退出程序了。看一下原理示意图：

四、singleInstance

这个模式不同于以上三种模式，指定为singleInstance模式的活动会启用一个新的返回栈来管理这个活动（其实，如果singleTask模式制定了不同的taskAffinity，也许启动一个新的返回栈）。那么这么做的意义是什么呢？想象一下如下场景，假设我们的程序中有一个活动允许其他程序调用的，如果我们想实现其他程序和我们的程序可以共享这个活动的实例，应该如何实现呢？在本模式下会产生一个单独的返回栈来管理这个共享的活动，无论哪个应用程序来访问这个活动，都共用同一个返回栈，也就解决了共享活动实例的问题。我们来实践一下。

1.修改AndroidManifest.xml中SecondActivity的launchMode：

[html] view plaincopy
  1. <?xml version="1.0" encoding="utf-8"?>  
  2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"  
  3.     package="org.yayun.demo"  
  4.     android:versionCode="1"  
  5.     android:versionName="1.0" >  
  6.   
  7.     <uses-sdk android:minSdkVersion="10" />  
  8.   
  9.     <application  
  10.         android:icon="@drawable/icon"  
  11.         android:label="@string/app_name" >  
  12.         <activity  
  13.             android:name=".MainActivity"  
  14.             android:label="@string/app_name"  
  15.             android:launchMode="singleTask" >  
  16.             <intent-filter>  
  17.                 <action android:name="android.intent.action.MAIN" />  
  18.   
  19.                 <category android:name="android.intent.category.LAUNCHER" />  
  20.             </intent-filter>  
  21.         </activity>  
  22.         <activity   
  23.             android:name=".SecondActivity"  
  24.             android:launchMode="singleInstance" >  
  25.         </activity>  
  26.         <activity   
  27.             android:name=".ThirdActivity"></activity>  
  28.     </application>  
  29.   
  30. </manifest>  


2.修改MainActivity.java代码：

[java] view plaincopy
  1. package org.yayun.demo;  
  2.   
  3. import android.app.Activity;  
  4. import android.content.Intent;  
  5. import android.os.Bundle;  
  6. import android.util.Log;  
  7. import android.view.View;  
  8. import android.view.View.OnClickListener;  
  9. import android.widget.Button;  
  10.   
  11. public class MainActivity extends Activity {  
  12.     private Button btnButton;  
  13.     public void onCreate(Bundle savedInstanceState) {  
  14.         super.onCreate(savedInstanceState); // 生命周期方法  
  15.         Log.d("MainActivity","Task id is"+getTaskId());  
  16.         super.setContentView(R.layout.main); // 设置要使用的布局管理器  
  17.           
  18.     btnButton=(Button)findViewById(R.id.btn);  
  19.     btnButton.setOnClickListener(new OnClickListener() {  
  20.           
  21.         public void onClick(View v) {  
  22.             Intent intent=new Intent(MainActivity.this,SecondActivity.class);  
  23.             startActivity(intent);  
  24.               
  25.         }  
  26.     });  
  27.   
  28.     }  
  29.     @Override  
  30.     protected void onRestart() {  
  31.         super.onRestart();  
  32.         Log.d("MainActivity","onRestart");  
  33.     }  
  34. }  

3.修改SecondActivity.java:

[java] view plaincopy
  1. package org.yayun.demo;  
  2.   
  3. import android.app.Activity;  
  4. import android.content.Intent;  
  5. import android.os.Bundle;  
  6. import android.util.Log;  
  7. import android.view.View;  
  8. import android.view.View.OnClickListener;  
  9. import android.widget.Button;  
  10.   
  11. public class SecondActivity extends Activity {  
  12.     private Button button;  
  13.     public void onCreate(Bundle savedInstanceState) {  
  14.         super.onCreate(savedInstanceState); // 生命周期方法  
  15.         Log.d("SecondActivity","Task id is"+getTaskId());  
  16.         super.setContentView(R.layout.second); // 设置要使用的布局管理器  
  17.     button=(Button)findViewById(R.id.btn);  
  18.     button.setOnClickListener(new OnClickListener() {  
  19.           
  20.         public void onClick(View v) {  
  21.             Intent intent=new Intent(SecondActivity.this,ThirdActivity.class);  
  22.             startActivity(intent);  
  23.               
  24.         }  
  25.     });  
  26.       
  27.   
  28.     }  
  29.     @Override  
  30.     protected void onDestroy() {  
  31.         super.onDestroy();  
  32.         Log.d("SecondActivity","onDestroy");  
  33.     }  
  34. }  


4.修改ThirdActivity.java:

[java] view plaincopy
  1. package org.yayun.demo;  
  2.   
  3. import android.app.Activity;  
  4. import android.os.Bundle;  
  5. import android.util.Log;  
  6.   
  7. public class ThirdActivity extends Activity {  
  8.       
  9.     public void onCreate(Bundle savedInstanceState) {  
  10.         super.onCreate(savedInstanceState); // 生命周期方法  
  11.         Log.d("ThirdActivity","Task id is"+getTaskId());  
  12.         super.setContentView(R.layout.main); // 设置要使用的布局管理器  
  13.       
  14.   
  15.     }  
  16. }  


运行实例，点击按钮跳到SecondActivity，再点击按钮跳到ThirdActivity,我们看一下此时的logcat：


可以看出MainActivity和ThirdActivity在同一个Task中，SecondActivity在另一个Task中，这时我们按返回按钮，从ThirdActivity直接跳到MainActivity，再按返回键，跳到SecondActivity,再按返回键，所有的栈都已经空了，程序退出。看一下singleInstance模式的原理示意图：

 

0 0
开扒淘宝高端定制店 开扒淘宝高端定制店
原创粉丝点击
热门IT博客
农村淘宝怎么申请农村淘宝怎么申请
php怎么连接虚拟主机php怎么连接虚拟主机
mux数据选择器
数据库的管理实验报告
电力工程经济评价软件
apache下载安装 php
林志颖吹牛知乎
土木工程三维建模软件
软件验收报告
如何彻底注销淘宝店铺
mmd恋爱循环动作数据
php大牛简历
爬取企业工商数据
selected 知乎
推荐系统的算法
天猫卖家最怕什么知乎
网络销售药品
淘宝全新店铺出售
mac 无需root密码登录
阿里云企业邮箱 免费
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 小型钻孔机械 空调打孔尺寸 空调开孔尺寸 空调洞尺寸 钻展 淘宝钻展 钻展推广 钻展是什么 钻展图 淘宝钻展是什么 淘宝钻展图 淘宝钻展图片尺寸 钻展图尺寸 钻石展位 钻铣床小型 zx6350d钻铣床 小型钻铣床价格 zx6350钻铣床 多轴钻床 龙门钻床 二手摇臂钻床 钻床价格 组合钻床 深孔钻镗床 自动分度钻床 数控龙门钻床 木工钻床 高速钻床 数控钻床价格 数控平面钻床 自动进给钻床 钻床参数 多孔钻床 钻床型号 钻床图片 钻床攻牙器 中捷钻床 西菱钻床 立式钻床型号 简易钻床 手动钻床

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里