安卓面试题-->一直更新就当复习基础

最近要去面试了，该复习的内容有点多，慢慢来，我们的目标 答出面试官想要的答案，并且说出一些自己的见解.

先来点开胃菜:

1. 简述Android 平台的特征有哪些。

答：开放性、挣脱运行商的束缚、丰富的硬件选择、无缝结合的Google应用.

2.简述Android 平台开发环境搭建的步骤。

答：安装Java JDK，安装Eclipse，安装Android SDK，搭建Eclipse集成开发环境（IDE）、配置ADT（Android Development Tools）、创建AVD（Android Virtual Device）

3.简述Android系统架构从高到低的几个层次。

答：四个层次，分别是：应用程序层（Applications）、应用程序框架层（Application Framework）、

各种库（Libraries）和运行环境（Runtime）、Linux内核（Linux kernel）

4.应用程序的基本组件有哪些？

答：Activity、Service、Content Provider、BroadCast Receiver

5.Android根据应用程序的组件以及组件当前运行状态将所有的进程按重要性程度从高到低划分为几个？

答：可以划分为5个：

前台进程、可见进程、服务进程、后台进程、空进程

6.应用程序的界面布局主要有哪些？

答：线性布局（LinearLayout）、表格布局（TableLayout）、相对布局（RelativeLayout）、帧布局（FrameLayout）

7.Android应用程序的菜单有哪几种？

答：Android应用程序的菜单有3种：选择菜单（Option Menu）、上下文菜单（Context Menu）、子菜单（Sub Menu）

首先是四大组件的面试题：

activity 是什么？=简述一下四大组件以及应用场景.

activity 是一个用来给用户进行展示，并且可执行界面交互的组件，之间的通信是通过Intent 运输大队长进行的，之所以能进行交互，是因为他是Context的子类，并且实现了window.callback和keyevent.callback。

1. 请描述下Activity的生命周期。

 必调用的三个方法：onCreate() --> onStart() --> onResume()，用AAA表示

（1）父Activity启动子Activity，子Actvity退出，父Activity调用顺序如下
  AAA --> onFreeze() --> onPause() --> onStop() --> onRestart() --> onStart(),onResume() …
（2）用户点击Home，Actvity调用顺序如下
  AAA --> onFreeze() --> onPause() --> onStop() -- Maybe --> onDestroy() – Maybe
（3）调用finish()， Activity调用顺序如下
  AAA --> onPause() --> onStop() --> onDestroy()
（4）在Activity上显示dialog， Activity调用顺序如下
   AAA
（5）在父Activity上显示透明的或非全屏的activity，Activity调用顺序如下
   AAA --> onFreeze() --> onPause()
（6）设备进入睡眠状态，Activity调用顺序如下
   AAA --> onFreeze() --> onPause()

2.    如果后台的Activity由于某原因被系统回收了，如何在被系统回收之前保存当前状态？

      onSaveInstanceState()

      当你的程序中某一个Activity A在运行时，主动或被动地运行另一个新的Activity B，这个时候A会执行onSaveInstanceState()。B完成以后又会来找A，这个时候就有两种情况：一是A被回收，二是A没有被回收，被回收的A就要重新调用onCreate()方法，不同于直接启动的是这回onCreate()里是带上了参数savedInstanceState；而没被收回的就直接执行onResume()，跳过onCreate()了。

3.    如何将一个Activity设置成窗口的样式

在AndroidManifest.xml 中定义Activity的地方一句话android:theme="@android:style/Theme.Dialog"或android:theme="@android:style/Theme.Translucent"就变成半透明的

4.    如何退出Activity？如何安全退出已调用多个Activity的Application？

对于单一Activity的应用来说，退出很简单，直接finish()即可。当然，也可以用killProcess()和System.exit()这样的方法。

后面那个简单就是 建立一个Application类继承Application，有人知道Application是干什么的么，知道我就不说了。建立一个数组专门放activity 最后要退出应用 使用for循环finish掉所有activity。在创建activity时候，将activity添加application中去。

5.如何启用Service，如何停用Service。

Android中的service类似于windows中的service，service一般没有用户操作界面，它运行于系统中不容易被用户发觉，

可以使用它开发如监控之类，或者播放MP3的程序。

一。步骤

第一步：继承Service类

public class SMSService extends Service { }

第二步：在AndroidManifest.xml文件中的<application>节点里对服务进行配置:

<service android:name=".DemoService" />

二。Context.startService()和Context.bindService

服务不能自己运行，需要通过调用Context.startService()或Context.bindService()方法启动服务。这两个方法都可

以启动Service，但是它们的使用场合有所不同。

1.使用startService()方法启用服务，调用者与服务之间没有关连，即使调用者退出了，服务仍然运行。

使用bindService()方法启用服务，调用者与服务绑定在了一起，调用者一旦退出，服务也就终止。

2.采用Context.startService()方法启动服务，在服务未被创建时，系统会先调用服务的onCreate()方法，

接着调用onStart()方法。如果调用startService()方法前服务已经被创建，多次调用startService()方法并

不会导致多次创建服务，但会导致多次调用onStart()方法。

采用startService()方法启动的服务，只能调用Context.stopService()方法结束服务，服务结束时会调用

onDestroy()方法。 
 

3.采用Context.bindService()方法启动服务，在服务未被创建时，系统会先调用服务的onCreate()方法，

接着调用onBind()方法。这个时候调用者和服务绑定在一起，调用者退出了，系统就会先调用服务的onUnbind()方法，

。接着调用onDestroy()方法。如果调用bindService()方法前服务已经被绑定，多次调用bindService()方法并不会

导致多次创建服务及绑定(也就是说onCreate()和onBind()方法并不会被多次调用)。如果调用者希望与正在绑定的服务

解除绑定，可以调用unbindService()方法，调用该方法也会导致系统调用服务的onUnbind()-->onDestroy()方法。

三。Service的生命周期

1.Service常用生命周期回调方法如下：

onCreate() 该方法在服务被创建时调用，该方法只会被调用一次，无论调用多少次startService()或bindService()方法，

服务也只被创建一次。 onDestroy()该方法在服务被终止时调用。 
 

2. Context.startService()启动Service有关的生命周期方法

onStart() 只有采用Context.startService()方法启动服务时才会回调该方法。该方法在服务开始运行时被调用。

多次调用startService()方法尽管不会多次创建服务，但onStart() 方法会被多次调用。

3. Context.bindService()启动Service有关的生命周期方法

onBind()只有采用Context.bindService()方法启动服务时才会回调该方法。该方法在调用者与服务绑定时被调用，

当调用者与服务已经绑定，多次调用Context.bindService()方法并不会导致该方法被多次调用。

onUnbind()只有采用Context.bindService()方法启动服务时才会回调该方法。该方法在调用者与服务解除绑定时被调用。

备注：

1. 采用startService()启动服务

     Intent intent = new Intent(DemoActivity.this, DemoService.class);

     startService(intent);

2.Context.bindService()启动

    Intent intent = new Intent(DemoActivity.this, DemoService.class);

    bindService(intent, conn, Context.BIND_AUTO_CREATE);

   //unbindService(conn);//解除绑定

说道服务了，那就有aidl的进程通信

AIDL的英文全称是Android Interface Define Language

当A进程要去调用B进程中的service时，并实现通信，我们通常都是通过AIDL来操作的

A工程：

首先我们在net.blogjava.mobile.aidlservice包中创建一个RemoteService.aidl文件，在里面我们自定义一个接口，含有方法get。ADT插件会在gen目录下自动生成一个RemoteService.java文件，该类中含有一个名为RemoteService.stub的内部类，该内部类中含有aidl文件接口的get方法。

说明一：aidl文件的位置不固定，可以任意

然后定义自己的MyService类，在MyService类中自定义一个内部类去继承RemoteService.stub这个内部类，实现get方法。在onBind方法中返回这个内部类的对象，系统会自动将这个对象封装成IBinder对象，传递给他的调用者。

其次需要在AndroidManifest.xml文件中配置MyService类，代码如下：

<!-- 注册服务 -->  

<service android:name=".MyService"> 

   <intent-filter> 

   <!--  指定调用AIDL服务的ID  --> 

       <action android:name="net.blogjava.mobile.aidlservice.RemoteService" /> 

    </intent-filter> 

</service>

为什么要指定调用AIDL服务的ID,就是要告诉外界MyService这个类能够被别的进程访问，只要别的进程知道这个ID，正是有了这个ID,B工程才能找到A工程实现通信。

说明：AIDL并不需要权限

B工程：

      首先我们要将A工程中生成的RemoteService.java文件拷贝到B工程中，在bindService方法中绑定aidl服务

      绑定AIDL服务就是将RemoteService的ID作为intent的action参数。

      说明：如果我们单独将RemoteService.aidl文件放在一个包里，那个在我们将gen目录下的该包拷贝到B工程中。如果我们将RemoteService.aidl文件和我们的其他类存放在一起，那么我们在B工程中就要建立相应的包，以保证RmoteService.java文件的报名正确，我们不能修改RemoteService.java文件

           bindService(new Inten("net.blogjava.mobile.aidlservice.RemoteService"), serviceConnection, Context.BIND_AUTO_CREATE); 

       ServiceConnection的onServiceConnected(ComponentName name, IBinder service)方法中的service参数就是A工程中MyService类中继承了RemoteService.stub类的内部类的对象。

 

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

 Android广播机制（两种注册方法） 

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

 

public class SmsBroadCastReceiver extends BroadcastReceiver    

{   

  

    @Override  

    public void onReceive(Context context, Intent intent)   

    {   

        Bundle bundle = intent.getExtras();   

        Object[] object = (Object[])bundle.get("pdus");   

        SmsMessage sms[]=new SmsMessage[object.length];   

        for(int i=0;i<object.length;i++)   

        {   

            sms[0] = SmsMessage.createFromPdu((byte[])object[i]);   

            Toast.makeText(context, "来自"+sms[i].getDisplayOriginatingAddress()+" 的消息是："+sms[i].getDisplayMessageBody(), Toast.LENGTH_SHORT).show();   

        }   

        //终止广播，在这里我们可以稍微处理，根据用户输入的号码可以实现短信防火墙。   

        abortBroadcast();   

    }   

       

}  

 

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

 

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

 

//生成广播处理   

smsBroadCastReceiver = new SmsBroadCastReceiver();   

//实例化过滤器并设置要过滤的广播   

 

IntentFilter intentFilter = new IntentFilter("android.provider.Telephony.SMS_RECEIVED"); 

 

//注册广播   

BroadCastReceiverActivity.this.registerReceiver(smsBroadCastReceiver, intentFilter);  

一种是在AndroidManifest.xml中配置广播

 

<?xml version="1.0" encoding="utf-8"?>  

<manifest xmlns:android="http://schemas.android.com/apk/res/android"  

      package="spl.broadCastReceiver"  

      android:versionCode="1"  

      android:versionName="1.0">  

    <application android:icon="@drawable/icon" android:label="@string/app_name">  

        <activity android:name=".BroadCastReceiverActivity"  

                  android:label="@string/app_name">  

            <intent-filter>  

                <action android:name="android.intent.action.MAIN" />  

                <category android:name="android.intent.category.LAUNCHER" />  

            </intent-filter>  

        </activity>  

           

        <!--广播注册-->  

        <receiver android:name=".SmsBroadCastReceiver">  

            <intent-filter android:priority="20">  

                <action android:name="android.provider.Telephony.SMS_RECEIVED"/>  

            </intent-filter>  

        </receiver>  

           

    </application>  

       

    <uses-sdk android:minSdkVersion="7" />  

       

    <!-- 权限申请 -->  

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

       

</manifest>   

 

  两种注册类型的区别是：

 

     1)第一种不是常驻型广播，也就是说广播跟随程序的生命周期。

 

     2)第二种是常驻型，也就是说当应用程序关闭后，如果有信息广播来，程序也会被系统调用自动运行。

7.    请解释下在单线程模型中Message、Handler、Message Queue、Looper之间的关系。

Handler简介：
一个Handler允许你发送和处理Message和Runable对象，这些对象和一个线程的MessageQueue相关联。每一个线程实例和一个单独的线程以及该线程的MessageQueue相关联。当你创建一个新的Handler时，它就和创建它的线程绑定在一起了。这里，线程我们也可以理解为线程的MessageQueue。从这一点上来看，Handler把Message和Runable对象传递给MessageQueue，而且在这些对象离开MessageQueue时，Handler负责执行他们。

Handler有两个主要的用途：（1）确定在将来的某个时间点执行一个或者一些Message和Runnable对象。（2）在其他线程（不是Handler绑定线程）中排入一些要执行的动作。

Message简介：
Message类就是定义了一个信息，这个信息中包含一个描述符和任意的数据对象，这个信息被用来传递给Handler.Message对象提供额外的两个int域和一个Object域，这可以让你在大多数情况下不用作分配的动作。
尽管Message的构造函数是public的，但是获取Message实例的最好方法是调用Message.obtain(),或者Handler.obtainMessage()方法，这些方法会从回收对象池中获取一个。


MessageQueue简介：
这是一个包含message列表的底层类。Looper负责分发这些message。Messages并不是直接加到一个MessageQueue中，而是通过MessageQueue.IdleHandler关联到Looper。
你可以通过Looper.myQueue()从当前线程中获取MessageQueue。


Looper简介：
Looper类被用来执行一个线程中的message循环。默认情况，没有一个消息循环关联到线程。在线程中调用prepare()创建一个Looper，然后用loop()来处理messages，直到循环终止。

大多数和message loop的交互是通过Handler。