目录
1.如何在一个应用程序当中定义多个Activity
1.定义一个类，继承Activity
2.在该类当中，复写Activity当中的onCreate方法
3.在AndroidManifest.xml文件当中注册该Activity
例子：
新建一个应用程序，命名为：S11_MutiActivity
1.定义一个类，继承Activity
创建成功后，我们可以在MainActivity看见有一个人默认的Activity
自己新建一个Activity，命名为：secondActivity.java，然后去继承Activity,然后复写里面的onCreate（）方法：
继承Activity然后导入Activity要使用的包
2.在该类当中，复写Activity当中的onCreate方法
复写Activity的onCreate方法：
点击shouce->Cverride/Implement Menthod..
弹出一个窗，找到onCreate方法
为了让这个Activity有东西显示，我们还需要重新定义一个布局文件，命名为：second.xml
然后再second.xml添加一个TextView控件：
接下来在SecondActivity，使用setContentView（）这个方法把布局文件设置进去以便显示在Activity上：
3.在AndroidManifest.xml文件当中注册该Activity
打开Manifest.xml文件：
在Manifest.xml注册second.xml这个Activity并设置属性
代码如下：
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.yuan.s11_mutiactivity"
android:versionCode="1"
android:versionName="1.0" >
<uses-sdk
android:minSdkVersion="8"
android:targetSdkVersion="17" />
<application
android:allowBackup="true"
android:icon="@drawable/ic_launcher"
android:label="@string/app_name"
android:theme="@style/AppTheme" >
<activity
android:name="com.yuan.s11_mutiactivity.MainActivity"
android:label="@string/app_name" >
</activity>
<activity
android:name="com.yuan.s11_mutiactivity.secondActivity"
android:label="secondActivity">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
</manifest>现在试运行这个应用程序，可见程序运行了我们刚新建的secondActivity：
现在经过上面的设置我们可以使用多个Activity，但是我们需要去手动去更改代码，然后去默认启动特定的Activity，如何通过程序设置的方法切换Activity呢？
2.启动一个Activity的方法
1.生成一个意图对象（Intent）
2.调用setClass方法设置所要启动的Activity
3.调用startActivity方法启动Activity
例子：
还是使用原来的应用程序， S11_MutiActivity、
我们设置这样一个程序，默认开启第一个Activity就是activityz_main_xml这个，然后再这个应用程序设置一个按钮，当点击了这个按钮之后，我们进入第二个Acitivity也就是名为second的Activity.
把Mainfest.xml中默认启动的Activity改回来：
在第一个Activity增加一个按钮，和一个TextView显示信息，activity_main.xml中代码如下：
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingBottom="@dimen/activity_vertical_margin"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
tools:context=".MainActivity" >
<TextView
android:id="@+id/firstTextViewId"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:background="#00ff00"
android:gravity="center"
android:textSize="20dp"
android:text="这是第一个Activity"/>
<Button
android:id="@+id/buttonId"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="启动secondActivity"
android:layout_below="@id/firstTextViewId"
android:layout_marginTop="50dp"/>
</RelativeLayout>视图如下：
然后在MainActivity中的去实现button的监听器，并绑定监听器，在监听器实现类的onClick方法中，去启动另一个Activity,
根据步骤：
1.生成一个意图对象（Intent）
2.调用setClass方法设置所要启动的Activity
3.调用startActivity方法启动Activity(注意：你需要启动的Activity,一定要现在Mainfest文件进行注册)
整体代码如下：
package com.yuan.s11_mutiactivity;
import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.Menu;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
public class MainActivity extends Activity {
private Button button;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//获取标签控件用对象表示
button = (Button)findViewById(R.id.buttonId);
//生成button类监听器实现类对象，并为button点击绑定监听器
OnButtonListener buttonLitener = new OnButtonListener();
button.setOnClickListener(buttonLitener);
}
class OnButtonListener implements OnClickListener{
public void onClick(View v) {
//生成意图对象
Intent intent = new Intent();
//调用意图的方法，setClass方法
//setClass函数的第一个参数是Context对象
//Context是一个类，Activity是Context的一个子类
//所以所有的Activity对象，都可以向上转型为Context对象
//----->|传入Activity对象，使用：MainActivity.this |<------
//直接填this,表示是调用这个函数的对象，就是button了
//setClass函数的第二个参数是一个Class对象
//在当前场景，应填入需要被启动的Activity的Class对象
intent.setClass(MainActivity.this, secondActivity.class);
//调用startActivity,启动这个intent，这个意图就是打开另一个Activity
startActivity(intent);
}
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.main, menu);
return true;
}
}
运行这个应用程序，当进入第二个Activity,按返回键，就可以回到第一个Activity：
3.Android当中的back stack（后退栈）
从上面的实验知道，当我们启动模拟机的时候是启动默认的Activity，就调用了这个Activity的onCreate方法，后退栈是一个栈，放的是Activity对象，当我们启动了这个Activity，这个后退栈就存放了就存放了这个对象，但我们启动另一个Activity的时候，这个back stack就又存放了第二个Activity对象，如果有三个四个..都会存放在back stack中。
那这个栈的作用什么呢？
栈的特点是什么：先进后出。
此时假设我们在第三个Acitvity中，我们按后退键，此时，第三个Activity就会从栈顶移除，那么此时栈顶元素就是第二个Activity,以此类推，再次按后退键，那么栈顶元素就是第一个Activity。
小结：所以说，栈顶记住的就是Activity的启动顺序，就像我们的网页一样，当我们按返回键的时候，网页就返回到上一次的界面，而屏幕只显示栈顶元素的对象。
4.什么是Activity生命周期
比如：人的生命周期，从出生，到青年、中年、老年、直至死亡，人在每一阶段做的事情是不一样的，人在生命的每一个阶段都有每一阶段应该做的事情，如果在你的人生阶段做了你这个阶段不应该做的事，可能就会违背常理，变得整个人生就会出现问题。
转回正题：
每一个对象也是有生命周期的，从创建出来到销毁这个对象都要经历哪些阶段，而哪个阶段应该对哪些事情。
我们看看官方给出Activity给出的声明周期的逻辑图：
Activity的生命周期函数
人的生命周期，在人生的不同阶段做不同的事情，一个Activity对象从被创建出来到销毁，也分为很多阶段，而每一个阶段都会去执行一个函数，这些函数就被称为Activity的生命周期函数，注意，Activity生命周期函数不是由程序员调用的，是由Android操作系统去调用管理的，这些函数是本身Activity自身携带的函数，我们的任务就需要在这些函数当中复写这些生命周期函数，然后填写相应的代码。
| 生命周期函数 | 函数说明 | 调用时机 |
| onCreate( ) | 表示activity正在被创建，这是生命周期的第一个方法。我们可以在这里做加载布局，setContentView(), 初始化Activity所需的资源等 | 在Activity对象被第一次创建时调用 |
| onRestart( ) | 表示Activity正在被重新启动，一般情况下，当前Activity从不可见到可见，onStart方法就会被调用。这种情况一般是由于用户操作导致的，例如用户在当前Activity界面点击home键或者打开一个其他的activity, activity的onPause,onStop方法就会被调用。接着这个用户又回到这个Activity界面，就会回调onRestart方法 | 当一个Activity再次启动之前调用此方法 |
| onStart( ) | 表示Activity正在被启动，这个时候activity其实已经可见了。但是没有出现在前台，还无法和用户交互。这个时候其实可以理解为Activity已经显示出来了，但是我们看不到 | 在Activity变得可见时调用 |
| onResume( ) | 表示Activity已经可见了，并且出现在前台并可以开始活动。要注意这个和onStart的区别，这两个方法都表示Acitivity可见了。但是onStart的时候Activity还是在后台，onResume的时候才显示在前 | 当Activity开始准备与用户交互时调用 |
| onPause( ) | 表示Activity正在停止，正常情况下，紧跟着onStop()方法就会被调用。这个时候可以做一些存储数据，停止动画的工作，但是要注意不能太延时，会影响到新的Activity的显示，onPause必须先执行完，新的Activity的onResume方法才会执行 | 当系统即将启动另一个Acitvity之前调用该方法 |
| onStop( ) | 表示Activity即将停止，可以做一些重量级的回收工作，同样不能太耗时 | 当前Activity变得不可见时调用该方法 |
| onDestory( ) | 表示Activity即将被销毁，这是Activity生命周期的最后一个回调方法，可以做一些回收工作和最终的资源释放 | 当前Activity被销毁之前将会调用该方法 |
例子：
新建一个应用程序，命名为：S11_ActivityLifeCycle
可以发现在MainActivity已经有了onCreate这个方法了，表示activity正在被创建，这是生命周期的第一个方法。
接下来我们复写其他几个生命周期的函数：
复写函数，如下所示，Activity生命周期方法：
我们在每一个生命周期函数打印一句话：
如下所示：
package com.yuan.s11_activitylifecycle;
import android.os.Bundle;
import android.app.Activity;
import android.view.Menu;
public class MainActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
System.out.println("MainActivity:onCreate");
}
protected void onDestroy() {
super.onDestroy();
System.out.println("MainActivity:onDestroy");
}
protected void onPause() {
super.onPause();
System.out.println("MainActivity:onPause");
}
protected void onRestart() {
super.onRestart();
System.out.println("MainActivity:onRestart");
}
protected void onResume() {
super.onResume();
System.out.println("MainActivity:onResume");
}
protected void onStart() {
super.onStart();
System.out.println("MainActivity:onStart");
}
protected void onStop() {
super.onStop();
System.out.println("MainActivity:onStop");
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.main, menu);
return true;
}
}
运行这个应用程序，首先肯定是先执行MainActivity这个Activity,然后依次执行了onCreate——》onStart——》onResume：
例如：每个人生命都有少年、中年、老年，这些阶段都有他们自己要做的是事，而这些事就相当于生命周期这些方法，而每个人在每个阶段要去做的事，是由这个人自己去决定的，而不是上帝安排的，也就是说，Android操作系统给你这些阶段，系统不会告诉你这些阶段去干什么，做什么你自己去决定。
新建一个Activity,命名为：secondActivity
然后继承Activity这个类，并导入包：
然后复写生命周期函数，依然在每一个阶段都打印，一句话：
package com.yuan.s11_activitylifecycle;
import android.app.Activity;
import android.os.Bundle;
public class SecondActivity extends Activity {
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.second_activity);
System.out.println("SecondActivity:onCreate");
}
protected void onDestroy() {
super.onDestroy();
System.out.println("SecondActivity:onDestroy");
}
protected void onPause() {
super.onPause();
System.out.println("SecondActivity:onPause");
}
protected void onRestart() {
super.onRestart();
System.out.println("SecondActivity:onRestart");
}
protected void onResume() {
super.onResume();
System.out.println("SecondActivity:onResume");
}
protected void onStart() {
super.onStart();
System.out.println("SecondActivity:onStart");
}
protected void onStop() {
super.onStop();
System.out.println("SecondActivity:onStop");
}
}
然后增加一个布局文件，命名为：second_activity.xml
在 second_activity布局文件加一个TextView,用来显示这个Activity显示的内容，根据我们上面的操作，还需要，在AdroidManifest.xml文件注册这个Activity之后才可以使用这个Activity：
在AdroidManifest.xml文件注册 ：
和上面一样，在默认的Activity通过一个按钮来启动SecondActivity,这个步骤和上面重复了，故不赘述：
在MainActivity布局文件的代码如下：
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent">
<TextView
android:id="@+id/firstTextViewId"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:gravity="center"
android:textSize="20dp"
android:background="#00ff00"
android:text="这是默认的Activity"/>
<Button
android:id="@+id/buttonId"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="启动SecondActivity"
android:layout_below="@id/firstTextViewId"
android:layout_marginTop="20dp"/>
</RelativeLayout>视图如下：
然后再MainActivity的类复写的函数，的onCreate添加内容，然后复写button监听器接口，然后绑定监听器，代码如下：
package com.yuan.s11_activitylifecycle;
import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.Menu;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
public class MainActivity extends Activity {
//生命引用
private Button button;
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
System.out.println("MainActivity:onCreate");
//获取控件的标签用对象表示
button =(Button)findViewById(R.id.buttonId);
//生成监听器实现类的对象，并为button绑定监听器
OnButonListener listener = new OnButonListener();
button.setOnClickListener(listener);
}
protected void onDestroy() {
super.onDestroy();
System.out.println("MainActivity:onDestroy");
}
protected void onPause() {
super.onPause();
System.out.println("MainActivity:onPause");
}
protected void onRestart() {
super.onRestart();
System.out.println("MainActivity:onRestart");
}
protected void onResume() {
super.onResume();
System.out.println("MainActivity:onResume");
}
protected void onStart() {
super.onStart();
System.out.println("MainActivity:onStart");
}
protected void onStop() {
super.onStop();
System.out.println("MainActivity:onStop");
}
class OnButonListener implements OnClickListener{
public void onClick(View v) {
//生成意图对象
Intent intent = new Intent();
intent.setClass(MainActivity.this,SecondActivity.class );
//调用startActivity,启动这个intent，这个意图就是打开另一个Activity
startActivity(intent);
}
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.main, menu);
return true;
}
}
以上已经完成了所有程序的部署工作，接下来我们就要运行这个程序，然后根据CatLog输出去看一下生命周期的规律：
1.然后现在点击按钮启动SecondActivity,再次调用MainActivity的onPause方法（当系统即将启动另一个Acitvity之前调用该方法）
2.然后再依次调用SecondActivity的onCreate方法（在Activity对象被第一次创建时调用）
3.——>onStart方法（在Activity变得可见时调用）
4.——>onResume方法（当Activity开始准备与用户交互时调用）
5.最后调用MianActivity的onStop方法（当前Activity变得不可见时调用该方法）
如果此时我们按返回键的话，会是什么结果呢？
1.首先调用SecondActivity的onPause方法（当系统即将启动另一个Acitvity之前调用该方法）
2.然后调用MainActivity的onRestart方法（当一个Activity再次启动之前调用此方法）这里注意了，因为我们上面说过因为运行过所以是存在back stack(历史栈)当中的不需要重新创建。
3.——>onStart方法（在Activity变得可见时调用）
4.——>onResume方法（当Activity开始准备与用户交互时调用）
5.然后调用SecondActivity的onStop方法（当前Activity变得不可见时调用该方法）
6.——>onDestory方法（当前Activity被销毁之前将会调用该方法）
5.Activity对象的状态
1.Resumed:Activity处于运行状态
2.Paused：另一个Activity处于前端（弹窗），但是本Activity还可见
3.Stoped：另一个Activity位于前端，完全遮挡本Activity.
2.成对的生命周期函数
从上面可以看出生命周期函数是成对出现的：
比如：onResume 和 onPause onStart 和 onStop onCreate和onDestory
3 .生命周期函数的意义：
举例子：比如你现在的功能是播放音乐的播放器，我们需要去启动这个线程，那我们放在哪个生命周期函数合适呢？只要能播放就行了吗？
加入放在我们所熟悉的onCreate方法中，当运行这个播放器的Activity时，首先运行onCreate方法，启动播放器这个线程，屏幕显示歌词，喇叭播放声音，生命周期也会接着执行onStart和onResume 然后Resumed:Activity处于运行状态，但是，这时候就来一个电话，这个电话的Activity会全部遮挡住当前的播放器的Activity，那么播放器的Activity就会依次去执行onPause和onStop方法，去结束这个播放器的线程，电话接通结束，电话的Activity已经没有遮挡了，此时，应该调用onRestart和onStart方法，但是因为把启动播放器这个线程放在onCreate方法里了，所以说没有办法去启动这个线程了。所以通过一个小例子，说明这样不行，Android操作系统并没有去限制你在生命周期的哪些阶段都干些什么事，都是根据你自己的需要，去编写这些函数的代码。
附录：
本博文Demo下载：https://github.com/zGuangYuan/Android-
github的用法：点我查看