Infosys Limited is an Indian multinational technology company that specializes in business consulting, information technology, and outsourcing services. Founded in 1981 by seven engineers—N. R. Narayana Murthy, Nandan Nilekani, N. S. Raghavan, S. Gopalakrishnan, S. D. Shibulal, K. Dinesh, and Ashok Arora—in Pune, India, with an initial capital of just $250, the company has grown into a global leader in digital services and consulting. It is headquartered in Bengaluru, often referred to as India's Silicon Valley, after relocating there in 1983.
Infosys pioneered the Global Delivery Model, which revolutionized offshore outsourcing by leveraging India's skilled workforce and cost advantages to deliver high-quality IT services worldwide. Over the years, it has expanded its offerings to include next-generation digital solutions such as artificial intelligence, cloud computing, data analytics, and blockchain, helping clients in over 50 countries navigate their digital transformation. The company serves a wide range of industries, including finance, healthcare, manufacturing, retail, and energy.
As of early 2025, Infosys employs over 300,000 people globally, with a significant portion based in India. It operates numerous development centers and sales offices worldwide, with a strong presence in North America (generating over 60% of its revenue), Europe, and Asia-Pacific. The company is publicly traded on the Bombay Stock Exchange (BSE), National Stock Exchange (NSE) in India, and the New York Stock Exchange (NYSE) in the U.S., where it was the first Indian company to list American Depositary Receipts (ADRs) in 1999.
Infosys has achieved significant milestones, including reaching a market capitalization of $100 billion in 2021, making it one of India’s most valuable companies. It is currently the second-largest Indian IT firm by revenue, trailing only Tata Consultancy Services (TCS). The company is also recognized for its commitment to sustainability and corporate governance, having been named one of the World’s Most Ethical Companies by Ethisphere multiple times, including in 2025.
Led by CEO Salil Parekh since 2018, Infosys continues to innovate with offerings like Infosys Topaz (an AI-first platform) and Infosys Cobalt (a cloud-focused solution). Despite its success, the company has faced challenges, including allegations of visa misuse and tax issues in the U.S., which it has settled, and occasional workforce controversies, such as recent layoffs of trainees reported in 2025. Nonetheless, Infosys remains a key player in the global IT landscape, known for its technical expertise, client-centric approach, and contributions to India’s emergence as a technology powerhouse.
The Infosys recruitment process is a structured, multi-stage evaluation designed to identify candidates with strong technical skills, problem-solving abilities, and cultural fit for the company. While the process can vary slightly depending on the role (e.g., freshers, experienced professionals, or specialized positions like Digital Specialist Engineer or Specialist Programmer), it generally follows a consistent framework. Below is an overview of the typical Infosys recruitment process as of 2025, based on its standard practices and recent trends.
Before applying, candidates must meet Infosys’ academic and professional requirements:
The first major step is an online test, which evaluates candidates’ aptitude and technical skills. This test is adaptive in 2025, meaning the difficulty adjusts based on performance. It typically includes:
Candidates who clear the online test proceed to the technical interview, which assesses domain knowledge and practical skills:
The final stage evaluates personality, communication skills, and alignment with Infosys’ values:
This process reflects Infosys’ commitment to hiring talent that can drive digital transformation for its global clients while fostering a culture of continuous learning. For the most current details, candidates should check the official Infosys careers page, as patterns may evolve.
Object-Oriented Programming (OOP) in Java is based on four major principles:
Encapsulation is the process of wrapping data (variables) and methods (functions) into a single unit (class). It restricts direct access to some of the object's components and protects the data from unintended modifications.
class BankAccount {
private double balance; // Private variable (cannot be accessed directly)
// Constructor
public BankAccount(double initialBalance) {
this.balance = initialBalance;
}
// Public getter method to access private data
public double getBalance() {
return balance;
}
// Public setter method to modify private data
public void deposit(double amount) {
if (amount > 0) {
balance += amount;
}
}
}
Data hiding
Control over data access
Increases security
Inheritance allows a class (child class) to acquire the properties and behaviors of another class (parent class). This promotes code reusability and hierarchical relationships.
// Parent class
class Animal {
void makeSound() {
System.out.println("Animal makes a sound");
}
}
// Child class (inherits from Animal)
class Dog extends Animal {
void bark() {
System.out.println("Dog barks");
}
}
public class Main {
public static void main(String[] args) {
Dog myDog = new Dog();
myDog.makeSound(); // Inherited method
myDog.bark(); // Own method
}
}
Code reusability
Reduces redundancy
Establishes relationships between classes
Polymorphism means "many forms." It allows the same method to perform different behaviors based on the object that calls it. This can be achieved in two ways:
Same method name, different parameters.
class MathOperations {
int add(int a, int b) {
return a + b;
}
double add(double a, double b) {
return a + b;
}
}
public class Main {
public static void main(String[] args) {
MathOperations obj = new MathOperations();
System.out.println(obj.add(5, 10)); // Calls int version
System.out.println(obj.add(5.5, 2.3)); // Calls double version
}
}
Child class provides its own version of a method that exists in the parent class.
class Animal {
void makeSound() {
System.out.println("Animal makes a sound");
}
}
class Cat extends Animal {
@Override
void makeSound() {
System.out.println("Cat meows");
}
}
public class Main {
public static void main(String[] args) {
Animal myAnimal = new Cat(); // Polymorphic behavior
myAnimal.makeSound(); // Calls Cat's overridden method
}
}
Increases flexibility and scalability
Enables dynamic method execution
Abstraction hides the implementation details of an object and only shows the necessary features. It can be achieved using abstract classes or interfaces.
abstract class Vehicle {
abstract void start(); // Abstract method (no implementation)
}
class Car extends Vehicle {
@Override
void start() {
System.out.println("Car starts with a key");
}
}
public class Main {
public static void main(String[] args) {
Vehicle myCar = new Car();
myCar.start();
}
}
Hides unnecessary details
Provides a blueprint for subclasses
Enhances security
| OOP Concept | Description | Key Feature |
|---|---|---|
| Encapsulation | Hides data and restricts direct access | Uses private variables and public methods |
| Inheritance | Child class acquires properties of a parent class | Promotes code reusability |
| Polymorphism | Same method behaves differently based on the object | Achieved via method overloading and overriding |
| Abstraction | Hides implementation details and shows only necessary features | Implemented using abstract classes & interfaces |
| Class | Interface |
|---|---|
| A class is a blueprint for the creation of objects with the same configuration for properties and methods | An interface is a collection of properties and methods that helps to describe an object, but it does not provide implementation or initialization for them |
| A class will have abstract or concrete methods | Interface will have abstract methods only. From Java 8 onwards, it supports static as well as default methods |
| Does not support multiple inheritance. | Multiple Inheritance is supported |
| An interface can be implemented by a class | Interface cannot be implemented by another interface, but it is possible to extend an interface |
| Using extends keyword, a class can be inherited from another class | Interface cannot inherit a class, but it can inherit an interface |
| It can have all types of members(public, private or, others) | Members are public by default, but you can use other access specifiers also for the interface members |
Java does not support multiple inheritance with classes to avoid ambiguity and complexity. However, it supports multiple inheritance through interfaces.
If a class were to inherit from multiple classes, there could be confusion if the parent classes had methods with the same name.
class Parent1 {
void show() {
System.out.println("Parent1's show() method");
}
}
class Parent2 {
void show() {
System.out.println("Parent2's show() method");
}
}
// ERROR: Java does not support multiple inheritance
class Child extends Parent1, Parent2 {
// Which show() method should be inherited? This creates ambiguity!
}
public class Main {
public static void main(String[] args) {
Child obj = new Child();
obj.show(); // Which show() method should be called? Ambiguous!
}
}
Java prevents this ambiguity by not allowing multiple inheritance with classes.
Java allows multiple inheritance using interfaces because interfaces only contain method declarations (not implementations), avoiding ambiguity.
interface Interface1 {
void method1();
}
interface Interface2 {
void method2();
}
// Implementing multiple interfaces
class Child implements Interface1, Interface2 {
public void method1() {
System.out.println("Method1 from Interface1");
}
public void method2() {
System.out.println("Method2 from Interface2");
}
}
public class Main {
public static void main(String[] args) {
Child obj = new Child();
obj.method1(); // Calls method from Interface1
obj.method2(); // Calls method from Interface2
}
}
Since interfaces do not have method implementations, no ambiguity arises!
With Java 8, interfaces can have default methods (methods with implementations). If two interfaces have the same default method, we must override it in the implementing class.
interface A {
default void show() {
System.out.println("Default method from Interface A");
}
}
interface B {
default void show() {
System.out.println("Default method from Interface B");
}
}
// Resolving method conflict using override
class C implements A, B {
public void show() {
System.out.println("Overridden method in Class C");
}
}
public class Main {
public static void main(String[] args) {
C obj = new C();
obj.show(); // Calls overridden method in Class C
}
}
The class must override the conflicting method to resolve ambiguity.
| DDL(Data Definition Language) | DML(Data Manipulation Language) |
|---|---|
| DDL is used to define database schema and also to define some constraints | DML is used to manipulate the data within the database |
| Does not have further classification | Classified into procedural and non-procedural DML |
| DDL statements do not use WHERE clause | DML statements use WHERE clause |
| Examples for DDL statements are CREATE, ALTER, DROP, TRUNCATE, COMMENT, and RENAME | Examples for DML statements are INSERT, UPDATE, and DELETE |
| TRUNCATE | DELETE |
|---|---|
| It is used to remove all records from a database table | It is used to delete specified records(one or more) from a database table |
| It is a Data Definition Language(DDL) command | It is a Data Manipulation Language(DML) command |
| Faster than DELETE command | Slower compared to TRUNCATE command |
| Cannot be applied for indexed views as it works only on tables | Can be applied for indexed views |
int x = 25;
int *ptr = &x;
cout << ptr;ptr will store the address of x. That means the address of x is the ptr value.*ptr, we can obtain the value stored in the address referenced by ptr(i.e., 25). *ptr is known as dereference operator.int *pointer=NULL;int *pointer= (int*)NULL; /* A palindrome number is a number that remains same after reversing the digits. */
#include<iostream.h>
#include<conio.h>
void main()
{
int num, n, rem, rev=0;
clrscr();
cout<<"Enter a number:";
cin>>num;
n=num; //Used for comparision after reversal of a number
while(num>0)
{
/* In this block, we retrieve each digit from a given number and will get the reversed number at the end stored at rev variable. */
rem=num%10;
rev=(rev*10)+rem;
num=num/10;
}
if(n==rev) //Comparing given number with reversed number
cout<<n<<" is a palindrome.";
else
cout<<n<<" is not a palindrome.";
getch();
}| White box testing | Black box testing |
|---|---|
| The tester will have complete knowledge about the internal working of the application. | It is not necessary to know the internal working of the application. |
| It is done by developers and testers(QA). | It is done by the end-user and also by developers and testers. |
| It is more time-consuming and exhaustive. | It is less time-consuming and exhaustive. |
| Here, a tester will design test data and test cases. | Testing is done based on an external or end-user perspective. |
| White box testing is also called an open box, glass, structural testing, clear box, or code-based testing. | Black box testing is also called closed box, functional, data-driven testing. |