简单易懂，一步一步带你入门Activity

2024-06-02 11:58
文章标签 简单 入门 activity 易懂 一步

本文主要是介绍简单易懂，一步一步带你入门Activity，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

文章目录

    • 什么是Activity？
    • Activity四种状态
      • 1.Running
      • 2.Paused
      • 3.Stopped
      • 4.Killed
    • 生命周期
      • 正常情况生命周期
      • 异常情况生命周期
      • 特殊情况生命周期
    • 启动模式
      • 什么是任务栈
      • 为什么需要启动模式
      • 启动模式的种类和特性
    • Activity 组件之间的通信

在这里插入图片描述

什么是Activity？

开门见山，既然要介绍Activity，那我们现在要明白Activity是干什么的？
在这里插入图片描述
以上是百度百科概要说明，总结一句话就是:Activity就是负责与用户交互的一个应用组件，显示的页面。

Activity四种状态

在这里插入图片描述

1.Running

当前Activity正处于运行状态，指的是当前Activity获取了焦点

2.Paused

当前Activity正处于暂停状态，指的是当前Activity失去焦点，此时的Activity并没有被销毁，内存里面的成员变量，状态信息等仍然存在，当然这个Activity也仍然可见，但是焦点却不在它身上。

3.Stopped

stopped状态的Activity是完全不可见的，但是内存里面的成员变量，状态信息等仍然存在，但是也没有被销毁。

4.Killed

已经被销毁的Activity才处于killed状态，它的内存里面的成员变量，状态信息等都会被一并回收。

生命周期

在这里插入图片描述
Activity生命周期的方法说明:
onCreate():
 表示Activity正在被创建，通常我们在此函数中做初始化的工作，比如：绑定布局，控件，初始化数据等。

onStart():
 表示Activity正在被启动，这时Activity已经被创建好，但没有出现在前台，需执行onResume()函数才可以进入到前台与用户进行交互。

onResume():
 表示Activitiy已经可见，并且Activity处于运行状态，也就是Activity不止出现在了前台，而且还可以让用户点击，滑动等等操作与它进行交互。

onPause():
 表示Activity正在暂停，大多数情况下，Activity执行完onPause()函数，再执行另外Activity后会继续执行onStop()函数，造成这种函数调用的原因是当前的Activity启动了另外一个Activity或者回切到上一个Activity。还有一种情况就是onPause()函数被单独执行了，并没有附带执行onStop()方法，造成这种函数调用的原因很简单，就是当前Activity里启动了类似于对话框。

onStop():
 表示Activity即将停止，我们在此函数中做一些不那么耗时的轻量级回收操作。

onRestart():
 表示Activity正在重新启动。一般情况下，一个存在于后台不可见的Activity变为可见状态，都会去执行onRestart()函数，然后会继续执行onStart()函数，onResume()函数出现在前台并且处于运行状态。

onDestory():
 表示Activity要被销毁了。这是Activity生命周期中的最后一个阶段，我们可以在onDestory()函数中做一些回收工作和资源释放等，比如：广播接收器的注销等。

正常情况生命周期

	1.ActivityA启动–>onCreate()–>onStart()–>onResume()2.点击home键回到桌面–>onPause()–>onStop()3.再次回到原ActivityA时–>onRestart()–>onStart()–>onResume()4.ActivityA跳转到ActivityB->onPause(A)->onCreate(B)->onStart(B)->onResume(B)->onStop(A)5.ActivityB返回键到ActivityA-> onPause(B)->onRestart(A)->onStart(A)->onResume(A)->onStop(B)->onDestroy(B)4.退出当前ActivityA时–>onPause()–>onStop()–>onDestroy()

异常情况生命周期

1.资源相关配置发生改变导致Activity被杀死并重新创建
在这里插入图片描述
上图就是资源配置文件发生改变的生命周期图。
比如一个场景：我们显示一张图片，为了兼容不同设备，需要在其他目录放置不同的图片，比如drawable-mdpi and drawable-hdpi目录下。我们突然旋转屏幕，由于系统配置发生了改变，默认情况，页面会被销毁并且重新创建。
下面我们模拟下上面场景：

1.上代码：

@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);String outState=null;if(savedInstanceState!=null){outState=savedInstanceState.getString("mBundle");}Log.i(TAG,"onCreate:"+outState);}@Overrideprotected void onSaveInstanceState(Bundle outState) {super.onSaveInstanceState(outState);Log.i(TAG,"onSaveInstanceState");outState.putString("mBundle","outState");}@Overrideprotected void onRestoreInstanceState(Bundle savedInstanceState) {super.onRestoreInstanceState(savedInstanceState);String outState=savedInstanceState.getString("mBundle");Log.i(TAG,"onRestoreInstanceState:"+outState);}@Overrideprotected void onDestroy() {super.onDestroy();Log.i(TAG,"onDestroy");}

2.真机操作
竖屏(没有旋转)
在这里插入图片描述
在这里插入图片描述
此时正常启动，获取的值为null，说明只执行了onCreate方法，onSaveInstanceState和onRestoreInstanceState方法没有执行。

横屏（有旋转）
在这里插入图片描述
在这里插入图片描述
我们旋转屏幕，资源配置发生了改变，页面销毁重建。 执行循序是:onSaveInstanceState->onDestroy->onCreate->onRestoreInstanceState。

特殊情况生命周期

再拿横竖屏切换来讲述，但现在唯一改变的是设置了相关属性android:configChanges的值。

  1. orientation：消除横竖屏的影响
  2. keyboardHidden：消除键盘的影响
  3. screenSize：消除屏幕大小的影响

当我们设置Activity的android:configChanges属性为orientation或者orientation|keyboardHidden或者不设置这个属性的时候，它的生命周期会走如下流程：
在这里插入图片描述
当我们设置Activity的android:configChanges属性为orientation|screenSize或者orientation|screenSize|keyboardHidden
在这里插入图片描述
对比两图的生命周期，正常旋转是销毁重新创建页面，并执行相应生命周期的，但设置orientation|screenSize后，旋转的时候，相应生命周期是不会执行，并执行onConfigurationChanged()。
这也很好解决旋转屏幕，不重新初始化页面功能。

启动模式

什么是任务栈

  1. android任务栈又称为Task，它是一个栈结构，具有后进先出的特性，用于存放我们的Activity组件。
  2. 我们每次打开一个新的Activity或者退出当前Activity都会在一个称为任务栈的结构中添加或者减少一个Activity组件，因此一个任务栈包含了一个activity的集合, android系统可以通过Task有序地管理每个activity，并决定哪个Activity与用户进行交互:只有在任务栈栈顶的activity才可以跟用户进行交互。
  3. 在我们退出应用程序时，必须把所有的任务栈中所有的activity清除出栈时,任务栈才会被销毁。当然任务栈也可以移动到后台, 并且保留了每一个activity的状态. 可以有序的给用户列出它们的任务, 同时也不会丢失Activity的状态信息。
  4. 需要注意的是，一个App中可能不止一个任务栈，某些特殊情况下，单独一个Actvity可以独享一个任务栈。还有一点就是一个Task中的Actvity可以来自不同的App，同一个App的Activity也可能不在一个Task中。

为什么需要启动模式

我们在开发项目时:

  1. 一般都需要在本应用中多个Activity组件之间的跳转。
  2. 也可能需要在本应用中打开其它应用的可复用的Activity。
  3. 我们点击屏幕太快，一个页面被调用多次。
  4. 每开启一个Activity，加入到任务栈，保留数据沉余，重复数据太多，造成内存溢出。

这些都需要用到启动模式来解决。

启动模式的种类和特性

Activity的启动模式有四种:standard，singleTop，singTask和singleInstance

  • Standard 模式

    系统的默认模式（可以不指定），在这样模式下，每启动一个Activity都会重新创建一个Activity的新实例，并且将其加入任务栈中，而且完全不会去考虑这个实例是否已存在。
    我们通过图解来更清晰地了解Standard模式：
    在这里插入图片描述
    通过上图，我们可以发现，这个过程中，在standard模式下启动了三次MainActivity后，都生成了不同的新实例，并添加到同一个任务栈中。这个时候Activity的onCreate、onStart、onResume方法都会被调用。

上代码:

public class MainActivity extends AppCompatActivity {final String TAG="MainActivityA";@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);Log.i(TAG,"onCreate");}@Overrideprotected void onSaveInstanceState(Bundle outState) {super.onSaveInstanceState(outState);Log.i(TAG,"onSaveInstanceState");outState.putString("mBundle","outState");}@Overrideprotected void onRestoreInstanceState(Bundle savedInstanceState) {super.onRestoreInstanceState(savedInstanceState);String outState=savedInstanceState.getString("mBundle");Log.i(TAG,"onRestoreInstanceState:"+outState);}@Overridepublic void onConfigurationChanged(Configuration newConfig) {super.onConfigurationChanged(newConfig);Log.i(TAG,"onConfigurationChanged");}@Overrideprotected void onStart() {super.onStart();Log.i(TAG,"onStart");}@Overrideprotected void onResume() {super.onResume();Log.i(TAG,"onResume");}@Overrideprotected void onRestart() {super.onRestart();Log.i(TAG,"onRestart");}@Overrideprotected void onPause() {super.onPause();Log.i(TAG,"onPause");}@Overrideprotected void onStop() {super.onStop();Log.i(TAG,"onStop");}@Overrideprotected void onDestroy() {super.onDestroy();Log.i(TAG,"onDestroy");}public void intoMainTwo(View v){new Thread() {@Overridepublic void run() {super.run();try {Thread.sleep(2000);//休眠2秒} catch (InterruptedException e) {e.printStackTrace();}Intent it=new Intent(MainActivity.this,MainActivity.class);startActivity(it);}}.start();}
}

在这里插入图片描述
可以看出，除了启动时执行onCreate、onStart、onResume方法，启动三次MainActivity页面，调用了三次onCreate、onStart、onResume方法。这就证明系统默认模式(standard)每启动一个Activity都会重新创建一个Activity的新实例。

  • singleTop 模式
    singleTop为栈顶复用模式，如果有新的Activity已经存在任务栈的栈顶，那么此Activity就不会被重新创建新实例，而是复用已存在任务栈栈顶的Activity。如果新的Activity的实例已存在但没有位于栈顶，那么新的Activity仍然会被重建。需要注意的是，Activity的onNewIntent方法会被调用，方法原型如下：
@Override
protected void onNewIntent(Intent intent) {super.onNewIntent(intent);
}

通过此方法的参数，我们可以获取当前请求的相关信息，此时Activity的onCreate、onStart方法不会被调用，因为Activity并没有被重建。同理，我们通过图解来协助我们更清晰的理解singleTop模式：
在这里插入图片描述
从上图我们可以看出，当需要新创建的MainActivity位于栈顶时，MainActivity并没有重新创建。
上代码:

 <activityandroid:name=".MainActivity"android:launchMode="singleTop"></activity><activity android:name=".OtherActivity"><intent-filter><action android:name="android.intent.action.MAIN" /><category android:name="android.intent.category.LAUNCHER" /></intent-filter></activity>

public class OtherActivity extends AppCompatActivity {final String TAG="OtherOrMainActivity";@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_other);Log.i(TAG,"onCreate_Other");}public void intoOtherMain(View v){Intent it=new Intent(OtherActivity.this,MainActivity.class);startActivity(it);}
}

MainActivity 同上面standard代码一致。
在这里插入图片描述
上图可以看出，MainActivity设置为singleTop模式，MainActivity位于栈顶，启动三次MainActivity，是没有调用onCreate、onStart方法。证明MainActivity并没有重新创建。

下面我们再来看看新创建的MainActivity没有位于栈顶的情况。
在这里插入图片描述
上代码:

<activityandroid:name=".MainActivity"android:launchMode="singleTop"><intent-filter><action android:name="android.intent.action.MAIN" /><category android:name="android.intent.category.LAUNCHER" /></intent-filter>
</activity><activity android:name=".OtherActivity"/>

public class MainActivity extends AppCompatActivity {final String TAG="OtherOrMainActivity";@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);Log.i(TAG,"onCreate");}@Overrideprotected void onSaveInstanceState(Bundle outState) {super.onSaveInstanceState(outState);Log.i(TAG,"onSaveInstanceState");outState.putString("mBundle","outState");}@Overrideprotected void onRestoreInstanceState(Bundle savedInstanceState) {super.onRestoreInstanceState(savedInstanceState);String outState=savedInstanceState.getString("mBundle");Log.i(TAG,"onRestoreInstanceState:"+outState);}@Overridepublic void onConfigurationChanged(Configuration newConfig) {super.onConfigurationChanged(newConfig);Log.i(TAG,"onConfigurationChanged");}@Overrideprotected void onStart() {super.onStart();Log.i(TAG,"onStart");}@Overrideprotected void onResume() {super.onResume();Log.i(TAG,"onResume");}@Overrideprotected void onRestart() {super.onRestart();Log.i(TAG,"onRestart");}@Overrideprotected void onPause() {super.onPause();Log.i(TAG,"onPause");}@Overrideprotected void onStop() {super.onStop();Log.i(TAG,"onStop");}@Overrideprotected void onDestroy() {super.onDestroy();Log.i(TAG,"onDestroy");}public void intoMainTwo(View v){Intent it=new Intent(MainActivity.this,OtherActivity.class);startActivity(it);}
}

public class OtherActivity extends AppCompatActivity {final String TAG="OtherOrMainActivity";@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_other);Log.i(TAG,"onCreate_Other");}@Overrideprotected void onSaveInstanceState(Bundle outState) {super.onSaveInstanceState(outState);Log.i(TAG,"onSaveInstanceState_Other");outState.putString("mBundle","outState");}@Overrideprotected void onRestoreInstanceState(Bundle savedInstanceState) {super.onRestoreInstanceState(savedInstanceState);String outState=savedInstanceState.getString("mBundle");Log.i(TAG,"onRestoreInstanceState_Other:"+outState);}@Overridepublic void onConfigurationChanged(Configuration newConfig) {super.onConfigurationChanged(newConfig);Log.i(TAG,"onConfigurationChanged_Other");}@Overrideprotected void onStart() {super.onStart();Log.i(TAG,"onStart_Other");}@Overrideprotected void onResume() {super.onResume();Log.i(TAG,"onResume_Other");}@Overrideprotected void onRestart() {super.onRestart();Log.i(TAG,"onRestart_Other");}@Overrideprotected void onPause() {super.onPause();Log.i(TAG,"onPause_Other");}@Overrideprotected void onStop() {super.onStop();Log.i(TAG,"onStop_Other");}@Overrideprotected void onDestroy() {super.onDestroy();Log.i(TAG,"onDestroy_Other");}public void intoOtherMain(View v){new Thread() {@Overridepublic void run() {super.run();try {Thread.sleep(2000);//休眠2秒} catch (InterruptedException e) {e.printStackTrace();}Intent it=new Intent(OtherActivity.this,MainActivity.class);startActivity(it);}}.start();}
}

在这里插入图片描述
看到没，这就是设置MainActivity 为栈顶模式，但MainActivity 没有在栈顶。启动三次MainActivity ,MainActivity 只执行一次onCreate方法，后两次不会重新执行onCreate方法。这种模式通常比较适用于接收到消息后显示的界面，如qq接收到消息后弹出Activity界面，如果一次来10条消息，总不能一次弹10个Activity，是吧？

  • singleTask 模式
    又称为栈内复用模式。这是一种单例模式，与singTop点类似，只不过singTop是检测栈顶元素是否有需要启动的Activity，而singTask则是检测整个栈中是否存在当前需要启动的Activity，如果存在就直接将该Activity置于栈顶，并将该Activity以上的Activity都从任务栈中移出销毁，同时也会回调onNewIntent方法。情况如下图：
    在这里插入图片描述
    上代码
<activityandroid:name=".MainActivity"android:launchMode="singleTask"><intent-filter><action android:name="android.intent.action.MAIN" /><category android:name="android.intent.category.LAUNCHER" /></intent-filter>
</activity><activity android:name=".OtherActivity" /><activity android:name=".StartActivity"></activity>

public class MainActivity extends AppCompatActivity {final String TAG="OtherOrMainActivity";@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);Log.i(TAG,"onCreate");}@Overrideprotected void onSaveInstanceState(Bundle outState) {super.onSaveInstanceState(outState);Log.i(TAG,"onSaveInstanceState");outState.putString("mBundle","outState");}@Overrideprotected void onRestoreInstanceState(Bundle savedInstanceState) {super.onRestoreInstanceState(savedInstanceState);String outState=savedInstanceState.getString("mBundle");Log.i(TAG,"onRestoreInstanceState:"+outState);}@Overridepublic void onConfigurationChanged(Configuration newConfig) {super.onConfigurationChanged(newConfig);Log.i(TAG,"onConfigurationChanged");}@Overrideprotected void onStart() {super.onStart();Log.i(TAG,"onStart");}@Overrideprotected void onResume() {super.onResume();Log.i(TAG,"onResume");}@Overrideprotected void onRestart() {super.onRestart();Log.i(TAG,"onRestart");}@Overrideprotected void onPause() {super.onPause();Log.i(TAG,"onPause");}@Overrideprotected void onStop() {super.onStop();Log.i(TAG,"onStop");}@Overrideprotected void onDestroy() {super.onDestroy();Log.i(TAG,"onDestroy");}public void intoMainTwo(View v){Intent it=new Intent(MainActivity.this,OtherActivity.class);startActivity(it);}
}

public class OtherActivity extends AppCompatActivity {final String TAG="OtherOrMainActivity";@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_other);Log.i(TAG,"onCreate_Other");}@Overrideprotected void onSaveInstanceState(Bundle outState) {super.onSaveInstanceState(outState);Log.i(TAG,"onSaveInstanceState_Other");outState.putString("mBundle","outState");}@Overrideprotected void onRestoreInstanceState(Bundle savedInstanceState) {super.onRestoreInstanceState(savedInstanceState);String outState=savedInstanceState.getString("mBundle");Log.i(TAG,"onRestoreInstanceState_Other:"+outState);}@Overridepublic void onConfigurationChanged(Configuration newConfig) {super.onConfigurationChanged(newConfig);Log.i(TAG,"onConfigurationChanged_Other");}@Overrideprotected void onStart() {super.onStart();Log.i(TAG,"onStart_Other");}@Overrideprotected void onResume() {super.onResume();Log.i(TAG,"onResume_Other");}@Overrideprotected void onRestart() {super.onRestart();Log.i(TAG,"onRestart_Other");}@Overrideprotected void onPause() {super.onPause();Log.i(TAG,"onPause_Other");}@Overrideprotected void onStop() {super.onStop();Log.i(TAG,"onStop_Other");}@Overrideprotected void onDestroy() {super.onDestroy();Log.i(TAG,"onDestroy_Other");}public void intoOtherMain(View v){Intent it=new Intent(OtherActivity.this,StartActivity.class);startActivity(it);}
}

public class StartActivity extends AppCompatActivity {final String TAG="OtherOrMainActivity";@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_start);Log.i(TAG,"onCreate_Start");}@Overrideprotected void onSaveInstanceState(Bundle outState) {super.onSaveInstanceState(outState);Log.i(TAG,"onSaveInstanceState_Start");outState.putString("mBundle","outState");}@Overrideprotected void onRestoreInstanceState(Bundle savedInstanceState) {super.onRestoreInstanceState(savedInstanceState);String outState=savedInstanceState.getString("mBundle");Log.i(TAG,"onRestoreInstanceState_Start:"+outState);}@Overridepublic void onConfigurationChanged(Configuration newConfig) {super.onConfigurationChanged(newConfig);Log.i(TAG,"onConfigurationChanged_Start");}@Overrideprotected void onStart() {super.onStart();Log.i(TAG,"onStart_Start");}@Overrideprotected void onResume() {super.onResume();Log.i(TAG,"onResume_Start");}@Overrideprotected void onRestart() {super.onRestart();Log.i(TAG,"onRestart_Start");}@Overrideprotected void onPause() {super.onPause();Log.i(TAG,"onPause_Start");}@Overrideprotected void onStop() {super.onStop();Log.i(TAG,"onStop_Start");}@Overrideprotected void onDestroy() {super.onDestroy();Log.i(TAG,"onDestroy_Start");}public void intoOtherMain(View v){Intent it=new Intent(StartActivity.this,MainActivity.class);startActivity(it);}
}

MainActivity->OtherActivity
在这里插入图片描述
OtherActivity->StartActivity
在这里插入图片描述
StartActivity ->MainActivity
在这里插入图片描述
从StartActivity ->MainActivity可以看出，MainActivity为singleTask模式，跳转至栈顶的时候，会将MainActivity以上的activity都从任务栈中移出销毁。
singleTask 模式比较适合应用的主界面activity（频繁使用的主架构）

  • singleInstance 模式
    在singleInstance模式下，该Activity在整个android系统内存中有且只有一个实例，而且该实例单独尊享一个Task。如下图所示：
    在这里插入图片描述
    上代码:
<activityandroid:name=".MainActivity"android:launchMode="singleInstance"><intent-filter><action android:name="android.intent.action.MAIN" /><category android:name="android.intent.category.LAUNCHER" /></intent-filter>
</activity><activity android:name=".OtherActivity" />
<activity android:name=".StartActivity"></activity>

和上面singleTask 的例子相比，只是把启动模式设置为：singleInstance ，android:launchMode=“singleInstance”。
生命周期
MainActivity->OtherActivity
在这里插入图片描述
OtherActivity->StartActivity
在这里插入图片描述
StartActivity->MainActivity
在这里插入图片描述
从上面的生命周期可以看出来，StartActivity再次启动MainActivity时，是没有执行onCreate方法的。

MainActivity回退
在这里插入图片描述
StartActivity回退
在这里插入图片描述
OtherActivity回退
在这里插入图片描述
看到没，OtherActivity回退直接销毁了OtherActivity页面，没有回到MainActivity页面，而是回到了桌面。这就证明了，设置为singleInstance模式的activity，是会独享一个Task的。

Activity 组件之间的通信

  • Activity-Activity

    1.Intent/Bundle

    • 这种方式多用于Activity之间传递数据。
    //首先创建一个Bundle对象
Bundle bundle = new Bundle();
bundle.putString("data_string","数据");
bundle.putInt("data_int",6);//然后创建一个Intent对象
Intent it= new Intent(MainActivity.this,OtherActivity.class);
it.putExtras(bundle);
startActivity(it);

    2.静态内部变量

    • 在Activity内部定义静态的变量，这种方式见于少量的数据通信
    public class MainActivity extends AppCompatActivity {final String TAG="OtherOrMainActivity";public static Map<String,Object> infos=new HashMap<String,Object>();@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);Log.i(TAG,"onCreate");}public void intoMainTwo(View v){Intent it=new Intent(MainActivity.this,OtherActivity.class);startActivity(it);infos.put("msg","静态传值");}
}

    在OtherActivity中就直接用静态变量获取值了

    String msg=MainActivity.infos.get("msg").toString();

    3.全局变量

    • 创建Apploication的子类，并在类中声明全局变量
     public class MyApplication extends Application {public  Map<String,Object> appInfos=new HashMap<String,Object>();}
    • 在清单文件中声明MyApplication
     android:name=".MyApplication"
    • MainActivity中设置值:
    @Override
protected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);Log.i(TAG,"onCreate");MyApplication mMyApplication=(MyApplication)getApplication();mMyApplication.appInfos.put("mgs","全局变量");
}
    • OtherActivity中获取值
    @Override
protected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_other);Log.i(TAG,"onCreate_Other");MyApplication mMyApplication=(MyApplication)getApplication();String msg=mMyApplication.appInfos.get("msg").toString();Log.i(TAG,"onCreate_Other_Msg:"+msg);
}

  • Activity-Service
    1.绑定服务的方式，利用ServiceConnection这个接口

  • 首先我们需要在要绑定的服务中声明一个Binder类

    public class MyService1 extends Service {public String data = "";public MyService1() {}@Overridepublic IBinder onBind(Intent intent) {return new Binder();}public class Binder extends android.os.Binder{public void sendData(String data){MyService1.this.data = data;}}}

  • 然后我们让Activity实现ServiceConnection这个接口，并且在onServiceConnected方法中获取到Service提供给Activity的Binder实例对象，通过这个对象我们就可以与Service进行通信可以通过上述代码的Binder类中的sendData()方法进行通信。

    public class ServiceBindActivity extends AppCompatActivity implements ServiceConnection,View.OnClickListener {private Button bt0,bt1,bt2;public MyService1.Binder binder = null;@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_service_bind);bt0 = findViewById(R.id.bt0);bt1 = findViewById(R.id.bt1);bt2 = findViewById(R.id.bt2);bt0.setOnClickListener(this);bt1.setOnClickListener(this);bt2.setOnClickListener(this);}@Overrideprotected void onDestroy() {super.onDestroy();unbindService(this);}//这个是服务绑定的时候调用@Overridepublic void onServiceConnected(ComponentName componentName, IBinder iBinder) {binder = (MyService1.Binder) iBinder;}//这个是服务解绑的时候调用@Overridepublic void onServiceDisconnected(ComponentName componentName) { }@Overridepublic void onClick(View view) {switch (view.getId()){case R.id.bt0://绑定服务Intent intent = new Intent(ServiceBindActivity.this,MyService1.class);bindService(intent,this, Context.BIND_AUTO_CREATE);break;case R.id.bt1://通过binder对象来和Service进行通信if(binder != null)binder.sendData("bt1");break;case R.id.bt2://通过binder对象来和Service进行通信if(binder != null)binder.sendData("bt2");break;}}
}

2.Intent

  • 启动和停止Service时所调用的方法都需要传入一个Intent实例对象，通过这个传入的Intent对象，我们就可以与Service进行通信。

    public class ServiceStartActivity extends AppCompatActivity implements View.OnClickListener {private Button bt0,bt1;private Intent intent ;@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_service_start);intent = new Intent(this, MyService2.class);bt0 = findViewById(R.id.bt0);bt1 = findViewById(R.id.bt1);bt0.setOnClickListener(this);bt1.setOnClickListener(this);}@Overridepublic void onClick(View view) {switch (view.getId()){case R.id.bt0://开启服务并且传递数据intent.putExtra("data_stirng","string数据");startActivity(intent);break;case R.id.bt1://结束服务stopService(intent);break;}}
}

    public class MyService2 extends Service {public String data = "";public MyService2() { }@Overridepublic IBinder onBind(Intent intent) {return null;}@Overridepublic int onStartCommand(Intent intent, int flags, int startId) {//得到Activity传递过来的数据data = intent.getStringExtra("data_string");return super.onStartCommand(intent, flags, startId);}
}

  • Activity->Fragment

    1.Bundle

    • 在创建Fragment实例的时候，调用方法setArguments将一个Bundle对象传递给Fragment，然后在Fragment中先去判断是否和当前Activity绑定上了，如果绑定上了，就可以拿出这个Bundle中的数据了。

    Activity：

        //首先创建一个Bundle对象Bundle bundle = new Bundle();bundle.putString("data_string","数据");bundle.putInt("data_int",10);bundle.putChar("da_char",'a');Fragment fragment = new MyFragment1();fragment.setArguments(bundle);

    Fragment:

    	if(isAdded()){//这里判断是否Fragment和Activity进行了绑定Bundle bundle = getArguments();String data_string = bundle.getString("data_string");String data_int = bundle.getInt("data_int");String data_char = bundle.getChar("data_char");}

    2.直接进行方法调用

    • 在Activity里通过Fragment的引用，可以直接调用Framgent中的定义的任何方法。
        MyFragment1 myFragment1 = new MyFragment1();myFragment.toString("传送的string数据");

    好了，至此Activity的入门知识点基本讲完了，之后会分享Activity的进阶知识点和源码分析博客，敬请期待。。。

这篇关于简单易懂，一步一步带你入门Activity的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1023904。

相关文章

Spring Boot + MyBatis Plus 高效开发实战从入门到进阶优化(推荐)

Spring Boot + MyBatis Plus 高效开发实战从入门到进阶优化(推荐)

《SpringBoot+MyBatisPlus高效开发实战从入门到进阶优化(推荐)》本文将详细介绍SpringBoot+MyBatisPlus的完整开发流程,并深入剖析分页查询、批量操作、动... 目录Spring Boot + MyBATis Plus 高效开发实战：从入门到进阶优化1. MyBatis
阅读更多...
Mysql表的简单操作(基本技能)

Mysql表的简单操作(基本技能)

《Mysql表的简单操作(基本技能)》在数据库中,表的操作主要包括表的创建、查看、修改、删除等,了解如何操作这些表是数据库管理和开发的基本技能,本文给大家介绍Mysql表的简单操作,感兴趣的朋友一起看... 目录3.1 创建表 3.2 查看表结构3.3 修改表3.4 实践案例：修改表在数据库中，表的操作主要
阅读更多...
springboot简单集成Security配置的教程

springboot简单集成Security配置的教程

《springboot简单集成Security配置的教程》：本文主要介绍springboot简单集成Security配置的教程,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,... 目录集成Security安全框架引入依赖编写配置类WebSecurityConfig（自定义资源权限规则
阅读更多...
如何使用Python实现一个简单的window任务管理器

如何使用Python实现一个简单的window任务管理器

《如何使用Python实现一个简单的window任务管理器》这篇文章主要为大家详细介绍了如何使用Python实现一个简单的window任务管理器,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起... 任务管理器效果图完整代码import tkinter as tkfrom tkinter i
阅读更多...
C++中函数模板与类模板的简单使用及区别介绍

C++中函数模板与类模板的简单使用及区别介绍

《C++中函数模板与类模板的简单使用及区别介绍》这篇文章介绍了C++中的模板机制,包括函数模板和类模板的概念、语法和实际应用,函数模板通过类型参数实现泛型操作,而类模板允许创建可处理多种数据类型的类,... 目录一、函数模板定义语法真实示例二、类模板三、关键区别四、注意事项 ‌在C++中，模板是实现泛型编程
阅读更多...
使用EasyExcel实现简单的Excel表格解析操作

使用EasyExcel实现简单的Excel表格解析操作

《使用EasyExcel实现简单的Excel表格解析操作》：本文主要介绍如何使用EasyExcel完成简单的表格解析操作,同时实现了大量数据情况下数据的分次批量入库,并记录每条数据入库的状态,感兴... 目录前言固定模板及表数据格式的解析实现Excel模板内容对应的实体类实现AnalysisEventLis
阅读更多...
Python FastAPI入门安装使用

Python FastAPI入门安装使用

《PythonFastAPI入门安装使用》FastAPI是一个现代、快速的PythonWeb框架,用于构建API,它基于Python3.6+的类型提示特性,使得代码更加简洁且易于绶护,这篇文章主要介... 目录第一节：FastAPI入门一、FastAPI框架介绍什么是ASGI服务（WSGI）二、FastAP
阅读更多...
Java中数组转换为列表的两种实现方式(超简单)

Java中数组转换为列表的两种实现方式(超简单)

《Java中数组转换为列表的两种实现方式(超简单)》本文介绍了在Java中将数组转换为列表的两种常见方法使用Arrays.asList和Java8的StreamAPI,Arrays.asList方法简... 目录1. 使用Java Collections框架（Arrays.asList）1.1 示例代码1.
阅读更多...
Java8需要知道的4个函数式接口简单教程

Java8需要知道的4个函数式接口简单教程

《Java8需要知道的4个函数式接口简单教程》：本文主要介绍Java8中引入的函数式接口,包括Consumer、Supplier、Predicate和Function,以及它们的用法和特点,文中... 目录什么是函数是接口？Consumer接口定义核心特点注意事项常见用法1.基本用法2.结合andThen链
阅读更多...
C++初始化数组的几种常见方法(简单易懂)

C++初始化数组的几种常见方法(简单易懂)

《C++初始化数组的几种常见方法(简单易懂)》本文介绍了C++中数组的初始化方法,包括一维数组和二维数组的初始化,以及用new动态初始化数组,在C++11及以上版本中,还提供了使用std::array... 目录1、初始化一维数组1.1、使用列表初始化（推荐方式）1.2、初始化部分列表1.3、使用std::
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2