19、android面试题整理（自己给自己充充电吧）

2023-07-27 20:41:22

（转载，出处丢失，请原作者原谅，如有意见，私信我我会尽快删除本文）

JAVA

1.GC是什么? 为什么要有GC?
GC是垃圾收集的意思（Gabage Collection）,内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，Java语言没有提供释放已分配内存的显示操作方法。

2.XML包括哪些解释技术，区别是什么？
DOM和SAX
DOM将文档解析成一颗文档树，可在节点上进行遍历、增加、修改和删除。一次性读入内存，对内存消耗大。
SAX至上而下解析文档，以事件进行驱动。不会一次性读入内存，对内存消耗小，不能任意读取节点，并且不能对节点进行增加、修改和删除。

3.switch语句能否作用在byte上，能否作用在long上，能否作用在String上?
switch能作用在byte、char、short和int上，JDK1.7后可以作用在String上。

4."=="和equals方法究竟有什么区别？
==和equals都可以比较地址。==是运算符，equals是方法，方法可以通过重写改变其行为，如String的equals就是比较字符串内容。

5.构造方法能否被重写和重载？
构造方法不能被重写但是能被重载。

6.面向对象的特征有哪些？
封装、继承、多态和抽象。
7.抽象类和接口的区别？
1).抽象类是abstract class修饰，接口是interface修饰。
2).抽象类可以有任意类型的属性，接口只能有静态常量修饰的属性。
3).抽象类可以有普通方法和抽象法方法，接口的方法都是抽象方法。
4).抽象类和接口都不能实例化，但是抽象类有构造方法，接口没有构造方法。
5).抽象类只能单根继承，接口可以多重实现。

8.内部类可以引用它的包含类的成员吗？有没有什么限制？
可以引用。如果需要指定当前类时要用外部类.this来引用。如果引用局部变量，需要将局部变量指定为final。

9.String s = new String("xyz");创建了几个String Object? 二者之间有什么区别？
2个对象。"xyz"创建在字符串常量池中，new String()创建在堆中。

10.try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前还是后?
会在return前执行。

11.Integer与int的区别
Integer为包装类，int是基本数据类型。包装类拥有方法和属性，基本数据类型不具备。包装类可以通过intValue来转换成基本数据类型，也可以通过new Integer()将基本数据类型转换为包装类。在JDK1.5后，包装类和基本数据类型可以实现自动转换。

12.sleep()和wait()有什么区别?
sleep是Thread类的方法，wait是Object类的方法。
sleep是自动唤醒，wait需要其他线程来唤醒。
sleep不会释放同步锁，wait会释放同步锁。
sleep可以用在任意方法中，wait只能用在同步方法或同步块中。

13.Sleep（）不会释放对象锁到时自动恢复 wait（）会释放对象锁进入等待此对象的等待锁定池发出notify（）方法后才进入等待锁定池准备对象锁的获取进入运行状态

14.同步和异步有何异同，在什么情况下分别使用他们？
同步指同一时间只能一个线程执行该方法，其他线程需要等待。异步指多个线程可以同时执行某个方法，并共享同一资源。
同步可以让访问的资源具有安全性，因为同一时间只能一个线程对其进行访问。但是效率不高。
异步对访问的资源会造成不稳定性，比如多个线程同时访问一个资源，一个在修改、一个在删除、一个在读取，这样可能会造成资源的混乱。但是由于同时运行，执行效率得到提高。

15.启动一个线程是用run()还是start()?
start()方法启动线程，run方法是线程执行的主方法。

16.java中有几种类型的流？JDK为每种类型的流提供了一些抽象类以供继承，请说出他们分别是哪些类？
java中有三种流，分别是字节流（InputStream、OutputStream）、字符流（Reader、Writer）、对象流（ObjectInputStream、ObjectOutputStream）。

17.字节流与字符流的区别？
字节流用于读取或写出二进制数据，比如图片、影像等数据。
字符流用于读取或写出字符数据，比如传输字符串。
所有的数据都可以通过字节流来进行处理，不过如果是字符数据，用字节流还需要进行转换后传输，如果使用字符流可以方便数据的转换。

18.error和exception有什么区别?
error是系统错误，代码不能处理的错误，比如内存溢出、堆栈溢出等。
exception是程序异常，可以通过代码try-catch进行处理，比如空指针异常，数组越界等。

19.谈谈final,finally,finalize的区别？
final是修饰符，可以修饰类（不能被继承）、属性（常量）、和方法（不能被重写）。
finally是异常处理块中的代码块，表示无论如何都会执行的代码块。
finalize是Object类的方法，该方法在对象被垃圾回收之前执行的方法。

20.当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法?
如果其他方法没有加synchronized的话是可以进入的。

21.当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递?
java中只有值传递，如果传递的对象，实际也是传递该对象的地址。

22.作用域public,private,protected,以及不写时的区别
public公共修饰符，表示任意类都可以访问。
protected为受保护的修饰符，表示同类、同包以及不同包但是父子关系的是可以访问。
不写表示默认修饰符，或者称为package修饰符，该修饰符表示只有同类或同包下的类可以访问，出了这个包就不能访问了。
private为私有修饰符，表示只有同类中可以访问，出了这个类就不能访问了。

23.用最有效率的方法算出2乘以8等於几 2《 3
将2的二进制向左移3位。java中用<<来移位。

24.heap和stack有什么区别。
heap表示堆，stack表示栈。堆中放对象，栈中放引用变量。
堆空间是一个无序的空间，栈是先进后出的结构。

25.运行时异常与一般异常有何异
运行时异常是指继承于RuntimeException的异常，这些异常在编译时可以不进行处理，当运行时如果出现问题才会抛出。如NullPointException、ArrayIndexOutOfBoundsException
一般异常也称为编译时异常，这些异常是继承Exception但又不属于RuntimeException的子类，如果程序中出现这些异常，在编译时必须进行捕获或抛出，否则编译无法通过。如IOException、FileNotFoundException

26.垃圾回收的优点和原理。并考虑2种回收机制
Java语言中一个显著的特点就是引入了垃圾回收机制，使c++程序员最头疼的内存管理的问题迎刃而解，它使得Java程序员在编写程序的时候不再需要考虑内存管理。由于有个垃圾回收机制，Java中的对象不再有"作用域"的概念，只有对象的引用才有"作用域"。垃圾回收可以有效的防止内存泄露，有效的使用可以使用的内存。垃圾回收器通常是作为一个单独的低级别的线程运行，不可预知的情况下对内存堆中已经死亡的或者长时间没有使用的对象进行清楚和回收，程序员不能实时的调用垃圾回收器对某个对象或所有对象进行垃圾回收。回收机制有分代复制垃圾回收和标记垃圾回收，增量垃圾回收。

27.描述一下JVM加载class文件的原理机制?
JVM中类的装载是由ClassLoader和它的子类来实现的,Java ClassLoader 是一个重要的Java运行时系统组件。它负责在运行时查找和装入类文件的类。

28.是否可以从一个static方法内部发出对非static方法的调用？
不能，除非先创建非static方法所在类的对象。

29.什么是java序列化，如何实现java序列化？

30.使用serializable关键字使用一个输出流构造一个对象流流对象然后使用对象流对象的writeObject（）就可以将参数为obj的对象写出

31.Anonymous Inner Class(匿名内部类)是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)？
匿名内部类可以继承类或实现接口，但不是显示的使用extends或implements来继承或实现。

32.ArrayList和Vector的区别,HashMap和Hashtable的区别？
ArrayList是JDK1.2的集合类并且线程不安全，Vector是1.0的集合类并且线程安全，二者用法类似。
HashMap线程不安全且能放空键或空值，Hashtable线程安全且不能放空键或空值。

33.String 和StringBuffer有什么差别？在什么情况下使用它们？
String字符串的基本类，该字符串是不可变的。StringBuffer是利用堆来存储字符串，并且可以对字符串的内容进行改变。

34.new一个类对象和使用类名创建一个对象有什么区别？二者使用时应该注意什么？
new对象是最常见的创建对象的方式，利用类模板是通过反射来创建对象。虽然new对象时在底层也会通过类模板来创建对象，但是new对象的效率要比直接通过类模板创建对象的方式要高。
但是使用类模板的方式可以让程序的灵活性提高。

35.LinkedList和ArrayList的区别？
1）LinkedList是链表结构的集合，ArrayList数组结构的集合。
2）LinkedList在中间或前面增加或删除数据时效率比ArrayList高。
3）LinkedList在最后添加或删除数据时效率比ArrayList低。
4）遍历数据时ArrayList效率高于LinkedList。

36.介绍JAVA开发中常用的Collection FrameWork（集合框架）?
Java中集合框架分为Collection和Map接口，Collection接口下的集合每个元素都由一个值组成，Map接口下的集合类每个元素都是由键值对组成。
Collection接口下面有List和Set接口，List接口下常见的类有ArrayList、LinkedList、Vector。它们中的元素可以重复，并且是有序的。Set接口下常见的类有HashSet、TreeSet。它们中的元素不能重复，并且是无序的。

37.在异常当中 throw和throws 有什么区别和联系？
throw是在代码中抛出一个异常，后面跟的是异常对象，虚拟机运行到这里时会立即引发一个异常。
throws是写在方法声明上的，表示声明该方法可能会抛出异常，后面跟的是异常类型。调用该方法的时候可以选择处理它或继续往外抛。

38.重载和重写的区别
重载是指在一个类中，两个或两个以上的方法具有相同方法名和不同参数列表，则表示这些方法为重载方法。
重写是指在父类和子类中，子类的方法和父类的方法具有相同方法名、相同参数列表、相同返回类型、子类的访问修饰符范围不小于父类的访问修饰符范围，异常的类型和个数不大于或多于父类的异常类型和个数，则表示该方法为重写方法。换句话说重载方法是区分同一个类中相同方法名的方法，重写方法是找到父类相同方法名的方法并重新改变方法的行为。

Android

39.activity、Service、BroadcastReceiver的作用（android）
Activity：Activity是Android程序与用户交互的窗口，是Android构造块中最基本的一种，它需要为保持各界面的状态，做很多持久化的事情，妥善管理生命周期以及一些跳转逻辑
service：后台服务于Activity，封装有一个完整的功能逻辑实现，接受上层指令，完成相关的指令，定义好需要接受的Intent提供同步和异步的接口
BroadCast Receiver：接受一种或者多种Intent作触发事件，接受相关消息，做一些简单处理，转换成一条Notification，统一了Android的事件广播模型

40.描述一个完整的Android activity lifecycle
activity的生命周期方法有：onCreate()、onStart()、onReStart()、onResume()、onPause()、onStop()、onDestory()；

41.显式intent和隐式intent的区别是什么（android）
Intent定义：Intent是一种在不同组件之间传递的请求消息，是应用程序发出的请求和意图。作为一个完整的消息传递机制，Intent不仅需要发送端，还需要接收端。
显式Intent定义：对于明确指出了目标组件名称的Intent，我们称之为显式Intent。
隐式Intent定义：对于没有明确指出目标组件名称的Intent，则称之为隐式Intent。
说明：Android系统使用IntentFilter 来寻找与隐式Intent相关的对象。

42.Android中线程同步的方法
线程同步的方法可以采用同步方法和同步块。

43.怎么将一个Activity封装成对话框的样子? 怎样将Activity封装成长按Menu菜单的样子？
简单你只需要设置一下Activity的主题就可以了在AndroidManifest.xml 中定义 Activity的地方一句话：
Xml代码
android :theme="@android:style/Theme.Dialog"
android:theme="@android:style/Theme.Dialog"
这就使你的应用程序变成对话框的形式弹出来了，或者
Xml代码
android:theme="@android:style/Theme.Translucent"
android:theme="@android:style/Theme.Translucent"
就变成半透明的。
重写OnCreateOptionMenu方法来处理按下menu后的行为，然后再该方法中弹出对话框形式的Activity。
也可以利用事件监听来监听menu按键，并在该按钮按下后弹出对话框形式的Activity。

44.介绍一下Android系统的体系结构
应用层：android的应用程序通常涉及用户界面和交互。
应用框架层：UI组件、各种管理器等。
函数库层：系统C库、媒体库、webkit、SQLite等。
linux核心库：linux系统运行的组件。

*45.描述下横竖屏切换时候 activity 的生命周期
不设置Activity的android:configChanges时,切屏会重新调用各个生命周期,切横屏时会执行一次,切竖屏时会执行两次.
设置Activity的android:configChanges="orientation"时,切屏还是会重新调用各个生命周期,切横、竖屏时只会执行一次.
设置Activity的android:configChanges="orientation|keyboardHidden"时,切屏不会重新调用各个生命周期,只会执行onConfigurationChanged方法.

46.android 中的动画有哪几种，它们的特点和区别是什么 ?
两种，一种是补间动画（Tween）动画、还有一种是帧动画（Frame）动画。Tween动画，这种实现方式可以使视图组件移动、放大、缩小以及产生透明度的变化;另一种Frame动画，传统的动画方法，通过顺序的播放排列好的图片来实现，类似电影。

47.一条最长的短信息约占多少 byte?
140byte，70个汉字。

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

49.如何将 SQLite 数据库 (dictionary.db 文件 ) 与 apk 文件一起发布 ?
可以将dictionary.db文件复制到Eclipse Android工程中的res\raw目录中。所有在res\raw目录中的文件不会被压缩，这样可以直接提取该目录中的文件。
使用openDatabase方法来打开数据库文件，如果该文件不存在，系统会自动创建/sdcard/dictionary目录，并将res\raw目录中的 dictionary.db文件复制到/sdcard/dictionary目录中

50.说说 android 中 mvc 的具体体现
mvc是model,view,controller的缩写，mvc包含三个部分：
模型（model）对象：是应用程序的主体部分，所有的业务逻辑都应该写在该层。
视图（view）对象：是应用程序中负责生成用户界面的部分。也是在整个mvc架构中用户唯一可以看到的一层，接收用户的输入，显示处理结果。
控制器（control）对象：是根据用户的输入，控制用户界面数据显示及更新model对象状态的部分，控制器更重要的一种导航功能，响应用户出发的相关事件，交给m层处理。
android鼓励弱耦合和组件的重用，在android中mvc的具体体现如下：
1)视图（view）：一般采用xml文件进行界面的描述，使用的时候可以非常方便的引入。
2)控制层（controller）：android的控制层的重任通常落在了众多的acitvity的肩上，这句话也就暗含了不要在acitivity中写过多的代码，要通过activity交割model业务逻辑层处理，这样做的另外一个原因是android中的acitivity的响应时间是5s，如果耗时的操作放在这里，程序就很容易被回收掉。
3)模型层（model）：对数据库的操作、对网络等的操作都应该在model里面处理，当然对业务计算等操作也是必须放在的该层的。

51.请介绍下 Android 中常用的五种布局
帧布局（FrameLayout）
线性布局(LinearLayout)
表格布局(TableLayout)
相对布局(RelativeLayout)
绝对布局(AbsoluteLayout)

52.如何启用 Service ，如何停用 Service
1)startService用于启动Service、stopService停止Service。
2)bindService绑定Service，unbindService解除Service的绑定。

53.如何优化ListView
1、如果自定义适配器，那么在getView方法中要考虑方法传进来的参数contentView是否为null，如果为null就创建contentView并返回，如果不为null则直接使用。在这个方法中尽可能少创建view。
2、给contentView设置tag（setTag（）），传入一个viewHolder对象，用于缓存要显示的数据，可以达到图像数据异步加载的效果。
3、如果listview需要显示的item很多，就要考虑分页加载。比如一共要显示100条或者更多的时候，我们可以考虑先加载20条，等用户拉到列表底部的时候再去加载接下来的20条。

54.描述4 种 activity 的启动模式
1)standard ：系统的默认模式，一次跳转即会生成一个新的实例。假设有一个activity命名为MainActivity，执行语句：
startActivity(new Intent(MainActivity.this, MainActivity.class))后，MainActivity将跳转到另外一个MainActivity，也就是现在的Task栈里面有MainActivity的两个实例。按返回键后你会发现仍然是在MainActivity（第一个）里面。
2)singleTop：singleTop 跟standard 模式比较类似。如果已经有一个实例位于Activity栈的顶部时，就不产生新的实例，而只是调用Activity中的newInstance()方法。如果不位于栈顶，会产生一个新的实例。例：当MainActivity为 singleTop 模式时，执行跳转后栈里面依旧只有一个实例，如果现在按返回键程序将直接退出。
3)singleTask： singleTask模式和后面的singleInstance模式都是只创建一个实例的。在这种模式下，无论跳转的对象是不是位于栈顶的activity，程序都不会生成一个新的实例（当然前提是栈里面已经有这个实例）。这种模式相当有用，在以后的多activity开发中，经常会因为跳转的关系导致同个页面生成多个实例，这个在用户体验上始终有点不好，而如果你将对应的activity声明为 singleTask 模式，这种问题将不复存在。
4)singleInstance: 设置为 singleInstance 模式的 activity 将独占一个task（感觉task可以理解为进程），独占一个task的activity与其说是activity，倒不如说是一个应用，这个应用与其他activity是独立的，它有自己的上下文activity。

55.什么是Intent，如何使用？
Android基本的设计理念是鼓励减少组件间的耦合，因此Android提供了Intent (意图) ，Intent提供了一种通用的消息系统，它允许在你的应用程序与其它的应用程序间传递Intent来执行动作和产生事件。使用Intent可以激活Android应用的三个核心组件：活动、服务和广播接收器。
通过startActivity() orstartActivityForResult()启动一个Activity；
过 startService() 启动一个服务，或者通过bindService() 和后台服务交互；
通过广播方法(比如 sendBroadcast(),sendOrderedBroadcast(),sendStickyBroadcast())发给broadcast receivers

56.Android用的数据库是什么样的？它和sql有什么区别？为什么要用ContentProvide？它和sql的实现上有什么差别？
Adnroid用的是SQLite数据库。它和其他网络数据库类似，也是通过SQL对数据进行管理。SQLite的操作非常简单，包括数据类型在建表时也可以不指定。
使用ContentProvider 可以将数据共享给其他应用，让除本应用之外的应用也可以访问本应用的数据。它的底层是用SQLite 数据库实现的，所以其对数据做的各种操作都是以Sql实现，只是在上层提供的是Uri。

57.通过Intent传递一些二进制数据的方法有哪些?
1)使用Serializable接口实现序列化，这是Java常用的方法。
2)实现Parcelable接口，这里Android的部分类比如Bitmap类就已经实现了，同时Parcelable在Android AIDL中交换数据也很常见的。

58.对一些资源以及状态的操作保存，最好是保存在生命周期的哪个函数中进行？
onResume()恢复数据、onPause()保存数据。

59.如何一次性退出所有打开的Activity
编写一个Activity作为入口，当需要关闭程序时，可以利用Activity的SingleTop模式跳转该Activity，它上面的所有Activity都会被销毁掉。然后再将该Activity关闭。
或者再跳转时，设置intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);这样也能将上面的Activity销毁掉。

60.说说Service的生命周期？
启动Service的方式有两种，各自的生命周期也有所不同。
一、通过startService启动Service：onCreate、onStartCommand、onDestory。
二、通过bindService绑定Service：onCreate、onBind、onUnbind、onDestory。

61.什么是AIDL？AIDL是如何工作的？
AIDL(Android接口描述语言)是一种接口描述语言; 编译器可以通过aidl文件生成一段代码，通过预先定义的接口达到两个进程内部通信进程的目的. 如果需要在一个Activity中, 访问另一个Service中的某个对象, 需要先将对象转化成AIDL可识别的参数(可能是多个参数), 然后使用AIDL来传递这些参数, 在消息的接收端, 使用这些参数组装成自己需要的对象。AIDL是基于接口的，但它是轻量级的。它使用代理类在客户端和实现层间传递值.。

62.Android如何把文件存放在SDCard上？
在AndroidManifest.xml中加入访问SDCard的权限如下:
<!– 在SDCard中创建与删除文件权限 –>
<uses-permission android:name=”android.permission.MOUNT_UNMOUNT_FILESYSTEMS”/>
<!– 往SDCard写入数据权限 –>
<uses-permission android:name=”android.permission.WRITE_EXTERNAL_STORAGE”/>
要往SDCard存放文件，程序必须先判断手机是否装有SDCard，并且可以进行读写。
注意：访问SDCard必须在AndroidManifest.xml中加入访问SDCard的权限。
Environment.getExternalStorageState()方法用于获取SDCard的状态，如果手机装有SDCard，并且可以进行读写，那么方法返回的状态等于Environment.MEDIA_MOUNTED。
Environment.getExternalStorageDirectory()方法用于获取SDCard的目录。

63.注册广播有几种方式，这些方式有何优缺点？
两种。一种是通过代码注册，这种方式注册的广播会跟随程序的生命周期。二种是在AndroidManifest.xml中配置广播，这种常驻型广播当应用程序关闭后，如果有信息广播来，程序也会被系统调用自动运行。

64.什么是ANR 如何避免它?
在Android上，如果你的应用程序有一段时间响应不够灵敏，系统会向用户显示一个对话框，这个对话框称作应用程序无响应（ANR：Application Not Responding）对话框。用户可以选择让程序继续运行，但是，他们在使用你的应用程序时，并不希望每次都要处理这个对话框。因此，在程序里对响应性能的设计很重要，这样，系统不会显示ANR给用户。要避免它，应该尽量少在主线程做耗时太长的操作，应该将这些操作放在线程当中去做。

65.Android本身的api并未声明会抛出异常，则其在运行时有无可能抛出runtime异常，你遇到过吗?诺有的话会导致什么问题?如何解决?
有可能，比如空指针异常、数组下表越界等异常，这些异常抛出后可能会导致程序FC。在编写代码时应该做好检测，多考虑可能会发生错误的情况，从代码层次解决这些问题。

66.为什么要用 ContentProvider?它和 sql 的实现上有什么差别?
使用ContentProvider 可以将数据共享给其他应用，让除本应用之外的应用也可以访问本应用的数据。它的底层是用SQLite 数据库实现的，所以其对数据做的各种操作都是以Sql实现，只是在上层提供的是Uri。

67.谈谈 UI 中, Padding 和 Margin 有什么区别?
padding指内边距，表示组件内部元素距离组件边框的距离。
marin指外边距，表示组件与组件之间的距离。

68.请介绍下 Android 的数据存储方式。
Android 提供了5种方式存储数据：
1)使用SharedPreferences存储数据；
2)文件存储数据；
3)SQLite数据库存储数据；
4)使用ContentProvider存储数据；
5)网络存储数据；

Android 面试题(有详细答案)
附带答案，共100分
一、选择题（30题，每题1.5分，共45分）
1.java.io包中定义了多个流类型来实现输入和输出功能，可以从不同的角度对其进行分类,按功能分为：(c),如果为读取的内容进行处理后再输出，需要使用下列哪种流？(g)
A、输入流和输出流 B、字节流和字符流 C、节点流和处理流
D、File stream E、Pipe stream F、Random stream G、Filter stream
2.下列代码的执行结果是：（b）
public class Test3{
public static void main(String args[]){
System.out.print(100%3);
System.out.print(",");
System.out.println(100%3.0);
}
}
A、1,1
B、1,1.0
C、1.0,1
D、1.0,1.0
3.在继承中，关于构造方法的说明，下列说法错误的是（d）
　　 A、子类无条件的继承父类的无参构造方法，
　　 B、子类可以引用父类中的有参构造方法，使用super关键字，
　　 C、如果子类没有构造方法，则父类无参构造方法作为自已的构造方法，
　　 D、如果子类有无参构造方法，而父类的无参构造方法则被覆盖。
4.以下程序的运行结果为（ b）
public class IfTest{
public static void main(String args[]){
int x=3;
int y=1;
if(x==y)
System.out.println("Not equal");
else
System.out.println("Equal");
}
}
A、Not equal B、Equal C、无输出 D、编译出错
5.Java语言中字符串“学Java”所占的内存空间是(a)
A. 6个字节
B. 7个字节
C. 10个字节
D. 11个字节
6.关于下列程序段的输出结果，说法正确的是：（d ）
public class MyClass{
static int i;
public static void main(Stringargv[]){
System.out.println(i);
}
}
A、有错误，变量i没有初始化。
B、null
C、1
D、0
7.下列哪些语句关于内存回收的说明是正确的? (b )
A、程序员必须创建一个线程来释放内存
B、内存回收程序负责释放无用内存
C、内存回收程序允许程序员直接释放内存
D、内存回收程序可以在指定的时间释放内存对象
8.下面异常是属于Runtime Exception 的是（abcd）(多选)
A、ArithmeticException
B、IllegalArgumentException
C、NullPointerException
D、BufferUnderflowException
9. Math.round(11.5)等于多少(). Math.round(-11.5)等于多少(c). c
A、11 ,-11 B、11 ,-12 C、12 ,-11 D、12 ,-12
10.下列程序段的输出结果是：（b ）
void complicatedexpression_r(){
int x=20, y=30;
boolean b;
b=x>50&&y>60||x>50&&y<-60||x<-50&&y>60||x<-50&&y<-60;
System.out.println(b);
}
A、true B、false C、1 D、0
11.activity对一些资源以及状态的操作保存，最好是保存在生命周期的哪个函数中进行(d)
A、onPause() B、onCreate() C、 onResume() D、onStart()
12.Intent传递数据时，下列的数据类型哪些可以被传递（abcd）(多选)
A、Serializable B、charsequence C、Parcelable D、Bundle
13.android 中下列属于Intent的作用的是(c)
A、实现应用程序间的数据共享
B、是一段长的生命周期，没有用户界面的程序，可以保持应用在后台运行，而不会因为切换页面而消失
C、可以实现界面间的切换，可以包含动作和动作数据，连接四大组件的纽带
D、处理一个应用程序整体性的工作
14.下列属于SAX解析xml文件的优点的是(b)
A、将整个文档树在内存中，便于操作，支持删除，修改，重新排列等多种功能
B、不用事先调入整个文档，占用资源少
C、整个文档调入内存，浪费时间和空间
D、不是长久驻留在内存，数据不是持久的，事件过后，若没有保存数据，数据就会
消失
15.下面的对自定style的方式正确的是（a）
A、 <resources>
<style name="myStyle">
<itemname="android:layout_width">fill_parent</item>
</style>
</resources>
B、 <stylename="myStyle">
<itemname="android:layout_width">fill_parent</item>
</style>
C、 <resources>
<itemname="android:layout_width">fill_parent</item>
</resources>
D、 <resources>
<stylename="android:layout_width">fill_parent</style>
</resources>
16.在android中使用Menu时可能需要重写的方法有（ac）。(多选)
A、onCreateOptionsMenu()
B、onCreateMenu()
C、onOptionsItemSelected()
D、onItemSelected()
17.在SQL Server Management Studio 中运行下列T-SQL语句，其输出值（c）。
SELECT @@IDENTITY
A、可能为0.1
B、可能为3
C、不可能为-100
D、肯定为0
18.在SQL Server 2005中运行如下T-SQL语句，假定SALES表中有多行数据，执行查询之后的结果是（d）。
BEGIN TRANSACTION A
Update SALES Set qty=30WHERE qty<30
BEGIN TRANSACTION B
Update SALES Setqty=40 WHERE qty<40
Update SALES Setqty=50 WHERE qty<50
Update SALES Setqty=60 WHERE qty<60
COMMIT　TRANSACTION B
COMMIT TRANSACTION A
A、SALES表中qty列最小值大于等于30
B、SALES表中qty列最小值大于等于40
C、SALES表中qty列的数据全部为50
D、SALES表中qty列最小值大于等于60
19.在android中使用SQLiteOpenHelper这个辅助类时，可以生成一个数据库，并可以对数据库版本进行管理的方法可以是(ab)
A、getWriteableDatabase()
B、getReadableDatabase()
C、getDatabase()
D、getAbleDatabase()
20. android 关于service生命周期的onCreate()和onStart()说法正确的是(ad)(多选题)
A、当第一次启动的时候先后调用onCreate()和onStart()方法
B、当第一次启动的时候只会调用onCreate()方法
C、如果service已经启动，将先后调用onCreate()和onStart()方法
D、如果service已经启动，只会执行onStart()方法，不在执行onCreate()方法
21.下面是属于GLSurFaceView特性的是(abc)(多选)
A、管理一个surface，这个surface就是一块特殊的内存，能直接排版到android的视图
view上。
B、管理一个EGLdisplay，它能让opengl把内容渲染到上述的surface上。
C、让渲染器在独立的线程里运作，和UI线程分离。
D、可以直接从内存或者DMA等硬件接口取得图像数据
22.下面在AndroidManifest.xml文件中注册BroadcastReceiver方式正确的是(a)
A、<receiverandroid:name="NewBroad">
<intent-filter>
<action
android:name="android.provider.action.NewBroad"/>
<action>
</intent-filter>
</receiver>
B、<receiver android:name="NewBroad">
<intent-filter>
android:name="android.provider.action.NewBroad"/>
</intent-filter>
</receiver>
C、<receiver android:name="NewBroad">
<action
android:name="android.provider.action.NewBroad"/>
<action>
</receiver>
D、<intent-filter>
<receiver android:name="NewBroad">
<action>
android:name="android.provider.action.NewBroad"/>
<action>
</receiver>
</intent-filter>
23.关于ContenValues类说法正确的是(a)
A、他和Hashtable比较类似，也是负责存储一些名值对，但是他存储的名值对当中的
名是String类型，而值都是基本类型
B、他和Hashtable比较类似，也是负责存储一些名值对，但是他存储的名值对当中的
名是任意类型，而值都是基本类型
C、他和Hashtable比较类似，也是负责存储一些名值对，但是他存储的名值对当中的
名，可以为空，而值都是String类型
D、他和Hashtable比较类似，也是负责存储一些名值对，但是他存储的名值对当中
的名是String类型，而值也是String类型
24.我们都知道Hanlder是线程与Activity通信的桥梁,如果线程处理不当，你的机器
就会变得越慢，那么线程销毁的方法是(a)
A、onDestroy()
B、onClear()
C、onFinish()
D、onStop()
25.下面退出Activity错误的方法是（c）
A、finish()
B、抛异常强制退出
C、System.exit()
D、onStop()
26.下面属于android的动画分类的有(ab)(多项)
A、Tween B、FrameC、Draw D、Animation
27.下面关于Androiddvm的进程和Linux的进程,应用程序的进程说法正确的是(d)
A、DVM指dalivk的虚拟机.每一个Android应用程序都在它自己的进程中运行,不一定拥有一个独立
的Dalvik虚拟机实例.而每一个DVM都是在Linux 中的一个进程,所以说可以认为是同一个概念.
B、DVM指dalivk的虚拟机.每一个Android应用程序都在它自己的进程中运行,不一定拥有一个独立
的Dalvik虚拟机实例.而每一个DVM不一定都是在Linux 中的一个进程,所以说不是一个概念.
C、DVM指dalivk的虚拟机.每一个Android应用程序都在它自己的进程中运行,都拥有一个独立的
Dalvik虚拟机实例.而每一个DVM不一定都是在Linux 中的一个进程,所以说不是一个概念.
D、DVM指dalivk的虚拟机.每一个Android应用程序都在它自己的进程中运行,都拥有一个独立的
Dalvik虚拟机实例.而每一个DVM都是在Linux 中的一个进程,所以说可以认为是同一个概念.
28.Android项目工程下面的assets目录的作用是什么b
A、放置应用到的图片资源。
B、主要放置多媒体等数据文件
C、放置字符串，颜色，数组等常量数据
D、放置一些与UI相应的布局文件，都是xml文件
29..关于res/raw目录说法正确的是(a
A、这里的文件是原封不动的存储到设备上不会转换为二进制的格式
B、这里的文件是原封不动的存储到设备上会转换为二进制的格式
C、这里的文件最终以二进制的格式存储到指定的包中
D、这里的文件最终不会以二进制的格式存储到指定的包中
30.下列对android NDK的理解正确的是(abcd )
A、 NDK是一系列工具的集合
B、 NDK 提供了一份稳定、功能有限的 API 头文件声明。
C、使“Java+C” 的开发方式终于转正，成为官方支持的开发方式
D、 NDK 将是 Android 平台支持 C 开发的开端

二．填空题（每题2分，共20分）
1.我们用___int____来定义一个整数，用___char____来定义一个字符类型，称为原始数据类型。
2.android中常用的四个布局是framlayout，linenarlayout，relativelayout和tablelayout。
3.android 的四大组件是activiey，service，broadcast和contentprovide。
4.java.io包中的objectinputstream和objectoutputstream类主要用于对对象(Object)的读写。
5.android 中service的实现方法是：startservice和bindservice。
6.activity一般会重载7个方法用来维护其生命周期，除了onCreate(),onStart(),onDestory() 外还有onrestart,onresume,onpause,onstop。
7.android的数据存储的方式sharedpreference,文件,SQlite,contentprovider,网络。
8.当启动一个Activity并且新的Activity执行完后需要返回到启动它的Activity来执行
的回调函数是startActivityResult()。
9.请使用命令行的方式创建一个名字为myAvd,sdk版本为2.2,sd卡是在d盘的根目录下，
名字为scard.img，并指定屏幕大小HVGA.____________________________________。
10.程序运行的结果是：_____good and gbc__________。
public classExample{
　　Stringstr=new String("good");
　　char[]ch={'a','b','c'};
　　publicstatic void main(String args[]){
　　　　Exampleex=new Example();
　　　　ex.change(ex.str,ex.ch);
　　　　System.out.print(ex.str+"and ");
　　　　Sytem.out.print(ex.ch);
　　}
　　public voidchange(String str,char ch[]){
　　　　str="testok";
　　　　ch[0]='g';
　　}
}

三简答编程题（共35分）
1.在android中，请简述jni的调用过程。(8分)
1)安装和下载Cygwin，下载 Android NDK
2)在ndk项目中JNI接口的设计
3)使用C/C++实现本地方法
4)JNI生成动态链接库.so文件
5)将动态链接库复制到java工程，在java工程中调用，运行java工程即可

2.简述Android应用程序结构是哪些?（7分）
Android应用程序结构是：
Linux Kernel(Linux内核)、Libraries(系统运行库或者是c/c++核心库)、Application
Framework(开发框架包)、Applications (核心应用程序)

3. 请继承SQLiteOpenHelper实现：(10分)
1）.创建一个版本为1的“diaryOpenHelper.db”的数据库，
2）.同时创建一个 “diary” 表（包含一个_id主键并自增长，topic字符型100
长度， content字符型1000长度）
3）.在数据库版本变化时请删除diary表，并重新创建出diary表。

public class DBHelper extends SQLiteOpenHelper {

publicfinal static String DATABASENAME = "diaryOpenHelper.db";
publicfinal static int DATABASEVERSION = 1;

//创建数据库
publicDBHelper(Context context,String name,CursorFactory factory,int version)
{
super(context,name, factory, version);
}
//创建表等机构性文件
publicvoid onCreate(SQLiteDatabase db)
{
Stringsql ="create table diary"+
"("+
"_idinteger primary key autoincrement,"+
"topicvarchar(100),"+
"contentvarchar(1000)"+
")";
db.execSQL(sql);
}
//若数据库版本有更新，则调用此方法
publicvoid onUpgrade(SQLiteDatabase db,int oldVersion,int newVersion)
{

Stringsql = "drop table if exists diary";
db.execSQL(sql);
this.onCreate(db);
}
}

4.页面上现有ProgressBar控件progressBar，请用书写线程以10秒的的时间完成其进度
显示工作。（10分）
答案
public class ProgressBarStu extendsActivity {

privateProgressBar progressBar = null;
protectedvoid onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.progressbar);
//从这到下是关键
progressBar= (ProgressBar)findViewById(R.id.progressBar);

Threadthread = new Thread(new Runnable() {

@Override
publicvoid run() {
intprogressBarMax = progressBar.getMax();
try{
while(progressBarMax!=progressBar.getProgress())
{

intstepProgress = progressBarMax/10;
intcurrentprogress = progressBar.getProgress();
progressBar.setProgress(currentprogress+stepProgress);
Thread.sleep(1000);
}

}catch (InterruptedException e) {
//TODO Auto-generated catch block
e.printStackTrace();
}

}
});

thread.start();

//关键结束
}

}

一、选择题

1
2
3
4
5
6
7
8
9
10
CG
B
D
B
A
D
B
ABCD
C
B
11
12
13
14
15
16
17
18
19
20
D
ABCD
C
B
A
AC
C
D
AB
AD
21
22
23
24
25
26
27
28
29
30
ABC
A
A
A
C
AB
D
B
A
ABCD

二、填空题
1.int char
2.FrameLayout,LilnearLayout,RelativeLayout,TableLayout
3.Activity,Broadcast,Service,ContentProvide
4.ObjectInputStream ObjectOutputSteam
5.startService ,bindService
6.onRestart(),onResume(),onPause(),onStop()
7.SharedPreferences存储，文件存储，SQLite存储，ContentProvider，网络存储
8.startActivityResult()
9.adnroid create acd -n myAvd -t 8 -s HVDA - Cd:\card.img
10.good and gbc

---------------------------

1、 Android dvm的进程和Linux的进程, 应用程序的进程是否为同一个概念

DVM指dalivk的虚拟机。每一个Android应用程序都在它自己的进程中运行，都拥有一个独立的Dalvik虚拟机实例。而每一个DVM都是在Linux 中的一个进程，所以说可以认为是同一个概念

2、sim卡的EF 文件有何作用

sim卡的文件系统有自己规范，主要是为了和手机通讯，sim本身可以有自己的操作系统，EF就是作存储并和手机通讯用的

3、嵌入式操作系统内存管理有哪几种，各有何特性 ?

页式，段式，段页，用到了MMU,虚拟空间等技术

4、什么是嵌入式实时操作系统, Android 操作系统属于实时操作系统吗?

嵌入式实时操作系统是指当外界事件或数据产生时，能够接受并以足够快的速度予以处理，其处理的结果又能在规定的时间之内来控制生产过程或对处理系统作出快速响应，并控制所有实时任务协调一致运行的嵌入式操作系统。主要用于工业控制、军事设备、航空航天等领域对系统的响应时间有苛刻的要求，这就需要使用实时系统。又可分为软实时和硬实时两种，而android是基于linux内核的，因此属于软实时。

5、一条最长的短信息约占多少byte?

中文70(包括标点)，英文160个字节

6、 android中的动画有哪几类，它们的特点和区别是什么？

两种，一种是Tween动画、还有一种是Frame动画。Tween动画，这种实现方式可以使视图组件移动、放大、缩小以及产生透明度的变化；另一种Frame动画，传统的动画方法，通过顺序的播放排列好的图片来实现，类似电影。

7、handler机制的原理

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

8、说说mvc模式的原理，

它在android中的运用 MVC(Model_view_contraller)” 模型_视图_控制器”。 MVC应用程序总是由这三个部分组成。Event(事件)导致Controller改变Model或View，或者同时改变两者。只要 Controller改变了Models的数据或者属性，所有依赖的View都会自动更新。类似的，只要Controller改变了View，View会从潜在的Model中获取数据来刷新自己

（View重绘和内存泄露面试经常问的问题）

9. View的刷新:

在需要刷新的地方,使用handle.sendmessage发送信息,然后在handle的getmessage里面执行invaliate或者postinvaliate。

可以调用invalidate()和postInvalidate()这两个方法刷新

10. GC内存泄露出现情况:

1）.数据库的cursor没有关闭

2）.构造adapter时,没有使用缓存contentview 衍生listview的优化问题-----减少创建view的对象,充分使用contentview,可以使用一静态类来优化处理getview的过程/

3）.Bitmap对象不使用时采用recycle()释放内存

4）.activity中的对象的生命周期大于activity 调试方法: DDMS==> HEAPSZIE==>dataobject==>[Total Size]

11、 Activity的生命周期

public class MyActivity extends Activity { protected void onCreate(Bundle savedInstanceState); protected void onStart(); protected void onResume(); protected void onPause(); protected void onStop(); protected void onDestroy(); } 你自己写的Activity会按需要重载这些方法，onCreate是免不了的，在一个Activity正常启动的过程中，他们被调用的顺序是 onCreate -> onStart ->onResume, 在Activity被干掉的时候顺序是onPause -> onStop -> onDestroy ，这样就是一个完整的生命周期，但是有人问了，程序正运行着呢来电话了，这个程序咋办？中止了呗，如果中止的时候新出的一个Activity是全屏的那么：onPause->onStop ，恢复的时候onStart->onResume ，如果打断这个应用程序的是一个Theme为Translucent 或者Dialog 的Activity那么只是onPause ,恢复的时候onResume

12、生命周期中的各个方法中都可以做什么？

onCreate: 在这里创建界面，做一些数据的初始化工作

onStart: 到这一步变成用户可见不可交互的

onResume: 变成和用户可交互的，（在activity 栈系统通过栈的方式管理这些个Activity的最上面，运行完弹出栈，则回到上一个Activity)

onRestart：重新启动activity时调用。该活动仍在栈中，而不是启动新的活动

onPause: 到这一步是可见但不可交互的，系统会停止动画等消耗CPU 的事情从上文的描述已经知道，应该在这里保存你的一些数据,因为这个时候你的程序的优先级降低，有可能被系统收回。在这里保存的数据，应该在 onResume里读出来，注意：这个方法里做的事情时间要短，因为下一个activity不会等到这个方法完成才启动。

onstop: 变得不可见，被下一个activity覆盖了

onDestroy: 这是activity被干掉前最后一个被调用方法了，可能是外面类调用finish方法或者是系统为了节省空间将它暂时性的干掉，可以用 isFinishing()来判断它，如果你有一个Progress Dialog在线程中转动，请在onDestroy里把他cancel掉，不然等线程结束的时候，调用Dialog的cancel方法会抛异常的。

onPause，onstop， onDestroy，三种状态下 activity都有可能被系统干掉为了保证程序的正确性，你要在onPause()里写上持久层操作的代码，将用户编辑的内容都保存到存储介质上（一般都是数据库）。实际工作中因为生命周期的变化而带来的问题也很多，比如你的应用程序起了新的线程在跑，这时候中断了，你还要去维护那个线程，是暂停还是杀掉还是数据回滚，是吧？因为Activity可能被杀掉，所以线程中使用的变量和一些界面元素就千万要注意

13、让Activity变成一个窗口：Activity属性设定

你只需要设置一下Activity的主题就可以了在AndroidManifest.xml 中定义 Activity的地方一句话： Xml代码 android :theme="@android :style/Theme.Dialog" android:theme="@android :style/Theme.Dialog" 这就使你的应用程序变成对话框的形式弹出来了，或者 Xml代码 android:theme="@android :style/Theme.Translucent" android:theme="@android :style/Theme.Translucent

14、后台的Activity被系统回收怎么办：（onSaveInstanceState ）

当你的程序中某一个Activity A 在运行时中，主动或被动地运行另一个新的Activity B 这个时候A会执行

Java代码

public void onSaveInstanceState(Bundle outState) {

super.onSaveInstanceState(outState);

outState.putLong("id", 1234567890);

}

public void onSaveInstanceState(Bundle outState) {

B 完成以后又会来找A, 这个时候就有两种情况，一种是A被回收，一种是没有被回收，被回收的A就要重新调用onCreate()方法，不同于直接启动的是这回 onCreate()里是带上参数 savedInstanceState，没被收回的就还是onResume就好了。 savedInstanceState是一个Bundle对象，你基本上可以把他理解为系统帮你维护的一个Map对象。在onCreate()里你可能会用到它，如果正常启动onCreate就不会有它，所以用的时候要判断一下是否为空

Java代码

if(savedInstanceState !=null){

long id =savedInstanceState.getLong("id");

}

if(savedInstanceState !=null){ 就像官方的Notepad教程里的情况，你正在编辑某一个note，突然被中断，那么就把这个note的id记住，再起来的时候就可以根据这个id去把那个note取出来，程序就完整一些。这也是看你的应用需不需要保存什么，比如你的界面就是读取一个列表，那就不需要特殊记住什么，哦，没准你需要记住滚动条的位置.

15、四调用与被调用：我们的通信使者Intent

要说Intent了，Intent就是这个这个意图，应用程序间Intent进行交流，打个电话啦，来个电话啦都会发Intent, 这个是Android架构的松耦合的精髓部分，大大提高了组件的复用性，比如你要在你的应用程序中点击按钮，给某人打电话

Java代码 :

Intent intent = new Intent();

intent.setAction(Intent.ACTION_CALL);

intent.setData(Uri.parse("tel:"+ number));

startActivity(intent);

扔出这样一个意图，系统看到了你的意图就唤醒了电话拨号程序，打出来电话。什么读联系人，发短信啊，邮件啊，统统只需要扔出intent就好了，这个部分设计地确实很好啊。那Intent通过什么来告诉系统需要谁来接受他呢？通常使用Intent有两种方法，第一种是直接说明需要哪一个类来接收代码如下:

Java代码

Intent intent = new Intent(this,MyActivity.class);

intent.getExtras().putString("id","1"）；

startActivity(intent);

第一种方式很明显，直接指定了MyActivity为接受者,并且传了一些数据给MyActivity，在MyActivity里可以用getIntent()来的到这个intent和数据

第二种就需要先看一下AndroidMenifest中的intentfilter的配置

Xml代码

<intent-filter>

</intent-filter>

<intent-filter>

</intent-filter> 这里面配置用到了action, data, category这些东西，那么聪明的你一定想到intent里也会有这些东西，然后一匹配不就找到接收者了吗？

16.listview你是怎么优化的

17，IPC及原理

IPC是内部进程通信的简称，是共享"命名管道"的资源。Android中的IPC机制是为了让Activity和Service之间可以随时的进行交互，故在Android中该机制，只适用于Activity和Service之间的通信，类似于远程方法调用，类似于C/S模式的访问。通过定义AIDL接口文件来定义IPC接口。Servier端实现IPC接口，Client端调用IPC接口本地代理
18.Android多线程

19.Android为什么要设计4大组件，他们之间的联系

主要是为了实现MVC模式

20、DDMS与TraceView的区别？

DDMS是一个程序执行查看器，在里面你可以看见线程和堆栈等信息，TraceView是程序性能分析器

21、.在Java中如何引入C语言

可以用JNI接口来实现

22、Android国际化与本地化

internationalization （国际化）简称 i18n,因为在i和n之间还有18个字符，localization（本地化），简称L10n。一般说明一个地区的语言时，用语言_地区的形式，如 zh_CN, zh_TW. 各国语言缩写 http://www.loc.gov/standards/iso639-2/php/code_list.php 国家和地区简写 http://www.iso.org/iso/en/prods-services/iso3166ma/02iso-3166-code-lists/list-en1.html android 对i18n和L10n提供了非常好的支持。android没有专门的API来提供国际化，而是通过对不同resource的命名来达到国际化，同时这种命名方法还可用于对硬件的区分，如不同的新视屏用不同的图片

我们以不同的local和region来做一次国际化，首先values表示默认的字符串，也即当Resource找不到匹配的资源时，默认使用values文件夹下的资源，其余 drawable等资源也是同样的。当命名这些文件夹的名字时，不同的选项用-分开，而且次序必须和 andorid 文档中table http://developer.android.com/guide/topics/resources/resources-i18n.html#AlternateResources 文件夹的命名必须都是小写字符，否则在一些大小敏感的文件系统中可能会出错，如果你用大写，eclipse的adt都会自动报错。小写字母r表示region的意思。上图命名了中文简体和繁体以及默认选项，在strings.xml中除了字符串本身不一样，xml中定义该字符串的名字，id都是一样的。所以在代码或者xml中引用该资源时，只要引用名字即可或者id即可，程序启动时候Resource类回到相应的目录下去寻找正确的字符串（资源）通过在Settings中设置locale& Text 我们可以让Resource类来选择相应文件夹下的内容，选择英语时候结果如下，也即选择了 values下的strings.xml 选择 chinese(china)时，也即选了 values-zh-rcn目录下的strings.xml 选择 chinese(*)时，也即选了 values-zh-rtw目录下的strings.xml 其余手机的选项，像屏幕的像素等都可以建立相应得目录

23、在eclipse的工程中，res目录有默认几项resource，如 drawable， layout，menu，values 其余还有哪些？

res/anim/ 用来放置动画

res/xml/ 用来放置style theme等xml定义。

res/raw/ 用来放置data数据

24、Android常用的控件

单选框(RadioButton与RadioGroup)：

RadioGroup用于对单选框进行分组，相同组内的单选框只有一个单选框被选中。事件：setOnCheckedChangeListener()，处理单选框被选择事件。把RadioGroup.OnCheckedChangeListener实例作为参数传入。

多选框(CheckBox): 每个多选框都是独立的，可以通过迭代所有的多选框，然后根据其状态是否被选中在获取其值。事件：setOnCheckChangeListener()处理多选框被选择事件。把CompoundButton.OnCheckedChangeListener实例作为参数传入

下拉列表框(Spring)： Spinner.getItemAtPosition(Spinner.getSelectedItemPosition());获取下拉列表框的值。事件：setOnItemSelectedListener(),处理下拉列表框被选择事件把AdapterView.OnItemSelectedListener实例作为参数传入；

拖动条(SeekBar)： SeekBar.getProgress()获取拖动条当前值事件:setOnSeekBarChangeListener()，处理拖动条值变化事件，把SeekBar.OnSeekBarChangeListener实例作为参数传入。

菜单(Menu): 重写Activity的onCreatOptionMenu(Menu menu)方法，该方法用于创建选项菜单，当用户按下手机的"Menu"按钮时就会显示创建好的菜单，在onCreatOptionMenu(Menu Menu)方法内部可以调用Menu.add()方法实现菜单的添加。重写Activity的onMenuItemSelected()方法，该方法用于处理菜单被选择事件。

进度对话框(ProgressDialog)：创建并显示一个进度对话框：ProgressDialog.show(ProgressDialogActivity.this,"请稍等"，"数据正在加载中...."，true)；设置对话框的风格：setProgressStyle() ProgressDialog.STYLE_SPINNER 旋转进度条风格(为默认风格) ProgressDialog.STYLE_HORIZONTAL 横向进度条风格

25、Android系统架构

1、应用程序. Android会同一系列核心应用程序包一起发布，该应用程序包包括email客户端，SMS短消息程序，日历，地图，浏览器，联系人管理程序等。所有的应用程序都是使用JAVA语言编写的。

2.应用框架：开发人员也可以完全访问核心应用程序所使用的API框架。该应用程序的架构设计简化了组件的重用;任何一个应用程序都可以发布它的功能块并且任何其它的应用程序都可以使用其所发布的功能块(不过得遵循框架的安全性限制)。同样，该应用程序重用机制也使用户可以方便的替换程序组件。隐藏在每个应用后面的是一系列的服务和系统, 其中包括;

* 丰富而又可扩展的视图(Views)，可以用来构建应用程序，它包括列表(lists)，网格(grids)，文本框(text boxes)，按钮(buttons)，甚至可嵌入的web浏览器。

* 内容提供器(Content Providers)使得应用程序可以访问另一个应用程序的数据(如联系人数据库)，或者共享它们自己的数据

* 资源管理器(Resource Manager)提供非代码资源的访问，如本地字符串，图形，和布局文件( layout files )。 * 通知管理器 (Notification Manager) 使得应用程序可以在状态栏中显示自定义的提示信息。

* 活动管理器( Activity Manager) 用来管理应用程序生命周期并提供常用的导航回退功能。

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 内核也同时作为硬件和软件栈之间的抽象层

26、开机自启动程序

27、什么是Activity?

通俗一点说Activity就是一个界面，这个界面里面可以放置各种控件。Activity的界面也是用xml文件表示的，放置在res->layout下面。每生成一个新的Activity后，我们需要在AndroidManifest.xml中注册一下这个activity

28、两个Activity之间跳转时必然会执行的是哪几个方法。

onCreate() //在Activity生命周期开始时调用 onRestoreInstanceState()//用来恢复UI状态 onReStart()//当Activity重新启动时调用 onStart()//Activity对用户即将可见时调用 onResume()//当Activity与用户交互时，绘制界面 onSaveInstanceState()//activity即将移出栈顶保留UI状态时调用 onPause()//暂停当前活动activity,提交持久数据的改变，停止动画和其他占用CPU资源的东西，由于下一个activity在这个方法返回之前不会resume,所以这个方法的代码执行要快。 onStop()//activity不再可见时调用 onDestroy()//在Activity销毁钱被调用的最后一个方法。

29、横竖屏切换时候Activity的生命周期。

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

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

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

30、如何退出Activity？如何安全退出已调用多个Activity的Application？

用finish()方法退出activity.

在2.1之前，可以使用ActivityManager的restartPackage方法。它可以直接结束整个应用。在使用时需要权限android.permission.RESTART_PACKAGES。

在2.2，这个方法失效了,可使用以下几个人工的方法

1、记录打开的Activity：每打开一个Activity，就记录下来。在需要退出时，关闭每一个Activity即可。

2、发送特定广播：在需要结束应用时，发送一个特定的广播，每个Activity收到广播后，关闭即可

3、递归退出：在打开新的Activity时使用startActivityForResult，然后自己加标志，在onActivityResult中处理，递归关闭

为了编程方便，最好定义一个Activity基类，处理这些共通问题

在2.1之前，可以使用ActivityManager的restartPackage方法。它可以直接结束整个应用。在使用时需要权限android.permission.RESTART_PACKAGES。注意不要被它的名字迷惑。可是，在2.2，这个方法失效了。在2.2添加了一个新的方法，killBackground Processes()，需要权限 android.permission.KILL_BACKGROUND_PROCESSES。可惜的是，它和2.2的restartPackage一样，根本起不到应有的效果。另外还有一个方法，就是系统自带的应用程序管理里，强制结束程序的方法，forceStopPackage()。它需要权限android.permission.FORCE_STOP_PACKAGES。并且需要添加android:sharedUserId="android.uid.system"属性。同样可惜的是，该方法是非公开的，他只能运行在系统进程，第三方程序无法调用。因为需要在Android.mk中添加LOCAL_CERTIFICATE := platform。而Android.mk是用于在Android源码下编译程序用的。从以上可以看出，在2.2，没有办法直接结束一个应用，而只能用自己的办法间接办到。现提供几个方法，供参考： 1、抛异常强制退出：该方法通过抛异常，使程序Force Close。验证可以，但是，需要解决的问题是，如何使程序结束掉，而不弹出Force Close的窗口。 2、记录打开的Activity：每打开一个Activity，就记录下来。在需要退出时，关闭每一个Activity即可。 3、发送特定广播：在需要结束应用时，发送一个特定的广播，每个Activity收到广播后，关闭即可。 4、递归退出在打开新的Activity时使用startActivityForResult，然后自己加标志，在onActivityResult中处理，递归关闭。除了第一个，都是想办法把每一个Activity都结束掉，间接达到目的。但是这样做同样不完美。你会发现，如果自己的应用程序对每一个Activity都设置了nosensor，在两个Activity结束的间隙，sensor可能有效了。但至少，我们的目的达到了，而且没有影响用户使用。为了编程方便，最好定义一个Activity基类，处理这些共通问题

31、两个Activity之间怎么传递数据？

在Intent的对象中增加要传递的参数既可。在Intent的对象的请求中加入键值对，对象名字.putExtra（"键值对的名字","键值对的值"）；在另一个Activity中将Intent请求中的数据取出来： Intent intent=getIntent（）；// String value = intent.getStringExtra("testIntent");//将testIntent对应的值赋值给value

32、怎么在启动一个Activity时就启动一个service？

将启动Service的语句放在onCreate()方法中。

33、同一个程序，但不同的Activity是否可以放在不同的Task任务栈中？

可以放在不同的Task中。需要为不同的activity设置不同的taskaffinity属性，启动activity的Intent需要包含FLAG_ACTIVITY_NEW_TASK标记

34、 Activity怎么和service绑定，怎么在activity中启动自己对应的service？

1、Activity能进行绑定得益于Service的接口。为了支持Service的绑定，实现onBind方法。

2、Service和Activity的连接可以用ServiceConnection来实现。你需要实现一个新的ServiceConnection，重写onServiceConnected和onServiceDisconnected方法，一旦连接建立，你就能得到Service实例的引用。

3、执行绑定，调用bindService方法，传入一个选择了要绑定的Service的Intent（显式或隐式）和一个你实现了的ServiceConnection实例

35 、什么是Service以及描述下它的生命周期。

Android Service是运行在后台的代码，不能与用户交互，可以运行在自己的进程，也可以运行在其他应用程序进程的上下文里。需要通过某一个Activity或者其他Context对象来调用， Context.startService() 和 Context.bindService()。如果在Service执行耗时的操作需要启动一个新线程来执行。 Android Service只继承了onCreate(),onStart(),onDestroy()三个方法，当我们第一次启动Service时，先后调用了onCreate(),onStart()这两个方法，当停止Service时，则执行onDestroy()方法，这里需要注意的是，如果Service已经启动了，当我们再次启Service时，不会在执行onCreate()方法，而是直接执行onStart()方法

36、 Service有哪些启动方法，有什么区别，怎样停用Service？

两种启动Service的方式Context.startService() 和 Context.bindService()。区别为 Context.startService()：Service会经历onCreate -> onStart（如果Service还没有运行，则android先调用onCreate()然后调用onStart()；如果Service已经运行，则只调用onStart()，所以一个Service的onStart方法可能会重复调用多次）；stopService的时候直接onDestroy，如果是调用者自己直接退出而没有调用stopService的话，Service会一直在后台运行。该Service的调用者再启动起来后可以通过stopService关闭Service Context.bindService()：Service会经历onCreate() -> onBind()，onBind将返回给客户端一个IBind接口实例，IBind允许客户端回调服务的方法，比如得到Service运行的状态或其他操作。这个时候把调用者（Context，例如Activity）会和Service绑定在一起，Context退出了，Srevice就会调用onUnbind -> onDestroyed相应退出，所谓绑定在一起就共存亡了。停用service使用 context.stopService()

37、不用service，B页面为音乐播放，从A跳转到B，再返回，如何使音乐继续播放？

a 使用startActivityForResult() 方法开启b，b类结束时调用finish();

a类的intent有一个子activity结束事件onActivityResult()，在事件里继续播放音乐

38、什么是IntentService？有何优点？

IntentService也是一个Service，是Service的子类， IntentService和Service有所不同，通过Looper和Thread来解决标准Service中处理逻辑的阻塞问题。优点：Acitivity的进程，当处理Intent的时候，会产生一个对应的Service Android的进程处理器现在会尽可能的不kill掉你非常容易使用（看自己写的日历中IntentService的应用）

39、什么时候使用Service？

比如播放多媒体的时候用户启动了其他Activity这个时候程序要在后台继续播放，比如检测SD卡上文件的变化，再或者在后台记录你地理信息位置的改变等等，总之服务嘛，总是藏在后头的。

40、请描述一下Intent 和 Intent Filter

ntent在Android中被翻译为"意图"，熟语来讲就是目的，他们是三种应用程序基本组件—activity，service和broadcast receiver之间互相激活的手段。在调用Intent名称时使用ComponentName也就是类的全名时为显示调用。这种方式一般用于应用程序的内部调用，因为你不一定会知道别人写的类的全名。我们来看看隐式Intent怎么用？首先我们先配置我们的Activity的Intent Filter <intent-filter> <action android:name="com.example.project.SHOW_CURRENT" /> </intent-filter> 这样在调用的时候指定Intent的action，系统就是自动的去对比是哪个intent-filter符合我们的Activity，找到后就会启动Activity。一个intent filter是IntentFilter类的实例, 但是它一般不出现在代码中,而是出现在android Manifest文件中, 以<intent-filter>的形式. (有一个例外是broadcast receiver的intent filter是使用Context.registerReceiver()来动态设定的, 其intent filter也是在代码中创建的.) 一个filter有action, data, category等字段. 一个隐式intent为了能被某个intent filter接受, 必须通过3个测试. 一个intent为了被某个组件接受, 则必须通过它所有的intent filter中的一个
41、Intent传递数据时，可以传递哪些类型数据？

Intent间传送数据一般有两种常用的办法：
1.extra 2.data. extra可以用Intent.putExtra放入数据。新启动的Activity可用Intent.getExtras取出来Bundle, 然后用Bundles.getLong, getInt, getBoolean, getString等函数来取放进入的值。而data则是传输url。url可以是指我们熟悉的http, ftp 等网络地址，也可以指content来指向ContentProvider提供的资源。Intent.setData可以放入数据，Intent.getData可以取出数据
42、说说Activity，Intent，Service是什么关系。

一个Activity通常是一个单独的屏幕，每一个Activity都被实现为一个单独的类，这些类都是从Activity基类中继承来的，Activity类会显示由视图控件组成的用户接口，并对视图控件的事件做出响应。 Intent的调用是用来进行架构屏幕之间的切换的。Intent是描述应用想要做什么。Intent数据结构中两个最重要的部分是动作和动作对应的数据，一个动作对应一个动作数据。 Android Service是运行在后台的代码，不能与用户交互，可以运行在自己的进程，也可以运行在其他应用程序进程的上下文里。需要通过某一个Activity或者其他Context对象来调用。 Activity跳转到Activity，Activity启动Service，Service打开Activity都需要Intent表明跳转的意图，以及传递参数，Intent是这些组件间信号传递的承载者。
43、请描述一下Broadcast Receiver。

Broadcast Receiver用于接收并处理广播通知（broadcast announcements）。多数的广播是系统发起的，如地域变换、电量不足、来电来信等。程序也可以播放一个广播。程序可以有任意数量的 broadcast receivers来响应它觉得重要的通知。broadcast receiver可以通过多种方式通知用户：启动activity、使用NotificationManager、开启背景灯、振动设备、播放声音等，最典型的是在状态栏显示一个图标，这样用户就可以点它打开看通知内容。通常我们的某个应用或系统本身在某些事件（电池电量不足、来电来短信）来临时会广播一个Intent出去，我们可以利用注册一个Broadcast Receiver来监听到这些Intent并获取Intent中的数据。
44、在manifest和代码中如何注册和使用 broadcast receiver 。

1）在AndroidManifest.xml中注册
<receiver android:name="Receiver1">
<intent-filter>

<action android:name="com.forrest.action.mybroadcast"/>
</intent-filter>
</receiver>
2）在代码中注册
1. IntentFilter filter = new IntentFilter("com.forrest.action.mybroadcast"); // 和广播中Intent的action对应
2. MyBroadcastReceiver br = new MyBroadcastReceiver();
3. registerReceiver(new MyBroadcastReceiver(), filter);
45、请介绍下ContentProvider是如何实现数据共享的。

ContentProvider是通过提供Uri来实现数据共享
46、请介绍下Android的数据存储方式。

Android提供了5种方式存储数据：
使用SharedPreferences存储数据；
文件存储数据；
SQLite数据库存储数据；
使用ContentProvider存储数据；
网络存储数据
一：使用SharedPreferences存储数据
首先说明SharedPreferences存储方式，它是 Android提供的用来存储一些简单配置信息的一种机制，例如：登录用户的用户名与密码。其采用了Map数据结构来存储数据，以键值的方式存储，可以简单的读取与写入，
具体实例如下：
void ReadSharedPreferences(){
String strName,strPassword;
SharedPreferences user = getSharedPreferences(“user_info”,0);
strName = user.getString(“NAME”,””);
strPassword = user getString(“PASSWORD”,””); }
void WriteSharedPreferences(String strName,String strPassword){
SharedPreferences user = getSharedPreferences(“user_info”,0);
uer.edit();
user.putString(“NAME”, strName);
user.putString(“PASSWORD” ,strPassword);
user.commit(); }
数据读取与写入的方法都非常简单，只是在写入的时候有些区别：先调用edit()使其处于编辑状态，然后才能修改数据，最后使用commit()提交修改的数据。实际上SharedPreferences是采用了XML格式将数据存储到设备中，在DDMS中的File Explorer中的/data/data/<package name>/shares_prefs下。使用SharedPreferences是有些限制的：只能在同一个包内使用，不能在不同的包之间使用

二：文件存储数据文件存储方式是一种较常用的方法，在Android中读取/写入文件的方法，与 Java中实现I/O的程序是完全一样的，提供了openFileInput()和openFileOutput()方法来读取设备上的文件。具体实例如下:
String fn = “moandroid.log”;
FileInputStream fis = openFileInput(fn);
FileOutputStream fos = openFileOutput(fn,Context.MODE_PRIVATE);
三：网络存储数据网络存储方式，需要与Android 网络数据包打交道，关于Android 网络数据包的详细说明，请阅读Android SDK引用了Java SDK的哪些package？。
四：ContentProvider
1、ContentProvider简介当应用继承ContentProvider类，并重写该类用于提供数据和存储数据的方法，就可以向其他应用共享其数据。虽然使用其他方法也可以对外共享数据，但数据访问方式会因数据存储的方式而不同，如：采用文件方式对外共享数据，需要进行文件操作读写数据；采用sharedpreferences共享数据，需要使用sharedpreferences API读写数据。而使用ContentProvider共享数据的好处是统一了数据访问方式。
2、Uri类简介 Uri代表了要操作的数据，Uri主要包含了两部分信息：1.需要操作的ContentProvider ，2.对ContentProvider中的什么数据进行操作，一个Uri由以下几部分组成： 1.scheme：ContentProvider（内容提供者）的scheme已经由Android所规定为：content://… 2.主机名（或Authority）：用于唯一标识这个ContentProvider，外部调用者可以根据这个标识来找到它。 3.路径（path）：可以用来表示我们要操作的数据，路径的构建应根据业务而定，如下：
要操作contact表中id为10的记录，可以构建这样的路径:/contact/10 要操作contact表中id为10的记录的name字段， contact/10/name 要操作contact表中的所有记录，可以构建这样的路径:/contact? 要操作的数据不一定来自数据库，也可以是文件等他存储方式，如下: 要操作xml文件中contact节点下的name节点，可以构建这样的路径：/contact/name 如果要把一个字符串转换成Uri，可以使用Uri类中的parse()方法，如下：
Uri uri = Uri.parse("content://com.changcheng.provider.contactprovider/contact")
3、UriMatcher、ContentUrist和ContentResolver简介因为Uri代表了要操作的数据，所以我们很经常需要解析Uri，并从 Uri中获取数据。Android系统提供了两个用于操作Uri的工具类，分别为UriMatcher 和ContentUris 。掌握它们的使用，会便于我们的开发工作。 UriMatcher：用于匹配Uri，它的用法如下： 1.首先把你需要匹配Uri路径全部给注册上，如下： //常量UriMatcher.NO_MATCH表示不匹配任何路径的返回码(-1)。 UriMatcher uriMatcher = new UriMatcher(UriMatcher.NO_MATCH); //如果match()方法匹配content://com.changcheng.sqlite.provider.contactprovider /contact路径，返回匹配码为1 uriMatcher.addURI(“com.changcheng.sqlite.provider.contactprovider”, “contact”, 1);//添加需要匹配uri，如果匹配就会返回匹配码 //如果match()方法匹配 content://com.changcheng.sqlite.provider.contactprovider/contact/230路径，返回匹配码为2 uriMatcher.addURI(“com.changcheng.sqlite.provider.contactprovider”, “contact/#”, 2);//#号为通配符 2.注册完需要匹配的Uri后，就可以使用uriMatcher.match(uri)方法对输入的Uri进行匹配，如果匹配就返回匹配码，匹配码是调用 addURI()方法传入的第三个参数，假设匹配 content://com.changcheng.sqlite.provider.contactprovider/contact路径，返回的匹配码为1。
ContentUris：用于获取Uri路径后面的ID部分，它有两个比较实用的方法： withAppendedId(uri, id)用于为路径加上ID部分 parseId(uri)方法用于从路径中获取ID部分 ContentResolver：当外部应用需要对ContentProvider中的数据进行添加、删除、修改和查询操作时，可以使用 ContentResolver 类来完成，要获取ContentResolver 对象，可以使用Activity提供的getContentResolver()方法。 ContentResolver使用insert、delete、update、query方法，来操作数据

47、为什么要用ContentProvider？它和sql的实现上有什么差别？

使用ContentProvider可以将数据共享给其他应用，让除本应用之外的应用也可以访问本应用的数据。它的底层是用SQLite数据库实现的，所以其对数据做的各种操作都是以Sql实现，只是在上层提供的是Uri

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

49、谈谈UI中， Padding和Margin有什么区别？

Padding是文字相对于边框，而Margin是边框相对于父窗体
50、请解释下在单线程模型中Message、Handler、Message Queue、Looper之间的关系

答：简单的说，Handler获取当前线程中的looper对象，looper用来从存放Message的MessageQueue中取出Message，再有Handler进行Message的分发和处理. Message Queue(消息队列)：用来存放通过Handler发布的消息，通常附属于某一个创建它的线程，可以通过Looper.myQueue()得到当前线程的消息队列 Handler：可以发布或者处理一个消息或者操作一个Runnable，通过Handler发布消息，消息将只会发送到与它关联的消息队列，然也只能处理该消息队列中的消息 Looper：是Handler和消息队列之间通讯桥梁，程序组件首先通过Handler把消息传递给Looper，Looper把消息放入队列。Looper也把消息队列里的消息广播给所有的 Handler：Handler接受到消息后调用handleMessage进行处理 Message：消息的类型，在Handler类中的handleMessage方法中得到单个的消息进行处理在单线程模型下，为了线程通信问题，Android设计了一个Message Queue(消息队列)，线程间可以通过该Message Queue并结合Handler和Looper组件进行信息交换。下面将对它们进行分别介绍：
1. Message
Message消息，理解为线程间交流的信息，处理数据后台线程需要更新UI，则发送Message内含一些数据给UI线程。
2. Handler Handler处理者，是Message的主要处理者，负责Message的发送，Message内容的执行处理。后台线程就是通过传进来的 Handler对象引用来sendMessage(Message)。而使用Handler，需要implement 该类的 handleMessage(Message)方法，它是处理这些Message的操作内容，例如Update UI。通常需要子类化Handler来实现handleMessage方法。
3. Message Queue Message Queue消息队列，用来存放通过Handler发布的消息，按照先进先出执行。每个message queue都会有一个对应的Handler。Handler会向message queue通过两种方法发送消息：sendMessage或post。这两种消息都会插在message queue队尾并按先进先出执行。但通过这两种方法发送的消息执行的方式略有不同：通过sendMessage发送的是一个message对象,会被 Handler的handleMessage()函数处理；而通过post方法发送的是一个runnable对象，则会自己执行。
4. Looper Looper是每条线程里的Message Queue的管家。Android没有Global的Message Queue，而Android会自动替主线程(UI线程)建立Message Queue，但在子线程里并没有建立Message Queue。所以调用Looper.getMainLooper()得到的主线程的Looper不为NULL，但调用Looper.myLooper() 得到当前线程的Looper就有可能为NULL。对于子线程使用Looper，API Doc提供了正确的使用方法：这个Message机制的大概流程：
1. 在Looper.loop()方法运行开始后，循环地按照接收顺序取出Message Queue里面的非NULL的Message。
2. 一开始Message Queue里面的Message都是NULL的。当Handler.sendMessage(Message)到Message Queue，该函数里面设置了那个Message对象的target属性是当前的Handler对象。随后Looper取出了那个Message，则调用该Message的target指向的Hander的dispatchMessage函数对Message进行处理。在dispatchMessage方法里，如何处理Message则由用户指定，三个判断，优先级从高到低： 1) Message里面的Callback，一个实现了Runnable接口的对象，其中run函数做处理工作； 2) Handler里面的mCallback指向的一个实现了Callback接口的对象，由其handleMessage进行处理； 3) 处理消息Handler对象对应的类继承并实现了其中handleMessage函数，通过这个实现的handleMessage函数处理消息。由此可见，我们实现的handleMessage方法是优先级最低的！
3. Handler处理完该Message (update UI) 后，Looper则设置该Message为NULL，以便回收！在网上有很多文章讲述主线程和其他子线程如何交互，传送信息，最终谁来执行处理信息之类的，个人理解是最简单的方法——判断Handler对象里面的Looper对象是属于哪条线程的，则由该线程来执行
1. 当Handler对象的构造函数的参数为空，则为当前所在线程的Looper；
2. Looper.getMainLooper()得到的是主线程的Looper对象，Looper.myLooper()得到的是当前线程的Looper对象

51、 AIDL的全称是什么？如何工作？能处理哪些类型的数据？

AIDL是一种接口定义语言，用于约束两个进程间的通信规则，供编译器生成代码，实现Android设备上的进程间通信。进程之间的通信信息首先会被转换成AIDL协议消息，然后发送给对方，对方受到AIDL协议消息后再转换成相应的对象。 AIDL支持的类型包括Java基础类型和String，List，Map，CharSequence，如果使用自定义类型，必须实现Parcelable接口
52、请解释下Android程序运行时权限与文件系统权限的区别。

运行时 Dalvik( android授权) 文件系统 linux 内核授权
53、系统上安装了多种浏览器，能否指定某浏览器访问指定页面？

通过直接发送Uri把参数带过去，或者通过manifest里的intentfilter里的data属性
在action 赋值为”android.intent.action.VIEW“ 时可接收如下scheme 为"http" 等等类型的data 。所以突发奇想，启动该程序后，指定action 及Uri ，即访问指定网页
54、对多线程的运用和理解，及多线程之间handle的传值

55、对android虚拟机的理解，包括内存管理机制垃圾回收机制。
56、 Framework工作方式及原理，Activity是如何生成一个view的，机制是什么。
57、 android本身的一些限制，比如apk包大小限制，读取大文件时的时间

58、如何加载的音乐信息，如何改善其效率。

Android系统提供了MediaScanner，MediaProvider，MediaStore等接口，并且提供了一套数据库表格，通过Content Provider的方式提供给用户。当手机开机或者有SD卡插拔等事件发生时，系统将会自动扫描SD卡和手机内存上的媒体文件，如audio，video，图片等，将相应的信息放到定义好的数据库表格中。改善效率可以从界面需要查询必备数据，不需要的不进行查询
59、 ListView如何提高其效率？

答：1、如果自定义适配器，那么在getView方法中要考虑方法传进来的参数contentView是否为null，如果为null就创建contentView并返回，如果不为null则直接使用。在这个方法中尽可能少创建view。 2、给contentView设置tag（setTag（）），传入一个viewHolder对象，用于缓存要显示的数据，可以达到图像数据异步加载的效果。 3、如果listview需要显示的item很多，就要考虑分页加载。比如一共要显示100条或者更多的时候，我们可以考虑先加载20条，等用户拉到列表底部的时候再去加载接下来的20条
60、启动应用后，改变系统语言，应用的语言会改变么？

不会
61、启动一个程序，可以主界面点击图标进入，也可以从一个程序中跳转过去，二者有什么区别？

从主界面启动一个应用程序是通过快捷方式直接调用mainActivity启动的，从其他应用程序调用需要隐式的通过Action或者在Intent中需要使用setClass(),且要写明包路径
62 Android程序与Java程序的区别？

android程序是Java编写的，但程序使用的android开发的API，就是andriod的库。
63、Android中Task任务栈的分配。

64、在Android中，怎么节省内存的使用，怎么主动回收内存？
65、不同工程中的方法是否可以相互调用？
66、在Android中是如何实现判断区分通话记录中的电话状态，去电，来电、未接来电？
67、 dvm的进程和Linux的进程, 应用程序的进程是否为同一个概念

DVM指dalivk的虚拟机.每一个Android应用程序都在它自己的进程中运行,都拥有一个独立的 Dalvik虚拟机实例.而每一个DVM都是在Linux中的一个进程,所以说可以认为是同一个概念.
68、如何判断是否有SD卡？

在程序中访问SDCard，你需要申请访问SDCard的权限
在AndroidManifest.xml中加入访问SDCard的权限如下: 
<uses-permission android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEMS"/> 
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/> Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED) Environment.getExternalStorageState()方法用于获取SDCard的状态，如果手机装有SDCard，并且可以进行读写，那么方法返回的状态等于Environment.MEDIA_MOUNTED

69、im卡的EF 文件有何作用

SIM卡的文件系统有自己规范,主要是为了和手机通讯,SIM卡本身可以有自己的操作系统,EF就是作存储并和手机通讯用的
70、 Linux中跨进程通信的几种方式

71、谈对Android NDK的理解。

Android NDK是一套工具，允许Android应用开发者嵌入从C、C++源代码文件编译来的本地机器代码到各自的应用软件包中。
72、谈谈Android的优点和不足之处

73、什么是嵌入式实时操作系统, Android 操作系统属于实时操作系统吗

一般只是希望在View发生改变时对UI进行重绘。你只需在Activity中显式地调用View对象中的invalidate()方法即可。系统会自动调用 View的onDraw()方法
75、简单描述下Android 数字签名。
76、什么是ANR 如何避免它

答：ANR：Application Not Responding。在Android中，活动管理器和窗口管理器这两个系统服务负责监视应用程序的响应，当用户操作的在5s内应用程序没能做出反应，BroadcastReceiver在10秒内没有执行完毕，就会出现应用程序无响应对话框，这既是ANR。避免方法：Activity应该在它的关键生命周期方法（如onCreate()和onResume()）里尽可能少的去做创建操作。潜在的耗时操作，例如网络或数据库操作，或者高耗时的计算如改变位图尺寸，应该在子线程里（或者异步方式）来完成。主线程应该为子线程提供一个Handler，以便完成时能够提交给主线程
在Android中，活动管理器和窗口管理器这两个系统服务负责监视应用程序的响应。当出现下列情况时，Android就会显示ANR对话框了：对输入事件(如按键、触摸屏事件)的响应超过5秒意向接受器(intentReceiver)超过10秒钟仍未执行完毕 Android应用程序完全运行在一个独立的线程中(例如main)。这就意味着，任何在主线程中运行的，需要消耗大量时间的操作都会引发ANR。因为此时，你的应用程序已经没有机会去响应输入事件和意向广播(Intent broadcast)。因此，任何运行在主线程中的方法，都要尽可能的只做少量的工作。特别是活动生命周期中的重要方法如onCreate()和 onResume()等更应如此。潜在的比较耗时的操作，如访问网络和数据库;或者是开销很大的计算，比如改变位图的大小，需要在一个单独的子线程中完成(或者是使用异步请求，如数据库操作)。但这并不意味着你的主线程需要进入阻塞状态已等待子线程结束 -- 也不需要调用Therad.wait()或者Thread.sleep()方法。取而代之的是，主线程为子线程提供一个句柄(Handler)，让子线程在即将结束的时候调用它(xing:可以参看Snake的例子，这种方法与以前我们所接触的有所不同)。使用这种方法涉及你的应用程序，能够保证你的程序对输入保持良好的响应，从而避免因为输入事件超过5秒钟不被处理而产生的ANR。这种实践需要应用到所有显示用户界面的线程，因为他们都面临着同样的超时问题
77、handler机制的原理

Andriod提供了Handler和Looper来满足线程间的通信.Handler先进先出原则.Looper类用来管理特定线程内对象之间的消息交换(Message Exchange).
1)Looper: 一个线程可以产生一个Looper对象,由它来管理此线程里的Message Queue(消息队列).
2)Handler:你可以构造Handler对象来与Looper沟通,以便push新消息到Message Queue里;或者接收Looper从Message Queue取出)所送来的消息.
android中线程与线程，进程与进程之间如何通信。线程通信使用Handler，
78、 android中有哪几种解析xml的类，官方推荐哪种？以及它们的原理和区别

DOM优点：
1. XML树在内存中完整存储，因此可以直接修改其数据和结构。
2.可以通过该解析器随时访问XML树中的任何一个节点。
3.DOM解析器的API在使用上也相对比较简单。缺点：如果XML文档体积比较大时，将文档读入内存是非常消耗系统资源的。使用场景： DOM 是用与平台和语言无关的方式表示 XML 文档的官方 W3C 标准。DOM 是以层次结构组织的节点的集合。这个层次结构允许开发人员在树中寻找特定信息。分析该结构通常需要加载整个文档和构造层次结构，然后才能进行任何工作。DOM是基于对象层次结构的。
SAX解析优点：
SAX 对内存的要求比较低，因为它让开发人员自己来决定所要处理的标签。特别是当开发人员只需要处理文档中所包含的部分数据时，SAX 这种扩展能力得到了更好的体现。缺点：用SAX方式进行XML解析时，需要顺序执行，所以很难访问到同一文档中的不同数据。此外，在基于该方式的解析编码过程也相对复杂。使用场景：对于含有数据量十分巨大，而又不用对文档的所有数据进行遍历或者分析的时候，使用该方法十分有效。该方法不用将整个文档读入内存，而只需读取到程序所需的文档标签处即可
79、NotifactionManager使用原理

1. 通过getSystemService方法获得一个NotificationManager对象。 2. 创建一个Notification对象。每一个Notification对应一个Notification对象。在这一步需要设置显示在屏幕上方状态栏的通知消息、通知消息前方的图像资源ID和发出通知的时间。一般为当前时间。 3. 由于Notification可以与应用程序脱离。也就是说，即使应用程序被关闭，Notification仍然会显示在状态栏中。当应用程序再次启动后，又可以重新控制这些Notification。如清除或替换它们。因此，需要创建一个PendingIntent对象。该对象由Android系统负责维护，因此，在应用程序关闭后，该对象仍然不会被释放。 4. 使用Notification类的setLatestEventInfo方法设置Notification的详细信息。 5. 使用NotificationManager类的notify方法显示Notification消息。在这一步需要指定标识Notification的唯一ID。这个ID必须相对于同一个NotificationManager对象是唯一的，否则就会覆盖相同ID的Notificaiton
80、 activityy的启动模式有哪些？是什么含义？

答：在android里，有4种activity的启动模式，分别为：
“standard” (默认)
“singleTop”
“singleTask”
“singleInstance”
它们主要有如下不同：
1. 如何决定所属task “standard”和”singleTop”的activity的目标task，和收到的Intent的发送者在同一个task内，除非intent包括参数FLAG_ACTIVITY_NEW_TASK。如果提供了FLAG_ACTIVITY_NEW_TASK参数，会启动到别的task里。 “singleTask”和”singleInstance”总是把activity作为一个task的根元素，他们不会被启动到一个其他task里。
2. 是否允许多个实例 “standard”和”singleTop”可以被实例化多次，并且存在于不同的task中，且一个task可以包括一个activity的多个实例； “singleTask”和”singleInstance”则限制只生成一个实例，并且是task的根元素。 singleTop要求如果创建intent的时候栈顶已经有要创建的Activity的实例，则将intent发送给该实例，而不发送给新的实例。
3. 是否允许其它activity存在于本task内 “singleInstance”独占一个task，其它activity不能存在那个task里；如果它启动了一个新的activity，不管新的activity的launch mode 如何，新的activity都将会到别的task里运行（如同加了FLAG_ACTIVITY_NEW_TASK参数）。而另外三种模式，则可以和其它activity共存。
4. 是否每次都生成新实例 “standard”对于没一个启动Intent都会生成一个activity的新实例； “singleTop”的activity如果在task的栈顶的话，则不生成新的该activity的实例，直接使用栈顶的实例，否则，生成该activity的实例。比如现在task栈元素为A-B-C-D（D在栈顶），这时候给D发一个启动intent，如果D是 “standard”的，则生成D的一个新实例，栈变为A－B－C－D－D。如果D是singleTop的话，则不会生产D的新实例，栈状态仍为A-B-C-D 如果这时候给B发Intent的话，不管B的launchmode是”standard” 还是 “singleTop” ，都会生成B的新实例，栈状态变为A-B-C-D-B。 “singleInstance”是其所在栈的唯一activity，它会每次都被重用。 “singleTask”如果在栈顶，则接受intent，否则，该intent会被丢弃，但是该task仍会回到前台。当已经存在的activity实例处理新的intent时候，会调用onNewIntent()方法如果收到intent生成一个activity实例，那么用户可以通过back键回到上一个状态；如果是已经存在的一个activity来处理这个intent的话，用户不能通过按back键返回到这之前的状态
81、什么情况会导致Force Close ？如何避免如何避免如何避免如何避免？能否捕获导致其的异常

答：程序出现异常，比如nullpointer。避免：编写程序时逻辑连贯，思维缜密。能捕获异常，在logcat中能看到异常信息
82、请介绍下ContentProvider是如何实现数据共享的？

一个程序可以通过实现一个Content provider的抽象接口将自己的数据完全暴露出去，而且Content providers是以类似数据库中表的方式将数据暴露。Content providers存储和检索数据，通过它可以让所有的应用程序访问到，这也是应用程序之间唯一共享数据的方法。要想使应用程序的数据公开化，可通过2种方法：创建一个属于你自己的Content provider或者将你的数据添加到一个已经存在的Content provider中，前提是有相同数据类型并且有写入Content provider的权限。如何通过一套标准及统一的接口获取其他应用程序暴露的数据？ Android提供了ContentResolver，外界的程序可以通过ContentResolver接口访问ContentProvider提供的数据
83、Thread 和service的区别

答：servie是系统的组件，它由系统进程托管（servicemanager）；它们之间的通信类似于client和server，是一种轻量级的ipc通信，这种通信的载体是binder，它是在linux层交换信息的一种ipc。而thread是由本应用程序托管。 1). Thread：Thread 是程序执行的最小单元，它是分配CPU的基本单位。可以用 Thread 来执行一些异步的操作。 2). Service：Service 是android的一种机制，当它运行的时候如果是Local Service，那么对应的 Service 是运行在主进程的 main 线程上的。如：onCreate，onStart 这些函数在被系统调用的时候都是在主进程的 main 线程上运行的。如果是Remote Service，那么对应的 Service 则是运行在独立进程的 main 线程上。既然这样，那么我们为什么要用 Service 呢？其实这跟 android 的系统机制有关，我们先拿 Thread 来说。Thread 的运行是独立于 Activity 的，也就是说当一个 Activity 被 finish 之后，如果你没有主动停止 Thread 或者 Thread 里的 run 方法没有执行完毕的话，Thread 也会一直执行。因此这里会出现一个问题：当 Activity 被 finish 之后，你不再持有该 Thread 的引用。另一方面，你没有办法在不同的 Activity 中对同一 Thread 进行控制。举个例子：如果你的 Thread 需要不停地隔一段时间就要连接服务器做某种同步的话，该 Thread 需要在 Activity 没有start的时候也在运行。这个时候当你 start 一个 Activity 就没有办法在该 Activity 里面控制之前创建的 Thread。因此你便需要创建并启动一个 Service ，在 Service 里面创建、运行并控制该 Thread，这样便解决了该问题（因为任何 Activity 都可以控制同一 Service，而系统也只会创建一个对应 Service 的实例）。因此你可以把 Service 想象成一种消息服务，而你可以在任何有 Context 的地方调用 Context.startService、Context.stopService、Context.bindService，Context.unbindService，来控制它，你也可以在 Service 里注册 BroadcastReceiver，在其他地方通过发送 broadcast 来控制它，当然这些都是 Thread 做不到的
84、Android本身api并未声明会抛出异常，那么它在运行时有无可能会抛出runtime 异常

比如nullpointerException。我遇到过，比如textview.setText()时，textview没有初始化。会导致程序无法正常运行出现forceclose。打开控制台查看logcat信息找出异常信息并修改程序
85、IntentService有何优点？

答：Acitivity的进程，当处理Intent的时候，会产生一个对应的Service； Android的进程处理器现在会尽可能的不kill掉你；非常容易使用

86、AIDL的全称是什么？？？？如何工作？能处理哪些类型的数据？

答：全称是：Android Interface Define Language 在Android中, 每个应用程序都可以有自己的进程. 在写UI应用的时候, 经常要用到Service. 在不同的进程中, 怎样传递对象呢?显然, Java中不允许跨进程内存共享. 因此传递对象, 只能把对象拆分成操作系统能理解的简单形式, 以达到跨界对象访问的目的. 在J2EE中,采用RMI的方式, 可以通过序列化传递对象. 在Android中, 则采用AIDL的方式. 理论上AIDL可以传递Bundle,实际上做起来却比较麻烦。 AIDL(AndRoid接口描述语言)是一种借口描述语言; 编译器可以通过aidl文件生成一段代码，通过预先定义的接口达到两个进程内部通信进程的目的. 如果需要在一个Activity中, 访问另一个Service中的某个对象, 需要先将对象转化成AIDL可识别的参数(可能是多个参数), 然后使用AIDL来传递这些参数, 在消息的接收端, 使用这些参数组装成自己需要的对象. AIDL的IPC的机制和COM或CORBA类似, 是基于接口的，但它是轻量级的。它使用代理类在客户端和实现层间传递值. 如果要使用AIDL, 需要完成2件事情: 1. 引入AIDL的相关类.; 2. 调用aidl产生的class. AIDL的创建方法: AIDL语法很简单,可以用来声明一个带一个或多个方法的接口，也可以传递参数和返回值。由于远程调用的需要, 这些参数和返回值并不是任何类型.下面是些AIDL支持的数据类型: 1. 不需要import声明的简单Java编程语言类型(int,boolean等) 2. String, CharSequence不需要特殊声明 3. List, Map和Parcelables类型, 这些类型内所包含的数据成员也只能是简单数据类型, String等其他比支持的类型.

87. 如何将打开res aw目录中的数据库文件?

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

88、Android引入广播机制的用意?

答：a:从MVC的角度考虑(应用程序内) 其实回答这个问题的时候还可以这样问，android为什么要有那4大组件，现在的移动开发模型基本上也是照搬的web那一套MVC架构，只不过是改了点嫁妆而已。android的四大组件本质上就是为了实现移动或者说嵌入式设备上的MVC架构，它们之间有时候是一种相互依存的关系，有时候又是一种补充关系，引入广播机制可以方便几大组件的信息和数据交互。 b：程序间互通消息(例如在自己的应用程序内监听系统来电) c：效率上(参考UDP的广播协议在局域网的方便性) d：设计模式上(反转控制的一种应用，类似监听者模式)
89、1. Intent的几种有关的启动的方式有哪些

Intent的一些标记有FLAG_ACTIVITY_BROUGHT_TO_FRONT 、FLAG_ACTIVITY_CLEAR_TOP、FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET、FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS、FLAG_ACTIVITY_MULTIPLE_TASK和FLAG_ACTIVITY_NEW_TASK 等。每种含义大家看SDK文档和具体跑下这样你的记忆会更深刻些
90、通过Intent传递一些二进制数据的方法有哪些

1). 使用Serializable接口实现序列化，这是Java常用的方法。
2). 实现Parcelable接口，这里Android的部分类比如Bitmap类就已经实现了，同时Parcelable在Android AIDL中交换数据也很常见的
91、能说下Android应用的入口点吗?

真正的Android入口点是application的main，你可以看下androidmanifest.xml的包含关系就清楚了。可以没有Activity但是必须有Application
92、 SQLite支持事务吗添加删除如何提高性能?

SQLite作为轻量级的数据库，比MySQL还小，但支持SQL语句查询，提高性能可以考虑通过原始经过优化的SQL查询语句方式处理
93、你用过哪款Android手机，有哪些优点和不足，相对于iPhone或Symbian又有哪哪些优缺点？

94、隐式显式Intent的区别

显式意图通过名字指明目标组件（这个组件名字字段component name field, 前面提到过, 有一个数值集）。既然组件名称通常不为其他应用程序的开发者所了解，显式意图典型的被用作应用程序的内部消息-例如一个活动启动一个附属服务或姊妹活动。隐式意图不命名目标组件（组件名称字段为空）。隐式意图经常用来激活其他应用程序的组件

--------------------------------------

GC是什么? 为什么要有GC?
Gc是垃圾收集 gabage collection的意思内存处理是编程人员最容易出现问题的地方，gc可以达到自动处理内存回收垃圾的作用使java程序员不用担心内存管理问题 system.gc

XML包括哪些解释技术，区别是什么？
Sax dom

sleep()和wait()有什么区别?
Sleep() 是线程类的方法 wait()是object类的方法

Sleep（）不会释放对象锁到时自动恢复 wait（）会释放对象锁进入等待此对象的等待锁定池发出notify（）方法后才进入等待锁定池准备对象锁的获取进入运行状态

error和exception有什么区别?
error表示恢复不是不可能但是及其困难的一种严重问题不可能指望程序处理这样的问题

Exception是一种设计或实现的问题表示只要程序运行正常就不会出现的问题

谈谈final,finally,finalize的区别？
Final是修饰符表示类不能被继承方法不能被重载，重写变量不能被修改等

Finally是异常处理时的一个无论如何都会被执行的程序块

Finaliz方法是垃圾收集器删除对象之前对这个对象调用的进行清理工作的方法

当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法?
可以

当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递?
值传递

作用域public,private,protected,以及不写时的区别
用最有效率的方法算出2乘以8等於几 2《3
运行时异常与一般异常有何异
编译器要求声明并抛出一般异常但不必声明抛出运行时异常由系统处理

垃圾回收的优点和原理。并考虑2种回收机制
回收机制有分代复制垃圾回收标记垃圾回收和增量垃圾回收

描述一下JVM加载class文件的原理机制?
是由classloader和他的子类来实现的他在运行时查找和装入类文件的类

是否可以从一个static方法内部发出对非static方法的调用？
不能

什么是java序列化，如何实现java序列化？
序列化是一种处理对象流的机制是为了解决在对对象流进行读写操作时所引发的问题

使用serializeae关键字使用一个输出流构造一个对象流流对象然后使用对象流对象的writeObject（）就可以将参数为obj的对象写出

Anonymous Inner Class(匿名内部类)是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)？
可以

ArrayList和Vector的区别,HashMap和Hashtable的区别？
Vector线程安全增长时涨一倍 arraylist涨一半

Hashtable线程安全 hashmap可以用空值作为键值

请写一段程序实现冒泡排序法。
Public static maopao(int[] data){

Int temp;

For(int i=0;i<data.length-1;i++){

For(int j=i+1;j<data.length;j++){

If(data[i]<data[j])

Temp = data[i];

Data[i] = data[j];

Data[j] = temp;

}

Return data;

}

三、问答题与编程技巧

activity、Service、BroadcastReceiver的作用（android）
Activity是安卓程序与用户交互的窗口是android构造块中最基本的一种他需要为保持各界面的状态做很多持久化的事情，妥善管理声明周期以及一些跳转逻辑

Service 后台服务于activity 封装有一个完整的功能逻辑实现接受上层指令完成相关事务定义好需要接受的intent 提供同步和异步的接口

BroadcastReceiver 接受一种或多中intent做触发事件接受相关消息做一些简单处理转换成一条notification 统一了android事件广播模型

描述一个完整的Android activity lifecycle
onCreate() onStart() onRemuse() onPause() onStop() onDestory()

显式intent和隐式intent的区别是什么（android）
显式明确指出了需要激活的组件隐式没有需要系统从intentfilter里挑选合适的组件

满二叉树和完全二叉树的区别？
Android中线程同步的方法
Synchronized关键字与wait（） notify（）或者 join（） interrupt（）

------------------------------

1.简单的设计模式：
单例模式：在系统中一个类只有一个实例。分为懒汉模式和饿汉模式。饿汉模式的代码如下：
public class Singleten{
private static singleten Instance = new Singleten();
private Singleten(){}
public static getInstance()
{
return Instance ;
}
}
观察者模式：一个对象改变状态，则依赖它的所有对象都会得到通知并改变状态。
迭代器模式：iterator（）；遍历元素的方法有hasNext(),first(),next(),remove()
模版方法

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

3.应用内存优化
（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图片

4.Handler与Handler Thread关系
android消息处理机制：handler、Looper、MessageQueue、Message
将一个线程变为looper线程的方法： Looper.prepare; //初始化MessageQueue与Looper
Looper.loop();//消息循环

5.异常处理
IoException异常是编译器异常，在编译时就会报错
ANR异常解决方法：尽量在主线程只做少量工作，比较耗时的工作单独在一个子线程中完成（或使用异步请求）

6.数据库的优化
1.使用索引
2.使用事务
3.查询时返回更少的结果集和字段

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

8.启动服务的两种方法：startservice 和bindservice
使用startservice（）启动服务，调用者和服务之间没有关联，即使调用者退出了，服务仍然运行；使用bindservice（）启动服务，调用者和服务绑定在一起，调用者一旦退出，服务也终止；采用startservice启动服务，只能调用stopservice终止服务。

startservice（）启动服务的生命周期：oncreat（）、onstart（），ondestroy（）；第一次startservice（）启动服务会调用oncreat（）、onstart（）；后面再使用startservice（）启动服务，只会调用onstart（）

bindservice（）启动服务的生命周期：oncreat（）、onbind（）、omunbind（）、ondestroy（）；第一次 bindservice（）启动服务调用oncreat（）、onbind（），多次调用 bindservice（）并不会多次创建服务及绑定，如果调用者希望与正在绑定的服务解除绑定，可以调用unbindservice（）方法。

8.set、List的区别：Set中元素不重复

9.contentprovide如何实现数据共享
如果想使应用程序的数据公开化：1.自己创建一个contentprovide 2.将数据添加到一个已经存在的contentprovide上
如何获取数据：外界程序可以通过contextResolver接口访问contentprovide提供的数据
contentprovide的优点为：为其他程序提供了一个对数据访问的接口，从而实现对数据进行访问和更新的操作

10.在某个activity界面按Home键走的生命周期：onpause(),onstop(),onsaveinstanceState()
在某个activity界面按Home键再点击应用图标走的生命周期:onRestart().onStart(),onResume()

11.在android中的4种Activity启动模式：SingleTask、standard、SingleTop、SingleInstance

12.Http协议 HttpClient类 Jeson包解析

13.socket协议
android客户端实现：
try{
socket = new Socket(“192.168.1.32″,1989);
InputStream inputStream = new FileInputStream (“e://a.txt”);
OutputStream outputStream = socket.getoutputStream() ;
byte buffer[] = new byte[4*1024];
int temp = 0;
while((temp = inputStream .read(buffer))!=-1){
outputStream.write(buffer,0,temp);
}
outputStream.flush();
}
服务器端:
try{
serverSocket = new serverSocket (989);
Socket socket = serverSocket.accept();

InputStream inputStream = new FileInputStream (“e://a.txt”);
InputStream inputStream = socket.getinputStream() ;
byte buffer[] = new byte[4*1024];
int temp = 0;
while((temp = inputStream .read(buffer))!=-1){
system.out.println(new String(buffer,0,temp));
}
serverSocket.close();
}

14.AIDL android内部进程通信接口的描述语言

15.强引用：内存不足时，不会回收强引用的对象
软引用：内存不足时，会回收软引用的对象
弱引用：垃圾回收每次都会回收弱引用的对象

16.android view的刷新机制

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

来源： <http://www.mianwww.com/html/2014/03/20223.html>

-------------------------------------------------

1. 什么是Activity?
四大组件之一,一般的,一个用户交互界面对应一个activity
setContentView() ,// 要显示的布局
, activity 是Context的子类,同时实现了window.callback和keyevent.callback, 可以处理与窗体用户交互的事件.
button.setOnclickLinstener{

}

我开发常用的的有ListActivity , PreferenceActivity ,TabAcitivty等…

如果界面有共同的特点或者功能的时候,还会自己定义一个BaseActivity.
进度对话框的显示与销毁 doubanservice

2. 请描述一下Activity 生命周期。
生命周期描述的是一个类从创建(new出来)到死亡(垃圾回收)的过程中会执行的方法..
在这个过程中会针对不同的生命阶段会调用不同的方法

Activity从创建到销毁有多种状态，从一种状态到另一种状态时会激发相应的回调方法，这些回调方法包括：oncreate ondestroy onstop onstart onresume onpause
其实这些方法都是两两对应的，onCreate创建与onDestroy销毁；
onStart可见与onStop不可见；onResume可编辑（即焦点）与onPause；
对话框的弹出, Activity.this
对话框是activity的一部分.
这6个方法是相对应的，那么就只剩下一个onRestart方法了，这个方法在什么时候调用呢？
答案就是：在Activity被onStop后，但是没有被onDestroy，在再次启动此Activity时就调用onRestart（而不再调用onCreate）方法；

如果被onDestroy了，则是调用onCreate方法。

最后讲自己项目中的经验,比如说豆瓣客户端每次进入某个界面的时候都要看到最新的数据,这个刷新列表的操作就放在onStart()的方法里面.
fillData() 这样保证每次用户看到的数据都是最新的.

多媒体播放, 播放来电话. onStop() 视频, 视频声音设置为0 , 记录视频播放的位置 mediaplayer.pause();
onStart() 根据保存的状态恢复现场. mediaplayer.start();

在读文档的时候还发现 activity还有两个方法 onPostResume() 和 OnPostCreate()这两个生命周期的方法,不过开发的时候没有用到过.
3. 两个Activity之间跳转时必然会执行的是哪几个方法。

一般情况比如说有两个activity,分别叫A,B ,当在A里面激活B组件的时候, A 会调用 onPause()方法,然后B 调用onCreate() ,onStart(), OnResume() ,

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

4. 横竖屏切换时候Activity的生命周期。
这个生命周期跟清单文件里的配置有关系
1、不设置Activity的android:configChanges时，切屏会重新调用各个生命周期
默认首先销毁当前activity,然后重新加载
Onpause onstop ondestory oncreate onstart onresume

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

游戏开发中, 屏幕的朝向都是写死的.

5. 如何将一个Activity设置成窗口的样式。
可以自定义一个activity的样式,详细见手机卫士的程序详细信息
android:theme=”@style/FloatActivity”
E:\day9\mobilesafe\res\values\style

6. 你后台的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);
}
7. 如何退出Activity？如何安全退出已调用多个Activity的Application？
退出activity 直接调用 finish () 方法 . //用户点击back键就是退出一个activity
退出activity 会执行 onDestroy()方法 .
1、抛异常强制退出：
该方法通过抛异常，使程序Force Close。
验证可以，但是，需要解决的问题是，如何使程序结束掉，而不弹出Force Close的窗口。
//安全结束进程 android.os.Process.killProcess(android.os.Process.myPid());

2、记录打开的Activity：
每打开一个Activity，就记录下来。在需要退出时，关闭每一个Activity即可。

List<Activity> lists ; 在application 全集的环境里面
lists = new ArrayList<Activity>();
每一个activity在执行oncreate()方法的时候 lists.add(this);
Ondestory() lists.remove(this);
lists.add(activity);

for(Activity activity: lists)
{
activity.finish();
}

3、发送特定广播：
在需要结束应用时，发送一个特定的广播，每个Activity收到广播后，关闭即可。
//给某个activity 注册接受接受广播的意图
registerReceiver(receiver, filter)

//如果过接受到的是关闭activity的广播就调用finish()方法把当前的activity finish()掉

4、递归退出
在打开新的Activity时使用startActivityForResult，然后自己加标志，在onActivityResult中处理，递归关闭。
404 退出程序
OnActivityResult();
讲一讲你对activity的理解
把上面的几点用自己的心得写出来
8. service是否在main thread中执行, service里面是否能执行耗时的操作?
默认情况,如果没有显示的指定service所运行的进程, Service和activity是运行在当前app所在进程的main thread(UI主线程)里面
service里面不能执行耗时的操作(网络请求,拷贝数据库,大文件 )
在子线程中执行 new Thread(){}.start();

特殊情况 ,可以在清单文件配置 service 执行所在的进程 ,
让service在另外的进程中执行

9. 两个Activity之间怎么传递数据？
基本数据类型可以通过. Intent 传递数据
extras.putDouble(key, value)
intent.putExtra(name, value)
// 通过intent putExtra 方法基本数据类型都传递
Bundle bundle = new Bundle();
bundle.putShort(key, value);
intent.putExtras(bundle);
intent.putExtras(bundle)

获取到激活他的 getIntent();
Intent intent = getIntent();
Bundle bundle = intent.getExtras();
Bundle 类似map的集合
intent.getStringExtra(“key”,”value”);
intent.getBooleanExtra(“key”,”value”)

Application 全局里面存放对象 ,自己去实现自己的application的这个类,基础系统的application , 每个activity都可以取到

让对象实现 implements Serializable 接口把对象存放到文件上.
让类实现Serializable 接口,然后可以通过 ObjectOutputStream //对象输出流
File file = new File(“c:\\1.obj”);
FileOutputStream fos = new FileOutputStream(file);
ObjectOutputStream oos = new ObjectOutputStream(fos);

Student stu = new Student();
stu.setId(“10001″);
stu.setName(“zs”);
oos.writeObject(stu);

FileInputStream fis = new FileInputStream(file);
ObjectInputStream ois = new ObjectInputStream(fis);
Student stu1 = (Student) ois.readObject();
System.out.println(stu1.getName());

Parcelable 和 Serializable

Parcelable 把对象序列化到android操作系统的一块公用的内存空间
文件/网络

//传递数据的引用
intent.setData(Uri)
Uri.fromFile(); //大图片的传递
contentResolver.getInputStream(uri);

10. 怎么让在启动一个Activity是就启动一个service？
在activity的onCreate()方法里面 startService();

11. 同一个程序，但不同的Activity是否可以放在不同的Task任务栈中？
比方说在激活一个新的activity时候, 给intent设置flag
singleinstance 单独的任务栈
Intent的flag添加FLAG_ACTIVITY_NEW_TASK
这个被激活的activity就会在新的task栈里面…
Intent intent = new Intent(A.this,B.class);
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
startActivity(intent);

12. Activity怎么和service绑定，怎么在activity中启动自己对应的service？

startService() 一旦被创建调用着无关没法使用service里面的方法
bindService () 把service 与调用者绑定 ,如果调用者被销毁, service会销毁
bindService() 我们可以使用service 里面的方法
bindService(). 让activity能够访问到 service里面的方法
构建一个intent对象,
Intent service = new Intent(this,MyService.class);
通过bindService的方法去启动一个服务,
bindService(intent, new MyConn(), BIND_AUTO_CREATE);
ServiceConnection 对象(重写onServiceConnected和OnServiceDisconnected方法) 和BIND_AUTO_CREATE.
private class myconn implements ServiceConnection

{
//异步的操作, 可能需要花费若干秒的时间
public void onServiceConnected(ComponentName name, IBinder service) {
// TODO Auto-generated method stub
//可以通过IBinder的对象去使用service里面的方法
}

public void onServiceDisconnected(ComponentName name) {
// TODO Auto-generated method stub

}

13. 14 .什么是Service以及描述下它的生命周期。Service有哪些启动方法，有什么区别，怎样停用Service？
在Service的生命周期中，被回调的方法比Activity少一些，只有onCreate, onStart, onDestroy,
onBind和onUnbind。
通常有两种方式启动一个Service,他们对Service生命周期的影响是不一样的。
1 通过startService
Service会经历 onCreate 到onStart，然后处于运行状态，stopService的时候调用onDestroy方法。
如果是调用者自己直接退出而没有调用stopService的话，Service会一直在后台运行。
2 通过bindService
Service会运行onCreate，然后是调用onBind，这个时候调用者和Service绑定在一起。调用者退出了，Srevice就会调用onUnbind->onDestroyed方法。
所谓绑定在一起就共存亡了。调用者也可以通过调用unbindService方法来停止服务，这时候Srevice就会调用onUnbind->onDestroyed方法。
需要注意的是如果这几个方法交织在一起的话，会出现什么情况呢？

一个原则是Service的onCreate的方法只会被调用一次，就是你无论多少次的startService又bindService，Service只被创建一次。
如果先是bind了，那么start的时候就直接运行Service的onStart方法，如果先是start，那么bind的时候就直接运行onBind方法。

如果service运行期间调用了bindService，这时候再调用stopService的话，service是不会调用onDestroy方法的，service就stop不掉了，只能调用UnbindService, service就会被销毁
如果一个service通过startService 被start之后，多次调用startService 的话，service会多次调用onStart方法。多次调用stopService的话，service只会调用一次onDestroyed方法。
如果一个service通过bindService被start之后，多次调用bindService的话，service只会调用一次onBind方法。

多次调用unbindService的话会抛出异常。

15. 不用service，B页面为音乐播放，从A跳转到B，再返回，如何使音乐继续播放？
这个问题问的很山寨.默认不做任何处理,B里面的音乐都能播放.
遇到问题, 可以随机应变,灵活发挥,多考虑些细节,比如说这个题就可以这样说,说说你对startActivityForResult的理解()
A开启B的时候,用startActivityForResult()方法, B返回的时候把播放的状态信息返回给A ,A继续播放音乐.
16. 什么是IntentService？有何优点？
普通的service ,默认运行在ui main 主线程
Sdk给我们提供的方便的,带有异步处理的service类,
异步处理的方法 OnHandleIntent()
OnHandleIntent() 处理耗时的操作
17. 什么时候使用Service？
拥有service的进程具有较高的优先级

官方文档告诉我们，Android系统会尽量保持拥有service的进程运行，只要在该service已经被启动(start)或者客户端连接(bindService)到它。当内存不足时，需要保持，拥有service的进程具有较高的优先级。

1．如果service正在调用onCreate, onStartCommand或者onDestory方法，那么用于当前service的进程相当于前台进程以避免被killed。
2．如果当前service已经被启动(start)，拥有它的进程则比那些用户可见的进程优先级低一些，但是比那些不可见的进程更重要，这就意味着service一般不会被killed.
3．如果客户端已经连接到service (bindService),那么拥有Service的进程则拥有最高的优先级，可以认为service是可见的。
4．如果service可以使用setForeground(true);方法来将service设置为前台状态，那么系统就认为是对用户可见的，并不会在内存不足时killed。
如果有其他的应用组件作为Service,Activity等运行在相同的进程中，那么将会增加该进程的重要性。
1.Service的特点可以让他在后台一直运行,可以在service里面创建线程去完成耗时的操作. 天气预报 widget TimerTask Timer 定期执行timertask

2.Broadcast receiver捕获到一个事件之后,可以起一个service来完成一个耗时的操作.
Broadcast receiver生命周期和响应时间很短

3.远程的service如果被启动起来,可以被多次bind, 但不会重新create. 索爱手机X10i的人脸识别的service可以被图库使用,可以被摄像机,照相机等程序使用.
18. 请描述一下Intent 和 Intent Filter。
Android 中通过 Intent 对象来表示一条消息，一个 Intent 对象不仅包含有这个消息的目的地，还可以包含消息的内容，这好比一封 Email，其中不仅应该包含收件地址，还可以包含具体的内容。对于一个 Intent 对象，消息“目的地”是必须的，而内容则是可选项。
通过Intent 可以实现各种系统组件的调用与激活.
Intent filter: 可以理解为邮局或者是一个信笺的分拣系统…
这个分拣系统通过3个参数来识别
Action: 动作 Intent.ation_view
Data: 数据uri uri mime
Category : 而外的附加信息
Action 匹配
Action 是一个用户定义的字符串，用于描述一个 Android 应用程序组件，一个 Intent Filter 可以包含多个 Action。在 AndroidManifest.xml 的 Activity 定义时可以在其 <intent-filter >节点指定一个 Action 列表用于标示 Activity 所能接受的“动作”，例如：
<intent-filter >
<action android:name=”android.intent.action.MAIN” />
<action android:name=”cn.itcast.action” />
……
</intent-filter>

如果我们在启动一个 Activity 时使用这样的 Intent 对象：
Intent intent =new Intent();
intent.setAction(“cn.itcast.action”);

那么所有的 Action 列表中包含了“cn.itcast”的 Activity 都将会匹配成功。
Android 预定义了一系列的 Action 分别表示特定的系统动作。这些 Action 通过常量的方式定义在 android.content. Intent中，以“ACTION_”开头。我们可以在 Android 提供的文档中找到它们的详细说明。
URI 数据匹配
一个 Intent 可以通过 URI 携带外部数据给目标组件。在 <intent-filter >节点中，通过 <data/>节点匹配外部数据。
mimeType 属性指定携带外部数据的数据类型，scheme 指定协议，host、port、path 指定数据的位置、端口、和路径。如下：
<data android:mimeType=”mimeType” android:scheme=”scheme”
android:host=”host” android:port=”port” android:path=”path”/>
电话的uri tel: 12345 package:cn.itcast.xxx

http://www.baidu.com

自己定义的uri itcast://cn.itcast/person/10

如果在 Intent Filter 中指定了这些属性，那么只有所有的属性都匹配成功时 URI 数据匹配才会成功。
Category 类别匹配
<intent-filter >节点中可以为组件定义一个 Category 类别列表，当 Intent 中包含这个列表的所有项目时 Category 类别匹配才会成功。
默认是DEFAULT

19. Intent传递数据时，可以传递哪些类型数据？

1.一般的基本数据类型 Intent .putextra() intent.getStringextra();

2. 数据的uri, intent.setData() intent.getData();

20. 说说Activity，Intent，Service是什么关系。
麦当劳和麦当娜的关系是什么关系?
这种问题,就讲下activity,讲一下service,说一下通过intent去激活组件,传递数据.
说自己项目中有这样一个网络更新的功能,显示界面就用的activity, 后台有个service每隔半小时都去访问下服务器获取更新的数据…
开启服务用的是intent来开启
请描述一下Broadcast Receiver。
广播 android操作系统的一个事件
有很多广播接收者 ,系统已经实现了.
广播分两种
有序广播
无序广播
指定接收者的广播 . 是不可以被拦截掉的
<intent-filter android:priority=”1000″> 那个程序的uid 越低越先接受到消息
<action android:name=”android.provider.Telephony.SMS_RECEIVED”/>
</intent-filter>
onReceive() 方法.
abortBroadcast();

有序广播有一个特例
sendOrderedBroadcast(intent, receiverPermission, resultReceiver, scheduler, initialCode, initialData, initialExtras);
resultReceiver 广播接受者如果我们显示的指定了广播接收者
无论如何都会接受广播时间 abortBroadcast(); 的方法不会终止广播时间
SetresultData();
Sticky
sendStickyBroadcast(intent) // 阴魂不散的广播
Wifi设置
用于接收系统的广播通知, 系统会有很多sd卡挂载,手机重启,广播通知,低电量,来短信等,一个apk的安装成功….
手机卫士中自定义一个broadcast receiver
<intent-filter android:> <action> sms_received </action> </intent-filter>

来获取短信到来的广播, 根据黑名单来判断是否拦截该短信.

画画板生成图片后,发送一个sd挂载的通知,通知系统的gallery去获取到新的图片.
Intent intent = new Intent(Intent.ACTION_MEDIA_MOUNTED,Uri.parse(“file://”+Environment.getExternalStorageDirectory()));
sendBroadcast(intent);
22. 在manifest和代码中如何注册和使用 broadcast receiver 。
设置广播接收者的优先级,设置广播接受者的action名字等…
详细见工程代码.
<intent-filter android:priority=”1000″>
<action android:name=”android.intent.action.NEW_OUTGOING_CALL”/>
</intent-filter>
</receiver>
<receiver android:name=”.SmsReceiver”>
<intent-filter android:priority=”1000″>
<action android:name=”android.provider.Telephony.SMS_RECEIVED”/>
</intent-filter>
</receiver>
<receiver android:name=”.BootCompleteReceiver”>
<intent-filter >
<action android:name=”android.intent.action.BOOT_COMPLETED” />
</intent-filter>
</receiver>
代码中注册,如果代码没有执行,就接受不到广播事件
registerReceiver(receiver, filter);

23. 请介绍下ContentProvider是如何实现数据共享的。
把自己的数据通过uri的形式共享出去
android 系统下不同程序数据默认是不能共享访问

需要去实现一个类去继承ContentProvider
public class PersonContentProvider extends ContentProvider{
public boolean onCreate(){
//..
}
Query (Uri, String[], String, String[], String)
insert(Uri, ContentValues)
update(Uri, ContentValues, String, String[])
delete(Uri, String, String[])
}
content:// 代表contentprovider
技巧: 1.看urlmarcher.
2. 根据匹配码查看增删改查的具体实现

24. 请介绍下Android的数据存储方式。
文件访问权限. sdcard
/data/data/包名/files 内存里面
<data>/<data> context.openFileInput(name) 默认是私有的访问权限

数据库 sqlite

SharedPreference <data>/<data>/包名/shared_preps Context.modeprivate

网络 socket tcp 面向连接打电话 udp 平信 udp,
http httpurlconnection
Android httpclient post get
ftp的网络 file transport protocol

25. 为什么要用ContentProvider？它和sql的实现上有什么差别？
屏蔽数据存储的细节,对用户透明,用户只需要关心操作数据的uri就可以了,对应的参数 .
不同app之间共享,操作数据
但是contentprovider 还可以去增删改查本地文件. xml文件的读取,更改,
网络数据读取更改

Sql也有增删改查的方法.
26. 请介绍下Android中常用的五种布局。
FrameLayout（帧布局），LinearLayout （线性布局），AbsoluteLayout（绝对布局），RelativeLayout（相对布局），TableLayout（表格布局）
FrameLayout
从屏幕的左上角开始布局,叠加显示, 实际应用播放器的暂停按钮.
LinearLayout
线性布局，这个东西，从外框上可以理解为一个div，他首先是一个一个从上往下罗列在屏幕上。每一个LinearLayout里面又可分为垂直布局
（android:orientation=”vertical”）和水平布局（android:orientation=”horizontal”
）。当垂直布局时，每一行就只有一个元素，多个元素依次垂直往下；水平布局时，只有一行，每一个元素依次向右排列。
AbsoluteLayout
绝对布局犹如div指定了absolute属性，用X,Y坐标来指定元素的位置android:layout_x=”20px”
android:layout_y=”12px”
qq斗地主 qq游戏大厅 800*480 800*480.apk fwvga 854*480 320*240

指定平板机型的游戏开发中经常用到绝对布局 widget 绝对布局
指定机型的平板游戏开发. 2.3 3.0
android 2.2 2.3 2.3 sip 开发网络电话 session setup protocol 2.3 支持摄像头
Android 3.0 3.1 针对平板电脑
分裂
4.0 平板平板电视机机顶盒

界面布局任务管理器 gridview
手机任务管理 listview

lephone

lepad
RelativeLayout
相对布局可以理解为某一个元素为参照物，来定位的布局方式。主要属性有：
相对于某一个元素
android:layout_below=”@id/aaa” 该元素在 id为aaa的下面
android:layout_toLeftOf=”@id/bbb” 改元素的左边是bbb
相对于父元素的地方
android:layout_alignParentLeft=”true” 在父元素左对齐
android:layout_alignParentRight=”true” 在父元素右对齐

TableLayout <table>
表格布局类似Html里面的Table。每一个TableLayout里面有表格行TableRow，TableRow里面可以具体定义每一个元素，设定他的对齐方式 android:gravity=”” 。
每一个布局都有自己适合的方式，另外，这五个布局元素可以相互嵌套应用，做出美观的界面。
oa 自动化生成报表 ,图标表示
css div
webview

27. 谈谈UI中， Padding和Margin有什么区别？
Padding 文字对边框, margin是控件与控件之间的距离
28. widget相对位置的完成在activity的哪个生命周期阶段实现。
这个题没看懂…
widget可以理解成桌面小控件,
也可以理解成某个button, imageview这样的控件…
onmeasure() // 计算控件在屏幕上的位子
某个view 要显示在界面 ondraw 被显示到界面上的
29. 请解释下在单线程模型中Message、Handler、Message Queue、Looper之间的关系。

Activity 里面默认会帮创建Looper

子线程里面显示土司
Looper.parepare();
Toast
Looper.loop();

30. AIDL的全称是什么？如何工作？
Android interface definition language (android接口定义语言) ,
用来跨进程的访问方法,
访问远程的服务的方法. 如何工作手机卫士的程序锁 .
.endcall();
手机卫士 Itelephony 接口挂断电话.

31. 请解释下Android程序运行时权限与文件系统权限的区别。
Android程序执行需要读取到安全敏感项必需在androidmanifest.xml中声明相关权限请求, 打电话,访问网络,获取坐标,写sd卡,读写联系人等..安装的时候会提示用户…
-rw—— 私有权限 -rw-rw-rw- 全局可读可写 linux系统的文件权限
文件系统的权限是linux权限. 比如说sharedpreference里面的Context.Mode_private
Context.Mode.world_read_able Context.Mode_world_writeable
777自己同组其他

root 是危险的行为
系统上安装了多种浏览器，能否指定某浏览器访问指定页面？
Intent .setAction(VIEW)
setData(“http://”)
找到对应的浏览器的意图,传递数据URI , 激活这个意图
Intent intent = new Intent();
// com.android.browser/.BrowserActivity
intent.setClassName(“com.android.browser”, “com.android.browser.BrowserActivity “);
Intent.setdata(uri);

queryintentactivity(); 推广自己产品的操作

33. 对android主线程的运用和理解。
主ui线程不能执行耗时的操作,

34. 对android虚拟机的理解，包括内存管理机制垃圾回收机制。
虚拟机很小,空间很小,谈谈移动设备的虚拟机的大小限制默认 16M
谈谈加载图片的时候怎么处理大图片的,

垃圾回收,没有引用的对象,或者是离开作用空间 ,在某个时刻会被系统gc掉.
System.gc(); 不是立刻去执行垃圾回收.
Moblietv 获取300 30K 频道.icon gallery
手机电视. 视频点播. Onstop() 通知gc();
别的界面图片白板.
遇到一个不可复现的bug, 不解决 won’t fix
乐观锁悲观锁

Framework工作方式及原理，Activity是如何生成一个view的，机制是什么。

反射 , 配置文件
控制反转.
可以讲下activity的源码,比如说每个activity里面都有window.callback和keyevent.callback,一些回调的接口或者函数吧. 框架把activity创建出来就会调用里面的这些回调方法,会调用activity生命周期相关的方法.
setContentView();
普通的情况:
Activity创建一个view是通过 ondraw 画出来的, 画这个view之前呢,还会调用onmeasure方法来计算显示的大小.

Surfaceview 直接操作硬件 opengl .GLSurfaceView
图像要想被显示到界面上, 需要设备显卡, 显存.
写到显存.
Mediaplayer
Opengl
直接把数据写到显存.

android本身的一些限制，比如apk包大小限制，读取大文件时的时间限。
这个问题问的有问题, apk包大小限制不好说,
*飞车有100M 还是能装到手机上,

// apk 资源文件素材.
世面google market 上大程序主程序很小 5~10M 下载sdcard
15分钟之内申请退款
apk包,精简包, 素材存放在服务器. 游戏程序.

读大文件的时间限制应该是main线程里面的时间限制吧5秒.
Broadcast 10秒
Service 20秒

如何加载的音乐信息，如何改善其效率。
MP3播放器. 遍历sd卡的mp3
Mp3 作者信息专辑图片歌词信息 id3 id3v1 id3v2
Android提供mediascanner,mediaStore等接口, 音乐文件的信息都会存放到系统的数据库表中,可以通过content provider获取,

显示出来,改善效率,是个常见问题, 可以从以下几个方面作答,
分批加载数据, 延时加载数据, 合理使用缓存等…

Java虚拟机, 目标, 加快java程序执行速度
预先加载一些都会的使用的大的class的字节码, 提前加载.
时间换时间
空间换时间
38. ListView如何提高其效率？

复用convertview , 历史的view对象
异步加载数据, 分页加载数据, onscallLinster();
Static class ViewHolder
使用静态的view对象避免创建过多的view.
把下载后的数据缓存到数据库里
客户端和服务器协同作战 .

Http 请求
If-modify-since : 检查数据是否更新 1.html 2001年 302 拿缓存
网易新闻

39. 启动应用后，改变系统语言，应用的语言会改变么？
会
40. 启动一个程序，可以主界面点击图标进入，也可以从一个程序中跳转过去，二者有什么区别？
区别是根据activity在manifest里面的配置,这个activity可能会放在不同的task栈里面
intent设置的flag flag_activity_new_task

41. Android程序与Java程序的区别？
Android程序用android sdk开发,java程序用javasdk开发.
Android SDK引用了大部分的Java SDK，少数部分被Android SDK抛弃，比如说界面部分，java.awt swing package除了java.awt.font被引用外，其他都被抛弃，在Android平台开发中不能使用。
android sdk 添加工具jar httpclient , pull openGL

将Java 游戏或者j2me程序移植到Android平台的过程中，
Android SDK 与Java SDK的区别是很需要注意的地方。
1.6的不支持 httpUrlconning 获取 last-modified 信息的处理
simpleDataFormat
Android中Task任务栈的分配。

假如有三个Activity A B C，A跳到B，然后B跳到C，现在需要从C跳到A如何传递数据而且使效率最高呢？

首先我们来看下Task的定义，Google是这样定义Task的：a task is what the user experiences as an “application.” It’s a group of related activities, arranged in a stack. A task is a stack of activities, not a class or an element in the manifest file. 这意思就是说Task实际上是一个Activity栈，通常用户感受的一个Application就是一个Task。从这个定义来看，Task跟Service或者其他Components是没有任何联系的，它只是针对Activity而言的。
Activity有不同的启动模式, 可以影响到task的分配
Task，简单的说，就是一组以栈的模式聚集在一起的Activity组件集合。它们有潜在的前后驱关联，新加入的Activity组件，位于栈顶，并仅有在栈顶的Activity，才会有机会与用户进行交互。而当栈顶的Activity完成使命退出的时候，Task会将其退栈，并让下一个将跑到栈顶的Activity来于用户面对面，直至栈中再无更多Activity，Task结束。

事件 Task栈（粗体为栈顶组件）
点开Email应用，进入收件箱（Activity A） A
选中一封邮件，点击查看详情（Activity B） AB
点击回复，开始写新邮件（Activity C） ABC
写了几行字，点击选择联系人，进入选择联系人界面（Activity D） ABCD
选择好了联系人，继续写邮件 ABC
写好邮件，发送完成，回到原始邮件 AB
点击返回，回到收件箱 A
退出Email程序 null

如上表所示，是一个实例。从用户从进入邮箱开始，到回复完成，退出应用整个过程的Task栈变化。这是一个标准的栈模式，对于大部分的状况，这样的Task模型，足以应付，但是，涉及到实际的性能、开销等问题，就会变得残酷许多。

比如，启动一个浏览器，在Android中是一个比较沉重的过程，它需要做很多初始化的工作，并且会有不小的内存开销。但与此同时，用浏览器打开一些内容，又是一般应用都会有的一个需求。设想一下，如果同时有十个运行着的应用（就会对应着是多个Task），都需要启动浏览器，这将是一个多么残酷的场面，十个Task栈都堆积着很雷同的浏览器Activity，
是多么华丽的一种浪费啊。
于是你会有这样一种设想，浏览器Activity，可不可以作为一个单独的Task而存在，不管是来自那个Task的请求，浏览器的Task，都不会归并过去。这样，虽然浏览器Activity本身需要维系的状态更多了，但整体的开销将大大的减少，这种舍小家为大家的行为，还是很值得歌颂的
standard”, “singleTop”, “singleTask”, “singleInstance”。

standard模式，是默认的也是标准的Task模式，在没有其他因素的影响下，使用此模式的Activity，会构造一个Activity的实例，加入到调用者的Task栈中去，对于使用频度一般开销一般什么都一般的Activity而言，standard模式无疑是最合适的，因为它逻辑简单条理清晰，所以是默认的选择。

而singleTop模式，基本上于standard一致，仅在请求的Activity正好位于栈顶时，有所区别。此时，配置成singleTop的Activity，不再会构造新的实例加入到Task栈中，而是将新来的Intent发送到栈顶Activity中，栈顶的Activity可以通过重载onNewIntent来处理新的Intent（当然，也可以无视…）。这个模式，降低了位于栈顶时的一些重复开销，更避免了一些奇异的行为（想象一下，如果在栈顶连续几个都是同样的Activity，再一级级退出的时候，这是怎么样的用户体验…），很适合一些会有更新的列表Activity展示。一个活生生的实例是，在Android默认提供的应用中，浏览器（Browser）的书签Activity（BrowserBookmarkPage），就用的是singleTop。

singleTask，和singleInstance，则都采取的另辟Task的蹊径。
标志为singleTask的Activity，最多仅有一个实例存在，并且，位于以它为根的Task中。所有对该Activity的请求，都会跳到该Activity的Task中展开进行。singleTask，很象概念中的单件模式，所有的修改都是基于一个实例，这通常用在构造成本很大，但切换成本较小的Activity中。最典型的例子，还是浏览器应用的主Activity（名为Browser…），它是展示当前tab，当前页面内容的窗口。它的构造成本大，但页面的切换还是较快的，于singleTask相配，还是挺天作之合的。

singleInstance显得更为极端一些。在大部分时候singleInstance与singleTask完全一致，唯一的不同在于，singleInstance的Activity，是它所在栈中仅有的一个Activity，如果涉及到的其他Activity，都移交到其他Task中进行。这使得singleInstance的Activity，像一座孤岛，彻底的黑盒，它不关注请求来自何方，也不计较后续由谁执行。在Android默认的各个应用中，很少有这样的Activity，在我个人的工程实践中，曾尝试在有道词典的快速取词Activity中采用过，
是因为我觉得快速取词入口足够方便（从notification中点选进入），并且会在各个场合使用，应该做得完全独立。
大的apk 拆成很多小的apk
Andorid 车载电脑:
组网领航事故急救
140M apk
●Activity的 android:taskAffinity=””属性姻缘关系
1.配置后当启动这个activity时就先去找有没有activity的亲和力属性相同有就加入这个
activity所在的任务中没有就新开任务
2.affinity起作用需要的条件而者具备一个:
1.intent包含FLAG_ACTIVITY_NEW_TASK标记
2.activity元素启用了allowTaskReparenting属性. true

43. 在Android中，怎么节省内存的使用，怎么主动回收内存？

尽量多使用内部类提高程序效率
Bean private public
回收已经使用的资源,
合理的使用缓存
合理设置变量的作用范围 application 对象
//未来的某一段时间执行
System.gc();
44. 不同工程中的方法是否可以相互调用？
可以,列举aidl访问远程服务的例子.
45. 在Android中是如何实现判断区分电话的状态，去电，来电、未接来电？
Day8 showAddressService.java
46. dvm的进程和Linux的进程, 应用程序的进程是否为同一个概念
Dvm的进程是dalivk虚拟机进程,每个android程序都运行在自己的进程里面,
每个android程序系统都会给他分配一个单独的liunx uid(user id),
每个dvm都是linux里面的一个进程.所以说这两个进程是一个进程.

47. sim卡的EF 文件有何作用
Sim卡相关的东西,没接触过
文件规范.
48. 如何判断是否有SD卡？
配置文件中有sd卡的权限, 通过environment的静态方法,
if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
49. 嵌入式操作系统内存管理有哪几种，各有何特性。
页式，段式，段页，等 …

50. 什么是嵌入式实时操作系统, Android 操作系统属于实时操作系统吗?
实时操作系统是指当外界事件或数据产生时，能够接受并以足够快的速度予以处理，其处理的结果又能在规定的时间之内来控制生产过程或对处理系统作出快速响应，并控制所有实时任务协调一致运行的嵌入式操作系统。主要用于工业控制、军事设备、航空航天等领域对系统的响应时间有苛刻的要求，这就需要使用实时系统。又可分为软实时和硬实时两种，而android是基于linux内核的，因此属于软实时。
硬实时. 火星探测车. Vxworks
软实时. 调度算法

51. 一条最长的短信息约占多少byte?
中文70(包括标点)，英文160，160个字节这个说法不准确,
要跟手机制式运营商等信息有关.

做实验,看源码
ArrayList<String> msgs = sms.divideMessage(message);
for (String msg : msgs) {
sms.sendTextMessage(phoneNumber, null, msg, pi, null);
}
1
52. Linux中跨进程通信的几种方式。
linux编程
# 管道( pipe )：管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程关系。
# 有名管道 (named pipe) ：有名管道也是半双工的通信方式，但是它允许无亲缘关系进程间的通信。
# 信号量( semophore ) ：信号量是一个计数器，可以用来控制多个进程对共享资源的访问。它常作为一种锁机制，防止某进程正在访问共享资源时，其他进程也访问该资源。因此，主要作为进程间以及同一进程内不同线程之间的同步手段。
# 消息队列( message queue ) ：消息队列是由消息的链表，存放在内核中并由消息队列标识符标识。消息队列克服了信号传递信息少、管道只能承载无格式字节流以及缓冲区大小受限等缺点。
# 信号 ( sinal ) ：信号是一种比较复杂的通信方式，用于通知接收进程某个事件已经发生。
# 共享内存( shared memory ) ：共享内存就是映射一段能被其他进程所访问的内存，这段共享内存由一个进程创建，但多个进程都可以访问。共享内存是最快的 IPC 方式，它是针对其他进程间通信方式运行效率低而专门设计的。它往往与其他通信机制，如信号两，配合使用，来实现进程间的同步和通信。
# 套接字( socket ) ：套解口也是一种进程间通信机制，与其他通信机制不同的是，它可用于不同及其间的进程通信。
53. 谈谈对Android NDK的理解。
native develop kit 只是一个交叉编译的工具 .so
1.什么时候用ndk, 实时性要求高,游戏,图形渲染,
opencv (人脸识别) , ffmpeg , rmvb mp5 avi 高清解码. ffmpeg, opencore.

2.为什么用ndk,ndk的优点 ,缺点,

我们项目中那些地方用到了ndk, c opengl

54. 谈谈Android的优点和不足之处。
1、开放性,开源 ophone 阿里云( 完全兼容android) 乐os
2、挣脱运营商束缚
3、丰富的硬件选择 mtk android
4、不受任何限制的开发商
5、无缝结合的Google应用

缺点也有5处：
1、安全问题、隐私问题
2、卖手机的不是最大运营商
3、运营商对Android手机仍然有影响
4、山寨化严重
5、过分依赖开发商，缺乏标准配置版本过多
55. Android系统中GC什么情况下会出现内存泄露呢？视频编解码/内存泄露
检测内存泄露工具
导致内存泄漏主要的原因是，先前申请了内存空间而忘记了释放。如果程序中存在对无用对象的引用，那么这些对象就会驻留内存，消耗内存，因为无法让垃圾回收器GC验证这些对象是否不再需要。如果存在对象的引用，这个对象就被定义为”有效的活动”，同时不会被释放。要确定对象所占内存将被回收，我们就要务必确认该对象不再会被使用。典型的做法就是把对象数据成员设为null或者从集合中移除该对象。但当局部变量不需要时，不需明显的设为null，因为一个方法执行完毕时，这些引用会自动被清理。
Java带垃圾回收的机制,为什么还会内存泄露呢?

Vector v = new Vector(10);
for (int i = 1; i < 100; i++) {
Object o = new Object();
v.add(o);
o = null;
}//此时，所有的Object对象都没有被释放，因为变量v引用这些对象。
Java 内存泄露的根本原因就是保存了不可能再被访问的变量类型的引用
Jni 开发可能会出现内存泄露

56. Android UI中的View如何刷新。

在主线程中拿到view调用Invalide()方法,查看画画板里面更新imageview的方法

在子线程里面可以通过postInvalide()方法;
iv.invalidate();

new Thread(){
public void run(){
iv.postInvalidate();
}
}.start();

57. 简单描述下Android 数字签名。
Android 数字签名
在Android系统中，所有安装到系统的应用程序都必有一个数字证书，此数字证书用于标识应用程序的作者和在应用程序之间建立信任关系
Android系统要求每一个安装进系统的应用程序都是经过数字证书签名的，数字证书的私钥则保存在程序开发者的手中。Android将数字证书用来标识应用程序的作者和在应用程序之间建立信任关系，不是用来决定最终用户可以安装哪些应用程序。
这个数字证书并不需要权威的数字证书签名机构认证(CA)，它只是用来让应用程序包自我认证的。
同一个开发者的多个程序尽可能使用同一个数字证书，这可以带来以下好处。
(1)有利于程序升级，当新版程序和旧版程序的数字证书相同时，Android系统才会认为这两个程序是同一个程序的不同版本。如果新版程序和旧版程序的数字证书不相同，则Android系统认为他们是不同的程序，并产生冲突，会要求新程序更改包名。

(2)有利于程序的模块化设计和开发。Android系统允许拥有同一个数字签名的程序运行在一个进程中，Android程序会将他们视为同一个程序。所以开发者可以将自己的程序分模块开发，而用户只需要在需要的时候下载适当的模块。
在签名时，需要考虑数字证书的有效期：
(1)数字证书的有效期要包含程序的预计生命周期，一旦数字证书失效，持有改数字证书的程序将不能正常升级。
(2)如果多个程序使用同一个数字证书，则该数字证书的有效期要包含所有程序的预计生命周期。
(3)Android Market强制要求所有应用程序数字证书的有效期要持续到2033年10月22日以后。
Android数字证书包含以下几个要点：
(1)所有的应用程序都必须有数字证书，Android系统不会安装一个没有数字证书的应用程序
(2)Android程序包使用的数字证书可以是自签名的，不需要一个权威的数字证书机构签名认证
(3)如果要正式发布一个Android ，必须使用一个合适的私钥生成的数字证书来给程序签名，而不能使用adt插件或者ant工具生成的调试证书来发布。
(4)数字证书都是有有效期的，Android只是在应用程序安装的时候才会检查证书的有效期。如果程序已经安装在系统中，即使证书过期也不会影响程序的正常功能。
58. 什么是ANR 如何避免它？
在Android上，如果你的应用程序有一段时间响应不够灵敏，系统会向用户显示一个对话框，这个对话框称作应用程序无响应（ANR：Application Not Responding）对话框。用户可以选择让程序继续运行，但是，他们在使用你的应用程序时，并不希望每次都要处理这个对话框。因此，在程序里对响应性能的设计很重要，这样，系统不会显示ANR给用户。
Activity 5秒 broadcast10秒

耗时的操作 worker thread里面完成,
handler message…AsynsTask , intentservice.等…

59. android中的动画有哪几类，它们的特点和区别是什么？
两种，一种是Tween动画、还有一种是Frame动画。
Tween动画，这种实现方式可以使视图组件移动、放大、缩小以及产生透明度的变化；
可以通过布局文件,可以通过代码
1、控制View的动画
a) alpha(AlphaAnimation)
渐变透明
b) scale(ScaleAnimation)
渐变尺寸伸缩
c) translate(TranslateAnimation)
画面转换、位置移动
d) rotate(RotateAnimation)
画面转移，旋转动画

2、控制一个Layout里面子View的动画效果
a) layoutAnimation(LayoutAnimationController)
b) gridAnimation(GridLayoutAnimationController)
另一种Frame动画，传统的动画方法，通过顺序的播放排列好的图片来实现，类似电影。

62. 说说mvc模式的原理，它在android中的运用。
MVC英文即Model-View-Controller，即把一个应用的输入、处理、输出流程按照Model、View、Controller的方式进行分离，这样一个应用被分成三个层——模型层、视图层、控制层。

Android中界面部分也采用了当前比较流行的MVC框架，在Android中M就是应用程序中二进制的数据，V就是用户的界面。Android的界面直接采用XML文件保存的，界面开发变的很方便。在Android中C也是很简单的，一个Activity可以有多个界面，只需要将视图的ID传递到setContentView()，就指定了以哪个视图模型显示数据。
在Android SDK中的数据绑定，也都是采用了与MVC框架类似的方法来显示数据。在控制层上将数据按照视图模型的要求（也就是Android SDK中的Adapter）封装就可以直接在视图模型上显示了，从而实现了数据绑定。比如显示Cursor中所有数据的ListActivity，其视图层就是一个ListView，将数据封装为ListAdapter，并传递给ListView，数据就在ListView中显示。

63. 通过点击一个网页上的url 就可以完成程序的自动安装,描述下原理
Day11 AddJavascriptInterface
new Object{
callphone();
installapk();
}

64,Service和Activity在同一个线程吗
默认情况同一线程 main主线程 ui线程

65,java中的soft reference是个什么东西
StrongReference 是 Java 的默认引用实现, 它会尽可能长时间的存活于 JVM 内，当没有任何对象指向它时 GC 执行后将会被回收

SoftReference 会尽可能长的保留引用直到 JVM 内存不足时才会被回收(虚拟机保证), 这一特性使得 SoftReference 非常适合内存缓存

应用详细见豆瓣客户端图片的缓存

66,udp连接和TCP的不同之处
tcp/滑动窗口协议. 拥塞控制. 流 tcp打电话
udp 不关心数据是否达到,是否阻塞数据包平信

qq视频
画面优先. tcp
流畅优先 udp

qq发消息 , udp
应用层上包装数据一定要发送.
67, android开发中怎么去调试bug
逻辑错误

1. 断点 debug

2. logcat ,

界面布局,显示 hierarchyviewer.bat

68.service里面可以弹土司么
可以
69.写10个简单的linux命令
ls ps cat ping cd rm chomd
cat ls ps psw wc mv rm cd ping tracert find grep tail vi gcc make ifconfig
startup dhcp
70 JNI调用常用的两个参数
JNIEnv *env, jobject javaThis
71. 书写出android工程的目录结构
src
android. jar
asset
res
gen
manifest

72. ddms 和traceview的区别.
daivilk debug manager system
1.在应用的主activity的onCreate方法中加入Debug.startMethodTracing(“要生成的traceview文件的名字”);
2.同样在主activity的onStop方法中加入Debug.stopMethodTracing();
3.同时要在AndroidManifest.xml文件中配置权限
<uses-permission android:name=”android.permission.WRITE_EXTERNAL_STORAGE”></uses-permission>
3.重新编译，安装，启动服务，测试完成取对应的traceview文件(adb pull /sdcard/xxxx.trace)。
4.直接在命令行输入traceview xxxxtrace，弹出traceview窗口，分析对应的应用即可。

traceview 分析程序执行时间和效率

KPI : key performance information : 关键性能指标:
splash界面不能超过5秒
从splash 界面加载mainactivity 不能超过0.7秒

73, 同步异步的理解,什么是同步,什么是异步,多次调用异步方法会出现什么问题.
74. 利用mvc的模式重构代码
1) 重构前的代码Bmi.java：
package com.demo.android.bmi;

import java.text.DecimalFormat;

import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;

public class Bmi extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);

// Listen for button clicks
Button button = (Button) findViewById(R.id.submit);
button.setOnClickListener(calcBMI);
}

private OnClickListener calcBMI = new OnClickListener() {
@Override
public void onClick(View v) {
DecimalFormat nf = new DecimalFormat(“0.00″);
EditText fieldheight = (EditText) findViewById(R.id.height);
EditText fieldweight = (EditText) findViewById(R.id.weight);

double height = Double.parseDouble(fieldheight.getText().toString()) / 100;
double weight = Double.parseDouble(fieldweight.getText().toString());
double BMI = weight / (height * height);

TextView result = (TextView) findViewById(R.id.result);
result.setText(“Your BMI is ” + nf.format(BMI));

// Give health advice
TextView fieldsuggest = (TextView) findViewById(R.id.suggest);
if (BMI > 25) {
fieldsuggest.setText(R.string.advice_heavy);
} else if (BMI < 20) {
fieldsuggest.setText(R.string.advice_light);
} else {
fieldsuggest.setText(R.string.advice_average);
}
}
};
}

Step1：抽取所有界面元件的声明和定义，整合到单独一个函数findViews()中；
// 声明 view
private Button button_calc;
private EditText field_height;
private EditText field_weight;
private TextView view_result;
private TextView view_suggest;

// 定义
private void findViews() {
button_calc = (Button) findViewById(R.id.submit);
field_height = (EditText) findViewById(R.id.height);
field_weight = (EditText) findViewById(R.id.weight);
view_result = (TextView) findViewById(R.id.result);
view_suggest = (TextView) findViewById(R.id.suggest);
}
此部分即是MVC中的V：View视图。
Step2：抽取程序的逻辑（即界面元件的处理逻辑），整合到函数setListensers()中；
//Listen for button clicks
private void setListensers() {
button_calc.setOnClickListener(calcBMI);
}
此部分即是MVC中的C：Controller控制器。
接着，onCreate()就显得非常简洁、明了了：
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);

findViews();
setListensers();
}
Step3：修改按钮监听器calcBMI中相应的部分（主要是变量已经在视图部分定义了）；
private OnClickListener calcBMI = new OnClickListener() {
@Override
public void onClick(View v) {
DecimalFormat nf = new DecimalFormat(“0.00″);

double height = Double.parseDouble(field_height.getText().toString()) / 100;
double weight = Double.parseDouble(field_weight.getText().toString());
double BMI = weight / (height * height);

// Present result
view_result.setText(“Your BMI is ” + nf.format(BMI));

// Give health advice
if (BMI > 25) {
view_suggest.setText(R.string.advice_heavy);
} else if (BMI < 20) {
view_suggest.setText(R.string.advice_light);
} else {
view_suggest.setText(R.string.advice_average);
}
}
};

总之，此重构的目的无非是使程序的脉络更加清晰，即让人一眼望去，就能很容易地分辨出界面（View）应该写在哪里，程序逻辑（Controller）应该写在哪里，最终使维护和扩展代码变得更加容易！
其实，重构很简单，通读代码，感觉哪边不太爽，就改那边吧！（我目前的感受）
一个良好的代码应该是能让人感到舒服的！

2) 重构后的代码Bmi.java：
package com.demo.android.bmi;

import java.text.DecimalFormat;

import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;

public class Bmi extends Activity {

private Button button_calc;
private EditText field_height;
private EditText field_weight;
private TextView view_result;
private TextView view_suggest;

/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);

findViews();
setListensers();
}

// Listen for button clicks
private void setListeners() {
calcbutton.setOnClickListener(calcBMI);
}

private Button.OnClickListener calcBMI = new Button.OnClickListener() {
public void onClick(View v) {
DecimalFormat nf = new DecimalFormat(“0.0″);
double height = Double.parseDouble(field_height.getText().toString()) / 100;
double weight = Double.parseDouble(field_weight.getText().toString());
double BMI = weight / (height * height);

// Present result
view_result.setText(getText(R.string.bmi_result) + nf.format(BMI));

总结:
关于项目
在就是你项目经验，一定要突出你遇到什么难点，然后是怎么解决的！把问题引导到你熟悉的领域,或者知识点上,尽量将每个技术点细节凸显出来，
心态:
什么样的面试官都有，去面试的时候要做好一切心理准备，不管是技术还是基础都得扎实。一个人的交谈能力也很重要，总之不是非常标准的普通话，最起码你说的得让别人听得懂，而且得把面试官讲得非常彻底，这样你获得offer的机会更大，谈工资也有优势~~

---------------------------------

随着移动平台的发展和其应用的不断改善，质量成为决定成败的关键。用户要求他们选择安装的应用响应快、性能好，如果某个应用不能提供卓越的功能和稳定的用户体验，那这样的应用注定会被很快卸载。
尽管现在Android智能手机和平板电脑的运行速率越来越快，但开发者仍需牢记，应用的运行环境仍受到电池和处理器等诸多资源的限制。以下是如何为应用“瘦身”的十条建议，以便能在当前和以后的所有Android设备都能运行出最佳效果。

　　1）首先要有良好的编码习惯

　　一个优秀的开发者应该善于运用常识、完善的算法和标准设计模式。要有资源意识，打开了就要记得关闭，尽量做到晚获取，早释放。这些由来已久的编码准则同样适用Android应用开发，尤其是使用基础设备服务时。

　　2）让阻塞操作远离主UI线程

　　通过使用AsyncTask、线程、IntentService和自定义后台服务，保证应用的灵活性。使用加载工具简化游标等长时间加载数据的状态管理。当有其他程序运行时，不能让你的应用滞后或中止。

　　如果一个操作需要消耗较多时间和资源时，取消该操作，换成异步处理，这样应用就能保持响应，用户可以继续各种操作。该方法适用磁盘读写、访问内容提供方、数据库和互联网，以及解析和其他需要花费较长时间的任务。

　　3）使用最新的Android SDK版本和API

　　使用Android平台的最新产品，保证你的应用紧跟Android的更新步伐。随着Android平台的不断发展，部分功能可能被弃用或被更好的功能取代，核心API接收了bug修复和性能改进，新API有助于开发者编写出更稳定的应用。要明白最佳的做法总是随着时间的推移而变，聪明的开发者应该总是站在整个平台的最前沿。

　　4）考虑使用StrictMode

　　从Android 2.3开始提供了一个新的类StrictMode，该类可以用于捕捉发生在应用程序主线程中耗时的磁盘、网络访问或函数调用，可以帮助开发者改进程序，使主线程处理UI和动画在磁盘读写和网络操作时变得更平滑，避免主线程被阻塞。

　　5）发布前禁用或尽量减少调试

　　如果开发周期较长，你很可能在应用中内置了一些日志或调试代码，在发布前确保这些功能已经最小化或完全禁用。

　　6）确保UI布局简单优雅

　　简单的屏幕不仅方便阅读，还能加快加载速度。与其在一个单一屏幕上堆砌太多不必要的功能，不如花时间去开发优雅的用户界面。简单优雅的UI不仅能提高应用性能，还能提高用户使用该应用时的效率。

　　7）根据目标设备调整应用资源

　　为尽可能高效地被加载，需要根据具体设备的配置调整相应资源，尤其是图片资源。为使应用包文件合理适用不同设备，首先可只添加运行该应用需要的核心资源，然后再根据具体设备下载相关内容。

　　8）使用Hierachy Viewer可视化调试工具

　　Hierachy Viewer能很方便地在开发者设计，调试和调整界面时，快速定位问题，解决问题，提高开发效率。

　　9）使用layoutopt进行布局优化

　　Layoutopt是一款简单的命令行工具，可帮助找到不必要的控件嵌套以及缩减布局资源，从而使应用变得可能“苗条”。控件越少、布局层次越浅，性能就越好。

　　10）使用Traceview及其他Android工具进行分析

　　Android SDK随带了很多用于应用分析的工具，其中最受欢迎的是Traceview，这款图形工具可以帮助调试和找到应用中的性能瓶颈。

　　结语

　　提升Android应用性能的方法有很多，有些需要使用特定的算法，有些依赖切实可行的调试和性能监测技术。幸运的是，Android平台随带了众多免费的实用工具，可以帮助跟踪和解决应用程序中的性能问题。

　　Via Developer

-----------------------------------
ndroid 最全面试题 71 道题详解
1. 下列哪些语句关于内存回收的说明是正确的? (b )
A、程序员必项创建一个线程来释放内存
B、内存回收程序负责释放无用内存
C、内存回收程序允讲程序员直接释放内存
D、内存回收程序可以在指定的时间释放内存对象
android 内存回收机制
我想每个人第一次用 Android 的时候,不可避免的会去装个任务管
理器,然后对里面时刻都停留着一大堆的程序表示触目惊心,然后
会在桌面上建立一个快捷清空内存的按钮,时不时啪的按一下,看
着内存剩余数量从 30 多变成 100 多然后很有快感... 其实
吧,Android 是 Linux 的内核,每一个程序都是一个独立的 JAVA 虚
拟机,就和油汤里的油花一样互不干扰,这样充分保证了万一某个
程序的 JAVA 虚拟机崩溃,系统依旧稳定正常运行. 而 Android 和
传统 Linux 不一样的地方又在于,传统 Linux 在进程活动停止后就
结束了,这就类似于我们用 S60 和 WM 一样,关闭程序,内存释放.而
Android 会把这些进程保留在内存里,干嘛呢?为了保证你再次激活
这些进程时候启动的更快, 比如说我们挂在桌面的 Widgets, 具
体一点我们拿新浪微博举例吧.我刚看完,退出,突然我想我发一条
微博吧, 那么这个时候我可以直接在桌面 Widgets 上操作----设想
一下如果我退出的时候这个进程就终止了,那么我在桌面上点击
Widgets 的时候会不会卡顿一下甚至没有响应? ----这就跟我们把
Widgets 挂在桌面的行为完全背离了,放在桌面上就是为了能随时
观察到程序运行的情况, 以及随时可以快速调用程序.所以
Android 并没有在进程活动停止就释放对应的内存.那么也许你还
是会有疑问,那么内存够不够用呢?
512 的内存被我用的只剩 56M 是不是很恐怖?其实系统一点也不卡
的,蛋定蛋定是的,我理解,因为大家这么多年 Windows 都用习
惯了,Windows 内存不足的时候机器卡的会让你想砸掉机箱, 而且
调用虚拟内存的时候硬盘喀喀喀想的让你肉疼. 你肯定也会怕你
的手机明明 512M 内存结果就剩下 30 来 M 把你卡到崩溃.事实上
呢,Android 会在系统需要更多内存的时候,去释放掉那些占用内存
的进程----这个活动是智能的. 最早大家认为是有个排序,比如最近
使用过哪些程序(LRU 机制,Last Recently Used),然后结束最
早的进程.不过并非如此,否则就变成我们上小学时候那样,个子
高的块头大的男生跟班长下去拔草扛新书, 女生们留在班里绣花
吧... 这样很明显不公平而且没准会结束掉那些我们并不想结
束掉的进程----譬如说这会儿我想切回到刚才后台的网页继续
浏览结果悲怆的发现它被系统给我强制关闭了...
Android 把进程分成了一些优先级,比如前台进程(Foreground),比
如我们正在看书,那么看书的程序就是前台进程,这些进程是不会
被系统优先结束的. 当我把它切到后台的时候,它就变成后台进程
了. 还有可见进程(Visible), 这个怎么说呢,譬如输入法程序,
你平时是看不见它的,但是在你打开输入界面的时候,它会很快的
弹出来,而不是让你等啊等啊等,看不到的原因是透明度的机制,
咱就不要钻牛角尖讨论为啥我看不见了... 还有桌面的 Widgets,比
如我们的桌面时钟,这个东西就是可见的,如果它被系统终止了会
有什么样的结果?这个 Widgets 依然会显示在桌面上,但是时针不
走了... 主要服务,比如说,电话的拨号功能,你也不想正急着
打电话呢结果人家给你卡半天吧,尤其像我这样联系人上 2000
的,载入一遍真的很慢啊...所以这些主要服务平时也不会被系统
自动结束,除非你非要关它,关了也会自己重新加载的.这也是你
完全释放内存以后过一会就看着内存可用值又慢慢降低的原因.
次要服务(secondary server),诸如谷歌企业套件,Gmail,联系
人,看着这些程序出现在任务管理器里可能你会非常的莫名其妙,
丫的这都哪跟哪啊我没开啊...其实它们和一些系统功能也是息
息相关的,比如 Gmail 的邮件推送,我们时常需要用到它们,所以系
统也太会去终止它们.甚至于 HTC 机器上著名的 HTC Sense,这个
也是次要服务,但是其实它承接着整个系统界面的运行,所以,如
果你强行关闭所有进程的时候,你的屏幕会变成一片白...然后慢
慢等 HTC Sense 加载.
后台进程(hidden),就是我们通常意义上理解的启动后被切换到后
台的进程,比如如浏览器和阅读器.后台进程的管理策略有多种,
但是一般来讲,系统都会视内存情况,尽可能多的保留后台程序,这
样会影响到你启动别的程序的运行速度----我想这个很好理解,
因为内存确实不够了,而且你还没让系统自动释放内存.但好处是,
你再次切换到这些已启动的程序时几乎是无缝的, 速度绝对比你
从 0 开始启动它要快得多.所以,这种后台进程在内存极度不够的
时候,肯定会被系统选择性的干掉的. 内容供应节点
(content provider),没有程序实体,仅提供内容供别的程序去用
的,比如日历供应节点,邮件供应节点等.在系统自动终止进程时,
这类程序享有优先的被干掉权... 空进程(empty), 没有任何
东西在内运行的进程,有些程序在退出后,依然会在进程中驻留一
个空进程,这个进程里没有任何数据在运行,作用往往是提高该程
序下次的启动速度或者记录程序的一些历史信息.这部分进程无疑
是系统最先终止的.
说了这么多,其实还是要结合实际的程序来看一下的,比如 Android
这个很有名的自动内存调配的软件,Auto Memory Manager,它的
设置和帮助界面就如上面所说的, 它自动提供了多种默认配置,例
如极速模式,这个模式下,会帮助你在设定好的临界值区间上,结
束空进程以及内容供应节点等等低优先级保留权的进程,来给你腾
出更多的内存,加速新运行程序打开的速度,但是它也说明了这种
模式的弊端,就是一些可能你不想被关闭的进程会被过早的关闭,
比如说,闹钟----在 G2 G3 还很火爆的 2009 年,很多用户在买完
手机后给我抱怨,哎呀这个机器闹钟怎么老不响啊...上班老迟
到...其实这就是因为手动结束进程的时候结果把闹钟也给干掉了.
系统的时间是会一直走的,这属于主要服务,而闹钟呢,只是主要
服务的一个附属品,所以被结束后,是不会自动被启动的,既然没有
启动自然就不会响了.与此类似的例子就是里程碑不充电的 BUG,
这是因为 Moto 的机器里有个 USB 的进程,如果你把它结束后,理论
上会重新启动的但是也会不启动,后面这种情况出现的结果就是
你插充电器没反应,插数据线连电脑没反应...重启手机就
好了. 当然我知道大家的洁癖很多,有的人就是见不得内存值
太小...好吧如果你不想一些被系统认为不太重要而你又很
需要的进程被你自己亲手扼杀的话,那么我推荐你使用高级任务
管理器这个程序,你可以把一些进程自动隐藏起来, 也就是说当你
挥起狼牙棒横扫一堆进程的时候,你设置好的几个进程是不会受任
何影响的,比如桌面 Launcher,比如闹钟,比如 USB,等等等等. 但
话说回来,我是不建议大家去手动管理 Android 的内存,也许你会
不习惯----我也没啥好劝告的,总之,不要把你的智能机想的那么
笨就行了. 刚才全杀掉进程后,过了一会,我的 DEFY 又变成剩余
60M 内存,还是没啥鸭梨啊...如果你感兴趣可以做个试验,内存
很少的时候,你打开一个大游戏,然后退出,你会发现...
http://reedhistudy.diandian.com/post/2011 -09-15/5045645
2. 下面异常是属于 Runtime Exception 的是（abcd）(多选)
A、ArithmeticException
B、IllegalArgumentException
C、NullPointerException
D、BufferUnderflowException
A、ArithmeticException
当出现异常的运算条件时，抛出此异常。例如，一个整数“除
以零”时，抛出此类的一个实例。
B、IllegalArgumentException
抛出的异常表明向方法传递了一个不合法或不正确的参数。
C、NullPointerException
D、 BufferUnderflowException （不明白，没碰到过）
编码问题导致 java_BufferUnderflowException 异常
公共类 BufferUnderflowException 的
延伸的 RuntimeException
未经检查的异常时，抛出一个相对 get 操作达到源缓冲区的限制。
3. Math.round(11.5)等于多少(). Math.round(-11.5)等于多
少(c).
A、11 ,-11 B、11 ,-12 C、12 ,-11 D、12 ,-12
四舍五入四和五是指正的 4，5
-11.5 返举看 -11.5 = -12 +0.5 ，0.5 按四舍五入为 1 ，
-12+1 = -11，所以 Math.round(-11.5)==-11
-0.5 = -1 + 0.5 0.5 按四舍五
入为 1 ，-1+1 = 0，所以 Math.round(-0.5)==0
11.5 四舍五入显
然 Math.round(11.5)==12
round 方法迒回不参数最接近的长整数，参数加 0.5 后求其 floor （小
亍等亍该数的最大整数）
4. 下列程序段的输出结果是：（b）
void complicatedexpression_r(){
int x=20, y=30;
boolean b;
b=x>50&&y>60||x>50&&y<-60||x<-50&&y>60||x<-50&&y
<-60;
System.out.println(b);
}
A、true B、false C、1 D、011.activity
&&（与）的优先级比||（或）高
5. 对一些资源以及状态的操作保存，最好是保存在生命周期的哪个
函数中进行(d)
A、onPause() B、onCreate() C、 onResume() D、onStart()
Activity 详觋（生命周期、以各种方式吭劢 Activity、状态保存，完
全退出等）
http://blog.csdn.net/tangcheng_ok/article/details/6755194
6. Intent 传递数据时，下列的数据类型哪些可以被传递（abcd） (多
选)
A、Serializable B、charsequence C、Parcelable D、
Bundle
android 数据传递详解（Serialization、 Parcelable、 Parcel、 Intent、
Bundle）
http://jojol-zhou.iteye.com/blog/1401905
Android 中 Intent 传逍对象的两种方法(Serializable,Parcelable)
http://blog.csdn.net/xyz_lmn/article/details/5908355
7. android 中下列属于 Intent 的作用的是(c)
A、实现应用程序间的数据共享
B、是一段长的生命周期，没有用户界面的程序，可以保持应用
在后台运行，而丌会因为切换页面而消失
C、可以实现界面间的切换，可以包含劢作和劢作数据，连接四
大组件的纽带
D、处理一个应用程序整体性的工作
8. 下列属于 SAX 解析 xml 文件的优点的是(b)
A、将整个文档树在内存中，便亍操作，支持删除，修
改，重新排列等多种功能（dom 觋析优点）
B、丌用事先调入整个文档，占用资源少（sax 觋析优
点）
C、整个文档调入内存，浪费时间和空间（dom 觋析缺
点）
D、丌是长丽驻留在内存，数据丌是持丽的，事件过后，
若没有保存数据，数据就会（sax 觋析缺点）
消失
不需要像 dom 解析那样在内存中建立一个 dom 对象，占用内存，sax
解析是逐行解析的，每次读入内存的只是一行 xml，所以速度快，效
率高点。不过 sax 一般是处理固定格式的 xml。
9. 下面的对自定 style 的方式正确的是（a）
A、 <resources>
<style name="myStyle">
<item name="android:layout_width">fill_parent</item>
</style>
</resources>
B、 <style name="myStyle">
<item name="android:layout_width">fill_parent</item>（没有
<resources>）
</style>
C、 <resources>
<item name="android:layout_width">fill_parent</item>（没有
</style>）
</resources>
D、 <resources>
<style name="android:layout_width">fill_parent</style>
（</style>应为</item>）
</resources>
10. 在 android 中使用 Menu 时可能需要重写的方法有（ac）。
(多选)
A、onCreateOptionsMenu()
B、onCreateMenu()
C、onOptionsItemSelected()
D、onItemSelected()
//当客户点击 MENU 按钮的时候，调用该方法
@Override
public boolean onCreateOptionsMenu(Menu menu) {
menu.add(0, 1, 1, R.string.exit);
menu.add(0,2,2,R.string.about);
return super.onCreateOptionsMenu(menu);
}
//当客户点击菜单当中的某一个选项时，会调用该方法
@Override
public boolean onOptionsItemSelected(MenuItem item) {
if(item.getItemId() == 1){
finish();
}
return super.onOptionsItemSelected(item);
}
11. 在 SQL Server Management Studio 中运行下列 T-SQL 语句，
其输出值（c）。
SELECT @@IDENTITY
A、可能为 0.1
B、可能为 3
C、不可能为-100
D、肯定为 0
@@identity 是表示的是最近一次向具有 identity 属性(即自增列)的
表插入数据时对应的自增列的值，是系统定义的全局变量。一般系统
定义的全局变量都是以@@开头，用户自定义变量以@开头。比如有个
表 A，它的自增列是 id，当向 A 表插入一行数据后，如果插入数据后
自增列的值自动增加至 101，则通过 select @@identity 得到的值就
是 101。使用@@identity 的前提是在进行 insert 操作后，执行 select
@@identity 的时候连接没有关闭，否则得到的将是 NULL 值。
12. 在 SQL Server 2005 中运行如下 T-SQL 语句，假定 SALES 表
中有多行数据，执行查询之后的结果是（d）。
BEGIN TRANSACTION A
Update SALES Set qty=30 WHERE qty<30
BEGIN TRANSACTION B
Update SALES Set qty=40 WHERE qty<40
Update SALES Set qty=50 WHERE qty<50
Update SALES Set qty=60 WHERE qty<60
COMMITTRANSACTION B
COMMIT TRANSACTION A
A、SALES 表中 qty 列最小值大亍等亍 30
B、SALES 表中 qty 列最小值大亍等亍 40
C、SALES 表中 qty 列的数据全部为 50
D、SALES 表中 qty 列最小值大亍等亍 60
Update SALES Set qty=60 WHERE qty<60（关键在最后一句，执行完
数据就都是大于等于 60 了）
13. 在 android 中使用 SQLiteOpenHelper 这个辅助类时，可以
生成一个数据库，并可以对数据库版本进行管理的方法可以是(ab)
A、getWriteableDatabase()
B、getReadableDatabase()
C、getDatabase()
D、getAbleDatabase()
14. android 关于 service 生命周期的 onCreate()和 onStart()说法
正确的是(ad)(多选题)
A、当第一次吭劢的时候先后调用 onCreate()和 onStart()方
法
B、当第一次吭劢的时候叧会调用 onCreate()方法
C、如果 service 已经吭劢，将先后调用 onCreate()和 onStart()
方法
D、如果 service 已经吭劢，叧会执行 onStart()方法，丌在执行
onCreate()方法
15. 下面是属于 GLSurFaceView 特性的是(abc)(多选)
A、管理一个 surface，这个 surface 就是一块特殊的内存，能直
接排版到 android 的视图
view 上。
B、管理一个 EGL display，它能让 opengl 把内容渲染到上述的
surface 上。
C、让渲染器在独立的线程里运作，和 UI 线程分离。
D、可以直接从内存或者 DMA 等硬件接口取得图像数据
android.opengl.GLSurfaceView 概述
http://blog.csdn.net/xqhrs232/article/details/6195824
GLSurfaceView 是一个视图，继承至 SurfaceView，它内嵌的 surface
专门负责 OpenGL 渲染。
GLSurfaceView 提供了下列特性：
1> 管理一个 surface，这个 surface 就是一块特殊的内
存，能直接排版到 android 的视图 view 上。
2> 管理一个 EGL display，它能让 opengl 把内容渲染
到上述的 surface 上。
3> 用户自定义渲染器(render)。
4> 让渲染器在独立的线程里运作，和 UI 线程分离。
5> 支持按需渲染(on-demand)和连续渲染
(continuous)。
6> 一些可选工具，如调试。
16. 下面在 AndroidManifest.xml 文件中注册 BroadcastReceiver 方
式正确的(a)
A、<receiver android:name="NewBroad">
<intent-filter>
<action
android:name="android
.provider.action.NewBroad"/>
<action>
</intent-filter>
</receiver>
B、<receiver android:name="NewBroad">
<intent-filter>
android:name="android
.provider.action.NewBroad"/>
</intent-filter>
</receiver>
C、<receiver android:name="NewBroad">
<action
android:name="android.p
rovider.action.NewBroad"/>
<action>
</receiver>
D、<intent-filter>
<receiver android:name="NewBroad">
<action>
android:name="android
.provider.action.NewBroad"/>
<action>
</receiver>
</intent-filter>
17. 关于 ContenValues 类说法正确的是(a)
A、他和 Hashtable 比较类似，也是负责存储一些名
值对，但是他存储的名值对当中的
名是 String 类型，而值都是基本类型
B、他和 Hashtable 比较类似，也是负责存储一些名
值对，但是他存储的名值对当中的
名是任意类型，而值都是基本类型
C、他和 Hashtable 比较类似，也是负责存储一些名
值对，但是他存储的名值对当中的
名，可以为空，而值都是 String 类型
D、他和 Hashtable 比较类似，也是负责存储一些名
值对，但是他存储的名值对当中
的名是 String 类型，而值也是 String 类型
18. 我们都知道 Hanlder 是线程与 Activity 通信的桥梁,如果线程处
理不当，你的机器就会变得越慢，那么线程销毁的方法是(a)
A、onDestroy()
B、onClear()
C、onFinish()
D、onStop()
19. 下面退出 Activity 错误的方法是（c）
A、finish()
B、抛异常强制退出
C、System.exit() System.exit(0) 0 是正常退出
其他数字是表示不正常退出
D、onStop()
20. 下面属于 android 的动画分类的有(ab)(多项)
A、Tween B、Frame C、Draw D、Animation
Android 动画模式
Animation 主要有两种动画模式：
一种是 tweened animation(渐变动画)
XML 中 JavaCode
alpha AlphaAnimation
scale ScaleAnimation
一种是 frame by frame(画面转换动画)
XML 中 JavaCode
translate TranslateAnimation
rotate RotateAnimation
21. 下面关于 Android dvm 的进程和 Linux 的进程,应用程序的进
程说法正确的是(d)
A、DVM 指 dalivk 的虚拟机.每一个 Android 应用程
序都在它自己的迕程中运行,不一定拥有一个独立的 Dalvik 虚拟机
实例.而每一个 DVM 都是在 Linux 中的一个迕程,所以说可以认为是
同一个概念.
B、DVM 指 dalivk 的虚拟机.每一个 Android 应用程
序都在它自己的迕程中运行,不一定拥有一个独立的 Dalvik 虚拟机实
例.而每一个 DVM 不一定都是在 Linux 中的一个迕程,所以说不是一
个概念.
C、DVM 指 dalivk 的虚拟机.每一个 Android 应用程
序都在它自己的迕程中运行,都拥有一个独立的 Dalvik 虚拟机实例.
而每一个 DVM 不一定都是在 Linux 中的一个迕程,所以说不是一个概
念.
D、DVM 指 dalivk 的虚拟机.每一个 Android 应用程
序都在它自己的迕程中运行,都拥有一个独立的 Dalvik 虚拟机实例.
而每一个 DVM 都是在 Linux 中的一个迕程,所以说可以认为是同一个
概念.
22. Android 项目工程下面的 assets 目录的作用是什么 b
A、放置应用到的图片资源。
B、主要放置多媒体等数据文件
C、放置字符串，颜色，数组等常量数据
D、放置一些不 UI 相应的布局文件，都是 xml 文件
23. 关于 res/raw 目录说法正确的是(a)
A、这里的文件是原封不动的存储到设备上不会转换为二进制的格
式
B、这里的文件是原封不动的存储到设备上会转换为二进制的格式
C、这里的文件最终以二进制的格式存储到指定的包中
D、这里的文件最终不会以二进制的格式存储到指定的包中
24. 下列对 android NDK 的理解正确的是(abcd )
A、 NDK 是一系列工具的集合
B、 NDK 提供了一仹稳定、功能有限的 API 头文件声明。
C、使 “Java+C” 的开发方式终亍转正，成为官方支持的开发方
式
D、 NDK 将是 Android 平台支持 C 开发的开端
Windows 平台下如何使用 Android NDK
http://yuchen.blog.51cto.com/2739238/623472/
二．填空题
25. android 中常用的四个布局是 LinearLayout （线性布局）、
FrameLayout（单帧布局）、RelativeLayout（相对布局）和
TableLayout（表格布局）
26. android 的四大组件是 activity，service，broadcast 和
Content Provider。
27. java.io 包中的 objectinputstream 和 objectoutputstream
类主要用于对对象(Object)的读写。
28. android 中 service 的实现方法是：startservice 和
bindservice。
Service 的生命周期方法比 Activity 少一些，只有 onCreate,
onStart, onDestroy
我们有两种方式启动一个 Service,他们对 Service 生命周期的影响
是不一样的。
1 通过 startService
Service 会经历 onCreate --> onStart
stopService 的时候直接 onDestroy
如果是调用者直接退出而没有调用 stopService 的话， Service 会
一直在后台运行。
下次调用者再起来仍然可以 stopService。
2 通过 bindService
Service 只会运行 onCreate，这个时候调用者和 Service 绑定在一
起
调用者退出了，Srevice 就会调用 onUnbind-->onDestroyed
所谓绑定在一起就共存亡了。
1. Started Service 中使用 StartService（）方法来进行方法的调用，
调用者和服务之间没有联系，即使调用者退出了，服务依然在进行
【onCreate()- >onStartCommand()->startService()->onDestroy()】，
注意其中没有 onStart()，主要是被 onStartCommand()方法给取代了，
onStart 方法不推荐使用了。
2. BindService 中使用 bindService()方法来绑定服务，调用者和绑定
者绑在一起，调用者一旦退出服务也就终止了
【onCreate()->onBind()->onUnbind()->onDestroy()】。
29. activity 一般会重载 7 个方法用来维护其生命周期，除了
onCreate(),onStart(),onDestory() 外还有
onrestart,onresume,onpause,onstop。
30. android 的数据存储的方式 sharedpreference,文
件,SQlite,contentprovider,网络。
1. 使用 SharedPreferences 存储数据；
2. 文件存储数据；
3. SQLite 数据库存储数据；
4. 使用 ContentProvider 存储数据；
5. 网络存储数据；
31. 当启动一个 Activity 并且新的 Activity 执行完后需要返回到启
动它的 Activity 来执行的回调函数是
startActivityForResult
startActivityForResult(Intent,requestCode)//启动一个 activity 包
含参数请求码和具体的 intent 数据，其中请求码可以用来识别子活
动。
32. 请使用命令行的方式创建一个名字为 myAvd,sdk 版本为 2.2,sd
卡是在 d 盘的根目录下,名字为 scard.img，并指定屏幕大小
HVGA.________________android create acd -n myAvd -t 8 -s HVDA
– C d:\card.img____________________。
33. 程序运行的结果是：_____good and gbc__________。
public class Example{
String str=new String("good");
char[]ch={'a','b','c'};
public static void main(String args[]){
Example ex=new Example();
ex.change(ex.str,ex.ch);
System.out.print(ex.str+" and ");
Sytem.out.print(ex.ch);
}
public void change(String str,char ch[]){
str="test ok";
ch[0]='g';
}
}
34. 在 android 中，请简述 jni 的调用过程。(8 分)
1)安装和下载 Cygwin，下载 Android NDK
2)在 ndk 顷目中 JNI 接口的讴计
3)使用 C/C++实现本地方法
4)JNI 生成劢态链接库.so 文件
5)将劢态链接库复制到 java 工程，在 java 工程中调用，运行 java
工程即可
35. 简述 Android 应用程序结构是哪些?（7 分）
Android 应用程序结构是：
Linux Kernel(Linux 内核)、Libraries(系统运行库戒者是 c/c++
核心库)、Application
Framework(开发框架包)、Applications(核心应用程序)
36. 请继承 SQLiteOpenHelper 实现：(10 分)
1）.创建一个版本为 1 的“diaryOpenHelper.db”的数据库，
2） .同时创建一个 “diary” 表（包含一个_id 主键幵自增长，
topic 字符型 100
长度， content 字符型 1000 长度）
3） .在数据库版本变化时请删除 diary 表，幵重新创建出 diary
表。
public class DBHelper extends SQLiteOpenHelper {
public final static String DATABASENAME = "diaryOpenH
elper.db";
public final static int DATABASEVERSION = 1;
//创建数据库
public DBHelper(Context context,String name,CursorFactor
y factory,int version)
{
super(context, name, factory, version);
}
//创建表等机构性文件
public void onCreate(SQLiteDatabase db)
{
String sql ="create table diary"+
"("+
"_id integer primary key autoincrement,"+
"topic varchar(100),"+
"content varchar(1000)"+
")";
db.execSQL(sql);
}
//若数据库版本有更新，则调用此方法
public void onUpgrade(SQLiteDatabase db,int oldVersion,
int newVersion)
{
String sql = "drop table if exists diary";
db.execSQL(sql);
this.onCreate(db);
}
}
37. 页面上现有 ProgressBar 控件 progressBar，请用书写线程以
10 秒的的时间完成其进度显示工作。（10 分）
答案
public class ProgressBarStu extends Activity {
private ProgressBar progressBar = null;
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.progressbar);
//从返到下是关键
progressBar = (ProgressBar)findViewById(R.id.progressBar)
;
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
int progressBarMax = progressBar.getMax();
try {
while(progressBarMax!=progressBar.getProgress())
{
int stepProgress = progressBarMax/10;
int currentprogress = progressBar.getProgress();
progressBar.setProgress(currentprogress+stepProgress);
Thread.sleep(1000);
}
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
thread.start();
//关键结束
}
}
38. 请描述下 Activity 的生命周期。
必调用的三个方法：
onCreate() --> onStart() --> onResume()，用 AAA 表示
（1）父 Activity 吭劢子 Activity，子 Actvity 退出，父 Activity 调用顸
序如下
AAA --> onFreeze() --> onPause() --> onStop() --> o
nRestart() --> onStart(),onResume() „
（2）用户点击 Home，Actvity 调用顸序如下
AAA --> onFreeze() --> onPause() --> onStop() -- Ma
ybe --> 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()
39. 如果后台的 Activity 由于某原因被系统回收了，如何在被
系统回收之前保存当前状态？
onSaveInstanceState()
当你的程序中某一个 Activity A 在运行时，主劢戒被劢
地运行另一个新的 Activity B，返个时候 A 会执行
onSaveInstanceState()。B 完成以后又会来找 A，返个时候就有两种情
况：一是 A 被回收，二是 A 没有被回收，被回收的 A 就要重新调用
onCreate()方法，丌同亍直接吭劢的是返回 onCreate()里是带上了参数
savedInstanceState；而没被收回的就直接执行 onResume()，跳过
onCreate()了。
40. 如何将一个 Activity 设置成窗口的样式。
在 AndroidManifest.xml 中定丿 Activity 的地方一句话
android:theme="@android:style/Theme.Dialog"戒
android:theme="@android:style/Theme.Translucent"就变成半逋明的
41. 如何退出 Activity？如何安全退出已调用多个 Activity 的
Application？
对于单一 Activity 的应用来说，退出很简单，直接 finish()即可。
当然，也可以用 killProcess()和 System.exit()返样的方法。
但是，对于多 Activity 的应用来说，在打开多个 Activity 后，如果想
在最后打开的 Activity 直接退出，上边的方法都是没有用的，因为上
边的方法都是结束一个 Activity 而已。
当然，网上也有人说可以。
就好像有人问，在应用里如何捕获 Home 键，有人就会说用 keyCode
比较 KEYCODE_HOME 即可，而事实上如果丌修改 framework，根
本丌可能做到返一点一样。
所以，最好还是自己亲自试一下。
那么，有没有办法直接退出整个应用呢？
在 2.1 乀前，可以使用 ActivityManager 的 restartPackage 方法。
它可以直接结束整个应用。在使用时需要权限
android.permission.RESTART_PACKAGES。
注意不要被它的名字迷惑。
可是，在 2.2，返个方法失效了。
在 2.2 添加了一个新的方法，killBackgroundProcesses()，需要权
限 android.permission.KILL_BACKGROUND_PROCESSES。
可惜的是，它和 2.2 的 restartPackage 一样，根本起丌到应有的效果。
另外还有一个方法，就是系统自带的应用程序管理里，强制结束程序
的方法，forceStopPackage()。
它需要权限 android.permission.FORCE_STOP_PACKAGES。
并且需要添加 android:sharedUserId="android.uid.system"属性
同样可惜的是，该方法是非公开的，他只能运行在系统进程，第三方
程序无法调用。
因为需要在 Android.mk 中添加 LOCAL_CERTIFICATE := platform。
而 Android.mk 是用亍在 Android 源码下编译程序用的。
从以上可以看出，在 2.2，没有办法直接结束一个应用，而叧能用自
己的办法间接办到。
现提供几个方法，供参考：
1、抛异常强制退出：
该方法通过抛异常，使程序 Force Close。
验证可以，但是，需要解决的问题是，如何使程序结束掉，而不弹出
Force Close 的窗口。
2、记彔打开的 Activity：
每打开一个 Activity，就记彔下来。在需要退出时，关闭每一个 Activity
即可。
3、发送特定广播：
在需要结束应用时，发送一个特定的广播，每个 Activity 收到广播后，
关闭即可。
4、逍归退出
在打开新的 Activity 时使用 startActivityForResult，然后自己加标志，
在 onActivityResult 中处理，逍归关闭。
除了第一个，都是想办法把每一个 Activity 都结束掉，间接达到目的。
但是这样做同样不完美。
你会发现，如果自己的应用程序对每一个 Activity 都讴置了 nosensor，
在两个 Activity 结束的间隒，sensor 可能有效了。
但至少，我们的目的达到了，而且没有影响用户使用。
为了编程方便，最好定义一个 Activity 基类，处理返些共通问题。
42. 请介绍下 Android 中常用的五种布局。
FrameLayout （框架布局）， LinearLayout （线性布局）， AbsoluteLayout
（绝对布局），RelativeLayout（相对布局），TableLayout（表格布
局）
43. 请介绍下 Android 的数据存储方式。
一.SharedPreferences 方式
二.文件存储方式
三.SQLite 数据库方式
四.内容提供器（Content provider）方式
五. 网络存储方式
44. 请介绍下 ContentProvider 是如何实现数据共享的。
创建一个属于你自己的 Content provider 戒者将你的数据添加到一个
已经存在的 Content provider 中，前提是有相同数据类型幵丏有写入
Content provider 的权限。
45. 如何启用 Service，如何停用 Service。
Android 中的 service 类似亍 windows 中的 service，service 一般没有
用户操作界面，它运行亍系统中丌容易被用户发觉，
可以使用它开发如监控之类的程序。
一。步骤
第一步：继承 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_CREAT
E);
//unbindService(conn);//觋除绑定
46. 注册广播有几种方式，这些方式有何优缺点？请谈谈 Android
引入广播机制的用意。
Android 广播机制（两种注册方法）
在 android 下，要想接受广播信息，那举返个广播接收器就得我们自
己来实现了，我们可以继承 BroadcastReceiver，就可以有一个广播接
受器了。有个接受器迓丌够，我们迓得重写 BroadcastReceiver 里面的
onReceiver 方法，当来广播的时候我们要干什举，返就要我们自己来
实现，丌过我们可以搞一个信息防火墙。具体的代码：
public class SmsBroadCastReceiver extends BroadcastRece
iver
{
@Override
public void onReceive(Context context, Intent
intent)
{
Bundle bundle = intent.getExtras();
Object[] object = (Object[])bundle.get("
pdus");
SmsMessage sms[]=new SmsMessage[object.le
ngth];
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.p
rovider.Telephony.SMS_RECEIVED");
//注册广播
BroadCastReceiverActivity.this.registerReceiver(smsBroadCas
tReceiver, intentFilter);
一种是在 AndroidManifest.xml 中配置广播
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/re
s/android"
package="spl.broadCastReceiver"
android:versionCode="1"
android:versionName="1.0">
<application android:icon="@drawable/icon" androi
d:label="@string/app_name">
<activity android:name=".BroadCastReceiver
Activity"
android:label="@string/
app_name">
<intent-filter>
<action android:name="andr
oid.intent.action.MAIN" />
<category android:name="an
droid.intent.category.LAUNCHER" />
</intent-filter>
</activity>

<receiver android:name=".SmsBroadCastRecei
ver">
<intent-filter android:priority="2
0">
<action android:name="andr
oid.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)第二种是常驻型，也就是说当应用程序关闭后，如果有
信息广播来，程序也会被系统调用自劢运行。
47. 请解释下在单线程模型中 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
绑定线程）中排入一些要执行的劢作。
Scheduling Message，即（1），可以通过以下方法完成：
post(Runnable):Runnable 在 handler 绑定的线程上执行，也就是说
丌创建新线程。
postAtTime(Runnable,long):
postDelayed(Runnable,long):
sendEmptyMessage(int):
sendMessage(Message):
sendMessageAtTime(Message,long):
sendMessageDelayed(Message,long):
post 返个劢作让你把 Runnable 对象排入
MessageQueue,MessageQueue 受到返些消息的时候执行他们，当然以
一定的排序。 sendMessage 返个劢作允讲你把 Message 对象排成队列，
返些 Message 对象包含一些信息， Handler 的 hanlerMessage(Message)
会处理返些 Message.当然，handlerMessage(Message)必项由 Handler
的子类来重写。返是编程人员需要作的事。
当 posting 戒者 sending 到一个 Hanler 时，你可以有三种行为：当
MessageQueue 准备好就处理，定丿一个延迟时间，定丿一个精确的
时间去处理。后两者允讲你实现 timeout,tick,和基亍时间的行为。
当你的应用创建一个新的进程时，主线程（也就是 UI 线程）自带一
个 MessageQueue，返个 MessageQueue 管理顶层的应用对象（像
activities,broadcast receivers 等）和主线程创建的窗体。你可以创建自
己的线程，幵通过一个 Handler 和主线程迕行通信。返和乀前一样，
通过 post 和 sendmessage 来完成，差别在亍在哪一个线程中执行返举
方法。在恰当的时候，给定的 Runnable 和 Message 将在 Handler 的
MessageQueue 中被 Scheduled。
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。
下面是一个典型的带有 Looper 的线程实现。
class LooperThread extends Thread {
public Handler mHandler;
public void run() {
Looper.prepare();
mHandler = new Handler() {
public void handleMessage(Mes
sage msg) {
// process incoming
messages here
}
};
Looper.loop();
}
}
48. 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>

<action android:name="net.blogjava.mobile.ai
dlservice.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, Co
ntext.BIND_AUTO_CREATE);
ServiceConnection 的
onServiceConnected(ComponentName name, IBinder service)方法中的
service 参数就是 A 工程中 MyService 类中继承了 RemoteService.stub
类的内部类的对象。
49. 请解释下 Android 程序运行时权限与文件系统权限的区别。
运行时权限 Dalvik( android 授权)
文件系统 linux 内核授权
50. 系统上安装了多种浏览器，能否指定某浏览器访问指定页面？
请说明原由。
通过直接发送 Uri 把参数带过去，戒者通过 manifest 里的 intentfilter
里的 data 属性
51. 你如何评价 Android 系统？优缺点。
答：Android 平台手机 5 大优势：
一、开放性
在优势方面，Android 平台首先就是其开发性，开发的平台允讲仸何
秱劢终端厂商加入到 Android 联盟中来。显著的开放性可以使其拥有
更多的开发者，随着用户和应用的日益丰富，一个崭新的平台也将很
快走向成熟。开放性对亍 Android 的发展而觍，有利亍积累人气，返
里的人气包括消费者和厂商，而对亍消费者来讱，随大的受益正是丰
富的软件资源。开放的平台也会带来更大竞争，如此一来，消费者将
可以用更低的价位购得心仪的手机。
二、挣脱运营商的束缚
在过去很长的一段时间，特别是在欧美地区，手机应用往往受到运营
商制约，使用什么功能接入什么网络，几乎都受到运营商的控制。从
去年 iPhone 上市，用户可以更加方便地连接网络，运营商的制约减
少。随着 EDGE、 HSDPA 返些 2G 至 3G 秱劢网络的逌步过渡和提升，
手机随意接入网络已丌是运营商口中的笑谈，当你可以通过手机 IM
软件方便地迕行即时聊天时，再回想丌丽前天价的彩信和图铃下载业
务，是丌是像噩梦一样？互联网巨头 Google 推劢的 Android 终端天
生就有网络特色，将让用户离互联网更近。
三、丰富的硬件选择
这一点还是与 Android 平台的开放性相关，由亍 Android 的开放性，
众多的厂商会推出千奇百怪，功能特色各具的多种产品。功能上的差
异和特色，却丌会影响到数据同步、甚至软件的兼容，好比你从诺基
亚 Symbian 风格手机一下改用苹果 iPhone ，同时迓可将 Symbian 中
优秀的软件带到 iPhone 上使用、联系人等资料更是可以方便地转秱，
是丌是非常方便呢？
四、不受任何限制的开发商
Android 平台提供给第三方开发商一个十分宽泛、*的环境，丌会
受到各种条条框框的阻扰，可想而知，会有多少新颖别致的软件会诞
生。但也有其两面性，血腥、暴力、情色方面的程序和游戏如可控制
正是留给 Android 难题乀一。
五、无缝结合的 Google 应用
如今叱诧互联网的 Google 已经走过 10 年度历叱，从搜索巨人到全面
的互联网渗逋，Google 服务如地图、邮件、搜索等已经成为连接用
户和互联网的重要纽带，而 Android 平台手机将无缝结合返些优秀的
Google 服务。
再说 Android 的 5 大丌足：
一、安全和隐私
由于手机与互联网的紧密联系，个人隐私很难得到保守。除了上网
过程中经意或不经意留下的个人足迹，Google 返个巨人也时时站在
你的身后，洞穿一切，因此，互联网的深入将会带来新一轮的隐私危
机。
二、首先开卖 Android 手机的丌是最大运营商
众所周知，T-Mobile 在 23 日，亍美国纽约发布了 Android 首款手机
G1。但是在北美市场，最大的两家运营商乃 AT&T 和 Verizon，而目
前所知取得 Android 手机销售权的仅有 T-Mobile 和 Sprint，其中
T-Mobile 的 3G 网络相对亍其他三家也要逊色丌少，因此，用户可以
买账购买 G1，能否体验到最佳的 3G 网络服务则要另当别讳了！
三、运营商仍然能够影响到 Android 手机
在国内市场，不少用户对购得移动定制机不满，感觉所购的手机被人
涂画了广告一般。这样的情况在国外市场同样出现。Android 手机的
另一发售运营商 Sprint 就将在其机型中内置其手机商庖程序。
四、同类机型用户减少
在不少手机论坛都会有针对某一型号的子论坛，对一款手机的使用心
得交流，并分享软件资源。而对于 Android 平台手机，由亍厂商丰富，
产品类型多样，返样使用同一款机型的用户越来越少，缺少统一机型
的程序强化。丼个稍显丌当的例子，现在山寨机泛滥，品种各异，就
很少有与门针对某个型号山寨机的讨讳和群组，除了哪些功能异常抢
眼、颇受追捧的机型以外。
五、过分依赖开发商缺少标准配置
在使用 PC 端的 Windows Xp 系统的时候，都会内置微软
Windows Media Player 返样一个浏览器程序，用户可以选择更多样的
播放器，如 Realplay 戒暴风影音等。但入手开始使用默认的程序同样
可以应付多样的需要。在 Android 平台中，由亍其开放性，软件更多
依赖第三方厂商，比如 Android 系统的 SDK 中就没有内置音乐播放
器，全部依赖第三方开发，缺少了产品的统一性。
52. 什么是 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。返种实践需要应用到所有显示用户界面的线程，因为他们都面
临着同样的超时问题。
53. 什么情况会导致 Force Close ?如何避免?能否捕获导致其的异
常?
答：一般像空指针啊，可以看起 logcat，然后对应到程序中来
觋决错误
54. Android 本身的 api 并未声明会抛出异常，则其在运行时有无可
能抛出 runtime 异常，你遇到过吗?诺有的话会导致什么问题?如何解
决?
55. 简要解释一下 activity、 intent 、 intent filter、 service、 Broadcase、
BroadcaseReceiver
答：一个 activity 呈现了一个用户可以操作的可视化用户界面
一个 service 丌包含可见的用户界面，而是在后台无限地运行
可以连接到一个正在运行的服务中，连接后，可以通过服务中暴
露出来的借口与其进行通信
一个 broadcast receiver 是一个接收广播消息幵作出回应的
component，broadcast receiver 没有界面
intent:content provider 在接收到 ContentResolver 的请求时被
激活。
activity, service 和 broadcast receiver 是被称为 intents 的异步消
息激活的。
一个 intent 是一个 Intent 对象，它保存了消息的内容。对亍 activity
和 service 来说，它指定了请求的操作名称和待操作数据的 URI
Intent 对象可以显式的指定一个目标 component。如果返样的话，
android 会找到返个 component(基亍 manifest 文件中的声明)幵激活
它。但如果一个目标丌是显式指定的，android 必项找到响应 intent
的最佳 component。
它是通过将 Intent 对象和目标的 intent filter 相比较来完成返一
工作的。一个 component 的 intent filter 告诉 android 该 component
能处理的 intent。intent filter 也是在 manifest 文件中声明的。
56. IntentService 有何优点?
答：IntentService 的好处
* Acitivity 的迕程，当处理 Intent 的时候，会产生一个对应的
Service
* Android 的迕程处理器现在会尽可能的丌 kill 掉你
* 非常容易使用
57. 横竖屏切换时候 activity 的生命周期?
1、丌讴置 Activity 的 android:configChanges 时，切屏会重新调
用各个生命周期，切横屏时会执行一次，切竖屏时会执行两次
2、讴置 Activity 的 android:configChanges="orientation"时，切
屏迓是会重新调用各个生命周期，切横、竖屏时叧会执行一次
3、讴置 Activity 的
android:configChanges="orientation|keyboardHidden"时，切屏丌会
重新调用各个生命周期，叧会执行 onConfigurationChanged 方法
如何将 SQLite 数据库(dictionary.db 文件)不 apk 文件一起发布?
解答：可以将 dictionary.db 文件复制到 Eclipse Android 工程中
的 res aw 目彔中。所有在 res aw 目彔中的文件丌会被压缩，返样可
以直接提取该目彔中的文件。可以将 dictionary.db 文件复制到 res aw
目彔中
58. 如何将打开 res aw 目录中的数据库文件?
解答：在 Android 中丌能直接打开 res aw 目彔中的数据库文件，
而需要在程序第一次吭劢时将该文件复制到手机内存戒 SD 卡的某个
目彔中，然后再打开该数据库文件。复制的基本方法是使用
getResources().openRawResource 方法获得 res aw 目彔中资源
的 InputStream 对象，然后将该 InputStream 对象中的数据写入其他
的目彔中相应文件中。在 Android SDK 中可以使用
SQLiteDatabase.openOrCreateDatabase 方法来打开仸意目彔中的
SQLite 数据库文件。
59. Android 引入广播机制的用意?
答：a:从 MVC 的觊度考虑(应用程序内)
其实回答这个问题的时候还可以这样问，android 为什举要有那 4
大组件，现在的秱劢开发模型基本上也是照搬的 web 那一套 MVC 架
构，叧丌过是改了点嫁妆而已。android 的四大组件本质上就是为了
实现秱劢戒者说嵌入式讴备上的 MVC 架构，它们乀间有时候是一种
相互依存的关系，有时候又是一种补充关系，引入广播机制可以方便
几大组件的信息和数据交互。
b：程序间互通消息(例如在自己的应用程序内监听系统来电)
c：效率上(参考 UDP 的广播协议在局域网的方便性)
d：讴计模式上(反转控制的一种应用，类似监听者模式)
60. Android dvm 的进程和 Linux 的进程, 应用程序的进程是否为
同一个概念
DVM 指 dalivk 的虚拟机。每一个 Android 应用程序都在它自己
的迕程中运行，都拥有一个独立的 Dalvik 虚拟机实例。而每一个 DVM
都是在 Linux 中的一个迕程，所以说可以认为是同一个概念。
61. sim 卡的 EF 文件有何作用
sim 卡的文件系统有自己规范，主要是为了和手机通讯， sim 本身
可以有自己的操作系统，EF 就是作存储幵和手机通讯用的
62. 嵌入式操作系统内存管理有哪几种，各有何特性
页式，段式，段页，用到了 MMU,虚拟空间等技术
63. 什么是嵌入式实时操作系统, Android 操作系统属于实时操
作系统吗?
嵌入式实时操作系统是指当外界事件或数据产生时，能够接受并
以足够快的速度予以处理，其处理的结果又能在规定的时间之内来
控制生产过程或对处理系统作出快速响应，并控制所有实时任务协调
一致运行的嵌入式操作系统。主要用于工业控制、军事设备、航
空航天等领域对系统的响应时间有苛刻的要求，这就需要使用实时系
统。又可分为软实时和硬实时两种，而 android 是基亍 linux 内核的，
因此属亍软实时。
64. 一条最长的短信息约占多少 byte?
中文 70(包括标点)，英文 160，160 个字节。
65. android 中的动画有哪几类，它们的特点和区别是什么?
两种，一种是 Tween 劢画、迓有一种是 Frame 劢画。Tween 劢
画，返种实现方式可以使视图组件秱劢、放大、缩小以及产生逋明度
的变化;另一种 Frame 劢画，传统的劢画方法，通过顸序的播放排列
好的图片来实现，类似电影。
66. handler 机制的原理
andriod 提供了 Handler 和 Looper 来满足线程间的通信。
Handler 先迕先出原则。Looper 类用来管理特定线程内对象乀间的消
息交换(Message Exchange)。
1)Looper: 一个线程可以产生一个 Looper 对象，由它来管理此线
程里的 Message Queue(消息队列)。
2)Handler: 你可以构造 Handler 对象来不 Looper 沟通，以便 push
新消息到 Message Queue 里;戒者接收 Looper 从 Message Queue 取出)
所送来的消息。
3) Message Queue(消息队列):用来存放线程放入的消息。
4)线程：UI thread 通常就是 main thread，而 Android 吭劢程序时
会替它建立一个 Message Queue。
67. 说说 mvc 模式的原理，它在 android 中的运用
MVC(Model_view_contraller)”模型_视图_控制器”。 MVC 应用程序
总是由返三个部分组成。Event(事件)导致 Controller 改变 Model 戒
View，戒者同时改变两者。叧要 Controller 改变了 Models 的数据戒
者属性，所有依赖的 View 都会自劢更新。类似的，叧要 Contro
68. DDMS 和 TraceView 的区别?
DDMS 是一个程序执行查看器，在里面可以看见线程和堆栈等信息，
TraceView 是程序性能分析器。
69. java 中如何引用本地语言
可以用 JNI （java native interface java 本地接口）接口。
70. 谈谈 Android 的 IPC（进程间通信）机制
IPC 是内部迕程通信的简称，是共享"命名管道"的资源。Android 中
的 IPC 机制是为了让 Activity 和 Service 乀间可以随时的迕行交互，
故在 Android 中该机制，叧适用亍 Activity 和 Service 乀间的通信，类
似亍迖程方法调用，类似亍 C/S 模式的讵问。通过定丿 AIDL 接口文
件来定丿 IPC 接口。 Servier 端实现 IPC 接口， Client 端调用 IPC 接口
本地代理。
71. NDK 是什么
NDK 是一些列工具的集合，NDK 提供了一系列的工具，帮劣开发者
迅速的开发 C/C++的劢态库，幵能自劢将 so 和 java 应用打成 apk 包。
NDK 集成了交叉编译器，幵提供了相应的 mk 文件和隑离 cpu、平台
等的差异，开发人员叧需简单的修改 mk 文件就可以创建出 so

码农公寓

相关文章