Android复习准备

1. 四大组件是什么？

• Activity（活动）：用于表现功能
• Service（服务）：后台运行服务，不提供界面呈现
• BroadcastReceiver（广播接收器）：用来接收广播
• ContentProvider（内容提供者）：支持在多个应用中存储和读取数据，相当于数据库。

2. 四个组件的生命周期？

1. Activity生命周期图

2. Fragment生命周期图

3. Service生命周期：首先Service有两种启动方式，而在这两种启动方式下，它的生命周期不同。

* 通过startService()方法启动

初始化结束后系统会调用 void onStart(Intent intent) 方法，用于处理传递给startService()的Intent对象。如音乐服务会打开Intent 来探明将要播放哪首音乐，并开始播放。注意：多次调用startService()方法会多次触发onStart()方法。

* 通过bindService ()方法启动的服务

初始化结束后系统会调用 IBinder onBind(Intent intent) 方法，用来绑定传递给bindService 的Intent 的对象。注意：多次调用bindService()时，如果该服务已启动则不会再触发此方法。

3.Activity的四种启动模式对比

• Standard：标准模式

这是 Activity 默认的启动模式，这种模式下，每次 startActivity 都会在栈顶创建一个新的实例，在同一个任务中可以存在多个Activity 的实例。

• SingeTop：栈顶复用模式

栈顶复用，也就是说，要启动 singleTop 模式的 Activity，如果它恰好在当前栈顶，那么直接复用，执行其 onNewIntent 方法。否则，就重新创建一个实例入栈。

• SingleTask：栈内复用模式

栈内复用模式。这是一种单实例模式，在这种模式下，只要 Activity 在一个栈中存在，那么多次启动此 Activity 都不会重新创建实例，和 singleTop 模式一样，系统也会回调其 onNewIntent。当这个Activity上面有其他Activity时会将它们全部出栈（自动执行clearTop），然后再调用onNewIntent()方法。

• SingleInstance：单实例模式

单实例模式。这是一种加强的 singleTask 模式，它除了具有 singleTask 模式的所有特性外，还加强了一点，那就是具有此种模式的 Activity 只能单独地位于一个任务栈中。

设置方式：

<activity
            android:name=".SecondActivity"
            android:label="@string/title_activity_second"
            android:launchMode="singleTask"//<-----------------------
            android:taskAffinity="com.xplee.task.task.SecondActivity"
            android:theme="@style/AppTheme.NoActionBar"></activity>

4.Activity在有Dialog（对话框）时按Home键的生命周期？

当我们的Activity上弹出Dialog对话框时，程序的生命周期依然是onCreate() —> onStart() —> onResume()，在弹出Dialog的时候并没有onPause()和onStop()方法。而在此时我们按下Home键，才会继续执行onPause()和onStop()方法。这说明对话框并没有使Activity进入后台，而是在点击了Home键后Activity才进入后台工作。

原因就是，其实Dialog是Activity的一个组件，此时Activity并不是不可见，而是被Dialog组件覆盖了其他的组件，此时我们无法对其他组件进行操作而已。

5.两个Activity之间跳转时必然会执行的方法？

首先定义两个Activity，分别为A和B。

当我们在A中激活B时，A调用onPause()方法，此时B出现在屏幕时，B调用onCreate()、onStart()、onResume()。

这个时候B【B不是一个透明的窗体或对话框的形式】已经覆盖了A的窗体，A会调用onStop()方法。

6.前台切换到后台，然后再回到前台，Activity生命周期回调方法。弹出Dialog，生命周期回调方法？

首先定义两个Activity，分别为A和B。

完整顺序为：A调用onCreate()方法 —> onStart()方法 —> onResume()方法。当A启动B时，A调用onPause()方法，然后调用新的Activity B，此时调用onCreate()方法 —> onStart()方法 —> onResume()方法将新Activity激活。之后A再调用onStop()方法。当A再次回到前台时，B调用onPause()方法，A调用onRestart()方法 —> onStart()方法 —> onResume()方法，最后调用B的onStop()方法 —> onDestory()方法。

弹出Dialog时，调用onCreate()方法 —> onStart()方法 —> onResume()方法。

7.fragment各种情况下的生命周期？

8.如何实现Fragment的滑动？

将Fragment与viewpager绑定，通过viewpager中的touch事件，会进行move事件的滑动处理。

9.fragment之间传递数据的方法？

方法一：

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

//MainFragment.java文件中

public void setData(String string) {

bt_main.setText(string);

}

1. 在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));

}

});

方法二：

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

方法三：EventBus

10.Activity怎么和Service绑定？

这需要实现sercice中的onBind()函数以返回service实例给activity

1. 创建service类和activity类。
   
   2.在service类中定义一个内部类继承自Binder()类：

public class MyBinder extends Binder{  

        public Service1 getService(){  

            return Service1.this;  

        }  

    }  

实例化onBind()方法：

private final IBinder binder = new MyyBinder();

@Override

public IBinder onBind(Intent intent){

        Log.i(LOG，"onBind......");

        return binder;

}

1. 在activity中完成绑定

Intent intent = new Intent(Activity1.this,Activity2.class);
bindService(intent,conn,Context.BIND_AUTO_CREATE);
// bindService的第二个参数是一个ServiceConnection类型的参数。service和其他组件之间的连接都表示为一个ServiceConnection，要想将service和其他组件进行绑定，就需要实现一个新的ServiceConnection。

public ServiceConnection conn= new ServiceConnection() {
        @Override
public void onServiceDisconnected(ComponentName name) {  

//当连接意外断开时调用

Log.i(LOG, "onServiceDisconnected>>>>>>>>");  

            myservice = null;  

        }  

        @Override  

        public void onServiceConnected(ComponentName name, IBinder service) {  

//当建立连接时调用

            Log.i(LOG, "onServiceConnected>>>>>>>>");  

            myservice = ((Service1.MyBinder)service).getService();  

        }  

    }; 

11.service的生命周期？

1. 被启动的服务（startService()）的生命周期：

如果一个Service被某个Activity 调用Context.startService() 方法启动，那么不管是否有Activity使用bindService()绑定或unbindService()解除绑定到该Service，该Service都在后台运行。如果一个Service被多次执行startService()，它的onCreate()方法只会调用一次，也就是说该Service只会创建一个实例，而它的onStartCommand()将会被调用多次(对应调用startService()的次数)。该Service将会一直在后台运行，直到被调用stopService()，或自身的stopSelf方法。当然如果系统资源不足，系统也可能结束服务。

1. 被绑定的服务（bindService()）的生命周期。

如果一个Service被调用 Context.bindService ()方法绑定启动，不管调用bindService()调用几次，onCreate()方法都只会调用一次，而onStartCommand()方法始终不会被调用，这时会调用onBind()方法。当连接建立之后，Service将会一直运行，除非调用Context.unbindService() 断开连接或者之前调用bindService() 的 Context 不存在了(如该Activity被finish)，系统将会自动停止Service，对应onDestroy()将被调用。

1. 被启动又被绑定的服务的生命周期。

如果一个Service又被启动又被绑定，则该Service将会一直在后台运行。调用unbindService()将不会停止Service，而必须调用stopService()或Service的stopSelf()方法来停止服务。

1. 当服务被停止时清除服务。

当一个Service被终止时，Service的onDestroy()方法将会被调用，在这里应当做一些清除工作，如停止在Service中创建并运行的线程等。

12.activity和service的绑定方式以及怎么在Activity 中启动自己对应的Service？

1、activity能进行绑定得益于Serviece的接口。为了支持Service的绑定，实现onBind方法。

2、Service和Activity的连接可以用ServiceConnection来实现。需要实现一个新的ServiceConnection，重现onServiceConnected和OnServiceDisconnected方法，一旦连接建立，就能得到Service实例的引用。

3、执行绑定，调用bindService方法，传入一个选择了要绑定的Service的Intent(显示或隐式)和一个你实现了的ServiceConnection的实例

13.Service的启动方式？

采用Context.startService()方法启动服务，在服务未被创建时，系统会先调用服务的onCreate()方法，接着调用onStart()方法。如果调用startService()方法前服务已经被创建，多次调用startService()方法并不会导致多次创建服务，但会导致多次调用onStart()方法。采用startService()方法启动的服务，只能调用Context.stopService()方法结束服务，服务结束时会调用onDestroy()方法。

采用Context.bindService()方法启动服务，在服务未被创建时，系统会先调用服务的 onCreate()方法，接着调用onBind()方法。这个时候调用者和服务绑定在一起，调用者退出了，系统就会先调用服务的onUnbind()方 法，接着调用onDestroy()方法。如果调用bindService()方法前服务已经被绑定，多次调用bindService()方法并不会导致 多次创建服务及绑定(也就是说onCreate()和onBind()方法并不会被多次调用)。如果调用者希望与正在绑定的服务解除绑定，可以调用 unbindService()方法，调用该方法也会导致系统调用服务的onUnbind()–>onDestroy()方法。

14.谈谈ContentProvider、ContentResolver、ContentObserver之间的关系？

ContentProvider:

• 四大组件的内容提供者，主要用来对外提供数据，

• 实现各个应用程序之间的（跨应用）数据共享，比如联系人应用中就使用了ContentProvider，你在自己的应用中可以读取和修改联系人的数据，不过需要获得相应的权限。其实它也只是一个中间人，真正的数据源是文件或者SQLite等

• 一个应用实现ContentProvider来提供内容给别的应用来操作，通过ContentResolver来操作别的应用数据，当然在自己的应用中也可以。

ContentResolver：

• 内容解析者，用于获取内容提供者提供的数据
• ContentResolver.notifyChange(uri)发出消息

ContentObserver：

• 内容监听者，可以监听数据的改变状态
• 目的时观察特定的Uri引起的数据库的变化，进而做一些相应的处理，类似于数据库技术中的触发器（Tigger）。
• ContentResolver.registerContentObserver()监听消息

15.广播的分类？

• 无序广播发送代码：

public class MainActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }

    public void click(View v){
        //启动界面 startActivity
        //发送广播 sendBroadcast

        Intent intent = new Intent();

        intent.setAction("com.itheima.cctv.action.NEWS");
        intent.putExtra("data", "我是一个无须的广播");
        sendBroadcast(intent);
    }
}

• 无序广播的监听代码：

public class CctvReceiver extends BroadcastReceiver {

    private static final String TAG = "CctvReceiver";

    @Override
    public void onReceive(Context context, Intent intent) {
        String data = intent.getStringExtra("data");
        Log.d(TAG, "data==="+data);
    }

}

xml：
<receiver android:name="com.itheima.cctv.CctvReceiver">
            <intent-filter >
            <!--这里监听的广播就是上面发送广播设置的intent.setAction("com.itheima.cctv.action.NEWS");-->
                <action android:name="com.itheima.cctv.action.NEWS"/>
            </intent-filter>
        </receiver>

• 有序广播发送代码：

public class ShengReceiver extends BroadcastReceiver {
@Override
    public void onReceive(Context context, Intent intent) {
        Log.d("vivi", "我是省级部门，我收到的指令是："+getResultData());
        //getResultData()是用来获取有序广播里面的数值.这里的信息是:
        //主席讲话：每人奖励10斤土豆

        setResultData("主席讲话：每人奖励7斤土豆");//有序广播的数值,可以被修改,后面的程序在接受到这个广播,就会变成,现在我们改变的值了

        //有序广播传输是可以终止的.但是最终的接受者就算在终止之后,也是可以接受到数据的
        //abortBroadcast();
    }
}

public class ShiReceiver extends BroadcastReceiver {

    @Override
    public void onReceive(Context context, Intent intent) {
        Log.d("vivi", "我是市级部门，我收到的指令是："+getResultData());
    //因为上面修改了数据,所以这里获取到的数据是:主席讲话：每人奖励7斤土豆
    }

}

<!--有序广播的优先级别使用 android:priority=""来指定,最高是1000,最低是-1000-->
        <receiver android:name="com.itheima.region.ShengReceiver">
            <intent-filter android:priority="1000">
                <action android:name="com.itheima.gov.action.POTATO"/>
            </intent-filter>
        </receiver>

        <receiver android:name="com.itheima.region.ShiReceiver">
           <intent-filter android:priority="500">
                <action android:name="com.itheima.gov.action.POTATO"/>
            </intent-filter>
        </receiver>

• 有序广播接收代码：

public class MyReceiver extends BroadcastReceiver {

    @Override
    public void onReceive(Context context, Intent intent) {
        Log.d("vivi", "我是恩恩主席的内线，我收到的指令是："+getResultData());
    }

}

16. Handler(Android SDK提供给开发者方便进行异步消息处理的类):

1.Handler四大组件：

1. Message
   
   Message是在线程之间传递的消息，它可以在内部携带少量的信息，用于在不同线程之间交换数据。
   
   例：Message的what字段、arg1字段、arg2字段来携带整型数据，obj字段携带一个Object对象。

2. Handler
   
   处理者，它主要用来发送和处理消息。发送消息一般是使用Handler的sendMessage()方法，消息经过处理后，最终传递到Handler的handlerMessage()方法中

3. MessageQueue
   
   消息队列，它主要用来存放所有通过Handler发送的消息，这部分消息会一直存在于消息队列中，等待被处理。

4. Looper
   
   是每个线程中MessageQueue的管家，调用Looper的loop()方法后，就会进入到一个无限循环当中，每当发现MessageQueue中存在一条消息，就会将其取出传递到Handler的handleMessage()方法当中。

异步消息处理流程：

1. 在主线程中创建一个Handler对象；
2. 重写handleMessage()方法
3. 当子线程需要进行UI操作时，创建一个Message对象，并通过Handler将消息发送出去；
4. 消息添加到MessageQueue的队列中等待被处理；
5. Looper在MessageQueue中取出待处理的消息，发回Handler的handleMessage()方法中。