由于公司要做一个android的消息推送功能，让我进行了一个调研，发现网上没有一个集中说明的地方，自己在网上搜罗了一些资料并且自己总结了一下。
对于消息的提醒方式可以分为四种：固定窗口、弹出窗口、手机短信和Push信息。下面的针对于push信息的机制和技术实现向大家介绍一下。
首先，我们要知道什么是Push信息？
所谓信息推送，就是"web广播"，是通过一定的技术标准或协议，在互联网上通过定期传送用户需要的信息来减少信息过载的一项新技术。推送技术通过自动传送信息给用户，来减少用于网络上搜索的时间。它根据用户的兴趣来搜索、过滤信息，并将其定期推给用户，帮助用户高效率地发掘有价值的信息。
简单的来说，信息推送就是服务器端主动向客户端发送信息，客户端进行接收信息。如下图：
使用推送信息的好处:
1、节省用户的电池电量。
2、你可以通过推送通知来告知你的用户在程序中发生了一些有趣的事，即使程序没有运行。
现在很多应用程序都是用的推送的机制：
包括新浪微博，推送最新的朋友消息；墨迹天气推送最新的天气状况；网易新闻，推送重要的新闻；同花顺手机炒股推送最新的股票资讯；微信，推送最新的语音最新。Gmail、Gtalk推送最新的Mail信息和IM信息。
下面，我们了解一下现在主流手机的push机制。
IPhone（APPLE）的工作机制可以简单的概括为下图：
iPhone自3.0之后推出消息推送机制，原理是消息由服务器统一处理。
图中，Provider是指某个iPhone软件的Push服务器，这篇文章我将使用Java作为Provider。
APNS 是Apple Push Notification Service（Apple Push服务器）的缩写，是苹果的服务器。
上图可以分为三个阶段。
第一阶段：Java应用程序把要发送的消息、目的iPhone的标识打包，发给APNS。
第二阶段：APNS在自身的已注册Push服务的iPhone列表中，查找有相应标识的iPhone，并把消息发到iPhone。
第三阶段：iPhone把发来的消息传递给相应的应用程序， 并且按照设定弹出Push通知。
从上图我们可以看到。
1、首先是应用程序注册消息推送。
2、 IOS跟APNS Server要deviceToken。应用程序接受deviceToken。
3、应用程序将deviceToken发送给PUSH服务端程序。
4、 服务端程序向APNS服务发送消息。
5、APNS服务将消息发送给iPhone应用程序。
APNs和iPhone保持15分钟的心跳式长连接，维护手机和服务器的联系正常，否则手机会不停发起连接，直到连接到服务器为止。程序不必实时开启和主动检查更新，当收到APNs消息时，iPhone会弹出对话框Push消息并伴随着声音，用户可以选择“view”或者“close”。即使用户当前处在离线状态，用户收到消息之后激活程序，再通过程序链接应用服务器下载邮件或者录音。
WP7（Microsoft）的Push机制如下图：
WP7的也有相应的推送服务，无论程序是否开启都可以界面顶部推送Toast Notification，并显示10秒。WP7的Push Client负责于服务器交互，接受到消息时再传送给相应的应用程序，而不需要应用程序各自维护一个进程。如果程序被钉在首页，服务器推送瓦片通知（Tile Notification），改变瓦片的背景图片、数字和标题属性。而弹出框式的原生推送（Raw Notification）只能应用在程序开启时，容许实时更新界面
WebOS (BlackBerry)的推送机制如下如所示：
从示意图中可以看到在BlackBerry应用平台上的数据推送从整体上可以分为六步，按时间顺序分别为：
第一步：应用服务器向MDS/BES服务器发送推送请求，所发送的请求为HTTP格式的请求。
第二步：MDS/BES服务器查询相关配置数据库，确定应用服务器所发送的请求是否为合法的请求。此外，MDS/BES服务器还会根据资源情况确定是否接收该请求。对于是否接收请求的判断在下一节内容中也有详细讨论
第三步：MDS/BES服务器向应用服务器返回消息，通知应用服务器是否接受该请求。返回消息以HTTP答复的方式返回给应用服务器
第四步：MDS/BES服务器将数据推送到手持设备端
第五步：手持设备端对数据进行处理后向MDS/BES服务器返回确认消息
第六步：MDS/BES根据手持设备端返回的消息决定向应用服务器返回什么异步消息，这一步并不是必然发生的，根据推送请求的不同有可能不发生。
黑莓的推送是最早的，最早应用在邮件上，而且黑莓的推送机制也是加密最好的，最安全的机制。
下面我们来详细的介绍一下android的推送机制：
Android（Google）：
首先介绍一下google官方应用的push：
1）如果你有新的Gmail邮件，手机可以马上收到邮件通知，这个中间可能有2，3秒的延迟，一般感觉还是很及时的；
2）如果你的联系人和Google Contanct是关联的话，你用桌面浏览器访问Gmail，修改联系人信息，很快新的联系人信息就会同步到你手机上。
在Google I/O 2010 介绍了 Android 2.2 导入的 Android Cloud to Device Messaging (C2DM) 服务， C2DM)作为 Android 2.2 的一部分已经发布了。C2DM 允许第三方开发者开发相关的应用来推送少量数据消息到用户的手机上，其机制如下图：
Android Cloud to Device Messaging (C2DM)是一个用来帮助开发者从服务器向Android应用程序发送数据的服务。该服务提供了一个简单的、轻量级的机制，允许服务器可以通知移动应用程序直接与服务器进行通信，以便于从服务器获取应用程序更新和用户数据。C2DM服务负责处理诸如消息排队等事务并向运行于目标设备上的应用程序分发这些消息。
启用C2DM的过程：
1，移动设备：必须运行android，并且安装Market，至少有一个登录的google账号。
2，服务器：自己的服务器
3，C2DM服务器：google的服务器
授权机制：
1， Sender ID：一个google账号，用于标示开发者的身份，比如hxzhoupeng@google.com
2，Application ID：Manifest.xml里面的pacakage name。用于标示应用程序
3，Registration ID：当应用程序向C2DM服务器注册时，C2DM服务器会返回这个ID，当应用程序获得这个ID之后，应该告诉自己的服务器，自己的服务器把这个ID存在数据库里面，用于告诉C2DM服务器标示客户端。
4，Google User Account：要使用C2DM服务，必须有一个google账号。
5，Sender Auth Token：自己的服务器与C2DM服务器通信的认证。
应用程序发送Intent，com.google.android.c2dm.intent.REGISTER，附上自己的SenderID和AppId，就可以向C2DM服务器进行注册，注册成功之后，可以收到REGISTRATION Intent，获得Registration ID，这个Registration ID是会被C2DM改变的，所以这个REGISTRATION Intent可能会收到多次，要记得存储和发送给自己的服务器
通过对比研究发现C2DM机制存在以下缺点：
1、C2DM内置于Android的2.2系统上，无法兼容老的1.6到2.1系统;
2、C2DM需要依赖于Google官方提供的C2DM服务器，由于国内的网络环境，这个服务经常不可用，如果想要很好的使用，我们的App Server必须也在国外，这个恐怕不是每个开发者都能够实现的;。
除了C2DM在实现Android消息推送机制的方案还有以下几种：
1、轮询（polling）：应用程序应当阶段性的与服务器进行连接并查询是否有新的消息到达，你必须自己实现与服务器之间的通信，例如消息排队等。而且你还要考虑轮询的频率，如果太慢可能导致某些消息的延迟，如果太快，则会大量消耗网络带宽和电池。
2、长连接：这个方案可以解决由轮询带来的性能问题，但是还是会消耗手机的电池。Apple的推送服务之所以工作的很好，是因为每一台手机仅仅保持一个与服务器之间的连接，事实上C2DM也是这么工作的。不过这个方案也存在不足，就是我们很难在手机上实现一个可靠的服务。Android操作系统允许在低内存情况下杀死系统服务，所以你的通知服务很可能被操作系统Kill掉了。
这种方法通过come（基于 HTTP 长连接的“服务器推”技术）长连接也可以实现。详细可以参照http://www.ibm.com/developerworks/cn/web/wa-lo-comet/，但是这并不是最有的一种方式，
在Android下最有的方式应该采取XMPP协议推送Android信息：
首先介绍一下XMPP基于可扩展标记语言（XML）的协议，它用于即时消息（IM）以及在线探测。这个协议可能最终允许因特网用户向因特网上的其他任何人发送即时消息。详细参考：
http://zh.wikipedia.org/zh-cn/XMPP
Google官方的C2DM服务器底层也是采用XMPP协议进行的封装。
androidpn是一个基于XMPP协议的java开源Android push notification实现。它包含了完整的客户端和服务器端。该服务器端基本是在另外一个开源工程openfire基础上修改实现的。它的实现示意图如下：
androidpn客户端需要用到一个基于java的开源XMPP协议包asmack，这个包同样也是基于openfire下的另外一个开源项目smack，不过我们不需要自己编译，可以直接把androidpn客户端里面的asmack.jar拿来使用。客户端利用asmack中提供的XMPPConnection类与服务器建立持久连接，并通过该连接进行用户注册和登录认证，同样也是通过这条连接，接收服务器发送的通知。
androidpn服务器端也是java语言实现的，基于openfire开源工程，不过它的Web部分采用的是spring框架，这一点与openfire是不同的。Androidpn服务器包含两个部分，一个是侦听在5222端口上的XMPP服务，负责与客户端的XMPPConnection类进行通信，作用是用户注册和身份认证，并发送推送通知消息。另外一部分是Web服务器，采用一个轻量级的HTTP服务器，负责接收用户的Web请求。服务器架构如下：
最上层包含四个组成部分，分别是SessionManager，Auth Manager，PresenceManager以及Notification Manager。SessionManager负责管理客户端与服务器之间的会话，Auth Manager负责客户端用户认证管理，Presence Manager负责管理客户端用户的登录状态，NotificationManager负责实现服务器向客户端推送消息功能。
服务器端界面如下，分别对应了上述的几个功能模块：
发送以后，我们可以在手机端看到接收的消息：
这个的最大优势就是简单，我们不需要象C2DM那样依赖操作系统版本，也不会担心某一天Google服务器不可用。利用XMPP协议我们还可以进一步的对协议进行扩展，实现更为完善的功能。
采用这个方案，目前只能发送文字消息，不过对于推送来说一般足够了，因为我们不能指望通过推送得到所有的数据，一般情况下，利用推送只是告诉手机端服务器发生了某些改变，当客户端收到通知以后，应该主动到服务器获取最新的数据，这样才是推送服务的完整实现。
【转自】http://blog.csdn.net/zphappy/article/details/6658504
【相关文章】http://www.chinaz.com/manage/2011/0808/203769.shtml
欢迎各位在开发一线的朋友发言，探讨！
下面这段程序的输出结果是？（）
public class Leaf {
int i = 0;
static int j=0;
Leaf increment() {
i++;
j++;
return this;
}
void print() {
System.out.println("i = " + i+" ，j = "+j);
}
public static void main(String[] args) {
Leaf x = new Leaf();
x.increment().increment().increment().print();
}
}
A. i = 3 ，j = 3
B. i = 0 ，j = 3
c. i = 3 ，j = 0
D. i = 0 ，j = 0
【翻译】(12)用户界面
see
http://developer.android.com/guide/topics/ui/index.html
原文见
http://developer.android.com/guide/topics/ui/index.html
-------------------------------
User Interface
用户界面
In this document
本文目录
* View Hierarchy 视图层级
* Layout 布局
* Widgets 部件
* Input Events 输入事件
* Menus 菜单
* Advanced Topics 高级话题
* Adapters 适配器
* Styles and Themes 风格和主题
Key classes
关键类
View
ViewGroup
Widget classes
-------------------------------
In an Android application, the user interface is built using View and ViewGroup objects. There are many types of views and view groups, each of which is a descendant of the View class.
在一个Android应用程序中，使用View和ViewGroup对象构建用户界面。有很多类型的视图和视图组，它们中每一个都是View类的后代。
View objects are the basic units of user interface expression on the Android platform. The View class serves as the base for subclasses called "widgets," which offer fully implemented UI objects, like text fields and buttons. The ViewGroup class serves as the base for subclasses called "layouts," which offer different kinds of layout architecture, like linear, tabular and relative.
View对象是Android平台上用户界面表现的基本单元。View类担当被称为部件的子类的基类，以提供完整实现的用户界面对象，像文本域和按钮。ViewGroup类作为被称为布局的子类的基类而服务，以提供不同类型的布局架构，像线性、表格（注：标签？）和相对布局。
A View object is a data structure whose properties store the layout parameters and content for a specific rectangular area of the screen. A View object handles its own measurement, layout, drawing, focus change, scrolling, and key/gesture interactions for the rectangular area of the screen in which it resides. As an object in the user interface, a View is also a point of interaction for the user and the receiver of the interaction events.
View对象是一种数据结构，它的属性存储布局参数和屏幕上特定矩形范围的内容。View对象处理它所处屏幕矩形范围内自身的度量、布局、绘画、焦点改变、滚动，以及键盘/手势交互。作为用户界面的对象，View对象还是用户的交互点以及交互事件的接收器。
-------------------------------
View Hierarchy
视图层级
On the Android platform, you define an Activity's UI using a hierarchy of View and ViewGroup nodes, as shown in the diagram below. This hierarchy tree can be as simple or complex as you need it to be, and you can build it up using Android's set of predefined widgets and layouts, or with custom Views that you create yourself.
在Android平台上，你使用View和ViewGroup节点的层级来定义Activity对象的用户界面，正如以下图例演示的那样。这个层级树可以如你所需地简单或者复杂，你可以使用Android的预定义部件和布局集合构建它，或者使用你自己创建的自定义View类。
（图略：
ViewGroup -> View
-> View
-> ViewGroup -> View
-> View
-> View
）
In order to attach the view hierarchy tree to the screen for rendering, your Activity must call the setContentView() method and pass a reference to the root node object. The Android system receives this reference and uses it to invalidate, measure, and draw the tree. The root node of the hierarchy requests that its child nodes draw themselves — in turn, each view group node is responsible for calling upon each of its own child views to draw themselves. The children may request a size and location within the parent, but the parent object has the final decision on where how big each child can be. Android parses the elements of your layout in-order (from the top of the hierarchy tree), instantiating the Views and adding them to their parent(s). Because these are drawn in-order, if there are elements that overlap positions, the last one to be drawn will lie on top of others previously drawn to that space.
为了把视图层级树依附到屏幕供渲染，你的Activity对象必须调用setContentView()方法并传递引用到根节点对象。Android系统接收到这个引用并使用它无效化（注：这里invalidate指重新画屏），度量和绘画视图树。层级的根节点要求它的子节点绘画它们自己——同样，每个视图组节点负责叫它自己的每个子视图去绘画它们自己。子对象可以在父对象中请求大小和位置，但父对象拥有每个子对象可以在哪里以及有多大的最终决定权。Android按顺序解析布局的元素（从层级树的顶部开始），实例化View对象并添加它们到它们的父对象。因为这些对象是按顺序绘画的，如果有元素重叠了位置，那么最后一个被绘画的对象将处于其它之前被绘画在那个空间的对象的上方。
For a more detailed discussion on how view hierarchies are measured and drawn, read How Android Draws Views.
想获取关于视图层级如何被度量和绘画的更详细讨论，请阅读Android绘画视图章节。
-------------------------------
Layout
布局
The most common way to define your layout and express the view hierarchy is with an XML layout file. XML offers a human-readable structure for the layout, much like HTML. Each element in XML is either a View or ViewGroup object (or descendant thereof). View objects are leaves in the tree, ViewGroup objects are branches in the tree (see the View Hierarchy figure above).
定义你的布局并表现视图层级的最通常的方式是使用XML布局文件。XML为布局提供易于让人阅读的结构，非常类似于HTML。XML内的每个元素是View对象或ViewGroup对象（或其后代）。View对象是继承树的叶节点，ViewGroup对象则是继承树的分支（见上面所示的视图层级）。
The name of an XML element is respective to the Java class that it represents. So a <TextView> element creates a TextView in your UI, and a <LinearLayout> element creates a LinearLayout view group. When you load a layout resource, the Android system initializes these run-time objects, corresponding to the elements in your layout.
XML元素的名称分别对应它代表的Java类。因此<TextView>元素在你的用户界面中创建一个TextView对象，而<LinearLayout>元素创建一个LinearLayout视图组。当你加载一个布局资源时，Android系统初始化这些运行时对象，对应于你的布局内的元素。
For example, a simple vertical layout with a text view and a button looks like this:
例如，一个带有文本视图和按钮的简单垂直布局看起来就像这样：
-------------------------------
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:orientation="vertical" >
<TextView android:id="@+id/text"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Hello, I am a TextView" />
<Button android:id="@+id/button"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Hello, I am a Button" />
</LinearLayout>
-------------------------------
Notice that the LinearLayout element contains both the TextView and the Button. You can nest another LinearLayout (or other type of view group) inside here, to lengthen the view hierarchy and create a more complex layout.
注意LinearLayout元素包含TextView和Button。你可以在它里面嵌套另一个LinearLayout（或另一种视图组），以延伸视图的层级和创建更复杂的布局
For more on building a UI layout, read XML Layouts.
想获取更多关于构建用户界面布局的信息，请阅读XML布局。
-------------------------------
Tip: You can also draw View and ViewGroups objects in Java code, using the addView(View) methods to dynamically insert new View and ViewGroup objects.
提示：你还可以使用addView(View)方法动态地插入新的View和ViewGroup对象，在Java代码中绘画View和ViewGroup对象。
-------------------------------
There are a variety of ways in which you can layout your views. Using more and different kinds of view groups, you can structure child views and view groups in an infinite number of ways. Some pre-defined view groups offered by Android (called layouts) include LinearLayout, RelativeLayout, TableLayout, GridLayout and others. Each offers a unique set of layout parameters that are used to define the positions of child views and layout structure.
你可以用不同的方式布局你的视图。使用更多和不同种类的视图组，你可以以无限数量的方式构建子视图和视图组。一些由Android提供的预定义视图组（称为布局）包括LinearLayout，RelativeLayout，TableLayout，GridLayout和其它。每种布局提供一组特有的布局参数，用于定义子视图的位置和布局结构。
To learn about some of the different kinds of view groups used for a layout, read Common Layout Objects.
为了获取关于用于布局的一些不同类型的视图组的信息，请阅读一般布局对象章节。
-------------------------------
Widgets
部件
A widget is a View object that serves as an interface for interaction with the user. Android provides a set of fully implemented widgets, like buttons, checkboxes, and text-entry fields, so you can quickly build your UI. Some widgets provided by Android are more complex, like a date picker, a clock, and zoom controls. But you're not limited to the kinds of widgets provided by the Android platform. If you'd like to do something more customized and create your own actionable elements, you can, by defining your own View object or by extending and combining existing widgets.
部件是View对象，担当与用户交互的界面。Android提供一系列完全实现的部件，如按钮、勾选框，和文本输入域，所以你可以快速构建你的用户界面。一些由Android提供的部件会更复杂，如数据拾取器、时钟、缩放控件。但你并不限于由Android平台提供的部件类型。如果你想处理更多自定义的事情并创建你自己的可操作元素，那么你可以通过定义你自己的View对象或通过扩展和组合现存部件来做到。
Read more in the Custom Components developer guide.
更多信息在自定义组件开发者指引中。
For a list of the widgets provided by Android, see the android.widget package.
想获取Android提供的部件列表，请参见android.widget包。
-------------------------------
Input Events
输入事件
Once you've added some Views/widgets to the UI, you probably want to know about the user's interaction with them, so you can perform actions. To be informed of user input events, you need to do one of two things:
一旦你添加一些视图/部件到用户界面，你很可能希望知道用户对它们的交互，使你能执行一些动作。为了被用户输入事件通知，你需要做两件事情的其中一件。
* Define an event listener and register it with the View. More often than not, this is how you'll listen for events. The View class contains a collection of nested interfaces named On<something>Listener, each with a callback method called On<something>(). For example, View.OnClickListener (for handling "clicks" on a View), View.OnTouchListener (for handling touch screen events in a View), and View.OnKeyListener (for handling device key presses within a View). So if you want your View to be notified when it is "clicked" (such as when a button is selected), implement OnClickListener and define its onClick() callback method (where you perform the action upon click), and register it to the View with setOnClickListener().
* 定义一个事件监听器并用View对象注册它。这往往是你监听事件的方式。View类包含一组内嵌的称为On<动作>Listener的接口类，每个类的活动方法叫On<动作>()。例如，View.OnClickListener（用于处理View上的“点击”），View.OnTouchListener（用于处理View中触碰屏幕事件），以及and View.OnKeyListener（用于处理View中设备键盘按下）。所以如果你希望你的View在它被“点击”时被通知（诸如当按钮被选中），那么请实现OnClickListener类并定义它的onClick()回调方法（在那里你执行点击时的动作），并用setOnClickListener()把它注册到View对象。
* Override an existing callback method for the View. This is what you should do when you've implemented your own View class and want to listen for specific events that occur within it. Example events you can handle include when the screen is touched (onTouchEvent()), when the trackball is moved (onTrackballEvent()), or when a key on the device is pressed (onKeyDown()). This allows you to define the default behavior for each event inside your custom View and determine whether the event should be passed on to some other child View. Again, these are callbacks to the View class, so your only chance to define them is when you build a custom component.
* 覆盖View的现存回调方法。当你实现你自己的View类并希望监听发生在它里面的特定事件时，你应该这样做。你可以处理的例子事件包括当你屏幕被触碰（onTouchEvent()），当轨迹球被移动（onTrackballEvent()），或当设备上的键盘被按下（onKeyDown()）。这允许你定义你的自定义View内每个事件的默认行为，并且决定事件是否被传递给其它一些子View类。再一次重申，这些是View类的回调，所以你定义它们的唯一机会是在你构建一个自定义组件的时候。
Continue reading about handling user interaction with Views in the Input Events document.
请在输入事件文档中继续阅读关于用View处理用户交互的信息。
-------------------------------
Menus
菜单
Application menus are another important part of an application's UI. Menus offers a reliable interface that reveals application functions and settings. The most common application menu is revealed by pressing the MENU key on the device. However, you can also add Context Menus, which may be revealed when the user presses and holds down on an item.
应用程序菜单是应用程序用户界面的另一个重要部分。菜单提供展示应用程序功能和设置的可靠界面。大多数一般的应用程序菜单通过按设备上的菜单键来展开。然而，你还可以添加上下文菜单，它可以在用户按下不放开一个条目时展开。
Menus are also structured using a View hierarchy, but you don't define this structure yourself. Instead, you define the onCreateOptionsMenu() or onCreateContextMenu() callback methods for your Activity and declare the items that you want to include in your menu. At the appropriate time, Android will automatically create the necessary View hierarchy for the menu and draw each of your menu items in it.
菜单还可以用View层级进行构建，但你不能自己定义此结构。取而代之的是，你为你的Activity类定义onCreateOptionsMenu()或onCreateContextMenu()回调方法，并声明你希望包含在你的菜单中的条目。在合适的时候，Android将自动为菜单创建必需的View层级，并在它里面绘画你的每个菜单条目。
Menus also handle their own events, so there's no need to register event listeners on the items in your menu. When an item in your menu is selected, the onOptionsItemSelected() or onContextItemSelected() method will be called by the framework.
菜单还处理它们自己的事件，所以没必要在你的菜单中注册事件监听器。当你的菜单中有条目被选中时，onOptionsItemSelected()或onContextItemSelected()方法将被框架调用。
And just like your application layout, you have the option to declare the items for you menu in an XML file.
同时，正如你的应用程序布局那样，你可以选择在XML文件中声明菜单的条目。
Read Menus to learn more.
读取菜单章节以获取更多信息。
-------------------------------
Advanced Topics
高级话题
Once you've grappled the fundamentals of creating a user interface, you can explore some advanced features for creating a more complex application interface.
一旦你已经熟悉创建用户界面的基础，你可以探索一些创建更复杂应用程序界面的高级特性。
Adapters
适配器
Sometimes you'll want to populate a view group with some information that can't be hard-coded, instead, you want to bind your view to an external source of data. To do this, you use an AdapterView as your view group and each child View is initialized and populated with data from the Adapter.
有时，你希望用一些不能硬编码的信息填充视图组，相反，你希望绑定你的数据到外部源数据。为了做到这一点，你可以使用AdapterView作为你的视图组，每个子视图使用来自Adapter的数据初始化和填充。
The AdapterView object is an implementation of ViewGroup that determines its child views based on a given Adapter object. The Adapter acts like a courier between your data source (perhaps an array of external strings) and the AdapterView, which displays it. There are several implementations of the Adapter class, for specific tasks, such as the CursorAdapter for reading database data from a Cursor, or an ArrayAdapter for reading from an arbitrary array.
AdapterView对象是ViewGroup的实现类，基于给定的Adapter对象决定其子视图。Adapter的行为就像你的数据源（可能是一个外部字符串数组）和显示它的AdapterView之间的信使。针对特定的任务，存在几个Adapter类的实现，诸如CursorAdapter用于从Cursor对象中读取数据库数据，或ArrayAdapter用于从任意数组中读取数据。
To learn more about using an Adapter to populate your views, read Binding to Data with AdapterView.
请阅读用AdapterView绑定到数据章节，以获取更多关于使用Adapter生成你的视图的信息。
Styles and Themes
风格和主题
Perhaps you're not satisfied with the look of the standard widgets. To revise them, you can create some of your own styles and themes.
可能你对标准部件的外观不满。为了修改它们，你可以创建一些你自己的风格和主题。
* A style is a set of one or more formatting attributes that you can apply as a unit to individual elements in your layout. For example, you could define a style that specifies a certain text size and color, then apply it to only specific View elements.
* 风格是一个或多个格式化属性集合，你可以应用它作为针对你的布局中单个元素的单元。例如，你可以定义一个风格指定某个文本的大小和颜色，然后只应用它到特定的View元素。
* A theme is a set of one or more formatting attributes that you can apply as a unit to all activities in an application, or just a single activity. For example, you could define a theme that sets specific colors for the window frame and the panel background, and sets text sizes and colors for menus. This theme can then be applied to specific activities or the entire application.
* 主题是一个或更多个格式化属性集合，你可以应用它作为针对应用程序中所有活动的单元，或只是应用于单个活动。例如，你可以定义一个主题，设置窗口框架和面板背景的特定颜色，以及设置文本大小和菜单颜色。然后这个主题可以被应用到指定活动或整个应用程序。
Styles and themes are resources. Android provides some default style and theme resources that you can use, or you can declare your own custom style and theme resources.
风格和主题是资源。Android提供一些你可以使用的默认风格和主题资源，或者你可以声明你自己的自定义风格和主题资源。
Learn more about using styles and themes in the Styles and Themes document.
请在风格和主题文档中学习更多关于使用风格和主题的信息。
Except as noted, this content is licensed under Apache 2.0. For details and restrictions, see the Content License.
除特别说明外，本文在Apache 2.0下许可。细节和限制请参考内容许可证。
Android 4.0 r1 - 17 Nov 2011 21:59
Site Terms of Service - Privacy Policy - Brand Guidelines
-------------------------------
Portions of this page are modifications based on work created and shared by the Android Open Source Project and used according to terms described in the Creative Commons 2.5 Attribution License.
（此页部分内容基于Android开源项目，以及使用根据创作公共2.5来源许可证描述的条款进行修改）