docs/html-intl/intl/ru/guide/topics/ui/declaring-layout.jd

page.title=Макеты
page.tags=view,viewgroup
@jd:body

<div id="qv-wrapper">
<div id="qv">
  <h2>Содержание документа</h2>
<ol>
  <li><a href="#write">Создание XML</a></li>
  <li><a href="#load">Загрузка ресурса XML</a></li>
  <li><a href="#attributes">Атрибуты</a>
    <ol>
      <li><a href="#id">Идентификатор</a></li>
      <li><a href="#layout-params">Параметры макета</a></li>
    </ol>
  </li>
  <li><a href="#Position">Размещение макета</a></li>
  <li><a href="#SizePaddingMargins">Размер, отступ и поля</a></li>
  <li><a href="#CommonLayouts">Часто используемые макеты</a></li>
  <li><a href="#AdapterViews">Создание макетов с помощью адаптера</a>
    <ol>
      <li><a href="#FillingTheLayout">Заполнение представления адаптера данными</a></li>
      <li><a href="#HandlingUserSelections">Обработка нажатий</a></li>
    </ol>
  </li>
</ol>

  <h2>Ключевые классы</h2>
  <ol>
    <li>{@link android.view.View}</li>
    <li>{@link android.view.ViewGroup}</li>
    <li>{@link android.view.ViewGroup.LayoutParams}</li>
  </ol>

  <h2>См. также:</h2>
  <ol>
    <li><a href="{@docRoot}training/basics/firstapp/building-ui.html">Создание простого
пользовательского интерфейса</a></li> </div>
</div>

<p>Макет определяет визуальную структуру пользовательского интерфейса, например, пользовательского интерфейса <a href="{@docRoot}guide/components/activities.html">операции</a> или <a href="{@docRoot}guide/topics/appwidgets/index.html">виджета приложения</a>.
Существует два способа объявить макет:</p>
<ul>
<li><strong>Объявление элементов пользовательского интерфейса в XML</strong>. В Android имеется удобный справочник XML-элементов
для классов View и их подклассов, например таких, которые используются для виджетов и макетов.</li>
<li><strong>Создание экземпляров элементов во время выполнения</strong>. Ваше
приложение может программным образом создавать объекты View и ViewGroup (а также управлять их свойствами). </li>
</ul>

<p>Платформа Android предоставляет вам гибкость при использовании любого из этих способов для объявления пользовательского интерфейса приложения и его управления. Например, вы можете объявить в XML макеты по умолчанию, включая элементы экрана, которые будут отображаться в макетах, и их свойства. Затем вы можете добавить в приложение код, который позволяет изменять состояние объектов на экране (включая объявленные в XML) во время выполнения. </p>

<div class="sidebox-wrapper">
<div class="sidebox">
  <ul>
  <li>В <a href="{@docRoot}tools/sdk/eclipse-adt.html">подключаемом модуле ADT
для Eclipse</a> предусмотрена функция предварительного просмотра созданного вами файла XML &mdash;
достаточно открыть файл XML и выбрать вкладку <strong>Layout</strong> (Макет).</li>
  <li>Для отладки макетов можно воспользоваться инструментом
<a href="{@docRoot}tools/debugging/debugging-ui.html#hierarchyViewer">Hierarchy Viewer</a>
&mdash; с его помощью можно просмотреть значения свойств,
рамки с индикаторами заполнения или полей, а также полностью отрисованные представления
прямо во время отладки приложения в эмуляторе или на устройстве.</li>
  <li>С помощью инструмента <a href="{@docRoot}tools/debugging/debugging-ui.html#layoutopt">layoutopt</a>
можно быстро проанализировать макеты и их иерархии на предмет низкой эффективности или иных проблем.</li>
</div>
</div>

<p>Преимущество объявления пользовательского интерфейса в файле XML заключается в том, что таким образом вы можете более эффективно отделить представление своего приложения от кода, который управляет его поведением. Описания пользовательского интерфейса находятся за пределами кода вашего приложения. Это означает, что вы можете изменять или адаптировать интерфейс без необходимости вносить правки в исходный код и повторно компилировать его. Например, можно создать разные файлы XML макета для экранов разных размеров и разных ориентаций экрана, а также для различных языков. Кроме того, объявление макета в XML упрощает визуализацию структуры пользовательского интерфейса, благодаря чему отладка проблем также становится проще. В данной статье мы научим вас объявлять макет в XML. Если вы
предпочитаете создавать экземпляры объектов View во время выполнения, обратитесь к справочной документации для классов {@link android.view.ViewGroup} и
{@link android.view.View}.</p>

<p>Как правило, справочник XML-элементов для объявления элементов пользовательского интерфейса точно следует структуре и правилам именования для классов и методов — названия элементов соответствуют названиям классов, а названия атрибутов соответствуют методам. Фактически, соответствие зачастую такое точное, что вы можете с легкостью догадаться, какой атрибут XML соответствует тому или иному методу класса, или какой класс соответствует заданному элементу XML. Однако следует отметить, что не все справочники являются идентичными. В некоторых случаях названия могут несколько отличаться. Например,
у элемента EditText есть атрибут <code>text</code>, который соответствует методу
<code>EditText.setText()</code>. </p>

<p class="note"><strong>Совет.</strong> Дополнительные сведения о различных типах макетов представлены в разделе
<a href="{@docRoot}guide/topics/ui/layout-objects.html">Часто используемые макеты</a>. Также в инструкциях по построению
<a href="{@docRoot}resources/tutorials/views/index.html">объектов представления Hello </a> изложены сведения о создании различных макетов.</p>

<h2 id="write">Создание XML</h2>

<p>С помощью справочника XML-элементов, который имеется в Android, можно быстро и просто создавать макеты пользовательского интерфейса и содержащиеся в нем элементы, точно так же, как при создании веб-страниц в HTML &mdash; с помощью вложенных элементов. </p>

<p>В каждом файле макета должен быть всего один корневой элемент, в качестве которого должен выступать объект представления (View) или представления группы (ViewGroup). После определения корневого элемента можно приступать к добавлению дополнительных объектов макета или виджетов в качестве дочерних элементов для постепенного формирования иерархии представлений, которая определяет ваш макет. Ниже представлен пример макета XML, в котором используется вертикальный объект {@link android.widget.LinearLayout},
в котором размещены элементы {@link android.widget.TextView} и {@link android.widget.Button}.</p>
<pre>
&lt;?xml version="1.0" encoding="utf-8"?>
&lt;LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
              android:layout_width="match_parent"
              android:layout_height="match_parent"
              android:orientation="vertical" >
    &lt;TextView android:id="@+id/text"
              android:layout_width="wrap_content"
              android:layout_height="wrap_content"
              android:text="Hello, I am a TextView" />
    &lt;Button android:id="@+id/button"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="Hello, I am a Button" />
&lt;/LinearLayout>
</pre>

<p>После объявления макета в файле XML сохраните файл с расширением <code>.xml</code>
в каталог <code>res/layout/</code> своего проекта Android для последующей компиляции. </p>

<p>Дополнительные сведения о синтаксисе для файла XML макета представлены в документе <a href="{@docRoot}guide/topics/resources/layout-resource.html">Ресурсы макета</a>.</p>

<h2 id="load">Загрузка ресурса XML</h2>

<p>Во время компиляции приложения каждый файл XML макета компилируется в ресурс
{@link android.view.View}. Вам необходимо загрузить ресурс макета в коде приложения в ходе реализации метода обратного вызова
{@link android.app.Activity#onCreate(android.os.Bundle) Activity.onCreate()}.
Для этого вызовите метод
<code>{@link android.app.Activity#setContentView(int) setContentView()}</code>, передайте в него ссылку на ресурс макета в следующей форме:
<code>R.layout.<em>layout_file_name</em></code>.
Например, если макет XML сохранен как файл <code>main_layout.xml</code>, загрузить его
для вашей операции необходимо следующим образом:</p>
<pre>
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main_layout);
}
</pre>

<p>Метод обратного вызова <code>onCreate()</code> в вашей операции вызывается платформой Android во время
запуска операции (см. сведения о жизненных циклах в
документе
<a href="{@docRoot}guide/components/activities.html#Lifecycle">Операции</a>).</p>


<h2 id="attributes">Атрибуты</h2>

<p>Каждый объект View и ViewGroup поддерживают свои собственные атрибуты XML.
Некоторые атрибуты характерны только для объекта View (например, объект TextView поддерживает атрибут <code>textSize</code>),
однако эти атрибуты также наследуются любыми объектами View, которые могут наследовать этот класс.
Некоторые атрибуты являются общими для всех объектов View, поскольку они наследуются от корневого класса View (такие как атрибут
<code>id</code>). Любые другие атрибуты рассматриваются как «параметры макета». Такие атрибуты
описывают определенные ориентации макета для объекта View, которые заданы
родительским объектом ViewGroup такого объекта.</p>

<h3 id="id">Идентификатор</h3>

<p>У любого объекта View может быть связанный с ним целочисленный идентификатор, который служит для обозначения уникальности объекта View в иерархии.
Во время компиляции приложения этот идентификатор используется как целое число, однако идентификатор
обычно назначается в файле XML макета в виде строки в атрибуте <code>id</code>.
Этот атрибут XML является общим для всех объектов View
(определенных классом {@link android.view.View}), который вы будете использовать довольно часто.
Синтаксис для идентификатора внутри тега XML следующий:</p>
<pre>android:id="&#64;+id/my_button"</pre>

<p>Символ @ в начале строки указывает на то, что обработчику XML следует выполнить синтаксический анализ остальной части
идентификатора, выполнить ее синтаксический анализ и определить ее в качестве ресурса идентификатора. Символ плюса (+) обозначает, что это имя нового ресурса,
который необходимо создать и добавить к нашим ресурсам (в файле <code>R.java</code>). В Android существует ряд других ресурсов
идентификатора. При ссылке на идентификатор ресурса Android вам не нужно указывать символ плюса,
однако необходимо добавить пространство имен пакета <code>android</code>, как указано ниже:</p>
<pre>android:id="&#64;android:id/empty"</pre>
<p>После добавления пространства имен пакета <code>android</code> можно сослаться на идентификатор из класса ресурсов<code>android.R</code>,
а не из локального класса ресурсов.</p>

<p>Чтобы создать представления и сослаться на них из приложения, обычно следует выполнить указанные ниже действия.</p>
<ol>
  <li>Определите представление или виджет в файле макета и присвойте ему уникальный идентификатор:
<pre>
&lt;Button android:id="&#64;+id/my_button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="&#64;string/my_button_text"/>
</pre>
  </li>
  <li>Затем создайте экземпляр объекта представления и выполните его захват из макета
(обычно с помощью метода <code>{@link android.app.Activity#onCreate(Bundle) onCreate()}</code>):
<pre>
Button myButton = (Button) findViewById(R.id.my_button);
</pre>
  </li>
</ol>
<p>Определение идентификаторов для объектов представления имеет важное значение при создании объекта {@link android.widget.RelativeLayout}.
В относительном макете универсальные идентификаторы используются для
расположения представлений относительно друг друга.</p>
<p>Идентификатор не обязательно должен быть уникальным в рамках всей иерархии,
а только в той ее части, где вы выполняете поиск (зачастую это может быть как раз вся иерархия, поэтому
при возможности идентификаторы должны быть полностью уникальными).</p>


<h3 id="layout-params">Параметры макета</h3>

<p>Атрибуты макета XML, которые называются <code>layout_<em>something</em></code>, определяют
параметры макета для объекта представления, подходящие для класса ViewGroup, в котором он находится.</p>

<p>Каждый класс ViewGroup реализует вложенный класс, который наследует {@link
android.view.ViewGroup.LayoutParams}. В этом подклассе
имеются типы свойств, которые определяют размер и положение каждого дочернего представления,
подходящие для его группы. На рисунке 1 показано, что родительская группа
представлений определяет параметры макета для каждого дочернего представления (включая дочернюю группу представлений).</p>

<img src="{@docRoot}images/layoutparams.png" alt="" />
<p class="img-caption"><strong>Рисунок 1.</strong> Графическое представление иерархии представления с параметрами
макета каждого представления.</p>

<p>Обратите внимание, что подкласс LayoutParams имеет собственный синтаксис для задания
значений. Каждый дочерний элемент должен определять LayoutParams, которые подходят для его родительского элемента,
тогда как он сам может определять другие LayoutParams для своих дочерних элементов. </p>

<p>Все группы представлений включают в себя параметры ширины и высоты (<code>layout_width</code> и
<code>layout_height</code>), и каждое представление должно определять их. Многие
LayoutParams также включают дополнительные параметры полей и границ. <p>

<p>Для параметров ширины и высоты можно указать точные значения, хотя, возможно,
вам не захочется делать это часто. Обычно для задания значений ширины и высоты используется одна из следующих
констант: </p>

<ul>
  <li><var>wrap_content</var> — размер представления задается по размерам
его содержимого;</li>
  <li><var>match_parent</var> (которая до API уровня 8 <var>называлась fill_parent</var> )
 — размер представления определяется ограничениями, задаваемыми его родительской группой представлений.</li>
</ul>

<p>Как правило, не рекомендуется задавать абсолютные значения ширины и высоты макета
(например, в пикселах). Вместо этого используйте относительные единицы измерения, такие как
пикселы, не зависящие от разрешения экрана (<var>dp</var>), <var>wrap_content</var>или
<var>match_parent</var>Это гарантирует одинаковое отображение
вашего приложения на устройствах с экранами разных размеров.
Принятые типы измерения определены в
документе
<a href="{@docRoot}guide/topics/resources/available-resources.html#dimension">Доступные ресурсы</a>.</p>


<h2 id="Position">Размещение макета</h2>
   <p>
   Представление имеет прямоугольную форму. Расположение представления
определяется его координатами <em>слева</em> и <em>сверху</em>, а его размеры
— параметрами ширины и высоты. Расположение измеряется
в пикселах.
   </p>

   <p>
   Расположение представления можно получить путем вызова методов
{@link android.view.View#getLeft()} и {@link android.view.View#getTop()}. Первый возвращает координату слева (по оси X)
для прямоугольника представления. Второй возвращает верхнюю координату
 (по оси Y) для прямоугольника представления. Оба этих метода
возвращают расположение представления относительно его родительского элемента. Например,
когда метод <code>getLeft()</code> возвращает 20, это означает, что представление находится на расстоянии 20 пикселов
от левого края его непосредственного родительского элемента.
   </p>

   <p>
   Кроме того, имеется несколько удобных методов
({@link android.view.View#getRight()} и {@link android.view.View#getBottom()}), которые позволяют избежать лишних вычислений.
   Эти методы возвращают координаты правого и нижнего краев
прямоугольника представления. Например, вызов метода {@link android.view.View#getRight()}
аналогичен следующему вычислению: <code>getLeft() + getWidth()</code>.
   </p>


<h2 id="SizePaddingMargins">Размер, отступ и поля</h2>
   <p>
   Размер представления выражается его шириной и высотой. Фактически, представление
обладает двумя парами значений «ширина-высота».
   </p>

   <p>
   Первая пара — это <em>измеренная ширина</em> и
<em>измеренная высота</em>. Эти размеры определяют размер представления
в границах своего родительского элемента. Измеренные
размеры можно получить, вызвав методы {@link android.view.View#getMeasuredWidth()}
и{@link android.view.View#getMeasuredHeight()}.
   </p>

   <p>
   Вторая пара значений — это просто <em>ширина</em> и <em>высота</em> (иногда они называются
<em>чертежная ширина</em> и <em>чертежная высота</em>). Эти размеры
определяют фактический размер представления на экране после разметки во время их
отрисовки. Эти значения могут отличаться от
измеренных ширины и высоты, хотя это и не обязательно. Значения ширины и высоты можно получить, вызвав методы
{@link android.view.View#getWidth()} и {@link android.view.View#getHeight()}.
   </p>

   <p>
   При измерении своих размеров представление учитывает заполнение. Отступ
выражается в пикселах для левой, верхней, правой и нижней частей представления.
   Отступ можно использовать для смещения содержимого представления на определенное количество
пикселов. Например, значение отступа слева, равное 2, приведет к тому, что содержимое представления будет смещено
на 2 пиксела вправо от левого края представления. Для задания отступов можно использовать метод
{@link android.view.View#setPadding(int, int, int, int)}. Чтобы запросить отступ, используются методы
{@link android.view.View#getPaddingLeft()}, {@link android.view.View#getPaddingTop()},
{@link android.view.View#getPaddingRight()} и {@link android.view.View#getPaddingBottom()}.
   </p>

   <p>
   Даже если представление может определить отступ, в нем отсутствует поддержка
полей. Такая возможность имеется у группы представлений. Дополнительные сведения представлены в справке по объектам
{@link android.view.ViewGroup} и
{@link android.view.ViewGroup.MarginLayoutParams}.
   </p>

   <p>Дополнительные сведения о размерах представлены в разделе
<a href="{@docRoot}guide/topics/resources/more-resources.html#Dimension">Значения размеров</a>.
   </p>






<style type="text/css">
div.layout {
  float:left;
  width:200px;
  margin:0 0 20px 20px;
}
div.layout.first {
  margin-left:0;
  clear:left;
}
</style>




<h2 id="CommonLayouts">Часто используемые макеты</h2>

<p>В каждом подклассе класса {@link android.view.ViewGroup} имеется уникальный способ отображения
вложенных в него представлений. Ниже представлены некоторые из наиболее часто используемых типов макетов, которые входят в состав платформы
Android.</p>

<p class="note"><strong>Примечание.</strong> Несмотря на то, что для формирования пользовательского интерфейса один
макет может содержать один или несколько вложенных макетов, рекомендуется использовать как можно более простую
иерархию макетов. Чем меньше в макете вложенных элементов, тем быстрее выполняется его отрисовка (горизонтальная иерархия
представлений намного лучше вертикальной).</p>

<!--
<h2 id="framelayout">FrameLayout</h2>
<p>{@link android.widget.FrameLayout FrameLayout} is the simplest type of layout
object. It's basically a blank space on your screen that you can
later fill with a single object &mdash; for example, a picture that you'll swap in and out.
All child elements of the FrameLayout are pinned to the top left corner of the screen; you cannot
specify a different location for a child view. Subsequent child views will simply be drawn over
previous ones,
partially or totally obscuring them (unless the newer object is transparent).
</p>
-->


<div class="layout first">
  <h4><a href="layout/linear.html">Линейный макет</a></h4>
  <a href="layout/linear.html"><img src="{@docRoot}images/ui/linearlayout-small.png" alt="" /></a>
  <p>Макет, в котором дочерние элементы представлены в горизонтальных или вертикальных столбцах. Если длина окна больше длины экрана, в нем
создается полоса прокрутки.</p>
</div>

<div class="layout">
  <h4><a href="layout/relative.html">Относительный макет</a></h4>
  <a href="layout/relative.html"><img src="{@docRoot}images/ui/relativelayout-small.png" alt="" /></a>
  <p>В этом макете можно задавать расположение дочерних объектов относительно друг друга (дочерний элемент А находится
слева от дочернего элемента Б) или относительно родительского объекта (выравнивание относительно верхнего края родительского элемента).</p>
</div>

<div class="layout">
  <h4><a href="{@docRoot}guide/webapps/webview.html">Представление веб-страницы</a></h4>
  <a href="{@docRoot}guide/webapps/webview.html"><img src="{@docRoot}images/ui/webview-small.png" alt="" /></a>
  <p>Отображение веб-страниц.</p>
</div>




<h2 id="AdapterViews" style="clear:left">Создание макетов с помощью адаптера</h2>

<p>Если содержимое макета является динамическим или не определено заранее, можно использовать макет, который создает подклассы класса
{@link android.widget.AdapterView} для заполнения макета представлениями во время выполнения. Подкласс класса
{@link android.widget.AdapterView} использует {@link android.widget.Adapter} для
привязки данных к своему макету. {@link android.widget.Adapter} выступает в качестве посредника между источником
данных и макетом {@link android.widget.AdapterView} &mdash; {@link android.widget.Adapter}
извлекает данные (из источника, например, массива или запроса к базе данных) и преобразует каждую запись
в представление, которое можно добавить в макет {@link android.widget.AdapterView}.</p>

<p>Часто используемые макеты, для создания которых можно использовать адаптер, включают в себя следующие:</p>

<div class="layout first">
  <h4><a href="layout/listview.html">Представление в виде списка</a></h4>
  <a href="layout/listview.html"><img src="{@docRoot}images/ui/listview-small.png" alt="" /></a>
  <p>Отображение списка в один столбец с возможностью прокрутки.</p>
</div>

<div class="layout">
  <h4><a href="layout/gridview.html">Представление в виде сетки</a></h4>
  <a href="layout/gridview.html"><img src="{@docRoot}images/ui/gridview-small.png" alt="" /></a>
  <p>Отображение сетки из столбцов и строк с возможностью прокрутки.</p>
</div>



<h3 id="FillingTheLayout" style="clear:left">Заполнение представления адаптера данными</h3>

<p>Чтобы заполнить адаптер {@link android.widget.AdapterView}, такой как {@link android.widget.ListView} или
{@link android.widget.GridView}, свяжите экземпляр {@link android.widget.AdapterView} с приложением
{@link android.widget.Adapter}, которое извлекает данные из внешнего источника и создает объект {@link
android.view.View}, который представляет каждую запись данных.</p>

<p>В Android предусмотрено несколько подклассов адаптера {@link android.widget.Adapter}, которые полезно использовать для
извлечения данных различных видов и создания представлений для {@link android.widget.AdapterView}. Вот
два наиболее часто используемых адаптера:</p>

<dl>
  <dt>{@link android.widget.ArrayAdapter}</dt>
    <dd>Этот адаптер используется в случае, когда в качестве источника данных выступает массив. По умолчанию {@link
android.widget.ArrayAdapter} создает представление для каждого элемента массива путем вызова метода {@link
java.lang.Object#toString()} для каждого элемента и помещения его содержимого в объект {@link
android.widget.TextView}.
      <p>Например, если имеется массив строк, которые необходимо отобразить в объекте {@link
android.widget.ListView}, запустите новый {@link android.widget.ArrayAdapter} с помощью
конструктора, чтобы указать макет для каждой строки и массива строк:</p>
<pre>
ArrayAdapter&lt;String> adapter = new ArrayAdapter&lt;String>(this,
        android.R.layout.simple_list_item_1, myStringArray);
</pre>
<p>Аргументы для такого конструктора следующие:</p>
<ul>
  <li>ваше приложение {@link android.content.Context};</li>
  <li>макет, в котором содержится объект {@link android.widget.TextView} для каждой строки в массиве;</li>
  <li>массив строк.</li>
</ul>
<p>Затем достаточно вызвать метод
{@link android.widget.ListView#setAdapter setAdapter()} для своего объекта {@link android.widget.ListView}:</p>
<pre>
ListView listView = (ListView) findViewById(R.id.listview);
listView.setAdapter(adapter);
</pre>

      <p>Чтобы настроить внешний вид каждого элемента, можно переопределить метод {@link
java.lang.Object#toString()} для объектов в массиве. Либо можно создать представление для каждого элемента,
который отличается от{@link android.widget.TextView} (например, если для каждого элемента массива требуется объект
{@link android.widget.ImageView}), наследовать класс {@link
android.widget.ArrayAdapter} и переопределить метод {@link android.widget.ArrayAdapter#getView
getView()}, чтобы возвратить требуемый тип представления для каждого элемента.</p>

</dd>

  <dt>{@link android.widget.SimpleCursorAdapter}</dt>
    <dd>Этот адаптер используется в случае, когда в качестве источника данных выступает объект {@link android.database.Cursor}. Если
используется {@link android.widget.SimpleCursorAdapter}, необходимо указать макет, который будет
использоваться для каждой строки в объекте {@link android.database.Cursor}, а также в какие представления макета необходимо вставить столбцы в объекте {@link android.database.Cursor}
. Например, если необходимо создать список
имен людей с их номерами телефонов, можно выполнить запрос, который возвращает объект {@link
android.database.Cursor}, содержащий строку для каждого человека и столбцы для имен и номеров
телефонов. Затем создается массив строк с указанием столбцов из объекта {@link
android.database.Cursor}, которые необходимо поместить в макет для каждого результата, а также массив целых чисел, в котором указаны
соответствующие представления для вставки каждого столбца:</p>
<pre>
String[] fromColumns = {ContactsContract.Data.DISPLAY_NAME,
                        ContactsContract.CommonDataKinds.Phone.NUMBER};
int[] toViews = {R.id.display_name, R.id.phone_number};
</pre>
<p>При создании экземпляра объекта {@link android.widget.SimpleCursorAdapter} передайте в него макет,
который будет использоваться для каждого результата, объект {@link android.database.Cursor} с результатами и два следующих массива:</p>
<pre>
SimpleCursorAdapter adapter = new SimpleCursorAdapter(this,
        R.layout.person_name_and_number, cursor, fromColumns, toViews, 0);
ListView listView = getListView();
listView.setAdapter(adapter);
</pre>
<p>Затем {@link android.widget.SimpleCursorAdapter} создает представление для каждой строки в объекте
{@link android.database.Cursor} с помощью предоставленного макета путем вставки каждого элемента {@code
fromColumns} в соответствующее представление {@code toViews}.</p>.</dd>
</dl>


<p>Если в течение жизненного цикла вашего приложения вы вносите изменения в соответствующие данные, чтение которых
выполняет адаптер, вам следует вызвать метод {@link android.widget.ArrayAdapter#notifyDataSetChanged()}. Это позволит
уведомить связанное представление о том, что данные были изменены и ему требуется выполнить обновление.</p>



<h3 id="HandlingUserSelections">Обработка нажатий</h3>

<p>Чтобы организовать реагирование на нажатие каждого элемента в {@link android.widget.AdapterView},
реализуйте интерфейс {@link android.widget.AdapterView.OnItemClickListener}. Например:</p>

<pre>
// Create a message handling object as an anonymous class.
private OnItemClickListener mMessageClickedHandler = new OnItemClickListener() {
    public void onItemClick(AdapterView parent, View v, int position, long id) {
        // Do something in response to the click
    }
};

listView.setOnItemClickListener(mMessageClickedHandler);
</pre>