Java Programming Core Concepts and Study Notes

Posted on Aug 25, 2026 in Computer Engineering in Information Technologies Engineering

Core Study Notes by Unit

Unit I: Fundamentals of OOP and Java Basics

Basic Concepts of OOP

  • The fundamental pillars are Classes, Objects, Encapsulation (hiding data), Inheritance (reusability), Polymorphism (one interface, multiple methods), and Abstraction.

Java Evolution and Features

  • Java is distinct from C/C++ because it is platform-independent (Write Once, Run Anywhere), robust, secure, and uses both a compiler and an interpreter. It does not support pointers directly to ensure security.

The JVM (Java Virtual Machine)

  • The heart of Java’s platform independence. It converts compiled bytecode (.class files) into machine-specific code.

Command Line Arguments

  • These allow users to pass arguments to the main() method when executing a Java program via the terminal.

Unit II: Data Types, Operators, and Control Statements

Data Types and Variables

  • Java is strongly typed. Primitive types include int, float, double, char, and boolean. Typecasting allows for converting one data type to another (e.g., int to float).

Operators

  • Understand the precedence and associativity of Arithmetic, Relational, Logical, Bitwise, and Conditional (Ternary) operators.

Control Statements

  • Decision Making: if, if-else, switch.
  • Looping: for, while, do-while.
  • Jumps: break, continue, and labeled loops.

Unit III: Classes, Objects, Arrays, and Inheritance

Classes and Objects

  • A class is a blueprint, while an object is an instance of a class.

Methods and Constructors

  • Constructors initialize objects and have the same name as the class.

Overloading vs. Overriding

  • Method Overloading occurs within the same class (same name, different parameters).
  • Method Overriding occurs in a subclass (same name, same parameters) to provide a specific implementation.

Arrays and Vectors

  • Arrays have a fixed size (1D and 2D). Vector is a dynamic array found in java.util.

Inheritance and Polymorphism

  • Java supports single, multilevel, and hierarchical inheritance using the extends keyword.
  • Important: Java does not support multiple inheritance through classes, but achieves it using Interfaces (implements keyword).

Unit IV: Packages and Exception Handling

Packages

  • A mechanism to encapsulate a group of classes, sub-packages, and interfaces. Examples include java.lang (default) and java.util. You can create user-defined packages using the package keyword.

Exception Handling

  • A mechanism to handle runtime errors to maintain normal application flow.
  • try: Block of code where exceptions might occur.
  • catch: Block that handles the exception.
  • finally: Block that always executes, regardless of whether an exception is caught.
  • throw & throws: Used to manually trigger and declare exceptions.

Important Questions and Answers

Q1: What is the main difference between C++ and Java?

  • Answer: C++ is platform-dependent, supports pointers, and allows multiple inheritance through classes. Java is platform-independent (due to bytecode and the JVM), does not support explicit pointers for security reasons, and only supports multiple inheritance through interfaces.

Q2: How does Java achieve platform independence?

  • Answer: When Java code is compiled, it is not converted directly into machine code. Instead, the compiler generates “bytecode.” This bytecode can be executed on any operating system that has a Java Virtual Machine (JVM) installed, making the code portable across different platforms.

Q3: Explain the difference between Method Overloading and Overriding.

  • Method Overloading (Compile-time Polymorphism): Multiple methods in the same class share the same name but have different parameter lists (type, number, or order).
  • Method Overriding (Run-time Polymorphism): A method in a subclass has the exact same name, return type, and parameters as a method in its superclass, providing a specific implementation.

Q4: How does Java handle multiple inheritance?

  • Answer: Java prevents the “Diamond Problem” (ambiguity in multiple inheritance) by restricting a class from extending more than one superclass. Instead, it uses Interfaces. A single class can implement multiple interfaces, thereby achieving multiple inheritance safely.

Q5: What is the purpose of the finally block?

  • Answer: The finally block is used to place important code that must be executed whether an exception is thrown or not, such as closing database connections or closing file streams.

Essential Core Programs

Below are foundational programs that demonstrate the most critical concepts from the syllabus.

1. Command Line Arguments (Unit I)

public class CommandLineExample {
    public static void main(String[] args) {
        if(args.length > 0) {
            System.out.println("The first command line argument is: " + args[0]);
        } else {
            System.out.println("No arguments were provided.");
        }
    }
}

2. Method Overloading and Constructors (Unit III)

class MathOperations {
    // Constructor
    MathOperations() {
        System.out.println("MathOperations object created.");
    }
    // Method Overloading: Same method name, different parameters
    int add(int a, int b) {
        return a + b;
    }
    double add(double a, double b) {
        return a + b;
    }
}

public class OverloadingDemo {
    public static void main(String[] args) {
        MathOperations math = new MathOperations();
        System.out.println("Integer Addition: " + math.add(5, 10));
        System.out.println("Double Addition: " + math.add(5.5, 10.2));
    }
}

3. Exception Handling with Try-Catch-Finally (Unit IV)

public class ExceptionDemo {
    public static void main(String[] args) {
        try {
            int divideByZero = 10 / 0; // This will throw an ArithmeticException
            System.out.println("This line will not print");
        } catch (ArithmeticException e) {
            System.out.println("Error Caught: Cannot divide by zero.");
        } finally {
            System.out.println("Finally block executed: Cleaning up resources.");
        }
        System.out.println("Program continues normally.");
    }
}