Activity中关闭另一个Activity方法汇总

Activity中关闭另一个Activity方法汇总

第一中方法: 这种情况在项目中经常会用到，所以一般会使用ActivityManager 的方式 ActivityManager manager = (ActivityManager)getSystemService(ACTIVITY_SERVICE);

1.思路是这样滴：首先封装一个AppManager类，利用Java单例模式获取AppManager这个类，如下：

`public class AppManager {
private static AppManager instance；

private AppManager() {
}

/**
 * 单一实例
 */
public static AppManager getAppManager() {
    if (instance == null) {
        instance = new AppManager();
    }
    return instance;
}`

2.利用java中Stack（栈）来添加对应的Activity,：

/**
* 添加Activity到堆栈
*/
public void addActivity(Activity activity) {
if (activityStack == null) {
activityStack = new Stack();
}
activityStack.add(activity);
}

由于用到的频率比较高，可以封装到基类BaseActivity中默认去添加，对应方法如下：

Activity的onCreate()方法中：
// 添加Activity到堆栈
        AppManager.getAppManager().addActivity(this);

3. Activity都已经加入到栈中了，在任意Activity中只需要根据需要Activity的类名来找到对应Activity，然后调用finish()方法即可，如下：

/**
* 结束指定类名的Activity
*/
public void finishActivity(Class

对应需要的地方调用方法：
------------

AppManager.getAppManager().finishActivity(XxxxxxActivity.class);

第二种方法：如果使用的的情况比较少，就没必要去将所有Activity手动添加在栈中了，直接在需要关闭的Activity中创建一个静态Activity的引用，直接利用静态特性类名去获取该Activity引用调用finish()方法即可：（XActivity中关闭YActivity）
------------------------------------------------------------------------

1.在YActivity中声明一个静态Activity的引用：
-------------------------------

private Static Activity instance = null;

2.在onCreate()方法中将该Activity赋给引用：
-------------------------------

instance = this;

3.在YActivity中需要的地方调用：
---------------------

XActivity.instance .finfish();

小结：这两种方法是对应与在一个Activity中完成某个操作再确定关闭某些对
应关系的Activity,返回不再出现不需要的Activity。对于某些开启完下一个Activity就可以注销的Activity直接就可以finish,还有另一中，必须在获取界面焦点时才会注销的，可以利用静态或者通知、setResult等传递信息，获取焦点后根据获取的信息再finish();

下面附上AppManager类封装的代码：

import android.app.Activity;
import android.content.Context;

import com.android.volley.RequestQueue;
import com.android.volley.toolbox.Volley;

import java.util.Stack;

public class AppManager {
private static Stack activityStack;
private static AppManager instance;
private static RequestQueue mGlobalQueue;

private AppManager() {
}

/**
 * 单一实例
 */
public static AppManager getAppManager() {
    if (instance == null) {
        instance = new AppManager();
    }
    return instance;
}

/**
 * 添加Activity到堆栈
 */
public void addActivity(Activity activity) {
    if (activityStack == null) {
        activityStack = new Stack();
    }
    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);
            return;//防止报错：java.util.ConcurrentModificationException（不能在对一个List进行遍历的时候将其中的元素删除掉）
        }
    }
}

//获取指定类名的Activity
public Activity getActivity(Class cls) {
    for (Activity activity : activityStack) {
        if (activity.getClass().equals(cls)) {
            return activity;
        }
    }
    return null;
}

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

/**
 * 退出应用程序
 */
public void AppExit(Context context) {
    try {
        finishAllActivity();
        System.exit(0);
    } catch (Exception e) {
    }
}

public RequestQueue getGlobalQuere(){
/*全局的请求队列,应该放在Application中*/
    if(mGlobalQueue == null){
        mGlobalQueue = Volley.newRequestQueue(AppContext.getContext());
    }
    return mGlobalQueue;
}

}

“`