This guide will explain the important methods/APIs of the Spring ApplicationContext interface with examples.
The ApplicationContext is the central interface within a Spring application for providing configuration information to the application. It is read-only at run time but can be reloaded if necessary and supported by the application. A number of classes implement the ApplicationContext interface, allowing for a variety of configuration options and types of applications.

The ApplicationContext provides:

Bean factory methods for accessing application components.
The ability to load file resources in a generic fashion.
The ability to publish events to registered listeners.
The ability to resolve messages to support internationalization.
Inheritance from a parent context.

ApplicationContext Interface Methods

String getApplicationName() - This method returns a name for the deployed application that this context belongs to.
AutowireCapableBeanFactory getAutowireCapableBeanFactory() - This method exposes AutowireCapableBeanFactory functionality for this context.
String getDisplayName() - This method is used to return a friendly name for current context.
String getId() - This method is used to return the unique id of this application context.
ApplicationContext getParent() - This method returns the parent context, or null if there is no parent and this is the root of the context hierarchy.
long getStartupDate() - This method is used to return the timestamp when this context was first loaded.

ApplicationContext Interface Class Diagram Hierarchy

Below diagram shows the ApplicationContext interface hierarchy:

Note that ApplicationContext interface extends ApplicationEventPublisher, BeanFactory, EnvironmentCapable, HierarchicalBeanFactory, ListableBeanFactory, MessageSource, ResourceLoader, ResourcePatternResolver interfaces.

ApplicationContext Interface Methods/APIs with Examples

You can find all ApplicationContext interface methods at https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/context/ApplicationContext.html.

The below sample code demonstrate the usage of important ApplicationContext interface methods. Note that the comments in below code are self-descriptive:

package net.javaguides.springboot;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Component;

/**
 * Created by Ramesh Fadatare
 */
@SpringBootApplication
public class Application {
    public static void main(String[] args) {

        // Class that can be used to bootstrap and launch a Spring application from a Java main method. 
        // By default class will perform the following steps to bootstrap your application: 
        // Create an appropriate ApplicationContext instance (depending on your classpath) 
        ApplicationContext applicationContext = SpringApplication.run(Application.class, args);

        // Return the bean instance that uniquely matches the given object type, if any. 
        UserService userService = applicationContext.getBean(UserService.class);
        System.out.println(userService.getUserName());

        Class < ? > userService2 = applicationContext.getType("userService");
        System.out.println(userService2.getName());

        // Does this bean factory contain a bean definition or externally 
        // registered singleton instance with the given name? 
        boolean hasBean = applicationContext.containsBean("userService");
        System.out.println("containsBean userService :: " + hasBean);

        // Is this bean a prototype? That is, will getBean always return independent instances? 
        boolean isPrototype = applicationContext.isPrototype("userService");
        System.out.println(" isPrototype :: " + isPrototype);

        // Is this bean a shared singleton? That is, will getBean always return the same instance? 
        boolean isSingleton = applicationContext.isSingleton("userService");
        System.out.println(" isSingleton :: " + isSingleton);

        // Return an instance, which may be shared or independent, of the specified bean. 
        UserService userService3 = (UserService) applicationContext.getBean("userService");
        System.out.println(userService3.getUserName());

        // Find an Annotation of annotationType on the specified bean, traversing its interfaces and 
        // super classes if no annotation can be found on the given class itself.
        Component component = applicationContext.findAnnotationOnBean("userName", Component.class);
        System.out.println(" component annotation :: " + component);

        // Return the unique id of this application context.
        String id = applicationContext.getId();
        System.out.println(" Return the unique id of this application context. :: " + id);

        // Return a friendly name for this context.
        String displayName = applicationContext.getDisplayName();
        System.out.println("Return a friendly name for this context :: " + displayName);

        // Return a name for the deployed application that this context belongs to.
        String appName = applicationContext.getApplicationName();
        System.out.println("Return a name for the deployed application that this context belongs to :: " + appName);

        // Return the timestamp when this context was first loaded.
        long date = applicationContext.getStartupDate();
        System.out.println(" Return the timestamp when this context was first loaded :: " + date);
    }
}

@Component
class UserService {

    public String getUserName() {
        return "Spring Boot";
    }
}