Android知识点总结(一)

Android核心

阐述下activity生命周期

创建 onCreate - 启动onStart – 开始 onResume – 暂停 onPause – 结束 onStop – 销毁onDestroy

每一个活动（ Activity ）都处于某一个状态，对于开发者来说，是无法控制其应用程序处于某一个状态的，这些均由系统来完成。 但是当一个活动的状态发生改变的时候，开发者可以通过调用 onXX() 的方法获取到相关的通知信息。

在实现 Activity 类的时候，通过覆盖（ override ）这些方法即可在你需要处理的时候来调用。

• onCreate ：当活动第一次启动的时候，触发该方法，可以在此时完成活动的初始化工作。 onCreate 方法有一个参数，该参数可以为空（ null ），也可以是之前调用 onSaveInstanceState（）方法保存的状态信息。

• onStart ：该方法的触发表示所属活动将被展现给用户。

• onResume ：当一个活动和用户发生交互的时候，触发该方法。

• onPause ：当一个正在前台运行的活动因为其他的活动需要前台运行而转入后台运行的时候，触发该方法。这时候需要将活动的状态持久化，比如正在编辑的数据库记录等。

• onStop ：当一个活动不再需要展示给用户的时候，触发该方法。如果内存紧张，系统会直接结束这个活动，而不会触发 onStop 方法。 所以保存状态信息是应该在onPause时做，而不是onStop时做。活动如果没有在前台运行，都将被停止或者Linux管理进程为了给新的活动预留足够的存储空间而随时结束这些活动。因此对于开发者来说，在设计应用程序的时候，必须时刻牢记这一原则。在一些情况下，onPause方法或许是活动触发的最后的方法，因此开发者需要在这个时候保存需要保存的信息。

• onRestart ：当处于停止状态的活动需要再次展现给用户的时候，触发该方法。

• onDestroy ：当活动销毁的时候，触发该方法。和 onStop 方法一样，如果内存紧张，系统会直接结束这个活动而不会触发该方法。

• onSaveInstanceState ：系统调用该方法，允许活动保存之前的状态，比如说在一串字符串中的光标所处的位置等。 通常情况下，开发者不需要重写覆盖该方法，在默认的实现中，已经提供了自动保存活动所涉及到的用户界面组件的所有状态信息。

android四大组件

1.活动：
Android 中，Activity是所有程序的根本，所有程序的流程都运行在Activity 之中，Activity可以算是开发者遇到的最频繁，也是Android 当中最基本的模块之一。在Android的程序当中，Activity 一般代表手机屏幕的一屏。如果把手机比作一个浏览器，那么Activity就相当于一个网页。在Activity 当中可以添加一些Button、Check box 等控件。可以看到Activity 概念和网页的概念相当类似。一般一个Android 应用是由多个Activity 组成的。这多个Activity 之间可以进行相互跳转，例如，按下一个Button按钮后，可能会跳转到其他的Activity。和网页跳转稍微有些不一样的是，Activity 之间的跳转有可能返回值，例如，从Activity A 跳转到Activity B，那么当Activity B 运行结束的时候，有可能会给Activity A 一个返回值。这样做在很多时候是相当方便的。 　　当打开一个新的屏幕时，之前一个屏幕会被置为暂停状态，并且压入历史堆栈中。用户可以通过回退操作返回到以前打开过的屏幕。可以选择性的移除一些没有必要保留的屏幕，因为Android会把每个应用的开始到当前的每个屏幕保存在堆栈中。

2.服务
Service 是android 系统中的一种组件，它跟Activity 的级别差不多，但是他不能自己运行，只能后台运行，并且可以和其他组件进行交互。Service 是没有界面的长生命周期的代码。Service是一种程序，它可以运行很长时间，但是它却没有用户界面。这么说有点枯燥，来看个例子。打开一个音乐播放器的程序，这个时候若想上网了，那么，打开Android浏览器，这个时候虽然已经进入了浏览器这个程序，但是，歌曲播放并没有停止，而是在后台继续一首接着一首的播放。其实这个播放就是由播放音乐的Service进行控制。当然这个播放音乐的Service也可以停止，例如，当播放列表里边的歌曲都结束，或者用户按下了停止音乐播放的快捷键等。Service 可以在和多场合的应用中使用，比如播放多媒体的时候用户启动了其他Activity这个时候程序要在后台继续播放，比如检测SD 卡上文件的变化，再或者在后台记录地理信息位置的改变等等，总之服务嘛，总是藏在后头的。

开启Service有两种方式: （1） Context.startService（）：Service会经历onCreate -> onStart（如果Service还没有运行，则android先调用onCreate（）然后调用onStart（）； 　　　　如果Service已经运行，则只调用onStart（），所以一个Service的onStart方法可能会重复调用多次 ）； 　　　　StopService的时候直接onDestroy，如果是调用者自己直接退出而没有调用StopService的话，Service会一直在后台运行。该Service的调用者再启动起来后可以通过stopService关闭Service。 　　*注意:多次调用Context.startservice（）不会嵌套（即使会有相应的onStart（）方法被调用），所以无论同一个服务被启动了多少次，一旦调用Context.stopService（）或者StopSelf（），他都会被停止。 　　补充说明：传递给StartService（0的Intent对象会传递给onStart（）方法。调用顺序为：onCreate --> onStart（可多次调用) --> onDestroy。 （2） Context.bindService（）：Service会经历onCreate（） -->onBind（），onBind将返回给客户端一个IBind接口实例，IBind允许客户端回调服务的方法，比如得到Service运行的状态或其他操作。这个时候把调用者（Context，例如Activity）会和Service绑定在一起，Context退出了，Srevice就会调用onUnbind --> onDestroyed相应退出，所谓绑定在一起就共存亡了。

3.广播接收器
在Android 中，Broadcast是一种广泛运用的在应用程序之间传输信息的机制。而BroadcastReceiver 是对发送出来的Broadcast进行过滤接受并响应的一类组件。可以使用BroadcastReceiver 来让应用对一个外部的事件做出响应。这是非常有意思的，例如，当电话呼入这个外部事件到来的时候，可以利用BroadcastReceiver 进行处理。例如，当下载一个程序成功完成的时候，仍然可以利用BroadcastReceiver 进行处理。BroadcastReceiver不能生成UI，也就是说对于用户来说不是透明的，用户是看不到的。BroadcastReceiver通过NotificationManager 来通知用户这些事情发生了。BroadcastReceiver 既可以在AndroidManifest.xml 中注册，也可以在运行时的代码中使用Context.registerReceiver（)进行注册。只要是注册了，当事件来临的时候，即使程序没有启动，系统也在需要的时候启动程序。各种应用还可以通过使用Context.sendBroadcast （） 将它们自己的Intent Broadcasts广播给其他应用程序。

4.内容提供者
Content Provider 是Android提供的第三方应用数据的访问方案。 　　在Android中，对数据的保护是很严密的，除了放在SD卡中的数据，一个应用所持有的数据库、文件等内容，都是不允许其他直接访问的。Andorid当然不会真的把每个应用都做成一座孤岛，它为所有应用都准备了一扇窗，这就是Content Provider。应用想对外提供的数据，可以通过派生Content Provider类， 封装成一枚Content Provider，每个Content Provider都用一个uri作为独立的标识，形如：content://com.xxxxx。所有东西看着像REST的样子，但实际上，它比REST 更为灵活。和REST类似，uri也可以有两种类型，一种是带id的，另一种是列表的，但实现者不需要按照这个模式来做，给id的uri也可以返回列表类型的数据，只要调用者明白，就无妨，不用苛求所谓的REST。

service和IntentSerview的区别

service是同步的，而intentService是异步的。

intentService:异步处理服务，新开一个线程：handlerThread在线程中发消息，然后接受处理完成后，会清理线程，并且关掉服务。

IntentService有以下特点：

（1） 它创建了一个独立的工作线程来处理所有的通过onStartCommand()传递给服务的intents。

（2） 创建了一个工作队列，来逐个发送intent给onHandleIntent()。

（3） 不需要主动调用stopSelft()来结束服务。因为，在所有的intent被处理完后，系统会自动关闭服务。

（4） 默认实现的onBind()返回null

（5） 默认实现的onStartCommand()的目的是将intent插入到工作队列中

继承IntentService的类至少要实现两个函数：构造函数和onHandleIntent()函数。要覆盖IntentService的其它函数时，注意要通过super调用父类的对应的函数。

• activity_main.xml

• MainActivity.java

public class MainActivity extends AppCompatActivity {
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
    public void test(View view) {
        //Intent intent = new Intent("myService");
        Intent intent = new Intent("intentService");
        startService(intent);
}
}

• MyService.java

package com.miao.myintentservice;
import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.util.Log;
public class MyService extends Service {
    public MyService() {
    }
    public IBinder onBind(Intent intent) {
        throw new UnsupportedOperationException("Not yet implemented");
    }
     public int onStartCommand(Intent intent, int flags, int startId) {
        Log.i("miao","MyService onStartCommand ..." + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return super.onStartCommand(intent, flags, startId);
    }
}

• TestIntentService.java

package com.miao.myintentservice;
import android.app.IntentService;
import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.util.Log;
public class TestIntentService extends IntentService {
    public TestIntentService() {
        super("miao");
    }
       public void onCreate() {
        super.onCreate();
    }
    /*
        onStartCommand的返回值：
        1.START_STIKY:粘性的，被系统Kill掉，会重新启动，但intent的值为null。
        2.START_NOT_STIKY:非粘性的，被系统Kill掉，不会重新启动。
        3.START_REDELIVER_INTETN:重传INTENT,被系统KILL掉的话，会重新启动，并传入intent值。
     */
       public int onStartCommand(Intent intent, int flags, int startId) {
        return super.onStartCommand(intent, flags, startId);
    }
    public IBinder onBind(Intent intent) {
        throw new UnsupportedOperationException("Not yet implemented");
    }
       protected void onHandleIntent(Intent intent) {
        Log.i("miao", "TestIntentService onHandleIntent ..." + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Android 应用的结构是什么？

• src 目录
  是源代码目录， 所有允许用户修改的 java 文件和用户自己添加的 java 文件都保存在这个目录中

• gen 目录
  是 1.5 版本新增的目录，用来保存 ADT 自动生成的 java 文件，例如 R.java 或 AIDL 文件。注意：

• R．java 文件（非常重要）
  a) R.java 文件是 ADT 自动生成的文件，包含对 drawable、layout 和 values 目录内的资源的引用指针，Android 程序能够直接通过 R 类引用目录中的资源
  b) R.java 文件不能手工修改，如果向资源目录中增加或删除了资源文件，则需要在工程名称上右击，选择 Refresh 来更新 R.java 文件中的代码
  c) R 类包含的几个内部类，分别与资源类型相对应，资源 ID 便保存在这些内部类中，例如子类drawable 表示图像资源，内部的静态变量 icon 表示资源名称，其资源 ID 为 0x7f020000。一般情况下，资源名称与资源文件名相同

• android.jar 文件
  是 Android 程序所能引用的函数库文件，Android 通过平台所支持 API 都包含在这个文件中

• assets 目录
  用来存放原始格式的文件，例如音频文件、视频文件等二进制格式文件。此目录中的资源不能被 R.java 文件索引。，所以只能以资截流的形式读取。一般情况下为空

• layout 目录
  用来存放我们为每个界面写的布局文件

• Strings.xml 文件
  是程序中的一些字符串的引用

• AndroidManifest.xml
  是 XML 格式的 Android 程序声明文件，包含了 Android 系统运行Android 程序前所必须掌握的重要信息，这些信息包含应用程序名称、图标、包名称、模块组成、授权和 SDK 最低版本等，而且每个 Android 程序必须在根目录下包含一个 AndroidManifest.xml文件
  注：AndroidMainfest.xml 文件：

1. AndroidManifest.xml 文件的根元素是 manifest，包含了 xmlns:android、package、
   android:versionCode 和 android:versionName 共 4 个属性
2. xmlns:android 定义了 Android 的命名空间，值为
   http://schemas.android.com/apk/res/android
3. package 定义了应用程序的包名称
4. android:versionCode 定义了应用程序的版本号，是一个整数值，数值越大说明版本越新，但仅在程序内部使用，并不提供给应用程序的使用者
5. android:versionName 定义了应用程序的版本名称，是一个字符串，仅限于为用户提供一个版本标识
6. manifest 元素仅能包含一个 application 元素， application 元素中能够声明 Android 程序中最重要的四个组成部分，包括 Activity、Service、BroadcastReceiver 和 ContentProvider，所定义的属性将影响所有组成部分
7. android:icon 定义了 Android 应用程序的图标，其中@drawable/icon 是一种资源引用方式，表示资源类型是图像，资源名称为 icon，对应的资源文件为 res/drawable 目录下的 icon.png
8. android:label 则定义了 Android 应用程序的标签名称default.properties 文件记录 Android 工程的相关设置，该文件不能手动修改，需右键单击工程名称，选择“Properties”进行修改

Android 应用中如何保存数据

数据存储在开发中是使用最频繁的，在这里主要介绍Android平台中实现数据存储的5种方式，分别是：

1. 使用SharedPreferences存储数据

2. 文件存储数据

3. SQLite数据库存储数据

4. 使用ContentProvider存储数据

5. 网络存储数据

下面将为大家一一详细介绍。

第一种： 使用SharedPreferences存储数据

SharedPreferences是Android平台上一个轻量级的存储类，主要是保存一些常用的配置比如窗口状态，一般在Activity中

重载窗口状态onSaveInstanceState保存一般使用SharedPreferences完成，它提供了Android平台常规的Long长 整形、Int整形、String字符串型的保存。

它是什么样的处理方式呢? SharedPreferences类似过去Windows系统上的ini配置文件，

但是它分为多种权限，可以全局共享访问，android123提示最终是以xml方式来保存，

整体效率来看不是特别的高，对于常规的轻量级而言比SQLite要好不少，

如果真的存储量不大可以考虑自己定义文件格式。

xml 处理时Dalvik会通过自带底层的本地XML Parser解析，比如XMLpull方式，这样对于内存资源占用比较好。

它的本质是基于XML文件存储key-value键值对数据，通常用来存储一些简单的配置信息。

其存储位置在/data/data/<包名>/shared_prefs目录下。

SharedPreferences对象本身只能获取数据而不支持存储和修改，存储修改是通过Editor对象实现。

实现SharedPreferences存储的步骤如下：

一、根据Context获取SharedPreferences对象

二、利用edit()方法获取Editor对象。

三、通过Editor对象存储key-value键值对数据。

四、通过commit()方法提交数据。

下面是示例代码：

public class MainActivity extends Activity {
      public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.main);
        //获取SharedPreferences对象
        Context ctx = MainActivity.this;
        SharedPreferences sp = ctx.getSharedPreferences("SP", MODE_PRIVATE);
        //存入数据
        Editor editor = sp.edit();
        editor.putString("STRING_KEY", "string");
        editor.putInt("INT_KEY", 0);
        editor.putBoolean("BOOLEAN_KEY", true);
        editor.commit();
        //返回STRING_KEY的值
        Log.d("SP", sp.getString("STRING_KEY", "none"));
        //如果NOT_EXIST不存在，则返回值为"none"
        Log.d("SP", sp.getString("NOT_EXIST", "none"));
     }
}

这段代码执行过后，即在/data/data/com.test/shared_prefs目录下生成了一个SP.xml文件，一个应用可以创建多个这样的xml文件。

SharedPreferences对象与SQLite数据库相比，免去了创建数据库，创建表，写SQL语句等诸多操作，相对而言更加方便，简洁。

但是SharedPreferences也有其自身缺陷，

比如其职能存储boolean，int，float，long和String五种简单的数据类型，比如其无法进行条件查询等。

所以不论SharedPreferences的数据存储操作是如何简单，它也只能是存储方式的一种补充，而无法完全替代如SQLite数据库这样的其他数据存储方式。

第二种： 文件存储数据

关于文件存储，Activity提供了openFileOutput()方法可以用于把数据输出到文件中，具体的实现过程与在J2SE环境中保存数据到文件中是一样的。

文件可用来存放大量数据，如文本、图片、音频等。

默认位置：/data/data/<包>/files/.。

代码示例：

public void save() {
        try {

            FileOutputStream outStream=this.openFileOutput("a.txt",Context.MODE_WORLD_READABLE);

            outStream.write(text.getText().toString().getBytes());

            outStream.close();

            Toast.makeText(MyActivity.this,"Saved",Toast.LENGTH_LONG).show();

        } catch (FileNotFoundException e) {

            return;

        }

        catch (IOException e){

            return ;

        }


 }

openFileOutput()方法的第一参数用于指定文件名称，不能包含路径分隔符“/” ，如果文件不存在，Android 会自动创建它。

创建的文件保存在/data/data//files目录，

如： /data/data/cn.itcast.action/files/itcast.txt ，

通过点击Eclipse菜单“Window”-“Show View”-“Other”，在对话窗口中展开android文件夹，

选择下面的File Explorer视图，然后在File Explorer视图中展开/data/data//files目录就可以看到该文件。

openFileOutput()方法的第二参数用于指定操作模式，有四种模式，分别为：

Context.MODE_PRIVATE = 0

Context.MODE_APPEND = 32768

Context.MODE_WORLD_READABLE = 1

Context.MODE_WORLD_WRITEABLE = 2

Context.MODE_PRIVATE：为默认操作模式，代表该文件是私有数据，只能被应用本身访问，

在该模式下，写入的内容会覆盖原文件的内容，如果想把新写入的内容追加到原文件中。可以使用Context.MODE_APPEND

Context.MODE_APPEND：模式会检查文件是否存在，存在就往文件追加内容，否则就创建新文件。

Context.MODE_WORLD_READABLE和Context.MODE_WORLD_WRITEABLE用来控制其他应用是否有权限读写该文件。

MODE_WORLD_READABLE：表示当前文件可以被其他应用读取；

MODE_WORLD_WRITEABLE：表示当前文件可以被其他应用写入。

如果希望文件被其他应用读和写，
可以传入： openFileOutput("itcast.txt", Context.MODE_WORLD_READABLE + Context.MODE_WORLD_WRITEABLE);
android有一套自己的安全模型，当应用程序(.apk)在安装时系统就会分配给他一个userid，
当该应用要去访问其他资源比如文件的时候，就需要userid匹配。

默认情况下，任何应用创建的文件，sharedpreferences，数据库都应该是私有的（位于/data/data//files），其他程序无法访问。

除非在创建时指定了Context.MODE_WORLD_READABLE或者Context.MODE_WORLD_WRITEABLE ，只有这样其他程序才能正确访问。

读取文件示例：

public void load()
{

    try {

        FileInputStream inStream=this.openFileInput("a.txt");

        ByteArrayOutputStream stream=new ByteArrayOutputStream();

        byte[] buffer=new byte[1024];

        int length=-1;
    while((length=inStream.read(buffer))!=-1)   {

            stream.write(buffer,0,length);

        }
        stream.close();

        inStream.close();

        text.setText(stream.toString());

        Toast.makeText(MyActivity.this,"Loaded",Toast.LENGTH_LONG).show();

    } catch (FileNotFoundException e) {

        e.printStackTrace();

    }
    catch (IOException e){
        return ;
    }
}

对于私有文件只能被创建该文件的应用访问，如果希望文件能被其他应用读和写，可以在创建文件时，

指定Context.MODE_WORLD_READABLE和Context.MODE_WORLD_WRITEABLE权限。

Activity还提供了getCacheDir()和getFilesDir()方法：

getCacheDir()方法用于获取/data/data//cache目录 getFilesDir()方法用于获取/data/data//files目录。

把文件存入SDCard：

使用Activity的openFileOutput()方法保存文件，文件是存放在手机空间上，一般手机的存储空间不是很大，存放些小文件还行，如果要存放像视频这样的大文件，是不可行的。

对于像视频这样的大文件，我们可以把它存放在SDCard。

SDCard是干什么的？你可以把它看作是移动硬盘或U盘。 在模拟器中使用SDCard，你需要先创建一张SDCard卡（当然不是真的SDCard，只是镜像文件）。

创建SDCard可以在Eclipse创建模拟器时随同创建，也可以使用DOS命令进行创建，

如下： 在Dos窗口中进入android SDK安装路径的tools目录，输入以下命令创建一张容量为2G的SDCard，文件后缀可以随便取，

建议使用.img： mksdcard 2048M D:\AndroidTool\sdcard.img 在程序中访问SDCard，你需要申请访问SDCard的权限。

在AndroidManifest.xml中加入访问SDCard的权限如下:

要往SDCard存放文件，程序必须先判断手机是否装有SDCard，并且可以进行读写。

注意：访问SDCard必须在AndroidManifest.xml中加入访问SDCard的权限。

if(Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)){ 
    File sdCardDir = Environment.getExternalStorageDirectory();//获取SDCard目录         
    File saveFile = new File(sdCardDir, “a.txt”);

        FileOutputStream outStream = new FileOutputStream(saveFile);

        outStream.write("test".getBytes());

        outStream.close();


}

Environment.getExternalStorageState()方法用于获取SDCard的状态，如果手机装有SDCard，并且可以进行读写，

那么方法返回的状态等于Environment.MEDIA_MOUNTED。

Environment.getExternalStorageDirectory()方法用于获取SDCard的目录，当然要获取SDCard的目录，你也可以这样写：

 File sdCardDir = new File("/sdcard"); //获取SDCard目录 

 File saveFile = new File(sdCardDir, "itcast.txt"); 

 //上面两句代码可以合成一句： 

 File saveFile = new File("/sdcard/a.txt"); 

 FileOutputStream outStream = new FileOutputStream(saveFile); 

 outStream.write("test".getBytes()); 

 outStream.close();

第三种： SQLite数据库存储数据

SQLite是轻量级嵌入式数据库引擎，它支持 SQL 语言，并且只利用很少的内存就有很好的性能。此外它还是开源的，任何人都可以使用它。

许多开源项目（(Mozilla, PHP, Python）都使用了 SQLite.SQLite 由以下几个组件组成：SQL 编译器、内核、后端以及附件。

SQLite 通过利用虚拟机和虚拟数据库引擎（VDBE），使调试、修改和扩展 SQLite 的内核变得更加方便。

特点：

面向资源有限的设备，

没有服务器进程,

所有数据存放在同一文件中跨平台，

可自由复制。

SQLite 内部结构：

SQLite 基本上符合 SQL-92 标准，和其他的主要 SQL 数据库没什么区别。它的优点就是高效，Android 运行时环境包含了完整的 SQLite。

SQLite 和其他数据库最大的不同就是对数据类型的支持，创建一个表时，可以在 CREATE TABLE 语句中指定某列的数据类型，

但是你可以把任何数据类型放入任何列中。当某个值插入数据库时，SQLite 将检查它的类型。

如果该类型与关联的列不匹配，则 SQLite 会尝试将该值转换成该列的类型。

如果不能转换，则该值将作为其本身具有的类型存储。

比如可以把一个字符串（String）放入 INTEGER 列。SQLite 称这为“弱类型”（manifest typing.）。

此外，SQLite 不支持一些标准的 SQL 功能，特别是外键约束（FOREIGN KEY constrains），

嵌套 transcaction 和 RIGHT OUTER JOIN 和 FULL OUTER JOIN, 还有一些 ALTER TABLE 功能。

除了上述功能外，SQLite 是一个完整的 SQL 系统，拥有完整的触发器，交易等等。

Android 集成了 SQLite 数据库 Android 在运行时（run-time）集成了 SQLite，所以每个 Android 应用程序都可以使用 SQLite 数据库。

对于熟悉 SQL 的开发人员来时，在 Android 开发中使用 SQLite 相当简单。但是，由于 JDBC 会消耗太多的系统资源，所以 JDBC 对于手机这种内存受限设备来说并不合适。

因此，Android 提供了一些新的 API 来使用 SQLite 数据库，Android 开发中，程序员需要学使用这些 API。

数据库存储在 data/< 项目文件夹 >/databases/ 下。 Android 开发中使用 SQLite 数据库 Activites 可以通过 Content Provider 或者 Service 访问一个数据库。

下面会详细讲解如果创建数据库，添加数据和查询数据库。 创建数据库 Android 不自动提供数据库。

在 Android 应用程序中使用 SQLite，必须自己创建数据库，然后创建表、索引，填充数据。

Android 提供了 SQLiteOpenHelper 帮助你创建一个数据库，

你只要继承 SQLiteOpenHelper 类，就可以轻松的创建数据库。

SQLiteOpenHelper 类根据开发应用程序的需要，封装了创建和更新数据库使用的逻辑。

SQLiteOpenHelper 的子类，至少需要实现三个方法：

1 构造函数，调用父类 SQLiteOpenHelper 的构造函数。

这个方法需要四个参数：上下文环境（例如，一个 Activity），数据库名字，一个可选的游标工厂（通常是 Null），一个代表你正在使用的数据库模型版本的整数。

2 onCreate（）方法，它需要一个 SQLiteDatabase 对象作为参数，根据需要对这个对象填充表和初始化数据。

3 onUpgrage() 方法，它需要三个参数，一个 SQLiteDatabase 对象，一个旧的版本号和一个新的版本号，这样你就可以清楚如何把一个数据库从旧的模型转变到新的模型。

下面示例代码展示了如何继承 SQLiteOpenHelper 创建数据库：

public class DatabaseHelper extends SQLiteOpenHelper {    
  DatabaseHelper(Context context, String name, CursorFactory cursorFactory, int version) 

  {     

    super(context, name, cursorFactory, version);     

     }     

     

     @Override    

     public void onCreate(SQLiteDatabase db) {     

         // TODO 创建数据库后，对数据库的操作     

     }     

     

     @Override    

 public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {     

         // TODO 更改数据库版本的操作     

     }     

     

 @Override    

 public void onOpen(SQLiteDatabase db) {     

         super.onOpen(db);       

         // TODO 每次成功打开数据库后首先被执行     

     }     

 }

接下来讨论具体如何创建表、插入数据、删除表等等。

调用 getReadableDatabase() 或 getWriteableDatabase() 方法，你可以得到 SQLiteDatabase 实例，具体调用那个方法，取决于你是否需要改变数据库的内容：

 db=(new DatabaseHelper(getContext())).getWritableDatabase();        return (db == null) ? false : true;  

上面这段代码会返回一个 SQLiteDatabase 类的实例，使用这个对象，你就可以查询或者修改数据库。

当你完成了对数据库的操作（例如你的 Activity 已经关闭），需要调用 SQLiteDatabase 的 Close() 方法来释放掉数据库连接。

创建表和索引 为了创建表和索引，需要调用 SQLiteDatabase 的 execSQL() 方法来执行 DDL 语句。如果没有异常，这个方法没有返回值。

例如，你可以执行如下代码：

db.execSQL("CREATE TABLE mytable (_id INTEGER PRIMARY KEY AUTOINCREMENT, title TEXT, value REAL);");

这条语句会创建一个名为 mytable 的表，表有一个列名为 _id，并且是主键，

这列的值是会自动增长的整数（例如，当你插入一行时，SQLite 会给这列自动赋值），另外还有两列：title( 字符 ) 和 value( 浮点数 )。

SQLite 会自动为主键列创建索引。 通常情况下，第一次创建数据库时创建了表和索引。

如果你不需要改变表的 schema，不需要删除表和索引 . 删除表和索引，需要使用 execSQL() 方法调用 DROP INDEX 和 DROP TABLE 语句。

给表添加数据 上面的代码，已经创建了数据库和表，现在需要给表添加数据。有两种方法可以给表添加数据。

像上面创建表一样，你可以使用 execSQL() 方法执行 INSERT, UPDATE, DELETE 等语句来更新表的数据。execSQL() 方法适用于所有不返回结果的 SQL 语句。

例如： db.execSQL("INSERT INTO widgets (name, inventory)"+ "VALUES ('Sprocket', 5)");

另一种方法是使用 SQLiteDatabase 对象的 insert(), update(), delete() 方法。这些方法把 SQL 语句的一部分作为参数。

示例如下：

 ContentValues cv=new ContentValues(); 

 cv.put(Constants.TITLE, "example title"); 

 cv.put(Constants.VALUE, SensorManager.GRAVITY_DEATH_STAR_I); 

 db.insert("mytable", getNullColumnHack(), cv); 

update（）方法有四个参数，分别是表名，表示列名和值的 ContentValues 对象，

可选的 WHERE 条件和可选的填充 WHERE 语句的字符串，这些字符串会替换 WHERE 条件中的“？”标记。

update() 根据条件，更新指定列的值，所以用 execSQL() 方法可以达到同样的目的。 WHERE 条件和其参数和用过的其他 SQL APIs 类似。

例如：

String[] parms=new String[] {"this is a string"};

db.update("widgets", replacements, "name=?", parms);

delete() 方法的使用和 update() 类似，使用表名，可选的 WHERE 条件和相应的填充 WHERE 条件的字符串。

查询数据库 类似 INSERT, UPDATE, DELETE，有两种方法使用 SELECT 从 SQLite 数据库检索数据。

1 ．使用 rawQuery() 直接调用 SELECT 语句； 使用 query() 方法构建一个查询。

Raw Queries 正如 API 名字，rawQuery() 是最简单的解决方法。通过这个方法你就可以调用 SQL SELECT 语句。

例如： Cursor c=db.rawQuery( "SELECT name FROM sqlite_master WHERE type='table' AND name='mytable'", null);

在上面例子中，我们查询 SQLite 系统表（sqlite_master）检查 table 表是否存在。

返回值是一个 cursor 对象，这个对象的方法可以迭代查询结果。 如果查询是动态的，使用这个方法就会非常复杂。

例如，当你需要查询的列在程序编译的时候不能确定，这时候使用 query() 方法会方便很多。

Regular Queries query() 方法用 SELECT 语句段构建查询。SELECT 语句内容作为 query() 方法的参数，

比如：要查询的表名，要获取的字段名，WHERE 条件，包含可选的位置参数，去替代 WHERE 条件中位置参数的值，GROUP BY 条件，HAVING 条件。

除了表名，其他参数可以是 null。所以，以前的代码段可以可写成：

 String[] columns={"ID", "inventory"}; 

 String[] parms={"snicklefritz"}; 
 Cursor result=db.query("widgets", columns, "name=?",parms, null, null, null);   

使用游标

不管你如何执行查询，都会返回一个 Cursor，这是 Android 的 SQLite 数据库游标，

使用游标，你可以：

通过使用 getCount() 方法得到结果集中有多少记录；

通过 moveToFirst(), moveToNext(), 和 isAfterLast() 方法遍历所有记录；

通过 getColumnNames() 得到字段名；

通过 getColumnIndex() 转换成字段号；

通过 getString()，getInt() 等方法得到给定字段当前记录的值；

通过 requery() 方法重新执行查询得到游标；

通过 close() 方法释放游标资源；

例如，下面代码遍历 mytable 表：

Cursor result=db.rawQuery("SELECT ID, name, inventory FROM mytable");     
result.moveToFirst(); 

    while (!result.isAfterLast()) { 

        int id=result.getInt(0); 

        String name=result.getString(1); 

        int inventory=result.getInt(2); 

        // do something useful with these 

        result.moveToNext(); 

      } 
 result.close();

在 Android 中使用 SQLite 数据库管理工具 在其他数据库上作开发，一般都使用工具来检查和处理数据库的内容，而不是仅仅使用数据库的 API。

使用 Android 模拟器，有两种可供选择的方法来管理数据库。

首先，模拟器绑定了 sqlite3 控制台程序，可以使用 adb shell 命令来调用他。只要你进入了模拟器的 shell，在数据库的路径执行 sqlite3 命令就可以了。

数据库文件一般存放在： /data/data/your.app.package/databases/your-db-name 如果你喜欢使用更友好的工具，

你可以把数据库拷贝到你的开发机上，使用 SQLite-aware 客户端来操作它。这样的话，你在一个数据库的拷贝上操作，

如果你想要你的修改能反映到设备上，你需要把数据库备份回去。

把数据库从设备上考出来，你可以使用 adb pull 命令（或者在 IDE 上做相应操作）。

存储一个修改过的数据库到设备上，使用 adb push 命令。 一个最方便的 SQLite 客户端是 FireFox SQLite Manager 扩展，它可以跨所有平台使用。

如果你想要开发 Android 应用程序，一定需要在 Android 上存储数据，使用 SQLite 数据库是一种非常好的选择。

第四种： 使用ContentProvider存储数据

Android这个系统和其他的操作系统还不太一样，我们需要记住的是，数据在Android当中是私有的，当然这些数据包括文件数据和数据库数据以及一些其他类型的数据。

那这个时候有读者就会提出问题，难道两个程序之间就没有办法对于数据进行交换？Android这么优秀的系统不会让这种情况发生的。

解决这个问题主要靠ContentProvider。一个Content Provider类实现了一组标准的方法接口，从而能够让其他的应用保存或读取此Content Provider的各种数据类型。

也就是说，一个程序可以通过实现一个Content Provider的抽象接口将自己的数据暴露出去。外界根本看不到，也不用看到这个应用暴露的数据在应用当中是如何存储的，

或者是用数据库存储还是用文件存储，还是通过网上获得，这些一切都不重要，

重要的是外界可以通过这一套标准及统一的接口和程序里的数据打交道，可以读取程序的数据，也可以删除程序的数据，当然，中间也会涉及一些权限的问题。

一个程序可以通过实现一个ContentProvider的抽象接口将自己的数据完全暴露出去，而且ContentProviders是以类似数据库中表的方式将数据暴露，

也就是说ContentProvider就像一个“数据库”。那么外界获取其提供的数据，也就应该与从数据库中获取数据的操作基本一样，只不过是采用URI来表示外界需要访问的“数据库”。

Content Provider提供了一种多应用间数据共享的方式，比如：联系人信息可以被多个应用程序访问。

Content Provider是个实现了一组用于提供其他应用程序存取数据的标准方法的类。

应用程序可以在Content Provider中执行如下操作: 查询数据 修改数据 添加数据 删除数据

标准的Content Provider: Android提供了一些已经在系统中实现的标准Content Provider，

比如联系人信息，图片库等等，你可以用这些Content Provider来访问设备上存储的联系人信息，图片等等。

查询记录:

在Content Provider中使用的查询字符串有别于标准的SQL查询。

很多诸如select, add, delete, modify等操作我们都使用一种特殊的URI来进行，这种URI由3个部分组成， “content://”, 代表数据的路径，和一个可选的标识数据的ID。

以下是一些示例URI:

content://media/internal/images 这个URI将返回设备上存储的所有图片

content://contacts/people/ 这个URI将返回设备上的所有联系人信息

content://contacts/people/45 这个URI返回单个结果（联系人信息中ID为45的联系人记录）

尽管这种查询字符串格式很常见，但是它看起来还是有点令人迷惑。

为此，Android提供一系列的帮助类（在android.provider包下），里面包含了很多以类变量形式给出的查询字符串，这种方式更容易让我们理解一点，参见下例:

MediaStore.Images.Media.INTERNAL_CONTENT_URI Contacts.People.CONTENT_URI

因此，如上面content://contacts/people/45这个URI就可以写成如下形式：

Uri person = ContentUris.withAppendedId(People.CONTENT_URI, 45);

然后执行数据查询: Cursor cur = managedQuery(person, null, null, null);

这个查询返回一个包含所有数据字段的游标，我们可以通过迭代这个游标来获取所有的数据：

package com.wissen.testApp;
public class ContentProviderDemo extends Activity {

    @Override

    public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.main);

       displayRecords();

    }



    private void displayRecords() {

        //该数组中包含了所有要返回的字段

     String columns[] = new String[] { People.NAME, People.NUMBER };

       Uri mContacts = People.CONTENT_URI;

       Cursor cur = managedQuery(

           mContacts,

          columns,  // 要返回的数据字段

       null,          // WHERE子句

       null,         // WHERE 子句的参数

       null         // Order-by子句

     );

       if (cur.moveToFirst()) {

           String name = null;

           String phoneNo = null;

           do {

              // 获取字段的值

         name = cur.getString(cur.getColumnIndex(People.NAME));

             phoneNo = cur.getString(cur.getColumnIndex(People.NUMBER));

             Toast.makeText(this, name + ” ” + phoneNo, Toast.LENGTH_LONG).show();

          } while (cur.moveToNext());

       }

    }
}

上例示范了一个如何依次读取联系人信息表中的指定数据列name和number。

修改记录:

我们可以使用ContentResolver.update()方法来修改数据，我们来写一个修改数据的方法:

private void updateRecord(int recNo, String name) {
         Uri uri = ContentUris.withAppendedId(People.CONTENT_URI, recNo);
         ContentValues values = new ContentValues();
         values.put(People.NAME, name);
         getContentResolver().update(uri, values, null, null);


    }

现在你可以调用上面的方法来更新指定记录： updateRecord(10, ”XYZ”); //更改第10条记录的name字段值为“XYZ”

添加记录:

要增加记录，我们可以调用ContentResolver.insert()方法，该方法接受一个要增加的记录的目标URI，以及一个包含了新记录值的Map对象，

调用后的返回值是新记录的URI，包含记录号。

上面的例子中我们都是基于联系人信息簿这个标准的Content Provider，现在我们继续来创建一个insertRecord() 方法以对联系人信息簿中进行数据的添加：

private void insertRecords(String name, String phoneNo) {
    ContentValues values = new ContentValues();

    values.put(People.NAME, name);

    Uri uri = getContentResolver().insert(People.CONTENT_URI, values);

    Log.d(”ANDROID”, uri.toString());

    Uri numberUri = Uri.withAppendedPath(uri, People.Phones.CONTENT_DIRECTORY);

    values.clear();

    values.put(Contacts.Phones.TYPE, People.Phones.TYPE_MOBILE);

    values.put(People.NUMBER, phoneNo);

    getContentResolver().insert(numberUri, values);


}

这样我们就可以调用insertRecords(name, phoneNo)的方式来向联系人信息簿中添加联系人姓名和电话号码。

删除记录:

Content Provider中的getContextResolver.delete()方法可以用来删除记录。

下面的记录用来删除设备上所有的联系人信息：

 private void deleteRecords() { 

 Uri uri = People.CONTENT_URI;

 getContentResolver().delete(uri, null, null); 

 } 

你也可以指定WHERE条件语句来删除特定的记录：

getContentResolver().delete(uri, “NAME=” + “‘XYZ XYZ’”, null);

这将会删除name为‘XYZ XYZ’的记录。

创建Content Provider:

至此我们已经知道如何使用Content Provider了，现在让我们来看下如何自己创建一个Content Provider。

要创建我们自己的Content Provider的话，我们需要遵循以下几步：

1. 创建一个继承了ContentProvider父类的类

2. 定义一个名为CONTENT_URI，并且是public static final的Uri类型的类变量，你必须为其指定一个唯一的字符串值，最好的方案是以类的全名称，

如: public static final Uri CONTENT_URI = Uri.parse( “content://com.google.android.MyContentProvider”);

3. 创建你的数据存储系统。大多数Content Provider使用Android文件系统或SQLite数据库来保持数据，但是你也可以以任何你想要的方式来存储。

4. 定义你要返回给客户端的数据列名。如果你正在使用Android数据库，则数据列的使用方式就和你以往所熟悉的其他数据库一样。

但是，你必须为其定义一个叫_id的列，它用来表示每条记录的唯一性。

5. 如果你要存储字节型数据，比如位图文件等，那保存该数据的数据列其实是一个表示实际保存文件的URI字符串，

客户端通过它来读取对应的文件数据，处理这种数据类型的Content Provider需要实现一个名为_data的字段，_data字段列出了该文件在Android文件系统上的精确路径。

这个字段不仅是供客户端使用，而且也可以供ContentResolver使用。客户端可以调用ContentResolver.openOutputStream()方法来处理该URI指向的文件资源，

如果是ContentResolver本身的话，由于其持有的权限比客户端要高，所以它能直接访问该数据文件。

6. 声明public static String型的变量，用于指定要从游标处返回的数据列。

7. 查询返回一个Cursor类型的对象。所有执行写操作的方法如insert(), update() 以及delete()都将被监听。

我们可以通过使用ContentResover().notifyChange()方法来通知监听器关于数据更新的信息。

8. 在AndroidMenifest.xml中使用标签来设置Content Provider。

9. 如果你要处理的数据类型是一种比较新的类型，你就必须先定义一个新的MIME类型，以供ContentProvider.geType(url)来返回。

MIME类型有两种形式:

一种是为指定的单个记录的，还有一种是为多条记录的。

这里给出一种常用的格式： vnd.android.cursor.item/vnd.yourcompanyname.contenttype （单个记录的MIME类型）

比如, 一个请求列车信息的URI如content://com.example.transportationprovider/trains/122

可能就会返回typevnd.android.cursor.item/vnd.example.rail这样一个MIME类型。

vnd.android.cursor.dir/vnd.yourcompanyname.contenttype （多个记录的MIME类型）

比如, 一个请求所有列车信息的URI如content://com.example.transportationprovider/trains

可能就会返回vnd.android.cursor.dir/vnd.example.rail这样一个MIME 类型。

下列代码将创建一个Content Provider，它仅仅是存储用户名称并显示所有的用户名称（使用 SQLLite数据库存储这些数据）：

package com.wissen.testApp;
public class MyUsers {
    public static final String AUTHORITY  = “com.wissen.MyContentProvider”;
    // BaseColumn类中已经包含了 _id字段

   public static final class User implements BaseColumns {

        public static final Uri CONTENT_URI  = Uri.parse(”content://com.wissen.MyContentProvider”);

        // 表数据列

     public static final String  USER_NAME  = “USER_NAME”;

    }
}

上面的类中定义了Content Provider的CONTENT_URI，以及数据列。下面我们将定义基于上面的类来定义实际的Content Provider类：

 


package com.wissen.testApp.android;
public class MyContentProvider extends ContentProvider {

    private SQLiteDatabase     sqlDB;

    private DatabaseHelper    dbHelper;

    private static final String  DATABASE_NAME     = “Users.db”;

    private static final int        DATABASE_VERSION         = 1;

    private static final String TABLE_NAME   = “User”;

    private static final String TAG = “MyContentProvider”;



    private static class DatabaseHelper extends SQLiteOpenHelper {

        DatabaseHelper(Context context) {

            super(context, DATABASE_NAME, null, DATABASE_VERSION);

        }



        @Override

        public void onCreate(SQLiteDatabase db) {

            //创建用于存储数据的表

        db.execSQL(”Create table ” + TABLE_NAME + “( _id INTEGER PRIMARY KEY AUTOINCREMENT, USER_NAME TEXT);”);

        }



        @Override

        public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {

            db.execSQL(”DROP TABLE IF EXISTS ” + TABLE_NAME);

            onCreate(db);

        }

    }



    @Override

    public int delete(Uri uri, String s, String[] as) {

        return 0;

    }



    @Override

    public String getType(Uri uri) {

        return null;

    }



    @Override

    public Uri insert(Uri uri, ContentValues contentvalues) {

        sqlDB = dbHelper.getWritableDatabase();

        long rowId = sqlDB.insert(TABLE_NAME, “”, contentvalues);

        if (rowId > 0) {

            Uri rowUri = ContentUris.appendId(MyUsers.User.CONTENT_URI.buildUpon(), rowId).build();

            getContext().getContentResolver().notifyChange(rowUri, null);

            return rowUri;

        }

        throw new SQLException(”Failed to insert row into ” + uri);

    }



    @Override

    public boolean onCreate() {

        dbHelper = new DatabaseHelper(getContext());

        return (dbHelper == null) ? false : true;

    }



    @Override

    public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) {

        SQLiteQueryBuilder qb = new SQLiteQueryBuilder();

        SQLiteDatabase db = dbHelper.getReadableDatabase();

        qb.setTables(TABLE_NAME);

        Cursor c = qb.query(db, projection, selection, null, null, null, sortOrder);

        c.setNotificationUri(getContext().getContentResolver(), uri);

        return c;

    }



    @Override

    public int update(Uri uri, ContentValues contentvalues, String s, String[] as) {

        return 0;

    }
}

一个名为MyContentProvider的Content Provider创建完成了，它用于从Sqlite数据库中添加和读取记录。

Content Provider的入口需要在AndroidManifest.xml中配置:

之后，让我们来使用这个定义好的Content Provider:

package com.wissen.testApp;
public class MyContentDemo extends Activity {

    @Override

    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        insertRecord(”MyUser”);

        displayRecords();

    }
    private void insertRecord(String userName) {

        ContentValues values = new ContentValues();

        values.put(MyUsers.User.USER_NAME, userName);

        getContentResolver().insert(MyUsers.User.CONTENT_URI, values);

    }



    private void displayRecords() {

        String columns[] = new String[] { MyUsers.User._ID, MyUsers.User.USER_NAME };

        Uri myUri = MyUsers.User.CONTENT_URI;

        Cursor cur = managedQuery(myUri, columns,null, null, null );

        if (cur.moveToFirst()) {

            String id = null;

            String userName = null;

            do {

                id = cur.getString(cur.getColumnIndex(MyUsers.User._ID));

                userName = cur.getString(cur.getColumnIndex(MyUsers.User.USER_NAME));

                Toast.makeText(this, id + ” ” + userName, Toast.LENGTH_LONG).show();

           } while (cur.moveToNext());

       }

    }
}

上面的类将先向数据库中添加一条用户数据，然后显示数据库中所有的用户数据。

第五种： 网络存储数据

前面介绍的几种存储都是将数据存储在本地设备上，除此之外，还有一种存储（获取）数据的方式，通过网络来实现数据的存储和获取。

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

具体需要熟悉java.net.，Android.net.这两个包的内容，在这就不赘述了，请大家参阅相关文档。

下面是一个通过地区名称查询该地区的天气预报，以POST发送的方式发送请求到webservicex.net站点，访问WebService.webservicex.net站点上提供查询天气预报的服务。

代码如下：

package com.android.weather; 

import java.util.ArrayList;
import java.util.List;

import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.EntityUtils;

import android.app.Activity;
import android.os.Bundle;

public class MyAndroidWeatherActivity extends Activity {
    //定义需要获取的内容来源地址
    private static final String SERVER_URL =
        "http://www.webservicex.net/WeatherForecast.asmx/GetWeatherByPlaceName";


    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        HttpPost request = new HttpPost(SERVER_URL); //根据内容来源地址创建一个Http请求
        // 添加一个变量 
        List params = new ArrayList(); 
        // 设置一个地区名称
        params.add(new BasicNameValuePair("PlaceName", "NewYork"));  //添加必须的参数


        try {
            //设置参数的编码
            request.setEntity(new UrlEncodedFormEntity(params, HTTP.UTF_8)); 
            //发送请求并获取反馈
            HttpResponse httpResponse = new DefaultHttpClient().execute(request);

            // 解析返回的内容
            if(httpResponse.getStatusLine().getStatusCode() != 404){ 
               String result = EntityUtils.toString(httpResponse.getEntity()); 
               System.out.println(result);
            }
        } catch (Exception e) {
            e.printStackTrace();
       }
    }
}

别忘记了在配置文件中设置访问网络权限：

如何在Android 应用中执行耗时操作

两个 Fragment 之间如何通信

方法一：

1、在MainFragment中设置一个setData()方法，在方法中设置更改按钮名称;

//MainFragment.java文件中
public void setData(String string) {
    bt_main.setText(string);
}

2、在MenuFragment中的ListView条目点击事件中通过标签获取到MainFragment，并调用对应的setData()方法，将数据设置进去，从而达到数据传递的目的。

lv.setOnItemClickListener(new AdapterView.OnItemClickListener() {
    @Override
     public void onItemClick(AdapterView parent, View view, int position, long id) {
          MainFragment mainFragment =
               (MainFragment) getActivity()
               .getSupportFragmentManager()
               .findFragmentByTag("mainFragment");
          mainFragment.setData(mDatas.get(position));
     }
});

只需上面区区两步即可达到数据传递的目的。

方法二：

采取接口回调的方式进行数据传递。

step1: 在Menuragment中创建一个接口以及接口对应的set方法：

//MenuFragment.java文件中
public interface OnDataTransmissionListener {
    public void dataTransmission(String data);
}
public void setOnDataTransmissionListener(OnDataTransmissionListener mListener) {
    this.mListener = mListener;
}

step2: 在MenuFragment中的ListView条目点击事件中进行接口进行接口回调

//MenuFragment.java文件中
lv.setOnItemClickListener(new AdapterView.OnItemClickListener() { 
   @Override
    public void onItemClick(AdapterView parent, View view, int position, long id) {
        /**
         * 方法二：采取接口回调的方式进行数据传递
         */
        if (mListener != null) {
            mListener.dataTransmission(mDatas.get(position));
        }
    }
});

step3: 在MainActivity中根据menuFragment获取到接口的set方法，在这个方法中进行进行数据传递，具体如下：

//在MainActivity.java中
menuFragment.setOnDataTransmissionListener(new MenuFragment.OnDataTransmissionListener() {
    @Override
    public void dataTransmission(String data) {
        mainFragment.setData(data);  //注：对应的mainFragment此时应该要用final进行修饰
    }
});

通过上面的三步也可以轻松做到Fragment数据之间的传递。

方法三：

使用三方开源框架：EventBus
那么问题来了：EventBus是个啥东西？？？
简单来说，EventBus是一款针对Android优化的发布/订阅（publish/subscribe）事件总线。主要功能是替代Intent,Handler,BroadCast在Fragment，Activity，Service，线程之间传递消息。简化了应用程序内各组件间、组件与后台线程间的通信。优点是开销小，代码更优雅，以及将发送者和接收者解耦。比如请求网络，等网络返回时通过Handler或Broadcast通知UI，两个Fragment之间需要通过Listener通信，这些需求都可以通过EventBus实现。
下面我们就用EventBus来实现以下Fragment之间的数据传递：

• step1：引入EventBus

compile 'org.greenrobot:eventbus:3.0.0'

• step2：注册事件接收者
  这里MainFragment是要接收MenuFragment发送来的数据，所以我们在MainFragment中的onCreateView()方法中进行注册：

EventBus.getDefault().register(this);

• step3：发送事件
  注：发送事件之前其实还有一步定义事件类型，这里我们传递的数据只有一个类型，所以这一步取消了。
  MenuFragment发送数据给MainFragment，所以我们在MenuFragment中将要传递的数据进行发送事件操作：

lv.setOnItemClickListener(new AdapterView.OnItemClickListener() {
    @Override
    public void onItemClick(AdapterView parent, View view, int position, long id) {
        EventBus.getDefault().post(mDatas.get(position));
    }
});

• step4：接收消息并处理
  在MainFragment中我们接收来自MenuFragment传递过来的数据,并进行对应的处理（注：EventBus 3.0版本这一步必须要写注解@Subscribe (与2.4版本有所区别)）：

public void onEvent(String data) {
    bt_main.setText(data);
}

通过上面这一步即可完成数据之间的传递，需要注意的是在销毁的时候我们要注销事件接收。

• step5：注销事件接收

//MainFragment.java中
@Override
public void onDestroy() {
    super.onDestroy();
    EventBus.getDefault().unregister(this);
}

以上五步完成了Fragment之间的数据传递，看似比上面两个方法要复杂的多，但当我们涉及到复杂的Fragment之间数据传递（例如Fragment中嵌套多层Fragment）时，就会体会到EventBus的爽快之处这里不进行赘述了。

阐述一下 Android 的通知系统