Premium Content

JAVA BASICS

Learn the fundamental structure of Java programs

Beginner

Module 1: Java Program Structure

Java is a powerful, object-oriented programming language known for its portability and robustness. Every Java program has a specific structure that includes classes, methods, and statements. Understanding this structure is essential for writing effective Java code.

Try It Yourself:

Java

public class HelloWorld {
    public static void main(String[] args) {
        // This is a simple Java program
        System.out.println("Hello, World!");
        System.out.println("Welcome to Java programming!");
        
        // Variables and basic operations
        int x = 10;
        int y = 5;
        int sum = x + y;
        
        System.out.println("The sum of " + x + " and " + y + " is: " + sum);
        
        // Conditional statement
        if (sum > 10) {
            System.out.println("The sum is greater than 10");
        } else {
            System.out.println("The sum is 10 or less");
        }
    }
}

Console Output

Key Points:

Every Java program must have a class definition (like HelloWorld)
The main method is the entry point of any Java application
System.out.println() is used to output text to the console
Java is case-sensitive: Main is different from main
Code statements must end with a semicolon (;)
Comments start with // for single-line or /* */ for multi-line
Code blocks are enclosed in curly braces {}

Premium Content

DATA TYPES & VARIABLES

Learn about Java data types and variable declaration

Beginner

Module 2: Data Types and Variables

Java is a strongly typed language, which means every variable must be declared with a specific data type. Java has two categories of data types: primitive types and reference types. Understanding these is crucial for effective programming.

Try It Yourself:

Java

public class DataTypes {
    public static void main(String[] args) {
        // Primitive data types
        byte myByte = 100;                 // 8-bit integer (-128 to 127)
        short myShort = 5000;              // 16-bit integer (-32,768 to 32,767)
        int myInt = 100000;                // 32-bit integer (most common)
        long myLong = 15000000000L;        // 64-bit integer (note the L suffix)
        
        float myFloat = 5.75f;             // 32-bit floating point (note the f suffix)
        double myDouble = 19.99d;          // 64-bit floating point (most common for decimals)
        
        char myChar = 'A';                 // Single 16-bit Unicode character
        boolean myBoolean = true;          // true or false values
        
        // Reference data types
        String myString = "Hello Java";    // Sequence of characters
        
        // Output variables
        System.out.println("byte: " + myByte);
        System.out.println("short: " + myShort);
        System.out.println("int: " + myInt);
        System.out.println("long: " + myLong);
        System.out.println("float: " + myFloat);
        System.out.println("double: " + myDouble);
        System.out.println("char: " + myChar);
        System.out.println("boolean: " + myBoolean);
        System.out.println("String: " + myString);
        
        // Type casting
        System.out.println("\n--- Type Casting ---");
        int intValue = 100;
        double doubleValue = intValue;     // Widening casting (automatic)
        System.out.println("int to double: " + intValue + " -> " + doubleValue);
        
        double anotherDouble = 9.78;
        int anotherInt = (int) anotherDouble; // Narrowing casting (manual)
        System.out.println("double to int: " + anotherDouble + " -> " + anotherInt);
    }
}

Console Output

Key Points:

Java has 8 primitive data types: byte, short, int, long, float, double, char, and boolean
Reference types include String, arrays, and objects
Variables must be declared with a type before use
Java supports both widening (automatic) and narrowing (manual) type casting
Use descriptive variable names following camelCase convention
String is not a primitive type but a class in Java
Literal values for long need an 'L' suffix, float needs an 'f' suffix

Premium Content

CONTROL FLOW

Learn about conditional statements and loops in Java

Beginner

Module 3: Control Flow Statements

Control flow statements allow your program to make decisions and repeat actions. Java provides conditional statements like if-else and switch, and looping statements like for, while, and do-while to control the flow of execution.

Try It Yourself:

Java

public class ControlFlow {
    public static void main(String[] args) {
        // If-else statement
        int number = 10;
        
        if (number > 0) {
            System.out.println(number + " is positive");
        } else if (number < 0) {
            System.out.println(number + " is negative");
        } else {
            System.out.println(number + " is zero");
        }
        
        // Switch statement
        int day = 3;
        String dayName;
        
        switch (day) {
            case 1:
                dayName = "Monday";
                break;
            case 2:
                dayName = "Tuesday";
                break;
            case 3:
                dayName = "Wednesday";
                break;
            case 4:
                dayName = "Thursday";
                break;
            case 5:
                dayName = "Friday";
                break;
            case 6:
                dayName = "Saturday";
                break;
            case 7:
                dayName = "Sunday";
                break;
            default:
                dayName = "Invalid day";
                break;
        }
        System.out.println("Day " + day + " is: " + dayName);
        
        // For loop
        System.out.println("\nCounting from 1 to 5:");
        for (int i = 1; i <= 5; i++) {
            System.out.println("Count: " + i);
        }
        
        // While loop
        System.out.println("\nCounting down from 5:");
        int count = 5;
        while (count > 0) {
            System.out.println("Countdown: " + count);
            count--;
        }
        
        // Do-while loop
        System.out.println("\nPrinting at least once with do-while:");
        int x = 1;
        do {
            System.out.println("This runs at least once: " + x);
            x++;
        } while (x <= 3);
    }
}

Console Output

Key Points:

if-else statements allow conditional execution of code blocks
switch statements provide multi-way branching based on a value
Always include break statements in switch cases to prevent fall-through
for loops are ideal when the number of iterations is known
while loops continue as long as the condition is true
do-while loops always execute at least once before checking the condition
Use continue to skip the current iteration and break to exit a loop entirely
Be cautious of infinite loops - ensure the loop condition will eventually become false

Premium Content

METHODS & CLASSES

Learn to organize code with methods and classes

Intermediate

Module 4: Methods and Classes

Methods allow you to break your code into reusable blocks, while classes are the building blocks of object-oriented programming in Java. Understanding how to create and use methods and classes is essential for writing modular, maintainable code.

Try It Yourself:

Java

// Define a simple class
class Calculator {
    // Instance variable
    private String model;
    
    // Constructor
    public Calculator(String model) {
        this.model = model;
    }
    
    // Method with return value and parameters
    public int add(int a, int b) {
        return a + b;
    }
    
    // Method overloading (same name, different parameters)
    public double add(double a, double b) {
        return a + b;
    }
    
    // Method with no return value
    public void displayModel() {
        System.out.println("Calculator model: " + model);
    }
    
    // Static method (can be called without creating an object)
    public static void printBrand() {
        System.out.println("JavaCalc Brand");
    }
}

public class MethodsAndClasses {
    public static void main(String[] args) {
        // Create an object of Calculator class
        Calculator myCalc = new Calculator("Scientific");
        
        // Call methods
        myCalc.displayModel();
        
        int result1 = myCalc.add(5, 3);
        System.out.println("5 + 3 = " + result1);
        
        double result2 = myCalc.add(2.5, 3.7);
        System.out.println("2.5 + 3.7 = " + result2);
        
        // Call static method
        Calculator.printBrand();
        
        // Demonstrate method with different scope
        System.out.println("\n--- Local vs Instance Variables ---");
        demonstrateScope();
    }
    
    // Another method in the main class
    public static void demonstrateScope() {
        int localVar = 10; // Local variable - only accessible in this method
        System.out.println("Local variable value: " + localVar);
        
        // Cannot access instance variables from static method
        // System.out.println(model); // This would cause an error
    }
}

Console Output

Key Points:

Methods are blocks of code that perform specific tasks and can be reused
Classes are blueprints for creating objects with properties and behaviors
Constructors are special methods used to initialize objects
Method overloading allows multiple methods with the same name but different parameters
static methods belong to the class rather than instances
Instance variables are declared in a class but outside any method
Local variables are declared within methods and have limited scope
The this keyword refers to the current object instance
Access modifiers (public, private, etc.) control visibility of classes, methods, and variables

Premium Content

OOP CONCEPTS

Learn Object-Oriented Programming principles

Intermediate

Module 5: Object-Oriented Programming Concepts

Object-Oriented Programming (OOP) is a programming paradigm based on the concept of "objects", which can contain data and code. Java's OOP principles include encapsulation, inheritance, polymorphism, and abstraction. These concepts help create flexible and maintainable code.

Try It Yourself:

Java

// Base class (parent)
class Animal {
    // Encapsulation: private fields with public getters/setters
    private String name;
    private int age;
    
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    // Getter and setter methods
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public int getAge() {
        return age;
    }
    
    public void setAge(int age) {
        this.age = age;
    }
    
    // Method to be overridden (polymorphism)
    public void makeSound() {
        System.out.println("The animal makes a sound");
    }
    
    // Abstraction: common method for all animals
    public void sleep() {
        System.out.println(name + " is sleeping");
    }
}

// Inheritance: Dog extends Animal
class Dog extends Animal {
    private String breed;
    
    public Dog(String name, int age, String breed) {
        super(name, age); // Call parent constructor
        this.breed = breed;
    }
    
    // Polymorphism: method overriding
    @Override
    public void makeSound() {
        System.out.println(getName() + " says: Woof! Woof!");
    }
    
    // Additional method specific to Dog
    public void fetch() {
        System.out.println(getName() + " is fetching the ball");
    }
    
    public String getBreed() {
        return breed;
    }
}

// Another subclass
class Cat extends Animal {
    public Cat(String name, int age) {
        super(name, age);
    }
    
    // Polymorphism: method overriding
    @Override
    public void makeSound() {
        System.out.println(getName() + " says: Meow!");
    }
}

public class OOPConcepts {
    public static void main(String[] args) {
        // Create objects
        Dog myDog = new Dog("Buddy", 3, "Golden Retriever");
        Cat myCat = new Cat("Whiskers", 2);
        
        // Demonstrate encapsulation
        System.out.println("Dog: " + myDog.getName() + ", Breed: " + myDog.getBreed());
        System.out.println("Cat: " + myCat.getName() + ", Age: " + myCat.getAge());
        
        // Demonstrate polymorphism
        System.out.println("\n--- Animal Sounds (Polymorphism) ---");
        Animal[] animals = {myDog, myCat};
        for (Animal animal : animals) {
            animal.makeSound(); // Calls the appropriate overridden method
        }
        
        // Demonstrate inheritance and additional methods
        System.out.println("\n--- Dog-specific Behavior ---");
        myDog.fetch();
        myDog.sleep(); // Inherited method
        
        // Demonstrate abstraction
        System.out.println("\n--- Abstraction in Action ---");
        myCat.sleep(); // Common behavior for all animals
    }
}

Console Output

Key Points:

Encapsulation: Bundling data and methods that operate on that data, restricting direct access to some components
Inheritance: Allows a class to inherit properties and behaviors from another class (using extends)
Polymorphism: The ability of objects to take on many forms, typically through method overriding
Abstraction: Hiding complex implementation details and showing only essential features
Use super keyword to access parent class members
The @Override annotation indicates that a method is being overridden from a parent class
Java supports single inheritance for classes (a class can extend only one parent class)
Getter and setter methods provide controlled access to private fields
OOP principles help create more modular, flexible, and reusable code

Premium Content

ADVANCED JAVA

Learn advanced Java concepts and features

Intermediate

Module 6: Advanced Java Concepts

Advanced Java includes concepts like exception handling, collections framework, generics, and multithreading. These features make Java a powerful language for building robust, efficient, and scalable applications.

Try It Yourself:

Java

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class AdvancedJava {
    public static void main(String[] args) {
        // Exception handling
        System.out.println("--- Exception Handling ---");
        try {
            int[] numbers = {1, 2, 3};
            System.out.println(numbers[5]); // This will cause an ArrayIndexOutOfBoundsException
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Exception caught: " + e.getMessage());
        } finally {
            System.out.println("This block always executes");
        }
        
        // Collections Framework
        System.out.println("\n--- Collections Framework ---");
        
        // List example
        List<String> fruits = new ArrayList<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Orange");
        
        System.out.println("Fruits list: " + fruits);
        System.out.println("First fruit: " + fruits.get(0));
        
        // Map example
        Map<String, Integer> studentGrades = new HashMap<>();
        studentGrades.put("Alice", 90);
        studentGrades.put("Bob", 85);
        studentGrades.put("Charlie", 95);
        
        System.out.println("Student grades: " + studentGrades);
        System.out.println("Bob's grade: " + studentGrades.get("Bob"));
        
        // Generics
        System.out.println("\n--- Generics ---");
        Box<Integer> integerBox = new Box<>();
        integerBox.setContent(42);
        System.out.println("Integer box contains: " + integerBox.getContent());
        
        Box<String> stringBox = new Box<>();
        stringBox.setContent("Hello Generics");
        System.out.println("String box contains: " + stringBox.getContent());
        
        // Multithreading
        System.out.println("\n--- Multithreading ---");
        Thread thread1 = new Thread(new SimpleTask("Task 1"));
        Thread thread2 = new Thread(new SimpleTask("Task 2"));
        
        thread1.start();
        thread2.start();
        
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        System.out.println("Both threads have finished execution");
    }
}

// Generic class example
class Box<T> {
    private T content;
    
    public void setContent(T content) {
        this.content = content;
    }
    
    public T getContent() {
        return content;
    }
}

// Multithreading example
class SimpleTask implements Runnable {
    private String taskName;
    
    public SimpleTask(String taskName) {
        this.taskName = taskName;
    }
    
    @Override
    public void run() {
        for (int i = 1; i <= 3; i++) {
            System.out.println(taskName + " - Step " + i);
            try {
                Thread.sleep(500); // Pause for 500 milliseconds
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Console Output

Key Points:

Exception Handling: Use try-catch-finally blocks to handle runtime errors gracefully
Collections Framework: Provides data structures like List, Set, Map for storing and manipulating groups of objects
Generics: Enable types (classes and interfaces) to be parameters when defining classes, interfaces, and methods
Multithreading: Allows concurrent execution of two or more parts of a program for maximum utilization of CPU
Java provides both checked (compile-time) and unchecked (runtime) exceptions
ArrayList is a resizable array implementation of the List interface
HashMap stores key-value pairs and allows null values and the null key
Generic types provide type safety and eliminate the need for casting
Threads can be created by implementing the Runnable interface or extending the Thread class
The join() method allows one thread to wait for the completion of another

PRACTICE PLAYGROUND

Experiment with what you've learned

Your Coding Playground: Try Your Own Java Code

Use this space to experiment with everything you've learned. Try writing Java programs and see the results in real-time! This is your sandbox to practice and explore.

Java

public class Playground {
    public static void main(String[] args) {
        System.out.println("Welcome to the Java Playground!");
        System.out.println("Modify this code to practice what you've learned.");
        
        // Try creating your own classes and methods
        String message = "Hello, Java Developer!";
        printMessage(message);
        
        // Experiment with different Java features
        int result = calculateSum(10, 20);
        System.out.println("The sum is: " + result);
        
        // Create objects and try OOP concepts
        Person person = new Person("Alice", 25);
        person.introduce();
    }
    
    public static void printMessage(String msg) {
        System.out.println("Message: " + msg);
    }
    
    public static int calculateSum(int a, int b) {
        return a + b;
    }
}

// You can define additional classes here
class Person {
    private String name;
    private int age;
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public void introduce() {
        System.out.println("Hi, I'm " + name + " and I'm " + age + " years old.");
    }
}

Console Output

Challenge Exercises:

Create a calculator class with methods for basic arithmetic operations
- Add, subtract, multiply, and divide methods
- Handle division by zero with exception handling
- Create a main method to test all operations
Build a student management system:
- Create a Student class with name, id, and grades
- Implement methods to calculate average grade
- Use a collection to store multiple students
Implement a simple bank account system:
- Create BankAccount class with account number and balance
- Implement deposit and withdraw methods with validation
- Add exception handling for insufficient funds
Create a multithreaded program:
- Create two threads that count to 10
- Add a delay between numbers to see interleaving
- Use synchronization to make the counting orderly
Experiment with Java's Collections Framework:
- Create lists of different types
- Use HashMap to create a simple dictionary
- Iterate through collections using different methods

Tips & Resources:

Remember that Java is case-sensitive
All statements must end with a semicolon
Use descriptive variable and method names following camelCase convention
Java documentation is your best friend: https://docs.oracle.com/javase/8/docs/api/
Practice problem-solving on platforms like HackerRank and LeetCode

JAVA BASICS

Learn the fundamental structure of Java programs

Module 1: Java Program Structure

Try It Yourself:

Key Points:

DATA TYPES & VARIABLES

Learn about Java data types and variable declaration

Module 2: Data Types and Variables

Try It Yourself:

Key Points:

CONTROL FLOW

Learn about conditional statements and loops in Java

Module 3: Control Flow Statements

Try It Yourself:

Key Points:

METHODS & CLASSES

Learn to organize code with methods and classes

Module 4: Methods and Classes

Try It Yourself:

Key Points:

OOP CONCEPTS

Learn Object-Oriented Programming principles

Module 5: Object-Oriented Programming Concepts

Try It Yourself:

Key Points:

ADVANCED JAVA

Learn advanced Java concepts and features

Module 6: Advanced Java Concepts

Try It Yourself:

Key Points:

PRACTICE PLAYGROUND

Experiment with what you've learned

Your Coding Playground: Try Your Own Java Code

Challenge Exercises:

Tips & Resources:

Unlock Premium SkillMynte Content

Premium Courses

Certification

Mentorship

Monthly

Annual Best Value

Lifetime