简单易懂，一步一步带你入门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。

相关文章

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

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

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

redis群集简单部署过程

《redis群集简单部署过程》文章介绍了Redis,一个高性能的键值存储系统,其支持多种数据结构和命令,它还讨论了Redis的服务器端架构、数据存储和获取、协议和命令、高可用性方案、缓存机制以及监控和... 目录Redis介绍1. 基本概念2. 服务器端3. 存储和获取数据4. 协议和命令5. 高可用性6.
阅读更多...
JAVA调用Deepseek的api完成基本对话简单代码示例

JAVA调用Deepseek的api完成基本对话简单代码示例

《JAVA调用Deepseek的api完成基本对话简单代码示例》：本文主要介绍JAVA调用Deepseek的api完成基本对话的相关资料,文中详细讲解了如何获取DeepSeekAPI密钥、添加H... 获取API密钥首先，从DeepSeek平台获取API密钥，用于身份验证。添加HTTP客户端依赖使用Jav
阅读更多...
利用Python编写一个简单的聊天机器人

利用Python编写一个简单的聊天机器人

《利用Python编写一个简单的聊天机器人》这篇文章主要为大家详细介绍了如何利用Python编写一个简单的聊天机器人,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下... 使用 python 编写一个简单的聊天机器人可以从最基础的逻辑开始，然后逐步加入更复杂的功能。这里我们将先实现一个简单的
阅读更多...
使用IntelliJ IDEA创建简单的Java Web项目完整步骤

使用IntelliJ IDEA创建简单的Java Web项目完整步骤

《使用IntelliJIDEA创建简单的JavaWeb项目完整步骤》：本文主要介绍如何使用IntelliJIDEA创建一个简单的JavaWeb项目,实现登录、注册和查看用户列表功能,使用Se... 目录前置准备项目功能实现步骤1. 创建项目2. 配置 Tomcat3. 项目文件结构4. 创建数据库和表5.
阅读更多...
使用PyQt5编写一个简单的取色器

使用PyQt5编写一个简单的取色器

《使用PyQt5编写一个简单的取色器》：本文主要介绍PyQt5搭建的一个取色器,一共写了两款应用,一款使用快捷键捕获鼠标附近图像的RGB和16进制颜色编码,一款跟随鼠标刷新图像的RGB和16... 目录取色器1取色器2PyQt5搭建的一个取色器，一共写了两款应用，一款使用快捷键捕获鼠标附近图像的RGB和16
阅读更多...
四种简单方法 轻松进入电脑主板 BIOS 或 UEFI 固件设置

四种简单方法 轻松进入电脑主板 BIOS 或 UEFI 固件设置

《四种简单方法轻松进入电脑主板BIOS或UEFI固件设置》设置BIOS/UEFI是计算机维护和管理中的一项重要任务，它允许用户配置计算机的启动选项、硬件设置和其他关键参数，该怎么进入呢？下面... 随着计算机技术的发展，大多数主流 PC 和笔记本已经从传统 BIOS 转向了 UEFI 固件。很多时候，我们也
阅读更多...
基于Qt开发一个简单的OFD阅读器

基于Qt开发一个简单的OFD阅读器

《基于Qt开发一个简单的OFD阅读器》这篇文章主要为大家详细介绍了如何使用Qt框架开发一个功能强大且性能优异的OFD阅读器,文中的示例代码讲解详细,有需要的小伙伴可以参考一下... 目录摘要引言一、OFD文件格式解析二、文档结构解析三、页面渲染四、用户交互五、性能优化六、示例代码七、未来发展方向八、结论摘要
阅读更多...
MyBatis框架实现一个简单的数据查询操作

MyBatis框架实现一个简单的数据查询操作

《MyBatis框架实现一个简单的数据查询操作》本文介绍了MyBatis框架下进行数据查询操作的详细步骤,括创建实体类、编写SQL标签、配置Mapper、开启驼峰命名映射以及执行SQL语句等,感兴趣的... 基于在前面几章我们已经学习了对MyBATis进行环境配置，并利用SqlSessionFactory核
阅读更多...
Spring Security 从入门到进阶系列教程

Spring Security 从入门到进阶系列教程

Spring Security 入门系列 《保护 Web 应用的安全》 《Spring-Security-入门（一）：登录与退出》 《Spring-Security-入门（二）：基于数据库验证》 《Spring-Security-入门（三）：密码加密》 《Spring-Security-入门（四）：自定义-Filter》 《Spring-Security-入门（五）：在 Sprin
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2