排序
http://blog.csdn.net/speedme/article/details/23021467
http://blog.csdn.net/cutesource/article/details/5810171
视角
http://blog.csdn.net/top_code/article/details/20574469
————————————————————————————————————————————————
TraceView性能测试 debug.startMethodTracing 针对函数
debug.stopMethodTracing
Heap dump 包含了触发Heap dump生成的时刻Java进程的内存快照，主要内容为各个Java类和对象在堆内存中的分配情况 针对对象和内存
SDK——>tools——>TraceView
通过DDMS中的Heap选项卡监视内存情况：
1.Heap视图中部有一个Type叫做data object，即数据对象，也就是我们的程序中大量存在的类类型的对象。
2.在data object一行中有一列是“Total Size”，其值就是当前进程中所有Java数据对象的内存总量。
如果代码中存在没有释放对象引用的情况，则data object的Total Size值在每次GC后不会有明显的回落，随着操作次数的增多Total Size的
值会越来越大，直到到达一个上限后导致进程被kill掉。
1.避免创建不必要的对象
2.如果方法用不到成员变量，可以把方法声明为static，性能会提高15%到20%
3.避免使用getters/setters存取Field，可以把Field声明为public，直接访问
4.static的变量如不需要修改，应该使用static final修饰符定义为常量
5.使用增强For循环语法for（:）
6.私有内部类访问外部类的Field或方法，可以把外部类的Field或方法声明为包访问权限
7.合理利用浮点数，浮点数比整型慢两倍
减少主线程的阻塞时间 AsynTask, onPreExecut, doInbackGround，onUpdateProgress，onpostExecut
提高Adapter和AdapterView的效率
访问网络优化 ：设置超时时间，采用压缩流 传送数据
内存优化：尽量避免static成员变量的使用
使用SoftReference或者WeakReference代替强引用
尽量避免在一个activity里面写线程内部类：
线程是Activity的内部类，所以Thread中保存了Activity的一个引用，当run函数没有结束时，Thread是不会被销毁的，
因此它所引用的老的Activity也不会被销毁，当这些activity加载了很多资源，没有释放也就很容易出现了内存泄露的问题。
Android提供的AsyncTask，但事实上AsyncTask的问题更加严重，Thread只有在run函数不结束时才出现这种内存泄露问题，然而
AsyncTask内部的实现机制是运用了ThreadPoolExcutor,该类产生的Thread对象的生命周期是不确定的，是应用程序无法控制的，因
此如果AsyncTask作为Activity的内部类，就更容易出现内存泄露的问题。
————————————————————————————————————————————————
16.如何区分activity/task/process
process是一个继承自Linux的概念，一般一个app会有一个uid，一般会独立地开一个process。但是，也会有多个app共享一个process
或者uid的，这个可以自己指定
task是一个activity的栈，其中"可能"含有来自多个App中的activity。
ActivityManager类可以获取运行信息，如下：
getRecentTasks() 最近开的task，HOME键长按会看到这个
getRunningAppProcesses() 运行中的作为app容器的process
getRunningServices() 运行中的后台服务
getRunningTasks() 运行中的任务
————————————————————————————————————————————————
17.res加载流程
一.获取这些资源的入口对象都是Resources对象
获取Resources对象有两种方式，第一种通过Context，第二种通过PackageManager。
通过Context获取Resources对象，一个Acitvity或者一个Service中，我们直接this.getResources()方法，就可以获得Reousrces对象
————————————————————————————————————————————————
19.property动画与普通View动画区别
View Animation（Tween Animation）：补间动画，给出两个关键帧，通过一些算法将给定属性值在给定的时间内在两个关键帧间渐变。
View animation只能应用于View对象，而且只支持一部分属性，如支持缩放旋转而不支持背景颜色的改变。
属性动画，它更改的是对象的实际属性，在View Animation（Tween Animation）中，其改变的是View的绘制效果，真正的View的属性
保持不变，比如无论你在对话中如何缩放Button的大小，Button的有效点击区域还是没有应用动画时的区域，其位置与大小都不变。
而在Property Animation中，改变的是对象的实际属性，如Button的缩放，Button的位置与大小属性值都改变了。而且Property
Animation不止可以应用于View，还可以应用于任何对象。Property Animation只是表示一个值在一段时间内的改变，当值改变时
要做什么事情完全是你自己决定的。
————————————————————————————————————————————————
21.android Service stopSelf(int startId)与stopSelf()的区别
————————————————————————————————————————————————
18.如何优化UI
解析布局文件话费的时间取决于布局的复杂性：资源数据越大解析越慢
1. 使用相对布局代替线性布局或其他布局
2. 合并布局，如果自己布局的顶层元素是一个FrameLayout，可以使用<merge />标签来合并布局
3. 重用布局，使用 <include />
有两个目的：1. 多次使用相同的布局， 2. 布局有一个通用的组成部分，或有部分依赖于设备配置
4. ViewStub
ViewStub是轻量级且不可见的视图，当需要时，在自己的布局中可以用它来推迟展开布局。
布局优化工具，可以使用HierarchyViewer和layoutopt，这两个工具都位于SDK的tools目录下
5.图片优化.在Android中，BitmapFactory的使用。
在开发过程中尽可能降低对高质量图片的使用以提高运行效率。
同一张图片如何在不同大小屏幕合适地显示出来？如果图片不够满屏，就对图片进行放大，相反就进行缩小。
将多张图片集成到一张图片上。减少图片的颜色数。
————————————————————————————————————————————————
Android的ANR, service、广播有ANR吗？
一.ANR:Application Not Responding，即应用无响应
二：ANR的类型
ANR一般有三种类型：
1：KeyDispatchTimeout(5 seconds) --主要类型 ，按键或触摸事件在特定时间内无响应
2：BroadcastTimeout(10 seconds) BroadcastReceiver在特定时间内无法处理完成
3：ServiceTimeout(20 seconds) --小概率类型 Service在特定的时间内无法处理完成
四：为什么会超时呢？阻塞、耗时
如何避免KeyDispatchTimeout？
1：UI线程尽量只做跟UI相关的工作；
2：耗时的工作（比如数据库操作，I/O，连接网络或者别的有可能阻碍UI线程的操作）把它放入单独的线程处理
3：尽量用Handler来处理UIthread和别的thread之间的交互
Android application 可以运行多次吗？
android的apk，如果你在配置文件中增加了独立进程的属性，那么，Application类就会初始化多次。
————————————————————————————————————————————————
20.说说应用saveInstance 与 restoreInstance区别，如何使用
Activity的 onSaveInstanceState() 和 onRestoreInstanceState()并不是生命周期方法，它们不同于 onCreate()、
onPause()等生命周期方法，它们并不一定会被触发。当应用遇到意外情况（如：内存不足、用户直接按Home键）由系
统销毁一个Activity时，onSaveInstanceState()才会被调用。但是当用户主动去销毁一个Activity时，例如在应用中
按返回键，onSaveInstanceState()就不会被调用。因为在这种情况下，用户的行为决定了不需要保存Activity的状态。
通常onSaveInstanceState()只适合用于保存一些临时性的状态，而onPause()适合用于数据的持久化保存。
另外，当屏幕的方向发生了改变， Activity会被摧毁并且被重新创建，如果你想在Activity被摧毁前缓存一些数据，
并且在Activity被重新创建后恢复缓存的数据。可以重写Activity的 onSaveInstanceState() 和 onRestoreInstanceState()方法。
————————————————————————————————————————————————
android view，surfaceview，glsurfaceview的区别：
SurfaceView是从View基类中派生出来的显示类，直接子类有GLSurfaceView和VideoView，可以看出GL和视频播放以及Camera摄像
头一般均使用SurfaceViewSurfaceView和View最本质的区别在于，surfaceView是在一个新起的单独线程中可以重新绘制画面而View
必须在UI的主线程中更新画面。 那么在UI的主线程中更新画面 可能会引发问题，比如你更新画面的时间过长，那么你的主UI线程
会被你正在画的函数阻塞。那么将无法响应按键，触屏等消息。
当使用surfaceView 由于是在新的线程中更新画面所以不会阻塞你的UI主线程。但这也带来了另外一个问题，就是事件同步。比如
你触屏了一下，你需要surfaceView中thread处理，一般就需要有一个event queue的设计来保存touch event，这会稍稍复杂一点，
因为涉及到线程同步
所以基于以上，根据游戏特点，一般分成两类。
1)被动更新画面的。比如棋类，这种用view就好了。因为画面的更新是依赖于 onTouch 来更新，可以直接使用 invalidate。
因为这种情况下，这一次Touch和下一次的Touch需要的时间比较长些，不会产生影响。
2)主动更新。比如一个人在一直跑动。这就需要一个单独的thread不停的重绘人的状态，避免阻塞main UI thread。所以显然
view不合适，需要surfaceView来控制。
————————————————————————————————————————————————
android控件点击的事件传递机制
算法：
1.const* char p、const char* p、char const* p 区别
2.排序数列 代码
3.内存操作 代码
6.内存计算代码
深度优先、广度优先、hash、md5、基本加密方法简介、栈
管理
对项目关键点的细节要足够了解
对项目各个阶段的时间点要足够清晰
处理好与其他团队的关系
调动组员的积极性，尽量把事情让他人去做好
处理好风险点
安排好任务，并清晰了解任务的进度
保持清晰的思路，储备应对各种突发事件的措施
保持平和的心态，多站在他人立场考虑问题
加强项目自动化方面的能力
共识和决议要通过邮件发给相关人
注意倾听组员的意见，给他们留出足够的发挥空间
不以个人意愿为基准，凡是以大局为重
1． 关于动态加载机制??
学习Java比C++更容易理解OOP的思想，毕竟C++还混合了不少面向过程的成分。很多人都能背出来Java语言的特点，所谓的动态加载机制等等。当然概念往往是先记住而后消化的，可有多少人真正去体会过动态加载的机制，试图去寻找过其中的细节呢? 提供大家一个方法：
在命令行窗口运行Java程序的时候，加上这个很有用的参数：
java -verbose *.class
这样会清晰的打印出被加载的类文件，大部分是jdk自身运行需要的，最后几行会明显的看到自己用到的那几个类文件被加载进来的顺序。即使你声明了一个类对象，不实例化也不会加载，说明只有真正用到那个类的实例即对象的时候，才会执行加载。这样是不是大家稍微能明白一点动态加载了呢？^_^
2． 关于寻找class文件原理??
建议大家在入门的时候在命令行窗口编译和运行，不要借助JCreator或者Eclipse等IDE去帮助做那些事情。尝试自己这样做：
javac -classpath yourpath *.java
java -classpath yourpath *.class
也许很多人都能看懂，设置classpath的目的就是告诉编译器去哪里寻找你的class文件. 不过至少笔者今日才弄懂JVM去查询类的原理，编译器加载类要依靠classloader， 而classloader有3个级别，从高到低分别是BootClassLoader(名字可能不准确) , ExtClassLoader, AppClassLoader.
这3个加载器分别对应着编译器去寻找类文件的优先级别和不同的路径：BootClassLoader对应jre/classes路径，是编译器最优先寻找class的地方
ExtClassLoader对应jre/lib/ext路径，是编译器次优先寻找class的地方
AppClassLoader对应当前路径，所以也是编译器默认找class的地方
其实大家可以自己写个程序简单的测试，对任何class，例如A,
调用new A().getClass().getClassLoader().toString() 打印出来就可以看到，把class文件放在不同的路径下再次执行，就会看到区别。特别注意的是如果打印出来是null就表示到了最高级 BootClassLoader, 因为它是C++编写的，不存在Java对应的类加载器的名字。
寻找的顺序是一种向上迂回的思想，即如果本级别找不到，就只能去本级别之上的找，不会向下寻找。不过似乎从Jdk1.4到Jdk1.6这一特点又有改变，没有找到详细资料。所以就不举例子了。告诉大家设计这种体系的是Sun公司曾经的技术核心宫力先生，一个纯种华人哦！^_^
这样希望大家不至于迷惑为什么总报错找不到类文件，不管是自己写的还是导入的第三方的jar文件（J2ee中经常需要导入的）。
Android
--------------------------------------------------------------------------------------------------
1.Android的activity启动的几种模式简介。
A:
————launchMode在多个Activity跳转的过程中扮演着重要的角色，它可以决定是否生成新的Activity实例，是否重用已存在的Activity
实例，是否和其他Activity实例公用一个task里。
————Activity一共有以下四种launchMode：standard / singleTop / singleTask/ singleInstance
可以在AndroidManifest.xml配置<activity>的android:launchMode属性为以上四种之一
standard模式是默认的启动模式，不用为<activity>配置android:launchMode属性即可，当然也可以指定值为standard。
每次跳转系统都会在task中生成一个新的FirstActivity实例，并且放于栈结构的顶部，当我们按下后退键时，才能看到原来的FirstActivity实例。
【standard启动模式：不管有没有已存在的实例，都生成新的实例】
【singleTop启动模式：如果发现有对应的Activity实例正位于栈顶，则重复利用，不再生成新的实例】
【singleTask模式：如果发现有对应的Activity实例，则使此Activity实例之上的其他Activity实例统统出栈，使此Activity实例成为栈顶对象，显示到幕前】
【singleInstance模式：启用一个新的栈结构，将Acitvity放置于这个新的栈结构中，并保证不再有其他Activity实例进入】
--------------------------------------------------------------------------------------------------
2.Android的ANR？activity、service、广播有ANR吗？
3.Android application 可以运行多次吗？
4.android控件点击的事件传递机制
5.View绘制，自定义View，自己写一个布局，而不通过调用lineLayout布局
6.简述Android消息处理机制，Handler、looper、Message、Message Queue。
7.Android crash种类.
8.Android Binder机制。使用AIDL实现进程间的通信。
9.Android 服务启动方式
10.java 运行时异常与普通异常
--------------------------------------------------------------------------------------------------
Java的异常和错误
(1)编译时异常:Java.lang.Exception
(2)运行期异常:Java.lang.RuntimeException
(3)错误:Java.lang.Error
1.Error和Exception都继承自Thorwable。
2.Error是错误，是不可挽回的，也就是说，出了Error程序就挂了，最常见的就是OutOfMemoryError。
3.编译时异常指的是我们必须在代码中显示的处理，或者try或者throw，处理完成后才能编译成功，常见的是IOException, InterruptedException。
4.运行期异常指的是我们写的代码可以编译通过，但是如果运行时出现问题，则会出现运行期异常，最常见的就是NullPointerException、
IndexOutOfBoundsException、ClassNotFound、ResourceNotFound
运行时异常也可以通过捕捉预处理,因为运行时异常如果足够仔细，代码写的足够健壮，完全可以避免;
--------------------------------------------------------------------------------------------------
11.java 类加载机制,ClassLoader
12.Android OOM 产生的几种原因？
13.Android网络通讯优化？
14.Android APP性能优化工具、方法
15.Android JNI应用程序开发，java调C，C调java
--------------------------------------------------------------------------------------------------
16.如何区分activity/task/process
A:
————task是一个具有栈结构的对象，一个task可以管理多个Activity，启动一个应用，也就创建一个与之对应的task。
17.res加载流程
18.如何优化UI
19.property动画与普通View动画区别
20.说说应用saveInstance 与 restoreInstance区别，如何使用
21.android Service stopSelf(int startId)与stopSelf()的区别
22.设计模式、重构
23.网络知识http、socket
24.error和exception的区别，RuntimeException和非RuntimeException的区别
25.字符流和字节流的区别，使用场景，相关类
26.继承与组合的区别，使用场景
27.使用静态工厂方法的好处和坏处
28.排序算法，他们是时间复杂度是多少
29.数据库设计原则、范式
30.序列化的作用，应用场景，除了网路传输
--------------------------------------------------------------------------------------------------
31.HTTPS和HTTP的区别
A:
HTTPS（Secure Hypertext Transfer Protocol）安全超文本传输协议
它是一个安全通信通道，它基于HTTP开发，用于在客户计算机和服务器之间交换信息。它使用安全套接字层(SSL)进行信息交换，
单来说它是HTTP的安全版。 它是由Netscape开发并内置于其浏览器中，用于对数据进行压缩和解压操作，并返回网络上传送回的结果。
HTTPS实际上应用了Netscape的安 全全套接字层（SSL）作为HTTP应用层的子层。（HTTPS使用端口443，而不是象HTTP那样使用端口80
来和TCP/IP进行通信。）SSL使 用40 位关键字作为RC4流加密算法，这对于商业信息的加密是合适的。HTTPS和SSL支持使用X.509数字
认证，如果需要的话用户可以确认发送者是谁。
HTTPS和HTTP的区别：
https协议需要到ca申请证书，一般免费证书很少，需要交费。
http是超文本传输协议，信息是明文传输，https 则是具有安全性的ssl加密传输协议
http和https使用的是完全不同的连接方式用的端口也不一样,前者是80,后者是443。
http的连接很简单,是无状态的
HTTPS协议是由SSL+HTTP协议构建的可进行加密传输、身份认证的网络协议 要比http协议安全
--------------------------------------------------------------------------------------------------
32.XX宝怎么样保证他的安全，他的调用异常分哪几种
33.简述内部类
34.项目中你觉得做得最好的是什么
35.Native APP、WEB APP与Hybrid APP的区别
36.java的四种引用
--------------------------------------------------------------------------------------------------
37.不同APK之间想要互相访问数据应该怎么办呢？
A： Android为我们提供了两种数据互访的方法
一是使用Share Preference. / Content Provider APK通过指定接口和数据供其它APK读取，开发者需要实现接口和指定share的数据。
二是在配置文件manifest中配置相同的UserId通过共享userid,拥有相同userid的用户可以配置成运行在同一进程当中，因此默认就是
可以互相访问任意数据的也可以配置为不同进程当中，彼此之间就像访问自己的数据一样访问彼此的数据库和文件。
--------------------------------------------------------------------------------------------------
38.签名简介。
A：
在Android 系统中，所有安装到系统的应用程序都必有一个数字证书，此数字证书用于标识应用程序的作者和在应用程序之间建立信
任关系,这个数字证书并不需要权威的数字证书签名机构认证，它只是用来让应用程序包自我认证的。
调试时，ADT会自动的使用debug密钥为应用程序签名。debug密钥是一个名为debug.keystore的文件，它的位置：系统盘符:/Documents
and Settings/XXX/.android/debug.keystore “XXX”对应于windows操作系统用户名。
主要涉及工具有三个，keytool、jarsigner和zipalign
1）keytool：生成数字证书，即密钥，也就是上面说到的扩展名为.keystore的那类文件；
2）jarsigner：使用数字证书给apk文件签名；
3）zipalign：对签名后的apk进行优化，提高与Android系统交互的效率(Android SDK1.6版本开始包含此工具
--------------------------------------------------------------------------------------------------
39.shareUserId简介。
A:
Android给每个APK进程分配一个单独的空间,manifest中的userid就是对应一个分配的Linux用户ID，并且为它创建一个沙箱，以防止影响
其他应用程序（或者其他应用程序影响它）。用户ID 在应用程序安装到设备中时被分配，并且在这个设备中保持它的永久性。
通常，不同的APK会具有不同的userId，因此运行时属于不同的进程中，而不同进程中的资源是不共享的，在保障了程序运行的稳定。然后
在有些时候，我们自己开发了多个APK并且需要他们之间互相共享资源，那么就需要通过设置shareUserId来实现这一目的。
通过Shared User id,拥有同一个User id的多个APK可以配置成运行在同一个进程中.所以默认就是可以互相访问任意数据. 也可以配置成
运行成不同的进程, 同时可以访问其他APK的数据目录下的数据库和文件.就像访问本程序的数据一样。
--------------------------------------------------------------------------------------------------
40.JAVA的内存管理
A：
————Java的内存管理就是对象的分配和释放问题。
————在Java中，内存的分配是由程序完成的，而内存的释放是由垃圾收集器(Garbage Collection，GC)完成的，程序员不需要通过调用函数
来释放内存，但它只能回收无用并且不再被其它对象引用的那些对象所占用的空间。
Java的内存垃圾回收机制是从程序的主要运行对象开始检查引用链，当遍历一遍后发现没有被引用的孤立对象就作为垃圾回收。GC为了
能够正确释放对象，必须监控每一个对象的运行状态，包括对象的申请、引用、被引用、赋值等，GC都需要进行监控。监视对象状态是为了
更加准确地、及时地释放对象，而释放对象的根本原则就是该对象不再被引用。
在Java中，这些无用的对象都由GC负责回收，因此程序员不需要考虑这部分的内存泄露。
JVM调用GC的策略也有很多种，有的是内存使用到达一定程度时，GC才开始工作，也有定时执行的，有的是平缓执行GC，有的是中断式执行GC。
————在Java中，内存泄漏就是存在一些被分配的对象，这些对象有下面两个特点：
首先，这些对象是有被引用的，即在有向树形图中，存在树枝通路可以与其相连；
其次，这些对象是无用的，即程序以后不会再使用这些对象。
如果对象满足这两个条件，这些对象就可以判定为Java中的内存泄漏，这些对象不会被GC所回收，然而它却占用内存
典型的做法就是把对象数据成员设为null或者从集合中移除该对象。但当局部变量不需要时，不需明显的设为null，因为一个方法执行完毕时，
这些引用会自动被清理。
内存泄漏产生的主要原因：保留下来却永远不再使用的对象引用。
--------------------------------------------------------------------------------------------------
41.java对象锁
A：
————在并发环境下，解决共享资源冲突问题时，可以考虑使用锁机制。
————synchronized对象的锁:
所有对象都自动含有单一的锁。
当使用同步块时，如果方法下的同步块都同步到一个对象上的锁，则所有的任务（线程）只能互斥的进入这些同步块。
三个线程（包括main线程）试图进入某个类的三个不同的方法的同步块中，虽然这些同步块处在不同的方法中，但由于是同步到同一个对象（当前对象
synchronized (this)），所以对它们的方法依然是互斥的。
三个线程（包括main线程）试图进入某个类的三个不同的方法的同步块中，这些同步块处在不同的方法中，并且是同步到三个不同的对象（synchronized
(this)，synchronized(syncObject1)，synchronized (syncObject2)），所以对它们的方法中的临界资源访问是独立的。
————Lock对象锁
--------------------------------------------------------------------------------------------------
42.为什么一般要用http来进行网络编程，而用 socket 的比较少？ sockest有什么缺点？
A:
————TCP或者UDP协议其实都是基于Socket来实现的;
————http在tcp之上，要先用socket建立tcp才能实现http。http只不过帮你把底层实现屏蔽了，面向对象的特点。所以Socket效率高些.
HTTP协议：超文本传输协议，是一种通信协议（如FTP、Telnet、SMTP、HTTP、RIP），如对应于应用层 ，HTTP协议是基于TCP连接的
————socket是一个针对TCP和UDP编程的接口，你可以借助它建立TCP连接等等。而TCP和UDP协议属于传输层；
————两个计算机之间的交流无非是两个端口之间的数据通信,具体的数据会以什么样的形式展现,是以不同的应用层协议来定义的`如HTTP`FTP`...
socket是对端口通信开发的工具,它要更底层一些
--------------------------------------------------------------------------------------------------
43.TCP和UDP的区别:
————TCP是面向链接的，虽然说网络的不安全不稳定特性决定了多少次握手都不能保证连接的可靠性，但TCP的三次握手在最低限度上保证了连接的可靠性；
————UDP不是面向连接的，UDP传送数据前并不与对方建立连接，对接收到的数据也不发送确认信号，发送端不知道数据是否会正确接收，当然也不用重发，
所以说UDP是无连接的、不可靠的一种数据传输协议。
————UDP的开销更小数据传输速率更高，因为不必进行收发数据的确认，所以UDP的实时性更好。
————知道了TCP和UDP的区别，就不难理解为何采用TCP传输协议的MSN比采用UDP的QQ传输文件慢了，但并不能说QQ的通信是不安全的，因为程序员可以手动
对UDP的数据收发进行验证，比如发送方对每个数据包进行编号然后由接收方进行验证啊什么的，即使是这样，UDP因为在底层协议的封装上没有采用类
似TCP的“三次握手”而实现了TCP所无法达到的传输效率。
--------------------------------------------------------------------------------------------------
44.HTTP通讯的get和post
A:
GET和POST
————HTTP协议中的两种不同的请求方式——GET和POST。
————GET方式在进行数据请求时，会把数据附加到URL后面传递给服务器，比如常见的：http://XXX.XXX.XXX/XX.aspx?id=1，
————POST方式则是将请求的数据放到HTTP请求头中，作为请求头的一部分传入服务器。所以，在进行HTTP编程前，首先要明
确究竟使用的哪种方式进行数据请求
--------------------------------------------------------------------------------------------------
45.在Android中,进行http编程有几种方式？
A:
在Android中，可以有两种方式可以用来进行Http编程：1、HttpURLConnection；2、HttpClient
————HttpURLConnection是继承自URLConnection的一个抽象类，在HTTP编程时，来自HttpURLConnection的类是所有操作的基础；
HttpURLConnection对网络资源的请求在默认情况下是使用GET方式的，所以当使用GET方式时，不需要我们做太多的工作：
Http中的get请求，在Url中带有请求的参数，请求的URL格式通常为:"http://XXX.XXXX.com/xx.aspx?param=value"
当我们需要使用POST方式时，就需要使用setRequestMethod()来设置请求方式了。Http中的post请求，不在Url中附加任何参数，
这些参数都会通过cookie或者session等其他方式以键值对的形式key=value传送到服务器上，完成一次请求。请求的URL格式通常为:
"http://XXX.XXXX.com/xx.aspx"
————HttpClient：在Android SDK中提供了Apache HttpClient(org.apache.http.*)模块。但是这个类并不是来自Android的，而是来
自org.apache.http。与HttpURLConnection相同，HttpClient也存在GET和POST两种方式。
HttpGet 在HttpClient中，可以非常轻松使用HttpGet对象来通过GET方式进行数据请求操作，当获得HttpGet对象后我们可以使用
HttpClient的execute方法来向我们的服务器发送请求。在发送的GET请求被服务器相应后，会返回一个HttpResponse响应对象，利用
这个响应的对象我们能够获得响应回来的状态码，如：200、400、401等等
HttpPost 使用POST方式时，我们可以使用HttpPost类来进行操作。当获取了HttpPost对象后，我们就需要向这个请求体传入键值对，
这个键值对我们可以使用NameValuePair对象来进行构造，然后再使用HttpRequest对象最终构造我们的请求体，最后使用HttpClient的
execute方法来发送我们的请求，并在得到响应后返回一个HttpResponse对象。其他操作和我们在HttpGet对象中的操作一样
————HttpGet与HttpPost的异同
共同点，HttpGet和HttpPost创建方式相同：
A.创建HttpGet(或HttpPost)对象，将要请求的URL通过构造方法传入HttpGet(或HttpPost)对象中；
B.使用DefaultHttpClient类的execute方法发送HTTP GET或HTTP POST 请求，并返回HttpResponse对象；
C.通过HttpResponse接口的getEntity方法返回响应信息。
不同点，HttpPost在使用是需要传递参数 ，使用List<NameValuePair>添加参数。
————HttpClient就是一个增强版的HttpURLConnection，HttpURLConnection可以做的事情HttpClient全部可以做；HttpURLConnection没
有提供的有些功能，HttpClient也提供了，但它只是关注于如何发送请求、接收响应，以及管理HTTP连接。
--------------------------------------------------------------------------------------------------
46.Java和C++的区别
A：
————速度：解释过的Java要比C的执行速度慢上约20倍
Java是运行在JVM中的，并且是编译成JVM可识别加载的.class，并不是完全编译成计算机直接可执行的程序
————JAVA没有结构、联合，只有“类”（Class）！
————Java的“主类型”（Primitive type），boolean，char，byte，short，int，long，float以及double。所有主类型的大小都是固有的，
且与具体的机器无关（考虑到移植的问题）。
————Java的主类型都只能在堆栈上创建，Java的对象都从堆中分配
————Java没有象C和C++的指针，用new创建一个对象的时候，会获得一个引用
————JAVA有垃圾回收机制，c++用析构函数回收垃圾。
————JAVA的应用在高层，C++在中间件和底层
————Java不提供多重继承机制，但Java提供了一个interface关键字
--------------------------------------------------------------------------------------------------
47.设计模式
A：
————设计模式：经验复用；
————设计原则：
①针对接口编程、针对超类型编程：“变量的声明类型应该是超类型，通常是一个抽象类或者是一个接口，如此，只要是具体实现
此超类型的类所产生的对象，都可以指定给这个变量。这也意味着，声明类时不用理会以后执行时的真正对象类型！
关键就在多态，程序可以针对超类型编程，执行时会根据实际状况执行到真正的行为。
②封装变化：把变化的地方独立出来，使系统中的某部分改变不会影响其他部分
③组合优于继承：将两个类结合起来使用，这就是组合(composition)。
可以在运行时动态地改变行为。
使用组合建立系统具有很大的弹性
④关闭修改，开放扩展
⑤依赖倒置原则：要依赖抽象，不要依赖具体类
a.变量不可以持有具体类的引用；
b.不要让类派生自具体的类；
c.不要覆盖基类中已实现的方法；
⑥最少知识原则：不要让太多的类耦合在一起，免得修改系统中一部分，会影响到其他部分
⑦单一职责原则：一个类应该只有一个引起变化的原因
————设计模式
①策略模式：定义了算法族，分别封装起来，让他们之间可以相互替换，此模式让算法的变化独立于使用算法的客户。（锦囊妙计）
②观察者模式：定义了对象之间的一对多依赖，这样一来，当一个对象改变状态时，它的所有依赖者都会收到通知并自动更新。（气象公告）
③装饰者模式：动态地将责任附加到对象上，若要扩展功能，装饰者提供了比继承更有弹性的替代方案。（汉堡加生菜、辣椒，计算价格）
④工厂方法：定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法让类把实例化推迟到子类。（实例化不同口味的披萨）
⑤抽象工厂：提供一个接口，用于创建相关或依赖对象的家庭，而不需要明确指定具体类。
抽象工厂的任务是定义一个负责创建一组产品的接口。这个接口内的每个方法都负责创建一个具体产品，同时我们利用实现抽象工厂的子类来提
供这些具体的做法。所以在抽象工厂中利用工厂方法实现生产方法是相当自然的做法。
利用工厂方法创建对象，需要扩展一个类（继承方式），并覆盖他的工厂方法。
区别在于产品，如果产品单一，最合适用工厂模式，但是如果有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好
的解决方式。再通俗深化理解下：工厂模式针对的是一个产品等级结构 ，抽象工厂模式针对的是面向多个产品等级结构的。
⑥单例模式：确保一个类只有一个实例，并提供一个全局访问点
⑦命令模式：将请求封装成对象，这可以让你使用不同的请求、队列、或者日志请求来参数化其他对象。命令模式也可以支持撤销操作。
⑧适配器模式：将一个类的接口，转换成客户期望的另一个接口。适配器让原本接口不兼容的类可以合作无间。
⑨外观模式：提供了一个统一的接口，用来访问子系统中的一群接口。外观定义了一个高层接口，让子系统更容易使用。
⑩模板方法：模板方法定义了一个算法的步骤，并允许子类为一个或多个步骤提供实现。
在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤。
⑾迭代器模式：提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部的表示。
⑿组合模式：允许你将对象组合成树形结构来表现“整体/部分”层次结构。组合能让客户以一致的方式处理个别对象以及对象组合。
⒀状态模式：允许对象在内部状态改变时改变他的行为，对象看起来好像修改了他的类。
代理模式：为另一个对象提供一个替身或占位符，以控制对这个对象的访问。
适配器模式 —— 将一个接口转成另一个接口
装饰者模式 —— 不改变接口，但加入责任
外观模式 —— 让接口更简单
模板方法 —— 子类决定如何实现算法中的某些步骤
策略 —— 封装可互换的行为，然后使用委托来决定要采用哪一个行为
工厂方法 —— 由子类决定实例化哪个具体类
策略 —— 封装可互换的行为，并使用委托决定使用哪一个
适配器 —— 改变一个或多个类的接口
迭代器 —— 提供一个方式来遍历集合，而无需暴露集合的实现
外观 —— 简化一群类的接口
组合 —— 客户可以讲对象的集合以及个别的对象一视同仁
观察者 —— 当某个状态改变时，允许一群对象能被通知到
状态 —— 封装基于状态的行为，并将行为委托到当前状态
策略 —— 将可以互换的行为封装起来，然后使用委托的方法，决定使用哪一个行为
模板 —— 由子类决定使如何实现算法中的某些步骤
装饰者 —— 包装领一个对象，并提供不同的接口
外观 —— 包装许多对象以简化它们的接口
代理 —— 包装另一个对象，并控制对它的访问
适配器 —— 包装另一个对象，并提供不同的接口
桥接模式：不只改变你的实现，也改变你的抽象;
生成器： 封装一个产品的构造过程，并允许按步骤构造；
责任链： 当你想要让一个以上的对象有机会能够处理某个请求的时候，就使用责任链模式；
享元模式：如果想让某个类的一个实例能用来提供许多“虚拟实例”，就使用蝇量模式（Flyweight Pattern）；
解释器模式：为语言创建解释器；
中介者： 来集中相关对象之间复杂的沟通和控制方式；
备忘录： 当你需要让对象返回之前的状态时，就使用备忘录模式；
原型： 当创建给定类的实例的过程很昂贵或很复杂时，就使用原型模式；
访问者： 当你想要为一个对象的组合增加新的能力，且封装并不重要时，就使用访问者模式；
————使用继承与接口的区别
通过继承在父类中提供行为，会导致以下缺点：
a. 代码在多个子类中重复;
b. 运行时的行为不容易改变；
c. 改变会牵一发动全身，造成部分子类型不想要的改变；
通过实现接口方式，可以有选择性的提供一些行为在子类中，但是一些相同行为代码不能得到重复使用；
继承在某种程度上可以实现代码重用，但是父类(例如鸭子类Duck)的行为在子类型中是不断变化的，让所有子类型都有这些行为
是不恰当的。我们可以将这些行为定义为接口，让Duck的各种子类型去实现，但接口不具有实现代码，所以实现接口无法达到代码复
用。这意味着，当我们需要修改某个行为，必须往下追踪并在每一个定义此行为的类中修改它。
--------------------------------------------------------------------------------------------------
48.UI概述
A:
一个安卓应用中创建的所有用户界面元素都使用了View和ViewGroup对象，一个View是这么一个对象：它是一个画在屏幕上的用户可以与
之交互的东西。一个ViewGroup是这么一个对象：它是一个包含了一些其他的View和ViewGroup对象的对象，主要用来定义一个界面的布局。
安卓提供了一系列的View和ViewGroup的子类，这些子类可以提供给你一些输入控件（比如按钮和文本框）和一些布局模型（比如一个
线性或者关系布局）。
以上所述即为android的UI设计之大道。不管在我们的布局里出现了怎样的控件或布局，究其本质，总是逃脱不了View和ViewGroup这二
者之一。打一个比方：这里的View和ViewGroup就好比道家所说的阴阳，一阴一阳，化生万物。
一个<TextView>元素在你的UI中创建了一个TextView组件，一个<LinreaLayout>元素创建了一个LinearLayout的ViewGroup。
当你在应用中加载一个布局资源时，Android实例化每一个布局节点为一个运行时对象，你可以用这个对象定义一些附加的行为，查询
对象状态，或者修改布局等。
--------------------------------------------------------------------------------------------------
49.加解密
A：
————加密技术分类
（1）对称式：加密和解密使用同一密钥，通常称之为"Session Key"；如DES、AES加密标准是一种典型的“对称式”加密法；
（2）非对称式：加密解密使用的不是同一密钥，通常有两个密钥，称为“公钥”和“私钥”，需配对使用才能打开加密文件；
“公钥”是可以公开的，不怕别人知道，收件人解密时用自己的“私钥”既可以；很好的避免了密钥的传输安全性问题；
--------------------------------------------------------------------------------------------------
50.泛型
A:
泛型是在java5才加入的，简单的讲就是对集合中的类型进行约束，也增强了对象的安全。
在java5之前所有放进数据集合中的数据都会被转成object对象存储，而且不管什么时候都可以存的进去，你可以先放一个String然后再放一个Integer
这样也能编译通过，当取出数据的时候，取出都是object类型的数据，必须进行强制类型转换转换成原来的数据类型才能使用。
泛型就是给数据集合强制限定了存储数据的类型。是在编译期间约束类型的，保证对象安全。
比如 ArrayList<String>a=new ArrayList<String>();
上面这个ArrayList里只能存储String类型的数据，如果你往里放Integer的话就会报错，而且取出数据的时候也是String，不需要强制转换类型。
--------------------------------------------------------------------------------------------------
51.HashMap遍历的两种方式，推荐使用entrySet()
(1)第一种:
Map map=new HashMap();
Iterator iter=map.entrySet().iterator();
while(iter.hasNext()){
Map.Entry entry=(Map.Entry)iter.next();
Object key=entry.getKey();
Object val=entry.getValue();
}
(2)第二种
Map map=new HashMap();
Iterator iter=map.keyset.iterator();
while(iter.hasNext()){
Object key=iter.next();
Object val=map.get(key);
}
HashMap的遍历有两种常用的方法，那就是使用 entryset 及 keyset 来进行遍历，但两者的遍历速度是有差别的;
keySet其实是遍历了2次，一次是转为iterator，一次就从hashmap中取出key所对于的value; ——效率低，尽量少使用
entryset只是遍历了第一次，他把key和value都放到了entry中; ——效率高，推荐使用此种方式
————HashMap与HashTable的区别
（1）hashMap去掉了HashTable 的contains方法，但是加上了containsValue（）和containsKey（）方法。
（2）hashTable同步的，而HashMap是非同步的，效率上逼hashTable要高。
（3）hashMap允许空键值，而hashTable不允许。
--------------------------------------------------------------------------------------------------
52.匿名内部类
A:
————使用匿名内部类可使代码更加简洁、紧凑，模块化程度更高。内部类能够访问外部内的一切成员变量和方法，包括
有的，而实现接口或继承类做不到；
————匿名内部类的两种实现方式：第一种，继承一个类，重写其方法；第二种，实现一个接口（可以是多个），实现其方法；
————使用匿名内部类是因为我这地方需要有点什么特殊的实现，所以我就在这地方把具体实现也给了出来了；
--------------------------------------------------------------------------------------------------
53.Activity跳转流程
A：
————Activity从Main跳转到Subscreen过程函数调用顺序：
Main.onCreate()→Main.onStart()→Main.onResume()→Main.onPause()→Subscreen.onCreate()→Subscreen.onStart()→Subscreen.onResume()→Main.onStop()
Android在运行时，正常情况下，Activity的切换其实是将运行过的Activity压入栈中，每创建一个Activity就向栈中压入该Activity；
当点击返回键的时候会销毁当前Activity，即将当前Activity从栈顶删除，接着显式栈中的第二个Activity（也即现在的栈顶Activity）。
【注意：点击返回键是会destroy掉当前Activity的，而不是再将该Activity压入栈里】
--------------------------------------------------------------------------------------------------
54.父类引用指向子类对象（Java中的多态）
class Father {
void print() { System.out.println("Father print"); }
}
class Son extends Father {
void print() { System.out.println("Son print"); }
void show() { System.out.println("Son show"); }
}
class Demo {
public static void main(String args[]) {
Father obj = new Son();
obj.print(); // 调用的是 Son print
obj.show(); // 这个调用会报错！
}
}
Father obj = new Son(); 编译看左边，运行看右边
1.当出现“父类引用指向子类对象”的情况时，如果子类中重写了父类中的一个方法，那么父类引用在调用这个方法的时候，将会调用子类中
的这个方法（动态绑定、执行）；
2.如果你想实现多态，那么必须有三个条件：父类引用，子类对象，方法覆盖；
这里，如果Fathor类有一个show()方法，那么形成方法覆盖，此时才可以这么写：obj.show()——此刻形成了多态。
3.在没有方法覆盖的情况下，用父类引用去访问一个子类的方法，如上面的show()方法——由于父类引用没有这么大范围的权限，所以会报错；
4.父类类型的引用可以调用父类中定义的所有属性和方法，而对于子类中定义而父类中没有的方法，它是无可奈何的（对于子类中的成员变
量，它也是无法调用的）；另外，父类中的一个方法只有在在父类中定义而在子类中没有重写的情况下，才可以被父类类型的引用调用；
【定义一个父类类型的引用指向一个子类的对象既可以使用子类强大的功能，又可以抽取父类的共性。】
5.静态方法是没有多态性的：静态方法不会被子类所覆盖，因此，父类引用只能调用父类的静态方法。
附：一些问题的解答
A:当父类引用f指向其子类的对象的时候，通过f无法访问专属于子类对象的成员
Q:为什么这样不可以？因为f是FatherClass，所以编译器只知道f拥有FatherClass.class的信息，FatherClass.class以外的信息，编译器
不知道，而子类的对象成员是在SonClass.class里，也就是说在FatherClass.class以外，所以f无法访问子类的对象成员。
A:假如子类中有对父类方法的重写，那么根据多态机制，通过f访问这个方法的时候实际访问的是子类中重写的方法。
Q:为什么这样可以？上面说了，f只能访问FatherClass.class的信息（注意这里指的是编译期编译器只知道f是FatherClass类型，不知道f
具体指向什么对象，运行期才知道指向什么对象），而子类重写的方法，父类中也存在，即SonClass.class重写的方法，FatherClass.class里
也有（如果SonClass.class里有但是FatherClass.class里没有的方法，f也不能直接调用），所以f可以访问，但是调用的时候（注意这里指的
是运行期），f实际指向的是SonClass对象，所以调用的是SonClass对象的方法。
A:如果子类重写的方法中访问了专属于子类的成员变量，这时候通过父类引用f还可以调用那个被重写的方法吗？
Q:可以，要分清编译期和运行期，编译期是编译器检查语法和类型，运行期是解析器解析伪代码为机器指令而执行，编译期编译器会检查f
的访问范围，也就是f的访问不超过FatherClass.class的信息就不会出错，运行期解析器会解析方法的代码指令，因为f指向子类对象，所以会
解析子类重写的方法代码指令，而子类对象的内存空间是包含子类的成员变量的空间的，所以也不存在子类成员变量没有分配内存的问题，所
以可以调用。
Java中函数参数的传递是值传递还是引用传递?
Java中参数传递的都是值,对应基本类型,传递的是原值的拷贝;对于类类型,传递的是引用即地址的拷贝.
对于函数对参数的改变是否会影响原值的问题:值类型自然不会影响到原值.而对于类类型要看改变的是参数的地址还是值,如果是前者,参
数和原引用指向了不同的地址,它们自然脱离了关系;如果是后者,修改的实例就是原引用指向的实例,这当然对原值进行了修改
--------------------------------------------------------------------------------------------------
55. Android OOM 产生的几种原因?
A:
1. 程序中使用了太多自己创建的Bitmap.
大部分情况是因为重复创建bitmap, 而不使用的bitmap没有被及时释放, 导致了 oom. 所以在不使用的时候要将bitmap对象回收bitmap.recycle(),
并将bitmap对象置为null.
还有就是当你一次性使用过多bitmap的时候也会导致oom. 比如使用系统的Gallery组件, 然后在每一项使用自己的图片, 这个时候我们
通常自定义Gallery的adapter. 当Gallery需要显示很多图片的时候, 而我们没有做图片缓存机制的话必然会导致oom发生. 所以这个时候需
要做图片缓存机制. 例如只保存当前显示项前后3项的图片, 滑动Gallery的时候再根据当前项动态回收前后不需要的图片和加载需要的图片.
2. 程序中一些对象创建的时候需要context的时候.
这种情况, 通常我们会使用create(this);这个时候引用的时候activity的context, 如果该对象没有被及时回收, activity的引用将被它保留,
从而导致activity不能被及时销毁, 当重复创建activity后, 就会导致activity有多个实例,从而导致内存泄露.所以在用到context的时候尽量使用
application的context: getApplicationContext().
3. 查询数据库没有关闭游标
程序中经常会进行查询数据库的操作，但是经常会有使用完毕Cursor 后没有关闭的情况。如果我们的查询结果集比较小，对内存的消耗不容易被
发现，只有在常时间大量操作的情况下才会复现内存问题，这样就会给以后的测试和问题排查带来困难和风险。所以在使用完游标以后要cursor.close();
4.构造Adapter时，没有使用缓存的convertView
以构造ListView的BaseAdapter为例，在BaseAdapter中提供了方法：
publicView getView(int position, View convertView, ViewGroup parent)来向ListView提供每一个item所需要的view对象。初始时ListView会
从BaseAdapter中根据当前的屏幕布局实例化一定数量的 view对象，同时ListView会将这些view对象缓存起来。当向上滚动ListView时，原先位于最上
面的list item的view对象会被回收，然后被用来构造新出现的最下面的listitem。这个构造过程就是由getView()方法完成的，getView()的第二个形
参View convertView就是被缓存起来的list item的view对象(初始化时缓存中没有view对象则convertView是null)。由此可以看出，如果我们不去使
用convertView，而是每次都在getView()中重新实例化一个View对象的话，即浪费资源也浪费时间，也会使得内存占用越来越大。
Android进阶之图片缩略图（解决大图片溢出问题）
大图片的溢出问题，通过缩略图的方式避免。主要是通过BitmapFactory.Options 来实现。
第一步：BitmapFactory.Option设置 inJustDecodeBounds为true
第二步：BitmapFactory.decodeFile(path,option)方法解码图片路径为一个位图。如果指定的文件名是空的,或者不能解码到一个位图,函数将返回null[空值]。
获取到outHeight(图片原始高度)和 outWidth(图片的原始宽度)
第三步：计算缩放比例，也可以不计算，直接给它设定一个值。options.inSampleSize = "你的缩放倍数";如果是2就是高度和宽度都是原始的一半。
第四步：设置options.inJustDecodeBounds = false;重新读出图片 bitmap = BitmapFactory.decodeFile(path, options);
1.缩略图
2.软引用
3.及时回收
大部分的电都消耗在了网络连接、GPS、传感器上了,简单的说也就是主要在以下情况下耗电比较多：
1、 大数据量的传输。
2、 不停的在网络间切换。
3、 解析大量的文本数据。
改善程序
1、在需要网络连接的程序中，首先检查网络连接是否正常，如果没有网络连接，那么就不需要执行相应的程序。
2.使用效率高的数据格式和解析方法。
通过测试发现，目前主流的数据格式，使用树形解析（如DOM）和流的方式解析（SAX）对比情况如下图所示,很明显，使用流的方式解析效率要高一些，
因为DOM解析是在对整个文档读取完后，再根据节点层次等再组织起来。而流的方式是边读取数据边解析，数据读取完后，解析也就完毕了。
在数据格式方面，JSON和Protobuf效率明显比XML好很多，XML和JSON大家都很熟悉，Protobuf是Google提出的，一种语言无关、平台无关、扩展性好的
用于通信协议、数据存储的结构化数据串行化方法。
从上面的图中我们可以得出结论就是尽量使用SAX等边读取边解析的方式来解析数据，针对移动设备，最好能使用JSON之类的轻量级数据格式为佳。
3、使用GZIP压缩方式下载数据，能减少网络流量;目前大部门网站都支持GZIP压缩，所以在进行大数据量下载时，尽量使用GZIP方式下载
HttpEntity entity = response.getEntity();
InputStream compressed = entity.getContent();
InputStream rawData = new GZIPInputStream(compressed);
4.其它一些优化方法：
回收java对象，特别是较大的java对像
对定位要求不是太高的话尽量不要使用GPS定位，可能使用wifi和移动网络cell定位即可。GPS定位消耗的电量远远高于移动网络定位。
尽量不要使用浮点运算
很多人开发的程序后台都会一个service不停的去服务器上更新数据，在不更新数据的时候就让它sleep，这种方式是非常耗电的，通常情况下，我们
可以使用AlarmManager来定时启动服务
最后一招，在运行你的程序前先检查电量，电量太低，那么就提示用户充电之类的
--------------------------------------------------------------------------------------------------
56. Home键相关
按下home键，Home键也是打开一个activity:
mHomeIntent = new Intent(Intent.ACTION_MAIN, null);
mHomeIntent.addCategory(Intent.CATEGORY_HOME);
mHomeIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED);
//newTask保证了我们回到之前Launcher所在的栈
//reset task if need是设置清理栈标志，保证清除掉该栈除Launcher以外其他activity
//这样我们的Launcher当然会在自己单独的Task中,而且android:launchMode="singleTask"这个属性保证不会启动一个新的Launcher
通过Launcher启动的其他Activity不会跑到Launcher所在的Task中,所以按Home键是打开了Launcher这个activity并且保证他在自己单独的Task中，其他
的activity进入stop状态。
另外Launcher中打开一个activity直接进入之前打开的Task 而不是新打开一个activity.
1、并不是所有的view都有onInterceptTouchEvent(MotionEvent ev)方法，这个方法只有ViewGroup类有
（如LinearLayout，RelativeLayout等可以包含子View的容器）
2、这个三个方法的执行顺序是onInterceptTouchEvent/onTouchEvent/dispatchTouchEvent
LayoutInflater作用是将layout的xml布局文件实例化为View类对象。
LayoutInflater是一个用来实例化XML布局文件为View对象的类
public View inflate(int Resourece,ViewGrouproot) 从指定的XML资源文件填充一个新的视图层次结构View
实现LayoutInflater的实例化共有3种方法，
(1).通过SystemService获得LayoutInflater inflater = (LayoutInflater)context.getSystemServices(Context.LAYOUT_INFLATER_SERVICES);
(2).从给定的context中获得LayoutInflater inflater = LayoutInflater.from(context);
(3)在Activity中可以使用LayoutInflater inflater =getLayoutInflater();
其实，这三种方式本质是相同的,
Activity的getLayoutInflater()方法是调用PhoneWindow的getLayoutInflater()方法,它其实是调用LayoutInflater.from(context);
LayoutInflater.from(context)它其实调用context.getSystemService()。
类Window的成员变量mContext描述的是与当前窗口所关联的一个Activity组件
一个activity包含有一个PhoneWiondow对象，而所有的UI部件都是放在PhoneWiondow中
--------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------
栈中用来存放一些原始数据类型的局部变量数据和对象的引用(String,数组.对象等等)但不存放对象内容
当在一段代码块定义一个变量时，Java就在栈中 为这个变量分配内存空间，当该变量退出该作用域后，Java会自动释放掉为该变量所分配的内存空
间，该内存空间可以立即被另作他用。
堆中存放使用new关键字创建的对象.
堆内存用来存放由new创建的对象和数组。 在堆中分配的内存，由Java虚拟机的自动垃圾回收器来管理。
常量池指的是在编译期被确定，并被保存在已编译的.class文件中的一些数据
字符串是一个特殊包装类,其引用是存放在栈里的,而对象内容必须根据创建方式不同定(常量池和堆).有的是编译期就已经创建好，存放在字符串常 量池中，而有的是运行时才被创建.使用new关键字，存放在堆中。
Java的堆是一个运行时数据区.它们不需要程序代码来显式的释放。堆是由垃圾回收来负责的.
堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，因为它是在运行时动态分配内存的，Java的垃圾收集器会自动收走这些不再
使用的数据。但缺点是，由于要在运行时动态 分配内存，存取速度较慢。
栈的优势是，存取速度比堆要快，仅次于寄存器，栈数据可以共享。但缺点是，存在栈中的数据大小与生存期必须是 确定的，缺乏灵活性。栈中
主要存放一些基本类型的变量数据和对象句柄(引用)。
栈有一个很重要的特殊性，就是存在栈中的数据可以共享
Http协议要研究透彻.http的信息头有什么信息,分别代表什么,信息体有什么信息,代表什么,都要搞的明明白白.scoket也是一样
多线程、断点下载、线程池
手机银行客户端安全性测评报告.pdf
contentProvider
算法：
1.const* char p、const char* p、char const* p 区别
2.排序数列 代码
3.内存操作 代码
4.C++基础知识 代码
5.http get与set等如何使用
6.内存计算代码
深度优先、广度优先、hash、md5、基本加密方法简介、栈
管理
对项目关键点的细节要足够了解
对项目各个阶段的时间点要足够清晰
处理好与其他团队的关系
调动组员的积极性，尽量把事情让他人去做好
处理好风险点
安排好任务，并清晰了解任务的进度
保持清晰的思路，储备应对各种突发事件的措施
保持平和的心态，多站在他人立场考虑问题
加强项目自动化方面的能力
共识和决议要通过邮件发给相关人
注意倾听组员的意见，给他们留出足够的发挥空间
不以个人意愿为基准，凡是以大局为重
tabhost
手机银行客户端安全性测评报告 360
扫一扫
1004
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
