Sai Sree Satya

Search

SearchSearch

Java Fundamentals

Sep 22, 2025, 11 min read

Java Fundamentals: Your Complete Beginner’s Guide 🚀

Master the building blocks of Java programming step by step

😅 My Interview Story (Why This Guide Exists)

Interviewer: “So, what is static and why do we use it?”

Me: 😐 blank face “Uhh… it’s… static?”

Interviewer: “And what does public mean?”

Me: 🤯 sweating profusely “It means… everyone can see it?”

Result: Epic fail! 💀

That’s exactly why I created this guide! No more blank faces in interviews. No more forgetting the basics when you need them most. After reading this, you’ll confidently explain Java concepts like a pro!

This guide covers EVERYTHING they ask in interviews about Java basics. Bookmark it, study it, ace those interviews! 🏆

🎯 What You’ll Learn Today

By the end of this guide, you’ll understand:

  • How Java code is structured and organized
  • What each keyword means and why it’s important
  • How to read and write basic Java programs
  • The fundamental concepts that power every Java application

Let’s start with the big picture, then dive into details!

🏗️ Understanding Your Code Structure

Let’s examine this Java skeleton and break it down piece by piece:

class Main {
    
    public static void Printlinkedlist(Node head){
        // Code to print linked list goes here
    }
    
    public static Node reverser(Node head){
        // Code to reverse linked list goes here
        return prev;
    }
    
    public static void main(String[] args) {
        Printlinkedlist(a);
        System.out.println(Reverse(a));
    }
}

Think of this like a blueprint for a house - it shows the structure before we build it!

📚 Part 1: The Foundation - Classes

What is a class?

class Main {
    // Everything goes inside here
}

Think of a class as a CONTAINER or BLUEPRINT:

🏠 Real-world analogy: A class is like an architectural blueprint

  • The blueprint for a “Car” shows what every car should have: wheels, engine, doors
  • The blueprint for “Main” shows what our program should have: methods and variables

Why do we need classes?

  • Organization: Keeps related code together
  • Reusability: We can create multiple objects from one class
  • Structure: Makes code easier to understand and maintain

Examples to understand classes:

// Blueprint for a Student
class Student {
    String name;
    int age;
    
    void study() {
        System.out.println("Student is studying");
    }
}
 
// Blueprint for a Calculator  
class Calculator {
    int add(int a, int b) {
        return a + b;
    }
}

Key Point: Everything in Java happens inside classes. You cannot write Java code floating around outside a class!

🔐 Part 2: Access Control - The public Keyword

What does public mean?

public static void Printlinkedlist(Node head) {
    // This method can be accessed from anywhere
}

Think of public as PERMISSION LEVELS:

🏢 Real-world analogy:

  • public = Like a public park - anyone can enter
  • private = Like your bedroom - only you can enter
  • protected = Like a family gathering - only family members can enter

Visual representation:

public class School {
    public String schoolName;        // 🌍 Everyone can see
    private String principalPassword; // 🔒 Only School class can see
    protected int studentCount;      // 👨‍👩‍👧‍👦 Only School and its subclasses
}

Why use different access levels?

  • Security: Keep sensitive data private
  • Organization: Control what other programmers can use
  • Maintenance: Changes to private methods won’t break other code

⚡ Part 3: The Power of static

What makes something static?

public static void Printlinkedlist(Node head) {
    // This belongs to the CLASS, not to any specific object
}

The static keyword is CRUCIAL - let’s understand it deeply:

🏭 Factory analogy:

  • Non-static (Instance): Each car from the factory has its own steering wheel
  • Static (Class): The factory itself has one main office that all cars share

Code example to see the difference:

class Counter {
    static int totalCount = 0;    // SHARED by all Counter objects
    int individualCount = 0;      // UNIQUE to each Counter object
    
    static void showTotal() {     // Can be called without creating object
        System.out.println("Total: " + totalCount);
    }
    
    void increment() {            // Needs an object to be called
        individualCount++;
        totalCount++;
    }
}
 
// Usage:
Counter.showTotal();           // ✅ Works - static method
// Counter.increment();        // ❌ Error - need an object
 
Counter c1 = new Counter();
c1.increment();                // ✅ Works - instance method

When to use static:

  • ✅ Utility methods (like Math.max())
  • ✅ The main() method (JVM needs to call it without creating objects)
  • ✅ Constants that don’t change
  • ❌ Methods that work with object-specific data

🚫 Part 4: The void Keyword - No Return Zone

What does void mean?

public static void Printlinkedlist(Node head) {
    // This method does something but doesn't give anything back
}

Think of void as a ONE-WAY STREET:

📮 Real-world analogy:

  • void method = Like mailing a letter - you send it, but don’t expect anything back
  • return method = Like ordering food - you pay money, you get food back

Visual comparison:

// VOID - Does something, returns nothing
public static void printWelcome() {
    System.out.println("Welcome to Java!");
    // No return statement needed
}
 
// RETURN - Does something, gives back a result  
public static int addNumbers(int a, int b) {
    int sum = a + b;
    return sum;  // Must return an integer
}
 
// Usage:
printWelcome();              // Just runs the code inside
int result = addNumbers(5, 3); // Gets back the value 8

Common void methods you’ll see:

  • Printing to console
  • Updating variables
  • Drawing graphics
  • Playing sounds

🔄 Part 5: Methods That Return Values

Understanding Return Types

public static Node reverser(Node head) {
    // This method gives back a Node object
    return prev;
}

Return types tell us WHAT WE GET BACK:

🏪 Shopping analogy:

  • You go to different shops (methods)
  • Each shop gives you different things (return types)
  • Grocery store → Food (Food return type)
  • Bank → Money (int for amount)
  • Library → Books (Book return type)

Common return types:

// Primitive return types
public static int getAge() { return 25; }
public static boolean isStudent() { return true; }
public static double getPrice() { return 99.99; }
public static char getGrade() { return 'A'; }
 
// Object return types  
public static String getName() { return "Alice"; }
public static Node getFirstNode() { return firstNode; }
public static List<Integer> getNumbers() { return numberList; }

Golden Rule: If your method calculates, finds, or creates something that other code needs, use a return type. If it just performs an action, use void.

🎬 Part 6: The main Method - Where Everything Begins

The Special main Method

public static void main(String[] args) {
    // Your program starts here!
}

The main method is like the DIRECTOR of a movie:

🎬 Movie analogy:

  • Director (main method): Tells everyone what to do and when
  • Actors (other methods): Do specific tasks when called
  • Script (your code): The plan that everyone follows

Why does main have this exact signature?

public    // JVM needs access from outside your class
static    // JVM can't create objects, so method must be static  
void      // Program doesn't return anything to operating system
main      // Special name that JVM looks for
String[]  // Command line arguments (like terminal commands)
args      // Name for the arguments array (can be anything)

Understanding String[] args:

public static void main(String[] args) {
    if (args.length > 0) {
        System.out.println("You passed: " + args[0]);
    } else {
        System.out.println("No arguments provided");
    }
}

Running with arguments:

java Main hello world
# Output: You passed: hello

🖨️ Part 7: Input/Output - Communicating with Users

Understanding System.out.println

System.out.println("Hello World!");
System.out.println(Reverse(a));

Breaking down System.out.println:

🏢 Office building analogy:

  • System: The entire office building
  • out: The PR department (handles outgoing messages)
  • println: The specific employee who prints messages with new lines

Different ways to output:

// Print with newline
System.out.println("Hello");
System.out.println("World");
// Output:
// Hello
// World
 
// Print without newline  
System.out.print("Hello");
System.out.print("World");
// Output: HelloWorld
 
// Print with formatting
System.out.printf("Name: %s, Age: %d%n", "Alice", 25);
// Output: Name: Alice, Age: 25

🔗 Part 8: Method Calls and Program Flow

How Methods Work Together

Printlinkedlist(a);                // Calls method, expects nothing back
System.out.println(Reverse(a));    // Calls method, uses returned value

Think of method calls like DELEGATING TASKS:

👔 Office analogy:

  • Manager (main method): “Hey PrintLinkedList, display this data”
  • Employee (PrintLinkedList method): Does the work, reports back “Done”
  • Manager: “Hey Reverse, process this data and give me the result”
  • Employee (Reverse method): Does the work, hands back the processed data

Method call flow visualization:

public static void main(String[] args) {
    System.out.println("1. Program starts");
    
    printMessage();                    // Goes to printMessage method
    
    int result = addNumbers(5, 3);     // Goes to addNumbers method
    System.out.println("Result: " + result);
    
    System.out.println("4. Program ends");
}
 
public static void printMessage() {
    System.out.println("2. Inside printMessage method");
    // Returns to main automatically
}
 
public static int addNumbers(int a, int b) {
    System.out.println("3. Inside addNumbers method");
    return a + b;  // Returns to main with value 8
}

Output:

1. Program starts
2. Inside printMessage method  
3. Inside addNumbers method
Result: 8
4. Program ends

🧩 Part 9: Custom Return Types

Understanding Custom Classes as Return Types

public static Node reverser(Node head) {
    return prev;
}

The key point here: Node is just an example of a custom class being used as a return type. It could be ANY class:

// Examples of different return types
public static String getName() { return "Alice"; }
public static Student getTopStudent() { return topStudent; }
public static Car createCar() { return new Car(); }
public static Node processData() { return someNode; }

What matters for Java basics:

  • The method returns an object (not void)
  • You can return any type - primitive or custom class
  • The return type must match what you actually return

Don’t worry about what Node specifically does - it’s just showing the concept of returning custom objects!

⚠️ Part 10: Common Pitfalls and Best Practices

Issues in Your Original Code

// ❌ Problem: Method names don't match
public static Node reverser(Node head) { ... }
System.out.println(Reverse(a));  // Should be "reverser", not "Reverse"
 
// ❌ Problem: Variable 'a' is not defined
Printlinkedlist(a);  // Where does 'a' come from?
 
// ❌ Problem: Method names should follow camelCase
Printlinkedlist  // Should be: printLinkedList

✅ Corrected Version:

class Main {
    
    public static void printMessage() {
        System.out.println("Hello from Java!");
    }
    
    public static int addTwoNumbers(int a, int b) {
        return a + b;
    }
    
    public static void main(String[] args) {
        printMessage();
        int result = addTwoNumbers(5, 3);
        System.out.println("Result: " + result);
    }
}

Key fixes:

  • ✅ Method names follow camelCase convention
  • ✅ Variables are properly defined
  • ✅ Method calls match actual method names
  • ✅ Complete working example with clear logic

🎯 Part 11: Quick Reference Summary

Keywords Cheat Sheet

KeywordPurposeWhen to UseExample
classCreate a blueprint/templateAlways - everything goes in classesclass Student { }
publicMake accessible everywhereWhen others need to use itpublic void display()
privateKeep it secret within classFor internal implementationprivate String password
staticBelongs to class, not objectsUtility methods, main methodstatic void main()
voidMethod returns nothingWhen just performing actionsvoid printMessage()
return typeMethod gives back a valueWhen calculating/finding somethingint calculateSum()

Method Signature Breakdown

public static void printMessage(String text) {
  ^      ^     ^      ^              ^
  |      |     |      |              |
Access  |   Return  Method        Parameters
Level   |    Type    Name
        |
    Belongs to class

Common Patterns You’ll See

// 1. Main method (program entry point)
public static void main(String[] args) { }
 
// 2. Utility methods (helper functions)
public static int max(int a, int b) { }
 
// 3. Object methods (work with instance data)  
public void updateName(String newName) { }
 
// 4. Constructor (create new objects)
public Student(String name, int age) { }

✅ Summary of Keywords in Your Code

KeywordMeaning
classBlueprint to create objects
publicAccessible from anywhere
staticBelongs to class, no object needed
voidMethod returns nothing
mainEntry point of program
String[] argsCommand-line arguments array
System.out.printlnPrint text or values to console

🚀 What’s Next?

Now that you understand the fundamentals:

  1. Practice: Try writing simple methods with different return types
  2. Experiment: Create your own classes and objects
  3. Build: Start with small programs like calculators or simple games
  4. Learn: Explore object-oriented programming concepts like inheritance and polymorphism

Remember: Every expert was once a beginner. These concepts might seem overwhelming now, but with practice, they’ll become second nature!

💡 Final Thought

Java is like learning a new language. You start with basic words (keywords), learn grammar rules (syntax), and gradually build up to writing stories (programs). Every concept you’ve learned today is a building block for more advanced programming concepts.

Keep coding, keep learning, and most importantly - don’t be afraid to make mistakes. They’re your best teachers! 🌟

💼 You can check out my job preparation journey -MY Interview.

Happy coding! 🎉

Graph View

Backlinks