Just Learn Code

Mastering Android Activity Class: Moving Between Multiple Activities

Moving Between Activities in Android using the Activity Class

Mobile app development trends have moved from being just a luxury to a necessity in our daily lives. With the major players in the market namely Android and iOS, developers aim to create quality products that people can use to enhance their daily experiences.

One of the important concepts that developers need a good understanding of is the Android Activity class. This article will provide an in-depth look at the Android Activity class with specific attention to multiple activities and moving between them using startActivity() method.

Multiple activities in an Android Application

In mobile app development, an activity is used to represent a single screen or user interface. Activities are the building blocks of an Android application.

An application can have one or more activities. An application with just one activity is typically referred to as a single activity app.

There are many benefits to segregating functionalities using multiple activities, and one of them is providing users with a better and more organized interface. Developers can have multiple activities in one application.

To do this, they need to create a new activity class and define its behavior. Once the activity is defined, it can be added to the AndroidManifest.xml file – making the new activity class visible to the system.

Developers can also declare the parent activity in the AndroidManifest.xml file. This will define the way the app hierarchy works and how activities transition between each other.

Moving Between Activities using startActivity() method

The startActivity() method is an Android framework method. It is used to move from one activity to another in an Android application.

Android allows developers to pass data between activities using explicit intents. An Intent object is a simple message handling system.

Developers can use Intents to pass data to activities, to start other activities, and to send and receive broadcast messages.

Moving from MainActivity to SecondActivity

To move from MainActivity to SecondActivity, developers need to perform a few steps. First, create an instance of Intent with the source context and the destination class name as parameters.

The source context is the current activity, in our case, MainActivity. The destination class is SecondActivity.

The Intent object is used as an inter-process communication channel and is used to transport data and requests between activities. Secondly, use the startActivity() method to start the SecondActivity.

The startActvity() method requires an Intent object that is used to specify the activity that needs to be started. With a short and simple method like this, developers can move from one activity to another.

Using Intent object and Button to change activity

Another way developers can move between activities is by using a button. Buttons are commonly used in user interfaces to perform a specific action or submit user input.

In our case, the button helps us move from MainActivity to SecondActivity. To do this, we need an additional step.

First, create layout for MainActivity that includes a button. OnMainActivity’s onCreate() method, obtain a reference to the button, and set an onClick listener on the button.

In the onClick listener function, instantiate the intent object, specify the class name of the SecondActivity, and then use the startActivity() method to start the SecondActivity.


In this article, we have looked at the Android Activity class and its importance in mobile application development. We have seen how developers can have multiple activities in an Android application and how to move between the activities using startActivity() method.

We have also seen how this can be done using button click listeners. With the ability to have multiple activities, developers can create a better user experience and provide a more organized interface.

Moving between them is made easy, and we have seen that developers can do it using simple steps.

Creating SecondActivity Class

In order to create SecondActivity class, developers need to follow a few key steps. First, they need to create a new Java class file and name it SecondActivity.

In this class file, they need to define the behavior of the SecondActivity.

Code for SecondActivity Class

To define the behavior of SecondActivity, developers need to override the onCreate() method. The onCreate() method is called when the activity is being created.

In this method, developers can define the layout of the activity, create and reference views or widgets, and handle any required event listeners.

One way to define the layout of the activity is by using an XML file.

An XML file can be used to define the visual structure of the activity and allows developers to separate the appearance of the activity from its functionality. Developers can use the setContentView() method to set the XML file as the view of the SecondActivity.

An example code for SecondActivity class is shown below. “`

public class SecondActivity extends AppCompatActivity {


protected void onCreate(Bundle savedInstanceState) {






Displaying SecondActivity Class in the Application

To display SecondActivity class in the application, developers need to add it to the AndroidManifest.xml file. They need to declare the SecondActivity class as an intent-filter for the MainActivity class.



This will allow the application to recognize SecondActivity as a valid activity within the application. Developers also need to create a button or perform an event that triggers the transition from MainActivity to SecondActivity.

This can be done using the steps mentioned in the previous section.

Running and Testing the Application

Once developers have created the SecondActivity class and added it to the AndroidManifest.xml file, they can run and test the application to ensure that the code is working as expected.

Running the Application with Code in MainActivity Class

To run the application with the code in the MainActivity class, developers need to launch the application in an emulator or a physical device. They can do this by using the Run button in their Android Studio IDE.

The application will launch with the MainActivity being the first activity to be displayed.

Testing the Application to Move Between Activities

To test the application to move between activities, developers need to perform a few key steps. First, they need to click the button that they have created in MainActivity to move to SecondActivity.

This should transition the application from MainActivity to SecondActivity. The user interface of SecondActivity should now be displayed on the screen.

Developers can also use LogCat to view the logs generated by the application, allowing them to trace any issues or problems encountered during the transition. Developers can use this information to debug the application and ensure that it is functioning properly.


In conclusion, we have seen how to create the SecondActivity class and display it in the application. We have also seen how to run and test the application to move between activities.

The ability to create multiple activities and move between them is an important feature of mobile application development. As such, developers need a good understanding and ability to use it effectively to create quality mobile applications.

In conclusion, this article has covered the importance of the Android Activity class in mobile app development, specifically looking at multiple activities, moving between activities, creating the SecondActivity class, and running and testing the application. Developers need to have a good understanding of these concepts to create quality mobile applications that provide a better user experience and a more organized interface.

By following the steps outlined in this article, developers can create an application that makes it easy to move between activities, creating a seamless and intuitive experience for their users. As mobile technology continues to evolve, the ability to create quality applications that utilize the full range of features available to developers is becoming more important than ever.

Popular Posts