android的四大组件都是什么？简要说明作用及应用场景？

1、Activity

一个Activity通常展现为一个可视化的用户界面。比如，一个activity可能展现为一个用户能够选择的菜单项列表或者展现一些图片以及图 片的标题。一个消息服务应用程序可能包括一个显示联系人列表的activity,一个编写信息的activity，以及其他一些查看信息和改动应用程序设 置的activity。尽管这些activity一起工作，共同组成了一个应用程序，但每个activity都是相对独立的。每个activity都 是Activity(android.app.Activity)的子类。

一个应用程序可能仅仅包括一个activity，或者像上面提到的消息服务程序一样有多个activity。一个应用程序包括几个activity以 及各个activity完毕什么样的功能全然取决于应用程序以及它的设计。通常每一个应用程序都包括一个在应用程序启动后第一个展现给用户的 activity。在当前展现给用户的activity中启动一个新的activity，能够实现从一个activity转换到另外一个 activity。

每一个activity都会有一个用于绘制用户界面的窗体。通常这样一个窗体会填充整个屏幕，当然这个窗体也能够比屏幕小并漂浮在其它窗体之上。 activity还能够使用一些额外的窗体，比如一个要求用户响应的弹出式对话框，或者是当用户在屏幕上选择一个条目后向用户展现一些重要信息的窗体。

展示activity窗体的可视化内容区域是一些具有层次关系（非常像数据结构中的树）的视图，而视图则是由类View的子类表示的。每一个视图控制窗 口中的一个矩形区域。父视图包括一些子视图并管理子视图的布局。位于叶节点的视图直接控制并响应用户的动作。因此视图就是activity与用户交互的接 口。比如，一个显示图片的视图，当用户单击的时候它可能会启动一个动作。Android有很多开发者能够直接使用的视图，包括button，文本域，滚动栏，菜 单，复选框等。

通过调用Activity.setContentView()方法来设置展现activity的窗体的视图。内容视图则是视图层次结构中的根节点视图。

onRestart():

把activity从onStop状态唤醒时，会用onRestart方法，该方法优先于再次运行的onStart，运行完onRestart之后运行onStart。若在onRestart()方法中加入finish()语句，则还是会继续运行onStart及后面的状态方法直到onDestroy运行完

onStart()：

当activity对用户可见时会调用onStart，当activity在前台显示时，会运行onResume;当activity还没在前台显示就被隐藏(停止状态)了会运行onStop()，比如在onStart方法中用了finish()方法的话，onStart()之后就会直接运行onStop->onDestroy。

onResume():

当activity开始与用户交互时，会调用onResume，并且为了用户操作此时该activity位于activity栈的顶部。经过某些操作后该方法执行完后执行的是onPause()

onPause():

当一个activity运行到onResume方法后，不管是这个activity要销毁还是要暂停或停止，都会调用该方法。这个方法之后有可能是onResume也有可能是onStop，若是在这个activity-A中打开一个不完全覆盖这个activity-A的新activity-B，那么activity-A就会是onPause状态，当activity-B退出时，activity-A就直接运行onResume(前提是onPause的方法执行完了，否则会等onPause方法执行完后才运行onResume方法，所以不建议在这个方法中执行CPU密集的操作)。若是需要退出activity-A，那么下一个就会执行onStop。onPause()用于提交未保存发生变化了的持久化数据，及停止动画及其他其他比较消耗CPU的事件(比如广播接收器，传感器(比如GPS)，或者消耗电量的资源)，这是为了更好的运行新的activity

onStop():

当这个activity完全看不见的时候，会调用onStop方法，因为另一个activity会调用onResume并且覆盖这个activity。以下三种情况都会使这个activity调用onStop()方法，第一种是一个新的activity被执行，第二种是一个已经存在的activity被切换到最前端，第三种是这个activity要被销毁。如果通过用户召回这个activity，那么会调用onRestart方法;若这个activity要被销毁，则调用onDestroy方法

onDestroy():

当activity销毁前会调用该方法，比如发生如下情况：activity调用了finish()方法来结束这个activity，或者因为系统为了节省空间而临时销毁这个activity，这两个情况可以通过isFinishing()方法判断

BACK键：

当我们按BACK键时，我们这个应用程序将结束，这时候我们将先后调用onPause()->onStop()->onDestory()三个方法

HOME键:

当我们打开应用程序时，比如浏览器，我正在浏览NBA新闻，看到一半时，我突然想听歌，这时候我们会选择按HOME键，然后去打开音乐应用程序，而 当我们按HOME的时候，Activity先后执行了onPause()->onStop()这两个方法，这时候应用程序并没有销毁。

而当我们再次启动ActivityDemo应用程序时，则先后分别执行了onRestart()->onStart()->onResume()三个方法。

2、Service

Service是Android的四大组件之中的一个，即Android系统的服务（不是一个线程，是主程序的一部分），与Activity不同，它是不能与用户交互的，不能自己启动的，须要调用Context.startService()来启动，执行后台，假设我们退出应用时，Service进程并没有结束，它仍然在后台行。
service没实用户界面，但它会在后台一直执行。比如，service可能在用户处理其他事情的时候播放背景音乐，或者从网络上获取数据，或者执行一些运算，并把运算结构提供给activity展示给用户。每一个service都扩展自类Serivce。

多媒体播放器播放音乐是应用service的一个很好的样例。多媒体播放器程序可能含有一个或多个activity，用户通过这些 activity选择并播放音乐。然而，音乐回放并不须要一个activity来处理，由于用户可能会希望音乐一直播放下去，即使退出了播放器去执行其他 程序。为了让音乐一直播放，多媒体播放器activity可能会启动一个service在后台播放音乐。Android系统会使音乐回放service一 直执行，即使在启动这个service的activity退出之后。

应用程序能够连接到一个正在执行中的service。当连接到一个service后，能够使用这个service向外暴露的接口与这个service进行通信。对于上面提到的播放音乐的service，这个接口可能同意用户暂停，停止或又一次播放音乐。

与activity以及其他组件一样，service相同执行在应用程序进程的主线程中。所以它们不能堵塞其他组件或用户界面，通常须要为这些service派生一个线程执行耗时的任务。
使用context.startService() 启动Service

其生命周期为context.startService() ->onCreate()- >onStart()->Service running–>(如果调用context.stopService() )->onDestroy() ->Service shut down

如果Service还没有运行，则android先调用onCreate()然后调用onStart()；
如果Service已经运行，则只调用onStart()，所以一个Service的onStart方法可能会重复调用多次。

调用stopService的时候直接onDestroy，
如果是调用者自己直接退出而没有调用stopService的话，Service会一直在后台运行。
该Service的调用者再启动起来后可以通过stopService关闭Service。

所以调用startService的生命周期为：onCreate --> onStart(可多次调用) --> onDestroy

对于bindService()启动Service会经历：
context.bindService()->onCreate()->onBind()->Service running–>onUnbind() -> onDestroy() ->Service stop

onBind将返回给客户端一个IBind接口实例，IBind允许客户端回调服务的方法，比如得到Service运行的状态或其他操作。
这个时候把调用者（Context，例如Activity）会和Service绑定在一起，Context退出了，
Srevice就会调用onUnbind->onDestroy相应退出。

所以调用bindService的生命周期为：onCreate --> onBind(只一次，不可多次绑定) --> onUnbind --> onDestory。
一但销毁activity它就结束，如果按home把它放到后台，那他就不退出。

PS：
在Service每一次的开启关闭过程中，只有onStart可被多次调用(通过多次startService调用)，
其他onCreate，onBind，onUnbind，onDestory在一个生命周期中只能被调用一次。

3、Broadcase receiver

1、BroadcastReceiver 用于异步接收广播Intent。主要有两大类，用于接收广播的：

正常广播 Normal broadcasts（用 Context.sendBroadcast()发送）是全然异步的。它们都执行在一个没有定义的顺序，一般是在同一时间。这样会更有效，但意味着receiver不能包括所要使用的结果或中止的API。

有序广播 Ordered broadcasts（用 Context.sendOrderedBroadcast()发送）每次被发送到一个receiver。所谓有序，就是每一个receiver执行后能够传播到下一个receiver，也能够全然中止传播–不传播给其它receiver。 而receiver执行的顺序能够通过matched intent-filter 里面的android:priority来控制，当priority优先级同样的时候，Receiver以随意的顺序执行。

2、广播接收器是一个专注于接收广播通知信息，并做出相应处理的组件。非常多广播是源自于系统代码的──比方，通知时区改变、电池电量低、拍摄了一张照片或者用户改变了语言选项。应用程序也能够进行广播──比方说，通知其他应用程序一些数据下载完毕并处于可用状态。
3、应用程序能够拥有随意数量的广播接收器以对全部它感兴趣的通知信息予以响应。全部的接收器均继承自BroadcastReceiver基类。
4、广播接收器没实用户界面。然而，它们能够启动一个activity来响应它们收到的信息，或者用NotificationManager来通知用户。通知能够用非常多种方式来吸引用户的注意力──闪动背灯、震动、播放声音等等。一般来说是在状态栏上放一个持久的图标，用户能够打开它并获取消息。

广播分为普通广播、异步广播、有序广播。

广播接收者（ BroadcastReceiver ）用于接收广播 Intent ，广播 Intent 的发送是通过调用 Context.sendBroadcast() 、 Context.sendOrderedBroadcast() 来实现的。通常一个广播 Intent 可以被订阅了此 Intent 的多个广播接收者所接收。

4、Content provider

ContentProvider（内容提供者）是Android中的四大组件之中的一个。主要用于对外共享数据，也就是通过ContentProvider把应用中的数据共享给其它应用訪问，其它应用能够通过ContentProvider对指定应用中的数据进行操作。ContentProvider分为系统的和自己定义的，系统的也就是比如联系人，图片等数据。
下面这段是Google Doc中对ContentProvider的大致概述。
内容提供者将一些特定的应用程序数据供给其他应用程序使用。数据能够存储于文件系统、SQLite数据库或其他方式。内容提供者继承于ContentProvider 基类，为其他应用程序取用和存储它管理的数据实现了一套标准方法。然而，应用程序并不直接调用这些方法，而是使用一个 ContentResolver 对象，调用它的方法作为替代。ContentResolver能够与随意内容提供者进行会话，与其合作来对全部相关交互通讯进行管理。

ContentResolver

当外部应用需要对ContentProvider中的数据进行添加、删除、修改和查询操作时，可以使用ContentResolver类来完成，要获取ContentResolver对象，可以使用Context提供的getContentResolver()方法。

5、intent

当接收到ContentResolver发出的请求后，内容提供者被激活。而其他三种组件

activity、服务和广播接收器被一种叫做intent的异步消息所激活。intent是一个保存着消息内容的Intent对 象。对于activity和服务来说，它指明了请求的操作名称以及作为操作对象的数据的URI和其他一些信息。比方说，它能够承载对一个activity 的请求，让它为用户显示一张图片，或者让用户编辑一些文本。而对于广播接收器而言，Intent对象指明了声明的行为。比方，它能够对全部感兴趣的对象声 明照相button被按下。
对于每种组件来说，激活的方法是不同的：

1、通过传递一个Intent对象至 Context.startActivity()或Activity.startActivityForResult()以加载（或指定新工作给）一个activity。对应的activity能够通过调用 getIntent() 方法来查看激活它的intent。Android通过调用activity的onNewIntent()方法来传递给它继发的intent。

一个activity常常启动了下一个。假设它期望它所启动的那个activity返回一个结果，它会以调用startActivityForResult()来代替startActivity()。比方说，假设它启动了另外一个activity以使用户挑选一张照片，它或许想知道哪张照片被选中了。结果将会被封装在一个Intent对象中，并传递给发出调用的activity的onActivityResult() 方法。

2、通过传递一个Intent对象至Context.startService()将启动一个服务（或给予正在执行的服务以一个新的指令）。Android调用服务的onStart()方法并将Intent对象传递给它。

与此类似，一个Intent能够被调用组件传递给 Context.bindService()以获取一个正在执行的目标服务的连接。这个服务会经由onBind() 方法的调用获取这个Intent对象（假设服务尚未启动，bindService()会先启动它）。比方说，一个activity能够连接至前述的音乐回放服务，并提供给用户一个可操作的（用户界面）以对回放进行控制。这个activity能够调用 bindService() 来建立连接，然后调用服务中定义的对象来影响回放。

3、应用程序能够凭借将Intent对象传递给 Context.sendBroadcast() ，Context.sendOrderedBroadcast()， 以及Context.sendStickyBroadcast()和其他类似方法来产生一个广播。Android会调用全部对此广播有兴趣的广播接收器的 onReceive()方法将intent传递给它们。

Android 中的动画有哪几类,它们的特点和区别是什么？

Android包含三种动画：

ViewAnimation、 Drawable Animation、Property Animation。

ViewAnimation （Tween Animation补间动画）：

基于View的渐变动画，只改变了View的绘制效果，实际属性值未变。在代码中定义动画，可以参考AnimationSet类和Animation的子类；而如果使用XML，可以在res/anim/文件夹中定义XML文件。

DrawableAnimation（Frame Animation帧动画）：

加载一系列Drawable资源来创建动画，这种传统动画某种程度上就是创建不同图片序列，顺序播放，就像电影胶片。在代码中定义动画帧，使用AnimationDrawable类；XML文件能更简单的组成动画帧，在res/drawable文件夹，使用采用来定义不同的帧。只能设置的属性是动画间隔时间。

PropertyAnimation（属性动画）：

动画的对象除了传统的View对象，还可以是Object对象，动画之后，Object对象的属性值被实实在在的改变了。Property animation能够通过改变View对象的实际属性来实现View动画。任何时候View属性的改变，View能自动调用invalidate()来刷新。

handler机制的原理

在开始讨论android的消息处理机制前，先来谈谈一些基本相关的术语。

通信的同步（Synchronous）：指向客户端发送请求后，必须要在服务端有回应后客户端才继续发送其它的请求，所以这时所有请求将会在服务端得到同步，直到服务端返回请求。

通信的异步（Asynchronous）：指客户端在发送请求后，不必等待服务端的回应就可以发送下一个请求。

所谓同步调用，就是在一个函数或方法调用时，没有得到结果之前，该调用就不返回，直到返回结果。异步调用和同步是相对的，在一个异步调用发起后，被调用者立即返回给调用者，但是调用者不能立刻得到结果，被调用都在实际处理这个调用的请求完成后，通过状态、通知或回调等方式来通知调用者请求处理的结果。

android的消息处理有三个核心类：Looper,Handler和Message。其实还有一Message Queue（消息队列），但是MQ被封装到Looper里面了，我们不会直接与MQ打交道，所以它不算是个核心类。

1. 消息类：Message类

android.os.Message的主要功能是进行消息的封装，同时可以指定消息的操作形式，Message类定义的变量和常用方法如下：

（1）public int what：变量，用于定义此Message属于何种操作

（2）public Object obj：变量，用于定义此Message传递的信息数据，通过它传递信息

（3）public int arg1：变量，传递一些整型数据时使用

（4）public int arg2：变量，传递一些整型数据时使用

（5）public Handler getTarget()：普通方法，取得操作此消息的Handler对象。

在整个消息处理机制中，message又叫task，封装了任务携带的信息和处理该任务的handler。message的用法比较简单，但是有这么几点需要注意：

（1）尽管Message有public的默认构造方法，但是你应该通过Message.obtain()来从消息池中获得空消息对象，以节省资源。

（2）如果你的message只需要携带简单的int信息，请优先使用Message.arg1和Message.arg2来传递信息，这比用Bundle更省内存

（3）擅用message.what来标识信息，以便用不同方式处理message。

（4）使用setData()存放Bundle对象。？？？

2. 消息通道：Looper

在使用Handler处理Message时，需要Looper（通道）来完成。在一个Activity中，系统会自动帮用户启动Looper对象，而在一个用户自定义的类中，则需要用户手工调用Looper类中的方法，然后才可以正常启动Looper对象。Looper的字面意思是“循环者”，它被设计用来使一个普通线程变成Looper线程。所谓Looper线程就是循环工作的线程。在程序开发中（尤其是GUI开发中），我们经常会需要一个线程不断循环，一旦有新任务则执行，执行完继续等待下一个任务，这就是Looper线程。使用Looper类创建Looper线程很简单：

public class LooperThread extends Thread {@Overridepublic void run() {// 将当前线程初始化为Looper线程Looper.prepare();// ...其他处理，如实例化handler// 开始循环处理消息队列Looper.loop();}
}

通过上面两行核心代码，你的线程就升级为Looper线程了！那么这两行代码都做了些什么呢？

1)Looper.prepare()：创建Loop而对象。

通过上图可以看到，现在你的线程中有一个Looper对象，它的内部维护了一个消息队列MQ。注意，一个Thread只能有一个Looper对象，为什么呢？来看一下源码

 public class Looper {// 每个线程中的Looper对象其实是一个ThreadLocal，即线程本地存储(TLS)对象private static final ThreadLocal sThreadLocal = new ThreadLocal();// Looper内的消息队列final MessageQueue mQueue;// 当前线程Thread mThread;//其他属性// 每个Looper对象中有它的消息队列，和它所属的线程private Looper() {mQueue = new MessageQueue();mRun = true;mThread = Thread.currentThread();}// 我们调用该方法会在调用线程的TLS中创建Looper对象public static final void prepare() {if (sThreadLocal.get() != null) {// 试图在有Looper的线程中再次创建Looper将抛出异常throw new RuntimeException("Only one Looper may be created per thread");}sThreadLocal.set(new Looper());}// 其他方法
}

prepare()背后的工作方式一目了然，其核心就是将looper对象定义为ThreadLocal。

2）Looper.loop()：循环获取MQ中的消息，并发送给相应Handler对象。

调用loop方法后，Looper线程就开始真正工作了，它不断从自己的MQ中取出队头的消息(也叫任务)执行。其源码分析如下：

 public static final void loop() {Looper me = myLooper();  //得到当前线程LooperMessageQueue queue = me.mQueue;  //得到当前looper的MQBinder.clearCallingIdentity();final long ident = Binder.clearCallingIdentity();// 开始循环while (true) {Message msg = queue.next(); // 取出messageif (msg != null) {if (msg.target == null) {// message没有target为结束信号，退出循环return;}// 日志if (me.mLogging!= null) me.mLogging.println(">>>>> Dispatching to " + msg.target + " "+ msg.callback + ": " + msg.what);// 非常重要！将真正的处理工作交给message的target，即后面要讲的handlermsg.target.dispatchMessage(msg);// 日志if (me.mLogging!= null) me.mLogging.println("<<<<< Finished to    " + msg.target + " "+ msg.callback);final long newIdent = Binder.clearCallingIdentity();if (ident != newIdent) {Log.wtf("Looper", "Thread identity changed from 0x"+ Long.toHexString(ident) + " to 0x"+ Long.toHexString(newIdent) + " while dispatching to "+ msg.target.getClass().getName() + " "+ msg.callback + " what=" + msg.what);}// 回收message资源msg.recycle();}}}

除了prepare()和loop()方法，Looper类还提供了一些有用的方法，比如Looper.myLooper()得到当前线程looper对象：

    public static final Looper myLooper() {// 在任意线程调用Looper.myLooper()返回的都是那个线程的looperreturn (Looper)sThreadLocal.get();}

getThread()得到looper对象所属线程：

   public Thread getThread() {return mThread;}

quit()方法结束looper循环：

 public void quit() {// 创建一个空的message，它的target为NULL，表示结束循环消息Message msg = Message.obtain();// 发出消息mQueue.enqueueMessage(msg, 0);}

综上，Looper有以下几个要点：

1）每个线程有且只能有一个Looper对象，它是一个ThreadLocal

2）Looper内部有一个消息队列，loop()方法调用后线程开始不断从队列中取出消息执行

3）Looper使一个线程变成Looper线程。

那么，我们如何操作Message Queue上的消息呢？这就是Handler的用处了

1. 消息操作类：Handler类

Message对象封装了所有的消息，而这些消息的操作需要android.os.Handler类完成。什么是handler？handler起到了处理MQ上的消息的作用（只处理由自己发出的消息），即通知MQ它要执行一个任务(sendMessage)，并在loop到自己的时候执行该任务(handleMessage)，整个过程是异步的。handler创建时会关联一个looper，默认的构造方法将关联当前线程的looper，不过这也是可以set的。默认的构造方法：

public class handler {final MessageQueue mQueue;  // 关联的MQfinal Looper mLooper;  // 关联的looperfinal Callback mCallback; // 其他属性public Handler() {if (FIND_POTENTIAL_LEAKS) {final Class<? extends Handler> klass = getClass();if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&(klass.getModifiers() & Modifier.STATIC) == 0) {Log.w(TAG, "The following Handler class should be static or leaks might occur: " + klass.getCanonicalName());}}// 默认将关联当前线程的loopermLooper = Looper.myLooper();// looper不能为空，即该默认的构造方法只能在looper线程中使用if (mLooper == null) {throw new RuntimeException("Can't create handler inside thread that has not called Looper.prepare()");}// 重要！！！直接把关联looper的MQ作为自己的MQ，因此它的消息将发送到关联looper的MQ上mQueue = mLooper.mQueue;mCallback = null;}// 其他方法
}

下面我们就可以为之前的LooperThread类加入Handler：

public class LooperThread extends Thread {private Handler handler1;private Handler handler2;@Overridepublic void run() {// 将当前线程初始化为Looper线程Looper.prepare();// 实例化两个handlerhandler1 = new Handler();handler2 = new Handler();// 开始循环处理消息队列Looper.loop();}
}

以下具体看这篇文章：https://www.cnblogs.com/cheneasternsun/p/5467115.html

你后台的Activity被系统回收怎么办？如果后台的Activity由于某种原因被系统回收了，如何在被系统回收之前保存当前状态?

除了在栈顶的Activity，其他的Activity都有可能在内存不足的时候被系统回收，一个Activity越处于栈底，被回收的可能性就越大。

protected void onSaveInstanceState(Bundle outState) {super.onSaveInstanceState(outState);outState.putLong("id", 1234567890);}public void onCreate(Bundle savedInstanceState) {//判断 savedInstanceState是不是空.//如果不为空就取出来super.onCreate(savedInstanceState);}

如果我们没有覆写onSaveInstanceState()方法，此方法的默认实现会自动保存Activity中的某些状态数据，比如Activity中各种UI空间的状态。Android应用框架中定义的几乎所有的UI控件都恰当的实现了onSaveInstanceState()方法，因此当Activity被摧毁和重建时，这些UI控件会自动保存和恢复状态数据。比如EditText控件会自动保存和恢复输入的数据，而CheckBox控件会自动保存和恢复选中状态。开发者只需要为这些控件指定一个唯一的ID（通过设置android:id属性即可），剩余的事情就可以自动完成了。如果没有为控件指定ID，则这个控件就不会进行自动的数据保存和恢复操作。

由上所述，如果我们需要覆写onSaveInstanceState()方法，一般会在第一行代码中调用该方法的默认实现：super.onSaveInstanceState(outState)。

 详见：Android开发之InstanceState详解。

ListView你是怎么优化的？

ListView用法大全、性能优化与功能拓展

App冷启动、热启动介绍和App启动优化的方式，解决启动白屏的问题

App冷启动、热启动介绍和App启动优化的方式，解决启动白屏的问题

请描述一下Activity的生命周期

activity生命周期（这篇足够了）

注册广播有几种方式，这些方式有何优缺点？请谈谈Android引入广播机制的用意

Android广播机制（两种注册方法）
在android下，要想接受广播信息，那么这个广播接收器就得我们自己来实现了，我们可以继承BroadcastReceiver，就可以有一个广播接受器了。有个接受器还不够，我们还得重写BroadcastReceiver里面的onReceiver方法，当来广播的时候我们要干什么，这就要我们自己来实现，不过我们可以搞一个信息防火墙。具体的代码：

public class SmsBroadCastReceiverextendsBroadcastReceiver
{  @Override  public void onReceive(Context context, Intentintent)   {   Bundle bundle = intent.getExtras();  Object[] object =(Object[])bundle.get("pdus");   SmsMessage sms[]=newSmsMessage[object.length];   for(inti=0;i<object.length;i++)  {   sms[0]=SmsMessage.createFromPdu((byte[])object);  Toast.makeText(context,"来自"+sms.getDisplayOriginatingAddress()+"的消息是："+sms.getDisplayMessageBody(),Toast.LENGTH_SHORT).show();   }   //终止广播，在这里我们可以稍微处理，根据用户输入的号码可以实现短信防火墙。   abortBroadcast();   }   } 

当实现了广播接收器，还要设置广播接收器接收广播信息的类型，这里是信息：android.provider.Telephony.SMS_RECEIVED

我们就可以把广播接收器注册到系统里面，可以让系统知道我们有个广播接收器。这里有两种，一种是代码动态注册：

//生成广播处理
smsBroadCastReceiver = newSmsBroadCastReceiver();
//实例化过滤器并设置要过滤的广播

IntentFilter intentFilter = newIntentFilter(“android.provider.Telephony.SMS_RECEIVED”);

//注册广播
BroadCastReceiverActivity.this.registerReceiver(smsBroadCastReceiver,intentFilter);
一种是在AndroidManifest.xml中配置广播

<?xmlversion="1.0"encoding="utf-8"?>
<manifestxmlns:android="http://schemas.android.com/apk/res/android"  package="spl.broadCastReceiver"  android:versionCode="1" android:versionName="1.0"> <applicationandroid:icon="@drawable/icon"android:label="@string/app_name"><activityandroid:name=".BroadCastReceiverActivity"  android:label="@string/app_name">  <intent-filter>  <actionandroid:name="android.intent.action.MAIN"/>  <categoryandroid:name="android.intent.category.LAUNCHER"/>  </intent-filter>  </activity>  <!--广播注册-->  <receiverandroid:name=".SmsBroadCastReceiver">  <intent-filterandroid:priority="20">  <actionandroid:name="android.provider.Telephony.SMS_RECEIVED"/>  </intent-filter>  </receiver>  </application>  <uses-sdk android:minSdkVersion="7"/>  <!-- 权限申请 -->  <uses-permissionandroid:name="android.permission.RECEIVE_SMS"></uses-permission>  </manifest>

两种注册类型的区别是：

1)第一种不是常驻型广播，也就是说广播跟随程序的生命周期。2)第二种是常驻型，也就是说当应用程序关闭后，如果有信息广播来，程序也会被系统调用自动运行。

什么是 ANR 如何避免它？

在 Android 上，如果你的应用程序有一段时间响应不够灵敏，系统会向用户显示一个对话框，这个对话框称作应
用程序无响应（ANR：Application Not Responding）对话框。用户可以选择让程序继续运行，但是，他们在使用你
的应用程序时，并不希望每次都要处理这个对话框。因此，在程序里对响应性能的设计很重要，这样，系统不会显示
ANR 给用户。
不同的组件发生 ANR 的时间不一样，主线程（Activity、Service）是 5 秒，BroadCastReceiver 是 10 秒。
解决方案：
将所有耗时操作，比如访问网络，Socket 通信，查询大量 SQL 语句，复杂逻辑计算等都放在子线程中去，然后
通过 handler.sendMessage、runonUITread、AsyncTask 等方式更新 UI。无论如何都要确保用户界面操作的流畅度。如果耗时操作需要让用户等待，那么可以在界面上显示进度条。

IntentService及其优点

IntentService是Service的子类，比普通的Service增加了额外的功能。先看Service本身存在两个问题:Service不会专门启动一条单独的进程，Service与他所在应用位于同一个进程中。
Service也不是专门一条新进程，因此不应该在Service中直接处理耗时的任务。
特点:
IntentService会创建独立的worker线程来处理所有的Intent请求；
会创建独立的worker线程来处理onHandleIntent()方法实现的代码，无需处理多线程的问题；
所有请求处理完成后，IntentService会自动停止，无需调用stopSelf()方法停止Service；
为Service的onBind()提供默认实现，返回null；
为Service的onStartCommand提供默认实现，将请求Intent添加到队列中；

横竖屏切换时候Activity的生命周期的总结

曾经遇到过一个面试题，让你写出横屏切换竖屏Activity的生命周期。现在给大家分析一下他切换时具体的生命周期是怎么样的：

1、新建一个Activity，并把各个生命周期打印出来

2、运行Activity，得到如下信息

onCreate–>
onStart–>
onResume–>

3、按crtl+f12切换成横屏时

onSaveInstanceState–>
onPause–>
onStop–>
onDestroy–>
onCreate–>
onStart–>
onRestoreInstanceState–>
onResume–>

4、再按crtl+f12切换成竖屏时，发现打印了两次相同的log

onSaveInstanceState–>
onPause–>
onStop–>
onDestroy–>
onCreate–>
onStart–>
onRestoreInstanceState–>
onResume–>
onSaveInstanceState–>
onPause–>
onStop–>
onDestroy–>
onCreate–>
onStart–>
onRestoreInstanceState–>
onResume–>

5、修改AndroidManifest.xml，把该Activity添加 android:configChanges=“orientation”，执行步骤3

onSaveInstanceState–>
onPause–>
onStop–>
onDestroy–>
onCreate–>
onStart–>
onRestoreInstanceState–>
onResume–>

6、再执行步骤4，发现不会再打印相同信息，但多打印了一行onConfigChanged

onSaveInstanceState–>
onPause–>
onStop–>
onDestroy–>
onCreate–>
onStart–>
onRestoreInstanceState–>
onResume–>
onConfigurationChanged–>

7、把步骤5的android:configChanges=“orientation” 改成 android:configChanges=“orientation|keyboardHidden”，执行步骤3，就只打印onConfigChanged

onConfigurationChanged–>

8、执行步骤4

onConfigurationChanged–>
onConfigurationChanged–>

总结：

1、不设置Activity的android:configChanges时，切屏会重新调用各个生命周期，切横屏时会执行一次，切竖屏时会执行两次

2、设置Activity的android:configChanges="orientation"时，切屏还是会重新调用各个生命周期，切横、竖屏时只会执行一次

3、设置Activity的android:configChanges="orientation|keyboardHidden"时，切屏不会重新调用各个生命周期，只会执行onConfigurationChanged方法

总结一下整个Activity的生命周期

补充一点，当前Activity产生事件弹出Toast和AlertDialog的时候Activity的生命周期不会有改变

Activity运行时按下HOME键(跟被完全覆盖是一样的)：onSaveInstanceState --> onPause --> onStop onRestart -->onStart—>onResume

Activity未被完全覆盖只是失去焦点：onPause—>onResume

谈谈android数据存储的方式

下面详细讲解这五种方式的特点

第一种： 使用SharedPreferences存储数据

适用范围：保存少量的数据，且这些数据的格式非常简单：字符串型、基本类型的值。比如应用程序的各种配置信息（如是否打开音效、是否使用震动效果、小游戏的玩家积分等），解锁口 令密码等

核心原理：保存基于XML文件存储的key-value键值对数据，通常用来存储一些简单的配置信息。通过DDMS的File Explorer面板，展开文件浏览树,很明显SharedPreferences数据总是存储在/data/data//shared_prefs目录下。SharedPreferences对象本身只能获取数据而不支持存储和修改,存储修改是通过SharedPreferences.edit()获取的内部接口Editor对象实现。 SharedPreferences本身是一 个接口，程序无法直接创建SharedPreferences实例，只能通过Context提供的getSharedPreferences(String name, int mode)方法来获取SharedPreferences实例，该方法中name表示要操作的xml文件名，第二个参数具体如下：

Context.MODE_PRIVATE: 指定该SharedPreferences数据只能被本应用程序读、写。

Context.MODE_WORLD_READABLE: 指定该SharedPreferences数据能被其他应用程序读，但不能写。

Context.MODE_WORLD_WRITEABLE: 指定该SharedPreferences数据能被其他应用程序读，写

Editor有如下主要重要方法：

SharedPreferences.Editor clear():清空SharedPreferences里所有数据

SharedPreferences.Editor putXxx(String key , xxx value): 向SharedPreferences存入指定key对应的数据，其中xxx 可以是boolean,float,int等各种基本类型据

SharedPreferences.Editor remove(): 删除SharedPreferences中指定key对应的数据项

boolean commit(): 当Editor编辑完成后，使用该方法提交修改

实际案例：运行界面如下

class ViewOcl implements View.OnClickListener{@Overridepublic void onClick(View v) {switch(v.getId()){case R.id.btnSet://步骤1：获取输入值String code = txtCode.getText().toString().trim();//步骤2-1：创建一个SharedPreferences.Editor接口对象，lock表示要写入的XML文件名，MODE_WORLD_WRITEABLE写操作SharedPreferences.Editor editor = getSharedPreferences("lock", MODE_WORLD_WRITEABLE).edit();//步骤2-2：将获取过来的值放入文件editor.putString("code", code);//步骤3：提交editor.commit();Toast.makeText(getApplicationContext(), "口令设置成功", Toast.LENGTH_LONG).show();break;case R.id.btnGet://步骤1：创建一个SharedPreferences接口对象SharedPreferences read = getSharedPreferences("lock", MODE_WORLD_READABLE);//步骤2：获取文件中的值String value = read.getString("code", "");Toast.makeText(getApplicationContext(), "口令为："+value, Toast.LENGTH_LONG).show();break;}}}

读写其他应用的SharedPreferences: 步骤如下

1、在创建SharedPreferences时，指定MODE_WORLD_READABLE模式，表明该SharedPreferences数据可以被其他程序读取

2、创建其他应用程序对应的Context:

Context pvCount = createPackageContext(“com.tony.app”, Context.CONTEXT_IGNORE_SECURITY);这里的com.tony.app就是其他程序的包名

3、使用其他程序的Context获取对应的SharedPreferences

SharedPreferences read = pvCount.getSharedPreferences(“lock”, Context.MODE_WORLD_READABLE);

4、如果是写入数据，使用Editor接口即可，所有其他操作均和前面一致。

SharedPreferences对象与SQLite数据库相比，免去了创建数据库，创建表，写SQL语句等诸多操作，相对而言更加方便，简洁。 但是SharedPreferences也有其自身缺陷，比如其职能存储boolean，int，float，long和String五种简单的数据类 型，比如其无法进行条件查询等。所以不论SharedPreferences的数据存储操作是如何简单，它也只能是存储方式的一种补充，而无法完全替代如 SQLite数据库这样的其他数据存储方式。

第二种： 文件存储数据

核心原理: Context提供了两个方法来打开数据文件里的文件IO流 FileInputStream openFileInput(String name); FileOutputStream(String name , int mode),这两个方法第一个参数 用于指定文件名，第二个参数指定打开文件的模式。具体有以下值可选：

MODE_PRIVATE：为默认操作模式，代表该文件是私有数据，只能被应用本身访问，在该模式下，写入的内容会覆盖原文件的内容，如果想把新写入的内容追加到原文件中。可 以使用Context.MODE_APPEND

MODE_APPEND：模式会检查文件是否存在，存在就往文件追加内容，否则就创建新文件。

MODE_WORLD_READABLE：表示当前文件可以被其他应用读取；

MODE_WORLD_WRITEABLE：表示当前文件可以被其他应用写入。

除此之外，Context还提供了如下几个重要的方法：

getDir(String name , int mode):在应用程序的数据文件夹下获取或者创建name对应的子目录
File getFilesDir():获取该应用程序的数据文件夹得绝对路径

String[] fileList():返回该应用数据文件夹的全部文件

实际案例：界面沿用上图

核心代码如下：

public String read() {try {FileInputStream inStream = this.openFileInput("message.txt");byte[] buffer = new byte[1024];int hasRead = 0;StringBuilder sb = new StringBuilder();while ((hasRead = inStream.read(buffer)) != -1) {sb.append(new String(buffer, 0, hasRead));}inStream.close();return sb.toString();} catch (Exception e) {e.printStackTrace();} return null;}public void write(String msg){// 步骤1：获取输入值if(msg == null) return;try {// 步骤2:创建一个FileOutputStream对象,MODE_APPEND追加模式FileOutputStream fos = openFileOutput("message.txt",MODE_APPEND);// 步骤3：将获取过来的值放入文件fos.write(msg.getBytes());// 步骤4：关闭数据流fos.close();} catch (Exception e) {e.printStackTrace();}}

openFileOutput()方法的第一参数用于指定文件名称，不能包含路径分隔符“/” ，如果文件不存在，Android 会自动创建它。创建的文件保存在/data/data//files目录，如： /data/data/cn.tony.app/files/message.txt，

下面讲解某些特殊文件读写需要注意的地方:

读写sdcard上的文件

其中读写步骤按如下进行:

1、调用Environment的getExternalStorageState()方法判断手机上是否插了sd卡,且应用程序具有读写SD卡的权限，如下代码将返回true

Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)

2、调用Environment.getExternalStorageDirectory()方法来获取外部存储器，也就是SD卡的目录,或者使用"/mnt/sdcard/"目录

3、使用IO流操作SD卡上的文件

注意点：手机应该已插入SD卡，对于模拟器而言，可通过mksdcard命令来创建虚拟存储卡

必须在AndroidManifest.xml上配置读写SD卡的权限

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

// 文件写操作函数private void write(String content) {if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) { // 如果sdcard存在File file = new File(Environment.getExternalStorageDirectory().toString()+ File.separator+ DIR+ File.separator+ FILENAME); // 定义File类对象if (!file.getParentFile().exists()) { // 父文件夹不存在file.getParentFile().mkdirs(); // 创建文件夹}PrintStream out = null; // 打印流对象用于输出try {out = new PrintStream(new FileOutputStream(file, true)); // 追加文件out.println(content);} catch (Exception e) {e.printStackTrace();} finally {if (out != null) {out.close(); // 关闭打印流}}} else { // SDCard不存在，使用Toast提示用户Toast.makeText(this, "保存失败，SD卡不存在！", Toast.LENGTH_LONG).show();}}// 文件读操作函数private String read() {if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) { // 如果sdcard存在File file = new File(Environment.getExternalStorageDirectory().toString()+ File.separator+ DIR+ File.separator+ FILENAME); // 定义File类对象if (!file.getParentFile().exists()) { // 父文件夹不存在file.getParentFile().mkdirs(); // 创建文件夹}Scanner scan = null; // 扫描输入StringBuilder sb = new StringBuilder();try {scan = new Scanner(new FileInputStream(file)); // 实例化Scannerwhile (scan.hasNext()) { // 循环读取sb.append(scan.next() + "\n"); // 设置文本}return sb.toString();} catch (Exception e) {e.printStackTrace();} finally {if (scan != null) {scan.close(); // 关闭打印流}}} else { // SDCard不存在，使用Toast提示用户Toast.makeText(this, "读取失败，SD卡不存在！", Toast.LENGTH_LONG).show();}return null;}

第三种：SQLite存储数据

SQLite是轻量级嵌入式数据库引擎，它支持 SQL 语言，并且只利用很少的内存就有很好的性能。现在的主流移动设备像Android、iPhone等都使用SQLite作为复杂数据的存储引擎，在我们为移 动设备开发应用程序时，也许就要使用到SQLite来存储我们大量的数据，所以我们就需要掌握移动设备上的SQLite开发技巧

SQLiteDatabase类为我们提供了很多种方法，上面的代码中基本上囊括了大部分的数据库操作；对于添加、更新和删除来说，我们都可以使用

1 db.executeSQL(String sql); 2 db.executeSQL(String sql, Object[]
bindArgs);//sql语句中使用占位符，然后第二个参数

是实际的参数集
除了统一的形式之外，他们还有各自的操作方法：

1 db.insert(String table, String nullColumnHack, ContentValues
values); 2 db.update(String table, Contentvalues values, String
whereClause, String whereArgs); 3 db.delete(String table, String
whereClause, String whereArgs);

以上三个方法的第一个参数都是表示要操作的表名；insert中的第二个参数表示如果插入的数据每一列都为空的话，需要指定此行中某一列的名称，系 统将此列设置为NULL，不至于出现错误；insert中的第三个参数是ContentValues类型的变量，是键值对组成的Map，key代表列 名，value代表该列要插入的值；update的第二个参数也很类似，只不过它是更新该字段key为最新的value值，第三个参数 whereClause表示WHERE表达式，比如“age > ? and age < ?”等，最后的whereArgs参数是占位符的实际参数值；delete方法的参数也是一样

下面给出demo

数据的添加

1.使用insert方法

ContentValues cv = new ContentValues();//实例化一个ContentValues用来装载待插入的数据
cv.put("title","you are beautiful");//添加title
cv.put("weather","sun"); //添加weather
cv.put("context","xxxx"); //添加context
String publish = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
cv.put("publish ",publish); //添加publish
db.insert("diary",null,cv);//执行插入操作

2.使用execSQL方式来实现

String sql = "insert into user(username,password) values ('Jack Johnson','iLovePopMuisc');//插入操作的SQL语句
db.execSQL(sql);//执行SQL语句

数据的删除

同样有2种方式可以实现

String whereClause = "username=?";//删除的条件
String[] whereArgs = {"Jack Johnson"};//删除的条件参数
db.delete("user",whereClause,whereArgs);//执行删除

使用execSQL方式的实现

String sql = "delete from user where username='Jack Johnson'";//删除操作的SQL语句
db.execSQL(sql);//执行删除操作

数据修改

ContentValues cv = new ContentValues();//实例化ContentValues
cv.put("password","iHatePopMusic");//添加要更改的字段及内容
String whereClause = "username=?";//修改条件
String[] whereArgs = {"Jack Johnson"};//修改条件的参数
db.update("user",cv,whereClause,whereArgs);//执行修改

使用execSQL方式的实现

String sql = "update user set password = 'iHatePopMusic' where username='Jack Johnson'";//修改的SQL语句
db.execSQL(sql);//执行修改

数据查询

下面来说说查询操作。查询操作相对于上面的几种操作要复杂些，因为我们经常要面对着各种各样的查询条件，所以系统也考虑到这种复杂性，为我们提供了较为丰富的查询形式：

1 db.rawQuery(String sql, String[] selectionArgs);
2 db.query(String table, String[] columns, String selection, String[] selectionArgs, String groupBy, String having, String orderBy);
3 db.query(String table, String[] columns, String selection, String[] selectionArgs, String groupBy, String having, String orderBy, String limit);
4 db.query(String distinct, String table, String[] columns, String selection, String[] selectionArgs, String groupBy, String having, String orderBy, String limit);

上面几种都是常用的查询方法，第一种最为简单，将所有的SQL语句都组织到一个字符串中，使用占位符代替实际参数，selectionArgs就是占位符实际参数集；

各参数说明：

table：表名称
colums：表示要查询的列所有名称集
selection：表示WHERE之后的条件语句，可以使用占位符
selectionArgs：条件语句的参数数组
groupBy：指定分组的列名
having：指定分组条件,配合groupBy使用
orderBy：y指定排序的列名
limit：指定分页参数
distinct：指定“true”或“false”表示要不要过滤重复值
Cursor：返回值，相当于结果集ResultSet
最后，他们同时返回一个Cursor对象，代表数据集的游标，有点类似于JavaSE中的ResultSet。下面是Cursor对象的常用方法：

c.move(int offset); //以当前位置为参考,移动到指定行
c.moveToFirst();    //移动到第一行
c.moveToLast();     //移动到最后一行
c.moveToPosition(int position); //移动到指定行
c.moveToPrevious(); //移动到前一行
c.moveToNext();     //移动到下一行
c.isFirst();        //是否指向第一条
c.isLast();     //是否指向最后一条
c.isBeforeFirst();  //是否指向第一条之前
c.isAfterLast();    //是否指向最后一条之后
c.isNull(int columnIndex);  //指定列是否为空(列基数为0)
c.isClosed();       //游标是否已关闭
c.getCount();       //总数据项数
c.getPosition();    //返回当前游标所指向的行数
c.getColumnIndex(String columnName);//返回某列名对应的列索引值
c.getString(int columnIndex);   //返回当前行指定列的值

实现代码

String[] params =  {12345,123456};
Cursor cursor = db.query("user",columns,"ID=?",params,null,null,null);//查询并获得游标
if(cursor.moveToFirst()){//判断游标是否为空for(int i=0;i<cursor.getCount();i++){cursor.move(i);//移动到指定记录String username = cursor.getString(cursor.getColumnIndex("username");String password = cursor.getString(cursor.getColumnIndex("password"));}
}

通过rawQuery实现的带参数查询

Cursor result=db.rawQuery("SELECT ID, name, inventory FROM mytable");
//Cursor c = db.rawQuery("s name, inventory FROM mytable where ID=?",new Stirng[]{"123456"});
result.moveToFirst();
while (!result.isAfterLast()) { int id=result.getInt(0); String name=result.getString(1); int inventory=result.getInt(2); // do something useful with these result.moveToNext(); } result.close();

在上面的代码示例中，已经用到了这几个常用方法中的一些，关于更多的信息，大家可以参考官方文档中的说明。

最后当我们完成了对数据库的操作后，记得调用SQLiteDatabase的close()方法释放数据库连接，否则容易出现SQLiteException。

上面就是SQLite的基本应用，但在实际开发中，为了能够更好的管理和维护数据库，我们会封装一个继承自SQLiteOpenHelper类的数据库操作类，然后以这个类为基础，再封装我们的业务逻辑方法。

这里直接使用案例讲解：下面是案例demo的界面

SQLiteOpenHelper类介绍

SQLiteOpenHelper是SQLiteDatabase的一个帮助类，用来管理数据库的创建和版本的更新。一般是建立一个类继承它，并实现它的onCreate和onUpgrade方法。

方法名 方法描述
SQLiteOpenHelper(Context context,String name,SQLiteDatabase.CursorFactory factory,int version)
构造方法，其中

context 程序上下文环境 即：XXXActivity.this;

name :数据库名字;

factory:游标工厂，默认为null,即为使用默认工厂;

version 数据库版本号

onCreate(SQLiteDatabase db) 创建数据库时调用
onUpgrade(SQLiteDatabase db,int oldVersion , int newVersion) 版本更新时调用
getReadableDatabase() 创建或打开一个只读数据库
getWritableDatabase() 创建或打开一个读写数据库
首先创建数据库类

import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteDatabase.CursorFactory;
import android.database.sqlite.SQLiteOpenHelper;public class SqliteDBHelper extends SQLiteOpenHelper {// 步骤1：设置常数参量private static final String DATABASE_NAME = "diary_db";private static final int VERSION = 1;private static final String TABLE_NAME = "diary";// 步骤2：重载构造方法public SqliteDBHelper(Context context) {super(context, DATABASE_NAME, null, VERSION);}/** 参数介绍：context 程序上下文环境 即：XXXActivity.this * name 数据库名字 * factory 接收数据，一般情况为null* version 数据库版本号*/public SqliteDBHelper(Context context, String name, CursorFactory factory,int version) {super(context, name, factory, version);}//数据库第一次被创建时，onCreate()会被调用@Overridepublic void onCreate(SQLiteDatabase db) {// 步骤3：数据库表的创建String strSQL = "create table "+ TABLE_NAME+ "(tid integer primary key autoincrement,title varchar(20),weather varchar(10),context text,publish date)";//步骤4：使用参数db,创建对象db.execSQL(strSQL);}//数据库版本变化时，会调用onUpgrade()@Overridepublic void onUpgrade(SQLiteDatabase arg0, int arg1, int arg2) {}
}

正如上面所述，数据库第一次创建时onCreate方法会被调用，我们可以执行创建表的语句，当系统发现版本变化之后，会调用onUpgrade方法，我们可以执行修改表结构等语句。

我们需要一个Dao，来封装我们所有的业务方法，代码如下：

import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;import com.chinasoft.dbhelper.SqliteDBHelper;public class DiaryDao {private SqliteDBHelper sqliteDBHelper;private SQLiteDatabase db;// 重写构造方法public DiaryDao(Context context) {this.sqliteDBHelper = new SqliteDBHelper(context);db = sqliteDBHelper.getWritableDatabase();}// 读操作public String execQuery(final String strSQL) {try {System.out.println("strSQL>" + strSQL);// Cursor相当于JDBC中的ResultSetCursor cursor = db.rawQuery(strSQL, null);// 始终让cursor指向数据库表的第1行记录cursor.moveToFirst();// 定义一个StringBuffer的对象，用于动态拼接字符串StringBuffer sb = new StringBuffer();// 循环游标，如果不是最后一项记录while (!cursor.isAfterLast()) {sb.append(cursor.getInt(0) + "/" + cursor.getString(1) + "/"+ cursor.getString(2) + "/" + cursor.getString(3) + "/"+ cursor.getString(4)+"#");//cursor游标移动cursor.moveToNext();}db.close();return sb.deleteCharAt(sb.length()-1).toString();} catch (RuntimeException e) {e.printStackTrace();return null;}}// 写操作public boolean execOther(final String strSQL) {db.beginTransaction();  //开始事务try {System.out.println("strSQL" + strSQL);db.execSQL(strSQL);db.setTransactionSuccessful();  //设置事务成功完成 db.close();return true;} catch (RuntimeException e) {e.printStackTrace();return false;}finally {  db.endTransaction();    //结束事务  }  }
}

我们在Dao构造方法中实例化sqliteDBHelper并获取一个SQLiteDatabase对象，作为整个应用的数据库实例；在增删改信息时，我们采用了事务处理，确保数据完整性；最后要注意释放数据库资源db.close()，这一个步骤在我们整个应用关闭时执行，这个环节容易被忘记，所以朋友们要注意。

我们获取数据库实例时使用了getWritableDatabase()方法，也许朋友们会有疑问，在getWritableDatabase()和getReadableDatabase()中，你为什么选择前者作为整个应用的数据库实例呢？在这里我想和大家着重分析一下这一点。

我们来看一下SQLiteOpenHelper中的getReadableDatabase()方法：

public synchronized SQLiteDatabase getReadableDatabase() {  if (mDatabase != null && mDatabase.isOpen()) {  // 如果发现mDatabase不为空并且已经打开则直接返回  return mDatabase;  }  if (mIsInitializing) {  // 如果正在初始化则抛出异常  throw new IllegalStateException("getReadableDatabase called recursively");  }  // 开始实例化数据库mDatabase  try {  // 注意这里是调用了getWritableDatabase()方法  return getWritableDatabase();  } catch (SQLiteException e) {  if (mName == null)  throw e; // Can't open a temp database read-only!  Log.e(TAG, "Couldn't open " + mName + " for writing (will try read-only):", e);  }  // 如果无法以可读写模式打开数据库 则以只读方式打开  SQLiteDatabase db = null;  try {  mIsInitializing = true;  String path = mContext.getDatabasePath(mName).getPath();// 获取数据库路径  // 以只读方式打开数据库  db = SQLiteDatabase.openDatabase(path, mFactory, SQLiteDatabase.OPEN_READONLY);  if (db.getVersion() != mNewVersion) {  throw new SQLiteException("Can't upgrade read-only database from version " + db.getVersion() + " to "  + mNewVersion + ": " + path);  }  onOpen(db);  Log.w(TAG, "Opened " + mName + " in read-only mode");  mDatabase = db;// 为mDatabase指定新打开的数据库  return mDatabase;// 返回打开的数据库  } finally {  mIsInitializing = false;  if (db != null && db != mDatabase)  db.close();  }
}

在getReadableDatabase()方法中，首先判断是否已存在数据库实例并且是打开状态，如果是，则直接返回该实例，否则试图获取一个可读写模式的数据库实例，如果遇到磁盘空间已满等情况获取失败的话，再以只读模式打开数据库，获取数据库实例并返回，然后为mDatabase赋值为最新打开的数据库实例。既然有可能调用到getWritableDatabase()方法，我们就要看一下了：

public synchronized SQLiteDatabase getWritableDatabase() {  if (mDatabase != null && mDatabase.isOpen() && !mDatabase.isReadOnly()) {  // 如果mDatabase不为空已打开并且不是只读模式 则返回该实例  return mDatabase;  }  if (mIsInitializing) {  throw new IllegalStateException("getWritableDatabase called recursively");  }  // If we have a read-only database open, someone could be using it  // (though they shouldn't), which would cause a lock to be held on  // the file, and our attempts to open the database read-write would  // fail waiting for the file lock. To prevent that, we acquire the  // lock on the read-only database, which shuts out other users.  boolean success = false;  SQLiteDatabase db = null;  // 如果mDatabase不为空则加锁 阻止其他的操作  if (mDatabase != null)  mDatabase.lock();  try {  mIsInitializing = true;  if (mName == null) {  db = SQLiteDatabase.create(null);  } else {  // 打开或创建数据库  db = mContext.openOrCreateDatabase(mName, 0, mFactory);  }  // 获取数据库版本(如果刚创建的数据库,版本为0)  int version = db.getVersion();  // 比较版本(我们代码中的版本mNewVersion为1)  if (version != mNewVersion) {  db.beginTransaction();// 开始事务  try {  if (version == 0) {  // 执行我们的onCreate方法  onCreate(db);  } else {  // 如果我们应用升级了mNewVersion为2,而原版本为1则执行onUpgrade方法  onUpgrade(db, version, mNewVersion);  }  db.setVersion(mNewVersion);// 设置最新版本  db.setTransactionSuccessful();// 设置事务成功  } finally {  db.endTransaction();// 结束事务  }  }  onOpen(db);  success = true;  return db;// 返回可读写模式的数据库实例  } finally {  mIsInitializing = false;  if (success) {  // 打开成功  if (mDatabase != null) {  // 如果mDatabase有值则先关闭  try {  mDatabase.close();  } catch (Exception e) {  }  mDatabase.unlock();// 解锁  }  mDatabase = db;// 赋值给mDatabase  } else {  // 打开失败的情况：解锁、关闭  if (mDatabase != null)  mDatabase.unlock();  if (db != null)  db.close();  }  }
}

大家可以看到，几个关键步骤是，首先判断mDatabase如果不为空已打开并不是只读模式则直接返回，否则如果mDatabase不为空则加锁，然后开始打开或创建数据库，比较版本，根据版本号来调用相应的方法，为数据库设置新版本号，最后释放旧的不为空的mDatabase并解锁，把新打开的数据库实例赋予mDatabase，并返回最新实例。

看完上面的过程之后，大家或许就清楚了许多，如果不是在遇到磁盘空间已满等情况，getReadableDatabase()一般都会返回和getWritableDatabase()一样的数据库实例，所以我们在DBManager构造方法中使用getWritableDatabase()获取整个应用所使用的数据库实例是可行的。当然如果你真的担心这种情况会发生，那么你可以先用getWritableDatabase()获取数据实例，如果遇到异常，再试图用getReadableDatabase()获取实例，当然这个时候你获取的实例只能读不能写了

最后，让我们看一下如何使用这些数据操作方法来显示数据,界面核心逻辑代码:

public class SQLiteActivity extends Activity {public DiaryDao diaryDao;//因为getWritableDatabase内部调用了mContext.openOrCreateDatabase(mName, 0, mFactory);  //所以要确保context已初始化,我们可以把实例化Dao的步骤放在Activity的onCreate里@Overrideprotected void onCreate(Bundle savedInstanceState) {diaryDao = new DiaryDao(SQLiteActivity.this);initDatabase();}class ViewOcl implements View.OnClickListener {@Overridepublic void onClick(View v) {String strSQL;boolean flag;String message;switch (v.getId()) {case R.id.btnAdd:String title = txtTitle.getText().toString().trim();String weather = txtWeather.getText().toString().trim();;String context = txtContext.getText().toString().trim();;String publish = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());// 动态组件SQL语句strSQL = "insert into diary values(null,'" + title + "','"+ weather + "','" + context + "','" + publish + "')";flag = diaryDao.execOther(strSQL);//返回信息message = flag?"添加成功":"添加失败";Toast.makeText(getApplicationContext(), message, Toast.LENGTH_LONG).show();break;case R.id.btnDelete:strSQL = "delete from diary where tid = 1";flag = diaryDao.execOther(strSQL);//返回信息message = flag?"删除成功":"删除失败";Toast.makeText(getApplicationContext(), message, Toast.LENGTH_LONG).show();break;case R.id.btnQuery:strSQL = "select * from diary order by publish desc";String data = diaryDao.execQuery(strSQL);Toast.makeText(getApplicationContext(), data, Toast.LENGTH_LONG).show();break;case R.id.btnUpdate:strSQL = "update diary set title = '测试标题1-1' where tid = 1";flag = diaryDao.execOther(strSQL);//返回信息message = flag?"更新成功":"更新失败";Toast.makeText(getApplicationContext(), message, Toast.LENGTH_LONG).show();break;}}}private void initDatabase() {// 创建数据库对象SqliteDBHelper sqliteDBHelper = new SqliteDBHelper(SQLiteActivity.this);sqliteDBHelper.getWritableDatabase();System.out.println("数据库创建成功");}
}

Android sqlite3数据库管理工具

Android SDK的tools目录下提供了一个sqlite3.exe工具，这是一个简单的sqlite数据库管理工具。开发者可以方便的使用其对sqlite数据库进行命令行的操作。

程序运行生成的*.db文件一般位于"/data/data/项目名(包括所处包名)/databases/*.db"，因此要对数据库文件进行操作需要先找到数据库文件：

1、进入shell 命令

adb shell
2、找到数据库文件

#cd data/data
#ls --列出所有项目
#cd project_name --进入所需项目名
#cd databases
#ls --列出现寸的数据库文件
3、进入数据库

#sqlite3 test_db --进入所需数据库
会出现类似如下字样：

SQLite version 3.6.22
Enter “.help” for instructions
Enter SQL statements terminated with a “;”
sqlite>
至此，可对数据库进行sql操作。

4、sqlite常用命令

.databases --产看当前数据库
.tables --查看当前数据库中的表
.help --sqlite3帮助
.schema --各个表的生成语句

第四种： 使用ContentProvider存储数据

Android这个系统和其他的操作系统还不太一样，我们需要记住的是，数据在Android当中是私有的，当然这些数据包括文件数据和数据库数据 以及一些其他类型的数据。那这个时候有读者就会提出问题，难道两个程序之间就没有办法对于数据进行交换？Android这么优秀的系统不会让这种情况发生 的。解决这个问题主要靠ContentProvider。一个Content Provider类实现了一组标准的方法接口，从而能够让其他的应用保存或读取此Content Provider的各种数据类型。也就是说，一个程序可以通过实现一个Content Provider的抽象接口将自己的数据暴露出去。外界根本看不到，也不用看到这个应用暴露的数据在应用当中是如何存储的，或者是用数据库存储还是用文件 存储，还是通过网上获得，这些一切都不重要，重要的是外界可以通过这一套标准及统一的接口和程序里的数据打交道，可以读取程序的数据，也可以删除程序的数 据，当然，中间也会涉及一些权限的问题。

一个程序可以通过实现一个ContentProvider的抽象接口将自己的数据完全暴露出去，而且ContentProviders是以类似数据 库中表的方式将数据暴露，也就是说ContentProvider就像一个“数据库”。那么外界获取其提供的数据，也就应该与从数据库中获取数据的操作基 本一样，只不过是采用URI来表示外界需要访问的“数据库”。

Content Provider提供了一种多应用间数据共享的方式，比如：联系人信息可以被多个应用程序访问。

Content Provider是个实现了一组用于提供其他应用程序存取数据的标准方法的类。 应用程序可以在Content Provider中执行如下操作: 查询数据 修改数据 添加数据 删除数据

标准的Content Provider: Android提供了一些已经在系统中实现的标准Content Provider，比如联系人信息，图片库等等，你可以用这些Content Provider来访问设备上存储的联系人信息，图片等等。

查询记录:

在Content Provider中使用的查询字符串有别于标准的SQL查询。很多诸如select, add, delete, modify等操作我们都使用一种特殊的URI来进行，这种URI由3个部分组成， “content://”, 代表数据的路径，和一个可选的标识数据的ID。

以下是一些示例URI:

content://media/internal/images 这个URI将返回设备上存储的所有图片

content://contacts/people/ 这个URI将返回设备上的所有联系人信息

content://contacts/people/45 这个URI返回单个结果（联系人信息中ID为45的联系人记录）

尽管这种查询字符串格式很常见，但是它看起来还是有点令人迷惑。为此，Android提供一系列的帮助类（在android.provider包下），里面包含了很多以类变量形式给出的查询字符串，这种方式更容易让我们理解一点，参见下例:

MediaStore.Images.Media.INTERNAL_CONTENT_URI Contacts.People.CONTENT_URI

因此，如上面content://contacts/people/45这个URI就可以写成如下形式：

Uri person = ContentUris.withAppendedId(People.CONTENT_URI, 45);

然后执行数据查询: Cursor cur = managedQuery(person, null, null, null);

这个查询返回一个包含所有数据字段的游标，我们可以通过迭代这个游标来获取所有的数据：

package com.wissen.testApp;
public class ContentProviderDemo extends Activity { @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); displayRecords(); } private void displayRecords() { //该数组中包含了所有要返回的字段 String columns[] = new String[] { People.NAME, People.NUMBER }; Uri mContacts = People.CONTENT_URI; Cursor cur = managedQuery( mContacts, columns,  // 要返回的数据字段 null,          // WHERE子句 null,         // WHERE 子句的参数 null         // Order-by子句 ); if (cur.moveToFirst()) { String name = null; String phoneNo = null; do { // 获取字段的值 name = cur.getString(cur.getColumnIndex(People.NAME)); phoneNo = cur.getString(cur.getColumnIndex(People.NUMBER)); Toast.makeText(this, name + ” ” + phoneNo, Toast.LENGTH_LONG).show(); } while (cur.moveToNext()); } }
}

上例示范了一个如何依次读取联系人信息表中的指定数据列name和number。

修改记录:

我们可以使用ContentResolver.update()方法来修改数据，我们来写一个修改数据的方法:

private void updateRecord(int recNo, String name) { Uri uri = ContentUris.withAppendedId(People.CONTENT_URI, recNo); ContentValues values = new ContentValues(); values.put(People.NAME, name); getContentResolver().update(uri, values, null, null); }

现在你可以调用上面的方法来更新指定记录： updateRecord(10, ”XYZ”); //更改第10条记录的name字段值为“XYZ”

添加记录:

要增加记录，我们可以调用ContentResolver.insert()方法，该方法接受一个要增加的记录的目标URI，以及一个包含了新记录值的Map对象，调用后的返回值是新记录的URI，包含记录号。

上面的例子中我们都是基于联系人信息簿这个标准的Content Provider，现在我们继续来创建一个insertRecord() 方法以对联系人信息簿中进行数据的添加：

private void insertRecords(String name, String phoneNo) { ContentValues values = new ContentValues(); values.put(People.NAME, name); Uri uri = getContentResolver().insert(People.CONTENT_URI, values); Log.d(”ANDROID”, uri.toString()); Uri numberUri = Uri.withAppendedPath(uri, People.Phones.CONTENT_DIRECTORY); values.clear(); values.put(Contacts.Phones.TYPE, People.Phones.TYPE_MOBILE); values.put(People.NUMBER, phoneNo); getContentResolver().insert(numberUri, values); }

这样我们就可以调用insertRecords(name, phoneNo)的方式来向联系人信息簿中添加联系人姓名和电话号码。

删除记录:

Content Provider中的getContextResolver.delete()方法可以用来删除记录。

下面的记录用来删除设备上所有的联系人信息：

private void deleteRecords() {  Uri uri = People.CONTENT_URI;  getContentResolver().delete(uri, null, null);  }
你也可以指定WHERE条件语句来删除特定的记录：getContentResolver().delete(uri, “NAME=” + “‘XYZ XYZ’”, null);

这将会删除name为‘XYZ XYZ’的记录。

创建Content Provider:

至此我们已经知道如何使用Content Provider了，现在让我们来看下如何自己创建一个Content Provider。

要创建我们自己的Content Provider的话，我们需要遵循以下几步：

1. 创建一个继承了ContentProvider父类的类

2. 定义一个名为CONTENT_URI，并且是public static final的Uri类型的类变量，你必须为其指定一个唯一的字符串值，最好的方案是以类的全名称，

如: public static final Uri CONTENT_URI = Uri.parse( “content://com.google.android.MyContentProvider”);

1. 创建你的数据存储系统。大多数Content Provider使用Android文件系统或SQLite数据库来保持数据，但是你也可以以任何你想要的方式来存储。

2. 定义你要返回给客户端的数据列名。如果你正在使用Android数据库，则数据列的使用方式就和你以往所熟悉的其他数据库一样。但是，你必须为其定义一个叫_id的列，它用来表示每条记录的唯一性。

3. 如果你要存储字节型数据，比如位图文件等，那保存该数据的数据列其实是一个表示实际保存文件的URI字符串，客户端通过它来读取对应的文件数据，处理这种 数据类型的Content Provider需要实现一个名为_data的字段，_data字段列出了该文件在Android文件系统上的精确路径。这个字段不仅是供客户端使用，而 且也可以供ContentResolver使用。客户端可以调用ContentResolver.openOutputStream()方法来处理该 URI指向的文件资源，如果是ContentResolver本身的话，由于其持有的权限比客户端要高，所以它能直接访问该数据文件。

4. 声明public static String型的变量，用于指定要从游标处返回的数据列。

5. 查询返回一个Cursor类型的对象。所有执行写操作的方法如insert(), update() 以及delete()都将被监听。我们可以通过使用ContentResover().notifyChange()方法来通知监听器关于数据更新的信息。

6. 在AndroidMenifest.xml中使用标签来设置Content Provider。

7. 如果你要处理的数据类型是一种比较新的类型，你就必须先定义一个新的MIME类型，以供ContentProvider.geType(url)来返回。

MIME类型有两种形式:

一种是为指定的单个记录的，还有一种是为多条记录的。这里给出一种常用的格式： vnd.android.cursor.item/vnd.yourcompanyname.contenttype （单个记录的MIME类型） 比如, 一个请求列车信息的URI如content://com.example.transportationprovider/trains/122 可能就会返回typevnd.android.cursor.item/vnd.example.rail这样一个MIME类型。

vnd.android.cursor.dir/vnd.yourcompanyname.contenttype （多个记录的MIME类型） 比如, 一个请求所有列车信息的URI如content://com.example.transportationprovider/trains 可能就会返回vnd.android.cursor.dir/vnd.example.rail这样一个MIME 类型。

下列代码将创建一个Content Provider，它仅仅是存储用户名称并显示所有的用户名称（使用 SQLLite数据库存储这些数据）：

package com.wissen.testApp;
public class MyUsers { public static final String AUTHORITY  = “com.wissen.MyContentProvider”; // BaseColumn类中已经包含了 _id字段 public static final class User implements BaseColumns { public static final Uri CONTENT_URI  = Uri.parse(”content://com.wissen.MyContentProvider”); // 表数据列 public static final String  USER_NAME  = “USER_NAME”; }
}

上面的类中定义了Content Provider的CONTENT_URI，以及数据列。下面我们将定义基于上面的类来定义实际的Content Provider类：

package com.wissen.testApp.android;
public class MyContentProvider extends ContentProvider { private SQLiteDatabase     sqlDB; private DatabaseHelper    dbHelper; private static final String  DATABASE_NAME     = “Users.db”; private static final int        DATABASE_VERSION         = 1; private static final String TABLE_NAME   = “User”; private static final String TAG = “MyContentProvider”; private static class DatabaseHelper extends SQLiteOpenHelper { DatabaseHelper(Context context) { super(context, DATABASE_NAME, null, DATABASE_VERSION); } @Override public void onCreate(SQLiteDatabase db) { //创建用于存储数据的表 db.execSQL(”Create table ” + TABLE_NAME + “( _id INTEGER PRIMARY KEY AUTOINCREMENT, USER_NAME TEXT);”); } @Override public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { db.execSQL(”DROP TABLE IF EXISTS ” + TABLE_NAME); onCreate(db); } } @Override public int delete(Uri uri, String s, String[] as) { return 0; } @Override public String getType(Uri uri) { return null; } @Override public Uri insert(Uri uri, ContentValues contentvalues) { sqlDB = dbHelper.getWritableDatabase(); long rowId = sqlDB.insert(TABLE_NAME, “”, contentvalues); if (rowId > 0) { Uri rowUri = ContentUris.appendId(MyUsers.User.CONTENT_URI.buildUpon(), rowId).build(); getContext().getContentResolver().notifyChange(rowUri, null); return rowUri; } throw new SQLException(”Failed to insert row into ” + uri); } @Override public boolean onCreate() { dbHelper = new DatabaseHelper(getContext()); return (dbHelper == null) ? false : true; } @Override public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) { SQLiteQueryBuilder qb = new SQLiteQueryBuilder(); SQLiteDatabase db = dbHelper.getReadableDatabase(); qb.setTables(TABLE_NAME); Cursor c = qb.query(db, projection, selection, null, null, null, sortOrder); c.setNotificationUri(getContext().getContentResolver(), uri); return c; } @Override public int update(Uri uri, ContentValues contentvalues, String s, String[] as) { return 0; }
}

一个名为MyContentProvider的Content Provider创建完成了，它用于从Sqlite数据库中添加和读取记录。

Content Provider的入口需要在AndroidManifest.xml中配置:

之后，让我们来使用这个定义好的Content Provider:

package com.wissen.testApp;
public class MyContentDemo extends Activity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); insertRecord(”MyUser”); displayRecords(); } private void insertRecord(String userName) { ContentValues values = new ContentValues(); values.put(MyUsers.User.USER_NAME, userName); getContentResolver().insert(MyUsers.User.CONTENT_URI, values); } private void displayRecords() { String columns[] = new String[] { MyUsers.User._ID, MyUsers.User.USER_NAME }; Uri myUri = MyUsers.User.CONTENT_URI; Cursor cur = managedQuery(myUri, columns,null, null, null ); if (cur.moveToFirst()) { String id = null; String userName = null; do { id = cur.getString(cur.getColumnIndex(MyUsers.User._ID)); userName = cur.getString(cur.getColumnIndex(MyUsers.User.USER_NAME)); Toast.makeText(this, id + ” ” + userName, Toast.LENGTH_LONG).show(); } while (cur.moveToNext()); } }
}

上面的类将先向数据库中添加一条用户数据，然后显示数据库中所有的用户数据。

第五种： 网络存储数据

前面介绍的几种存储都是将数据存储在本地设备上，除此之外，还有一种存储（获取）数据的方式，通过网络来实现数据的存储和获取。

我们可以调用WebService返回的数据或是解析HTTP协议实现网络数据交互。

具体需要熟悉java.net.*，Android.net.*这两个包的内容，在这就不赘述了，请大家参阅相关文档。

下面是一个通过地区名称查询该地区的天气预报，以POST发送的方式发送请求到webservicex.net站点，访问WebService.webservicex.net站点上提供查询天气预报的服务。

代码如下：

package com.android.weather;  import java.util.ArrayList;
import java.util.List; import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.EntityUtils; import android.app.Activity;
import android.os.Bundle; public class MyAndroidWeatherActivity extends Activity { //定义需要获取的内容来源地址 private static final String SERVER_URL =  "http://www.webservicex.net/WeatherForecast.asmx/GetWeatherByPlaceName";  /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); HttpPost request = new HttpPost(SERVER_URL); //根据内容来源地址创建一个Http请求 // 添加一个变量  List<NameValuePair> params = new ArrayList<NameValuePair>();  // 设置一个地区名称 params.add(new BasicNameValuePair("PlaceName", "NewYork"));  //添加必须的参数 try {  //设置参数的编码 request.setEntity(new UrlEncodedFormEntity(params, HTTP.UTF_8));  //发送请求并获取反馈 HttpResponse httpResponse = new DefaultHttpClient().execute(request); // 解析返回的内容 if(httpResponse.getStatusLine().getStatusCode() != 404){  String result = EntityUtils.toString(httpResponse.getEntity());  System.out.println(result); } } catch (Exception e) { e.printStackTrace(); }  }

别忘记了在配置文件中设置访问网络权限：

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

androidmanifest.xml清单文件中主要包含了哪些内容

(1)包名,版本号package,versionCode,versionName
(2)权限:程序中用到的权限都要在这里列出,uses-permission
(3)应用程序application,里面包括:及四大组件

请介绍下Android中常用的五种布局

常用五种布局方式，分别是：FrameLayout（框架布局），LinearLayout （线性布局），AbsoluteLayout（绝对布局），RelativeLayout（相对布局），TableLayout（表格布局）。

LinearLayout：

线性布局，每一个LinearLayout里面又可分为垂直布局（android:orientation=”vertical”）和水平布局（android:orientation=”horizontal” ）。当垂直布局时，每一行就只有一个元素，多个元素依次垂直往下；水平布局时，只有一行，每一个元素依次向右排列。

RelativeLayout：

相对布局可以理解为某一个元素为参照物，来定位的布局方式。主要属性有：相对于某一个元素android:layout_below、 android:layout_toLeftOf相对于父元素的地方android:layout_alignParentLeft、android:layout_alignParentRigh；

FrameLayout：

所有东西依次都放在左上角，会重叠，这个布局比较简单，也只能放一点比较简单的东西。

TableLayout：

表格布局，每一个TableLayout里面有表格行TableRow，TableRow里面可以具体定义每一个元素。每一个布局都有自己适合的方式，这五个布局元素可以相互嵌套应用，做出美观的界面。

AbsoluteLayout：

绝对布局用X,Y坐标来指定元素的位置，这种布局方式也比较简单，但是在屏幕旋转时，往往会出问题，而且多个元素的时候，计算比较麻烦。

Android开发中的长度单位详解

六种单位介绍

px : 像素(pixels)，即屏幕上的像素点，1px代表占据一个像素点。

dp : 独立像素(device independent pixels)，这是我们使用最多的一种单位，一般来说我们在布局文件中定义控件的宽高等属性时都会使用它。它是一种能够自动适应不同屏幕密度的单位，在160dpi的屏幕上，1dp = 1px。由于Android碎片化严重，使用它作为长度单位可以适配不同的屏幕密度。

sp : 比例像素(scaled pixels)，我们定义字体大小的时候，一般都会使用sp作单位。sp除了能够像dp一样可以适应屏幕密度的变化，还可以随着系统字体的大小设置改变作出变化。如果产品经理不想文字随着手机设置中字体的大小发生改变（例如标题），可以使用dp代替。

in : 英寸(inch)，屏幕的物理尺寸，1 inch = 2.54cm。

pt : 点(point，也是屏幕的物理尺寸，1 pt = 1/72 inch。

mm : 毫米(millimeter)，后面三种都是物理尺寸，在Android开发中不常用。

dp和px的换算

1px = 1dp * (density / 160)
dp和px的换算关系如上公式所示，density代表当前屏幕密度。常见的手机屏幕像素及对应分别率级别如下表所示：
在代码中转换单位

textView.setTextSize(2,14);

代码中设置的属性单位默认是px，我们需要对其作适当的转换。例如，上面的代码中，给TextView设置文字大小。第一个参数代表单位，这里的2代表sp，第二个参数代表大小。具体的单位指代可以在源码中看到。

public class DensityUtil {/*** 根据手机的分辨率从 dip 的单位 转成为 px(像素)*/public static int dip2px(Context context, float dpValue) {final float scale = context.getResources().getDisplayMetrics().density;return (int) (dpValue * scale + 0.5f);}/*** 根据手机的分辨率从 px(像素) 的单位 转成为 dp*/public static int px2dip(Context context, float pxValue) {final float scale = context.getResources().getDisplayMetrics().density;return (int) (pxValue / scale + 0.5f);}
}

我们也可以封装一个上面代码中的工具类，在代码中使用长度时先使用工具类进行转换。
总结
一般来说，我们在android开发中为了适配不同像素密度的屏幕，要避免使用px作单位。如果UI妹子给的效果图用的px作单位，我们要转换未dp，具体的公式在上面有。在设置文字大小时使用sp，除非不想文字随着系统字体设置变化大小。在代码中设置的长度单位默认是px，需要转换为dp或者sp。

细谈Activity四种启动模式

细谈Activity四种启动模式

安卓面试测试题复习专用 2019年版本个人收集相关推荐

1. ES6面试、复习干货知识点汇总（全）

   近期在复习ES6,针对ES6新的知识点,以问答形式整理一个全面知识和问题汇总.(全干货,适合对ES6有一定理解的同学复习,以及ES6面试.) 一.问:ES6是什么,为什么要学习它,不学习ES6会怎么样 ...

2. 一键伪装成 Windows 10：Kali Linux 2019.4 版本推出 “Undercover” 模式

    聚焦源代码安全,网罗国内外最新资讯! 编译:奇安信代码卫士团队 上上周,Kali Linux 2019.4 版本发布并推出"Undercover"模式,用于快速将 Kali 桌面 ...

3. 打造一个创客专用的UbuntuKylin版本－UMaker

   2019独角兽企业重金招聘Python工程师标准>>> 创客经常要干的事情都是从无到有,都将经历一个从创意.草图到模型.实体,然后电子电路开发.软件设计.作品集成这样一个完整的过程, ...

4. Android小技巧，快手安卓面试

   工欲行其事,必先利其器 1.B4A B4A是Android的基础版,这是一种可简化编程的Android的应用程序开发工具.这是一个IDE,可以允许开发者使用Basic语言来创建Android移动应用. ...

5. Activity 的 36 大难点，你会几个？，安卓面试2020

   前言 学 Android 有一段时间了,一直都只顾着学新的东西,最近发现很多平常用的少的东西竟让都忘了,趁着这两天,打算把有关 Activity 的内容以问题的形式梳理出来,也供大家查缺补漏. 本文中 ...

6. IntelliJ IDEA 2019.3发布，饱受性能诟病的2019.2版本终于成为过去式

   点击上方蓝色"程序猿DD",选择"设为星标" 回复"资源"获取独家整理的学习资料! 作者 | 白开水不加糖 来源 | 公众号「开源中国」 距 ...

7. Hadoop之Yarn面试知识复习

   Hadoop之Yarn面试知识复习 目录 简述hadoop1与hadoop2 的架构异同 为什么会产生 yarn,它解决了什么问题,有什么优势? Hadoop之Yarn工作机制详解 HDFS的数据压缩 ...

8. Hadoop之MapReduce面试知识复习

   Hadoop之MapReduce面试知识复习 目录 谈谈Hadoop序列化和反序列化及自定义bean对象实现序列化? FileInputFormat切片机制 在一个运行的Hadoop 任务中,什么是I ...

9. Hadoop之HDFS面试知识复习

   Hadoop之HDFS面试知识复习 目录 HDFS的存储机制 secondary namenode工作机制 NameNode与SecondaryNameNode 的区别与联系? hdfs整体架构介绍 ...

最新文章

1. MyBatis注解模式取参数方法
2. 干货 | Tomcat 连接数与线程池详解
3. simulink 快捷键 运行_【泡泡读者来搞】ROS、Simulink、Carsim的互联与规划、控制算法的验证...
4. Flutter 是移动应用程序开发的未来？
5. linux 上查找包含特定文本的所有文件
6. Trick（十二）——统计 label（序列）各个标签值出现的次数以及出现次数最多的标签
7. 视频会议受追捧，省钱又节能
8. 简单的mock-server 解决方案
9. java 编写浏览器_用Java自己写一个浏览器 —— JavaFX 入门
10. maven报错JAVA_HOME should point to a JDK not a JRE
11. android 打开公众号页面_解决「微信公众号」开发网页安卓端访问空白问题
12. 1988年图灵奖--伊万·萨瑟兰简介
13. 理解opencv读取图片后的格式，理解图片矩阵的储存方式
14. 英语单词记忆 词源法-思维导图（18）词源st/sist/stat/stin/stem-277
15. 1.3读论文笔记：M. Raissi a等人的Physics-informed neural networks：A deep learning framework for solving forw..
16. excel将一个工作表根据条件拆分成多个工作表图文教程
17. m在ISE平台下使用verilog开发基于FPGA的GMSK调制器
18. 相机显示无法访问内存卡？看完你就明白了
19. 学习STM32 Flash存储 W25Q64 SPI总线存储模块进行读写数据
20. 测试质量报告=测试报告？当然不是！

热门文章

1. 翻译土耳其语言去哪里比较好
2. [技术交流] 某设计院的计算机辅助制图标准
3. 通联ipay_通联ipay app下载-通联ipay助手下载 苹果版v2.4.1-PC6苹果网
4. Java类初始化、变量初始化
5. 2022年物联网发展趋势，我们如何抓住？
6. 多人姿态估计小小的综述
7. Python 利用 pyecharts 做数据分析绘图
8. 今年双十一套路太流弊了！
9. PHP定时器+CURL完成定时任务
10. 离线情况将镜像文件作为yum源一步安装gcc等库包解决依赖问题