原始碼分析相關面試題

Activity相關面試題

Service相關面試題

與XMPP相關面試題

與效能優化相關面試題

與登入相關面試題

與開發相關面試題

與人事相關面試題

一 容器式：

建立一個全域性容器，把所有的Activity儲存起來，退出時迴圈遍歷finish所有Activity

public class BaseActivity extends AppCompatActivity {
    @Override
    public void onCreate(@Nullable Bundle savedInstanceState ) {
        super
 
.onCreate(savedInstanceState);
        ActivityManager.getActivityManager().addActivity(this);
    }
    @Override protected void onDestroy() {
        super.onDestroy();
       //  結束Activity&從棧中移除該Activity
        ActivityManager.getActivityManager().finishActivity();
    }

}



public class ActivityManager
 
 {
        // Activity棧
        private static Stack<Activity> activityStack;
        // 單例模式
        private static ActivityManager instance;

        private ActivityManager() {
        }

        /**
         * 單一例項
         */
        public static ActivityManager getActivityManager() {
            if
 
 (instance == null) {
                instance = new ActivityManager();
            }
            return instance;
        }

        /**
         * 新增Activity到堆疊
         */
        public void addActivity(Activity activity) {
            if (activityStack == null) {
                activityStack = new Stack<Activity>();
            }
            activityStack.add(activity);
        }

        /**
         * 獲取當前Activity（堆疊中最後一個壓入的）
         */
        public Activity currentActivity() {
            Activity activity = activityStack.lastElement();
            return activity;
        }

        /**
         * 結束當前Activity（堆疊中最後一個壓入的）
         */
        public void finishActivity() {
            Activity activity = activityStack.lastElement();
            finishActivity(activity);
        }

        /**
         * 結束指定的Activity
         */
        public void finishActivity(Activity activity) {
            if (activity != null) {
                activityStack.remove(activity);
                activity.finish();
                activity = null;
            }
        }

        /**
         * 結束指定類名的Activity
         */
        public void finishActivity(Class<?> cls) {
            for (Activity activity : activityStack) {
                if (activity.getClass().equals(cls)) {
                    finishActivity(activity);
                }
            }
        }

        /**
         * 結束所有Activity
         */
        public void finishAllActivity() {
            for (int i = 0; i < activityStack.size(); i++) {
                if (null != activityStack.get(i)) {
                    activityStack.get(i).finish();
                }
            }
            activityStack.clear();
        }

        /**
         * 退出應用程式
         */
        public void AppExit(Context context) {
            try {
                finishAllActivity();
                //根據程序ID，殺死該程序
                android.os.Process.killProcess(android.os.Process.myPid());
                //退出真個應用程式
                System.exit(0);
            } catch (Exception e) {
            }
        }

}

二、廣播式

通過在BaseActivity中註冊一個廣播，當退出時傳送一個廣播，finish退出

public class BaseActivity2 extends AppCompatActivity {
    private static final String EXITACTION = "action.exit";
    private ExitReceiver exitReceiver = new ExitReceiver();
    @Override protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState); 
        IntentFilter filter = new IntentFilter(); 
        filter.addAction(EXITACTION);
        registerReceiver(exitReceiver, filter); 
    }
    @Override protected void onDestroy() { 
        super.onDestroy(); unregisterReceiver(exitReceiver);
    }
    class ExitReceiver extends BroadcastReceiver { 
        @Override public void onReceive(Context context, Intent intent) {
            BaseActivity2.this.finish(); 
        } 
    }

}

三 RxBus優雅式

首先，在基類BaseActivity裡，註冊RxBus監聽：

public class BaseActivity3 extends AppCompatActivity {
    Subscription mSubscription;

    @Override
    public void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        initRxBus();
    }
    //接收退出的指令，關閉所有activity
    private void initRxBus() {
        mSubscription = RxBus.getInstance().toObserverable(NormalEvent.class)
                .subscribe(new Action1<NormalEvent>() {
                               @Override
                               public void call(NormalEvent userEvent) {
                                   if (userEvent.getType() == -1) {
                                       finish();
                                   }
                               }
                           },
                        new Action1<Throwable>() {
                            @Override
                            public void call(Throwable throwable) {
                            }
                        });
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        if (!mSubscription.isUnsubscribed()) {
            mSubscription.unsubscribe();
        }
    }
}

這是事件實體NormalEvent:

public class NormalEvent {
    private int type;

    public NormalEvent(int type) {
        this.type = type;
    }

    public int getType() {
        return type;
    }

    public void setType(int type) {
        this.type = type;
    }
}

新建RxBus類

public class RxBus {

    private static volatile RxBus mInstance;

    private final Subject bus;


    public RxBus()
    {
        bus = new SerializedSubject<>(PublishSubject.create());
    }

    /**
     * 單例模式RxBus
     *
     * @return
     */
    public static RxBus getInstance()
    {

        RxBus rxBus2 = mInstance;
        if (mInstance == null)
        {
            synchronized (RxBus.class)
            {
                rxBus2 = mInstance;
                if (mInstance == null)
                {
                    rxBus2 = new RxBus();
                    mInstance = rxBus2;
                }
            }
        }

        return rxBus2;
    }


    /**
     * 傳送訊息
     *
     * @param object
     */
    public void post(Object object)
    {

        bus.onNext(object);

    }

    /**
     * 接收訊息
     *
     * @param eventType
     * @param <T>
     * @return
     */
    public <T> Observable<T> toObserverable(Class<T> eventType)
    {
        return bus.ofType(eventType);
    }
}

最後，在需要退出的地方呼叫：

 RxBus.getInstance().post(new NormalEvent(-1));//傳送退出指令

四：SingleTask

1、設定MainActivity的載入模式為singleTask

android:launchMode="singleTask"

2、將退出出口放置在MainActivity

private boolean mIsExit;
    @Override /** * 雙擊返回鍵退出 */
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        if (keyCode == KeyEvent.KEYCODE_BACK) {
            if (mIsExit) {
                this.finish();
            } else {
                Toast.makeText(this, "再按一次退出", Toast.LENGTH_SHORT).show();
                mIsExit = true;
                new Handler().postDelayed(new Runnable() {

                    @Override public void run() {
                        mIsExit = false;
                    }
                }, 2000);
            } return true;
        } return super.onKeyDown(keyCode, event);
    }

五、SingleTask改版式

第一步設定MainActivity的載入模式為singleTask

android:launchMode="singleTask"

第二步重寫onNewIntent()方法

private static final String TAG_EXIT = "exit"; 
    @Override
    protected void onNewIntent(Intent intent) { 
        super.onNewIntent(intent); 
        if (intent != null) { 
            boolean isExit = intent.getBooleanExtra(TAG_EXIT, false); 
            if (isExit) { this.finish();
            }
        } 
    }

第三步 退出

Intent intent = new Intent(this,MainActivity.class); intent.putExtra(MainActivity.TAG_EXIT, true); startActivity(intent);

• 歡迎關注微信公眾號,長期推薦技術文章和技術視訊

• 微信公眾號名稱：Android乾貨程式設計師