Java Tutorial for Beginners

Introduction

Sick of job hunting that requires advanced skills you lack? Java is the robust basis for enterprise apps, big data, and Android. It comes with stability and good pay, but frequently intimidates new learners. This Java tutorial for beginners dissects Java’s main principles into bite-sized, easy-to-follow steps, providing you with the in-demand skills to finally start your career as a developer. Ready to see the in-depth learning path? Download our entire Java Course Syllabus!

Why Students or Freshers Learn Java?

Java is what students and freshers must study because:

• Gigantic Job Market: Java powers the enterprise ecosystem (banking, insurance, big e-commerce), providing a plethora of stable job prospects worldwide.
• Top Salary Potential: It’s linked with some of the highest starting and experienced developer salaries due to its application in mission-critical systems.
• Scalability & Reliability: Mastering Java (especially with Spring Boot) provides essential knowledge for building scalable, high-performance, and secure applications.
• Strong Community & Tools: Java has mature documentation, comprehensive frameworks, and powerful IDEs, speeding up learning and development.
• Career Foundation: Learning Java’s Object-Oriented Programming (OOP) principles makes it easier to learn other programming languages like Kotlin or C#.

Ready for the next step? Master your technical interview! Download our valuable Java Interview Questions and Answers guide now!

Step-by-Step Java Tutorial for Beginners

Beginning with Java is an excellent decision! This hands-on, step-by-step tutorial will walk you through from setup to coding your first real applications.

Step 1. Installation and Setup: The Foundation

You’ll want two basic tools before you code your first line: the Java Development Kit (JDK) and an Integrated Development Environment (IDE).

1.1. Installing the Java Development Kit (JDK)

The JDK refers to the software bundle with the tools, compilers, and libraries required to develop and execute Java applications.

• Download the JDK: Visit the official Oracle site or an OpenJDK distribution (such as Adoptium/Eclipse Temurin). Download the current Long-Term Support (LTS) release (e.g., Java 17 or Java 21) that matches your operating system (Windows, macOS, or Linux).
• Run the Installer: Run the downloaded file and use the on-screen directions. The default options are fine.
• Verify Installation (Important!): Open your command prompt (Windows) or terminal (macOS/Linux) and enter:

java -version

javac -version

You will see the installed Java and Java Compiler version numbers, indicating the installation was successful.

1.2. Creating an IDE (Integrated Development Environment)

An IDE makes coding easier by providing features such as intelligent code completion, debugging, and project management. The most widely used option for Java is IntelliJ IDEA Community Edition (free) or Eclipse.

• Download and Install: Download the IntelliJ IDEA Community Edition.
• Create a New Project: Launch IntelliJ, choose “New Project.”

Configure Project:

• Provide a name to your project (e.g., MyFirstJavaApp).
• Choose the JDK you installed from the list.
• Select a type of project (most often a plain “Java” or “New Project” is fine for beginners).

Step 2. Your First Java Program: “Hello World”

This is where every programmer’s journey starts. This is showing the simplest form of a Java program.

2.1. The Structure of the Code

Create a new Java class file called HelloWorld.java in your IDE and insert the following code:

public class HelloWorld {

    // This is the main method, the entry point of every Java application

    public static void main(String[] args) {

        // The command to display output to the console

        System.out.println(“Hello, World! I am learning Java.”);

    }

}

2.2. What the Components Do

public class HelloWorld: Declares a class called HelloWorld. In Java, everything needs to be within a class. The class name has to be the same as the filename (HelloWorld.java).

public static void main(String[] args): The main method. The Java Virtual Machine (JVM) searches for this exact method signature to begin running your program.

• public: Accessible everywhere.
• static: The method is part of the class, not an object of the class.
• void: The function does not have a return value.

System.out.println(.): This instruction prints the message inside the parentheses to the console (standard output), and appends a new line.

2.3. Run the Program

Press the green “Run” button (or triangle) in your IDE alongside the main method, or right-click on the file and choose “Run.”

Output:

Hello, World! I am learning Java.

Step 3. Fundamentals: Variables and Data Types 

Variables are used to hold data values. Java is a statically typed language, and you have to declare the data type of a variable before it can be assigned a value.

3.1. Primitive Data Types

Java has 8 basic primitive data types:

Type	Description	Example
int	Stores whole numbers (integers), -2 billion to +2 billion.	int age = 25;
double	Stores floating-point numbers (decimals).	double price = 19.99;
boolean	Stores true or false values.	boolean isStudent = true;
char	Stores a single character, enclosed in single quotes.	char grade = ‘A’;
long	Stores very large whole numbers.	long population = 8000000000L;
float	Stores floating-point numbers (less precise than double).	float pi = 3.14f;
byte	Stores small whole numbers (-128 to 127).	byte level = 10;
short	Stores slightly larger whole numbers (-32768 to 32767).	short zip = 90210;

3.2. Reference Data Types (The String Example)

Reference types are more sophisticated and point to objects. The most familiar one is String.

String: Stores collections of characters (text), in double quotes.

Example Code:

public class Variables {

    public static void main(String[] args) {

        // Primitive Types

        int studentCount = 150;

        double averageScore = 88.5;

        boolean isComplete = true;

        // Reference Type (String is not a primitive)

        String courseName = “Core Java Fundamentals”;

        System.out.println(“Course: ” + courseName);

        System.out.println(“Students: ” + studentCount);

        System.out.println(“Average Score: ” + averageScore);

    }

}

Step 4. Control Flow: Decisions and Loops

Control flow statements enable your program to make choices and repeat processes.

4.1. Conditional Statements (if/else)

Use if statements to run code depending on whether a condition is true or false.

public class Conditionals {

    public static void main(String[] args) {

        int score = 75;

        if (score >= 90) {

            System.out.println(“Grade: A”);

        } else if (score >= 70) {

            System.out.println(“Grade: C”); // This will execute

        } else {

            System.out.println(“Grade: F”);

        }

    }

}

4.2. Looping Statements (for and while)

Loops repeat a section of code several times.

4.2.1. for Loop (Used when you know the number of iterations)

for (int i = 1; i <= 5; i++) {

    System.out.println(“Count: ” + i);

}

// Output:

// Count: 1

// …

// Count: 5

• int i = 1; (Initialization: starts the counter)
• i <= 5; (Condition: loop continues as long as this is true)
• i++ (Increment: runs after each loop iteration)

4.2.2. while Loop (Used when iterations are unknown)

int timer = 3;

while (timer > 0) {

    System.out.println(“T-” + timer);

    timer–; // Decrement the timer

}

System.out.println(“Launch!”);

// Output:

// T-3

// T-2

// T-1

// Launch!

Step 5. Object-Oriented Programming (OOP) in Java

Java is deeply rooted as an Object-Oriented language. This implies programs are designed around Objects that have data and behavior.

5.1. Classes and Objects

• A Class is a template or blueprint for creating objects (e.g., the concept of a “Car”).
• An Object is an instance of a class (e.g., your “red Honda Civic”).

5.2. Defining a Class (The Blueprint)

Create a new file called Dog.java:

public class Dog {

    // 1. Data/Attributes (Fields)

    String name;

    String breed;

    int age;

    // 2. Behavior (Methods)

    public void bark() {

        System.out.println(name + ” says Woof!”);

    }

    public void displayInfo() {

        System.out.println(“Name: ” + name + “, Breed: ” + breed + “, Age: ” + age);

    }

}

5.3. Instantiating an Object (The Instance)

In your main method (say in a new class called Zoo.java), instantiate an object of the Dog class:

public class Zoo {

    public static void main(String[] args) {

        // Creating the first Dog object (an instance of the Dog class)

        Dog dog1 = new Dog();

        // Accessing and setting the object’s attributes (data)

        dog1.name = “Max”;

        dog1.breed = “Golden Retriever”;

        dog1.age = 3;

        // Calling the object’s methods (behavior)

        dog1.bark();

        dog1.displayInfo(); // Output: Name: Max, Breed: Golden Retriever, Age: 3

        // Creating a second, independent Dog object

        Dog dog2 = new Dog();

        dog2.name = “Lucy”;

        dog2.breed = “Poodle”;

        dog2.bark(); // Output: Lucy says Woof!

    }

}

5.4. OOP’s Four Pillars

Java gets its strength from these ideas:

• Encapsulation: Packaging data (fields) and methods (behavior) into one unit (the Class). It conceals the internal information from the outside world.
  • Implementation: Apply the private keyword to fields and offer public Getter and Setter methods for controlling access to them.
• Inheritance: Enables a class (Subclass/Child) to inherit fields and methods from another class (Superclass/Parent). This encourages code reusability.
  • Implementation: Utilize the extends keyword (e.g., class Poodle extends Dog).
• Polymorphism: The power of an object to assume many forms. It enables you to implement one interface to represent various underlying forms (e.g., a “Dog” object can also be used as an “Animal” object).
  • Implementation: Method Overriding (Subclass provides an implementation of a method already provided in the Superclass).
• Abstraction: Concealing complex implementation details and revealing only what is required by the user.
  • Implementation: Implement using Abstract Classes and Interfaces.

Step 6. Arrays: Holding Groups of Data

An Array is an object container that stores a group of values of one fixed type.

6.1. Declaring and Initializing an Array

public class ArrayExample {

    public static void main(String[] args) {

        // 1. Declare and initialize an array of integers

        int[] numbers = {10, 20, 30, 40, 50};

        // 2. Accessing elements (Arrays are zero-indexed, meaning the first element is at index 0)

        System.out.println(“First element: ” + numbers[0]); // Output: 10

        System.out.println(“Third element: ” + numbers[2]); // Output: 30

        // 3. Getting the array length

        System.out.println(“Array length: ” + numbers.length); // Output: 5

        // 4. Looping through an array using an enhanced for loop (for-each)

        System.out.println(“\nAll elements:”);

        for (int num : numbers) {

            System.out.println(num);

        }

    }

}

Step 7. Beyond the Basics

After you learn these basics, your next move will be to:

• Collections Framework: Learning dynamic data structures such as ArrayLists (dynamic arrays) and HashMaps (key-value pairs) which are far more prevalent in real-world code than simple arrays.
• Exception Handling: Catching errors using try-catch blocks.
• File I/O: Reading from and writing to files.
• Java Standard API: Navigating the extensive collection of pre-built Java classes.
• Build Tools: Applying Maven or Gradle for handling third-party libraries and building projects.

Ready to put your skills to the test and tackle real-world coding challenges? Jump into our extensive collection of Java Challenges and Solutions today to speed up your learning and build your portfolio!

Real Time Examples for Java Tutorial for Learners

Here are some new, separate real-time examples for Java tutorial:

Easy ATM Simulation (Core Java/OOP Emphasis):

• Concept: Illustrates Object-Oriented Programming (OOP) by defining a User class (with attributes such as account number and balance) and an ATM class (with operations such as deposit, withdraw, and checkBalance).
• Real-time Element: Utilizes Scanner for real-time console input to mimic user action (typing in options and amounts). The logic applies real-world constraints, e.g., lack of funds and minimum withdraw amount, and introduces concepts of exceptions and conditional logic.
• Key Learning: Solid grounding in classes, objects, methods, state management, and simple user input.

RESTful API for Employee Directory (Spring Boot Focus):

• Concept: Develops the backend of an application using the Spring Boot framework to manage data access through APIs.
• Real-time Element: Develops REST endpoints (e.g., /api/employees) which reply in real time to HTTP requests (such as GET to retrieve data or POST to create a new employee) from a different frontend or API test tool such as Postman.
• Key Learning: Contemporary Java backend development with Dependency Injection, REST API modeling, and using the Tomcat server embedded in Spring Boot.

Basic Chat Application (Java Sockets Emphasis):

• Concept: Creates a client-server program to enable plain-text messaging.
• Real-time Aspect: Applies Java Sockets (ServerSocket and Socket) to create an ongoing network link between two applications. The program manages simultaneous, real-time message transfer between receiver and sender, exemplifying concurrent processing.
• Key Learning: Networking basics, multithreading (to process several clients/messages concurrently), and important real-time communication fundamentals usually applied in enterprise-level systems.

Ready to begin with building? Take our Java Project Ideas list, ideal for beginners to create a robust portfolio!

FAQs About Java Tutorial for Beginners

Conclusion

You’ve made the important first steps in your Java programming career! You know the basic environment, the outline of a Java program, how to operate with variables and control flow, and the basic principles of Object-Oriented Programming (OOP). Regular practice is the only means of cementing this information and moving from being a beginner to being a career-ready programmer. Become a master in coding with our Java course in Chennai.