4Android用户界面
1. 本章概述
通过本章的学习，掌握Android常用布局管理器的用法，通过综合运用各种布局管理器实现复杂界面的设计。本章详细介绍Android常用组件的知识，并通过实例的实现过程讲解各个组件的使用方法。
2. 本章重点与难点
1） 重点
（1） 常用布局管理器。
（2） 常用UI控件。
（3） 复杂UI控件。
（4） Android资源。
2） 难点
（1） ListView与RecycleView控件的用法。
（2） 图像状态资源的使用。
3. 重难点学习建议
本章主要帮助读者学习并掌握Android中布局管理器的应用，读者在学习中要深入理解各个布局管理器的常用参数。Android应用程序的人机交互界面由许多Android控件组成，这些控件是直接与用户交互的对象，掌握好这些控件对我们在以后的开发中会起到至关重要的作用。多看案例，多思考，多动手实践，从而能够熟练地综合应用各个布局管理器及常用控件搭建出需要实现的界面。本章所涉及的资源文件是读者比较容易忽略的章节，读者往往会感觉学习难度不大，在实际应用中很多时候会因为不注意对资源的使用产生各种各样的错误。学习本章应重点掌握不同资源文件存放的位置、资源的属性、调用的方法等内容。熟练掌握并使用字符串资源、图片资源、值资源、风格与主题资源、动画资源等知识，学好使用资源文件是安卓开发的重中之重。4.1界 面 布 局
界面布局（Layout）是用户界面结构的描述，定义了界面中所有的元素、结构和相互关系。在Android中，每个控件在窗体中都有具体的位置和尺寸，在窗体中摆放各种控件时，很难准确判断控件的具体位置和大小，不过使用Android的布局管理器可以很方便地控制各个控件的位置和大小。Android中的布局是一个容器，在此容器中可放置其他控件，大部分容器控件继承ViewGroup类。在Android应用中，用户界面布局可以使用XML描述。Android Studio提供一套富布局编辑器，开发者可以在其中随意拖曳各类用户界面组件进行布局构建，还可以在多屏幕配置中同时查看多种布局的显示效果。
在Android中，提供了一种非常简单、方便的方法用于控制UI界面。该方法采用XML文件来进行界面布局，从而将布局界面的代码和逻辑控制的代码分离开来，使程序的结构更加清晰、明了。使用XML布局文件控制UI界面可以分为以下两个关键步骤。
（1） 在Android应用的res/layout目录下编写XML布局文件，可以是任何符合Java命名规则的文件名。创建后，R.java会自动收集该布局资源。
（2） 在Activity中使用以下代码加载XML文件中布局的内容。setContentView(R.layout. activity_main);
在上面的代码中，activity_main是XML布局文件的文件名。
通过上面的代码步骤就可轻松实现布局并显示UI界面功能了。
4.1.1线性布局    
线性布局（LinearLayout）是布局中最常用的一种布局，它按照垂直或者水平的顺序依次排列子元素，每一个子元素都位于前一个元素之后。如果是垂直排列，那么将是一个N行单列的结构，每一行只会有一个元素，而不论这个元素的宽度为多少；如果是水平排列，那么将是一个单行N列的结构。如果搭建两行两列的结构，通常的方式是先垂直排列两个元素，每一个元素里再包含一个LinearLayout进行水平排列。
LinearLayout属性中的android:orientation属性是设置线性布局方向的，当其值为vertical时，为垂直线性布局，当其值为horizontal时，为水平线性布局。
再来看一下android:layout_gravity 和 android:gravity的使用，这两个属性看起来有些相似，都是设置对齐方式的，那么这两个属性有什么区别呢？其实从名字上就可以看出，android:gravity 是用于指定文字在控件中的对齐方式，而 android:layout_gravity 是用于指定控件在布局中的对齐方式。android:layout_gravity 的可选值和 android:gravity 差不多，但是需要注意，当 LinearLayout 的排列方向是 horizontal 时，只有垂直方向上的对齐方式才会生效，因为此时水平方向上的长度是不固定的，每添加一个控件，水平方向上的长度都会改变，因而无法指定该方向上的对齐方式。同样的道理，当 LinearLayout 的排列方向是 vertical 时，只有水平方向上的对齐方式才会生效。这两个属性的可选值也是相同的，包括： top、bottom、left、right、center_vertical、fill_vertical、center_horizontal、fill_horizontal、center、fill、clip_vertical。而且这些属性是可以多选的，用“|”分开。默认值是： Gravity.LEFT。对这些属性的描述如表4.1所示。表4.1android:layout_gravity和android:gravity属性取值
取值说明top将对象放在其容器的顶部，不改变其大小bottom将对象放在其容器的底部，不改变其大小left将对象放在其容器的左侧，不改变其大小right将对象放在其容器的右侧，不改变其大小center_vertical将对象纵向居中，不改变其大小，垂直对齐方式：垂直方向居中对齐fill_vertical必要的时候增加对象的纵向大小，以完全充满其容器；垂直方向填充center_horizontal将对象横向居中，不改变其大小；水平对齐方式：水平方向居中对齐fill_horizontal必要的时候增加对象的横向大小，以完全充满其容器；水平方向填充center将对象横纵居中，不改变其大小fill必要的时候增加对象的横纵向大小，以完全充满其容器clip_vertical附加选项，用于按照容器的边来剪切对象的顶部和/或底部的内容。剪切基于其纵向对齐设置：顶部对齐时，剪切底部；底部对齐时剪切顶部；除此之外，剪切顶部和底部；垂直方向裁剪clip_horizontal附加选项，用于按照容器的边来剪切对象的左侧和/或右侧的内容。剪切基于其横向对齐设置：左侧对齐时，剪切右侧；右侧对齐时，剪切左侧；除此之外，剪切左侧和右侧；水平方向裁剪【例4.1】android:orientation、android:layout_gravity 和 android:gravity的使用。<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:background="#ff666666"
android:baselineAligned="false"
android:orientation="vertical">
<LinearLayout
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:background="#ff0000"
android:baselineAligned="false"
android:orientation="vertical">
<Button
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="buttonA" />
<Button
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="buttonB" />
<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_gravity="left"
android:text="buttonC" />

<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_gravity="center"
android:text="buttonD" />
<Button
android:layout_width="wrap_content"
android:layout_height="match_parent"
android:layout_gravity="right"
android:text="buttonE" />
</LinearLayout>

<LinearLayout
android:layout_width="match_parent"
android:layout_height="match_parent"
android:background="#00ff00"
android:baselineAligned="false"
android:orientation="horizontal">
<Button
android:layout_width="wrap_content"
android:layout_height="match_parent"
android:text="buA" />
<Button
android:layout_width="wrap_content"
android:layout_height="match_parent"
android:layout_marginTop="10dp"
android:text="buB" />
<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_gravity="top"
android:layout_marginTop="15dp"
android:text="butC" />

<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_gravity="center"
android:text="butD" />
<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_gravity="bottom"
android:text="bunE" />
</LinearLayout>
</LinearLayout>
运行效果如图4.1所示。
图4.1程序运行效果
程序分析： 例子中在线性容器中放置两个子线性布局容器，如图中上面5个按钮区域和下面5个按钮区域，红色区域线性容器的方向是垂直的，控件的对齐方式是left、center和right。而绿色区域线性容器的方向是水平的，控件的对齐方式是top、center和bottom。
接下来学习LinearLayout的另一个重要属性： android:layout_weight。这个属性允许使用比例的方式来指定控件的大小，它在手机屏幕的适配性方面可以起到非常重要的作用。
【例4.2】使用android:weight完成消息发送界面，包含一个文本编辑框和一个发送按钮。<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="horizontal">
<EditText

android:id="@+id/input_message"
android:layout_width="0dp"
android:layout_height="wrap_content"
android:layout_weight="1"
android:hint="Type something"
/>
<Button
android:id="@+id/send"
android:layout_width="0dp"
android:layout_height="wrap_content"
android:layout_weight="1"
android:text="Send"/>

</LinearLayout>
读者会发现，这里竟然将 EditText 和 Button 的宽度都指定成了0，这样文本编辑框和按钮还能显示出来吗？不用担心，由于使用了 android:layout_weight 属性，此时控件的宽度就不应该再由 android:layout_width 来决定，这里指定成 0 是一种比较规范的写法。
然后在EditText和Button里都将android:layout_weight属性的值指定为1，这表示EditText和Button将在水平方向平分宽度，重新运行程序，会看到如图4.2所示的效果。
图4.2消息发送界面
为什么将android:layout_weight属性的值同时指定为1就会平分屏幕宽度呢？其实原理也很简单，系统会先把LinearLayout下所有控件指定的layout_weight值相加，得到一个总值，然后每个控件所占大小的比例就是用该控件的layout_weight值除以刚才算出的总值。因此，如果想让EditText占据屏幕宽度的3/5，Button占据屏幕宽度的2/5，只需要将EditText的layout_weight改成3，Button的layout_weight改成2就可以了。还可以通过指定部分控件的layout_weight值，来实现更好的效果。
【例4.3】使用android:weight实现按钮放到屏幕底端，剩余空间全部分配给另一个控件。<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="Vertical">
<EditText
android:id="@+id/input_message"
android:layout_width="match_parent"
android:layout_height="0dp"
android:layout_weight="1"
android:hint="Type something"
/>
<Button
android:id="@+id/send"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_weight="0"
android:text="Send"/>
</LinearLayout>
程序运行效果如图4.3所示。
图4.3程序运行效果
【例4.4】使用android:weight实现两个按钮均分屏幕宽度。<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:orientation="horizontal">
<Button
android:layout_width="0dp"
android:layout_height="wrap_content"
android:layout_weight="1"
android:text="button" />
<Button
android:id="@+id/send"
android:layout_width="0dp"
android:layout_height="wrap_content"
android:layout_weight="1"
android:text="button" />
</LinearLayout>
程序运行效果如图4.4所示。
图4.4程序运行效果
4.1.2相对布局
相对布局（RelativeLayout），与线性布局一样，在里面可以放多个控件，但是每个控件的位置都是相对的。可以定义每一个子View与其他子View之间以及与屏幕边界之间的相对位置。RelativeLayout继承于android.widget.ViewGroup，其按照子元素之间的位置关系完成布局，作为Android系统四大布局中最灵活也是最常用的一种布局方式，非常适合于一些比较复杂的界面设计。
注意： 在引用其他子元素之前，引用的ID必须已经存在，否则将出现异常。RelativeLayout按照各子元素之间的位置关系完成布局。在此布局中的子元素里与位置相关的属性将生效。具体的属性介绍如下。
第一类:属性值为true或false。
android:layout_centerHorizontal： 水平居中。
android:layout_centerVertical： 垂直居中。
android:layout_centerInparent： 相对于父元素完全居中。
android:layout_alignParentBottom： 贴紧父元素的下边缘。
android:layout_alignParentLeft： 贴紧父元素的左边缘。
android:layout_alignParentRight： 贴紧父元素的右边缘。
android:layout_alignParentTop： 贴紧父元素的上边缘。
android:layout_alignWithParentIfMissing： 如果对应的兄弟元素找不到就以父元素作参照物。
第二类： 属性值必须为id的引用名“@id/idname”。
android:layout_below： 在某元素的下方。
android:layout_above： 在某元素的上方。
android:layout_toLeftOf： 在某元素的左边。
android:layout_toRightOf： 在某元素的右边。
android:layout_alignTop： 本元素的上边缘和某元素的上边缘对齐。
android:layout_alignLeft： 本元素的左边缘和某元素的左边缘对齐。
android:layout_alignBottom： 本元素的下边缘和某元素的下边缘对齐。
android:layout_alignRight： 本元素的右边缘和某元素的右边缘对齐。
第三类： 属性值为具体的像素值，如40dip，30px。
android:layout_marginBottom： 离某元素底边缘的距离。
android:layout_marginLeft： 离某元素左边缘的距离。
android:layout_marginRight： 离某元素右边缘的距离。
android:layout_marginTop： 离某元素上边缘的距离。
android:gravity属性是用来设置元素的文本内容的显示位置，比如一个按钮上面的文本可以靠左或者靠右显示，如果要设置按钮的文本靠右显示，就编写为android:gravity="right"。
android:layout_gravity是用来设置该元素相对于其父类元素的位置，比如一个按钮显示在线性布局管理器中，如果要设置按钮靠右显示，就编写为android:layout_gravity="right"。
下面通过一个实例来学习相对布局的应用。
【例4.5】相对布局管理器实例。<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="300dp"
android:background="#ff0000">
<!-- 相对父容器 -->
<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignParentLeft="true"
android:layout_alignParentTop="true"
android:text="B1" />
<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignParentLeft="true"
android:layout_alignParentBottom="true"
android:text="B2" />

<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignParentTop="true"
android:layout_alignParentRight="true"
android:text="B3" />

<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignParentRight="true"
android:layout_alignParentBottom="true"
android:text="B4" />

<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignParentLeft="true"
android:layout_centerVertical="true"
android:text="B5" />

<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignParentRight="true"
android:layout_centerVertical="true"
android:text="B6" />

<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignParentTop="true"
android:layout_centerHorizontal="true"
android:text="B7" />

<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignParentBottom="true"
android:layout_centerHorizontal="true"
android:text="B8" />

<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_centerInParent="true"
android:text="B9" />
</RelativeLayout>
程序分析： 本案例中使用相对布局管理器，共有8个按钮，B1放在父容器的左上角，B2放在父容器的左下角，B9放在父容器的中心，B6放在父容器的右侧垂直居中，以此类推，设置所有按钮相对父容器的位置。
界面设计效果如图4.5所示。
图4.5相对布局管理器案例运行结果图
4.1.3帧布局
FrameLayout表示帧布局管理器，在帧布局管理器中每加入一个控件都将会创建一个空白的区域，通常称之为一帧，这些帧会根据gravity属性执行自动对齐。默认情况下，帧布局从屏幕的左上角(0，0)坐标点开始布局，多个控件层叠排序，后面的控件覆盖前面的控件。
此布局可以放置多个view，但只有一个view可以显示，通常使用此布局处理在同一位置不同情况下显示不同内容的控件。
在Andriod中，在XML布局文件中定义帧布局管理器可以使用<FrameLayout>标记，格式为：<FrameLayout 
属性列表>
<!—添加需要的控件-->
</FrameLayout>
下面通过例子来看一下帧布局管理器的应用。
【例4.6】使用帧布局管理器实现通过单击按钮在3个红、绿、蓝的View之间进行切换的效果。
实现步骤如下。
（1） 首先实现界面效果，创建布局文件activity_frame，布局根元素使用垂直方向的线性布局，在根线性布局中再放置一个水平方向的线性容器，在水平线性容器中放置三个按钮，在根线性容器中接着再放一个帧布局，将三个TextView器放置到帧布局中，界面结构如图4.6所示。
图4.6界面布局结构
对应的代码如下。<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
tools:context=".FrameActivity">
<LinearLayout
android:layout_width="match_parent"
android:layout_height="wrap_content">
<Button
android:layout_width="0dp"
android:layout_height="wrap_content"
android:layout_weight="1"
android:text="FrameA"
android:id="@+id/frameA"/>
<Button
android:layout_width="0dp"
android:layout_height="wrap_content"
android:layout_weight="1"
android:text="FrameB"
android:id="@+id/frameB"/>
<Button
android:layout_width="0dp"
android:layout_height="wrap_content"
android:layout_weight="1"
android:text="FrameC"
android:id="@+id/frameC"/>
</LinearLayout>
<FrameLayout
android:layout_width="match_parent"
android:layout_height="match_parent">
<TextView
android:layout_width="match_parent"
android:layout_height="match_parent"
android:id="@+id/txtA"
android:background="#ff0000"/>
<TextView
android:layout_width="match_parent"
android:layout_height="match_parent"
android:id="@+id/txtB"
android:background="#00ff00"/>
<TextView
android:layout_width="match_parent"
android:layout_height="match_parent"
android:id="@+id/txtC"
android:background="#0000ff"/>
</FrameLayout>
</LinearLayout>
（2） 在FrameActivity.java文件中加载上面创建的布局文件，添加如下代码，让按钮能够进行事件处理，从而显示帧布局切换的效果。package com.example.booksource;

import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

public class FrameActivity extends AppCompatActivity {
class ButtonListener implements View.OnClickListener{

@Override
public void onClick(View v) {
switch (v.getId()){
case R.id.frameA:
txtA.setVisibility(View.VISIBLE);
txtB.setVisibility(View.GONE);
txtC.setVisibility(View.GONE);
break;
case R.id.frameB:
txtB.setVisibility(View.VISIBLE);
txtA.setVisibility(View.GONE);
txtC.setVisibility(View.GONE);
break;
case R.id.frameC:
txtC.setVisibility(View.VISIBLE);
txtA.setVisibility(View.GONE);
txtB.setVisibility(View.GONE);
break;
}
}
}
private Button btnA,btnB,btnC;
private TextView txtA,txtB,txtC;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_frame);
btnA=findViewById(R.id.frameA);
btnA.setOnClickListener(new ButtonListener());
btnB=findViewById(R.id.frameB);
btnB.setOnClickListener(new ButtonListener());
btnC=findViewById(R.id.frameC);
btnC.setOnClickListener(new ButtonListener());
txtA=findViewById(R.id.txtA);
txtB=findViewById(R.id.txtB);
txtC=findViewById(R.id.txtC);
}

}
单击FRAMEA按钮，界面如图4.7(a)所示，单击FRAMEB按钮，界面如图4.7(b)所示。
图4.7帧布局管理器案例运行结果
4.1.4网格布局
网格布局（GridLayout）在Android 4.0以上版本中才出现。GridLayout使用虚细线将布局划分为行、列和单元格，也支持一个控件在行、列上都有交错排列。而GridLayout使用方式有些类似LinearLayout，只不过是修改了一下相关的标签而已，所以对于开发者来说，掌握GridLayout还是很容易的。
GridLayout的布局策略简单分为以下三个部分。
首先，它与LinearLayout布局一样，也分为水平和垂直两种方式，默认是水平布局，一个控件挨着一个控件从左到右依次排列，但是通过指定android:columnCount设置列数的属性后，控件会自动换行进行排列。另外，对于GridLayout布局中的子控件，默认按照wrap_content的方式设置其显示，这只需要在GridLayout布局中显式声明即可。
其次，若要指定某控件显示在固定的行或列，只需设置该子控件的android:layout_row和android:layout_column属性即可，但是需要注意： android:layout_row="0"表示从第一行开始，android:layout_column="0"表示从第一列开始，这与编程语言中一维数组的赋值情况类似。
最后，如果需要设置某控件跨越多行或多列，只需将该子控件的android:layout_rowSpan或者layout_columnSpan属性设置为数值，再设置其layout_gravity属性为fill即可，前一个设置表明该控件跨越的行数或列数，后一个设置表明该控件填满所跨越的整行或整列。
【例4.7】使用网格布局完成计算器界面设计。<?xml version="1.0" encoding="utf-8"?>
<GridLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@+id/GridLayout1"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:columnCount="4"
android:orientation="horizontal"
android:rowCount="6">
<TextView
android:layout_columnSpan="4"
android:layout_gravity="fill"
android:layout_marginLeft="5dp"
android:layout_marginRight="5dp"
android:background="#FFCCCC"
android:text="0"
android:textSize="50sp" />

<Button
android:layout_columnSpan="2"
android:layout_gravity="fill"
android:layout_columnWeight="1"
android:text="回退" />

<Button
android:layout_columnSpan="2"
android:layout_gravity="fill"
android:layout_columnWeight="1"
android:text="清空" />

<Button
android:layout_gravity="fill"
android:layout_columnWeight="1"
android:text="+" />

<Button
android:layout_gravity="fill"
android:layout_columnWeight="1"
android:text="1" />

<Button
android:layout_gravity="fill"
android:text="2" />

<Button
android:layout_gravity="fill"
android:layout_columnWeight="1"
android:text="3" />

<Button
android:layout_gravity="fill"
android:layout_columnWeight="1"
android:text="-" />

<Button
android:layout_gravity="fill"
android:layout_columnWeight="1"
android:text="4" />

<Button
android:layout_gravity="fill"
android:layout_columnWeight="1"
android:text="5" />

<Button
android:layout_gravity="fill"
android:layout_columnWeight="1"
android:text="6" />

<Button
android:layout_gravity="fill"
android:layout_columnWeight="1"
android:text="" />

<Button
android:layout_gravity="fill"
android:layout_columnWeight="1"
android:text="7" />

<Button
android:layout_gravity="fill"
android:layout_columnWeight="1"
android:text="8" />

<Button
android:layout_gravity="fill"
android:layout_columnWeight="1"
android:text="9" />

<Button
android:layout_gravity="fill"
android:layout_columnWeight="1"
android:text="/" />

<Button
android:layout_width="wrap_content"
android:layout_columnWeight="1"
android:layout_gravity="fill"
android:text="." />

<Button
android:layout_gravity="fill"
android:layout_columnWeight="1"
android:text="0" />

<Button
android:layout_gravity="fill"
android:layout_columnWeight="1"
android:text="=" />

</GridLayout>
程序界面设计效果如图4.8所示。
图4.8网格布局管理器案例运行结果图
android:layout_gravity="fill"和android:layout_columnWeight="1"能让按钮平均分配所占列宽。
4.2项目实战： 综合运用常用布局实现eShop首页界面效果〖*2〗4.2.1项目分析本小节要实现项目中首页的界面开发，在完成界面开发时，首先确定界面所需的布局，因此结合本章所学知识，确定界面所用的布局和布局间的嵌套关系。先看首页的组成，首页界面涉及多个布局管理器的应用，最外层是LinearLayout布局管理器以垂直的方式布局，内层首先嵌套一个FrameLayout布局管理器，此布局管理器的使用是为了实现将来在程序中添加广告的展示，当前只留出位置，内容在后续章节添加。中间以GridLayout布局管理器和LinearLayout布局管理器两种布局管理器来布局，实现显示各类功能的显示。左面表示表格布局中的第一行的布局，右面是第二行的布局，两部分的组成是相同的。接下来是第三部分，将来是热门店铺的推荐、热门商品的推荐等，这个板块也主要是应用线性布局管理器来实现的，应用到的其他控件将在后续章节介绍，这里不再赘述。
4.2.2项目实现
那么接下来就通过程序代码来学习这部分的具体实现。页面布局文件fragment_home.xml的代码如下。<?xml version="1.0" encoding="utf-8"?>
<ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@+id/scrollView1"
android:layout_width="match_parent"
android:layout_height="match_parent">

<LinearLayout
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical">

<FrameLayout
android:id="@+id/framelayout"
android:layout_width="match_parent"
android:layout_height="150dp"
android:background="#00ff00">

<TextView
android:id="@+id/textView1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_gravity="center"
android:text="广告位"
android:textSize="36sp" />

<LinearLayout
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_gravity="bottom"
android:background="#88252525"
android:gravity="center"
android:padding="3dp">

<TextView
android:id="@+id/textView2"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="．．．"
android:textColor="#ff0000"
android:textSize="24sp" />
</LinearLayout>
</FrameLayout>

<GridLayout
android:layout_width="match_parent"
android:layout_height="match_parent"
android:layout_weight="1"
android:background="#fafafa"
android:columnCount="4"
android:rowCount="2">

<LinearLayout
android:id="@+id/ll_module1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_columnWeight="1"
android:layout_rowWeight="1"
android:orientation="vertical">

<ImageView
android:layout_width=" wrap_content "
android:layout_height="50dp"
android:layout_gravity="center"
android:padding="5dp"
android:src="@drawable/img_home1" />

<TextView
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:gravity="center_horizontal"
android:text="店铺"
android:textColor="#929292"
android:textSize="13sp" />
</LinearLayout>

<LinearLayout
android:id="@+id/ll_module2"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_columnWeight="1"
android:layout_rowWeight="1"
android:orientation="vertical">

<ImageView
android:layout_width=" wrap_content "
android:layout_height="50dp"
android:layout_gravity="center"
android:padding="5dp"
android:src="@drawable/img_home2" />

<TextView
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:gravity="center_horizontal"
android:text="雀巢"
android:textColor="#929292"
android:textSize="13sp" />
</LinearLayout>

<LinearLayout
android:id="@+id/ll_module3"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_columnWeight="1"
android:layout_rowWeight="1"
android:orientation="vertical">

<ImageView
android:layout_width=" wrap_content p"
android:layout_height="50dp"
android:layout_gravity="center"
android:padding="5dp"
android:src="@drawable/img_home3" />

<TextView
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:gravity="center_horizontal"
android:text="摩卡"
android:textColor="#929292"
android:textSize="13sp" />
</LinearLayout>

<LinearLayout
android:id="@+id/ll_module4"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_columnWeight="1"
android:layout_rowWeight="1"
android:orientation="vertical">

<ImageView
android:layout_width=" wrap_content p"
android:layout_height="50dp"
android:layout_gravity="center"
android:padding="5dp"
android:src="@drawable/img_home4" />

<TextView
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:gravity="center_horizontal"
android:text="星巴克"
android:textColor="#929292"
android:textSize="13sp" />
</LinearLayout>


<LinearLayout
android:id="@+id/ll_module5"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_columnWeight="1"
android:layout_rowWeight="1"
android:orientation="vertical">

<ImageView
android:layout_width=" wrap_content p"
android:layout_height="50dp"
android:layout_gravity="center"
android:padding="5dp"
android:src="@drawable/img_home5" />

<TextView
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:gravity="center_horizontal"
android:text="优惠券"
android:textColor="#929292"
android:textSize="13sp" />
</LinearLayout>

<LinearLayout
android:id="@+id/ll_module6"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_columnWeight="1"
android:layout_rowWeight="1"
android:orientation="vertical">

<ImageView
android:layout_width=" wrap_content "
android:layout_height="50dp"
android:layout_gravity="center"
android:padding="5dp"
android:src="@drawable/img_home6" />

<TextView
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:gravity="center_horizontal"
android:text="我的关注"
android:textColor="#929292"
android:textSize="13sp" />
</LinearLayout>

<LinearLayout
android:id="@+id/ll_module7"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_columnWeight="1"
android:layout_rowWeight="1"
android:orientation="vertical">

<ImageView
android:layout_width=" wrap_content "
android:layout_height="50dp"
android:layout_gravity="center"
android:padding="5dp"
android:src="@drawable/img_home7" />

<TextView
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:gravity="center_horizontal"
android:text="摇大奖"
android:textColor="#929292"
android:textSize="13sp" />
</LinearLayout>

<LinearLayout
android:id="@+id/ll_module8"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_columnWeight="1"
android:layout_rowWeight="1"
android:orientation="vertical">

<ImageView
android:layout_width=" wrap_content "
android:layout_height="50dp"
android:layout_gravity="center"
android:padding="5dp"
android:src="@drawable/img_home8" />

<TextView
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:gravity="center_horizontal"
android:text="物流查询"
android:textColor="#929292"
android:textSize="13sp" />
</LinearLayout>

</GridLayout>

<View
android:layout_width="match_parent"
android:layout_height="4dp"
android:background="#ff0000" />

<LinearLayout
android:id="@+id/recommand"
android:layout_width="match_parent"
android:layout_height="150dp"
android:orientation="vertical"
android:scrollbars="none">

<TextView
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:gravity="center_horizontal"
android:text="推荐商品"
android:textColor="#929292"
android:textSize="15sp" />

<GridView
android:id="@+id/grid"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:numColumns="2" />"
</LinearLayout>

<View
android:layout_width="match_parent"
android:layout_height="4dp"
android:background="#ff0000" />

<LinearLayout
android:id="@+id/discount"
android:layout_width="match_parent"
android:layout_height="150dp"
android:background="#6666ff"
android:orientation="vertical">

<TextView
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:gravity="center_horizontal"
android:text="打折商品"
android:textColor="#929292"
android:textSize="13sp" />
</LinearLayout>

<View
android:layout_width="match_parent"
android:layout_height="4dp"
android:background="#ff0000" />
<LinearLayout
android:layout_width="match_parent"
android:layout_height="150dp"
android:background="#ff6666"
android:orientation="vertical"
android:scrollbars="none">

<TextView
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:gravity="center_horizontal"
android:text="热销商品"
android:textColor="#929292"
android:textSize="13sp" />
</LinearLayout>
</LinearLayout>
</ScrollView>
4.2.3项目说明
本项目的首页涵盖内容较多，布局复杂，因此在首页的设计中用到了多种布局，首先把首页分成上中下三块，再以此进行每块的设计和布局，最终实现了总体效果。运行Activity文件显示的界面效果图如图4.9所示。
图4.9首页运行结果
4.3常用基本控件〖*2〗4.3.1文本类控件〖*2〗1. TextView在Android中使用TextView表示文本框，用于在屏幕上显示文本，主要显示不可编辑的文本，这与Java中的文本框控件不同，它相当于Java中的标签，TextView可以自动识别并链接如Email地址、Web地址、电话号码等特殊字符，它包含的主要属性如表4.2所示。表4.2TextView常用属性说明
属性说明android:text设置TextView显示的文本内容android:textColor设置文本颜色android:textSize设置文本字体的大小，支持度量单位： px(像素)/dp/sp/in/mmandroid:textStyle设置文本字体的风格，取值一般为bold、italic等android:height设置文本区域的高度，支持度量单位： px(像素)/dp/sp/in/mmandroid:layout_ height设置文本相对父类的长度的值，取值一般为match_parent,wrap_contentandroid:width设置文本区域的宽度，支持度量单位： px(像素)/dp/sp/in/mm，如果是android:layout_width="match_parent"，那么设置 android:width 是没有意义的android:layout_width设置文本相对父类的宽度的值，取值一般为match_parent,wrap_contentandroid:layout_gravity设置该控件相对于父view 的位置android:numeric如果被设置，该TextView有一个数字输入法。有如下值设置： integer正整数、signed带符号整数、decimal带小数点浮点数android:password以小点“.”显示文本android:phoneNumber设置为电话号码的输入方式android:singleLine设置单行显示。如果和layout_width一起使用，当文本不能全部显示时，后面用“…”表示。如果不设置singleLine或者设置为false，文本将自动换行【例4.8】本案例介绍了TextView控件的各种显示效果，包括文字居中、文字跑马灯效果、设置文字阴影效果、设置文字阴影效果、设置网址超链接效果、设置文字超链接效果、设置电话超链接效果、设置字形、设置文字缩放、设置行间距、设置行间距的倍数等内容，具体的应用请看下面的例子，主要是通过TextView控件的属性来设置的，代码如下。<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical">
<!-- 文字居中 -->
<TextView
android:id="@+id/testGravity"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:background="#ff00ff00"
android:gravity="center"
android:text="居中文字"
android:textColor="#ff000000"
android:textSize="18sp" />
<!-- 文字跑马灯效果 -->
<TextView
android:id="@+id/testEllipsize"
android:layout_width="100px"
android:layout_height="wrap_content"
android:ellipsize="marquee"
android:focusable="true"
android:focusableInTouchMode="true"
android:marqueeRepeatLimit="marquee_forever"
android:singleLine="true"
android:text="跑马灯文字效果"
android:textColor="#ff000000"
android:textSize="20sp" />
<!-- 设置文字阴影效果 -->
<TextView
android:id="@+id/testShadow"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:shadowColor="#ff0000"
android:shadowRadius="3.0"
android:text="文字阴影效果"
android:textColor="#ff000000" />
<!-- 设置网址超链接效果 -->
<TextView
android:id="@+id/testAutoLink1"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:autoLink="web"
android:text="网址超链接: http://www.baidu.com"
android:textColor="#ff000000"
android:textColorLink="#ff0000ff" />
<!-- 设置字形 -->
<TextView
android:id="@+id/testTextStyle"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="斜体"
android:textColor="#ff000000"
android:textStyle="italic" />
<!-- 设置文字缩放 -->
<TextView
android:id="@+id/testTextScaleX"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="hello 0.5f"
android:textColor="#ff000000"
android:textScaleX="0.5" />

<TextView
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="hello 1.0f"
android:textColor="#ff000000"
android:textScaleX="1.0" />

<TextView
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="hello 1.5f"
android:textColor="#ff000000"
android:textScaleX="1.5" />
<TextView
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="hello 2.0f"
android:textColor="#ff000000"
android:textScaleX="2.0" />

<TextView
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="hello 2.5f"
android:textColor="#ff000000"
android:textScaleX="2.5" />
<!-- 设置行间距 -->
<TextView
android:id="@+id/testLineSpacingExtra"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:lineSpacingExtra="4px"
android:text="设置行间距设置行间距设置行间距设置行间距设置行间距设置行间距"
android:textColor="#ff000000" />
<!-- 设置行间距的倍数 -->
<TextView
android:id="@+id/testLineSpacingMultiplier"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:lineSpacingMultiplier="1.5"
android:text="设置行间距设置行间距设置行间距设置行间距设置行间距设置行间距设置行间距设置行间距"
android:textColor="#ff000000" />
<ScrollView
android:layout_width="match_parent"
android:layout_height="match_parent">

<TextView
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:lineSpacingMultiplier="1.5"
android:shadowColor="@color/colorAccent"
android:shadowRadius="8.0"
android:text="其中,小米智能手机收入人民币1138亿元,同比增长41.3%(售价在2000元及以上的智能手机收入,占智能手机总收入的31.8%);IoT与生活消费品业务继续保持高增速,贡献收入438亿元人民币,较去年同比增长86.9%;2018年小米集团互联网服务收入160亿元人民币,同比增长61.2%(广告收入达人民币101亿元,同比增长79.9%)"
android:textSize="18sp" />
</ScrollView>
</LinearLayout>
运行结果如图4.10所示。
图4.10TextView控件运行结果图
2. AutoCompleteTextView
自动文本框使用AutoCompleteTextView表示，实现用户输入一定字符后显示一个下拉菜单，供用户从中选择，当用户选择某个菜单项后，按用户所选自动填写该文本框。
在屏幕中添加自动文本框，可在XML布局文件中通过<AutoCompleteTextView>标记添加，格式为：<AutoCompleteTextView
属性列表>
</AutoCompleteTextView>
AutoCompleteTextView控件是由TextView派生的，所以它支持EditText控件提供的属性，同时，该控件还支持以下XML属性。
android:completionHint： 用于为弹出的下拉菜单指定提示标题。
android:completionThreshold： 用于指定用户至少输入几个字符才会显示提示。
android:dropDownHeight： 用于指定下拉菜单的高度。
android:dropDownWidth： 用于指定下拉菜单的宽度。
android:dropDownHorizontalOffset： 用于指定下拉菜单与文本之间的水平偏移，下拉菜单默认与文本框左对齐。
android:dropDownSelector： 下拉列表被选中的行的背景。
android:ems： 需要编辑的字符串长度。
3. MultiAutoCompleTextView
该控件可支持选择多个值（在多次输入的情况下），分别用分隔符分开，并且在每个值选中的时候再次输入值时会自动去匹配。可用在发短信、发邮件时选择联系人这种类型当中。使用时需要执行设置分隔符方法。
MultiAutoCompleteTextView的使用和AutoCompleteTextView类似，只是需要设置分隔符。
具体的使用方法为在setAdapter（）方法后添加：setTokenizer(new MultiAutoCompleteTextView.CommaTokenizer());
4. EditText
在Android中，使用EditText表示输入框，用于在屏幕上显示文本输入框，这与Java中的文本框控件功能类似。不同之处在于，Android中的编辑框控件可以输入单文本，也可以输入多行文本，还可以输入指定格式的文本，例如电话号码、密码、Email地址等内容。
在Android中可使用两种方法向屏幕中添加编辑框，通常在XML布局文件中使用<EditText>标记添加，添加格式如下：<EditText
属性列表>
</EditText>
由于EditText类是TextView的子类，所以TextView的属性适用于EditText控件，特别需要注意的是，在EditText控件中，android:inputType属性可以帮助输入法显示合适的类型。例如，要添加一个密码框，可以将android:inputType属性设置为textPassword。
通常在使用EditText控件时，还需要获取该控件输入的文本内容，可以通过编辑框控件提供的getText()方法实现。在使用该方法时，要先获取到编辑框控件，然后再调用getText()方法，例如，要获取布局文件中添加的ID属性为txt的编辑框内容，可通过如下代码实现：EditText txt=(EditText)(this.findViewById(R.id.txt));
String txtText=txt.getText().toString();
【例4.9】EditText控件、AutoCompleteTextView控件和MultiAutoCompleteTextView控件的应用。本案例介绍了三个控件的应用，使用EditText控件的输入文本功能，并实现了通过对EditText控件进行事件处理实现了对脏话的过滤功能，同时也实现了AutoCompleteTextView和MultiAutoCompleteTextView两个控件的自动完成单个和多个文本的输入功能。
其实现步骤如下。
新建一个模块，打开项目文件夹中的res\\layout目录下的activity_main.xml文件，将其中的代码替换为以下代码。<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
tools:context=".Main4Activity">
<EditText
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:hint="pleaseinput"
android:textSize="24sp"
android:textColorHint="@color/colorPrimary"
android:textColorHighlight="@color/colorPrimary"
android:id="@+id/edit"/>
<AutoCompleteTextView
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:id="@+id/auto"
android:textSize="24sp"
android:hint="auto"
android:textColorHint="@color/colorPrimary"/>
<MultiAutoCompleteTextView
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:textSize="24sp"
android:id="@+id/multi"
android:hint="multi"
android:textColorHint="@color/colorPrimary"/>
</LinearLayout>
MainActivity中的主要代码如下。package com.example.chap4_2;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.text.Editable;
import android.text.TextWatcher;
import android.widget.ArrayAdapter;
import android.widget.AutoCompleteTextView;
import android.widget.EditText;
import android.widget.MultiAutoCompleteTextView;
public class Main4Activity extends AppCompatActivity {
privateEditText editText;
private AutoCompleteTextView auto;
private MultiAutoCompleteTextView multi;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main4);
editText=findViewById(R.id.edit);
auto=findViewById(R.id.auto);
multi=findViewById(R.id.multi);
String ［］ items={"bai","baidu","baicheng","baii"};
ArrayAdapter<String> adapter=new ArrayAdapter<>(this,android.R.
layout.simple_list_item_1,items);
auto.setAdapter(adapter);
multi.setAdapter(adapter);
multi.setTokenizer(new MultiAutoCompleteTextView.CommaTokenizer());
//分隔符号是逗号
editText.addTextChangedListener(new TextWatcher() {
String ［］ filters={"NND","MMD","MM"};
String oldtext,newtext;
@Override
public void beforeTextChanged(CharSequence s, int start, int 
count, int after) {
oldtext=editText.getText().toString();
}
@Override
public void onTextChanged(CharSequence s, int start, int before, int count) {
}
@Override
public void afterTextChanged(Editable s) {
newtext=editText.getText().toString();
if(newtext.equals(oldtext)){
return;
}
for(String filter:filters){
if(newtext.indexOf(filter)!=-1){
newtext=newtext.replaceAll(filter,"");
}
}
editText.setText(newtext);//重新设置文本框内容
 editText.invalidate();//刷新页面
editText.setSelection(newtext.length());
//把光标置于文本框末尾
}
});
}
}
运行效果如图4.11所示。
在图4.11中，在AutoCompleteTextView控件中输入文本“Be”，程序会自动弹出提示两个可选项，可以选择其中一个输入，运行结果如图4.12所示。
图4.11TextView控件运行结果
图4.12输入“Be”后弹出可选项



在MultiAutoCompleteTextView控件中输入文本“Be”，程序也会自动弹出提示两个可选项，可以选择其中一个输入，也可以选择多个，自动用“，”分隔，运行结果如图4.13所示。
EditText控件具备文本输入的功能，在本案例中设置了对脏话的过滤功能，当从键盘输入“NND”时，屏幕自动显示“**”，把脏话隐藏了。具体显示结果如图4.14所示。
图4.13TextView控件运行结果
图4.14EditTex控件运行结果



4.3.2按钮类控件〖*2〗1. RadioButtonRadioButton表示单选按钮，是Button的子类，所以单选按钮继承了Button的各种属性，可以直接使用。默认情况下，单选按钮显示为一个圆形图标，并且在该图标旁边放置一些说明性文字，而在程序中，一般将多个单选按钮放置在按钮组中，使这些单选按钮能够实现互斥，当用户选中某个单选按钮后，按钮组中的其他按钮将自动取消选中状态。
RadioGroup是单选组合框，用于将RadioButton框起来；在没有RadioGroup的情况下，RadioButton可以全部都选中；当多个RadioButton被RadioGroup包含的情况下，RadioButton只可以选择一个。
RadioGroup常用方法如表4.3所示。表4.3RadioGroup常用的方法
方法功 能 描 述addView(View child, int index,ViewGroup.LayoutParams params)使用指定的布局参数添加一个子视图check(int id) 单选按钮组的勾选状态clearCheck() 清除当前的选择状态，当选择状态被清除，则单选按钮组里面的所有单选按钮将取消勾选状态，getCheckedRadioButtonId()将返回nullgetCheckedRadioButtonId() 返回该单选按钮组中所选择的单选按钮的标识ID，如果没有勾选则返回-1setOnCheckedChangeListener(RadioGroup.OnCheckedChangeListener listener)注册一个当该单选按钮组中的单选按钮勾选状态发生改变时所要调用的回调函数由于RadioButton是继承自TextView，所以TextView具有的属性，都可以继承。RadioGroup常用的属性如表4.4所示。表4.4RadioGroup常用的属性
属性描述android:checkedButton单选按钮组内默认被选中的单选按钮的idandroid:background可拉伸作为背景android:contentDescription定义文本简要描述了视图内容android:id对此视图提供一个标识符名称android:onClick在本视图的上下文视图被单击时调用方法的名称android:visibility控制视图的初始可视性2. SeekBar拖动条
SeekBar（拖动条）是ProgressBar的扩展，与水平形式的显示进度条类似，不过其最大的区别在于，拖动条可以由用户自己进行手工调节，例如,当用户需要调整播放器音量或者电影的播放速度时都会用到拖动条SeekBar类。用户可以拖动滑块并向左或向右拖动，或者可以使用方向键设置当前的进度等级。使用过程中不建议把可以获取焦点的widget放在SeekBar的左边或右边。
SeekBar类的层次关系如下。java.lang.Object
android.view.View
android.widget.ProgressBar
android.widget.AbsSeekBar
android.widget.SeekBar
【例4.10】按钮类的应用。
本案综合运用按钮，使用实现了CheckBox的多选和RadioButton的单选功能，对按钮做了事件处理，获取并输出了CheckBox和RadioButton的选中信息，设置switch控件的事件处理，监听WiFi是否打开状态，监听SeekBar滑动事件，可通过滑动SeekBar来改变字号大小。具体的应用请看下面的例子。
布局文件内容如下。<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical" >
<TextView 
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="请选择您所在的城市: "/>
<RadioGroup 
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:orientation="horizontal"
android:id="@+id/radioContainer">
<RadioButton 
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:checked="true"
android:id="@+id/radio1"
android:text="北京"/>
<RadioButton 
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:id="@+id/radio2"
android:text="上海"/>
<RadioButton 
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:id="@+id/radio3"
android:text="大连"/>
</RadioGroup>
<TextView 
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="请选择您到过的城市: "/>
<LinearLayout 
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:orientation="horizontal"
android:id="@+id/checkContainer">
<CheckBox 
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="北京"/>
<CheckBox 
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="上海"/>
<CheckBox 
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="大连"/>
</LinearLayout>
<Button 
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="获取选中"
android:onClick="btnDisplaySelected"/>
<ProgressBar
android:id="@+id/progressBar"
style="?android:attr/progressBarStyleHorizontal"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:progress="50"
android:secondaryProgress="10"
/>
<TextView
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="请改变我的字号"
android:id="@+id/text"/>
<SeekBar
android:id="@+id/seekBar"
android:layout_width="match_parent"
android:layout_height="wrap_content"
/>
<Switch
android:id="@+id/wifi"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:textOff="turn off"
android:textOn="turn on"
android:showText="true"
/>
<RatingBar
android:id="@+id/ratingBar"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:numStars="5"
android:rating="3.5"/>
</LinearLayout>
MainActivity.java 中的主要代码如下。package com.example.chap4_2;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;
import android.widget.CheckBox;
import android.widget.CompoundButton;
import android.widget.LinearLayout;
import android.widget.RadioButton;
import android.widget.RadioGroup;
import android.widget.SeekBar;
import android.widget.Switch;
import android.widget.TextView;
import android.widget.Toast;
public class ButtonDemoActivity extends AppCompatActivity {
private RadioGroup radioContainer;
private LinearLayout checkContainer;
private Switch wifi;
private SeekBar seekBar;
private TextView txtResult;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_button_demo);
radioContainer=(findViewById(R.id.radioContainer));
checkContainer=(findViewById(R.id.checkContainer));
wifi=findViewById(R.id.wifi);
seekBar=findViewById(R.id.seekBar);
txtResult=findViewById(R.id.text);
seekBar.setOnSeekBarChangeListener(new 
SeekBar.OnSeekBarChangeListener() {
@Override
public void onProgressChanged(SeekBar seekBar, int progress, 
boolean fromUser) {
txtResult.setTextSize(progress);
}
@Override
public void onStartTrackingTouch(SeekBar seekBar) {
}
@Override
public void onStopTrackingTouch(SeekBar seekBar) {
}
});
wifi.setOnCheckedChangeListener(new CompoundButton.
OnCheckedChangeListener() {
@Override
public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
if(isChecked) {
Toast.makeText(ButtonDemoActivity.this, "wifi opened", Toast.LENGTH_LONG).show();
} else {
Toast.makeText(ButtonDemoActivity.this, "wifi closed", Toast.LENGTH_LONG).show();
}
}

});

}
public void btnDisplaySelected(View view){
String radioText="";
for(int i=0;i<radioContainer.getChildCount();i++)
{
View c=radioContainer.getChildAt(i);
if(c instanceof RadioButton){
RadioButton radio=(RadioButton)c;
if(radio.isChecked()){
radioText=radio.getText().toString();
break;
}
}
}

String checkText="";
for(int i=0;i<checkContainer.getChildCount();i++){
View c=checkContainer.getChildAt(i);

if(c instanceof CheckBox){
CheckBox check=(CheckBox)c;
if(check.isChecked()){
checkText+=check.getText().toString()+";";
}
}
}

Log.i("Check", "Check Selected is "+checkText);
Toast.makeText(this,"所在城市"+radioText+" 去过城市"+checkText,Toast.LENGTH_LONG).show();
}
}
布局结构如图4.15所示。
运行结果如图4.16所示，当单击“获取选中”按钮时，调用程序中的事件处理方法，在窗口弹出对话框中显示选中的单选按钮和复选框的值。
4.3.3DatePicker
DatePicker继承自FrameLayout类，日期选择控件的主要功能是向用户提供包含年、月、日的日期数据并允许用户对其修改。如果要捕获用户修改日期选择控件中的数据事件，需要为DatePicker添加OnDateChangedListener监听器。
【例4.11】DatePicker控件的应用
本案例介绍了DatePicker控件的应用，首先在界面上显示系统当前日期，单击选择日期按钮，弹出日期选择控件，选择好日期后，把选中的日期显示到文本控件上。选择日期时会触发DatePicke控件的OnDateSetListener事件。
图4.15Button等控件案例布局结构
图4.16Button等控件案例运行结果



布局文件设计如下。
XML文件中的主要代码如下。<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:background="#FFFFFFFF"
android:orientation="vertical">

<TextView
android:id="@+id/showDate"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_weight="0"
android:textColor="#FF000000" />

<Button
android:id="@+id/setDate"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="设置日期" />
</LinearLayout>
MainActivity.java中的主要代码如下。package com.example.chap4_2;
import java.util.Calendar;
import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.widget.DatePicker;
import android.widget.DatePicker.OnDateChangedListener;
import android.widget.LinearLayout;
import android.widget.TextView;
public class DatePickerActivity extends Activity {
private TextView txtDate;
static int year, month, day;
private LinearLayout linear;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_date_picker);
txtDate=this.findViewById(R.id.txtDate);
linear=this.findViewById(R.id.linear);
//初始化Calendar日历对象。
Calendar c=Calendar.getInstance();
year=c.get(Calendar.YEAR);
month=c.get(Calendar.MONTH)+1;//获取Calendar对象中的月,0表示1月,1表示2月....
day=c.get(Calendar.DATE);
txtDate.setText(year+"--"+month+"--"+day);
txtDate.setTextSize(24);
}
public void set(View v) {
final DatePicker datePicker=new DatePicker(this);
linear.addView(datePicker);

datePicker.init(year, month, day, new OnDateChangedListener() {
//view:该事件关联的组件, myyear: 当前选择的年, monthOfYear:当前选
//择的月,dayOfMonth: 当前选择的日
public void onDateChanged(DatePicker view, int year, 
int monthOfYear, int dayOfMonth) {
//修改year,month,day变量值,以便在依次单击按钮时DatePickerDialog
//上显示上一次修改后的值

 DatePickerActivity.year=year;
DatePickerActivity.month=monthOfYear;
DatePickerActivity.day=dayOfMonth;
//在DatePickerDialog组件上设置日期后,同时修改TextView上的信息
txtDate.setText(year+"--"+(month+1)+"--"+day);
datePicker.setVisibility(View.GONE);
}
});
}
}
由上面的布局可以看出，该界面默认情况下并没有DatePicker控制，该控件是在程序运行中添加进来的。
运行结果如图4.17所示。
单击“设置日期”按钮，出现如下控件的显示界面，就可以进行日期的设置了。具体界面如图4.18所示。
图4.17DatePicker案例的运行结果 1
图4.18DatePicker案例的运行结果 2



4.4项目实战： 主页底端导航条的实现〖*2〗4.4.1项目分析项目底端导航条利用5个单选按钮实现不同页面的切换，5个单选按钮分别是“首页”“购物车”“分类”“搜索”“我的”，单击哪个按钮就会切换到哪个页面，因为目前各个页面还没有实现，所以此时使用弹出对话框显示切换到的页面索引值。底端导航条效果图如图4.19所示。
图4.19主页的底端导航条效果
4.4.2项目实现
图4.19界面的下方包含五个单选按钮处于屏幕底端，其余空间全部分配给页面，可使用线性布局实现上面的效果。布局文件的代码如下。<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
tools:context=".MainActivity">
<TextView
android:layout_width="match_parent"
android:layout_height="0dp"
android:layout_weight="1"
android:textSize="24sp"
android:text="我是剩余空间,可在此处设计界面效果"
android:background="#ff0000" />
<!--设置单选按钮透明效果android:button="@null"-->
<!--设置单选按钮图片在字的上方android:drawableTop="@drawable/icon_home_nor"-->
<RadioGroup
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:id="@+id/radioGroup"
android:orientation="horizontal">
<RadioButton
android:layout_width="0dp"
android:layout_height="wrap_content"
android:layout_weight="1"
android:id="@+id/radio_home"
android:button="@null"
android:drawableTop="@drawable/icon_home_nor"
android:text="首页"
android:gravity="center"
/>
<RadioButton
android:layout_width="0dp"
android:layout_height="wrap_content"
android:layout_weight="1"
android:id="@+id/radio_shopcar"
android:button="@null"
android:drawableTop="@drawable/icon_car_nor"
android:text="购物车"
android:gravity="center"/>
<RadioButton
android:layout_width="0dp"
android:layout_height="wrap_content"
android:layout_weight="1"
android:id="@+id/radio_sort"
android:button="@null"
android:drawableTop="@drawable/icon_type_nor"
android:text="分类"
android:gravity="center" />
<RadioButton
android:layout_width="0dp"
android:layout_height="wrap_content"
android:layout_weight="1"
android:id="@+id/radio_search"
android:button="@null"
android:drawableTop="@drawable/icon_search_nor"
android:text="搜索"
android:gravity="center"/>
<RadioButton
android:layout_width="0dp"
android:layout_height="wrap_content"
android:layout_weight="1"
android:id="@+id/radio_me"
android:button="@null"
android:drawableTop="@drawable/icon_me_nor"
android:text="我的"
android:gravity="center" />
</RadioGroup>
</LinearLayout>
布局结构如图4.20所示。
图4.20主页的布局结构
4.4.3项目说明
本功能的实现需要监听单选按钮选中状态发生变化的事件，选中某个按钮，会把选中按钮的索引显示出来，如图4.21所示，若用户选择了购物车，则弹出的索引值为1。
图4.21eShop首页单选按钮运行结果
4.5常用高级控件〖*2〗4.5.1ListView列表组件ListView控件用于以列表形式显示数据，采用MVC模式将前端显示与后端数据进行分离。ListView相当于MVC中的View(视图)，为ListView提供数据的List，数据或数据库相当于MVC中的Model(模型)，而在需要添加数据的时候，则需要指定一个Adapter对象，Adapter则相当于MVC中的Controller(控制器)。
ListView类的层次关系如下。
java.lang.Object
android.view.View
android.view.ViewGroup
android.widget.AdapterView<T extends android.widget.Adapter>
android.widget.AbsListView
android.widget.ListView
ListView常用方法如表4.5所示。表4.5ListView常用的方法
方法功 能 描 述getAdapter()获取ListView的Adapter onFocusChanged(boolean gainFocus,int direction,Rect previouslyFocusedRect)获取view中焦点的变化setAdapter(ListAdapter adapter)绑定Adapter到ListView上1. ListView与Array Adapter
【例4.12】显示简单的ListView列表。
下面使用自定义布局建立图4.22所示的单行自定义ListView加载已经写好的数组内容。
图4.22单行自定义ListView
首先创建ListView并引用layout，layout里含有ListView想要展示的内容，控件的代码如下。<ListView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:id="@+id/myListView"
android:layout_alignParentLeft="true"
android:layout_alignParentStart="true"/>
在Java文件中对该ListView加载具体内容，需显示的内容为下面定义的城市数组cities，并且通过Adapter将cities与ListView绑定，其代码如下。//1. 通过findViewById方法获取ListView对象
myListView=(ListView) findViewById(R.id.myListView);
//2. 定义一个数组,显示具体内容
String［］ cities={"加格达奇","鄂尔多斯","呼伦贝尔"};
//3. 写一个adapter不写具体内容,内容从之前定义好的资源文件里引用过来
ArrayAdapter<String> adapter=new ArrayAdapter<String>(this,
R.layout.support_simple_spinner_dropdown_item,cities);
//4. 创建Adapter对象设置Adapter
myListView.setAdapter(adapter);
这里需要介绍一下R.layout.support_simple_spinner_dropdown_item布局，该布局是显示ListView所默认的布局，也可以对该布局的显示方式进行调整，使用自定义布局对城市信息进行显示。上述代码中只能选择一个条目，可以使用setChoiceMode实现对多条列表项的选择，使用语句如下：listView.setChoiceMode(listView.CHOICE_MODE_MULTIPLE);
2. ListView与SimpleAdapter
利用适配器SimpleAdapter匹配List数据，一般都是HashMap结构的List，List的每一节对应ListView的每一行。HashMap的每个键值数据映射到布局文件中对应id的组件上。
SimpleAdapter构造方法如下。public SimpleAdapter(Context context,List<? extends Map<String,?>> data, int resource, String［］ from,int［］ to)
第一个参数context： 表示访问整个Android应用程序接口，基本上所有的组件都需要。
第二个参数data： 一个由Map(String，Object)列表选项构成的List。每一个Map对应列表中的一行，而且每一个Map中应该包含所有在from参数中指定的键。
第三个参数resource： 一个定义列表项的布局文件的资源ID。该布局文件中至少包含那些在to参数中定义了的空间ID。
第四个参数from： 一个被添加到Map映射的键名。
第五个参数to： 绑定数据的视图空间的ID，与from参数的值一一对应。
创建一个案例，显示朋友的用户名列表，列表具有头像和姓名属性，通过姓名查找朋友，然后进行数据的删除。
【例4.13】ListView使用SimpleAdapter显示图文排列。
例4.12实现的是ListView简单文本显示效果，下面将例4.12的Java代码进行修改，实现ListView图文显示效果。首先在主布局文件activity_main.xml中定义ListView。<ListView
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:divider="#5be60a"
android:dividerHeight="10sp"
android:listSelector="#f27611"
android:id="@+id/listView1"
></ListView>
为了使List显示图文效果，使用了一个自定义的布局文件activity_main2.xml，这个布局的主要作用是定义List需要显示的图文，关键代码如下。<ImageView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:src="@mipmap/ic_launcher"
/>
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:textSize="30sp"
android:text="Hello world"
android:id="@+id/textView_icon"/>
在Activity中，首先获取ListView：setContentView(R.layout.activity_main);
listView1=(ListView) findViewById(R.id.listView1);
接下来定义一个list，并在list里添加具体内容，在SimpleAdapter中使用该list中的内容，关键代码如下。//准备数据,每一个HashMap就是一条记录
HashMap<String, String> title1=new HashMap<>();
title1. put("title","这是第1行HashMap");
HashMap<String, String> title2=new HashMap<>();
title2. put("title","文字可以随意填写");
HashMap<String, String> title3=new HashMap<>();
title3. put("title","通过HashMap加入到list列表中");
//建立List列表
List<Map<String,String>> list=new ArrayList<>();
//将HashMap添加到list中
list.add(title1);
list.add(title2);
list.add(title3);
//1. 上下文 2. List列表,内部是map集合 3. 填充到布局 4. 数据 5. 控件
SimpleAdapter sa=new SimpleAdapter(this, list,R.layout.activity_main2, new String［］ {"title"},new int［］{R.id.textView_icon});
listView1.setAdapter(sa);
其显示效果如图4.23所示。
图4.23显示图文排列
【例4.14】商品列表页实现。
下面使用ListView控件实现更加复杂的商品列表页，为实现该功能主要步骤如下。
（1） 首先创建并加载布局资源activity_main，在该布局中只定义了一个ListView控件，设置了单击时颜色属性listSelector。<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:id="@+id/activity_main3"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingBottom="@dimen/activity_vertical_margin"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
android:orientation="vertical"
tools:context="cn.edu.neusoft.spinner.Main3Activity">
<ListView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:divider="@color/colorPrimary"
android:dividerHeight="1sp"
android:listSelector="#ffe100"
android:id="@+id/listView1"
>
</ListView>
</LinearLayout>
（2） 创建布局参数，设置ListView中每一个条目的显示样式，该布局文件名字定义为list_main。<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:id="@+id/activity_main"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingBottom="@dimen/activity_vertical_margin"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
android:orientation="horizontal"
tools:context="cn.edu.neusoft.spinner.MainActivity">
<ImageView
android:layout_width="80sp"
android:layout_height="80sp"
android:scaleType="centerInside"
android:id="@+id/img"
android:src="@mipmap/ic_launcher"/>
<LinearLayout
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginLeft="10dp"
android:orientation="vertical">
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:textSize="15sp"
android:textColor="#131111"
android:id="@+id/tv"
android:text="Hello World!" />
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:id="@+id/price"
android:text="Hello World!" />
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:id="@+id/discount"
android:background="#ff5647"
android:textColor="#fff"
android:text="Hello World!" />
</LinearLayout>
</LinearLayout>
（3） 在Activity中获取列表项显示的数据，将需要显示的信息进行加载并显示到屏幕上，这里使用的是Map<String，Object>，并将细节信息逐一添加，最后设置列表项的单击事件。public class Main3Activity extends AppCompatActivity {
private ListView listView1;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main3);
listView1=(ListView) findViewById(R.id.listView1);
HashMap<String,Object> title1=new HashMap<>();
title1.put("img", R.drawable.img1);
title1.put("title", "荣耀 畅玩6X 4GB 32GB 全网通4G手机 ");
title1.put("price", "￥1299.00");
title1.put("discount", "9折");
HashMap<String,Object> title2=new HashMap<>();
title2.put("img", R.drawable.img2);
title2.put("title", "小米 红米 4A 全网通 2GB内存 16GB ROM 香槟金色");
title2.put("price", "￥599.00");
title2.put("discount", "8.5折");
HashMap<String,Object> title3=new HashMap<>();
title3.put("img", R.drawable.img3);
title3.put("title", "诺基亚6 (Nokia6) 4GB+64GB 黑色 全网通");
title3.put("price", "￥1699.00");
title3.put("discount", "9折");
HashMap<String,Object> title4=new HashMap<>();
title4.put("img", R.drawable.img4);
title4.put("title", "OPPO A57 3GB+32GB内存版 ");
title4.put("price", "￥1599.00");
title4.put("discount", "9折");
final List<HashMap<String,Object>> list=new ArrayList<>();
list.add(title1);
list.add(title2);
list.add(title3);
list.add(title4);
SimpleAdapter sa=new SimpleAdapter(this,list,R.layout.list_main,new String［］{"img","title","price","discount"},
new int［］{R.id.img,R.id.tv, R.id.price,R.id.discount});
listView1.setAdapter(sa);
listView1.setOnItemClickListener(new AdapterView.OnItemClickListener() {
@Override
public void onItemClick(AdapterView<?> adapterView, View view, 
int i, long l) {
Toast.makeText(Main3Activity.this,"您单击的是"+list.get(i).
get("title").toString(),
Toast.LENGTH_SHORT).show();
}
});
}
}
在模拟器中单击ListView的列表项时，会弹出对应的title文字，该商品列表页的实现如图4.24所示。
【例4.15】实现图4.25所示的书籍评分界面。主要通过ListView控件实现书籍名称、作者、价格、评分等界面显示效果。
其中,布局文件使用线性布局，排列方式为horizontal，并且该布局中使用ImageView控件作为图书背景图片。在这个布局基础上需要嵌套新的线性布局，新布局以vertical方式排列，这样就可以在原来布局的基础上纵向排列新的控件。另外，为了实现评分效果，该页面也采用了RatingBar控件。
图4.24商品列表页的实现
图4.25书籍评分界面



其XML代码如下。<?xmlversion="1.0"encoding="utf-8"?>
<LinearLayoutxmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:orientation="horizontal">
<ImageView
android:id="@+id/img"
android:layout_width="60px"
android:layout_height="90px"
android:layout_marginTop="0px"
/>
<LinearLayout
android:layout_width="140px"
android:layout_height="90px"
android:orientation="vertical"
android:baselineAligned="@id/img"
android:layout_marginLeft="10px">
<TextView
android:id="@+id/bookTitle"
android:layout_width="wrap_content"
android:textSize="8sp"
android:layout_height="wrap_content"
/>
<TextView
android:id="@+id/bookAuthor"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:textSize="8sp"
/>
<TextView
android:id="@+id/bookPrice"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:textSize="8sp"
android:textColor="#f00"
/>
<RatingBar
android:id="@+id/ratingBar1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:textSize="24sp"
style="?android:attr/ratingBarStyleSmall"/>"
</LinearLayout>
</LinearLayout>
Activity及执行结果代码如下。public class MainActivity extends Activity{
private ListView listView;
private ArrayList<HashMap<String, Object>>bookSource;
publicvoid getSource(intimgId,String bookName,String bookAuthor,intbookPrice){
HashMap<String, Object>map=new HashMap<String, Object>();
map.put("img",imgId);
map.put("bookName",bookName);
map.put("bookAuthor",bookAuthor);
map.put("bookPrice",bookPrice);
bookSource.add(map);
}
@Override
protectedvoid onCreate(Bundle savedInstanceState){
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
listView=(ListView)this.findViewById(R.id.listView1);
bookSource=new ArrayList<HashMap<String, Object>>();
getSource(R.drawable.img1,"疯狂android讲义","李刚",74);
getSource(R.drawable.img2,"深入理解android","邓凡平",54);
getSource(R.drawable.img3,"android内核剖析","柯元",64);
getSource(R.drawable.img4,"android高级编程","李五",44);
getSource(R.drawable.img5,"android开发入门与实战","李无",55);
getSource(R.drawable.img6,"android开发入门与实战第二版","王艺",88);
getSource(R.drawable.img7,"android 4 高级编程","李我",66);
getSource(R.drawable.img9,"android开发高清在线视频","李兴化",99);
SimpleAdapter adapter=new MyAdapter
(this,bookSource,R.layout.list_item_custom,
new String［］{"img","bookName","bookAuthor","bookPrice"},
newint［］{R.id.img,R.id.bookTitle,R.id.bookAuthor,R.id.bookPrice});
listView.setAdapter(adapter);
}
class MyAdapter extends SimpleAdapter {
public MyAdapter(Contextcontext, List<? extends Map<String, ?>> data,
intresource, String［］ from, int［］ to) {
super(context, data, resource, from, to);
//TODO Auto-generated constructor stub
}
@Override
public View getView(intposition, View convertView, ViewGroup parent) {
//TODO Auto-generated method stub
View view=super.getView(position, convertView, parent);
TextView txt=(TextView) view.findViewById(R.id.bookTitle);
if(position % 2==0) {
view.setBackgroundColor(Color.GRAY);
txt.setTextColor(Color.RED);
} else {
view.setBackgroundColor(Color.WHITE);
txt.setTextColor(Color.GREEN);
}
returnview;
}
}
}
（4） ListView与BaseAdapter
例4.15中使用SimpleAdapter实现了ListView控件中图文排列的效果，但是对于一些特殊的控件（比如Button）来说，单击ListView控件会产生一些混乱。当开发者在ListView的条目中引用一个Button控件，用户单击该控件时就会造成混乱，程序可能无法识别用户需要单击ListView的条目还是Button控件，此时为了避免这种情况发生，需要使用BaseAdapter来替代SimpleAdapter。
BaseAdapter是各种Adapter的父类，它支持自定义的数据绑定与显示，使用BaseAdapter时需要重写以下几个方法。
 getCount()
 getItem(int position)
 getItemId(int position)
  getView(int position，View convertView，ViewGroup parent)
【例4.16】使用BaseAdapter实现书籍评分案例。
下面对例4.15的知识进行扩展，通过使用BaseAdapter实现书籍显示案例，首先在主布局文件中添加一个ListView，将该ListView命名为listView，代码如下。<ListView
android:layout_width="match_parent"
android:layout_height="match_parent"
android:id="@+id/listView"
android:layout_alignParentLeft="true"
android:layout_alignParentStart="true"
android:layout_alignParentTop="true">
</ListView>
同时定义ListView控件每个条目的显示样式，本例中定义了一个名为list_item的布局文件，内部定义了一个ImageView控件和一个TextView控件。其代码如下。<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="horizontal">

<ImageView
android:id="@+id/imageView_icon"
android:layout_width="90dp"
android:layout_height="120dp" />

<TextView
android:id="@+id/textView_title"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_margin="10dp" />
</LinearLayout>
定义ImageView控件的同时，将其所需要引用的图片放置在drawable文件夹中，命名为img1到img5。此时已经将布局文件和资源文件放置在开发环境中，下面的代码使用了BaseAdapter完成书籍显示案例。public class MainActivity extends AppCompatActivity {
private ListView listView;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
listView=(ListView) findViewById(R.id.listView);
listView.setAdapter(new MyAdapter(this));
}

static class MyAdapter extends BaseAdapter {
private String［］ titles={"书籍1", "书籍2", "书籍3", "书籍4", "书籍5"};
private int［］ icons={R.drawable.img1,
R.drawable.img2, R.drawable.img3,
R.drawable.img4, R.drawable.img5,};
private Context context;

//构造方法传进来一个context,用它来实例化layoutinflatter
public MyAdapter(Context context) {
this.context=context;
}

@Override
public int getCount() {
return titles.length;
}
@Override
public Object getItem(int position) {
return titles［position］;
}
@Override
public long getItemId(int position) {
return position;
}
@Override
public View getView(int position, View convertView, ViewGroup parent) {
LayoutInflater inflater=LayoutInflater.from(context);
//实例化布局文件
View v=inflater.inflate(R.layout.list_item, null);
TextView tv_title=(TextView) v.findViewById(R.id.textView_title);
ImageView iv_icon=(ImageView) v.findViewById(R.id.imageView_icon);
tv_title.setText(titles［position］);
iv_icon.setImageResource(icons［position］);
return v;
}
}
}
上述代码中对getCount()、getItem()、getItemId()、getView()方法进行了重写，其中，在getView()方法中使用了inflater.inflate()方法引入了自定义布局list_item，从而实现了ListView条目中各个控件的使用。
【例4.17】优化ListView性能。
在程序开发中ListView控件使用十分频繁，如果能将ListView控件性能优化就会大大提高程序的可用性。当系统开始绘制ListView的时候，首先调用getCount()方法，得到它的返回值，即ListView的长度。然后系统调用getView()方法，根据这个长度逐一绘制ListView的每一行。也就是说，如果让getCount()返回1，那么只显示一行。而getItem()和getItemId()则在需要处理和取得Adapter中的数据时调用。那么getView如何使用呢？如果有10 000行数据，就绘制10 000次？这肯定会极大地消耗资源，导致ListView滑动非常的慢，那应该怎么做呢？通过下面的一个例子来讲解如何在使用BaseAdapter的时候优化ListView的显示。
ListView的列表项布局文件同SimplerAdapter中介绍的示例程序，这里不再列出。Activity的布局文件中只添加了一个ListView，所以也不再列出。getView()方法不容易理解。其实完全可以不用所谓的convertView和ViewHolder，直接导入布局并且设置控件显示的内容就可以了。但是这意味着有多少行数据就需要绘制多少行ListView，这显然是不可取的。这里采用了一种优化的方法。代码中，在getView()方法中加入了一行log输出convertView的内容。滚动ListView，输出信息如图420所示。
从图420中可以看出，当启动Activity呈现第一屏ListView的时候，convertView为零。当用户向下滚动ListView时，上面的条目变为不可见，下面出现新的条目。这时候convertView不再为空，而是创建了一系列的convertView的值。当又往下滚一屏的时候，发现原先的容器用来容纳新的内容。也就是说，convertView相当于一个缓存，开始为0，当有条目时变为不可见，它缓存了它的数据，后面再出来的条目只需要更新数据就可以了，这样大大节省了系统资源的开销。
上面的代码还可以继续优化。虽然重复利用了已经绘制的View，但是要得到其中的控件，需要在控件的容器中通过findViewById方法来获得。如果这个容器非常复杂，这显然会增加系统资源的开销。上例中引入了Tag的概念，这或许不是最好的办法，但是它确实能使ListView变得更流畅。代码中，当convertView为空时，用setTag()方法为每个View绑定一个存放控件的ViewHolder对象。当convertView不为空时，重复利用已经创建的View的时候，使用getTag()方法获取绑定的ViewHolder对象，这样就避免了findViewById对控件的层层查询，而是快速定位到控件。
下面对例4.16的知识进行扩展实现性能优化，在定义书籍标题和图片时增加10项内容，使程序运行时ListView内容布满整个屏幕。其代码修改如下。private String［］ titles={"书籍1", "书籍2", "书籍3", "书籍4", "书籍5", "书籍6", "书籍7", "书籍8", "书籍9", "书籍10", "书籍11", "书籍12", "书籍13", "书籍14", "书籍15"};
private int［］ icons={R.drawable.img1,
R.drawable.img2, R.drawable.img3,
R.drawable.img4, R.drawable.img5,
R.drawable.img1, R.drawable.img2,
R.drawable.img3, R.drawable.img4,
R.drawable.img5, R.drawable.img1,
R.drawable.img2, R.drawable.img3,
R.drawable.img4, R.drawable.img5};
程序运行时，由于ListView内容布满整个屏幕，用户向上或向下拖曳时，当一个新的条目产生时，程序会创建一个内存空间给该条目，当用户多次操作该ListView控件时，程序会持续创建内存空间，这就造成程序会占用越来越多的资源。为便于说明，在getView()方法中添加如下语句，对其进行监控。System.out.println(position+"---此时创建新的内存空间: ---"+convertView);
在模拟器中，当用户滑动ListView控件时，开发环境Logcat打印语句如下。9---此时创建新的内存空间: ---android.widget.LinearLayout{f08163 V.E...... ........ 0,-166-1136,74}
10---此时创建新的内存空间: ---android.widget.LinearLayout{afcb619 V.E...... ........ 0,56-1136,296}
11---此时创建新的内存空间: ---android.widget.LinearLayout{afcb619 V.E...... ........ 0,56-1136,296}
12---此时创建新的内存空间: ---android.widget.LinearLayout{7d202ea V.E.............. 0,-163-1136,77}
13---此时创建新的内存空间: ---android.widget.LinearLayout{ad40c78V.E.............. 0,189-1136,429}
14---此时创建新的内存空间: ---android.widget.LinearLayout{ad40c78V.E.............. 0,189-1136,429}
7---此时创建新的内存空间: ---android.widget.LinearLayout{84563b6 V.E...... ........ 0,-53-1136,187}
6--此时创建新的内存空间: --android.widget.LinearLayout{eb118b7V.E.............. 0,1582-1136,1822}
可以从上面的语句看到,程序在不断地创建内存空间，此时可以使用getView()方法中的convertView参数实现内存空间循环使用，该参数为空闲可用对象，当ListView控件条目被滑出屏幕时就会产生空闲可用对象，可以使用该参数实现内存重复使用。优化ListView的加载速度就要让convertView匹配列表类型，并最大限度地重新使用convertView。
具体代码如下。@Override
public View getView(int position, View convertView, ViewGroup parent) {
if(convertView==null) {
LayoutInflater inflater=LayoutInflater.from(context);
//实例化布局文件
convertView=inflater.inflate(R.layout.list_item, null);
}
System.out.println(position+"---此时创建新的内存空间: ---"+
convertView);
TextView tv_title=(TextView) convertView.findViewById(R.id.textView_title);
ImageView iv_icon=(ImageView) convertView.findViewById(R.id.imageView_icon);
tv_title.setText(titles［position］);
iv_icon.setImageResource(icons［position］);
return convertView;
}
上述代码的作用是当convertView不为空时直接重新使用convertView，从而减少很多不必要的View的创建。程序运行时滑动控件Logcat打印语句如下，其中，条目1使用了9的内存空间，0使用了10的内存空间。1---此时创建新的内存空间: ---android.widget.LinearLayout{877d5cf V.E...... . 0,1259-1136,1499}
0---此时创建新的内存空间: ---android.widget.LinearLayout{8b50a9 V.E...... .. 0,1501-1136,1741}
5---此时创建新的内存空间: ---android.widget.LinearLayout{33b6be1 V.E...... 0,973-1136,1213}
6---此时创建新的内存空间: ---android.widget.LinearLayout{d21e51d V.E...... 0,1215-1136,1455}
7---此时创建新的内存空间: ---android.widget.LinearLayout{ba0438cV.E...... 0,1457-1136,1697}
8---此时创建新的内存空间: ---android.widget.LinearLayout{e9f4e65 V.E...... 0,256-1136,496}
9---此时创建新的内存空间: ---android.widget.LinearLayout{877d5cf V.E...... 0,14-1136,254}
10---此时创建新的内存空间: ---android.widget.LinearLayout{8b50a9 V.E...... 0,-228-1136,12}
【例4.18】优化ListView性能2。
为优化ListView性能可以使用ViewHolder，它是一个内部类，其中包含单个项目布局中的各个控件。由于程序中会经常使用findViewById()方法查找空间，而该方法的实现需要对每个id进行匹配，这样不可避免地会造成资源上的浪费。ViewHolder用于保存第一次查找的组件，这样就可以避免下次重复查找，从而实现了节约系统资源的目的。
使用ViewHolder对例4.17的getView()方法优化如下。@Override
public View getView(int position, View convertView, ViewGroup parent) {
ViewHolder vh;
if(convertView==null) {
LayoutInflater inflater=LayoutInflater.from(context);
convertView=inflater.inflate(R.layout.list_item, null);
vh=new ViewHolder();
vh.iv_icon=(ImageView) convertView.findViewById(R.id.imageView_icon);
vh.tv_title=(TextView) convertView.findViewById(R.id.textView_title);
convertView.setTag(vh);
} else {
vh=(ViewHolder) convertView.getTag();
}
vh.tv_title.setText(titles［position］);
vh.iv_icon.setImageResource(icons［position］);
return convertView;
}

static class ViewHolder {
ImageView iv_icon;
TextView tv_title;
}
}
程序最终代码如下。public classMainActivity extends AppCompatActivity {
private ListView listView;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
listView=(ListView) findViewById(R.id.listView);
listView.setAdapter(new MyAdapter(this));
}

static class MyAdapter extends BaseAdapter {
private String［］ titles={"书籍1", "书籍2", "书籍3", "书籍4", "书籍5", "书籍6", "书籍7", "书籍8", "书籍9", "书籍10", "书籍11", "书籍12", "书籍13", "书籍14", "书籍15"};
private int［］ icons={R.drawable.img1,
R.drawable.img2, R.drawable.img3,
R.drawable.img4, R.drawable.img5,
R.drawable.img1, R.drawable.img2,
R.drawable.img3, R.drawable.img4,
R.drawable.img5, R.drawable.img1,
R.drawable.img2, R.drawable.img3,
R.drawable.img4, R.drawable.img5};
private Context context;

//构造方法传进来一个context,用它来实例化layoutinflatter
public MyAdapter(Context context) {
this.context=context;
}

@Override
public int getCount() {
return titles.length;
}

@Override
public Object getItem(int position) {
return titles［position］;
}

@Override
public long getItemId(int position) {
return position;
}

@Override
//convertView空闲可用对象
public View getView(int position, View convertView, ViewGroup parent) {
ViewHolder vh;
if(convertView==null) {
LayoutInflater inflater=LayoutInflater.from(context);
//实例化布局文件
convertView=inflater.inflate(R.layout.list_item, null);
vh=new ViewHolder();
vh.iv_icon=(ImageView) convertView.findViewById(R.id.
imageView_icon);
vh.tv_title=(TextView) convertView.findViewById(R.id.
textView_title);
convertView.setTag(vh);
}
else {
vh=(ViewHolder) convertView.getTag();
}
vh.tv_title.setText(titles［position］);
vh.iv_icon.setImageResource(icons［position］);
//tv_title.setText(titles［position］);
//iv_icon.setImageResource(icons［position］);
return convertView;

}
static class ViewHolder {
ImageView iv_icon;
TextView tv_title;
}
}
}
4.5.2RecycleView控件
从Android 5.0开始，谷歌公司推出了一个用于大量数据展示的新控件RecylerView，可以用来代替传统的ListView，更加强大和灵活。官方介绍，RecyclerView用于在有限的窗口展现大量的数据。其实早已经有了类似的控件，如ListView、GridView，那么相比它们，RecyclerView有什么优势呢？RecyclerView标准化了ViewHolder，而且异常灵活，可以轻松实现ListView实现不了的样式和功能，通过布局管理器LayoutManager可控制Item的布局方式，通过设置Item操作动画自定义Item添加和删除的动画，通过设置Item的间隔样式，自定义间隔。
RecyclerView是supportv7包中的新组件，是一个强大的滑动组件，与经典的ListView相比，同样拥有Item回收复用的功能。RecyclerView并不会完全替代ListView（这点从ListView没有被标记为@Deprecated可以看出），两者的使用场景不一样。但是RecyclerView的出现会让很多开源项目被废弃，例如，横向滚动的ListView、横向滚动的GridView、瀑布流控件，因为RecyclerView能够实现所有这些功能。RecylerView相对于ListView的优点罗列如下。
（1） RecyclerView封装了ViewHolder的回收复用，也就是说RecyclerView标准化了ViewHolder，编写Adapter面向的是ViewHolder而不再是View了，复用的逻辑被封装了，写起来更加简单。直接省去了ListView中convertView.setTag(holder)和convertView.getTag()这些烦琐的步骤。
（2） 提供了一种插拔式的体验，高度解耦，异常灵活，针对一个Item的显示RecyclerView专门抽取出了相应的类，来控制Item的显示，使其扩展性非常强。设置布局管理器以控制Item的布局方式，横向、竖向以及瀑布流方式，例如，想控制横向或者纵向滑动列表效果，可以通过LinearLayoutManager这个类来进行控制(与GridView效果对应的是GridLayoutManager，与瀑布流对应的是StaggeredGridLayoutManager等)。也就是说，RecyclerView不再拘泥于ListView的线性展示方式，它也可以实现GridView的效果等多种效果。
（3） 可设置Item的间隔样式（可绘制）。通过继承RecyclerView的ItemDecoration这个类，然后针对自己的业务需求去书写代码。
（4） 可以控制Item增删的动画，可以通过ItemAnimator这个类进行控制，当然针对增删的动画，RecyclerView有其自己默认的实现。
但是关于Item的单击和长按事件，需要用户自己去实现。
基本使用代码如下。recyclerView=(RecyclerView) findViewById(R.id.recyclerView);
LinearLayoutManager layoutManager=new LinearLayoutManager(this);
//设置布局管理器
recyclerView.setLayoutManager(layoutManager);
//设置为垂直布局,这也是默认的
layoutManager.setOrientation(OrientationHelper. VERTICAL);
//设置Adapter
recyclerView.setAdapter(recycleAdapter);
 //设置分隔线
recyclerView.addItemDecoration(new DividerGridItemDecoration(this));
//设置增加或删除条目的动画
recyclerView.setItemAnimator(new DefaultItemAnimator());
在使用RecyclerView时，必须指定一个适配器Adapter和一个布局管理器LayoutManager。适配器继承RecyclerView.Adapter类，具体实现类似ListView的适配器，取决于数据信息以及展示的UI。布局管理器用于确定RecyclerView中Item的展示方式以及决定何时复用已经不可见的Item，避免重复创建以及执行高成本的findViewById()方法。可以看见，RecyclerView相比ListView会多出许多操作，这也是RecyclerView灵活的地方，它将许多功能暴露出来，用户可以选择性地自定义属性以满足需求。
【例4.19】使用RecyclerView和CardView结合展示大量书籍数据。
（1） 首先需在build.gradle文件中引入该类。dependencies {
implementation 'com.android.support:cardview-v7:28.0.0'
implementation 'com.android.support:recyclerview-v7:28.0.0'
}
（2） 在Activity布局文件中加载RecyclerView。<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".MainActivity">
<android.support.v7.widget.RecyclerView
android:layout_width="match_parent"
android:layout_height="match_parent"
android:id="@+id/recycler_view">
</android.support.v7.widget.RecyclerView>
</LinearLayout>
（3） 创建适配器。标准实现步骤如下。
① 创建Adapter。创建一个继承RecyclerView.Adapter<VH>的Adapter类（VH是ViewHolder的类名）。
② 创建ViewHolder。在Adapter中创建一个继承RecyclerView.ViewHolder的静态内部类，记为VH。ViewHolder的实现和ListView的ViewHolder实现几乎一样。
③ 在Adapter中实现以下3个方法。
onCreateViewHolder()： 这个方法主要是为每个Item生成一个View，但是它返回的是一个ViewHolder。它把View直接封装在ViewHolder中，然后面向的是ViewHolder这个实例，当然这个ViewHolder需要自己去编写。需要注意的是，在onCreateViewHolder()中，映射Layout必须为View v=LayoutInflater.from(parent.getContext()).inflate(R.layout.item_1, parent, false);
onBindViewHolder()： 这个方法主要用于适配渲染数据到View中。方法提供了一个ViewHolder，而不是原来的ConvertView。
getItemCount()： 这个方法类似于BaseAdapter的getCount方法，即总共有多少个条目。
可以看出，RecyclerView将ListView中getView()的功能拆分成了onCreateViewHolder()和onBindViewHolder()。
BookBaseAdapter类的定义如下。package com.example.chap04_4_3;
import android.content.Context;
import android.support.v7.widget.RecyclerView;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import android.widget.TextView;
import java.util.List;
public class BookBaseAdapter extends RecyclerView.
Adapter<BookBaseAdapter.MyHolder> {
private List<Book> mBookList;
private Context mContext;
private OnItemClickListener mItemClickListener;

//定义一个设置单击监听器的方法
public void setOnItemClickListener(OnItemClickListener 
itemClickListener) {
this.mItemClickListener=itemClickListener;
}

public BookBaseAdapter(List<Book> mBookList, Context mContext) {
this.mBookList=mBookList;
this.mContext=mContext;
}

@Override
public MyHolder onCreateViewHolder(ViewGroup parent, int viewType) {
View view=LayoutInflater.from(parent.getContext()).inflate(R.
layout.book,parent,false);
MyHolder holder=new MyHolder(view);
return holder;
}

@Override
public void onBindViewHolder(final MyHolder holder, final int position) {
Book book=mBookList.get(position);

holder.bookname.setText(book.getName());
holder.bookImage.setImageResource(book.getImageId());
//如果设置了回调,则设置单击事件
if(mItemClickListener !=null){
holder.itemView.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
mItemClickListener.onItemClick(holder.itemView, 
position);
}
});
}
}
@Override
public int getItemCount() {
return mBookList.size();
}
class MyHolder extends RecyclerView.ViewHolder{
 private ImageView bookImage;
private TextView bookname;

public MyHolder (View view) {
super(view);
bookImage=view.findViewById(R.id.book_iamge);
bookname=view.findViewById(R.id.book_name);
}
}
}
其中，为RecyclerView的Item定义的布局book.xml的内容如下。<?xml version="1.0" encoding="utf-8"?>
<android.support.v7.widget.CardView
xmlns:card_view="http://schemas.android.com/apk/res-auto"
xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="200dp"
android:layout_height="match_parent"
android:layout_margin="3dp"
android:id="@+id/cv_item"
card_view:cardCornerRadius="20dp">
<TextView
android:id="@+id/book_name"
android:layout_width="100dp"
android:layout_height="100dp"
android:layout_gravity="center_vertical"
android:padding="20dp"
android:text="书名"
android:textSize="20sp" />
<ImageView
android:id="@+id/book_iamge"
android:layout_width="200dp"
android:layout_height="match_parent"
android:scaleType="matrix"/>
</android.support.v7.widget.CardView>
Book类的定义如下。package com.example.chap04_4_3;
import java.io.Serializable;
public class Book implements Serializable {
private int imageId;
private String name;
public Book(String name,int imageId) {
this.imageId=imageId;
this.name=name;
}

public int getImageId() {
return imageId;
}

public void setImageId(int imageId) {
this.imageId=imageId;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name=name;
}
}
Item的回调接口定义如下。package com.example.chap04_4_3;
import android.view.View;
public interface OnItemClickListener{
void onItemClick(View view, int Position);
}
（4） 创建完Adapter，接着设置RecyclerView，一般来说，需要为RecyclerView进行以下四大设置。
Layout Manager： Item的布局(必选)。
Adapter： 为Item提供数据(必选)。
Item Decoration： Item之间的Divider(可选，默认为空)。
Item Animator： 添加、删除Item动画(可选，默认为DefaultItemAnimator)。
如果要实现ListView的效果，只需要设置Adapter和Layout Manager，如下。List<String> data=initData();
RecyclerView rv=(RecyclerView) findViewById(R.id.rv);
rv.setLayoutManager(new LinearLayoutManager(this));
rv.setAdapter(new NormalAdapter(data));
RecyclerView能够支持各种各样的布局效果，这是ListView所不具有的功能，那么这个功能如何实现呢？其核心在于RecyclerView.LayoutManager类中。从前面的基础使用可以看到，RecyclerView在使用过程中要比ListView多一个setLayoutManager步骤，这个LayoutManager就是用于控制RecyclerView最终的展示效果的。LayoutManager负责RecyclerView的布局，其中包含ItemView的获取与回收。RecyclerView提供了以下三种布局管理器。
① LinerLayoutManager： 以垂直或者水平列表方式展示Item。
② GridLayoutManager： 以网格方式展示Item。
③ StaggeredGridLayoutManager： 以瀑布流方式展示Item。
如果想用RecyclerView来实现自定义效果，则应该去继承实现自己的LayoutManager，并重写相应的方法，而不应该想着去改写RecyclerView。
（5） 自定义间隔样式需要继承RecyclerView.ItemDecoration类，该类是一个抽象类，主要有三个方法。
① onDraw(Canvas c，RecyclerView parent，State state)，在Item绘制之前被调用，该方法主要用于绘制间隔样式。
② onDrawOver(Canvas c，RecyclerView parent，State state)，在Item绘制之前被调用，该方法主要用于绘制间隔样式。
③ getItemOffsets(Rect outRect，View view，RecyclerView parent，State state)，设置item的偏移量，偏移的部分用于填充间隔样式，在RecyclerView的onMeasure()中会调用该方法。onDraw()和onDrawOver()这两个方法都是用于绘制间隔样式，只需复写其中一个方法即可。
（6） RecyclerView能够通过mRecyclerView.setItemAnimator(ItemAnimator animator)设置添加、删除、移动、改变的动画效果。RecyclerView提供了默认的ItemAnimator实现类： DefaultItemAnimator。如果没有特殊的需求，默认使用这个动画即可。
MainActivity的代码如下。package com.example.chap04_4_3;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.support.v7.widget.DefaultItemAnimator;
import android.support.v7.widget.LinearLayoutManager;
import android.support.v7.widget.RecyclerView;
import android.support.v7.widget.StaggeredGridLayoutManager;
import android.view.View;
import android.widget.Toast;
import java.util.ArrayList;
import java.util.List;
public class MainActivity extends AppCompatActivity {
private List<Book> mlsit=new ArrayList<Book>();
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//初始化List数据
initBook();
//初始化RecyclerView
RecyclerView recyslerview=findViewById(R.id.recycler_view);
//以瀑布流方式展示Item
 StaggeredGridLayoutManager layoutmanager=new 
StaggeredGridLayoutManager(2,StaggeredGridLayoutManager.HORIZONTAL);
//设置RecyclerView 布局
layoutmanager.canScrollHorizontally();
recyslerview.setLayoutManager(layoutmanager);
//设置Adapter
BookBaseAdapter adapter=new BookBaseAdapter(mlsit, this);
adapter.setOnItemClickListener(new OnItemClickListener() {


@Override
public void onItemClick(View view, int position) {
//TODO Auto-generated method stub
Toast.makeText(MainActivity.this, "单击了: "+position, 
Toast.LENGTH_SHORT).show();
}


});
recyslerview.setAdapter(adapter);
 recyslerview.addItemDecoration(new RecyclerView.ItemDecoration() {
 });
recyslerview.setItemAnimator(new DefaultItemAnimator());
}

private void initBook() {
for (int i=0; i<30; i++) {
Book book01=new Book("Book"+i, R.drawable.img1);
mlsit.add(book01);
Book book02=new Book("Book"+(i+1), R.drawable.img2);
mlsit.add(book02);
Book book03=new Book("Book"+(i+2), R.drawable.img3);
mlsit.add(book03);

}
}
}
程序运行效果如图4.26所示。
图4.26使用RecycleView进行书籍信息显示界面
4.5.3ViewPager与ViewFlipper〖*2〗1. ViewPagerViewPager用于实现多页面的切换效果，该类存在于Android的兼容包androidsupportv4.jar中。support v4是Android官方提供的一个兼容低版本安卓设备的软件包，里面包含只有在安卓3.0以上可以使用的API。使用ViewPager与ListView类似，需要一个适配器PagerAdapter。ViewPager可以让用户左右切换当前的View。实现ViewPager导航，需要了解以下几点。
（1） ViewPager类直接继承了ViewGroup类，所以它是一个容器类，可以在其中添加其他的View类。
（2） ViewPager类需要一个PagerAdapter适配器类给它提供数据。
（3） ViewPager经常和Fragment一起使用，并且提供了专门的FragmentPagerAdapter和FragmentStatePagerAdapter类供Fragment中的ViewPager使用。
在编写ViewPager的应用时，还需要使用两个组件类，分别是PagerTitleStrip类和PagerTabStrip类。PagerTitleStrip类直接继承自ViewGroup类，而PagerTabStrip类继承自PagerTitleStrip类，所以这两个类也是容器类。但是有一点需要注意，在定义XML的Layout的时候，这两个类必须是ViewPager标签的子标签。
ViewPager类需要一个PagerAdapter适配器类给它提供数据。在ListView中也有适配器，通过重写GetView()函数来获取当前要加载的Item。由于PagerAdapter是单个View的合集，所以与ListView略有不同。PagerAdapter 必须重写的四个函数如下。
 boolean isViewFromObject(View arg0，Object arg1)
 int getCount() 
 void destroyItem(ViewGroup container，int position，Object object)
 Object instantiateItem(ViewGroup container，int position
2. ViewFlipper
ViewFlipper可以用来指定FrameLayout内多个View之间的切换效果，可以一次指定，也可以每次切换时都指定单独的效果。该类额外提供了如下几个函数。
isFlipping：  用来判断View切换是否正在进行。
setFilpInterval： 设置View之间切换的时间间隔。
startFlipping： 使用上面设置的时间间隔来开始切换所有的View，切换会循环进行。
stopFlipping: 停止View切换。
4.6项目实战： 店铺列表页的实现〖*2〗4.6.1项目分析在eShop项目中，当单击首页的店铺控件时会进入如图4.27所示的店铺列表页面。该页面包含咖啡商城里面全部店铺的基本信息，如店铺的名称、地址、联系方式，及推荐商品等，并且相邻的店铺还使用了不同的显示样式。
图4.27店铺列表实现效果
4.6.2项目实现
为了实现这个页面的显示效果，就需要用到本章所学习的ListView控件，下面完成该店铺列表页的开发。首先需要在布局文件里定义该页面的布局，所以需要在app/res/layout/文件夹下新建对应的布局文件shop_layout.xml。该页面使用的是线性布局的ListView控件。其布局文件代码如下。<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:background="#FFFFB9"
android:orientation="vertical">

<ListView
android:id="@+id/listshop"
android:layout_width="match_parent"
android:layout_height="wrap_content"></ListView>

</LinearLayout>
定义好布局文件后，需要在对应的Activity文件里对该布局进行引用并操作。其对应文件路径为app/java/neusoft.soft.coffeestore/view/shopActivity，在该文件的onCreate方法中使用setContentView对布局文件引用，其具体的代码如下。public class ShopActivity extends Activity {
 List<HashMap<String, String>> data;
 final String DB_DIR="databases";
 final String DB_NAME="coffeeshop";
 private ListView list;
 ApplicationInfo applicationInfo;
 String databasePath;
 DBUtil dbUtil;
 Shop［］ shops;

 @Override
 protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.shop_layout);
list=(ListView) findViewById(R.id.listshop);
init(this);
registerForContextMenu(list);
 }

 @Override
 protected void onRestart() {
//TODO Auto-generated method stub
super.onRestart();
showAllShops();
 }

 public void showAllShops() {
shops=dbUtil.queryAllShop();
data=new ArrayList<HashMap<String, String>>();
for (int i=0; i<shops.length; i++) {
 HashMap<String, String> map=new HashMap<String, String>();
 map.put("shop_name", shops［i］.getShop_name());
 map.put("shop_address", shops［i］.getShop_address());
 map.put("shop_tel", shops［i］.getTel());
 String picName=shops［i］.getImg_name();
 int picId=getResources().getIdentifier(picName, "drawable", 
ShopActivity.this.getPackageName());
 map.put("img_id", picId+"");
 data.add(map);

}
MyAdapter adapter=new MyAdapter
(ShopActivity.this, data, R.layout.list_item_custom,
new String［］{"shop_name", "shop_address", "shop_tel", "img_id"},
new int［］{R.id.txtName, R.id.txtAddress, R.id.txtTel, 
R.id.img});
list.setAdapter(adapter);
list.setOnItemClickListener(new OnItemClickListener() {

 @Override
 public void onItemClick(AdapterView<?> arg0, View arg1, int position,
 long arg3) {
Intent intent=new Intent();
intent.setClass(ShopActivity.this, ShopDetailActivity.class);
Bundle bundle=new Bundle();
bundle.putSerializable("shop", shops［position］);
intent.putExtras(bundle);
startActivity(intent);
 }
});
 }

 class MyAdapter extends SimpleAdapter {

public MyAdapter(Context context, List<? extends Map<String, ?>> 
data, int resource, String［］ from, int［］ to) {
 super(context, data, resource, from, to);
}
@Override
public View getView(int position, View convertView,
 ViewGroup parent) {
 View result=super.getView(position, convertView, parent);
 TextView txtTilte=(TextView) result.findViewById(R.id.txtName);
 if(position % 2==1) {
result.setBackgroundColor(Color.GREEN);
txtTilte.setTextColor(Color.BLUE);
 } else {
result.setBackgroundColor(Color.YELLOW);
txtTilte.setTextColor(Color.RED);
 }
 return result;
}
 }
 private void init(Context context) {
String packageName=context.getPackageName();
try {
 applicationInfo=context.getPackageManager().getApplicationInfo(packageName, PackageManager.GET_META_DATA);
 String dbDir=applicationInfo.dataDir+File.separator+DB_DIR;
 File file=new File(dbDir);
 if(!file.exists()) {
file.mkdir();
 }
 databasePath=applicationInfo.dataDir+File.separator+DB_DIR+File.separator+DB_NAME;
} catch (NameNotFoundException e) {
}
 }
 @Override
 public void onCreateContextMenu(ContextMenu menu, View v,
 ContextMenuInfo menuInfo) {

MenuInflater mInflater=getMenuInflater();
mInflater.inflate(R.menu.shop, menu);

super.onCreateContextMenu(menu, v, menuInfo);
 }
return super.onContextItemSelected(item);
 }
4.6.3项目说明
店铺列表使用ListView控件来实现，本节完成的店铺列表数据定义在内存的集合里，实际项目中这些店铺信息存储在远程数据库里，这些数据来源于远程数据库，通过网络通信传到本地，在第7章网络通信技术讲解后，会修改LIstView中的数据源为远程数据库。
4.7项目实战： 店铺详情页的实现〖*2〗4.7.1项目分析在三级项目中，单击首页的店铺控件时会进入店铺列表页面。该页面包含咖啡商城里面所有店铺的基本信息，如店铺的名称、地址、联系方式，及推荐商品等，相邻的店铺还使用了不同的显示样式。单击某一个店铺可以进入店铺的详细描述页面，可以单击“收藏”进行店铺收藏。
4.7.2项目实现
第一步，首先创建一个表示店铺详情的ShopDetailActivity。定义一个Shop类，里面设置店铺id、店铺名称、店铺地址、联系电话、店铺图片名称等属性，并且定义相应的setter方法和getter方法。考虑到跳转到店铺详情页面时要显示店铺的详细信息，即要将店铺对象传到店铺详情页面，所以要将Shop类实现Serializable接口。
 第二步，先设计ShopActivity对应的布局文件activity_shop.xml，该文件中只定义一个控件，即在LinearLayout布局中定义ListView。
第三步，定义ListView中每一项的布局，左侧放置店铺图片，右侧分别是店铺名称、店铺地址、店铺联系电话。
第四步，准备数据。设计五个店铺对象，给相应的属性赋值，并将店铺对象放置到ArrayList集合中，每个店铺对象分别放到HashMap中，记录店铺的详细信息。
第五步，选择合适的适配器，实现控件和数据的绑定。
第六步，当单击每一个条目时，会跳转到相应的店铺详情即ShopDetailActivity页面，考虑用Intent跳转，并且以Shop对象作为参数使用Bundle传参。
第七步，设计店铺详情的布局，分别显示店铺详细信息、图片及底部收藏按钮。
第八步，在ShopDetailActivity中使用Intent对象的getSerializableExtra方法，解析Shop对象并将店铺信息显示到界面上。
项目代码如下。package neusoft.soft.coffeestore.view;
import android.app.Activity;
import android.content.Intent;
import android.graphics.Color;
import android.os.Bundle;
import android.widget.ImageView;
import android.widget.TextView;
import neusoft.soft.coffeestore.bean.Shop;
public class ShopDetailActivity extends Activity {
private TextView txtInfo;
private Shop shop;
private ImageView img;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_shop_detail);
txtInfo=(TextView) findViewById(R.id.txtdetail);
img=(ImageView) findViewById(R.id.image);
Intent intent=this.getIntent();
shop=(Shop) intent.getSerializableExtra("shop");
txtInfo.setTextColor(Color.RED);
txtInfo.setTextSize(20);
txtInfo.setText("店铺名称: "+shop.getShop_name()+"\\n"
+"店铺地址"+shop.getShop_address()+"\\n"+
"店铺电话: "+shop.getTel());
int picId=getResources().getIdentifier(shop.getImg_name(), 
"drawable", ShopDetailActivity.this.getPackageName());
img.setBackgroundResource(picId);
}
}
Shop类定义如下。package neusoft.soft.coffeestore.bean;
import java.io.Serializable;
public class Shop implements Serializable{
private String shop_id;
private String shop_name;
private String shop_address;
private String tel;
private String img_name;
private int img_id;
public String getImg_name() {
return img_name;
}
public void setImg_name(String img_name) {
this.img_name=img_name;
}
public int getImg_id() {
return img_id;
}
public void setImg_id(int img_id) {
this.img_id=img_id;
}
public String getShop_id() {
return shop_id;
}
public void setShop_id(String shop_id) {
this.shop_id=shop_id;
}
public String getShop_name() {
return shop_name;
}
public void setShop_name(String shop_name) {
this.shop_name=shop_name;
}
public String getShop_address() {
return shop_address;
}
public void setShop_address(String shop_address) {
this.shop_address=shop_address;
}
public String getTel() {
return tel;
}
public void setTel(String tel) {
this.tel=tel;
}

}
页面布局文件定义如下。<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".ShopDetailActivity">
<TextView
android:id="@+id/txtdetail"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/hello_world" />
<ImageView
android:id="@+id/image"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_below="@+id/txtdetail"
android:layout_centerInParent="true" />
<Button
android:id="@+id/button1"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:layout_alignParentBottom="true"
android:text="加入收藏夹" /> 

</RelativeLayout>
4.7.3项目说明
 程序运行效果如图4.28所示。
本功能的实现思路及相关知识点如下。
（1） 店铺列表使用ListView控件来实现，店铺列表数据定义在内存的集合里，实际项目中这些店铺信息存储在远程数据库里，这些数据来源于远程数据库，通过网络通信传到本地，在学习网络通信技术讲解后，会修改ListView中的数据源为远程数据库。
（2） 页面跳转一般用Intent来完成，推荐使用显式的Intent来实现。
（3） 页面跳转时需要传递店铺的详细信息，考虑将店铺的所有信息封装到Shop类中，在Intent跳转时传递Shop对象，传递Shop对象首先将Shop实现Serializable接口，然后通过Intent直接传递。
图4.28店铺详情页实现效果
4.8值资源〖*2〗4.8.1字符串资源在安卓程序开发过程中，字符串资源是使用非常频繁的一类资源，把在应用程序中出现的文字单独放置在app/res/values/strings.xml文件中，称为字符串资源。将字符串声明在strings.xml文件中，一是有利于减少应用的体积，降低数据的冗余；二是对程序的国际化有很大帮助。在该文件中可以存放字符串类型如下。
（1） 普通的字符串；
（2） 引用字符串；
（3） HTML字符串（引用字符串与HTML字符串应更改XML文件的内容）；
（4） 可替换字符串（只能使用代码方式获取资源值后再赋值）。
字符串资源定义后，在资源文件和程序代码文件中都可以引用。
（1） 在资源中引用资源的格式为＠［package:］type:name，其中，＠表示对资源的引用，package是包名称，如果在相同的包中，package则可以省略，@标识表示需要解析的内容而非要显示的内容。
（2） 在代码中引用资源，需要使用资源的ID，可以通过［R.resource_type.resource_name］或［android.R.resource_type.resource_name］获取资源ID，其中，resource_type代表资源类型，即R类中的内部类名称；resource_name代表资源名称，对应资源的文件名或在XML文件中定义的资源名称属性。
【例4.20】不同类型字符串资源的定义并显示。
首先在strings.xml中使用如下代码。<resources>
<string name="app_name">Example</string>
<string name="common_string">普通字符串</string>
<string name="quoted_string">\\"引用字符串\\"</string>
<string name="html_string"><b><i>HTML</i></b><b>字符串</b>
</string>
<string name="java_format_string">这是一个 %1$s! </string>
</resources>
在布局文件中使用TextView控件分别引用不同的字符串资源，具体代码如下。<TextView
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_margin="2px"
android:text="@string/common_string" />
<TextView
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_margin="2px"
android:text="@string/quoted_string" />
<TextView
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_margin="2px"
android:text="@string/html_string" />
<TextView
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_margin="2px"
android:text="@string/java_format_string" />
其中，前三个字符串资源比较容易实现，对于可替换字符串来说只能使用代码方式获取资源值后再赋值，所以需要在Java文件中对其进行设置，首先在布局文件中对可替换字符串设置id属性为txtJavaFormatSting，在Java文件中使用如下代码。public class MainActivity extends AppCompatActivity {
 private TextView txtJavaFormatSting;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
txtJavaFormatSting=(TextView)(this.findViewById
(R.id.txtJavaFormatSting));
String value=String.format(this.getResources().getString
(R.string.java_format_string),"格式化字符串");
txtJavaFormatSting.setText(value);
}
}
运行效果如图4.29所示。
图4.29字符串资源使用
4.8.2颜色资源
对于Android程序来说，颜色资源是最基本最常用的资源。颜色资源可以对文本、背景、组件等部件进行设置。颜色资源位于app/res/values/colors.xml文件中，该文件中可以存放颜色资源类型如下。
（1） RGB值，是通过对红(R)、绿(G)、蓝(B)三个颜色通道的变化以及它们相互之间的叠加来得到各式各样的颜色的，是目前应用最广的颜色系统之一。
（2） ARGB值，如果ARGB每个值的两位十六进制值相同，可以省略为一个。
比如红色#FFFF0000，可以写成#FF00（或者#F00）。常用的颜色资源有： #FFFF0000红色，#FFFF6600橙色，#FFFFEE00黄色，#0000FF00绿色。
在颜色资源文件中定义颜色资源后，可以在Java或XML文件中使用该颜色资源。颜色资源在XML文件中的使用语法格式如下：@［<package>:］color/颜色资源名
与字符串资源类似，同样也可以通过引用的方式进行使用。下面通过一个例子进行演示。
【例4.21】对例4.20的扩展： 给TextView控件添加颜色资源。
首先在app/res/values/colors.xml文件中定义颜色资源，其代码如下。<?xml version="1.0" encoding="utf-8"?>
<resources>
<color name="colorPrimary">#3F51B5</color>
<color name="colorPrimaryDark">#303F9F</color>
<color name="colorAccent">#FF4081</color>
<color name="red">#FF0000</color>
<color name="green">#00FF00</color>
</resources>
定义完成颜色资源文件之后，在布局文件中定义TextView组件时，为TextView组件添加Android： textColor属性，通过引用的方式将资源文件引用进来，关键代码如下。<TextView
android:id="@+id/txtJavaFormatSting"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_margin="2px"
android:textColor="@color/red"/>
这样就可以通过引用资源文件将上述的TextView中字符串显示颜色设置成红色。
运行效果如图4.30所示。
图4.30字符串资源使用
4.8.3数组资源
数组资源位于app/res/values目录下，通过数组资源可以存放一维的字符串数组或者整数数组。定义时使用stringarray元素定义字符串数组，使用integerarray定义整数数组。定义数组资源时使用name属性，并且需要在起始标记和结束标记中使用<item></item>标签对定义单个数组元素。
【例4.22】定义一个数组，具体显示“北京”“上海”“天津”“重庆”等信息，代码如下。<string-array name="citylist">
<item>北京</item>
<item>上海</item>
<item>天津</item>
<item>重庆</item>
</string-array>
下面使用简单的ListView控件将上述数组显示出来,在主布局文件中使用字符串数组资源为其指定android: entries属性。其关键代码如下。<ListView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:entries="@array/citylist" />
运行效果如图4.31所示。
图4.31数组资源使用
4.9菜单
Android程序中，菜单资源应用广泛，它位于app/res/menu目录下。菜单主要分为选项菜单(ActionBar)和上下文菜单(Content menu)。
1. 选项菜单
【例4.23】定义和使用菜单。
菜单可以使用代码来定义，也可以使用XML文件来定义，下面分别介绍下两种菜单定义方法。
1） 使用XML菜单文件
菜单资源位于app/res/menu目录下，新建工程时一般没有这个文件夹，直接在res文件夹下新建一个menu文件夹即可，在该文件夹下存放程序需要的菜单资源。创建时在menu文件夹下使用鼠标右键选择New下的Menu Resourse File即可，接下来，在XML文件中进行设置。具体XML菜单的代码如下。<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto">
<group android:id="@+id/menu_group">
<item
android:id="@+id/index"
android:title="个人主页"
app:showAsAction="never" />
<item
android:id="@+id/pushsetting"
android:title="推送设置"
app:showAsAction="never">
<menu>
<item
android:id="@+id/ring"
android:title="声音" />
<item
android:id="@+id/Vibration"
android:title="震动" />
</menu>
</item>
<item
android:id="@+id/info"
android:title="我的消息"

app:showAsAction="never" />
<item
android:id="@+id/task"
android:title="签到任务"
app:showAsAction="never" />
</group>
</menu>
这里定义了一个名字为menu_main的菜单资源文件，代码中每个item代表一个选项，同时会发现存在menu里嵌套menu的情况，在Android开发中，不仅设置菜单资源，也可以为菜单添加子菜单，子菜单也使用<menu>标签进行声明，内部使用<item>标签描述菜单项。Menu菜单有多个属性，其中，showAsAction属性共有五个值： ifRoom、never、always、withText、collapseActionView，这些值可以混合使用。取值ifRoom时会显示在 Item 中，但是如果已经有4个或者4个以上的Item时会隐藏在溢出列表中。当然个数并不仅局限于4个，依据屏幕的宽窄而定。取值never时，永远不会显示，只会在溢出列表中显示，而且只显示标题，所以在定义 item 的时候，最好把标题都带上。取值always时，无论是否溢出，总会显示。取值withText时，表示显示文本标题。collapseActionView一般结合 ifRoom 实现 SearchView 的效果。
定义菜单后，需要在Activity中将定义好的菜单资源引入到程序中，首先需要重写onCreateOptionsMenu()方法，在该方法中引入定义好的菜单资源，使用的是getMenuInflater().inflate(R.menu.menu_main，menu);语句，这里inflate()方法引入了前面定义的menu_main资源，具体代码如下。public class MainActivity4_15 extends AppCompatActivity {

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main4_15);
}
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.menu,menu);
return super.onCreateOptionsMenu(menu);
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()){
case R.id.index:
Toast.makeText(this,"您单击的是"+item.getTitle(),Toast.
LENGTH_SHORT).show();
break;
case R.id.pushsetting:
Toast.makeText(this,"您单击的是"+item.getTitle(),Toast.
LENGTH_SHORT).show();
break;
case R.id.info:
Toast.makeText(this,"您单击的是"+item.getTitle(),Toast.
LENGTH_SHORT).show();
break;
case R.id.task:
Toast.makeText(this,"您单击的是"+item.getTitle(),Toast.
LENGTH_SHORT).show();
break;
}
return super.onOptionsItemSelected(item);
}
@Override
public boolean onMenuOpened(int featureId, Menu menu) {
if(menu !=null) {
if(menu.getClass().getSimpleName().equalsIgnoreCase
("MenuBuilder")) {
try {
Method method=menu.getClass().getDeclaredMethod
("setOptionalIconsVisible", Boolean.TYPE);
method.setAccessible(true);
method.invoke(menu, true);
} catch (Exception e) {
e.printStackTrace();
}
}
}
return super.onMenuOpened(featureId, menu);
}
}
上述代码中使用了选项菜单，当菜单项被单击时需要使用onOptionsItemSelected()方法设置单击事件。另外为了完全显示菜单内容，还需要定义onMenuOpened()方法，否则菜单中的图片无法正常显示。最终的显示效果如图4.32所示。
图4.32选项菜单的显示
2） 使用代码来定义菜单
除了定义menu文件夹下的菜单资源文件外，也可以使用代码来定义菜单，主要使用menu对象的add方法添加菜单项，重新定义onCreateOptionsMenu()方法，这种方法也可以实现菜单的效果。
创建方法如下。
（1） 覆盖Activity的onCreateOptionsMenu(Menu menu)方法，当第一次打开菜单时调用。
（2） 调用Menu的add()方法添加菜单项(MenuItem)，可以调用MenuItem的setIcon()方法为菜单项设置图标。
（3） 当菜单项(MenuItem)被选中时，覆盖Activity的onOptionsMenuSelected()方法响应事件。
具体代码如下所示。public boolean onCreateOptionsMenu(Menu menu) {
MenuItem index=menu.add(Menu.NONE, Menu.FIRST, Menu.FIRST, "个人主页");
index.setShowAsAction(MenuItem.SHOW_AS_ACTION_NEVER);
SubMenu pushsetting=menu.addSubMenu(Menu.NONE, Menu.FIRST+1, Menu.FIRST+1, "推送设置");
menu.add(Menu.NONE, Menu.FIRST+2, Menu.FIRST+2, "我的消息");
menu.add(Menu.NONE, Menu.FIRST+3, Menu.FIRST+3, "签到任务");
pushsetting.add(Menu.NONE, Menu.FIRST+4, Menu.FIRST+4, "声音");
pushsetting.add(Menu.NONE, Menu.FIRST+5, Menu.FIRST+5, "震动");
return super.onCreateOptionsMenu(menu);
}
这里使用了add()方法，其中4个参数介绍如下（以第一行“主页”为例）。
 Menu.NONE： 组Id。
 Menu.FIRST： 菜单项Id。
 Menu.FIRST： 排序Id。
 主页： 字符串类型或资源Id（int）类型的菜单项的内容。
需要注意的是，选项菜单使用Activity的onCreateOptionMenu方法关联，应用程序最多显示6个选项菜单，超出6个时，程序会自动显示More按钮。
2. 上下文菜单
上下文菜单的定义与选项菜单类似，都是在Activity的onCreate中注册，并在Activity的onCreateContextMenu方法中绑定上下文菜单。上下文菜单需要和具体控件进行绑定，长按该控件时实现上下文菜单的效果。例4.24的功能是在界面添加一个id为tv的TextView控件，对该控件绑定上下文菜单，菜单中定义红色、绿色、蓝色三个条目，单击对应条目时将TextView的背景颜色进行更换。
【例4.24】定义和使用菜单。
首先定义一个新的菜单资源main_menu，代码如下。<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
<item android:id="@+id/red"
android:title="红色"
android:orderInCategory="1">
</item>
<item
android:title="绿色"
android:id="@+id/green"
android:orderInCategory="2"
>
</item>
<item
android:title="蓝色"
android:id="@+id/blue"
android:orderInCategory="3"
>
</item>
</menu>
在布局文件中定义一个id为tv的TextView控件，在Activity中绑定注册时需要对该控件使用registerForContextMenu方法。当弹出菜单后单击每个条目需要重写onContextItemSelected方法，具体实现代码如下。public class MenuActivity extends AppCompatActivity {
private TextView tv;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_menu);
tv=(TextView) findViewById(R.id.tv);
registerForContextMenu(tv);
}
@Override
public void onCreateContextMenu(ContextMenu menu, View v, ContextMenu.ContextMenuInfo menuInfo) {
getMenuInflater().inflate(R.menu.main_menu,menu);
super.onCreateContextMenu(menu, v, menuInfo);
}
@Override
public boolean onContextItemSelected(MenuItem item) {
switch (item.getItemId()){
case R.id.red:
tv.setBackgroundColor(Color.RED);
break;
case R.id.green:
tv.setBackgroundColor(Color.GREEN);
break;
case R.id.blue:
tv.setBackgroundColor(Color.BLUE);
break;
}
return super.onContextItemSelected(item);
}
}
布局文件代码如下。<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical">

<TextView
android:id="@+id/tv"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:layout_margin="2px"
android:text="测试上下文菜单"
android:textSize="24dp"/>
</LinearLayout>
单击条目后设置文字的背景颜色，最终的显示代码如图4.33所示。
图4.33上下文菜单的显示
对于某些控件已带有上下文菜单，默认的情况下自定义的菜单将与已定义的菜单合并，也可以使用menu对象的clear方法清空原有菜单项。
4.10对话框
AlertDialog对话框用于向用户提示信息，或与用户交互，它是一个出现在当前Activity之上的一个小窗口。AlertDialog运行时，处于下面的Activity失去焦点，对话框接受所有的用户交互。为了创建AlertDialog对象，需要使用Builder类，该类是AlertDialog类中定义的一个内嵌类。首先必须创建AlertDialog.Builder对象，然后通过Builder.show方法显示对话框，或通过Builder.create方法返回AlertDialog对象，再通过AlertDialog.show方法显示对话框。
AlertDialog类层次关系如下。java.lang.Object
android.app.AlertDialog.Builder创建AlertDialog的步骤如下。
（1） 创建AlertDialog.Builder对象；
（2） 调用Builder对象的setTitle方法设置标题，setIcon方法设置图标；
（3） 调用Builder相关方法，如setMessage方法、setItems方法、setSingleChoiceItems方法、setMultiChoiceItems方法、setAdapter方法、setView方法设置不同类型的对话框内容；
（4） 调用setPositiveButton、setNegativeButton、setNeutralButton设置多个按钮；
（5） 调用Builder对象的create()方法创建AlertDialog对象；
（6） 调用AlertDialog对象的show()方法显示对话框。
AlertDialog提供了非常简单的方法来实现按钮操作，具体方法如下。
（1） 确定按钮：public Builder setPositiveButton(CharSequence text,final OnClickListener listener)
（2） 忽略按钮：public Builder setNeutralButton(CharSequence text,final OnClickListener listener)
（3） 取消按钮：public Builder setNegativeButton(CharSequence text,final OnClickListener listener)
其中，参数text是在按钮上显示的文本，而参数listener则指定了按钮的单击事件。
【例4.25】定义和使用简单对话框。
在实际应用中，创建这种对话框的代码如下。import android.content.DialogInterface;
import android.os.Bundle;
import android.support.v7.app.AlertDialog;
import android.support.v7.app.AppCompatActivity;
import android.widget.Toast;

public class MainActivity4_17 extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main4_17);
AlertDialog.Builder builder=new AlertDialog.Builder(MainActivity4_17.this);//创建对话框
builder.setTitle("提示") //设置标题
.setMessage("是否确认退出?") //设置内容
.setIcon(R.drawable.alarm)//设置图标
.setPositiveButton("确定", new DialogInterface.
OnClickListener() { //设置确定按钮
public void onClick(DialogInterface dialog, int which) {
dialog.dismiss(); //关闭dialog
Toast.makeText(MainActivity4_17.this, "确认"+which, Toast.LENGTH_SHORT).show();
}
})
.setNegativeButton("取消", new DialogInterface.
OnClickListener() { //设置取消按钮
public void onClick(DialogInterface dialog, int which) {
dialog.dismiss();
Toast.makeText(MainActivity4_17.this, "取消"+which, Toast.LENGTH_SHORT).show();
}
});
builder.create().show();//显示对话框
}
}
程序运行效果如图4.34所示。
图4.34带按钮对话框运行效果
4.11动 画 资 源
Android动画主要包含补间动画（Tween Animation）和属性动画（Property Animation）。补间动画是通过对View的内容进行一系列的图形变换来实现动画效果，即通过指定开始和结束的“关键帧”，而变化中的其他帧由系统来计算，不需要逐帧指定，其中的变换包括平移、缩放、旋转、改变透明度。动画效果的定义可以采用XML实现，也可以采用编码完成，但是一般都会采用XML文件形式来定义动画，这样有利于将界面与逻辑分离。补间动画类型如表4.6所示。表4.6补间动画类型
动画的类型XML定义动画使用配置节点编码定义动画使用的类渐变透明度动画效果<alpha/>AlphaAnimation渐变尺寸缩放动画效果<scale/>ScaleAnimation画面位置移动动画效果<translate/>TranslateAnimation画面旋转动画效果<rotate/>RotateAnimation另外，开发人员可以为每个动画设置动画插入器，其作用是设置动画某个属性随时间变化的形式，例如线性、指数、加速或减速等。Android自带的几种动画插入器如表4.7所示。表4.7动画插入器
名称说明AccelerateInterpolator加速，开始时慢中间加速DecelerateInterpolator减速，开始时快然后减速AccelerateDecelerateInterolator先加速后减速，开始结束时慢，中间加速AnticipateInterpolator反向，先向相反方向改变一段再加速播放AnticipateOvershootInterpolator反向加超越，先向相反方向改变，再加速播放，会超出目的值然后缓慢移动至目的值BounceInterpolator跳跃，快到目的值时值会跳跃，如目的值为100，后面的值可能依次为85，77，70，80，90，100CycleIinterpolator循环，动画循环一定次数，值的改变为一正弦函数：Math.sin(2 mCycles Math.PI input)LinearInterpolator线性，线性均匀改变OvershottInterpolator超越，最后超出目的值然后缓慢改变到目的值抽象类Animation是一个实现Android UI界面动画效果的API，Animation是补间动画的基类，它的直接子类AlphaAnimation（透明度动画）、RotateAnimation（旋转动画）、ScaleAnimation（缩放动画）、TranslateAnimation（位移动画）、AnimationSet提供了一系列的动画效果，可以进行淡入淡出、旋转、缩放、动画集等，这些效果可以应用在绝大多数的控件中。
【例4.26】定义和使用补间动画。
本例题中采用通过在XML中定义动画的方式来实现动画效果，在XML中分别定义四种补间动画。首先，定义渐变透明度动画，实现图片淡入淡出的动态效果，动画资源文件名称为amin_alpha.xml。<?xml version="1.0" encoding="utf-8"?>
<alpha xmlns:android="http://schemas.android.com/apk/res/android"
android:fromAlpha="1.0"
android:toAlpha="0.1"
android:duration="3000"
android:fillAfter="true"
android:repeatCount="-1">
</alpha>
定义渐变尺寸动画，实现图片尺寸变化的动态效果，动画资源文件名称为amin_scale.xml。<?xml version="1.0" encoding="utf-8"?>
<set xmlns:android="http://schemas.android.com/apk/res/android" >
<scale
android:duration="4000"
android:fillAfter="false"
android:fromXScale="0.0"
android:fromYScale="0.0"
android:interpolator="@android:anim/accelerate_decelerate_
interpolator"
android:pivotX="50%"
android:pivotY="50%"
android:toXScale="1.0"
android:toYScale="1.0" />
</set>
定义平移动画，实现图片移动的动态效果，动画资源文件名称为amin_ translate.xml。<?xml version="1.0" encoding="utf-8"?>
<set xmlns:android="http://schemas.android.com/apk/res/android">
<translate
android:duration="4000"
android:fromXDelta="0"
android:fromYDelta="0"
android:toXDelta="300"
android:toYDelta="0" />
</set>
定义旋转动画，实现图片旋转的动态效果，动画资源文件名称为amin_rotate.xml。<?xml version="1.0" encoding="utf-8"?>
<set xmlns:android="http://schemas.android.com/apk/res/android">
<rotate
android:duration="2000"
android:fromDegrees="0"
android:interpolator="@android:anim/linear_interpolator"
android:pivotX="50%"
android:pivotY="50%"
android:repeatCount="-1"
android:repeatMode="restart"
android:startOffset="-1"
android:toDegrees="+360"/>
</set>
布局文件代码如下。<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@+id/winpay_loading_parent"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:background="#111111"
android:orientation="vertical">

<ImageView
android:id="@+id/alpha_bg"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_gravity="center_horizontal"
android:contentDescription="@null"
android:src="@drawable/alpha" />

<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_gravity="center_horizontal"
android:layout_marginTop="3dp"
android:text="这是渐变透明度动画……"
android:textColor="#44aaaa"
android:textSize="28sp" />

<ImageView
android:id="@+id/scale_bg"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_gravity="center_horizontal"
android:contentDescription="@null"
android:src="@drawable/alpha" />

<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_gravity="center"
android:layout_marginTop="3dp"
android:text="这是渐变尺寸缩放动画……"
android:textColor="#44aaaa"
android:textSize="28sp" />

<ImageView
android:id="@+id/translate_bg"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_gravity="center_horizontal"
android:contentDescription="@null"
android:src="@drawable/alpha" />

<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_gravity="center"
android:layout_marginTop="3dp"
android:text="这是平移动画……"
android:textColor="#44aaaa"
android:textSize="28sp" />

<ImageView
android:id="@+id/rotate_bg"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_gravity="center_horizontal"
android:contentDescription="@null"
android:src="@drawable/rotate" />

<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_gravity="center_horizontal"
android:layout_marginTop="3dp"
android:text="这是旋转动画……"
android:textColor="#44aaaa"
android:textSize="28sp" />

</LinearLayout>
MainActivity代码如下。import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.animation.Animation;
import android.view.animation.AnimationUtils;
import android.widget.ImageView;

public class MainActivity4_20 extends AppCompatActivity {
private ImageView alphaBg;
private ImageView rotateBg;
private ImageView scaleBg;
private ImageView translateBg;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main4_20);

alphaBg=(ImageView) findViewById(R.id.alpha_bg);
Animation imageAlphaAnimation=AnimationUtils.loadAnimation(this, R.anim.amin_alpha);
alphaBg.startAnimation(imageAlphaAnimation);

scaleBg=(ImageView) findViewById(R.id.scale_bg);
 Animation imageScaleAnimation=AnimationUtils.loadAnimation(this,R.anim.anim_scale);
scaleBg.startAnimation(imageScaleAnimation);

translateBg=(ImageView) findViewById(R.id.translate_bg);
Animation imageTranslateAnimation=AnimationUtils.loadAnimation (this, R.anim.anim_translate);
translateBg.startAnimation(imageTranslateAnimation);

rotateBg=(ImageView)findViewById(R.id.rotate_bg);
Animation imageRotateAnimation=AnimationUtils.loadAnimation(this,R.anim.anim_rotate);
rotateBg.startAnimation(imageRotateAnimation);
}
}
本例题中实现了四种补间动画效果，案例运行效果如图4.35所示。
图4.35补间动画案例运行效果图
4.12样式与主题〖*2〗4.12.1样式Style资源可以看作将一系列控件的属性统一到一起，使其成为一种可重用的资源。Style资源声明在res/values/styles.xml文件中，并且需要为每一个style定义一个名称。使用时，在布局文件中对控件使用style="@styles/<style的名称>"进行引用，在控件中定义的属性可以重写style中对应的属性。
【例4.27】Style资源的使用。
本程序为按钮定义显示样式，首先在values/styles.xml文件中定义样式，具体代码如下。<resources>
 <style name="textstyle">
<item name="android:layout_height">wrap_content</item>
<item name="android:layout_width">match_parent</item>
<item name="android:textColor">#5599AA</item>
<item name="android:textSize">24dp</item>
<item name="android:gravity">center_horizontal</item>
</style>
</resources>
上面代码中使用了<item></item>标记定义了具体样式，设置其样式的名称为my_button_style，字体大小为30sp。下面在布局文件中加入一个按钮，对该按钮使用上述样式。其代码如下。<TextView
style="@style/textstyle"
android:text="@string/common_string"/>
<TextView
style="@style/textstyle"
android:text="@string/quoted_string" />
<TextView
style="@style/textstyle"
android:text="@string/html_string" />
通过上面的代码对TextView设置了显示样式，显示效果如图4.36所示。
图4.36样式定义效果
在Android中还支持继承样式的功能，只要在<style></style>标记中使用parent属性进行设置即可。
下面对例4.27中样式文件做如下修改。<style name="textstyle">
<item name="android:layout_height">wrap_content</item>
<item name="android:layout_width">match_parent</item>
<item name="android:textColor">#5599AA</item>
<item name="android:textSize">24dp</item>
<item name="android:gravity">center_horizontal</item>
</style>
<style name="textviewstyle" parent="textstyle">
<item name="android:background">#FF0000</item>
</style>
此时textviewstyle继承了textstyle属性，设置了背景色，在布局文件中对id为txtJavaFormatString的TextView使用 textviewstyle样式如下。<TextView
style="@style/textviewstyle"
android:id="@+id/txtJavaFormatString"
/>
效果如图4.37所示。
图4.37对按钮使用style
如果在textviewstyle中也设置了一个属性值，比如<item name="android:textSize">10sp</item>，此时会使用字样式的值，即10sp。
4.12.2主题
主题资源(Theme)是一系列资源的一种特殊样式，可以对应用程序或某个Activity进行主题的更换，以达到“换肤”的功能。通过改变主题可改变应用程序运行的外观。对Android系统来说，系统已经提供了一系列的主题资源，在Android开发过程中，可以使用继承某个主题并重写其中的某些项的方法来定义自己的主题资源。
定义主题资源的方法是在资源文件里建立不同样式的主题风格，使用时通过操作者的不同操作来对主题资源进行切换。下面介绍一个定义主题资源的例子，单击该按钮更改显示不同主题效果，如图4.38所示。
图4.38Android中设置不同主题
【例4.28】定义及使用主题资源。
首先要设置两个不同的主题风格，一个是黑色主题，另一个是白色主题。并且分别设置字号和字体显示颜色，具体style代码如下。<style name="Theme_a" parent="Theme.AppCompat">
<item name="android:textSize">32sp</item>
<item name="android:textColor">#00FF00</item>
<item name="android:background">#555555</item>
</style>

<style name="Theme_b" parent="Theme.AppCompat.Light">
<item name="android:textSize">24sp</item>
<item name="android:textColor">#FF0000</item>
<item name="android:background">#FFFFFF</item>
</style>
在主布局文件中定义按钮控件，其布局文件代码如下。<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="单击该按钮更换主题"
android:onClick="onclick"
/>
对程序使用Theme_b主题，需要更改Manifest对应的Theme，关键代码如下。<application
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:supportsRtl="true"
android:theme="@style/Theme_b">
<activity android:name=".MainActivity">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
单击按钮后更换为Theme_a主题，此时需要在Activity中编写onclick方法达到更换对应主题的目的，具体代码如下。private boolean flag=true;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
public void onclick(View view){
if(flag) {
setTheme(R.style.Theme_b);
flag=false;
} else {
setTheme(R.style.Theme_a);
flag=true;
}
setContentView(R.layout.activity_main);
}
}
4.12.3图像状态资源
Android SDK提供的Button控件默认样式显得有些单调，为此，Android提供了一种改变Button默认样式的方法，这种方法不需要编写一行Java代码。
当按钮处于不同状态（正常、按下、获得焦点等）时会显示不同的样式，这些样式一般使用不同的图像来渲染，这就需要指定与不同状态对应的图像，而图像状态资源就是用来指定这些图像的。
图像状态资源时XML格式的文件，必须以<selector>标签作为根节点。在<selector>标签中包含若干个<item>标签，用来指定相应的图像资源。
【例4.29】修改Button样式。
假设有3个图像： normal.png、focusd.png和pressed.png，分别表示按钮默认的样式、获得焦点的样式、被按下的样式。在res/drawable目录下建立一个button.xml文件，并输入如下的内容。<?xml version="1.0" encoding="utf-8"?>
<selector xmlns:android="http://schemas.android.com/apk/res/android">
<item android:state_pressed="true" android:drawable="@drawable/
pressed" />
<item android:drawable="@drawable/normal" /> 
</selector>
程序分析： 在<selector>标签中有两个<item>标签，其中一个<item>标签将android:state_pressed属性值设为true，表示当前<item>标签的android:drawable属性指定的图像是被按下和获得焦点的样式。
在布局文件中定义一个<Button>标签，并按下面的代码设置< Button >标签的属性值。<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:background="@drawable/button"
android:text="按钮"/>
现在运行程序，会显示图4.39(a)所示的默认样式，按下这个按钮（不要抬起来），会显示图4.39(b)所示的按钮按下后的样式。
图4.39修改Button的默认样式效果
【例4.30】控件圆角矩形效果。
下面为控件设置圆角矩形效果，控件只要有background属性，就可以引用XML文件。首先新建资源文件，本例中将res/drawable文件下添加名为shape的XML文件。主要方法为： drawable下右击/new/Drawable resource file，将File name命名为shape，添加代码如下。<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android">
<corners android:radius="8dp"></corners>
<gradient
android:angle="45"
android:endColor="#0000FF"
android:startColor="#FFFF0000"></gradient>
</shape>
其中，corners的作用是控制圆角的半径，值越大半径越大，圆角的弧度就越大。在布局文件中引用上述圆角矩形效果，代码如下。<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="单击该按钮更换主题"
android:onClick="onclick"
android:background="@drawable/shape"
/>
最终效果如图4.40所示。
图4.40控件圆角矩形效果
4.13项目实战： eShop项目中各种资源的使用〖*2〗4.13.1项目分析在项目中，需要使用各种不同的资源，如图4.41所示，在Activity里面会使用大量的图片资源（app/res/drawable），图4.41项目中的资源文件
每个Activity的页面都会使用布局资源（app/res/layout），为了更好地动态显示项目效果，也会使用到动画资源（app/res/anim）。另外，还会比较频繁地使用值资源（app/res/value），使用较多的值资源包括属性、颜色、样式、字符串等。
4.13.2项目实现〖*2〗1. 字符串资源的使用在本项目中，字符串资源被大量使用。具体方法是在strings.xml文件中对不同位置字符串资源进行声明并使用。这样做的好处是当想修改某一位置的字符串信息时不需要在程序文件中寻找，而是直接在字符串资源文件中进行修改。这样大大地简化了修改难度，如果想要将程序国际化，直接将字符串资源中的文字替换成所需要的文字即可。本项目中，具体字符串资源的使用代码如下。<?xml version="1.0" encoding="utf-8"?>
<resources>
<string name="login_name">登录</string>
<string name="welcome_to_coffeeonline_system">欢迎来到在线商品销售系统
</string>
<string name="app_name">CoffeeStore</string>
<string name="hello_world">Hello world!</string>
<string name="action_settings">Settings</string>
<string name="title_activity_main">MainActivity</string>
<string name="hello_blank_fragment">Hello blank fragment</string>

<string name="title_activity_test_main">TestMainActivity</string>
<string name="title_activity_update_shop">UpdateShopActivity</string>
<string name="title_activity_add_shop">AddShopActivity</string>

</resources>
上述的字符串资源在strings.xml文件中定义之后，使用时通过加载对应布局文件并通过寻找对应名字的方式获取。而且实现了所有的Strings资源统一管理，更加利于搜索使用及修改对应的字符串资源。
2. 图像状态资源的使用
前文使用了单选按钮作为底部导航条的案例，但是并没有添加样式。本节将使用选择器资源给单选按钮加上样式以及状态，实现如图4.42所示的比较漂亮的导航条。该导航条在未选择状态下显示的是白色字体灰色图片，当用户选择了某一具体项目时字体颜色会相应地改变为绿色图片变为高亮，例如“我的”按钮，未选择时状态如图4.42(a)所示，选择后如图4.42(b)所示，这就是使用了Selector的效果，下面来实现如上所述的效果。
图4.42导航条
前面章节讲解了使用RadioButton控件控制Fragment的方法，将 RadioButton控件作为导航条使用，但是显示效果不好，下面使用资源文件对该控件进行美化。
首先创建该导航条的布局文件，使用alignParentBottom属性将其布局到页面底端，并对RadioGroup设置背景图片为tabbar_bg，布局文件具体代码如下。<RadioGroup
android:id="@+id/tabbar"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_alignParentBottom="true"
android:background="@drawable/tabbar_bg"
android:orientation="horizontal">

<RadioButton
android:id="@+id/tab_weather"
style="@style/main_tab_bottom_style"
android:drawableTop="@drawable/tab_weather_selector"
android:text="@string/tab_text_weather" />

<RadioButton
android:id="@+id/tab_trend"
style="@style/main_tab_bottom_style"
android:text="@string/tab_text_trend" />

<RadioButton
android:id="@+id/tab_index"
style="@style/main_tab_bottom_style"
android:text="@string/tab_text_index" />

<RadioButton
android:id="@+id/tab_tools"
style="@style/main_tab_bottom_style"
android:text="@string/tab_text_tools" />

<RadioButton
android:id="@+id/tab_setting"
style="@style/main_tab_bottom_style"
android:text="@string/tab_text_setting" />
</RadioGroup>
下面以第一个单选按钮为例对其设置，首先设置其id属性为tab_weather，同时在strings.xml文件下设置其显示文字为天气，之后为其设置style样式。具体代码如下。<string name="tab_text_weather">首页</string>
<style name="main_tab_bottom_style">
<item name="android:textColor">#faf5f5</item>
<item name="android:textSize">11dp</item>
<item name="android:ellipsize">marquee</item>
<item name="android:gravity">center_horizontal</item>
<item name="android:singleLine">true</item>
<item name="android:button">@null</item>
<item name="android:layout_width">0dp</item>
<item name="android:layout_height">wrap_content</item>
<item name="android:layout_weight">0.5</item>
</style>
上述代码设置了该单选按钮的各种属性，其中，<item name="android:button">@null</item>为去掉按钮样式的属性。最后设置drawableTop属性，该属性用来设置图片在文字上方，并通过使用selector设置其选中变化时产生的不同效果。<?xml version="1.0" encoding="utf-8"?>
<selector xmlns:android="http://schemas.android.com/apk/res/android">
<item android:drawable="@drawable/tab_weather" android:state_checked=
"false" />
<item android:drawable="@drawable/tab_weather_checked" android:state_checked="true" />
</selector>
下面修改用户选择按钮时图片颜色由灰色变为高亮，设置的方法是在drawable文件夹下的icon_*.xml文件中修改，本项目中有“首页”“购物车”“分类”“搜索”和“我的”5个可选择按钮，所以，需要分别对这5个可选框的XML文件进行设置。下面以icon_me.xml为例修改代码如下（其他几个的设置方法与这个相似）。<?xml version="1.0" encoding="utf-8"?>
<selector xmlns:android="http://schemas.android.com/apk/res/android">
<item android:drawable="@drawable/icon_me_nor" android:state_checked=
"false" />
<item android:drawable="@drawable/icon_me_sel" android:state_checked=
"true" />
</selector>
设置完成后需要在其对应的Java文件中引用该布局文件，如下。public void InitView() {
 main_tab_RadioGroup=(RadioGroup) findViewById(R.id.main_tab_RadioGroup);

 radio_home=(RadioButton) findViewById(R.id.radio_home);
 radio_shopcar=(RadioButton) findViewById(R.id.radio_shopcar);
 radio_sort=(RadioButton) findViewById(R.id.radio_sort);
 radio_search=(RadioButton) findViewById(R.id.radio_search);
 radio_me=(RadioButton) findViewById(R.id.radio_me);

 main_tab_RadioGroup.setOnCheckedChangeListener(this);
}

public void InitViewPager() {
 main_viewPager=(ViewPager) findViewById(R.id.main_ViewPager);

 fragmentList=new ArrayList<Fragment>();

 Fragment homeFragment=new HomeFragment();
 Fragment sortFragment=new SortFragment();
 Fragment shopCarFragment=new ShopCarFragment();
 Fragment searchFragment=new SearchFragment();
 Fragment meFragment=new MeFragment();

 fragmentList.add(homeFragment);
 fragmentList.add(shopCarFragment);
 fragmentList.add(sortFragment);
 fragmentList.add(searchFragment);
 fragmentList.add(meFragment);
 //设置ViewPager适配器
 main_viewPager.setAdapter(new MyAdapter(getSupportFragmentManager(), fragmentList));
 main_viewPager.setCurrentItem(0);
 main_viewPager.setOnPageChangeListener(new MyListner());
}
public class MyAdapter extends FragmentPagerAdapter {
 ArrayList<Fragment> list;
 public MyAdapter(FragmentManager fm, ArrayList<Fragment> list) {
super(fm);
this.list=list;
 }
 @Override
 public Fragment getItem(int arg0) {
return list.get(arg0);
 }

 @Override
 public int getCount() {
return list.size();
 }
}
3. 动画资源的使用
项目中使用动画的场景很多。比如首页的图片切换，首页中目标被选中时样式的改变等内容，具体定义的动画资源如图4.43所示。下面以slide_in_right.xml文件为例介绍动画的显示过程。
图4.43动画资源
首先在slide_in_right.xml文件中定义动画进入的位置（fromXDelta），最终的动画位置（toXDelta），以及动画持续时间。其中，fromXDelta 属性为动画起始时X坐标上的位置；toXDelta属性为动画结束时X坐标上的位置；fromYDelta属性为动画起始时Y坐标上的位置；toYDelta属性为动画结束时Y坐标上的位置。值得注意的是，没有指定的属性默认是以自己为相对参照物，这里没有指定Y轴的属性，则默认为其自身在Y轴方向没变化。另外，文件同时也定义了动画进入时透明度的变化，0.0表示完全透明，而1.0表示完全不透明，进入效果为从无到有的一个过程。另外，其duration属性为动画持续时间，时间以毫秒为单位。<?xml version="1.0" encoding="utf-8"?>
<set xmlns:android="http://schemas.android.com/apk/res/android">
<translate
android:duration="300"
android:fromXDelta="50%p"
android:toXDelta="0" />
<alpha
android:duration="300"
android:fromAlpha="0.0"
android:toAlpha="1.0" />
</set>
4.13.3项目说明
本节通过各种资源的使用，帮助读者掌握资源在实际项目中的应用方式，其中，字符串资源是使用最多的资源，通过合理使用字符串资源使页面显示更加多样化，同样对后期国际化有很大好处。尺寸资源、颜色和数组资源定义好后，在项目中随时调用，使编程更加灵活。通过菜单资源实现页面隐藏更多的信息，并且丰富了用户的交互形式。对话框资源给用户更多的提示信息，动画资源使页面显示更加多样化，风格和主题资源使程序统一显示。总之，资源文件是安卓开发中必不可少的部分，这部分知识相对容易，但是通过合理运用这部分知识实现多样化的效果却比较难，需要开发者深入钻研，多多实践。
4.14项目实战： eShop引导页图片切换的实现〖*2〗4.14.1项目分析很多App在第一次启动或者版本更新后再启动时，都会出现几个图片切换的效果，这些图片大都是此App的功能介绍，切换后才跳到App首页。本项目中，当应用程序检测到用户是首次启动时，会出现如图4.44(a)所示的引导页面，手指滑动界面则出现如图4.44(b)所示的欢迎界面。此启动页在项目第一次启动时才会出现。项目中通过手指滑动屏幕实现从第一张到第二张图片切换效果的方法就是Android人机交互方法。
图4.44使用ViewPager实现引导页
4.14.2项目实现
为实现上述引导页的图片切换效果，首先需要定义其XML文件，该布局文件定义名称为viewfilter.xml。由于该布局内只有一张图片文件，所以只需要一个线性布局，该布局内部使用ViewFlipper控件。<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical">

<ViewFlipper
android:id="@+id/viewflipper"
android:layout_width="match_parent"
android:layout_height="match_parent">
</ViewFlipper>
</LinearLayout>
同时,在资源目录中添加动画资源文件，此动画资源用于设置手势滑动时图片进入和滑出的动画效果，如从右侧滑入时使用的代码如下。<?xml version="1.0" encoding="utf-8"?>
<set xmlns:android="http://schemas.android.com/apk/res/android">

<translate
android:duration="400"
android:fromXDelta="-100%p"
android:toXDelta="0" />
<alpha
android:duration="300"
android:fromAlpha="0.0"
android:toAlpha="1.0" />

</set>
定义滑入效果的同时也要定义滑出时的动画效果，即对动画资源的push_right_out.xml文件代码修改如下。<?xml version="1.0" encoding="utf-8"?>
<set xmlns:android="http://schemas.android.com/apk/res/android">

<translate
android:duration="400"
android:fromXDelta="0"
android:toXDelta="100%p" />
<alpha
android:duration="300"
android:fromAlpha="1.0"
android:toAlpha="0.0" />

</set>
在后台Java文件里引用该布局文件，并且定义用户手势，通过GestureDetector进行手势检测，当检测到用户手势操作时则使用动画效果。
在手势识别中判断手势是从左向右滑动还是从右向左滑动，要在OnGestureListener的onFling事件中根据滑动时起点与终点的坐标进行判断。当检测到用户手势操作时则使用动画效果。具体的Activity关键代码如下。public class Welcome extends Activity implements android.view. GestureDetector. OnGestureListener {
private int［］ imgs={R.drawable.coffe1,
R.drawable.coffee2
};
private GestureDetector gestureDetector=null;
private ViewFlipper viewFlipper=null;

private Activity mActivity=null;

@SuppressWarnings("deprecation")
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);

final Window win=getWindow();
win.setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, 
WindowManager.LayoutParams.FLAG_FULLSCREEN);
requestWindowFeature(Window.FEATURE_NO_TITLE); 
setContentView(R.layout.viewfilter);

mActivity=this;

viewFlipper=(ViewFlipper) findViewById(R.id.viewflipper);
gestureDetector=new GestureDetector(this,this);

for (int i=0; i<imgs.length; i++) {
ImageView iv=new ImageView(this);
iv.setImageResource(imgs［i］);
iv.setScaleType(ImageView.ScaleType.FIT_XY);
viewFlipper.addView(iv);
}
}

@Override
public boolean onTouchEvent(MotionEvent event) {
return gestureDetector.onTouchEvent(event);}

@Override
public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
if(e2.getX()-e1.getX()>120) {
if(viewFlipper.getDisplayedChild()==0) {
new Handler().postDelayed(new Runnable() {
@Override
public void run() 
Intent intent=new Intent(Welcome.this, MainActivity.class);
startActivity(intent);
overridePendingTransition(R.anim.alpha_in, R.anim.
alpha_out);
}
}, 1000);
}
Animation rInAnim=AnimationUtils.loadAnimation(mActivity, R.anim.push_right_in);
Animation rOutAnim=AnimationUtils.loadAnimation(mActivity, 
R.anim.push_right_out); 

viewFlipper.setInAnimation(rInAnim);
viewFlipper.setOutAnimation(rOutAnim);
viewFlipper.showPrevious();

return true;
} else if(e2.getX()-e1.getX()<-120) { 
if(viewFlipper.getDisplayedChild()==0) {
 new Handler().postDelayed(new Runnable() {
@Override
public void run() {
Intent intent=new Intent(Welcome.this, MainActivity.class);
startActivity(intent);
overridePendingTransition(R.anim.alpha_in, R.anim.
alpha_out);
}
}, 1000);
}
Animation lInAnim=AnimationUtils.loadAnimation (mActivity, R.anim. push_left_in);
Animation lOutAnim=AnimationUtils.loadAnimation (mActivity, 
R.anim. push_left_out);

viewFlipper.setInAnimation(lInAnim);
viewFlipper.setOutAnimation(lOutAnim);
viewFlipper.showNext();
}
return true;
}

@Override
public boolean onDown(MotionEvent e) {
return false;
}
@Override
public void onLongPress(MotionEvent e) {
}
@Override
public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {
return false;
}
@Override
public void onShowPress(MotionEvent e) {
}
@Override
public boolean onSingleTapUp(MotionEvent e) {
return false;
}
}
4.14.3项目说明
引导页的实现使用了Android的高级控件ViewFlipper，动画资源以及手势识别等知识。手势识别是手机开发人机交互的一种重要方式，在实际项目开发中应用场景非常多，读者应掌握这种技术。
小结
布局管理器的作用是根据屏幕大小，管理容器内的控件，自动适配组件在手机屏幕中的位置。本章讲述了Android常用布局管理器的用法及各自的特点。Android为用户提供了大量的控件，给平台开发者选择的空间，这也要求开发人员了解每一种控件以及其使用方式，了解控件的各属性和方法的应用，根据实际情况选择最合适的控件。文中除了介绍Android中的常用控件，还结合所学的布局管理内容给出了若干案例，用于巩固所学知识。本章还介绍了一些高级控件，它们在复杂的程序开发中经常用到。在所有的Android程序开发中都会大量使用到资源文件，本章全面系统地介绍了程序开发中所需要的各种资源文件。读者应重点掌握不同资源文件存放的位置、资源的属性、调用的方法等方面内容。熟练掌握并使用字符串资源、图片资源、值资源、风格与主题资源、动画资源等知识。学好使用资源文件也是更好地适应越来越发达的网络环境，适应程序国际化、本地化的必然趋势。
习题〖*2〗【选择题】1. 下面哪一个方法是 View 的强制刷新方法？（）

A. invalidate()B. paint()C. redraw()D. refresh()
2. 在TextView中获取文本内容的方法是()。
A. setTextB. getTextC. setStringD. getString
3. 如果将一个TextView的android:layout_height属性值设置为wrap_content，那么该组件将是以下哪种显示效果？()
A. 该文本域的宽度将填充父容器宽度
B. 该文本域的宽度仅占据该组件的实际宽度
C. 该文本域的高度将填充父容器高度
D. 该文本域的高度仅占据该组件的实际高度
4. EditText编辑框的提示信息是哪个？()
A. android:inputTypeB. android:text
C. android:digitsD. android:hint
5. Button的单击事件是()。
A. setOnClickListenerB. setOnCheckChangeListener
C. setOnMenuItemSelectedListenerD. setOnCheckedListener6. 单选按钮的选中状态，使用哪个属性？（）
A. android:checkedB. android:clickable
C. android:enableD. android:focusable
7. 若将多个单选按钮组合在一起，使用控件（）。
A. RadioGroupB. RadioC. RadioButtonD. Group
8. 复选框被选择事件通常用（）。
A. setOnClickListenerB. setOnCheckChangeListener
C. setOnMenuItemSelectedListenerD. setOnCheckedListener
9. 进度条中哪个属性是设置进度条样式的？（）
A. android:secondaryProgressB. android:progress 
C. android:maxD. style
10. 拖动条组件是哪个？（）

A. RatingBarB. ProgressBarC. SeekBarD. ScrollBar
11. 对于音乐播放器程序中的播放进度控制，使用哪个控件适合？
A. RatingBarB. ProgressBarC. SeekBarD. ScrollBar
12. 通过拖动改变屏幕亮度，使用哪个控件适合？（）
A. RatingBarB. ProgressBarC. SeekBarD. ScrollBar
13. ImageView中，哪个属性设置图片的填充方式？（）
A. android:adjustViewBoundsB. android:maxHeight
C. android:scaleTypeD. android:src
14. 关于适配器的说法正确的是（）。
A. 它主要是用来存储数据B. 它主要用来把数据绑定到组件上
C. 它主要用来解析数据D. 它主要用来存储XML数据
15. 能提供内容补全的控件是（）。
A. EditTextB. DatePicker
C. TimePickerD. AutoCompleteTextView
16. 下拉列表框控件是（）。
A. EditTextB. SpinnerC. ListViewD. Gallery
17. ListView使用中，有时还需要在里面加入按钮等控件，需要使用哪个Adapter？（）
A. ArrayAdapterB. SimpleAdapter
C. CursorAdapterD. BaseAdapter
18. 下列哪个是实现分组功能的列表？（）
A. ListViewB. Group
C. ExpandableListViewD. GroupListView
19. 下列用以显示一系列图像的是（）。
A. ImageViewB. Gallery
C. ImageSwitcherD. GridView
20. 使用哪个方法来监听触屏事件？（）
A. onKeyDownB. onKeyUpC. keyDownD. onTouchEvent
21. 下面文件(文件夹)中放置图片资源的一项是（）。
A. res/values/B. /values/strings.xm
C. /res/values/styles.xmlD.  /app/res/drawable/
22. 下面哪一项不是继承自AlertDialog的（）。
A. ProgressDialog B. DatePickerDialog  
C. ActionBarD. TimePickerDialog
23.  Android中不属于显示单位的是（）。
A. px B. dipC. dpiD.  sp
24. 下面哪一项不是Android中的菜单类型？（）
A. DateMenuB. SubMenuC. ContextMenuD. OptionsMenu
25. 下列说法错误的一项是（）。
A. Toast（提示）是Android中用来显示提示信息的一种机制
B. Notification（通知）是Android提供的出现在状态栏的提醒机制
C. Toast没有焦点且显示的时间有限，不会打断用户当前的操作，不能与用户交互
D. 当用户打开Notification之后，会显示通知信息，不可与用户进行交互，也不能处理用户选择事件
【简答题】
1. 如何给RadioButton按钮设置选择器？
2. 简述Android:gravity与android:layout_gravity的区别。
3. ListView事件处理方法是什么？如何获取选中项的值？
4. ListView如何优化处理？
5. 请写出创建一个菜单的步骤。
6. 请写出主题与样式的区别。
7. 请写出自定义样式的步骤。
8. 请写出关于继承样式的两种方式。5Fragment与ToolBar
1. 本章概述
通过本章的学习，掌握Fragment的创建和应用，Activity与Fragment之间的交互，最后掌握ToolBar的应用。
2. 本章重点与难点
1） 重点
（1） Fragment的创建和应用。
（2） ToolBar的应用。
2） 难点
（1） Activity与Fragment的综合应用。
（2） ToolBar的应用。
3. 重难点学习建议
本章主要帮助读者学习并掌握Android中非常重要的Fragment和ToolBar的应用。学习本章时，知识的广度逐渐扩大，建议读者勤于练习，勤于思考，对本教材提供的项目更是要多体会，多实践。想深入了解本章知识的读者可进行课后延伸阅读，加深理解。
5.1Fragment简介与应用场合
Fragment（碎片）是Android Honeycomb 3.0新增的概念，Fragment代表用户界面中一个活动的部分或者是一种行为能力，它可以有自己单独的用户界面，也可以单独接收用户输入和处理事件的消息。
在原来的设计理念中，手机的屏幕比较小，整个屏幕作为一个整体出现，应用程序运行过程就是在多个屏幕之间切换的过程。但是随着平板电脑的出现，这一切都随之改变。单个应用界面不一定占据整个屏幕。而且单个界面包含的内容更加丰富，许多时候仅需要更新界面的局部，而不是切换整个界面。因此，代表应用界面局部区域，并能单独与用户进行交互的组件Fragment应运而生。下面举个例子，以便更好地理解Fragment出现的意义。
例如，设计一个读新闻的程序，可以用一个Fragment显示标题列表，另一个Fragment显示选中标题的内容，这两个Fragment都在一个Activity上，并排显示。那么这两个Fragment都有自己的生命周期并响应自身感兴趣的事件。于是，不需要再像手机上那样用一个Activity显示标题列表，用另一个Activity显示新闻内容。现在有了Fragment可以把两者放在一个Activity上同时显示出来，如图5.1所示。
图5.1手机显示的Fragment
由此可以看出，使用Fragment可以让用户更加充分地利用平板的屏幕空间。
5.2创建Fragment
Fragment是Android 3.0以上版本引入的新事物，默认的包为android.app.FragmentManager，如果要兼容3.0以下版本就需要引入android.support.v4.app.Fragment包。这两个包对Fragment相同方法的定义有所不同，因此在import时，经常容易混淆导致程序报错，如下事项在使用前需要了解。
最低支持版本不同：
（1） android.app.Fragment 兼容的最低版本是android:minSdkVersion="11"，即3.0版。
（2） android.support.v4.app.Fragment 兼容的最低版本是android:minSdkVersion="4"，即1.6版。
（3） 需要导入jar包：  android.support.v4.app.Fragment，需要引入包： androidsupportv4.jar。
如果在Activity中要使用android.app.Fragment，需要满足以下三个条件。
（1） 当前的Activity直接继承Activity。
（2） 在方法中使用getFragmentManager().findFragmentById(XXX)获取Fragment对象。
（3） support.v4包中的方法一般都会加上support.，例如获取fragmentManager，就需要getSupportFragmentManager，而app包中的直接getFragmentManager即可。
创建一个MyFirstFragemt事例，应该继承Fragment或者其子类，覆写相应的方法。Fragment有两类，一类是具有UI界面的，Fragment作为ViewGroup组件的节点增加到当前的Activity界面；另一类是没有UI界面的，它可能只是作为后台的一个工作线程。这里创建的Fragment有用户界面，因此首先要声明一个用户界面。
【例5.1】Fragment应用案例。
本案例共有三个Java文件，其中两个是Fragment类的子类，一个是Activity的子类，程序能够显示图5.2右面的界面，接下来就对案例进行详尽的分析。
图5.2Fragment案例
activity_main.xml文件是Activity的布局文件，两个Fragment在界面上的位置关系就是在这个文件中进行的定义。activity_main.xml代码如下。<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="horizontal"
android:layout_width="match_parent" 
android:layout_height="match_parent">
<fragment android:name="edu.hrbeu.FragmentDemo.AFragment"
android:id="@+id/fragment_a" 
android:layout_weight="1"
android:layout_width="0px" 
android:layout_height="match_parent" />
<fragment android:name="edu.hrbeu.FragmentDemo.BFragment"
android:id="@+id/fragment_b" 
android:layout_weight="1"
android:layout_width="0px" 
android:layout_height="match_parent" />
</LinearLayout>
FragmentDemoActivity是该示例主界面的Activity，加载了activity_main.xml文件声明的界面布局。FragmentDemoActivity.java文件的完整代码如下。import android.os.Bundle;
import android.app.Activity;
import android.view.Menu;
public class FragmentDemoActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
}
Android系统会根据代码“setContentView(R.layout.main);”的内容加载界面布局文件activity_main.xml，然后通过activity_main.xml文件中对Fragment所在的“包+类”的描述，找到Fragment的实现类，并调用类中的onCreateView()函数绘制界面元素。
AFragment.java文件的核心代码如下。public class AFragment extends Fragment{
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
 Bundle savedInstanceState) {
//TODO Auto-generated method stub
return inflater.inflate(R.layout.fragment_a, container,false);
}
}
AFragment中只实现了onCreateView()函数，返回值是AFragment的视图，代码“return inflater.inflate(R.layout.frag_a，container，false);”使用inflate()函数，通过指定资源文件R.layout.frag_a获取AFragment的视图。
BFragment.java文件的核心代码如下。public class BFragment extends Fragment{
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
 Bundle savedInstanceState) {
//TODO Auto-generated method stub
return inflater.inflate(R.layout.fragment_b, container, false);
}
}
最后，给出fragment_a.xml文件的全部代码如下。<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:orientation="vertical" >
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="AFragment" />
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="这是AFragment的显示区域,通过这行文字可以看到与
BFragment的边界" />
<CheckBox
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="AF选项" />
<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="AF按钮" />
</LinearLayout>
fragment_b.xml文件的全部代码如下。<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:orientation="vertical" >
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="BAFragment" />
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="这是BFragment的显示区域,通过这行文字可以看到与
AFragment的边界" />
<CheckBox
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="BF选项" />
<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="BF按钮" />
</LinearLayout>
Fragment也可以通过代码动态添加，下面通过一个例子了解Fragment的动态添加。
【例5.2】Fragment的动态添加应用案例。
本案例程序能够显示图5.3的界面。
图5.3Fragment动态添加的案例图
activity_main.xml文件是Activity的布局文件，Fragment将显示在container组件中。<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".MainActivity5_2">
<LinearLayout
android:id="@+id/container"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:orientation="vertical" >
</LinearLayout>
</LinearLayout>
Fragment的布局文件的代码如下。<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".ContentFragment">
<TextView
android:layout_width="match_parent"
android:layout_height="match_parent"
android:textSize="32dp"
android:text="这是ContentFragment界面" />
</FrameLayout>
MainActivity是该示例主界面的Activity，加载了activity_main.xml文件声明的界面布局。MainActivity.java文件的完整代码如下。import android.app.FragmentManager;
import android.app.FragmentTransaction;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
FragmentManager fragmentManager=this.getFragmentManager();
FragmentTransaction tx=fragmentManager.beginTransaction();
//第一个参数是activity_main布局文件中的linearlayout 的id,第二个参
//数是 Framgment 的类名
tx.add(R.id.container1, new ContentFragment());
tx.commit();
}
}
Fragment的界面代码如下。import android.app.Fragment;
import android.os.Bundle;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
public class ContentFragment extends Fragment {
public ContentFragment() {
//Required empty public constructor
}
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
//Inflate the layout for this fragment
Log.v("ContentFragment", "onCreateView");
return inflater.inflate(R.layout.fragment_content, container, false);
}
}
5.3Fragment生命周期
为了更好地使用Fragment，有必要深入了解Fragment的生命周期。因为Fragment必须嵌入在Acitivity中使用，所以Fragment的生命周期和它所在的Activity是密切相关的。Activity直接影响它所包含的Fragment的生命周期，所以对Activity的某个生命周期方法的调用也会产生对Fragment相同方法的调用。例如，当Activity的onPause()方法被调用时，它所包含的所有Fragment的onPause()方法都会被调用。当然，Fragment比Activity还要多出几个生命周期回调方法，这些额外的方法是为了与Activity的交互而设立的。下面是具体方法的说明，如表5.1所示。表5.1Fragment的生命周期方法
方法描述onAttach()当Fragment被加入到Activity时调用（在这个方法中可以获得所在的Activity）onCreate()完成Fragment的初始化创建onCreateView()当Activity要得到Fragment的layout（界面）时，调用此方法，Fragment在其中创建自己的layoutonActivityCreated()当Activity要得到Fragment的layout时，调用此方法，Fragment在其中创建自己的layoutonStart()Fragment可见，当主Activity处于started状态后执行onResume()Fragment能与用户交互，当主Activity处于resumed状态后执行onPause()Fragment不再与用户交互，可能在主Activity将要处于paused前执行，可能该Fragment被修改onStop()Fragment不可见，可能在主Activity将要处于stopped前执行，可能该Fragment被修改onDestroyView()当Fragment的layout被销毁时被调用，允许该Fragment清理视图相关资源onDestroy()清理视图state信息onDetach()当Fragment被从Activity中删除时被调用。该Fragment不再与Activity关联一旦Activity进入resumed状态（也就是running状态），就可以自由地添加和删除Fragment了。因此，只有当Activity在resumed状态时，Fragment的生命周期才能独立地运转，其他时候是依赖于Activity的生命周期变化的。
【例5.3】Fragment的生命周期以及与Activity的关系。import android.support.v4.app.FragmentTransaction;
import android.os.Bundle;
import android.support.v4.app.Fragment;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
public class MainActivity5_3 extends AppCompatActivity {
static String Tag="Fragment_Activity";

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Log.i(Tag, "in onCreate()......");
setContentView(R.layout.activity_main5_3);
addFragment();
Log.i(Tag, "out onCreate()......");
}

@Override
protected void onDestroy() {
//TODO Auto-generated method stub
Log.i(Tag, "in onDestroy()......");
super.onDestroy();
Log.i(Tag, "out onDestroy()......");
}
void addFragment() {
Fragment newFragment=new Fragmentlife();
FragmentTransaction ft=this.getSupportFragmentManager().
beginTransaction();
 ft.add(android.R.id.content,newFragment,"first");
ft.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_OPEN);
ft.commit();
}
}
Fragmentlife.java的代码如下。import android.app.Activity;
import android.os.Bundle;
import android.support.v4.app.Fragment;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
public class Fragmentlife extends Fragment {
static String Tag="Fragmentlife";
@Override
public void onCreate(Bundle savedInstanceState) {
//TODO Auto-generated method stub
Log.i(Tag, "in onCreate().......");
super.onCreate(savedInstanceState);
Log.i(Tag, "in outCreate().......");
}
@Override
public void onActivityCreated(Bundle savedInstanceState) {
//TODO Auto-generated method stub
Log.i(Tag, "in onActivityCreated().......");
super.onActivityCreated(savedInstanceState);
Log.i(Tag, "out onActivityCreated().......");
}
@Override
public void onDestroyView() {
//TODO Auto-generated method stub
Log.i(Tag, "in onDestroyView().......");
super.onDestroyView();
Log.i(Tag, "out onDestroyView().......");
}
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
//TODO Auto-generated method stub
Log.i(Tag, "in onCreateView().......");
View v=inflater.inflate(R.layout.fragmentlife, container,false);
Log.i(Tag, "out onCreateView().......");
return v;
}
@Override
public void onAttach(Activity activity) {
//TODO Auto-generated method stub
Log.i(Tag, "in onAttach().......");
super.onAttach(activity);
Log.i(Tag, "out onAttach().......");
}
}
运行程序，切换到LogCat子窗口，可以看到图5.4所示的结果。