Android经典面试题总结（未完待续）

1.生命周期

场景演示 : 切换到该Fragment
11-29 14:26:35.095: D/AppListFragment(7649): onAttach
11-29 14:26:35.095: D/AppListFragment(7649): onCreate
11-29 14:26:35.095: D/AppListFragment(7649): onCreateView
11-29 14:26:35.100: D/AppListFragment(7649): onActivityCreated
11-29 14:26:35.120: D/AppListFragment(7649): onStart
11-29 14:26:35.120: D/AppListFragment(7649): onResume
屏幕灭掉：
11-29 14:27:35.185: D/AppListFragment(7649): onPause
11-29 14:27:35.205: D/AppListFragment(7649): onSaveInstanceState
11-29 14:27:35.205: D/AppListFragment(7649): onStop

屏幕解锁
11-29 14:33:13.240: D/AppListFragment(7649): onStart
11-29 14:33:13.275: D/AppListFragment(7649): onResume

切换到其他Fragment:
11-29 14:33:33.655: D/AppListFragment(7649): onPause
11-29 14:33:33.655: D/AppListFragment(7649): onStop
11-29 14:33:33.660: D/AppListFragment(7649): onDestroyView

切换回本身的Fragment:
11-29 14:33:55.820: D/AppListFragment(7649): onCreateView
11-29 14:33:55.825: D/AppListFragment(7649): onActivityCreated
11-29 14:33:55.825: D/AppListFragment(7649): onStart
11-29 14:33:55.825: D/AppListFragment(7649): onResume
回到桌面
11-29 14:34:26.590: D/AppListFragment(7649): onPause
11-29 14:34:26.880: D/AppListFragment(7649): onSaveInstanceState
11-29 14:34:26.880: D/AppListFragment(7649): onStop
回到应用
11-29 14:36:51.940: D/AppListFragment(7649): onStart
11-29 14:36:51.940: D/AppListFragment(7649): onResume

退出应用
11-29 14:37:03.020: D/AppListFragment(7649): onPause
11-29 14:37:03.155: D/AppListFragment(7649): onStop
11-29 14:37:03.155: D/AppListFragment(7649): onDestroyView
11-29 14:37:03.165: D/AppListFragment(7649): onDestroy
11-29 14:37:03.165: D/AppListFragment(7649): onDetach

2.Android中的Context, Activity，Appliction有什么区别？
相同：Activity和Application都是Context的子类。
Context从字面上理解就是上下文的意思，在实际应用中它也确实是起到了管理上下文环境中各个参数和变量的总用，方便我们可以简单的访问到各种资源。
不同：维护的生命周期不同。 Context维护的是当前的Activity的生命周期，Application维护的是整个项目的生命周期。
使用context的时候，小心内存泄露，防止内存泄露，注意一下几个方面：
　1. 不要让生命周期长的对象引用activity context，即保证引用activity的对象要与activity本身生命周期是一样的。
　2. 对于生命周期长的对象，可以使用application，context。
　3. 避免非静态的内部类，尽量使用静态类，避免生命周期问题，注意内部类对外部对象引用导致的生命周期变化。

3.两个Activity之间传递数据，除了intent，广播接收者，content provider还有啥？
1）利用static静态数据，public static成员变量
2）利用外部存储的传输，
例如 File 文件存储
SharedPreferences首选项
Sqlite 数据库

4.Context是什么？
1、它描述的是一个应用程序环境的信息，即上下文。
2、该类是一个抽象(abstract class)类，Android提供了该抽象类的具体实现类（ContextIml）。
3、通过它我们可以获取应用程序的资源和类，也包括一些应用级别操作，例如：启动一个Activity，发送广播，接受Intent，信息，等。

5. 一条最长的短信息约占多少 byte?
中文70( 包括标点) ，英文160 ，160 个字节。
因为英文字母采用7位ASCII编码，而汉字则采用8位UCS-2编码并占2个字节，所以160个字符按照7位ASCII编码来换算，即160X7=1120位；而汉字是按照8位的UCS-2编码，即8位一个字符，一个汉字占2个字符，这样1120位换算成汉字数就是1120/8/2=70。

6. 如何将打开 res aw 目录中的数据库文件 ?
解答：在 Android 中不能直接打开 res aw 目录中的数据库文件，而需要在程序第一次启动时将该文件复制到手机内存或 SD 卡的某个目录中，然后再打开该数据库文件。复制的基本方法是使用 getResources().openRawResource 方法获得 res aw 目录中资源的 InputStream 对象，然后将该 InputStream 对象中的数据写入其他的目录中相应文件中。在 Android SDK 中可以使用 SQLiteDatabase.openOrCreateDatabase 方法来打开任意目录中的 SQLite 数据库文件。

7.Android 系统的架构
android 的系统架构和其操作系统一样，采用了分层的架构。从架构图看， android 分为四个层，从高层到低层分别是应用程序层、应用程序框架层、系统运行库层和 linux 核心层。
　　 1. 应用程序
　　 Android 会同一系列核心应用程序包一起发布，该应用程序包包括 email 客户端， SMS 短消息程序，日历，地图，浏览器，联系人管理程序等。所有的应用程序都是使用 JAVA 语言编写的。
　　 2. 应用程序框架
　　开发人员也可以完全访问核心应用程序所使用的 API 框架。该应用程序的架构设计简化了组件的重用 ; 任何一个应用程序都可以发布它的功能块并且任何其它的应用程序都可以使用其所发布的功能块 ( 不过得遵循框架的安全性限制 ) 。同样，该应用程序重用机制也使用户可以方便的替换程序组件。
　　隐藏在每个应用后面的是一系列的服务和系统 , 其中包括 ;
　　 * 丰富而又可扩展的视图 (Views) ，可以用来构建应用程序， 它包括列表 (lists) ，网格 (grids) ，文本框 (text boxes) ，按钮 (buttons) ， 甚至可嵌入的 web 浏览器。
　　 * 内容提供器 (Content Providers) 使得应用程序可以访问另一个应用程序的数据 ( 如联系人数据库 ) ， 或者共享它们自己的数据
　　 * 资源管理器 (Resource Manager) 提供 非代码资源的访问，如本地字符串，图形，和布局文件 ( layout files ) 。
　　 * 通知管理器 (Notification Manager) 使得应用程序可以在状态栏中显示自定义的提示信息。
　　 * 活动管理器 ( Activity Manager) 用来管理应用程序生命周期并提供常用的导航回退功能。
　　有关更多的细节和怎样从头写一个应用程序，请参考 如何编写一个 Android 应用程序 .
　　 3. 系统运行库
　　 1) 程序库
　　 Android 包含一些 C/C++ 库，这些库能被 Android 系统中不同的组件使用。它们通过 Android 应用程序框架为开发者提供服务。以下是一些核心库：
　　 * 系统 C 库 - 一个从 BSD 继承来的标准 C 系统函数库 ( libc ) ， 它是专门为基于 embedded linux 的设备定制的。
　　 * 媒体库 - 基于 PacketVideo OpenCORE; 该库支持多种常用的音频、视频格式回放和录制，同时支持静态图像文件。编码格式包括 MPEG4, H.264, MP3, AAC, AMR, JPG, PNG 。
　　 * Surface Manager - 对显示子系统的管理，并且为多个应用程序提 供了 2D 和 3D 图层的无缝融合。
　　 * LibWebCore - 一个最新的 web 浏览器引擎用，支持 Android 浏览器和一个可嵌入的 web 视图。
　　 * SGL - 底层的 2D 图形引擎
　　 * 3D libraries - 基于 OpenGL ES 1.0 APIs 实现 ; 该库可以使用硬件 3D 加速 ( 如果可用 ) 或者使用高度优化的 3D 软加速。
　　 * FreeType - 位图 (bitmap) 和矢量 (vector) 字体显示。

　　 * SQLite - 一个对于所有应用程序可用，功能强劲的轻型关系型数据库引擎。
　　 2)Android 运行库
　　 Android 包括了一个核心库，该核心库提供了 JAVA 编程语言核心库的大多数功能。
　　每一个 Android 应用程序都在它自己的进程中运行，都拥有一个独立的 Dalvik 虚拟机实例。 Dalvik 被设计成一个设备可以同时高效地运行多个虚拟系统。 Dalvik 虚拟机执行 (.dex) 的 Dalvik 可执行文件，该格式文件针对小内存使用做了优化。同时虚拟机是基于寄存器的，所有的类都经由 JAVA 编译器编译，然后通过 SDK 中 的 “ dx ” 工具转化成 .dex 格式由虚拟机执行。
　　 Dalvik 虚拟机依赖于 linux 内核的一些功能，比如线程机制和底层内存管理机制。
　　 4.Linux 内核
Android 的核心系统服务依赖于 Linux 2.6 内核，如安全性，内存管理，进程管理， 网络协议栈和驱动模型。 Linux 内核也同时作为硬件和软件栈之间的抽象层。

8. 请介绍下 Android 中常用的五种布局
Android 布局是应用界面开发的重要一环，在 Android 中，共有五种布局方式，分别是： FrameLayout （框架布局），LinearLayout （线性布局），AbsoluteLayout （绝对布局）， RelativeLayout （相对布局）， TableLayout （表格布局）。

9. 如何启用 Service ，如何停用 Service
Android 中的服务和 windows 中的服务是类似的东西，服务一般没有用户操作界面，它运行于系统中不容易被用户发觉，可以使用它开发如监控之类的程序。服务的开发比较简单，如下：
第一步：继承 Service 类
public class SMSService extends Service {
}
第二步：在 AndroidManifest.xml 文件中的 节点里对服务进行配置 :

服务不能自己运行，需要通过调用 Context.startService() 或 Context.bindService() 方法启动服务。这两个方法都可以启动 Service ，但是它们的使用场合有所不同。使用 startService() 方法启用服务，调用者与服务之间没有关连，即使调用者退出了，服务仍然运行。使用 bindService() 方法启用服务，调用者与服务绑定在了一起，调用者一旦退出，服务也就终止，大有“不求同时生，必须同时死”的特点。

如果打算采用 Context.startService() 方法启动服务，在服务未被创建时，系统会先调用服务的 onCreate() 方法，接着调用 onStart() 方法。如果调用 startService() 方法前服务已经被创建，多次调用 startService() 方法并不会导致多次创建服务，但会导致多次调用 onStart() 方法。采用 startService() 方法启动的服务，只能调用 Context.stopService() 方法结束服务，服务结束时会调用 onDestroy() 方法。

如果打算采用 Context.bindService() 方法启动服务，在服务未被创建时，系统会先调用服务的 onCreate() 方法，接着调用 onBind() 方法。这个时候调用者和服务绑定在一起，调用者退出了，系统就会先调用服务的 onUnbind() 方法，接着调用 onDestroy() 方法。如果调用 bindService() 方法前服务已经被绑定，多次调用 bindService() 方法并不会导致多次创建服务及绑定 ( 也就是说 onCreate() 和 onBind() 方法并不会被多次调用 ) 。如果调用者希望与正在绑定的服务解除绑定，可以调用 unbindService() 方法，调用该方法也会导致系统调用服务的 onUnbind()–>onDestroy() 方法。
服务常用生命周期回调方法如下：
onCreate() 该方法在服务被创建时调用，该方法只会被调用一次，无论调用多少次 startService() 或 bindService() 方法，服务也只被创建一次。
onDestroy() 该方法在服务被终止时调用。

与采用 Context.startService() 方法启动服务有关的生命周期方法
onStart() 只有采用 Context.startService() 方法启动服务时才会回调该方法。该方法在服务开始运行时被调用。多次调用 startService() 方法尽管不会多次创建服务，但 onStart() 方法会被多次调用。

与采用 Context.bindService() 方法启动服务有关的生命周期方法
onBind() 只有采用 Context.bindService() 方法启动服务时才会回调该方法。该方法在调用者与服务绑定时被调用，当调用者与服务已经绑定，多次调用 Context.bindService() 方法并不会导致该方法被多次调用。
onUnbind() 只有采用 Context.bindService() 方法启动服务时才会回调该方法。该方法在调用者与服务解除绑定时被调用

采用 Context.startService() 方法启动服务的代码如下：

public class HelloActivity extends Activity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        ......
        Button button =(Button) this.findViewById(R.id.button);
        button.setOnClickListener(new View.OnClickListener(){
       public void onClick(View v) {
              Intent intent = new Intent(HelloActivity.this, SMSService.class);
              startService(intent);
       }});      
    }
}

采用 Context. bindService() 方法启动服务的代码如下：

public class HelloActivity extends Activity {
     ServiceConnection conn = new ServiceConnection() {
              public void onServiceConnected(ComponentName name, IBinder service) {
           }
           public void onServiceDisconnected(ComponentName name) {
           }
     };
    @Override
       public void onCreate(Bundle savedInstanceState) {
        Button button =(Button) this.findViewById(R.id.button);
        button.setOnClickListener(new View.OnClickListener(){
               public void onClick(View v) {
                  Intent intent = new Intent(HelloActivity.this, SMSService.class);
                  bindService(intent, conn, Context.BIND_AUTO_CREATE);
                  //unbindService(conn);// 解除绑定
          }});      
    }
}

10. 广播接收者生命周期
一个广播接收者有一个回调方法： void onReceive(Context curContext , Intent broadcastMsg ) 。当一个广播消息到达接收者是， Android 调用它的 onReceive() 方法并传递给它包含消息的 Intent 对象。广播接收者被认为仅当它执行这个方法时是活跃的。当 onReceive() 返回后，它是不活跃的。
有一个活跃的广播接收者的进程是受保护的，不会被杀死。但是系统可以在任何时候杀死仅有不活跃组件的进程，当占用的内存别的进程需要时。
这带来一个问题，当一个广播消息的响应时费时的，因此应该在独立的线程中做这些事，远离用户界面其它组件运行的主线程。如果 onReceive() 衍生线程然后返回，整个进程，包括新的线程，被判定为不活跃的（除非进程中的其它应用程序组件是活跃的），将使它处于被杀的危机。解决这个问题的方法是 onReceive() 启动一个服务，及时服务做这个工作，因此系统知道进程中有活跃的工作在做。

11. 设计模式和 IoC( 控制反转 )
Android 框架魅力的源泉在于 IoC ，在开发 Android 的过程中你会时刻感受到 IoC 带来
的巨大方便，就拿 Activity 来说，下面的函数是框架调用自动调用的：
protected void onCreate(Bundle savedInstanceState) ；
不是程序编写者主动去调用，反而是用户写的代码被框架调用，这也就反转
了！当然 IoC 本身的内涵远远不止这些，但是从这个例子中也可以窥视出 IoC
带来的巨大好处。此类的例子在 Android 随处可见，例如说数据库的管理类，
例如说 Android 中 SAX 的 Handler 的调用等。有时候，您甚至需要自己编写简
单的 IoC 实现，上面展示的多线程现在就是一个说明。

12. 什么是 ANR 如何避免它 ?
ANR ： Application Not Responding ，五秒
在 Android 中，活动管理器和窗口管理器这两个系统服务负责监视应用程序的响应。当出现下列情况时， Android 就会显示 ANR 对话框了：
　　对输入事件 ( 如按键、触摸屏事件 ) 的响应超过 5 秒
　　意向接受器 (intentReceiver) 超过 10 秒钟仍未执行完毕
　　 Android 应用程序完全运行在一个独立的线程中 ( 例如 main) 。这就意味着，任何在主线程中运行的，需要消耗大量时间的操作都会引发 ANR 。因为此时，你的应用程序已经没有机会去响应输入事件和意向广播 (Intent broadcast) 。

　　因此，任何运行在主线程中的方法，都要尽可能的只做少量的工作。特别是活动生命周期中的重要方法如 onCreate() 和 onResume() 等更应如此。潜在的比较耗时的操作，如访问网络和数据库 ; 或者是开销很大的计算，比如改变位图的大小，需要在一个单独的子线程中完成 ( 或者是使用异步请求，如数据库操作 ) 。但这并不意味着你的主线程需要进入阻塞状态已等待子线程结束 – 也不需要调用 Therad.wait() 或者 Thread.sleep() 方法。取而代之的是，主线程为子线程提供一个句柄 (Handler) ，让子线程在即将结束的时候调用它 (xing: 可以参看 Snake 的例子，这种方法与以前我们所接触的有所不同 ) 。使用这种方法涉及你的应用程序，能够保证你的程序对输入保持良好的响应，从而避免因为输入事件超过 5 秒钟不被处理而产生的 ANR 。这种实践需要应用到所有显示用户界面的线程，因为他们都面临着同样的超时问题。

13、两个Activity之间跳转时必然会执行的是哪几个方法？
一般情况下比如说有两个activity,分别叫A,B,当在A里面激活B组件的时候, A会调用 onPause()方法,然后B调用onCreate() ,onStart(), onResume()。

这个时候B覆盖了窗体, A会调用onStop()方法. 如果B是个透明的,或者是对话框的样式, 就不会调用A的onStop()方法。

14.单例模式
见http://blog.csdn.net/jason0539/article/details/23297037/

15.Listview列表效率优化
（1）利用convertview回收视图
（2）采用ViewHolder模式
（3） 异步加载图片
（4） 快速滑动时不加载图片
（5） 如果自定义的item中有图片，需要处理图片（减少图片所占内存）
1.对图片进行边界压缩 2.用option类来保存图片大小 3.避免图片的实时缩放，最好预先缩放到视图大小
（6）尽量避免在listview适配器中使用线程，因为线程是产生内存泄露的主要原因在于线程的生命周期不可控。

16.应用内存优化
（1）bitmap设置图片大小（优化内存溢出）
BitmapFactory.Option option = new BitmapFactory.Option();
option.inSampleSize = 2; //将视图宽、高都变为原来的1/2
（2）bitmap对象销毁，可以借助recycle（）方法让GC回收bitmap对象。
（3）尽量避免static成员变量引用资源消耗过多的实例，如：context
（4）使用Application的context
（5）及时关闭资源，如在查询数据库时需要及时关闭cursor
（6）对经常使用的图片使用软引用保存
（7）线程也是造成内存泄露的一个重要原因，在于线程的生命周期不可控制，解决方法：
1.将线程内部类改为静态内部类
2.用弱引用来保存context引用
（8）使用.9图片

17.数据存储的方法
sharedpreference存储、文件存储、SQLite存储、contentprovide存储、网络存储数据

18.set、List的区别：Set中元素不重复
存放的是对象的引用，没有重复对象

   Set set=new HashSet();
　　String s1=new String("hello");
　　String s2=s1;
　　String s3=new String("world");
　　set.add(s1);
　　set.add(s2);
　　set.add(s3);
　　System.out.println(set.size());//打印集合中对象的数目 为 2。

补充：
ArrayList() : 代表长度可以改变得数组。可以对元素进行随机的访问，向ArrayList()中插入与
与删除元素的速度慢。
LinkedList(): 在实现中采用链表数据结构。插入和删除速度快，访问速度慢。

18.静态内部类
（1）非静态内部类中bunengdingy静态成员变量和方法
（2）外部类和非静态内部类之间可以互相访问自己的私有成员
（3）静态内部类只能访问外部类的静态成员

19.handler机制的原理
andriod提供了Handler和Looper来满足线程间的通信。Handler先进先出原则。Looper类用来管理特定线程内对象之间的消息交换(MessageExchange)。
1)Looper:一个线程可以产生一个Looper对象，由它来管理此线程里的MessageQueue(消息队列)。
2)Handler:你可以构造Handler对象来与Looper沟通，以便push新消息到MessageQueue里;或者接收Looper从MessageQueue取出)所送来的消息。
3)MessageQueue(消息队列):用来存放线程放入的消息。
4)线程：UIthread通常就是mainthread，而Android启动程序时会替它建立一个MessageQueue。

20.assest文件夹里放文件，对于文件的大小有没有限制？
答案解析 assets目录更像一个附录类型的目录，Android不会为这个目录中的文件生成ID并保存在R类当中，因此它与Android中的一些类和方法兼容度更低。 同时，由于你需要一个字符串路径来获取这个目录下的文件描述符，访问的速度会更慢。但是把一些文件放在这个目录下会使一些操作更加方便，比方说拷贝一个数据库文件到系统内存中。要注意的是，你无法在Android XML文件中引用到assets目录下的文件，只能通过AssetManager来访问这些文件。数据库文件和游戏数据等放在这个目录下是比较合适的。另外，网上关于assets和raw的资料都千篇一律了，因此关于这两者中单个文件大小不能超过1M的错误描述也在传播，即如果读取超过1M的文件会报”Data exceeds UNCOMPRESS_DATA_MAX (1314625 vs 1048576)”的IOException，还引申出种种解决方案。个人认为不应该有这样的限制，为了验证这个说法写了个Demo，发现将近5M的压缩包在assets和raw中都能正常访问，因此在这里纠正一下，理论上只要打包不超过Android APK 50M大小的限制都是没有问题的。当然了，不排除是Android很早期的时候因为设备硬件原因aapt在编译的时候对这两个文件夹大小做出了限制，如果是这样，较新版的ADT应该不会出现这种情况。

21.进程销毁优先级以及各自含义。
重要性依次是：前台进程，可见进程，服务进程，后台进程和空进程；所以销毁的顺序是逆方向。
前台进程（foreground）： 目前正在屏幕上显示的进程和一些系统进程。举例来说，Dialer Storage，Google
Search等系统进程就是前台进程；再举例来说，当你运行一个程序，如浏览器，当浏览器界面在前台显示时，浏览器属于前台进程（foreground），但一旦你按home回到主界面，浏览器就变成了后台程序（background）。
我们最不希望终止的进程就是前台进程。 可见进程（visible）：
可见进程是一些不在前台，但用户依然可见的进程，举个例来说：widget、输入法等，都属于visible。这部分进程虽然不在前台，但与我们的使用也密切相关，我们也不希望它们被终止（你肯定不希望时钟、天气，新闻等widget被终止，那它们将无法同步，你也不希望输入法被终止，否则你每次输入时都需要重新启动输入法）
次要服务（secondary server）：
目前正在运行的一些服务（主要服务，如拨号等，是不可能被进程管理终止的，故这里只谈次要服务），举例来说：谷歌企业套件，Gmail内部存储，联系人内部存储等。这部分服务虽然属于次要服务，但很一些系统功能依然息息相关，我们时常需要用到它们，所以也太希望他们被终止
后台进程（hidden）：
虽然用了hidden这个词，但实际即是后台进程（background），就是我们通常意义上理解的启动后被切换到后台的进程，如浏览器，阅读器等。当程序显示在屏幕上时，他所运行的进程即为前台进程（foreground），一旦我们按home返回主界面（注意是按home，不是按back），程序就驻留在后台，成为后台进程（background）。后台进程的管理策略有多种：有较为积极的方式，一旦程序到达后台立即终止，这种方式会提高程序的运行速度，但无法加速程序的再次启动；也有较消极的方式，尽可能多的保留后台程序，虽然可能会影响到单个程序的运行速度，但在再次启动已启动的程序时，速度会有所提升。这里就需要用户根据自己的使用习惯找到一个平衡点
内容供应节点（content provider）：
没有程序实体，仅仅提供内容供别的程序去用的，比如日历供应节点，邮件供应节点等。在终止进程时，这类程序应该有较高的优先权 空进程（empty）：
没有任何东西在内运行的进程，有些程序，比如BTE，在程序退出后，依然会在进程中驻留一个空进程，这个进程里没有任何数据在运行，作用往往是提高该程序下次的启动速度或者记录程序的一些历史信息。
这部分进程无疑是应该最先终止的。 补充：
系统会对进程的重要性进行评估，并将重要性以“oom_adj”这个数值表示出来，赋予各个进程；（系统会根据“oom_adj”来判断需要结束哪些进程，一般来说，“oom_adj”的值越大，该进程被系统选中终止的可能就越高）
前台程序的“oom_adj”值为0，这意味着它不会被系统终止，一旦它不可访问后，会获得个更高的“oom_adj”，推测“oom_adj”的值是根据软件在LRU列表中的位置所决定的； Android不同于Linux，有一套自己独特的进程管理模块，这个模块有更强的可定制性，可根据“oom_adj”值的范围来决定进程管理策略，比如可以设定“当内存小于X时，结束“oom_adj”大于Y的进程”。这给了进程管理脚本的编写以更多的选择。

22.Adapter有什么作用？常见的Adapter有哪些？
Adapter是连接后端数据和前端显示的适配器接口。常见的Adapter有ArrayAdapter, BaseAdapter, CursorAdapter, HeaderViewListAdapter, ListAdapter, ResourceCursorAdapter, SimpleAdapter, SimpleCursorAdapter, SpinnerAdapter, WrapperListAdapter等

23.启动一个程序，可以主界面点击图标进入，也可以从一个程序中跳转过去，二者有什么区别？
是因为启动程序（主界面也是一个app），发现了在这个程序中存在一个设置为的activity, 所以这个launcher会把icon提出来，放在主界面上。当用户点击icon的时候，发出一个Intent： Intent intent = mActivity.getPackageManager().getLaunchIntentForPackage(packageName); mActivity.startActivity(intent); 跳过去可以跳到任意允许的页面，如一个程序可以下载，那么真正下载的页面可能不是首页（也有可能是首页），这时还是构造一个Intent，startActivity. 这个intent中的action可能有多种view,download都有可能。系统会根据第三方程序向系统注册的功能，为你的Intent选择可以打开的程序或者页面。所以唯一的一点 不同的是从icon的点击启动的intent的action是相对单一的，从程序中跳转或者启动可能样式更多一些。本质是相同的。

24.Android提供了5种方式存储数据
（1）使用SharedPreferences存储数据；它是Android提供的用来存储一些简单配置信息的一种机制，采用了XML格式将数据存储到设备中。只能在同一个包内使用，不能在不同的包之间使用。 （2）文件存储数据；文件存储方式是一种较常用的方法，在Android中读取/写入文件的方法，与Java中实现I/O的程序是完全一样的，提供了openFileInput()和openFileOutput()方法来读取设备上的文件。
（3）SQLite数据库存储数据；SQLite是Android所带的一个标准的数据库，它支持SQL语句，它是一个轻量级的嵌入式数据库。
（4）使用ContentProvider存储数据；主要用于应用程序之间进行数据交换，从而能够让其他的应用保存或读取此Content Provider的各种数据类型。
（5）网络存储数据；通过网络上提供给我们的存储空间来上传(存储)和下载(获取)我们存储在网络空间中的数据信息。

25.AsyncTask使用在哪些场景？它的缺陷是什么？如何解决？
答案解析 AsyncTask 运用的场景就是我们需要进行一些耗时的操作，耗时操作完成后更新主线程，或者在操作过程中对主线程的UI进行更新。 缺陷：AsyncTask中维护着一个长度为128的线程池，同时可以执行5个工作线程，还有一个缓冲队列，当线程池中已有128个线程，缓冲队列已满时，如果 此时向线程提交任务，将会抛出RejectedExecutionException。 解决：由一个控制线程来处理AsyncTask的调用判断线程池是否满了，如果满了则线程睡眠否则请求AsyncTask继续处理。