2. 程式人生 > >Android中的Service全面總結（修正過）

Android中的Service全面總結（修正過）

阿新 • • 發佈：2019-02-05

1、Service的種類 

按執行地點分類：

類別 區別  優點 缺點   應用
本地服務（Local） 該服務依附在主程序上， 服務依附在主程序上而不是獨立的程序，這樣在一定程度上節約了資源，另外Local服務因為是在同一程序因此不需要IPC，也不需要AIDL。相應bindService會方便很多。 主程序被Kill後，服務便會終止。 非常常見的應用如：HTC的音樂播放服務，天天動聽音樂播放服務。
遠端服務（Remote） 該服務是獨立的程序， 服務為獨立的程序，對應程序名格式為所在包名加上你指定的android:process字串。由於是獨立的程序，因此在Activity所在程序被Kill的時候，該服務依然在執行，不受其他程序影響，有利於為多個程序提供服務具有較高的靈活性。
 該服務是獨立的程序，會佔用一定資源，並且使用AIDL進行IPC稍微麻煩一點。 一些提供系統服務的Service，這種Service是常駐的。

其實remote服務還是很少見的，並且一般都是系統服務。 

按執行型別分類：

類別 區別 應用
前臺服務 會在通知一欄顯示ONGOING的Notification 當服務被終止的時候，通知一欄的Notification也會消失，這樣對於使用者有一定的通知作用。常見的如音樂播放服務。
後臺服務 預設的服務即為後臺服務，即不會在通知一欄顯示ONGOING的Notification。 當服務被終止的時候，使用者是看不到效果的。某些不需要執行或終止提示的服務，如天氣更新，日期同步，郵件同步等。

有同學可能會問，後臺服務我們可以自己建立ONGOING的Notification這樣就成為前臺服務嗎？答案是否定的，前臺服務是在做了上述工作之後需要呼叫startForeground（android 2.0及其以後版本）或setForeground（android 2.0以前的版本）使服務成為 前臺服務。這樣做的好處在於，當服務被外部強制終止掉的時候，ONGOING的Notification仍然會移除掉。

按使用方式分類：

類別 區別
startService啟動的服務 主要用於啟動一個服務執行後臺任務，不進行通訊。停止服務使用stopService
bindService啟動的服務 該方法啟動的服務要進行通訊。停止服務使用unbindSer
vice
startService同時也bindService啟動的服務 停止服務應同時使用stopService與unbindService

以上面三種方式啟動的服務其生命週期也有區別，將在隨後給出。

2、Service 與Thread的區別

很多時候，你可能會問，為什麼要用Service，而不用Thread 呢，因為用Thread是很方便的，比起Service也方便多了，下面我詳細的來解釋一下。1). Thread：Thread是程式執行的最小單元，它是分配CPU的基本單位。可以用Thread來執行一些非同步的操作。
2). Service：Service是android的一種機制，當它執行的時候如果是Local Service，那麼對應的Service是執行在主程序的main執行緒上的。如：onCreate，onStart 這些函式在被系統呼叫的時候都是在主程序的main執行緒上執行的。如果是Remote Service，那麼對應的Service則是執行在獨立程序的main執行緒上。因此請不要把Service理解成執行緒，它跟執行緒半毛錢的關係都沒有！

既然這樣，那麼我們為什麼要用Service呢？其實這跟android的系統機制有關，我們先拿Thread來說。Thread的執行是獨立於Activity的，也就是說當一個Activity被finish之後，如果你沒有主動停止Thread或者Thread裡的run方法沒有執行完畢的話，Thread也會一直執行。因此這裡會出現一個問題：當Activity被finish之後，你不再持有該Thread的引用。另一方面，你沒有辦法在不同的Activity中對同一Thread進行控制。

舉個例子：如果你的Thread需要不停地隔一段時間就要連線伺服器做某種同步的話，該Thread需要在Activity沒有start的時候也在執行。這個時候當你start一個Activity就沒有辦法在該Activity裡面控制之前建立的Thread。因此你便需要建立並啟動一個Service，在Service裡面建立、執行並控制該Thread，這樣便解決了該問題（因為任何Activity都可以控制同一Service，而系統也只會建立一個對應Service的例項）。

因此你可以把Service想象成一種訊息服務，而你可以在任何有Context的地方呼叫Context.startService、Context.stopService、Context.bindService，Context.unbindService，來控制它，你也可以在Service裡註冊BroadcastReceiver，在其他地方通過傳送broadcast來控制它，當然這些都是Thread 做不到的。

3、Service的生命週期

onCreate　　onStart　　onDestroy　　onBind 
1). 被啟動的服務的生命週期：如果一個Service被某個Activity  呼叫Context.startService方法啟動，那麼不管是否有Activity使用bindService繫結或unbindService解除繫結到該Service，該Service都在後臺執行。如果一個Service被startService  方法多次啟動，那麼onCreate方法只會呼叫一次，onStart將會被呼叫多次（對應呼叫startService的次數），並且系統只會建立Service的一個例項（因此你應該知道只需要一次stopService呼叫）。該Service將會一直在後臺執行，而不管對應程式的Activity是否在執行，直到被呼叫stopService，或自身的stopSelf方法。當然如果系統資源不足，android系統也可能結束服務。
2). 被繫結的服務的生命週期：如果一個Service被某個Activity 呼叫Context.bindService方法繫結啟動，不管呼叫bindService呼叫幾次，onCreate方法都只會呼叫一次，同時onStart方法始終不會被呼叫。當連線建立之後，Service將會一直執行，除非呼叫Context.unbindService  斷開連線或者之前呼叫bindService的Context不存在了（如Activity被finish的時候），系統將會自動停止Service，對應onDestroy將被呼叫。
3). 被啟動又被繫結的服務的生命週期：如果一個Service又被啟動又被繫結，則該Service將會一直在後臺執行。並且不管如何呼叫，onCreate始終只會呼叫一次，對應startService呼叫多少次，Service的onStart便會呼叫多少次。呼叫unbindService將不會停止Service，而必須呼叫stopService或 Service的 stopSelf來停止服務。
4). 當服務被停止時清除服務：當一個Service被終止（1、呼叫stopService；2、呼叫stopSelf；3、不再有繫結的連線（沒有被啟動））時，onDestroy方法將會被呼叫，在這裡你應當做一些清除工作，如停止在Service中建立並執行的執行緒。

特別注意：
1、你應當知道在呼叫bindService繫結到Service的時候，你就應當保證在某處呼叫unbindService解除繫結（儘管Activity被finish的時候繫結會自動解除，並且Service會自動停止）；
2、你應當注意使用startService啟動服務之後，一定要使用stopService停止服務，不管你是否使用bindService；3、同時使用startService與bindService要注意到，Service 的終止，需要unbindService與stopService同時呼叫，才能終止Service，不管startService與bindService的呼叫順序，如果先呼叫unbindService  此時服務不會自動終止，再呼叫stopService 之後服務才會停止，如果先呼叫 stopService此時服務也不會終止，而再呼叫unbindService 或者之前呼叫bindService的Context不存在了（如Activity被finish的時候）之後服務才會自動停止；
4、當在旋轉手機螢幕的時候，當手機螢幕在“橫”“豎”變換時，此時如果你的Activity如果會自動旋轉的話，旋轉其實是Activity的重新建立，因此旋轉之前的使用bindService建立的連線便會斷開（Context 不存在了），對應服務的生命週期與上述相同。
5、在sdk 2.0及其以後的版本中，對應 onStart已經被否決變為了onStartCommand，不過之前的onStart仍然有效。這意味著，如果你開發的應用程式用的sdk為2.0 及其以後的版本，那麼你應當使用onStartCommand而不是 onStart。

4、startService  啟動服務

想要用startService啟動服務，不管Local還是Remote我們需要做的工作都是一樣簡單。當然要記得在Androidmanifest.xml中註冊 service。
根據上面的生命週期，我們便會給出Service中的程式碼框架：

  1. package com.newcj.test;  
  2. import android.app.Service;  
  3. import android.content.Intent;  
  4. import android.os.IBinder;  
  5. publicclass LocalService1 extends Service {   
  6.     /** 
  7.      * onBind 是 Service 的虛方法，因此我們不得不實現它。 
  8.      * 返回 null，表示客服端不能建立到此服務的連線。 
  9.      */
  10.     @Override
  11.     public IBinder onBind(Intent intent) {  
  12.         returnnull;  
  13.     }  
  14.     @Override
  15.     publicvoid onCreate() {  
  16.         super.onCreate();  
  17.     }  
  18.     @Override
  19.     publicvoid onStart(Intent intent, int startId) {  
  20.         super.onStart(intent, startId);  
  21.     }  
  22.     @Override
  23.     publicvoid onDestroy() {  
  24.         super.onDestroy();  
  25.     }   
  26. }  

對應生命週期系統回撥函式上面已經說明，在對應地方加上適當的程式碼即可。下面是啟動與停止 Service 的程式碼：

  1. // 啟動一個 Activity
  2. startActivity(new Intent(this, LocalService1.class));  
  3. ...  
  4. // 停止一個 Activity
  5. stopService(new Intent(this, LocalService1.class));  

對應的Intent為標誌服務類的Intent。

5、Local與Remote服務繫結
同樣記得在Androidmanifest.xml 中註冊 service
1). Local服務繫結：Local服務的繫結較簡單，首先在Service中我們需要實現Service的抽象方法onBind，並返回一個實現IBinder介面的物件。
Service中的程式碼：

  1. package com.newcj.test;  
  2. import android.app.Service;  
  3. import android.content.Intent;  
  4. import android.os.Binder;  
  5. import android.os.IBinder;  
  6. publicclass LocalService extends Service {   
  7.     /** 
  8.      * 在 Local Service 中我們直接繼承 Binder 而不是 IBinder,因為 Binder 實現了 IBinder 介面，這樣我們可以少做很多工作。 
  9.      * @author newcj 
  10.      */
  11.     publicclass SimpleBinder extends Binder{  
  12.         /** 
  13.          * 獲取 Service 例項 
  14.          * @return 
  15.          */
  16.         public LocalService getService(){  
  17.             return LocalService.this;  
  18.         }  
  19.         publicint add(int a,int b){  
  20.             return a + b;  
  21.         }  
  22.     }  
  23.     public SimpleBinder sBinder;  
  24.     @Override
  25.     publicvoid onCreate() {  
  26.         super.onCreate();  
  27.         // 建立 SimpleBinder
  28.         sBinder = new SimpleBinder();  
  29.     }  
  30.     @Override
  31.     public IBinder onBind(Intent intent) {  
  32.         // 返回 SimpleBinder 物件
  33.         return sBinder;  
  34.     }   
  35. }  

上面的程式碼關鍵之處，在於onBind(Intent)這個方法返回了一個實現了IBinder介面的物件，這個物件將用於繫結Service的Activity與Local Service通訊。下面是Activity中的程式碼： 

  1. package com.newcj.test;  
  2. import android.app.Activity;  
  3. import android.content.ComponentName;  
  4. import android.content.Context;  
  5. import android.content.Intent;  
  6. import android.content.ServiceConnection;  
  7. import android.os.Bundle;  
  8. import android.os.IBinder;  
  9. import android.util.Log;  
  10. import android.view.View;  
  11. import android.view.View.OnClickListener;  
  12. publicclass Main extends Activity {  
  13.     privatefinalstatic String TAG = "SERVICE_TEST";  
  14.     private ServiceConnection sc;  
  15.     privateboolean isBind;  
  16.     @Override
  17.     publicvoid onCreate(Bundle savedInstanceState) {  
  18.         super.onCreate(savedInstanceState);  
  19.         setContentView(R.layout.main);  
  20.         sc =new ServiceConnection() {               
  21.             @Override
  22.             publicvoid onServiceDisconnected(ComponentName name) {   
  23.             }               
  24.             @Override
  25.             publicvoid onServiceConnected(ComponentName name, IBinder service) {  
  26.                 LocalService.SimpleBinder sBinder = (LocalService.SimpleBinder)service;  
  27.                 Log.v(TAG,"3 + 5 = " + sBinder.add(3,5));  
  28.                 Log.v(TAG, sBinder.getService().toString());  
  29.             }  
  30.         };  
  31.         findViewById(R.id.btnBind).setOnClickListener(new OnClickListener() {               
  32.             @Override
  33.             publicvoid onClick(View v) {  
  34.                 bindService(new Intent(Main.this, LocalService.class), sc, Context.BIND_AUTO_CREATE);  
  35.                 isBind =true;  
  36.             }  
  37.         });  
  38.         findViewById(R.id.btnUnbind).setOnClickListener(new OnClickListener() {               
  39.             @Override
  40.             publicvoid onClick(View v) {  
  41.                 if(isBind){  
  42.                     unbindService(sc);  
  43.                     isBind =false;  
  44.                 }  
  45.             }  
  46.         });  
  47.     }  
  48. }  

在Activity中，我們通過ServiceConnection介面來取得建立連線與連線意外丟失的回撥。bindService有三個引數，第一個是用於區分Service的Intent 與startService中的Intent一致，第二個是實現了ServiceConnection介面的物件，最後一個是flag標誌位。有兩個flag，BIND_DEBUG_UNBIND與BIND_AUTO_CREATE，前者用於除錯（詳細內容可以檢視javadoc  上面描述的很清楚），後者預設使用。unbindService解除繫結，引數則為之前建立的ServiceConnection介面物件。另外，多次呼叫unbindService來釋放相同的連線會丟擲異常，因此我建立了一個boolean變數來判斷是否unbindService已經被呼叫過。

執行結果：

2). Remote服務繫結：Remote的服務繫結由於服務是在另外一個程序，因此需要用到android的IPC機制。這將又是一個很長的話題，因此，我打算寫另外一篇android的IPC機制分析 ，並在其中進行詳述，然後在這裡更新連結，敬請關注。

特別注意：
1、Service.onBind如果返回null，則呼叫bindService會啟動Service，但不會連線上Service，因此ServiceConnection.onServiceConnected不會被呼叫，但你仍然需要使用unbindService函式斷開它，這樣Service才會停止。

6、建立前臺服務

前臺服務的優點上面已經說明，但設定服務為前臺服務，我們需要注意在sdk 2.0及其以後版本使用的方法是startForeground與stopForeground，之前版本使用的是setForeground，因此如果你應用程式的最低執行環境要求是2.0，那麼這裡可以直接運用新方法，如果執行環境是2.0以下，那麼為了保證向後相容性，這裡必須使用反射技術來呼叫新方法。

下面是我仿照ApiDemos重新敲的程式碼，對某些地方進行了修改，因此更具有說明性：

  1. package com.newcj.test;  
  2. import java.lang.reflect.InvocationTargetException;  
  3. import java.lang.reflect.Method;  
  4. import android.app.Notification;  
  5. import android.app.NotificationManager;  
  6. import android.app.PendingIntent;  
  7. import android.app.Service;  
  8. import android.content.Context;  
  9. import android.content.Intent;  
  10. import android.os.IBinder;  
  11. publicclass ForegroundService extends Service {  
  12.     privatestaticfinal Class[] mStartForegroundSignature = new Class[] {  
  13.         int.class, Notification.class};  
  14.     privatestaticfinal Class[] mStopForegroundSignature = new Class[] {  
  15.         boolean.class};  
  16.     private NotificationManager mNM;  
  17.     private Method mStartForeground;  
  18.     private Method mStopForeground;  
  19.     private Object[] mStartForegroundArgs =new Object[2];  
  20.     private Object[] mStopForegroundArgs =new Object[1];  
  21.     @Override
  22.     public IBinder onBind(Intent intent) {  
  23.         returnnull;  
  24.     }  
  25.     @Override
  26.     publicvoid onCreate() {  
  27.         super.onCreate();  
  28.         mNM = (NotificationManager)getSystemService(Context.NOTIFICATION_SERVICE);  
  29.         try {  
  30.             mStartForeground = ForegroundService.class.getMethod("startForeground", mStartForegroundSignature);  
  31.             mStopForeground = ForegroundService.class.getMethod("stopForeground", mStopForegroundSignature);  
  32.         }catch (NoSuchMethodException e) {  
  33.             mStartForeground = mStopForeground =null;  
  34.         }  
  35.          // 我們並不需要為 notification.flags 設定 FLAG_ONGOING_EVENT，因為
  36.          // 前臺服務的 notification.flags 總是預設包含了那個標誌位
  37.         Notification notification =new Notification(R.drawable.icon,"Foreground Service Started.",  
  38.                 System.currentTimeMillis());  
  39.         PendingIntent contentIntent = PendingIntent.getActivity(this,0,  
  40.                 new Intent(this, Main.class),0);  
  41.         notification.setLatestEventInfo(this,"Foreground Service",  
  42.                 "Foreground Service Started.", contentIntent);  
  43.         // 注意使用  startForeground ，id 為 0 將不會顯示 notification
  44.         startForegroundCompat(1, notification);  
  45.     }  
  46.     @Override
  47.     publicvoid onDestroy() {  
  48.         super.onDestroy();  
  49.         stopForegroundCompat(1);  
  50.     }  
  51.     // 以相容性方式開始前臺服務
  52.     privatevoid startForegroundCompat(int id, Notification n){  
  53.         if(mStartForeground !=null){  
  54.             mStartForegroundArgs[0] = id;  
  55.             mStartForegroundArgs[1] = n;  
  56.             try {  
  57.                 mStartForeground.invoke(this, mStartForegroundArgs);  
  58.             }catch (IllegalArgumentException e) {  
  59.                 e.printStackTrace();  
  60.             }catch (IllegalAccessException e) {  
  61.                 e.printStackTrace();  
  62.             }catch (InvocationTargetException e) {  
  63.                 e.printStackTrace();  
  64.             }  
  65.             return;  
  66.         }  
  67.         setForeground(true);  
  68.         mNM.notify(id, n);  
  69.     }  
  70.     // 以相容性方式停止前臺服務
  71.     privatevoid stopForegroundCompat(int id){  
  72.         if(mStopForeground !=null){  
  73.             mStopForegroundArgs[0] = Boolean.TRUE;  
  74.             try {  
  75.                 mStopForeground.invoke(this, mStopForegroundArgs);  
  76.             }catch (IllegalArgumentException e) {  
  77.                 e.printStackTrace();  
  78.             }catch (IllegalAccessException e) {  
  79.                 e.printStackTrace();  
  80.             }catch (InvocationTargetException e) {  
  81.                 e.printStackTrace();  
  82.             }  
  83.             return;  
  84.         }  
  85.         //  在 setForeground 之前呼叫 cancel，因為我們有可能在取消前臺服務之後
  86.         //  的那一瞬間被kill掉。這個時候 notification 便永遠不會從通知一欄移除
  87.         mNM.cancel(id);  
  88.         setForeground(false);  
  89.     }  
  90. }  

特別注意：
 1、使用startForeground，如果id為0，那麼notification將不會顯示。

7、在什麼情況下使用startService或bindService或同時使用startService和bindService

如果你只是想要啟動一個後臺服務長期進行某項任務那麼使用startService便可以了。如果你想要與正在執行的Service取得聯絡，那麼有兩種方法，一種是使用broadcast，另外是使用bindService，前者的缺點是如果交流較為頻繁，容易造成效能上的問題，並且BroadcastReceiver本身執行程式碼的時間是很短的（也許執行到一半，後面的程式碼便不會執行），而後者則沒有這些問題，因此我們肯定選擇使用bindService（這個時候你便同時在使用 startService和bindService了，這在Activity中更新Service 的某些執行狀態是相當有用的）。另外如果你的服務只是公開一個遠端介面，供連線上的客服端（android的Service是C/S架構）遠端呼叫執行方法。這個時候你可以不讓服務一開始就執行，而只用bindService，這樣在第一次bindService 的時候才會建立服務的例項執行它，這會節約很多系統資源，特別是如果你的服務是Remote Service，那麼該效果會越明顯（當然在Service建立的時候會花去一定時間，你應當注意到這點）。

8、在AndroidManifest.xml 裡 Service元素的常見選項

android:name　　-------------　　服務類名
android:label　　--------------　　服務的名字，如果此項不設定，那麼預設顯示的服務名則為類名
android:icon　　--------------　　服務的圖示
android:permission　　-------　　申明此服務的許可權，這意味著只有提供了該許可權的應用才能控制或連線此服務
android:process　　----------　　表示該服務是否執行在另外一個程序，如果設定了此項，那麼將會在包名後面加上這段字串表示另一程序的名字
android:enabled　　----------　　如果此項設定為  true，那麼 Service  將會預設被系統啟動，不設定預設此項為 false
android:exported　　---------　　表示該服務是否能夠被其他應用程式所控制或連線，不設定預設此項為  false

相關推薦

Android中的Service全面總結（修正過）

1、Service的種類  按執行地點分類： 類別 區別  優點 缺點   應用 本地服務（Local） 該服務依附在主程序上， 服務依附在主程序上而不是獨立的程序，這樣在一定程度上節約了資源，另外Local服務因為是在同一程序因此不需要IPC，也不需要AIDL。相應bindService會方便很多。 主

Android中的系統服務（代理模式）

一，系統啟動 Android裝置的開機流程總得來分可以分為三部分： 載入載入程式 載入程式bootloader是開機執行的第一個小程式，因此它是針對特定的主機板與晶片的。bootloader有很多種，可以使用比較流行的如redboot、uboot、

Android中的ListView用法（自動滾動）

Listview用法： Java程式碼 package com.tmnw; import java.util.ArrayList; import java.util.List; import android.app.Activity; import android.os

Android中的動態載入（簡單實現）

先說明一點，這篇文章說的動態載入，只能載入dex檔案中的功能，涉及到資源的就不可以了。動態載入步驟    1、在宿主程式中寫外掛介面2、在外掛中實現宿主程式的介面這裡要注意，外掛介面的包名要和宿主程式中的一樣。3、將外掛打包成dex檔案，注意不能講宿主介面打包，否則在呼叫時會

Android 中的 Service 全面總結

按執行地點分類： 類別 區別  優點 缺點   應用 本地服務（Local） 該服務依附在主程序上，  服務依附在主程序上而不是獨立的程序，這樣在一定程度上節約了資源，另外Local服務因為是

Android四大元件之Service全面解析（一）

 在小杰的上一篇博文中給大家講了一下Android四大元件之一的Activity，也是最重要的，這一篇文章，給大家講一下Service。 什麼是Service  Service是Android的四大元件之一應用廣泛，它是一個能在後臺進行一個長時間的操作並且不提供使用者介面

android 框架之WIFI系統和系統架構全面總結（一）。

知識就本來就是滾雪球，越滾才越大！ 在瞭解WIFI模組的系統架構之前。我心中就有一個疑問，那麼android的系統架構是怎樣的呢。其實現在網路中有很多關於android系統架構的描述和解釋，在這裡我不做詳細的研究了，只是貼張圖重新溫故一下。具體細節還要檢視android原始

Android 中Service 和Activity之間傳值。（涉及BroadCast的基本用法）

首先先建立一個Android工程（名字自定義）這裡我命名為MyActivity 包名為：package org.hm.myactivity; 再最後給自己的activity命名（名字自定義）此處我命名為MyTestActivity public class MyTestA

Android中Service的使用詳解和注意點（LocalService）

開始，先稍稍講一點android中Service的概念和用途吧~ Service分為本地服務（LocalService）和遠端服務（RemoteService）： 1、本地服務依附在主程序上而不是獨立的程序，這樣在一定程度上節約了資源，另外Local服務因為是在同一程序因此

Android中顯示Html內容（總結）

效果圖如下： 首先，Android中顯示Html內容，有3中方式：（目前我用到的有這3種） 1、可以利用Android原生的Html.fromHtml(str, imageGetter, tagHandler)來進行顯示。（不過，我這邊用了，即使加了頁面載入動畫，還是

Android中檔案讀寫（輸入流和輸出流）操作總結（附原始碼）

Android中檔案讀寫操作 1. Android中檔案讀寫的原理： (1).所有檔案的儲存都是位元組的儲存。 (2).在磁碟上保留的並不是檔案的字元而是先把字元編碼成位元組,再儲存這些位元組到磁碟。 (3).在讀取檔案(

Android中Service(服務)和Thread（執行緒）的關係

一、Service(服務) Service是Android中四大元件之一，在Android開發中起到非常重要的作用，先來看一下官方對Service的定義： A  is an application component that can perform long-ru

最詳細的 Android Toolbar 開發實踐總結（轉）

activity resource listener nba flat xmlns mat https ons 轉自：http://www.codeceo.com/article/android-toolbar-develop.html 過年前發了一篇介紹 Transluc

OpenGL在MFC中的使用總結（一）——基本框架

palette 接受 white 要求 無效 結構 del 一次 是你 項目中要畫3D顯示的模型，於是要用到OpenGL,加上是在MFC中，並且是在MFC中的ActiveX中使用。再並且鑒於他們程序主框架的設定。常規的方法還不一定能實現。所以還是查過不少資料，在此一一總

兔子--ps中的基本工具總結（ps cs5）

計數 手工 背景 滾動 高速 pop 基本 工具 史記 矩形選框工具 橢圓選框工具 單行選框工具 單列選框工具 移動工具 套索工具櫃 多邊形套索工具 磁性套索工具 魔棒工具 高速選擇工具 裁剪工具 切片工

【Android-3】Android中的任務棧（Task）

集合 情況下 清除 bsp 生命周期方法 任務棧 保存 sin 也會 一、Android任務棧 概述：Android中的任務棧其實就是Activity的集合，在Android中退出程序的時候必須把任務棧中的所有Activity清除出棧，此時才能安全的完全的退出程序， 任務棧

Java中各種集合總結（一）

分享圖片 link 抽象類 解決 集合 1.0 分享 arr 抽象 （一）集合與數組 數組：（存基本數據類型）-->存對象的一種容器，長度固定，【不適合在對象數量未知的情況下使用】 集合：（存對象，對象類型可以不一樣）-->長度可變，可在多數情況下使用。 （二）

Java學習總結（十六）——MySQL數據庫（中）分組，嵌套，連接查詢及外鍵與關系表設計

MySQL數據庫 分組查詢 連接查詢 子查詢 外鍵與關系表設計 一．分組查詢 1.語法：group by 分組字段1[,分組字段2,.........] [having 分組後的篩選條件]2.註意：分組字段應該與select後的查詢字段一致，否則查詢結果無意義3.分組查詢經常會與聚合函

Butterknife--Android Butterknife使用方法總結（轉）

black inner 混淆 ora RoCE max 通過 要點 vat 原文鏈接：http://blog.csdn.net/donkor_/article/details/77879630 前言： ButterKnife是一個專註於Android系統的View註入框架,

Android中的對話方塊（AlertDialog）

建立android中分體式對話方塊需要四個步驟： 第一：獲得AlertDialog的靜態內部類Builder物件，有該類建立對話方塊。 第二：通過Builder物件設定對話方塊的標題，按鈕UI及將要響應的事件。、 第三：呼叫Builder的Create（）方法建立對對話方塊 第四