Andriod之132个最佳问题

1.常用的存储方式有哪些？

（五种，说出哪五种，五种存储方式什么情况下用。）注意sharepreferes对象支持读取不支持写入，写入引用Editor。

SQLite：

SQLite是一个轻量级的数据库，支持基本SQL语法，是常被采用的一种数据存储方式。Android为此数据库提供了一个名为SQLiteDatabase的类，封装了一些操作数据库的API。

SharedPreference：

除SQLite数据库外，另一种常用的数据存储方式，其本质就是一个xml文件，常用于存储较简单的参数设置。

File：

即常说的文件（I/O）存储方法，常用语存储大数量的数据，但是缺点是更新数据将是一件困难的事情。

ContentProvider:

Android 系统中能实现所有应用程序共享的一种数据存储方式，由于数据通常在各应用间的是互相私密的，所以此存储方式较少使用，但是其又是必不可少的一种存储方式。 例如音频，视频，图片和通讯录，一般都可以采用此种方式进行存储。每个ContentProvider都会对外提供一个公共的URI（包装成Uri对 象），如果应用程序有数据需要共享时，就需要使用ContentProvider为这些数据定义一个URI，然后其他的应用程序就通过 Content Provider传入这个URI来对数据进行操作。

网络存储：

从网络读取数据和写入数据。 Android提供了通过网络来实现数据的存储和获取的方法。

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

 

*2.安卓中动画有几类，他们的特点和区别？

   两种，一种是补间动画，还有一种是帧动画，帧动画类似于放电影，通过播放已经排列放好的图片来实现。

补间动画的实现定义开始和结束，中间由系统计算得出效果有透明，位移，放大缩小等等。

自定义录音或者进度条过程，会应用到帧动画，补间动画，一般用于应用的欢迎界面。

(菜单弹出，例如赞和评论，是个动画过程。)

3.handler机制原理

Handler主要用于线程间的通信。

一个Handler允许发送和处理Message和Runable对象，UI主线程会自动分配一个Looper（消息轮询器），每个Looper中封装着MessageQueue（消息队列），遵循先进先出原则。Looper负责不断的从自己的消息队列里取出队头的任务或消息执行。一般是在子线程执行完耗时操作之后，通过Handler的sendMessage或post方法将Message和Runable对象传递给MessageQueue，而且在这些对象离开MessageQueue时，Handler负责执行他们（用到handleMessage方法，主要执行刷新UI的代码）。 
其中Message类就是定义了一个信息，这个信息中包含一个描述符和任意的数据对象，这个信息被用来传递给Handler.Message对象提供额外的两个int域和一个Object域。

 

字面以外加上关联点。

4除了handler和子线程，还有一个处理线程的是什么，主要方法是什么？

AsynTask，doInbackGround+onPostExecute

doInBackground() 这个方法运行在后台线程中，主要负责执行那些很耗时的操作，如访问网络。该方法必须重写。

onPostExecute(Result) 这个方法运行于UI主线程，在doInBackground(Params…)方法执行后调用，该方法用于接收后台任务执行后返回的结果，刷新UI显示

5.tcp和udp区别.

TCP---传输控制协议,提供的是面向连接、可靠的字节流服务,传输数据前经过“三次握手”建立连接，保证数据传输的可靠性，但效率比较低。一般用于对于数据传输安全性较高的场合。

UDP---用户数据报协议，是一个简单的面向数据报的运输层协议，面向无连接。UDP不提供可靠性，数据传输可能发生错序，丢包，但效率较高。一般用于对于实时性要求较高的场合。

6线程之间的通信方式（如何避免ANR）

（1）. AsyncTask，其中doInBackground()和onPostExecute(Result)两个方法非常重要

doInBackground() 这个方法运行在后台线程中，主要负责执行那些很耗时的操作，如访问网络。该方法必须重写。

onPostExecute(Result) 这个方法运行于UI主线程，在doInBackground(Params…)方法执行后调用，该方法用于接收后台任务执行后返回的结果，刷新UI显示。

（2.）子线程 + handler

在子线程中执行完耗时操作需要刷新UI时，通过handler.sendMessage()发消息给主线程， 然后在主线程Handler中的handleMessage()方法中执行刷新UI操作

7.activity的生命周期

 

1）.启动Activity：系统会先调用onCreate方法，然后调用onStart方法，最后调用onResume，Activity进入运行状态。

2）.当前Activity被其他Activity覆盖其上或被锁屏：系统会调用onPause方法，暂停当前Activity的执行。

3）.当前Activity由被覆盖状态回到前台或解锁屏：系统会调用onResume方法，再次进入运行状态。

4）.当前Activity转到新的Activity界面或按Home键回到主屏，自身退居后台：系统会先调用onPause方法，然后调用onStop方法，进入停滞状态。

5）.用户后退回到此Activity：系统会先调用onRestart方法，然后调用onStart方法，最后调用onResume方法，再次进入运行状态。

6）.当前Activity处于被覆盖状态或者后台不可见状态，即第2步和第4步，系统内存不足，杀死当前Activity，而后用户退回当前Activity：再次调用onCreate方法、onStart方法、onResume方法，进入运行状态。

7）.用户退出当前Activity：系统先调用onPause方法，然后调用onStop方法，最后调用onDestory方法，结束当前Activity。

 

*8.ArrayList和LinkedList区别？

存数据，ArrayList数组存储数据，索引值以下标来搜索，查询比较方，删除增加比较麻烦，但是linkedList以链表式存储数据，对于增删比较方便。

9.安卓内存的优化？*

1）静态变量引起内存泄露

在代码优化的过程中，我们需要对代码中的静态变量特别留意。静态变量是类相关的变量， 它的生命周期是从这个类被声明，到这个类彻底被垃圾回收器回收才会被销毁。所以，一般情况下，静态变量从所在的类被使用开始就要一直占用着内存空间，直到 程序退出。如果不注意，静态变量引用了占用大量内存的资源，造成垃圾回收器无法对内存进行回收，就可能造成内存的浪费

2）使用Application的Context

在Android中，Application Context的生命周期和应用的生命周期一样长，而不是取决于某个Activity的生命周期。如果想保持一个长期生命的对象，并且这个对象需要一个 Context，就可以使用Application对象。可以通过调用Context.getApplicationContext()方法或者 Activity.getApplication()方法来获得Application对象。

3）及时关闭资源

Cursor是Android查询数据后得到的一个管理数据集合的类。正常情况下，如 果我们没有关闭它，系统会在回收它时进行关闭，但是这样的效率特别低。如果查询得到的数据量较小时还好，如果Cursor的数据量非常大，特别是如果里面 有Blob信息时，就可能出现内存问题。所以一定要及时关闭Cursor。

4）使用Bitmap及时调用recycle()

前面的章节讲过，在不使用Bitmap对象时，需要调用recycle()释放内存，然后将它设置为null。虽然调用recycle()并不能保证立即释放占用的内存，但是可以加速Bitmap的内存的释放。

在代码优化的过程中，如果发现某个Activity用到了Bitmap对象，却没有显式的调用recycle()释放内存，则需要分析代码逻辑，增加相关代码，在不再使用Bitmap以后调用recycle()释放内存。

    5）对Adapter进行优化

下面以构造ListView的BaseAdapter为例说明如何对Adapter进行优化。

软引用和弱引用。

如果一个对象只具有软引用，那么如果内存空间足够，垃圾回收器就不会回收它；如果内存 空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存。软引用可以和一个引用队 列（ReferenceQueue）联合使用，如果软引用所引用的对象被垃圾回收，Java虚拟机就会把这个软引用加入到与之关联的引用队列中。

如果一个对象只具有弱引用，那么在垃圾回收器线程扫描的过程中，一旦发现了只具有弱引 用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象。弱 引用也可以和一个引用队列（ReferenceQueue）联合使用，如果弱引用所引用的对象被垃圾回收，Java虚拟机就会把这个弱引用加入到与 之关联 的引用队列中。

弱引用与软引用的根本区别在于：只具有弱引用的对象拥有更短暂的生命周期，可能随时被回收。而只具有软引用的对象只有当内存不够的时候才被回收，在内存足够的时候，通常不被回收。

UI优化

在Android应用开发过程中，屏幕上控件的布局代码和程序的逻辑代码通常是分开 的。界面的布局代码是放在一个独立的xml文件中的，这个文件里面是树型组织的，控制着页面的布局。通常，在这个页面中会用到很多控件，控件会用到很多的 资源。Android系统本身有很多的资源，包括各种各样的字符串、图片、动画、样式和布局等等，这些都可以在应用程序中直接使用。这样做的好处很多，既 可以减少内存的使用，又可以减少部分工作量，也可以缩减程序安装包的大小。

 

10.framgment生命周期？

 

oncreate，onstart，onrestart，onstop，onresume，ondestroy，onpause，onAttach，onCreateView，onDettach，onDestroyView;（和activity的生命周期比较，会更好）

 MyFragment onAttach() 粘贴到activity上
MyFragment onCreate() fragment创建
MyFragment onCreateView() fragment创建自己的视图

MainActivity onCreate()
MyFragment onActivityCreated() 可以处理fragment数据的初始化

MainActivity onStart()
 MyFragment onStart()

MainActivity onResume()
MyFragment onResume()

按后退键
MyFragment onPause()
MainActivity onPause()

 MyFragment onStop()
 MainActivity onStop()

MyFragment onDestoryView() 销毁掉自己的视图
MyFragment onDestory()
MyFragment onDetach() 解除和activity的关系

MainActivity onDestory()

 

11·图片异步加载怎么做？

可定义图片异步加载工具类，核心方式实现思路如下：

1.先从内存缓存（Map<String,SoftReference<Bitmap>>中获取图片显示

2.获取不到的话从本地SD卡里获取并显示

3.都获取不到的话通过子线程从网络加载图片并保存到内存及SD卡中并通过handler显示

12·service和Thread区别？

http://wenku.baidu.com/link?url=p-P0sCqgr7y1w-mkd-B8DIwpIppzEud9MCVtttYWp1AWAmfZEfLyqKYKvAJWtXE2N2X8WS4vNHutJRBaG_RAC9i1AwqY5Wh7Zh4s-XHixju

 

1）.Thread：Thread 是程序执行的最小单元，它是分配CPU的基本单位。可以用 Thread 来执行一些异步的操作。 

2).Service：Service 是android的一种机制，当它运行的时候如果是Local Service，那么对应的 Service 是运行在主进程的 main 线程上的。如：onCreate，onStart 这些函数在被系统调用的时候都是在主进程的 main 线程上运行的。如果是Remote Service，那么对应的 Service 则是运行在独立进程的 main 线程上

13·内存泄露如何解决？

http://wenku.baidu.com/view/03dc4b46b307e87100f69604.html

 

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

2）、 构造adapter没有使用缓存contentview 

   衍生的listview优化问题：减少创建View的对象，充分使用contentview，可以使用静态类来处理优化getView的过程 3、Bitmap对象不使用时采用recycle()释放内存 4、Activity中的对象生命周期大于Activity

3.）Bitmap对象不使用recycle（）释放内存

4.）Activity中的对象生命周期大于Activity；

内存泄露大多数都是由于相同的错误导致的，即：对Context拥有较长时间的引用。

避免Context相关的内存泄露，记住以下事情： 

   不要保留对Context-Activity长时间的引用（对Activity的引用的时候，必须确保拥有和Activity一样的生命周期） 

   尝试使用Context-Application来替代Context-Activity 

   如果你不想控制内部类的生命周期，应避免在Activity中使用非静态的内部类，而应该使用静态的内部类，并在其中创建一个对Activity的弱引用。这种情况的解决办法是使用一个静态的内部类，其中拥有对外部类的WeakReference，如同ViewRoot和它的Winner类那样 

   GC（垃圾回收）不能解决内存泄露问题 

 

 

14·MVC的使用？

mvc是model,view,controller的缩写，mvc包含三个部分： 

　　l模型（model）对象：是应用程序的主体部分，所有的业务逻辑都应该写在该层。 

　　l视图（view）对象：是应用程序中负责生成用户界面的部分。也是在整个mvc架构中用户唯一可以看到的一层，接收用户的输入，显示处理结果。 

　　l控制器（control）对象：是根据用户的输入，控制用户界面数据显示及更新model对象状态的部分，控制器更重要的一种导航功能，想用用户出发的相关事件，交给m哦得了处理。 

　　android鼓励弱耦合和组件的重用，在android中mvc的具体体现如下： 

　 　1)视图层（view）：一般采用xml文件进行界面的描述，使用的时候可以非常方便的引入，当然，如何你对android了解的比较的多了话，就一定 可以想到在android中也可以使用javascript+html等的方式作为view层，当然这里需要进行java和javascript之间的通 信，幸运的是，android提供了它们之间非常方便的通信实现。 

　　2)控制层（controller）：android的控制层的重 任通常落在了众多的acitvity的肩上，这句话也就暗含了不要在acitivity中写代码，要通过activity交割model业务逻辑层处理， 这样做的另外一个原因是android中的acitivity的响应时间是5s，如果耗时的操作放在这里，程序就很容易被回收掉。 

　　3)模型层（model）：对数据库的操作、对网络等的操作都应该在model里面处理，当然对业务计算等操作也是必须放在的该层的。 

15·常用的设计模式

单例设计模式

       所谓单例设计模式简单说就是无论程序如何运行，采用单例设计模式的类（Singleton类）永远只会有一个实例化对象产生。具体实现步骤如下：

      (1) 将采用单例设计模式的类的构造方法私有化（采用private修饰）。

      (2) 在其内部产生该类的实例化对象，并将其封装成private static类型。

      (3) 定义一个静态方法返回该类的实例。

工厂设计模式

       程序在接口和子类之间加入了一个过渡端，通过此过渡端可以动态取得实现了共同接口的子类实例化对象

代理设计模式

       指由一个代理主题来操作真实主题，真实主题执行具体的业务操作，而代理主题负责其他相关业务的处理。比如生活中的通过代理访问网络，客户通过网络代理连接网络（具体业务），由代理服务器完成用户权限和访问限制等与上网相关的其他操作（相关业务）。

观察者设计模式

       所谓观察者模式，举个例子现在许多购房者都密切观察者房价的变化，当房价变化时，所有购房者都能观察到，以上的购房者属于观察者，这便是观察者模式。

       java中可以借助Observable类和Observer接口轻松实现以上功能。当然此种模式的实现也不仅仅局限于采用这两个类。

适配器模式

        如果一个类要实现一个具有很多抽象方法的接口，但是本身只需要实现接口中的部分方法便可以达成目的，所以此时就需要一个中间的过渡类，但此过渡类又不希望 直接使用，所以将此类定义为抽象类最为合适，再让以后的子类直接继承该抽象类便可选择性的覆写所需要的方法，而此抽象类便是适配器类。

策略模式 Strategy

       策略模式定义一系列的算法，把它们一个个封装起来，并且使它们可以相互替换。本模式使得算法的变化不会影响到使用算法的客户。

       策略模式将每一个算法封装到一个具有公共接口的独立类中，解除了客户与具体算法的直接耦合，是客户改变算法更为容易。

        策略模式+简单工厂+反射+配置文件可以组成更为灵活的方式。 

 

16·面向对象的特征？

封装

封装最好理解了。封装是面向对象的特征之一，是对象和类概念的主要特性。

封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。

继承

面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。

多态

多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。

实现多态，有二种方式，覆盖，重载。

覆盖，是指子类重新定义父类的虚函数的做法。

重载，是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。

 

17·程序结束的时候，如何处理Activity的？*

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

18·配置文件中存放什么？

四大组件，意图，权限，第三方key，版本号等

19·Final ，finally，finalized，区别；

final用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不

可继承。

finally是异常处理语句结构的一部分，表示总是执行。

finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此

方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。

 

20·NDK是什么？

NDK 是 Native Development Kit 的简称。它是一个工具集，集成了 Android 的交叉编译环境，并提供了一套比较方便的 Makefile ，可以帮助开发者快速开发 C 或是 C++ 的动态库，并自动的将 so 和 java 程序打包成 apk ，在 Android 上运行。Android 上，应用程序的开发，大部分基于 Java 语言来实现。要使用 c 或是 c++ 的程序或库，就需要使用 NDK 来实现。

 

21百度地图和谷歌地图的优缺点？

优势：

1一打开百度地图页面，显示的就是目前所在城市地图，谷歌地图不然。

2百度地图的界面，百度地图很多都是在显眼位置用文字做提示，一目了然，谷歌界面有点炫，很多用图标来表示，但是用起来相对复杂，不熟悉的用户需要确定这个图标是否是所需要选择的。

而百度地图搜索框下就直接有“公交”“驾车”的选项，界面简洁直接很多，谷歌地图需要点击获取路线，再点击小图标来选择“公交”这些选项，而且图标不够引人注目，使用起来相对复杂些，试想一个很少用网络地图的人分别使用二者地图，那个更方便呢？应该是百度，大多数用户通过地图是查询位置-这个地方在哪，周围有什么地物，查询路线-从一个方到另一个地方如何到达，用百度地图，这些问题很容易解决，而用谷歌地图得摆弄一会儿。

3百度地图的查询路线更好,首先还是界面更简洁直接，然后是数据的问题，先不管为他们提供数据的公司如何，刚刚特意同时查了下，同样地起点和终点， 百度地图给出了5条路线，谷歌地图给出的是4条路线，而且百度地图路线的选择时可以选择“较快捷”“少换乘”“少步行”三种方式，更方便。打车费用也直接 显示出来，而且个人体会10元内的打车费用基本正确。

4百度地图有个视野内搜索功能，可以很方便地查找到目标位置，谷歌地图没有。这个很重要。

5一个重要界面布局问题，百度地图是地图视野在左，而谷歌地图是地图视野在右，我们现在时喜欢从左到右看东西啊，这点百度地图更符合用户习惯。 （当然也可能是我常用百度地图，所以这么觉得）

 PS:刚在知乎上有朋友说到——因“左图右列表”强调的是“地图”，反之强调的是“搜索”；我们发现用户在经过这么些年的教育后，“不在乎”地图在哪边，相对其它体验，这一点影响用户选择服务的权重并不高。

6百度地图已经和都市圈合作推出了部分城市如北京、上海、深圳、广州的三维地图，谷歌地图没有。

7百度地图地图视野上方有个截图功能，可以直接拉框截图，谷歌地图没有。 

8以北京实时路况信息为例，直接输入北京查询，百度地图显示的是主城区的实时路况，而谷歌显示的区域很大 ，包括了密云、廊坊市了，但是实时路况信息还是显示的主城区，显示路况的彩色条就全挤在一起了，设计得不如百度好。

8使用百度的占大多数，经常可以听到“百度一下啊”的话语。随之带来百度地图的使用率也相对较高。

9百度地图的地图百宝箱、房产、天气等信息。

劣势：

1如果需要从网络地图上获取数据的话，谷歌地图完胜，而且还有谷歌地球在一旁辅助，如虎添翼，从网上各种各样的谷歌地图相关工具软件就可以看出。

2路线查询时输入地点名称却有多个符合条件时，会给出一个下拉菜单给予选择，同一地点谷歌地图提供的数据精确到街道，而百度地图精确到区。

3谷歌地图可以将侧边栏隐藏起来，看到更大的地图视野，而百度地图是点击全屏来显示更大的视野，两种切换方式比起来谷歌的更舒服。

4谷歌地图有个分享链接功能，而且还提供“粘贴 HTML 以便嵌入到网站”这一功能，百度没有。

5界面布局百度地图更简洁，但是色彩搭配上和画面感上谷歌地图更好。 

6谷歌的品牌形象占优。

 

22·安卓的系统架构

http://wenku.baidu.com/view/3ef50eddd15abe23482f4d7e.html

 

应用层：使用Java语言进行开发的一些应用程序

应用框架曾：主要是谷歌发布的一些操作支持的类库（API框架），开发人员可以使用这些类库方便的进行程序开发，但是在开发时必须遵守框架的开发原则

系统运行库层：当使用安卓框架层进行开发时，安卓操作系统会自动使用一些c/c++的库文件来支持所使用的各个组件，使其可以更好的为程序服务；

Linux内核层：安卓操作系统主要是基于Linux内核，程序的安全性，驱动程序，进程管理等都由Linux内核提供。

23.listView优化

1)、convertView复用，对convetView进行判空，当convertView不为空时重复使用，为空则初始化，从而减少了很多不必要的View的创建

2)定义一个ViewHolder，封装Listview Item条目中所有的组件，将convetView的tag设置为ViewHolder,不为空时通过ViewHolder的属性获取对应组件即可

3)、当ListView加载数据量较大时可以采用分页加载和图片异步加载

24·安卓上安装了多个浏览器，能否指定页面访问；

通过直接发送URI把参数带过去，或者通过Manifest里的intentfilter的data属性

25·简述音乐播放的方式与区别？

1）：MediaPlayer：主要用于播放音频，可以播放视频，但是一般不用其进行视频播放。

   2）：SoundPool： 主要用播放一些短促的声音片段，主要优势是cpu资源占有量低，反应延迟小。

 

*26·工作中如何利用线程池的？】

Java通过Executors提供四种线程池，分别为：
newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

*27·onTouch和onTouchEvent区别？

1.onTouch方法：
onTouch方法是View的 OnTouchListener借口中定义的方法。
当一个View绑定了OnTouchLister后，当有touch事件触发时，就会调用onTouch方法。
（当把手放到View上后，on  Touch方法被一遍一遍地被调用）

2.onTouchEvent方法：
onTouchEvent方法是override 的Activity的方法。
重新了Activity的onTouchEvent方法后，当屏幕有touch事件时，此方法就会别调用。

 

 28·JSON的结构？

json是一种轻量级的数据交换格式，

json简单说就是对象和数组，所以这两种结构就是对象和数组两种结构，通过这两种结构可以表示各种复杂的结构

1、对象：对象表示为“{}”扩起来的内容，数据结构为 {key：value,key：value,...}的键值对的结构，在面向对象的语言中，key为对象的属性，value为对应的属性值，所以很容易理解，取值方法为 对象.key 获取属性值，这个属性值的类型可以是 数字、字符串、数组、对象几种。

2、数组：数组在json中是中括号“[]”扩起来的内容，数据结构为 ["java","javascript","vb",...]，取值方式和所有语言中一样，使用索引获取，字段值的类型可以是 数字、字符串、数组、对象几种。

经过对象、数组2种结构就可以组合成复杂的数据结构了。

29·SIM卡的EF文件有何作用？

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

30.最长的短信多长，多少个字节？

70个汉字，140个字节

31·&和&&的区别

一个位运算符，一个是逻辑运算符

32·Java的基本特征

封装

封装最好理解了。封装是面向对象的特征之一，是对象和类概念的主要特性。

封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。

继承

面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。

多态

多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。

实现多态，有二种方式，覆盖，重载。

覆盖，是指子类重新定义父类的虚函数的做法。

重载，是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。

 

33·注册广播的方式

android中，不同进程之间传递信息要用到广播，可以有两种方式来实现。 
第一种方式：在Manifest.xml中注册广播，是一种比较推荐的方法，因为它不需要手动注销广播（如果广播未注销，程序退出时可能会出错）。 
具体实现在Manifest的application中添加： 
<receiver android:name=".mEvtReceiver"> 
<intent-filter> 
<action android:name="android.intent.action.BOOT_COMPLETED" /> 
</intent-filter> 
</receiver> 
上面两个android:name分别是广播名和广播的动作（这里的动作是表示系统启动完成），如果要自己发送一个广播，在代码中为： 
Intent i = new Intent("android.intent.action.BOOT_COMPLETED"); 
sendBroadcast(i); 
这样，广播就发出去了，然后是接收。 
接收可以新建一个类，继承至BroadcastReceiver，也可以建一个BroadcastReceiver的实例，然后得写onReceive方法，实现如下： 
protected BroadcastReceiver mEvtReceiver = new BroadcastReceiver() { 
@Override 
public void onReceive(Context context, Intent intent) { 
String action = intent.getAction(); 
if (action.equals("android.intent.action.BOOT_COMPLETED")) { 
//Do something 
} 
} 
}; 

第二种方式，直接在代码中实现，但需要手动注册注销，实现如下： 
IntentFilter filter = new IntentFilter(); 
filter.addAction("android.intent.action.BOOT_COMPLETED"); 
registerReceiver(mEvtReceiver, filter); //这时注册了一个recevier ,名为mEvtReceiver，然后同样用上面的方法以重写onReceiver， 
最后在程序的onDestroy中要注销广播，实现如下： 
@Override 
public void onDestroy() { 
super.onDestroy(); 
unregisterReceiver(mPlayerEvtReceiver); 
} 



Android系统中的广播是广泛用于应用程序之间通信的一种手段，它类似于事件处理机制，不同的地方就是广播的处理是系统级别的事件处理过程（一般事件处理是控件级别的）。在此过程中仍然是离不开Intent对象，理解广播事件的处理过程，灵活运用广播处理机制，在关键之处往往能实现特别的效果， 
在Android 中如果要发送一个广播必须使用sendBroadCast 向系统发送对其感兴趣的广播接收器中。 
使用广播必须要有一个intent 对象必设置其action动作对象 
使用广播必须在配置文件中显式的指明该广播对象 
每次接收广播都会重新生成一个接收广播的对象 
在BroadCast 中尽量不要处理太多逻辑问题，建议复杂的逻辑交给Activity 或者 Service 去处理 

34·异步和同步的区别？

同步：提交请求->等待服务器处理->处理完毕返回 这个期间客户端浏览器不能干任何事 异步: 请求通过事件触发->服务器处理（这是浏览器仍然可以作其他事情）->处理完毕

*35·Afinal和XUtils的区别？

Xutils是基于Afinal的

xUtils 包含了很多实用的android工具。

xUtils 源于Afinal框架，对Afinal进行了适当的精简，和一些适度的扩展和重构。

xUtils 具有Afinal的一些特性如：无需考虑bitmap在android中加载的时候oom的问题和快速滑动的时候图片加载位置错位等问题； 简洁，约定大于配置...

 

DbUtils模块：android中的orm框架，一行代码就可以进行增删改查。

ViewUtils模块：android中的ioc框架，完全注解方式就可以进行UI绑定和事件绑定。

HttpUtils模块：支持同步，异步方式的请求，支持大文件上传；支持GET,POST,PUT,MOVE,COPY,DELETE,HEAD请求，支持multipart上传设置subtype如related。

BitmapUtils模块：加载bitmap的时候无需考虑bitmap加载过程中出现的oom和android容器快速滑动时候出 现的图片错位等现象；内存管理使用lru算法，更好的管理bitmap内存；可配置线程加载线程数量，缓存大小，缓存路径，加载显示动画等...

 

36·ContentProvider的URI的配置？

清单文件之指定URI或者代码里面指定URI，contentProvider通过URI访问数据

37·AIDL是什么？

AIDL全称Android Interface Definition Language（AndRoid接口描述语言）是一种借口描述语言; 编译器 可以通过aidl文件生成一段代码，通过预先定义的接口达到两个进程内部通信进程跨界对象访问的目的.AIDL的IPC的机制和COM或CORBA类 似, 是基于接口的，但它是轻量级的。它使用代理类在客户端和实现层间传递值. 如果要使用AIDL, 需要完成2件事情: 1. 引入AIDL的相关类.; 2. 调用aidl产生的class.理论上, 参数可以传递基本数据类型和String, 还有就是Bundle的派生类

38·屏幕适配？

ه最好可以通过权重(layout_weight)的方式来分配每个组件的大小，也可以通过具体的像素(dip)来确定大小。
尽量使用Relativelayout  。
已知应用支持平台设备的分辨率,可以提供多个layout_320*480  ...
drawable-hdpi,drawable-mdpi,drawable-ldpi分别代表分辨率为480*800,360*480,240*360, 放置图片大小相差1.5倍
最后还需要在AndroidManifest.xml里添加下面一段，没有这一段自适应就不能实现：
<supports-screens
android:largeScreens="true"
android:normalScreens="true"
  android:anyDensity = "true"/>
在</application>标签和</manifest> 标签之间添加上面那段代码。即可。
备注：三者的解析度不一样，就像你把电脑的分辨率调低，图片会变大一样，反之分辨率高，图片缩小
还可以通过.9.png实现图片的自适应

 

 

39·版本更新?数据库的更新？跨版本？

版本：

在清单文件更改版本号，上传更新的应用到平台，利用平台的更新提醒用户是否更新新版本。

数据库更新：

先更改版本号，在onupgress方法内判断版本号是否一致，不一致则更新数据库。

40·安卓自定义组件？

Android自定义组件有三种实现思路:

1) 继承某个现有组件，在其基础上添加额外功能,如继承Gallery实现CoverFlow效果

      2) 复合型组件定义: 继承某个Layout，实现复合组件自定义，如TextView和EditText组合实现登录注册组件

      3) 继承View，实现onDraw()方法，实现自己绘制组件，如翻页效果组件

*41.listview分页加载的步骤

通常实现分页加载有两种方式，一种是在ListView底部设置一个按钮，用户点

击即加载。另一种是当用户滑动到底部时自动加载。

           在ListView底部设置一个按钮，用户点击即加载实现思路:

           // 加上底部View，注意要放在setAdapter方法前

      ListView.addFooterView(moreView);

      bt.setOnClickListener(new OnClickListener() {

     

      @Override

      public void onClick(View v) {

      pg.setVisibility(View.VISIBLE);// 将进度条可见

      bt.setVisibility(View.GONE);// 按钮不可见

     

      handler.postDelayed(new Runnable() {

     

      @Override

      public void run() {

      loadMoreDate();// 加载更多数据

      bt.setVisibility(View.VISIBLE);

      pg.setVisibility(View.GONE);

      mSimpleAdapter.notifyDataSetChanged();// 通知listView刷新数据

      }

     

      }, 2000);

      }

      });

           当用户滑动到底部时自动加载实现思路: 实现OnScrollListener 接口重写

onScrollStateChanged 和onScroll方法，使用onscroll方法实现”滑动“后处理检查是否还有新的记录，如果有,添加记录到adapter, adapter调用 notifyDataSetChanged 更新数据;如果没有记录了，则不再加载数据。使用onScrollStateChanged可以检测是否滚到最后一行且停止滚动然后执行加载.

 

42.移动互联数据的交换格式

 

移动互联数据交互格式有XML和JSON

1.JSON和XML的数据可读性基本相同

2.JSON和XML同样拥有丰富的解析手段

3.JSON相对于XML来讲，数据的体积小

4.JSON与JavaScript的交互更加方便

5.JSON对数据的描述性比XML较差

6.JSON的速度要远远快于XML

 

 

 

 

 

 

 

 

43.xmpp的底层是怎样实现的？

socket，双广播，连接广播和通知光爆

 

 

*44.Activity的启动模式（四种）

Standard、singleTop、singleTask、singleInstance

standard
默认模式，可以不用写配置。在这个模式下，都会默认创建一个新的实例。因此，在这种模式下，可以有多个相同的实例，也允许多个相同Activity叠加。

singleTop
可以有多个实例，但是不允许多个相同Activity叠加。即，如果Activity在栈顶的时候，启动相同的Activity，不会创建新的实例，而会调用其onNewIntent方法。

singleTask
只有一个实例。在同一个应用程序中启动他的时候，若Activity不存在，则会在当前task创建一个新的实例，若存在，则会把task中在其之上的其它Activity destory掉并调用它的onNewIntent方法。
如果是在别的应用程序中启动它，则会新建一个task，并在该task中启动这个Activity，singleTask允许别的Activity与其在一个task中共存，也就是说，如果我在这个singleTask的实例中再打开新的Activity，这个新的Activity还是会在singleTask的实例的task中。

singleInstance
只有一个实例，并且这个实例独立运行在一个task中，这个task只有这个实例，不允许有别的Activity存在。

 

45.广播机制的作用

广播机制，本质上它就是一种组件间的通信方式，如果是两个组件位于不同的进程当中，那么可以用Binder机制来实现，如果两个组件是在同一个进程中，那么它们之间可以用来通信的方式就更多了，这样看来，广播机制似乎是多余的。然而，广播机制却是不可替代的，它和Binder机制不一样的地方在于，广播的发送者和接收者事先是不需要知道对方的存在的，这样带来的好处便是，系统的各个组件可以松耦合地组织在一起，这样系统就具有高度的可扩展性，容易与其它系统进行集成。 

实现思路：

 在第1步中，广播的接收者把广播接收器注册到ActivityManagerService中；在第2步中，广播的发送者同样是把广播发送到ActivityManagerService中，由ActivityManagerService去查找注册了这个广播的接收者，然后把广播分发给它们。 

        在第2步的分发的过程，其实就是把这个广播转换成一个消息，然后放入到接收器所在的线程消息队列中去，最后就可以在消息循环中调用接收器的onReceive函数了。这里有一个要非常注意的地方是，由于ActivityManagerService把这个广播放进接收器所在的线程消息队列后，就返回了，它不关心这个消息什么时候会被处理，因此，对广播的处理是异步的，即调用sendBroadcast时，这个函数不会等待这个广播被处理完后才返回

实例连接：http://wenku.baidu.com/view/b73dd968af1ffc4ffe47ac0c.html

46.图片轮播的实现思路

图片轮播是由viewpage和handler两者结合所实现的，

 

47.Sleep和wait的区别

1.这两个方法来自不同的类分别是，sleep来自Thread类，和wait来自Object

类。

2.最主要是sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可

以使用同步控制块或者方法。sleep不出让系统资源；wait是进入线程等待池

等待，出让系统资源，其他线程可以占用CPU。一般wait不会加时间限制，

因为如果wait线程的运行资源不够，再出来也没用，要等待其他线程调用

notify/notifyAll唤醒等待池中的所有线程，才会进入就绪队列等待OS分配系

统资源。sleep(milliseconds)可以用时间指定使它自动唤醒过来，如果时间不到

只能调用interrupt()强行打断。

3.wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而

sleep可以在任何地方使用

4. Sleep需要捕获异常,而wait不需要

 

 

48.全局异常处理

Android使用UncaughtExceptionHandler捕获全局异常

    Android系统的“程序异常退出”，给应用的用户体验造成不良影响。为了捕获应用运行时异常并给出友好提示，便可继承UncaughtExceptionHandler类来处理。通过Thread.setDefaultUncaughtExceptionHandler()方法将异常处理类设置到线程上即可。 
Demo下载地址：http://code.google.com/p/android-custom-view/downloads/list 

 

*49.静态变量合实例变量的区别

语法：静态变量前要加static来修饰，而实例变量前则不加；

程序运行时的区别：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量；静态变量不属于某个实例对象，而是属于类，所以也称为类变量，静态变量就会被分配空间，静态变量就可以被使用了。

 

*50.listview失去焦点怎么处理

在listview子布局里面写，可以解决焦点失去的问题

android:descendantFocusability="blocksDescendants" 

 

 

*51.什么是匿名内部类，在什么时候调用

   内部类：内部类可以是static的或者非static的，static内部类只能包含静态方法和静态类变量，只能访问外部类的静态元素，内部类可以实例化，多次使用。        匿名内部类：它只能使用一次，不区分static和非static。如果用到外部类的变量的话，必须是类变量或者实例变量，就是必须是类定义的变量，或者final的局部变量。匿名内部类如果是继承某个类的话是可以重写那个类的方法的，这个和普通内部类一样。

1、 实现事件监听器的时候

2、 用匿名内部类编码非常简洁，也容易读懂，不重复利用时使用。

 

 

52.android中asset和raw的区别；

*res/raw和assets的相同点：

1.两者目录下的文件在打包后会原封不动的保存在apk包中，不会被编译成二进制。

*res/raw和assets的不同点：

 

1.res/raw中的文件会被映射到R.java文件中，访问的时候直接使用资源ID即R.id.filename；assets文件夹下的文件不会被映射到R.java中，访问的时候需要AssetManager类。
2.res/raw不可以有目录结构，而assets则可以有目录结构，也就是assets目录下可以再建立文件夹

*读取文件资源：

1.读取res/raw下的文件资源，通过以下方式获取输入流来进行写操作

· InputStream is = getResources().openRawResource(R.id.filename);  

2.读取assets下的文件资源，通过以下方式获取输入流来进行写操作

· AssetManager am = null;  

· am = getAssets();  

· InputStream is = am.open("filename");  

 

 

53.什么是线程

线程，有时被称为轻量级进程(Lightweight Process，LWP)，是程序执行流的最小单元。一个标准的线程由线程ID，当前指令指针(PC)，寄存器集合和堆栈组成。另外，线程是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤消另一个线程，同一进程中的多个线程之间可以并发执行。由于线程之间的相互制约，致使线程在运行中呈现出间断性。线程也有就绪、阻塞和运行三种基本状态。每一个程序都至少有一个线程，那就是程序本身。

　　线程是程序中一个单一的顺序控制流程。在单个程序中同时运行多个线程完成不同的工作，称为多线程。 

 

 

*54.线程和进程的区别

进程是表示资源分配的基本单位，又是调度运行的基本单位。

线程是进程中执行运算的最小单位，亦即执行处理机调度的基本单位。

线程的优点：

（1）易于调度。  

（2）提高并发性。通过线程可方便有效地实现并发性。进程可创建多个线程来执行同一程序的不同部分。  

（3）开销少。创建线程比创建进程要快，所需开销很少。。  

（4）利于充分发挥多处理器的功能。通过创建多线程进程（即一个进程可具有两个或更多个线程），每个线程在一个处理器上运行，从而实现应用程序的并发性，使每个处理器都得到充分运行。  

进程和线程的关系：  

（1）一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程。  （2）资源分配给进程，同一进程的所有线程共享该进程的所有资源。  

（3）处理机分给线程，即真正在处理机上运行的是线程。  

（4）线程在执行过程中，需要协作同步。不同进程的线程间要利用消息通信的办法实现同步。

 

55.接口和抽象类的区别

abstract可以修饰抽象方法，而一个类只要有一个抽象方法，就必须用

abstract定义该类，即抽象类。

用interface修饰的类，里面的方法都是抽象方法，因此在定义接口的时候，可以

直接不加那些修饰，系统会默认的添上去。接口里面的字段都是公有常量，即

public static final修饰的字段。

 

 

56.xml有几种解析方式、区别

基本的解析方式有三种: DOM,SAX,Pull

dom解析：解析器读入整个文档，然后构建一个驻留内存的树结构，然后就可以使用 DOM 接口来操作这个树结构。优点是对文档增删改查比较方便，缺点占用内存比较大。

sax解析：基于事件驱动型,优点占用内存少，解析速度快，缺点是只适合做文档的读取，不适合做文档的增删改，不能中途停止。

pull解析：同样基于事件驱动型,android 官方API提供,可随时终止,调用next() 方法提取它们（主动提取事件）

 

 

 

57.webview的辅助类

WebSettings、WebViewClient、WebChromeClient

WebSettings

设置WebView的一些属性、状态等,例如允许使用javascript，允许使用缓存，允许使用内置的缩放组件

setJavaScriptEnabled(true); 设置支持js  

 

WebViewClient

主要帮助WebView处理各种通知、请求事件（例如，点击链接时候如何显示界面，页面开始加载，加载完毕之后有何动作等）

shouldOverrideUrlLoading() onPageStarted() onPageFinished()

 

WebChromeClient

辅助WebView处理Javascript的对话框、网站图标、网站Title、加载进度等

核心方法有onJsAlert() onJsConfirm() onJsPrompt() onProgressChanged() onReceivedIcon()

onReceivedTitle()

 

 

 

58.w’ebview加载网页的两种方式

loadUrl(url)  通过url地址加载互联网或本地网页

如：loadUrl("http://www.baidu.com");

    loadUrl("file:///android_asset/html/index.html");

loadData(data,type,encoding) 直接加载网页内容，容易乱码，一般用 loadDataWithBaseURL代替

 

 

59.Intent可以被传递的数据类型

intent是连接Activity, Service, BroadcastReceiver, ContentProvider四大组件的信使,，可以传递八种基本数据类型以及string, Bundle类型，以及实现了Serializable或者Parcelable的类型。

Intent可以划分成显式意图和隐式意图。

显式意图：调用Intent.setComponent()或Intent.setClass()方法明确指定了组件名的Intent为显式意图，显式意图明确指定了Intent应该传递给哪个组件。

隐式意图：没有明确指定组件名的Intent为隐式意图。Android系统会根据隐式意图中设置的动作(action)、类别(category)、数据（URI和数据类型）找到最合适的组件来处理这个意图。

 

 

60.拦截短信

短信其实是一个有序广播

 

1：创建一个继承BroadcastReceiver类的广播接收器。

 

2：在清单文件中注册广播并在<intent-filter>中设置优先级priority（只要比你想拦截程序的短信接收器优先级高就可以了）

 

3：在onReceiver（）中调用abortBroadcast()就可以了

 

61.Throws与Throw的区别

1.throw则是指抛出的一个具体的异常类型。

2.通常在一个方法（类）的声明处通过throws声明方法（类）可能抛出的异常信息，而在方法（类）内部通过throw声明一个具体的异常信息。

3.throws通常不用显示的捕获异常，可由系统自动将所有捕获的异常信息抛给上级方法；

throw则需要用户自己捕获相关的异常，而后在对其进行相关包装，最后在将包装后的异常信息抛出。

如果在方法中会有异常被抛出而你又不希望在这个方法体内对此异常进行处理，可以使用throws在声明方法的时候同时声明他可能会跑出的异常。 

4.两者位置不同.

 

 

 

62.Service是如何启动

1通过startService
　　Service会经历onCreate->onStart
　　stopService的时候直接onDestroy
　　
　　如果是调用者(TestServiceHolder)自己直接退出而没有调用stopService的
　　话，Service会一直在后台运行。
　　下次TestServiceHolder再起来可以stopService。

2通过bindService
　　Service只会运行onCreate，这个时候TestServiceHolder和TestService绑定在一起
　　
　　TestServiceHolder退出了，Srevice就会调用onUnbind->onDestroyed
　　所谓绑定在一起就共存亡了。

 

63.android虚拟机的进程和linux的关系

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

 

64.程序运行的权限和文件系统权限的区别

运行时权限 Dalvik( android授权)文件系统 linux内核授权

 

 

*65.访问网络如何加密

1：对称加密（ＤＥＳ，ＡＥＳ）和非对称（ＲＳＡ公钥与私钥）。

（支付宝里的商户的公钥和私钥）

2：MD5（算法）

3：Base64 

 

*66.访问网络都有哪两种方式

get与post是两种不同的提交方式

get是把参数数据队列加到提交表单的ACTION属性所指的URL中，值和表单内各个字段一一对应，在URL中可以看到。post是通过HTTP post机制，将表单内各个字段与其内容放置在HTML HEADER内一起传送到ACTION属性所指的URL地址。用户看不到这个过程。

对于get方式，服务器端用Request.QueryString获取变量的值，对于post方式，服务器端用Request.Form获取提交的数据。

get传送的数据量较小，不能大于2KB。post传送的数据量较大，一般被默认为不受限制。但理论上，IIS4中最大量为80KB，IIS5中为100KB。

get安全性非常低，post安全性较高。

HTTP 定义了与服务器交互的不同方法，最基本的方法是GET 和POST。事实上GET 适用于多数请求，而保留POST 仅用于更新站点。

 

 

 

67.一键退出的实现

定义一个类继承Application，定义一个集合存放所有的activity， 定义一个添

加的方法，再写一个退出的方法，使用for循环全部调用finish方法，然后在每个

Activity的onCreate方法中调用自定义类里的添加方法，然后在需要使用一键退出

的地方调用类中的退出方法即可。

 

 

 

*68.gc是什么

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

 

 

 

*69.listview的分页加载

ListView分页加载通常有两种实现方式：一种是ListView底部设置一个按钮，用户点击即加载；另一种是当用户滑动到底部时自动加载。

在此说一下第一种方式点击底部按钮即加载的实现思路 ：

通过addFooterView()方法为listview底部加入一个“加载更多”按钮和加载进度的视图，默认按钮显示，加载进度为gone。当用户点击“加载更多”按钮时，按钮设置为gone，加载进度显示，并开启子线程从网络上加载下一页数据，加载完毕，发消息给handler，再handler的handleMessage（）方法中通过adapter的notifyDataSetChanged方法通知listview刷新，显示刚加入的数据，并恢复按钮显示，加载进度隐藏。

 

 

 

70.w’eb’service的UDDI是什么

UDDI 是一种目录服务，企业可以使用它对 Web services 进行注册和搜索。UDDI，英文为 "Universal Description, Discovery and Integration"，可译为“通用描述、发现与集成服务”。

 

 

71、webService中uddi是指什么

UDDI是一种目录服务，企业可以使用它对Web Service进行注册和搜索。UDDI,英文为“Universal Description and Integration”，可译为“通用描述、发现与集成服务”。

*72、说说java的反射机制原理以及应用场合

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有

属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态

获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

类对象: 封装了类的描述信息的对象,类加载的产物,由jvm创建java.lang.Class    

应用场景: Gson 序列化反序列化

 

获取类对象的方式:1. 类名.class2. 类的对象.getClass()3. Class.forName("

包名.类名")

73、contentprovider怎么实现数据共享

一个程序可以通过实现一个Content provider的抽象接口将自己的数据完全暴露出去，而且Content providers是以类似数据库中表的方式将数据暴露。Content providers存储和检索数据，通过它可以让所有的应用程序访问到，这也是应用程序之间唯一共享数据的方法。

要想使应用程序的数据公开化，可通过2种方法：创建一个属于你自己的Content provider或者将你的数据添加到一个已经存在的Content provider中，前提是有相同数据类型并且有写入Content provider的权限。

如何通过一套标准及统一的接口获取其他应用程序暴露的数据？

Android提供了ContentResolver，外界的程序可以通过ContentResolver接口访问ContentProvider提供的数据。

74、java有几种引用类型

强引用，软引用、弱引用、幽灵引用、

75、如何让Activity变成一个窗口？

答：在清单文件AndroidManifest.xml中相应的<activity>标签内设置属性android:theme=”@android:style/The

76，启动一个线程时run（）还是start（）

start（）

77，ArrayList的便利

ArrayList<String> al=new ArrayList<String>();

for(int i=0;i<10;i++){

    al.add(String.valueOf(i));

}

Iterator<String> it=al.iterator();

while(it.hasNext()){

    System.out.println(it.next());

}

 

78、String,StringBuffer区别

 

JAVA平台提供了两个类：String和StringBuffer，它们可以储存和操作字符串，

即包含多个字符的字符数据。这个String类提供了数值不可改变的字符串。而这个

StringBuffer类提供的字符串进行修改。

StringBuilder与StringBuffer的区别 。

StringBuffer

      1，一个类似于 String 的字符串缓冲区，对它的修改不会像String那样重创建对象。

      2，使用append()方法修改Stringbuffer的值，使用toString()方法转换为字符串。

      Stringbuild是jdk1.5后用来替换stringBuffer的一个类，大多数时候可以替换

StringBuffer。和StringBuffer的区别在于Stringbuild是一个单线程使用的类，不值

执行线程同步所以比StringBuffer的速度快，效率高。

79、集合的实现类

HashSet：元素无需、不可重复；ArrayList：元素有序，可重复

HashMap以兼职对的形式伯村数据，key值可重复，value值不可重复

80、android中常用的布局

第一种：帧布局（框架布局）FrameLayout，在这个布局中，所有的子元素统统放于这块区域的左上角，并且后面的子元素直接覆盖在前面的子元素之上，将前面的子元素部分和全部遮挡。

第二种：线性布局LinearLayout，最常用的一种布局方式，所有子控件的对齐方式，取决于如何定义 orientation的属性：vertical   垂直方向 ，如果按照这种方向所有的子控件将按照垂直的方式分布在布局上，每行只允许有一个子元素，horizontal水平方向 ，这时子控件将会以水平的方向分布在布局中。

第三种：绝对布局AbsoluteLayout，又可以叫做坐标布局，可以直接指定子元素的绝对位置，这种布局简单直接，直观性强，但是由于手机屏幕尺寸差别比较大，使用绝对定位的适应性会比较差。

第四种：相对布局RelativeLayout，允许子元素指定它们相对于其父元素或兄弟元素的位置，这是实际布局中最常用的布局方式之一。它灵活性大很多，当然属性也多，操作难度也大，属性之间产生冲突的的可能性也大，使用相对布局时要多做些测试。

第五种：表格布局TableLayout，表格布局TableLayout以行列的形式管理子元素，每一行是一个TableRow布局对象，当然也可以是普通的View对象，TableRow里每放一个元素就是一列，总列数由列数最多的那一行决定。

第六种：网格布局 GridLayout，在Android 4.0中，新引入的GridLayout网格布局，GridLayout布局使用虚细线将布局划分为行，列和单元格，也支持一个控件在行，列上都有交错排列。而GridLayout使用的其实是跟LinearLayout类似的API，只不过是修改了一下相关的标签而已，所以对于开发者来说，掌握GridLayout还是很容易的事情。

81、char，varchar区别

  1、CHAR。CHAR存储定长数据很方便，CHAR字段上的索引效率级高，比如定义char(10)，那么不论你存储的数据是否达到了10个字节，都要占去10个字节的空间。

 

 2、VARCHAR。存储变长数据，但存储效率没有CHAR高。如果一个字段可能的值是不固定长度的，我们只知道它不可能超过10个字符，把它定义为 VARCHAR(10)是最合算的。VARCHAR类型的实际长度是它的值的实际长度+1。为什么“+1”呢？这一个字节用于保存实际使用了多大的长度。

82.io流读取输出方法

文件读取：

public static void main(String[] args) throws IOException

{

//创建一个文件读取流对象，并初始化时指定名称的文件相关联。

//要保证此文件是已存在，如不存在会发生异常：FileNotFoundException

FileReader fr = new FileReader("demo.txt");

 

//调用读取流对象的read方法。

//read方法一次只读一个字符，而且会自动向下读取。当读取完后会返回-1.

int ch = 0;

while((ch = fr.read())!=-1)

System.out.print((char)ch);

fr.close();

}

*83，如何序列化

1). 实现序列化 Serializable

2). 属性私有化，并提供get，set方法

3). 提供无参构造

4). 属性名必须与json串中属性名保持一致 （因为Gson解析json串底层用到了Java的反射原理）

84、如何在android中调用js

loadUrl("javascript:test()");

 

85、显示intent隐士intent区别

对于明确指出了目标组件名称的intent成为现实intent；对于没有明确指出目标组件名称的intent成为隐式intent。

86、广播分为几种

第一种:在清单文件中声明,添加

<receive android:name=".IncomingSMSReceiver " >

                   <intent-filter>

                        <action android:name="android.provider.Telephony.SMS_RECEIVED")

                    <intent-filter>

<receiver>

第二种使用代码进行注册如:

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

IncomingSMSReceiver receiver = new IncomgSMSReceiver();

registerReceiver(receiver.filter);

87、intent和activity的区别

Activity活动，可以理解为窗口，是人机交互的核心，所以又被人们说成是所有程序的根本。Intent意图，负责所有Activity窗口通讯。Service服务是相对Activity来说的，不需要人机交互，但可以为Activity提供交互必需要的一些东西。

Android中，Activity是所有程序的根本，所有程序的流程都运行在Activity之中，Activity具有自己的生命周期. 由系统控制生命周期，程序无法改变，但可以用onSaveInstanceState保存其状态对于Activity，关键是其生命周期的把握（如下图），其次就是状态的保存和恢复（onSaveInstanceState onRestoreInstanceState），以及Activity之间的跳转和数据传输（intent）。

Intent

Android中提供了Intent机制来协助 应用间的交互与通讯，Intent负责对应用中一次操作的动作、动作涉及数据、附加数据进行描述，Android则根据此Intent的描述，负责找到对 应的组件，将 Intent传递给调用的组件，并完成组件的调用。Intent不仅可用于应用程序之间，也可用于应用程序内部的Activity/Service之间的交互。

 

 

88、android中经常用哪种数据库

 

SharedPreference，存放较少的五种类型的数据，只能在同一个包内使

用，生成XML的格式存放在设备中

    (2) SQLite数据库，存放各种数据，是一个轻量级的嵌入式数据库

    (3) File文件，通过读取写入方式生成文件存放数据

    (4) ContentProvider，主要用于让其他应用程序使用保存的数据

    (5)通过网络获取数据和写入数据到网络存储空间

 

*89、ipc机制（及原理）

）IPC（Inter-Process Communication，进程间通信）,

aidl是 Android Interface definition language的缩写，它是一种android内部进程通信接口的描述语言，通过它我们可以定义进程间的通信接口.编译器可以通过扩展名为aidl的文件生成一段代码，通过预先定义的接口达到两个进程内部通信进程的目的.

BroadcastReceiver也可以实现进程间通信

ContentProvider 提供进程间数据共享

2).Android的 Service工作流程

  1.Android虚拟机启动之前系统会先启动service Manager进程；

  2.service Manager打开binder驱动，并通知binder kernel驱动程序这个进程将作为System Service Manager；

  3.然后该进程将进入一个循环，等待处理来自其他进程的数据。

  4.用户创建一个System service后，通过defaultServiceManager得到一个远程ServiceManager的接口，通过这个接口我们可以调用addService函数将System service添加到Service Manager进程中；

  5.然后client可以通过getService获取到需要连接的目的Service的IBinder对象，这个IBinder是Service的BBinder在binder kernel的一个参考，

  6.所以service IBinder 在binder kernel中不会存在相同的两个IBinder对象，每一个Client进程同样需要打开Binder驱动程序。对用户程序而言，我们获得这个对象就可以通过binder kernel访问service对象中的方法。

  7.Client与Service在不同的进程中，通过这种方式实现了类似线程间的迁移的通信方式，对用户程序而言当调用Service返回的IBinder接口后，访问Service中的方法就如同调用自己的函数。

 

90、八种基本数据类型

 

byte、short、int、long、float、double、char、boolean

91、上传图片怎么做

用图片异步加载通过开启子线程实现

92、异常

答：编译时异常： 程序正确，但因为外在的环境条件不满足引发。例如：用户错

误及I/O问题----程序试图打开一个并不存在的远程Socket端口。这不是程序本

身的逻辑错误，而很可能是远程机器名字错误(用户拼写错误)。对商用软件系统，

程序开发者必须考虑并处理这个问题。Java编译器强制要求处理这类异常，如果

不捕获这类异常，程序将不能被编译。

运行期异常： 这意味着程序存在bug，如数组越界，0被除，入参不满足规范.....

这类异常需要更改程序来避免，Java编译器强制要求处理这类异常。

93、==equals区别

1、 ==是判断两个变量或实例是不是指向同一个内存空间

      equals是判断两个变量或实例所指向的内存空间的值是不是相同

 

 

2、==是指对内存地址进行比较

     equals()是对字符串的内容进行比较

 

3、==指引用是否相同

     equals（）指的是值是否相同

 

94 public，private，protect权限

public在任何情况下都可用；

protect可在当前类，同一个包中和子孙类中使用；

default：可在当前类和同一个包中使用

private只能在当前类中使用

95、HttpClient与HttpUrlConnection的区别

后者更为常用。HttpClient是个开源框架，封装了访问http的请求头，参数，内容体，响应等等， HttpURLConnection是java的标准类，什么都没封装，用起来太原始，不方便HttpClient实际上是对Java提供方法的一些封装，在HttpURLConnection中的输入输出流操作，在这个接口中被统一封装成了HttpPost(HttpGet)和HttpResponse，这样，就减少了操作的繁琐性。

 

96，json解析方式的两种区别

1，SDK提供JSONArray，JSONObject

2，google提供的 Gson

通过fromJson()实现对象的反序列化（即将json串转换为对象类型）

通过toJson()实现对象的序列化 （即将对象类型转换为json串）

 通过google提供的Gson解析json时，定义JavaBean的规则是什么？

1). 实现序列化 Serializable

2). 属性私有化，并提供get，set方法

3). 提供无参构造

4). 属性名必须与json串中属性名保持一致 （因为Gson解析json串底层用到了Java的反射原理）

*97、什么时候用递归

树用递归方便，用其它方法好像跟本不可能．

 

递归用在特定的函数如 f(x)= f(x-1) + 2

 

像这种情况，你想算出f(x)就必需算出f(x-1)，而f(x)和f(x-1)实际上都是用共一个方法，只是参数相差一．这种时候用递归就很快．

*98、jdbc中怎么处理事物

事务，也是数据库事务，指的是作为单个逻辑工作单元执行的一系列操作。正常的情况下，操作应该顺利进行，与操作相关的所有数据库信息也成功地更新；

 

但是，如果在这一系列过程中任何一个环节出了差错，导致操作失败了，数据库中所有信息都必须保持操作前的状态不变。否则，数据库的信息将会一片混乱而不可预测。

 

一个逻辑工作单元要称为事务，必须满足ACID（原子性，一致性，隔离性和持久性）

 

事务的结束只能有两种形式：提交和回滚。操作完全成功则提交，产生永久性的修改；操作不完全成功则回滚，恢复到事务开始前的状态。它们将结束一个事务。

 

（1）关闭自动提交事务。通过设置连接的自动提交事务属性为false，

*99、android时间分发机制

当你点击了某个控件，首先会去调用该控件所在布局的dispatchTouchEvent方法，然后在布局的dispatchTouchEvent方法中找到被点击的相应控件，再去调用该控件的dispatchTouchEvent方法

100，static内部发出对非static的调用

不能调用

101. 基于回调机制的处理以及监听机制的处理

监听机制的处理模型图：

 

①直接使用匿名内部类,作为事件监听器

ps:就是我们平时最常用的那种,setXxxListener后就重写里面的对应方法

通常都是临时使用一次,复用性不高

②使用内部类作为事件监听器

使用优点:可以在该类中复用,可直接访问外部类的所有界面组件

③使用外部类作为事件监听器

就是另外创建一个处理事件的Java文件,该形式比较少见

因为外部类不能直接访问用户界面类中的组件,要通过构造方法将组件传入使用,

这样的结果就是代码不够简洁

④直接使用Activity作为事件监听器

只需要让Activity类实现~Listener事件监听接口,在Activity中定义重写对应的事件处理器方法

http://www.2cto.com/kf/201403/287434.html

回调机制的处理：

Android平台中，每个View都有自己的处理事件的回调方法，通过重写View中的这些回调方法来实现需要的响应事件。当某个事件没有被任何一个View处理时，便会调用Activity中相应的回调方法。Android提供了以下回调方法供用户使用：

1. onKeyDown：
   功能：该方法是接口KeyEvent.Callback中的抽象方法，所有的View全部实现了该接口并重写了该方法，该方法用来捕捉手机键盘被按下的事件。

2. onKeyUp：
   功能：该方法同样是接口KeyEvent.Callback中的一个抽象方法，并且所有的View同样全部实现了该接口并重写了该方法，onKeyUp方法用来捕捉手机键盘按键抬起的事件。

3. onTouchEvent：

   功能：该方法在View类中的定义，并且所有的View子类全部重写了该方法，应用程序可以通过该方法处理手机屏幕的触摸事件。

４.　onTrackBallEvent：
　　　功能：　接下来将介绍的是手机中轨迹球的处理方法onTrackBallEvent。所有的View同样全部实现了该方法。

５.　 onFocusChanged：
　　　功能：　前面介绍的各个方法都可以在View及Activity中重写，接下来介绍的onFocusChanged却只能在View中重写。该方法是焦点改变的回调方法，当某个控件重写了该方法后，当焦点发生变化时，会自动调用该方法来处理焦点改变的事件。

http://blog.csdn.net/liranke/article/details/6855601

102. UI中padding和margin的区别

Padding 用来指定组件内的内容距离组件边界的距离;

Margin用来指定控件与控件之间的距离

103. *View如何刷新

实现模式对话框的OnOk()函数，在其中添加下面的代码就可以了：
（(C***View)(AfxGetMainWnd()->GetActiveView())）->Invalidate();
其中C***View替换为你自己的View类的名字。
当然，调用Invalidate()只是按你的问题要求实现了刷新显示而已，至于如何实现图片大小的更新，仍需要其他代码（比如在View类中添加代表图片大小的成员变量，在OnDraw()中按照成员变量绘制图片，在OnOK()中更新View成员变量的值）

104. *This和getApplicationContext ()的区别

getApplicationContext():生命周期是整个应用，应用摧毁，它才摧毁。

this:代表当前,在Activity当中就是代表当前的Activity，换句话说就是Activity.this在Activity当中可以缩写为this.

105. *横竖屏切换activity周期的变化

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

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

onCreate-->
onStart-->
onResume-->

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

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

4、再按crtl+f12切换成竖屏时，打印信息如下

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

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

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

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

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

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

onConfigurationChanged-->

8、执行步骤4

onConfigurationChanged-->
onConfigurationChanged-->

总结：

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

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

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

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

补充一点，当前Activity产生事件弹出Toast和AlertDialog的时候

ActivityActivity的生命周期不会有改变运行时按下HOME键(跟被完全覆盖是一样的)：onSaveInstanceState --> onPause --> onStop       onRestart -->onStart--->onResume

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

106. 如何实现ViewPager

先在布局文件中调用v4包下的ViewPager，在java代码中初始化ViewPager，并设置adapter（继承PagerAdapter），再设置监听onPageChangeListener

 

107. Sqlite中的事务如何实现

开启事务： start transaction 
 sql:…update account set money=money-500 where id=1;--检验隔离性
 sql…update account set money=money+500 where id=2; 
commit提交-验证原子性、一致性

 

108. Android中常用的菜单以及区别

1、左右推出的Menu

使用方法：

一.首先导入SlidingMenu这个库文件

二.在你的项目中引入SlidingMenu这个库

eclipse中的流程：右击你的项目 -- Properties -- Android  -- Add  选择SlidingMenu库

三.在你的项目中使用这个SlidingMenu

配置设定方法中 setMode() 是常用属性有：

1）SlidingMenu.LEFT    左测菜单

2）SlidingMenu.RIGHT   右侧菜单

3）SlidingMenu.LEFT_RIGHT    左右2测菜单 

 

2、Path菜单

3、GridView菜单

4、popuwindow菜单

5、系统菜单

 

109. 重载和重写的区别

方法的重载属于,编译时多态,方法名相同参数列表不同，返回值必须相同或都没有返回值类型。         方法的覆盖属于运行时多态，子类覆盖父类的方法,子类指向父类引用,在调用方法的时候用父类的引用调用。

110. Set list map集合的特点

List接口 元素有序可重复.

实现类有：ArrayList    数组实现轻量级，运行快，线程不安全。JDK1.2 查询快

 Vector   数组实现重量级，运行慢，线程安全。JDK1.0保证元素的无序唯一，自定义对象存进HashSet为了保证元素内容不重复需要覆盖hashCode()与equals()方法。

          SortedSet(不重要) 元素有序（Unicode升序）唯一

  LinkedList  链表实现 常用语堆栈与队列的实现 增删操作快

Set 接口 元素无序不可重复

实现类有：HashSet，底层用hashCode()算法实现，

  TreeSet要求元素有序，自定义的对象需要实

现Comparable接口的 compareTo（object o）方法

 Map(接口): 与Collection接口无关,有一个子接口SortedMap特点: 元素是key-value, key 

 唯一,无序; value可重复

实现类: HashMap 轻量级 线程不安全的,允许key或value为null JDK1.2

        HashTable 重量级 线程安全的 不允许key或value为null   JDK1.0

       Properties是HashTable的子类,主键和值都是字符串

SortedMap:(不重要)

特点: key唯一,有序(Unicode升序)

实现类:TreeMap

111. gradView上拉加载和下拉刷新怎么实现

实现OnScrollListener 接口重写onScrollStateChanged 和onScroll方法，使用onscroll方法实现”滑动“后处理检查是否还有新的记录，如果有，调用 addFooterView，添加记录到adapter, adapter调用 notifyDataSetChanged 更新数据;如果没有记录了，把自定义的mFooterView去掉。使用onScrollStateChanged可以检测是否滚到最后一行且停止滚动然后执行加载   

 

112. 用过哪些框架

XUtils  AFinal  第三方开源框架

113. 横向scrollView和ViewPager之间的冲突

重写ScrollView，

public class HomeFeatureLayout extends HorizontalScrollView {

private ArrayList<ListItem> items =null;

private GestureDetector gestureDetector;

View.OnTouchListener gestureListener;

private static final int SWIPE_MIN_DISTANCE = 5;

private static final int SWIPE_THRESHOLD_VELOCITY = 300;

private int activeFeature =0;

 

public HomeFeatureLayout(Context context,ArrayList<ListItem> items){

    super(context);

    setLayoutParams(new LayoutParams(LayoutParams.FILL_PARENT,LayoutParams.WRAP_CONTENT));

    setFadingEdgeLength(0);

    this.setHorizontalScrollBarEnabled(false);

    this.setVerticalScrollBarEnabled(false);

    LinearLayout internalWrapper =new LinearLayout(context);

    internalWrapper.setLayoutParams(new LayoutParams(LayoutParams.FILL_PARENT,LayoutParams.FILL_PARENT));

    internalWrapper.setOrientation(LinearLayout.HORIZONTAL);

    addView(internalWrapper);

    this.items = items;

    for(int i =0; i< items.size();i++){

        LinearLayout featureLayout = (LinearLayout)View.inflate(this.getContext(),R.layout.homefeature,null);

        TextView header = (TextView) featureLayout.findViewById(R.id.featureheader);

        ImageView image = (ImageView) featureLayout.findViewById(R.id.featureimage);

        TextView title = (TextView) featureLayout.findViewById(R.id.featuretitle);

        title.setTag(items.get(i).GetLinkURL());

        TextView date = (TextView) featureLayout.findViewById(R.id.featuredate);

        header.setText("FEATURED");

        Image cachedImage =new Image(this.getContext(), items.get(i).GetImageURL());

        image.setImageDrawable(cachedImage.getImage());

        title.setText(items.get(i).GetTitle());

        date.setText(items.get(i).GetDate());

        internalWrapper.addView(featureLayout);

    }

    gestureDetector =new GestureDetector(new MyGestureDetector());

    setOnTouchListener(new View.OnTouchListener() {

        @Override

        public boolean onTouch(View v,MotionEvent event) {

            if (gestureDetector.onTouchEvent(event)) {

                return true;

            }

            else if(event.getAction() ==MotionEvent.ACTION_UP || event.getAction() == MotionEvent.ACTION_CANCEL ){

                int scrollX = getScrollX();

                int featureWidth = getMeasuredWidth();

                activeFeature = ((scrollX + (featureWidth/2))/featureWidth);

                int scrollTo = activeFeature*featureWidth;

                smoothScrollTo(scrollTo,0);

                return true;

            }

            else{

                return false;

            }

        }

    });

}

 

class MyGestureDetector extends SimpleOnGestureListener {

    @Override

    public boolean onFling(MotionEvent e1,MotionEvent e2, float velocityX, float velocityY) {

        try {

            //right to left

            if(e1.getX() - e2.getX() > SWIPE_MIN_DISTANCE &&Math.abs(velocityX) > SWIPE_THRESHOLD_VELOCITY) {

                activeFeature = (activeFeature < (items.size() -1))? activeFeature + 1:items.size() -1;

                smoothScrollTo(activeFeature*getMeasuredWidth(),0);

                return true;

            }  

            //left to right

            else if (e2.getX() - e1.getX() > SWIPE_MIN_DISTANCE &&Math.abs(velocityX) > SWIPE_THRESHOLD_VELOCITY) {

                activeFeature = (activeFeature >0)? activeFeature - 1:0;

                smoothScrollTo(activeFeature*getMeasuredWidth(),0);

                return true;

            }

        }catch (Exception e) {

            // nothing

        }

        return false;

    }

}

 

114. 集合和数组的区别

1）：数组在定义时必须定义长度，而集合在定义时不必定义长度。

2）：数组在定义时必须要声明数组的数据类型，而集合不必。但是一般情况下我们都是存储统一数据类型的数据，我们可以使用泛型的写法来限制集合里面的数据类型。

115. 什么方法不能被重写

被final修饰的方法，构造方法，

116. 编译时异常和运行时异常的区别

异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误。java编译器要求方法必须声明抛出可能发生的非运行时异常，但是并不要求必须声明抛出未被捕获的运行时异常。

117. Gps定位和网络定位的区别

GPS定位需设置权限android.permission.ACCESS_LOCATION_FINE

网络定位需设置权限android.permission.ACCESS_LOCATION_COARSE

即GPS定位比网络定位在精确度方面更精准，但在速度方面稍差一些，而且GPS定位适合在室外环境下使用，网络定位在室内，室外都可以。

 

118. 如何实现通讯录的排序

 

119. Collection 和 Collections的区别
Collection是集合类的上级接口，继承与他的接口主要有Set 和List
Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。

Native是啥

120. Service实现的两种方式

1.Context.startService()方式启动 

①Context.startService()方式的生命周期： 启动时，startService –> onCreate() –> onStart()停止时，stopService –> onDestroy()如果调用者直接退出而没有停止Service，则Service 会一直在后台运行 Context.startService()方法启动服务，在服务未被创建时，系统会先调用服务的onCreate()方法，接着调用onStart()方法。如果调用startService()方法前服务已经被创建，多次调用startService()方法并不会导致多次创建服务，但会导致多次调用onStart()方法。采用startService()方法启动的服务，只能调用Context.stopService()方法结束服务，服务结束时会调用onDestroy()方法附代码

2.Context.bindService()方式启动：①Context.bindService()方式的生命周期： 绑定时,bindService -> onCreate() –> onBind()调用者退出了，即解绑定时,Srevice就会unbindService –>onUnbind() –> onDestory()Context.bindService()方式启动 Service的方法：绑定Service需要三个参数：bindService(intent, conn, Service.BIND_AUTO_CREATE);第一个：Intent对象第二个：ServiceConnection对象，创建该对象要实现它的onServiceConnected()和 onServiceDisconnected()来判断连接成功或者是断开连接第三个：如何创建Service，一般指定绑定的时候自动创建附代码

 

121. 手机上使用的传感器有什么

#define SENSOR_TYPE_ACCELEROMETER       1 //加速度

#define SENSOR_TYPE_MAGNETIC_FIELD      2 //磁力

#define SENSOR_TYPE_ORIENTATION         3 //方向

#define SENSOR_TYPE_GYROSCOPE           4 //陀螺仪

#define SENSOR_TYPE_LIGHT               5 //光线感应

#define SENSOR_TYPE_PRESSURE            6 //压力

#define SENSOR_TYPE_TEMPERATURE         7 //温度

#define SENSOR_TYPE_PROXIMITY           8 //接近

#define SENSOR_TYPE_GRAVITY             9 //重力

#define SENSOR_TYPE_LINEAR_ACCELERATION 10//线性加速度

#define SENSOR_TYPE_ROTATION_VECTOR     11//旋转矢量

 

122. SurfaceView实现的原理

SurfaceView，它拥有独立的绘图表面，即它不与其宿主窗口共享同一个绘图表面。由于拥有独立的绘图表面，因此SurfaceView的UI就可以在一个独立的线程中进行行绘制。又由于不占用主线程资源，SurfaceView一方面可以实现复杂而高效的UI，另一方面又不会导致用户输入得不到及时响应。

123.   Int Integer的区别      

 int 是基本类型，直接存数值

   

　　1.Java 中的数据类型分为基本数据类型和复杂数据类型

　　int 是前者>>integer 是后者（也就是一个类）

　　2.初始化时>>

　　int i =1;

　　Integer i= new Integer(1);(要把integer 当做一个类看)

　　int 是基本数据类型（面向过程留下的痕迹，不过是对java的有益补充）

　　Integer 是一个类，是int的扩展，定义了很多的转换方法

　　

类似的还有：float Float;double Double;string String等

 

124. Application类的作用

Application和Actovotu,Service一样是android框架的一个系统组件，当android程序启动时系统会创建一个 application对象，用来存储系统的一些信息。通常我们是不需要指定一个Application的，这时系统会自动帮我们创建，如果需要创建自己 的Application，也很简单创建一个类继承 Application并在manifest的application标签中进行注册(只需要给Application标签增加个name属性把自己的 Application的名字定入即可)。

android系统会为每个程序运行时创建一个Application类的对象且仅创建一个，所以Application可以说是单例 (singleton)模式的一个类.且application对象的生命周期是整个程序中最长的，它的生命周期就等于这个程序的生命周期。因为它是全局 的单例的，所以在不同的Activity,Service中获得的对象都是同一个对象。所以通过Application来进行一些，数据传递，数据共享 等,数据缓存等操作。

 

125. 嵌入式操作系统

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

 

126. ViewFlipper和ViewPager的区别

1.ViewFilpper类继承于ViewAnimator类。而ViewAnimator类继承于FrameLayout。

查看ViewAnimator类的源码可以看出此类的作用主要是为其中的View切换提供动画效果。该类有如下几个和动画相关的方法。

2.ViewPager用于实现多页面的切换效果，该类存在于Google的兼容包里面，所以在引用时记得在BuilldPath中加入“android-support-v4.jar”

 

127. 定义数组的几种方式

nt a[]; //声明未初始化
a = new int [10]; // 定义占用空间大小（10个int）
int a[] = new int [10]; //声明并定义大小（即分配了指定大小的空间）
int a[] = {1,2,3}; // 声明并初始化，占用空间大小是3个int。

 

 

128. 知道哪几种排序方式

冒泡  

public static int[] doMaoPao(int[] in){

int temp;

int length = in.length;

for(int i = 0;i<length; i++){

for(int j=0;j<length-1-i;j++){

if(in[j]<in[j+1]){

temp = in[j+1];

in[j+1] = in[j];

in[j] = temp;

}

System.out.print("输出j="+in[j]+"         ");

System.out.println("   ");

System.out.print("输出j+1=    "+in[j+1]);

}

// System.out.print("i="+in[i]);

}

return in;

}

选择

public static int[] doPaiXv(int[] in){

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

int temp = 0;

for(int j=i+1;j<in.length;j++){

if(in[i]>in[j]){

temp = in[i];

in[i] = in[j];

in[j] = temp;

}

System.out.print("输出j="+in[j]+"         ");

System.out.println("   ");

System.out.print("输出i=    "+in[i]);

}

}

return in;

}

二分

public static void binary_sort(int a[]){

int i,j,temp;

int left,right,mid;

for(i = 1; i<a.length; i++){

left = 0;

right = i-1;

temp = a[i];

while(left <= right){

mid = (left + right) /2;

if(a[mid] > temp){

right = mid - 1;

}else{

left = mid + 1;

}

}

for(j=i-1; j>right; j--){

a[j+1] = a[j];

a[right+1] = temp;

}

}

}

public static void main(String[] args) {

int a[] = {2,6,9,8,4,7,3,1,0,5};

binary_sort(a);

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

System.out.print(a[i]+ " ");

}

129. Doget和doPost的区别

通过get方式提交的数据有大小的限制，通常在1024字节左右。也就是说如果提交的数据很大，用get方法就可需要小心；而post方式没有数据大小的限制，理论上传送多少数据都可以。

通过get传递数据，实际上是将传递的数据按照”key，value”的方式跟在URL的后面来达到传送的目的的；而post传递数据是通过http请求的附件进行的，在URL中并没有明文显示

 

130. 什么是API

API（Application Programming Interface,应用程序编程接口）是一些预先定义的函数，目的是提供应用程序与开发人员基于某软件或硬件的以访问一组例程的能力，而又无需访问源码，或理解内部工作机制的细节.
简单来说,就是一套可供调用的系统接口.

131. 常遇到的异常、如何解决

异常的继承结构：

基类为Throwable，Error和Exception继承Throwable，RuntimeException和IOException等继承Exception，具体的RuntimeException继承RuntimeException。

Error和RuntimeException及其子类成为未检查异常（unchecked），其它异常成为已检查异常（checked）。 

 

  1、 SQLException：操作数据库异常类。

问题： 当Java应用程序与数据库进行沟通时如果产生了错误，就会触发这个类。同时会将数据库的错误信息通过这个类显示给用户。当用户插入数据的时候，如果这个字段的值跟现有的纪录重复了，违反了数据库的唯一性约束，此时数据库就会跑出一个异常信息。这个信息一般用户可能看不到，因为其发生在数据库层面的。此时这个操作数据库异常类就会捕捉到数据库的这个异常信息，并将这个异常信息传递到前台。如此的话，前台用户就可以根据这个异常信息来分析发生错误的原因。

解决方案：检查插入的数据是否重复。
    2、 ClassCastException：数据类型转换异常。

问题： 在Java应用程序中，有时候需要对数据类型进行转换。这个转换包括显示的转换与隐式的转换。不过无论怎么转换，都必须要符合一个前提的条件，即数据类型的兼容性。在数据类型进行转换之前，就保证数据类型的兼容性。如此的话，就不容易造成数据类型的转换异常。如在只允许数值类型的字段中，可以设置不允许用户输入数值以外的字符。

解决方案：注意相应的组件在初始化的时候，是否相对应。
    3、 NumberFormatException：字符串转换为数字类型时抛出的异常。

    在数据类型转换过程中，如果是字符型转换为数字型过程中出现的问题，对于这个异常在Java程序中采用了一个独立的异常，即NumberFormatException.如现在讲字符型的数据“123456”转换为数值型数据时，是允许的。但是如果字符型数据中包含了非数字型的字符，如123#56，此时转换为数值型时就会出现异常。系统就会捕捉到这个异常，并进行处理。
解决方案：检查数据是否正确。

4. java.lang.NullPointerException
(1).如果使用第三包的jar包，jar包中有错误

(2).没有实例化组件

(3).没有把Adapter和值绑定；

(4)．当页面中某个组件赋值为null时activity会出现错误，程序崩溃后其他页面的数据就会被重新初始化

(5).用Intent传值时，获取的key不存在

(6).没有赋初始值 

5. java.lang.ClassNotFoundException　　异常的解释是"指定的类不存在"。
6. java.lang.ArithmeticException　　这个异常的解释是"数学运算异常"，比如程序中出现了除以零这样的运算就会出这样的异常。
7. java.lang.ArrayIndexOutOfBoundsException
　　异常的解释是"数组下标越界"，现在程序中大多都有对数组的操作，因此在调用数组的时候一定要认真检查，看自己调用的下标是不是超出了数组的范围，一般来说，显示（即直接用常数当下标）调用不太容易出这样的错，但隐式（即用变量表示下标）调用就经常出错了，还有一种情况，是程序中定义的数组的长度是通过某些特定方法决定的，不是事先声明的，这个时候，最好先查看一下数组的length，以免出现这个异常。
8. java.lang.IllegalArgumentException

这个异常的解释是"方法的参数错误"，比如g.setColor(int red,int green,int blue)这个方法中的三个值，如果有超过２５５的也会出现这个异常，因此一旦发现这个异常，我们要做的，就是赶紧去检查一下方法调用中的参数传递是不是出现了错误。
9. java.lang.IllegalAccessException
　　这个异常的解释是"没有访问权限"，当应用程序要调用一个类，但当前的方法即没有对该类的访问权限便会出现这个异常。对程序中用了Package的情况下要注意这个异常

10.安全异常：产生的原因是由于当前的设备不支持当前程序，这个是由于机型产生的问题，我们应该换一个设备进行测试，检测当前程序存在什么样的异常；另一种原因是获取激活的网络信息实体类，需要添加权限，否则会出现此异常

解决办法：在配置文件中，添加android_permission_Access_NetWork_State的权限

 11. RejectExcuteException：一个异步任务只能执行一次，否则会报异常

    一个线程最多能执行5个线程，超出则等待，否则会报拒绝执行的异常 

         解决办法：使用子线程+handler来代替AsyncTask，或者一个线程中少添加几个异步操作。

12. Out of memory：内存溢出是存放的数据过多导致内存不足的溢出事件

13. Memory leak：内存泄露是本应该释放的资源没有充分得到释放，就继续添加数据导致内存泄露事件；

 

Java应用程序中常见的异常类还有很多。如未找到相应类异常、不允许访问某些类异常、文件已经结束异常、文件未找到异常、字段未找到异常等等。一般系统开发人员都可以根据这个异常名来判断当前异常的类型。

 

ArithmeticException（除数为0的异常）, BufferOverflowException（缓冲区上溢异常）, BufferUnderflowException（缓冲区下溢异常）, IndexOutOfBoundsException（出界异常）, NullPointerException（空指针异常）, EmptyStackException（空栈异常）, IllegalArgumentException（不合法的参数异常）, NegativeArraySizeException, NoSuchElementException, SecurityException, SystemException, UndeclaredThrowableException

 

 

132. 常用的推送，并简单介绍

并行的都包括：即时信息和空间协议(IMPP)、空间和即时信息协议(PRIM)；

推送的实现原理：

XMPP是一种基于XML的协议，它继承了在XML环境中灵活的发展性。因此，基于XMPP的应用具有超强的可扩展性。XMPP的前身是Jabber，一个开源形式组织产生的网络即时通信协议。 所有从一个client到另一个client的jabber消息和数据都要xmpp server，client连接到server，server利用本地目录系统的证书对其认证，client制定目标地址，让server告知目标状态，server查找，连接并进行相互认证，client间进行交互。

XMPP系统特点： 

 1)客户机/服务器通信模式；(2)分布式网络；(3)简单的客户端；(4)XML的数据格式。  

通俗解释： 

其实XMPP 是一种很类似于http协议的一种数据传输协议，它的过程就如同“解包装--〉包

装”的过程，用户只需要明白它接受的类型，并理解它返回的类型，就可以很好的利用xmpp来进行数据通讯。