A quick, practical guide to how a basic Java program is organized—classes, methods, the main entry point, packages, and more.

public class Main {
    // Program entry point
    public static void main(String[] args) {
        System.out.println("Hello, Java!");
    }
}

How Java Code Executes

This section explains the full journey from a .java source file to a running program on your machine.

1. Write Source Code (.java)

   You create a file such as HelloWorld.java that contains Java classes and methods.

   public class HelloWorld {
     public static void main(String[] args) {
       System.out.println("Hello, Java!");
     }
   }

2. Compile with javac

   The Java compiler checks syntax and type rules, then converts source code into platform-independent bytecode stored in .class files.

   javac HelloWorld.java   # produces HelloWorld.class

3. Class Loading

   When you run the program, the Class Loader loads required classes (rt.jar/modules, third-party libs, your classes) into memory.

4. Bytecode Verification

   The Bytecode Verifier ensures the .class files are safe and follow JVM constraints (no illegal casts, stack overflows, etc.).

5. Execution in the JVM

   The Execution Engine of the JVM runs the verified bytecode:

   • Interpreter quickly executes bytecode instructions one by one.
   • JIT (Just-In-Time) Compiler detects hot code paths and compiles them into native machine code for better performance.

   The JVM manages memory via the Heap and Stack, and reclaims unused objects using the Garbage Collector.

6. Program Output

   After execution, your program produces output on the console, files, network, or UI.

   java HelloWorld
   # → Hello, Java!

Key Terms

• JDK: Tools to compile and develop Java (includes javac and the JVM).
• JRE: Environment to run Java apps (JVM + core libraries).
• JVM: Virtual machine that executes bytecode on any platform.
• Bytecode: Platform-independent instructions in .class files.
• JIT: Compiles hot bytecode paths into native code at runtime.

package com.acme.app;            // Directory: com/acme/app
import java.util.ArrayList;      // Single class
import java.util.*;              // Wildcard (use sparingly)

public class App {
	public static void main(String[] args) {
		ArrayList items = new ArrayList<>();
		items.add("Java");
		System.out.println(items);
	}
}

public class Counter {
	// field (state)
	private int value;

	// constructor
	public Counter(int start) {
		this.value = start;
	}

	// instance method
	public void increment() {
		value++;
	}

	// static method (belongs to the class)
	public static Counter ofZero() {
		return new Counter(0);
	}

	// getter
	public int getValue() {
		return value;
	}

}

/**
 * Calculator utilities.
 */
public class Calc {
    // Single-line comment
    public static int add(int a, int b) {
        return a + b;  // Inline comment (brief!)
    }
}

# From the folder containing Main.java
javac Main.java     # compile → Main.class
java Main           # run

javac com/acme/app/App.java
java com.acme.app.App

In Java, data types define what kind of values a variable can hold and how those values are stored and manipulated in memory. Java is a statically typed and strongly typed language, which means:

• Every variable has a declared type at compile time.
• Type conversions are explicit or follow well-defined rules.

High-Level Classification of Data Types

• Primitive Types – built into the language, store simple values.
• Reference Types – objects, arrays, enums, interfaces, etc.

Primitive Data Types

Java has 8 primitive data types:

• byte
• short
• int
• long
• float
• double
• char
• boolean

1. Integer Types

Used to store whole numbers (no decimal point).

byte

• Size: 8-bit signed integer.
• Range: -128 to 127.
• Use case: memory-sensitive contexts (large arrays of small numbers, streams, file I/O).

byte b = 100;
byte min = -128;
byte max = 127;

short

• Size: 16-bit signed integer.
• Range: -32,768 to 32,767.
• Use case: rarely used; legacy code and some binary data formats.

short s = 32000;

int

• Size: 32-bit signed integer.
• Range: approx. -2.1 billion to 2.1 billion.
• Most commonly used integer type.
• Default type for integer literals (e.g., 42 is an int).

int count = 42;
int population = 1_000_000; // underscores for readability

long

• Size: 64-bit signed integer.
• Range: extremely large (~9.22e18).
• Used when integer range of int is insufficient.
• Requires L or l suffix for literals when exceeding int range.

long big = 10_000_000_000L; // L is important

2. Floating-Point Types

Used to represent numbers with fractional parts.

float

• Size: 32-bit IEEE 754 floating-point.
• Precision: about 6–7 decimal digits.
• Use case: large arrays of floating values where memory matters and some precision loss is acceptable.
• Requires f or F suffix for literals.

float average = 3.14f; // 'f' or 'F' required

double

• Size: 64-bit IEEE 754 floating-point.
• Precision: about 15–16 decimal digits.
• Default type for floating-point literals (e.g., 3.14 is a double).
• Most common floating-point type in Java.

double pi = 3.141592653589793;
double result = 1.0 / 3.0;

3. char Type

• Size: 16-bit unsigned value.
• Represents a single Unicode character.
• Range: from '\u0000' to '\uffff'.

char letter = 'A';
char digit = '9';
char unicodeChar = '\u03A9'; // Greek capital letter Omega

4. boolean Type

• Represents two values: true or false.
• Commonly used in conditional statements and logical operations.
• No defined size in the Java language specification (implementation-dependent).

boolean isJavaFun = true;
boolean isCold = false;

Reference (Non-Primitive) Data Types

Reference types refer to objects stored in the heap. The variable holds a reference (similar to an address) to the object.

1. Classes and Objects

Any class you define is a reference type:

class Person {
    String name;
    int age;
}

Person p = new Person();
p.name = "Alice";
p.age = 30;

• Default value for an uninitialized reference field is null.
• Accessing a member on a null reference throws NullPointerException.

2. String

• String is a reference type, not primitive.
• Strings are immutable.
• Literals are created with double quotes: "Hello".

String message = "Hello, Java!";
String another = new String("Hello, Java!"); // usually not needed

3. Arrays

• Arrays are objects and thus reference types.
• They have a fixed length once created.

int[] numbers = new int[5];      // all elements initialized to 0
int[] values  = {1, 2, 3, 4, 5}; // array literal

System.out.println(values.length); // 5

4. Enums

Enums are special reference types representing a fixed set of constants.

enum Day {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

Day today = Day.MONDAY;

Enums in Java Overview

Enums in Java are used to represent a fixed set of named constants, making your code safer, more readable, and easier to maintain, especially when you want to restrict possible values a variable can take, such as days of the week, months, colors, or predefined states in a system.

Common Use Cases for Enum in Java

Representing Fixed Categories

Enums help define a set of constant values like days (MONDAY to SUNDAY), levels (LOW, MEDIUM, HIGH), ticket categories (CRITICAL, HIGH, MEDIUM, LOW), or seasons (WINTER, SPRING, SUMMER, AUTUMN).

Control Flow Statements

Enums are widely used in switch-case and if-else statements, for handling logic based on these named values. This improves code clarity and reduces errors from using arbitrary numbers or strings.

Type Safety

They ensure type safety by restricting values to those defined in the enum, unlike traditional final static constants which can be any value.

Grouping Related Constants

Useful for grouping constants related by context, for example, status codes, user roles, or configuration options in applications.

Example of Using Enum

    enum TicketCategory {
    CRITICAL, HIGH, MEDIUM, LOW;
}

public class Main {
    public static void main(String[] args) {
        TicketCategory category = TicketCategory.HIGH;
        switch (category) {
            case CRITICAL:
                System.out.println("Critical ticket");
                break;
            case HIGH:
                System.out.println("High priority ticket");
                break;
            case MEDIUM:
                System.out.println("Medium priority ticket");
                break;
            case LOW:
                System.out.println("Low priority ticket");
                break;
        }
    }
}

This code demonstrates how enums define constant categories and integrate smoothly with control statements like switch, improving code reliability and readability.

Advanced Use

Enums with Methods and Fields

Enums in Java can have methods, fields, and constructors, enabling them to store and operate on more complex data, such as associating a value or description with each constant.

Interface Implementation

Enums can implement interfaces to provide flexible code design patterns, such as providing descriptions or custom behaviors for each constant.

Conclusion

Overall, enums in Java are preferred whenever you need a variable to accept only a predetermined set of constant values, ensuring code safety and ease of maintenance.

5. Interfaces, Records, and Other Reference Types

• Interfaces define contracts; implementation classes are reference types.
• Records (Java 16+) are special classes for immutable data carriers.

record Point(int x, int y) {}

Point p = new Point(10, 20); // x=10, y=20

In Java 16 and later, you can use a record to simplify classes that are mainly data carriers. A record automatically provides private final fields, a constructor, getters, equals(), hashCode(), and toString() methods, which greatly reduces boilerplate code.s

Wrapper Classes and Autoboxing

Each primitive type has a corresponding wrapper class in java.lang:

• byte → Byte
• short → Short
• int → Integer
• long → Long
• float → Float
• double → Double
• char → Character
• boolean → Boolean

Autoboxing and Unboxing

Autoboxing is automatic conversion from primitive to wrapper type. Unboxing is the reverse.

Integer a = 10;   // autoboxing: int to Integer
int b = a;        // unboxing: Integer to int

List<Integer> list = new ArrayList<>();
list.add(5);      // autoboxing
int x = list.get(0); // unboxing

Common pitfall: unboxing a null wrapper will throw NullPointerException.

Integer n = null;
int y = n; // throws NullPointerException

Type Conversion and Casting

Widening Primitive Conversions (Safe, Implicit)

Small type → larger type, done automatically.

• byte → short → int → long → float → double
• char → int → long → float → double

int i = 100;
long l = i;       // OK, widening
double d = l;     // OK, widening

Narrowing Primitive Conversions (Explicit, Risky)

Large type → smaller type, requires explicit cast and may lose data.

long big = 130L;
byte b = (byte) big; // overflow: result is -126

double v = 3.9;
int k = (int) v;     // k = 3, fractional part lost

Reference Type Casting

You can cast references within an inheritance hierarchy. Incorrect casts cause ClassCastException at runtime.

Object obj = "Hello";
String str = (String) obj;      // OK

Object obj2 = Integer.valueOf(10);
String s = (String) obj2;       // ClassCastException at runtime

Default Values

Default values apply to fields (instance or static), not to local variables.

• byte, short, int, long → 0
• float, double → 0.0
• char → '\u0000'
• boolean → false
• Any reference type → null

class Example {
    int number;       // default 0
    boolean flag;     // default false
    String text;      // default null
}

Local variables must be initialized before use or the code will not compile.

Newer Language Features Related to Types (Recent Java Versions)

While the primitive data types themselves have not changed, newer Java versions added features that affect how types are used and inferred.

1. Local Variable Type Inference (var, Java 10+)

Java allows var for local variables, where the type is inferred by the compiler. Important: the variable still has a static type; var is not dynamic typing.

var n = 10;          // inferred as int
var text = "Hello";  // inferred as String

// Still type-safe:
text = 20;           // compile-time error

2. Text Blocks for Strings (Java 13+)

Multi-line string literals using """ are still String type.

String json = """
{
  "name": "Alice",
  "age": 30
}
""";

3. Records (Java 16+)

Records provide a concise syntax for classes that are mainly data carriers.

record User(String name, int age) {}

User u = new User("Bob", 25);
String name = u.name();
int age = u.age();

4. Pattern Matching for instanceof (Java 16+)

Makes type checking and casting more concise.

Object obj = "Hello";
if (obj instanceof String s) {
    System.out.println(s.toUpperCase());
}

Common Exceptions Related to Data Types

• NullPointerException
  • Occurs when accessing a member or method on a null reference.

  String s = null;
  int len = s.length(); // NullPointerException

• ClassCastException
  • Occurs when an invalid type cast is performed on a reference.

  Object obj = Integer.valueOf(10);
  String s = (String) obj; // ClassCastException

• NumberFormatException
  • Occurs when converting a string to a numeric type fails.

  int n = Integer.parseInt("abc"); // NumberFormatException

• ArrayIndexOutOfBoundsException
  • Occurs when accessing an array index outside its bounds.

  int[] arr = {1, 2, 3};
  int x = arr[3]; // ArrayIndexOutOfBoundsException, valid indexes: 0..2

• ArithmeticException
  • Commonly occurs on integer division by zero.

  int a = 10;
  int b = 0;
  int c = a / b; // ArithmeticException: / by zero

Most Commonly Mistaken Concepts About Java Data Types

1. == vs equals()

• == compares references for objects (same memory location).
• equals() compares contents (if properly overridden).

String a = new String("Java");
String b = new String("Java");

System.out.println(a == b);        // false (different objects)
System.out.println(a.equals(b));   // true (same content)

2. Treating String as a Primitive

• String is not primitive; it is a class in java.lang.
• It behaves like a value in many scenarios, but it's still a reference.

3. Floating-Point Precision

• float and double are imprecise for some decimal values.
• Use BigDecimal for precise financial calculations.

double x = 0.1 + 0.2;
System.out.println(x); // may print 0.30000000000000004

4. Integer Division

• Dividing two integers performs integer division, discarding the fractional part.

int a = 5;
int b = 2;
int c = a / b;    // 2, not 2.5
double d = a / b; // 2.0, still integer division first

double correct = a / 2.0; // 2.5

5. Overflow and Underflow

• Primitive integer types (byte, short, int, long) overflow silently.

int max = Integer.MAX_VALUE; // 2147483647
int overflow = max + 1;      // -2147483648 (wraps around)

6. Confusing char with String

• char uses single quotes, String uses double quotes.
• char is a single 16-bit code unit, String is a sequence of characters.

char c = 'A';
String s = "A";

7. Assuming Arrays Grow Dynamically

• Arrays in Java have fixed length.
• To have dynamic growth, use collections like ArrayList.

int[] arr = new int[3];
// arr.length is always 3

List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
// list size can grow dynamically

8. Misusing Autoboxing and Caching

Wrapper classes cache some values (e.g., Integer from -128 to 127), which can lead to confusion when using ==.

Integer x = 127;
Integer y = 127;
System.out.println(x == y); // true (cached)

Integer m = 128;
Integer n = 128;
System.out.println(m == n); // false (different objects)
System.out.println(m.equals(n)); // true

9. Thinking var Means Dynamic Typing

• var does not mean the type can change.
• Type is inferred once at compile time and cannot change later.

Best Practices When Working with Data Types in Java

• Prefer int and double for general numeric work unless you have a specific reason to use others.
• Use long for large ranges (e.g., IDs, timestamps).
• Use BigInteger and BigDecimal for very large numbers or precise decimal arithmetic.
• Avoid excessive autoboxing in performance-critical code (e.g., in loops) to reduce object creation.
• Always check for null before unboxing wrapper types.
• Use equals() to compare object content (especially String), not ==.
• Be cautious with floating-point equality comparisons; use tolerances (epsilon) instead.
• Initialize local variables before use; do not rely on defaults.

Summary

Java data types are divided into primitive and reference types. Understanding their sizes, ranges, default values, conversions, and common pitfalls is essential for writing correct and efficient Java programs. While newer Java versions have introduced features like var, records, text blocks, and pattern matching, the core set of primitive types remains unchanged.

In Java, a variable is a named storage location in memory that holds a value. Java is statically typed, which means every variable has a declared type known at compile time.

Key Characteristics of Java Variables

• Each variable has a name, a type, and a value.
• Type determines what operations can be performed on the variable.
• Variables have scope (where they are visible) and lifetime (how long they exist).
• Java variables must be declared before use.

Basic Syntax

<type> <variableName> [= initialValue] ;

int count;
int age = 25;
String name = "Alice";

• Declaration: tells the compiler the type and name of the variable.
• Initialization: gives the variable an initial value.

Classification of Variables

By Data Type

• Primitive type variables – hold primitive values like int, double, boolean, etc.
• Reference type variables – hold references (addresses) to objects (e.g., String, arrays, custom classes).

By Scope / Where They Are Declared

• Local variables – declared inside methods, constructors, or blocks.
• Parameter variables – declared in method or constructor parameter lists.
• Instance variables (fields) – non-static fields declared in a class.
• Static variables (class variables) – fields declared with static.

Local Variables

Local variables are declared inside methods, constructors, or blocks and exist only within that scope.

void doSomething() {
    int x = 10;           // local variable
    if (x > 5) {
        int y = 20;       // local to the if-block
        System.out.println(y);
    }
    // y is not visible here
}

• No default values – must be initialized before use (otherwise compile-time error).
• Stored on the stack (conceptually) and destroyed when the method finishes.

Parameter Variables

Parameters are variables declared in a method or constructor’s parameter list. They receive values when the method is called.

void greet(String name, int times) {  // name and times are parameters
    for (int i = 0; i < times; i++) {
        System.out.println("Hello " + name);
    }
}

• Parameters are treated like local variables inside the method.
• They must have a type and a name.

Instance Variables (Fields)

Instance variables belong to an object (instance of the class).

class Person {
    String name;    // instance variable
    int age;        // instance variable

    void introduce() {
        System.out.println("My name is " + name);
    }
}

• Each object has its own copy of instance variables.
• Default values apply if not initialized explicitly (e.g., 0, false, null).
• Accessible via this.name, though this is usually optional.

Static Variables (Class Variables)

Static variables belong to the class itself, not to any particular object.

class Counter {
    static int count = 0; // static variable

    Counter() {
        count++;
    }
}

Counter c1 = new Counter();
Counter c2 = new Counter();
System.out.println(Counter.count); // 2

• Shared among all instances of the class.
• Accessed via class name: ClassName.variableName.
• Useful for constants and shared state (e.g., caches, counters).

Variable Initialization

1. Explicit Initialization

int x = 10;
String message = "Hello";

2. Default Initialization (Fields Only)

class Example {
    int n;         // default 0
    boolean flag;  // default false
    String text;   // default null
}

Local variables do not get default values and must be initialized before use.

3. Multiple Declarations

int a, b, c;
int x = 1, y = 2, z = 3;

For clarity, it is often better to declare one variable per line.

Final Variables (Constants)

A final variable can be assigned only once.

final int MAX_SIZE = 100;
final String APP_NAME = "MyApp";

• After assignment, the value cannot be changed.
• For reference types, the reference cannot change, but the object it points to may be mutable.

final List<String> list = new ArrayList<>();
list.add("A");    // OK, modifying the object
// list = new ArrayList<>(); // Error: cannot assign a value to final variable

Blank Final Variables

Final variables that are declared but not initialized immediately, typically assigned in the constructor.

class User {
    final String id; // blank final

    User(String id) {
        this.id = id; // must be assigned here
    }
}

Effectively Final Variables

A variable is effectively final if it is assigned only once, even without the final keyword. This is important for anonymous classes and lambdas.

void test() {
    int base = 10; // effectively final
    Runnable r = () -> System.out.println(base); // allowed
}

Local Variable Type Inference (var, Java 10+)

Java supports local variable type inference using var for local variables with initializers. The type is inferred by the compiler.

var number = 10;           // inferred as int
var text = "Hello";        // inferred as String
var list = new ArrayList<String>(); // inferred as ArrayList<String>

• var can only be used for local variables, for-each variables, and traditional for-loop indices.
• Cannot be used for fields, method parameters, or return types.
• Variable still has a single, static type – Java is not dynamically typed.
• Requires an initializer (you cannot write just var x;).

// Invalid uses:
var x;                    // Error: cannot use 'var' without initializer
var nothing = null;       // Error: cannot infer type from null alone

Naming Variables

• Use camelCase for variables and methods: totalAmount, userName.
• Use UPPER_SNAKE_CASE for static final constants: MAX_VALUE.
• Names must start with a letter, $, or _, and can contain digits after that.
• Avoid using $ and _ unless you have a special reason.
• Must not be a Java keyword (like int, class, for).

Scope and Lifetime

1. Block Scope

if (condition) {
    int a = 10;   // a is visible only inside this block
}
// a is not visible here

2. Method Scope

Local variables declared in a method are not visible outside that method.

3. Class Scope

Instance and static variables are visible to all methods of the class (subject to access modifiers).

Shadowing

A local or parameter variable can shadow a field with the same name. Use this to refer to the field.

class Example {
    int value;

    Example(int value) {
        this.value = value; // 'this.value' is the field, 'value' is parameter
    }
}

Variables and Memory

• Local variables and parameters live on the stack (conceptually) and are destroyed when the method returns.
• Instance and static variables are part of objects or class metadata stored on the heap.
• Reference variables hold an address pointing to an object on the heap.

Common Errors and Exceptions Related to Variables

Compile-Time Errors (Not Exceptions)

• "variable might not have been initialized" – using a local variable before assigning a value.
• "cannot find symbol" – using a variable name that is out of scope or not declared.
• "variable x is already defined in method" – declaring two variables with the same name in the same scope.

void example() {
    int x;
    // System.out.println(x); // Error: variable x might not have been initialized
}

Runtime Exceptions (Caused by Incorrect Use of Variables)

• NullPointerException – using a reference variable that is null.
• ArrayIndexOutOfBoundsException – using an array index outside the valid range.
• ClassCastException – incorrect casting of objects referenced by variables.

String s = null;
s.length(); // NullPointerException

int[] arr = new int[3];
arr[3] = 10; // ArrayIndexOutOfBoundsException

Most Commonly Mistaken Concepts About Variables in Java

1. Java Is Pass-by-Value (Always)

Many people think objects are passed by reference. In reality, Java passes the value of the reference (a copy of the reference).

void modify(int x) {
    x = 10;
}

void modify(StringBuilder sb) {
    sb.append(" world");
}

int a = 5;
modify(a);
System.out.println(a); // still 5

StringBuilder sb = new StringBuilder("Hello");
modify(sb);
System.out.println(sb); // Hello world

Changing the reference variable itself does not affect the caller, but modifying the object it points to does.

2. Confusing = with ==

• = is assignment.
• == is comparison.

3. Using == for Strings and Objects

== compares whether two reference variables point to the same object, not whether their values are equal. Use equals() for value equality.

String a = new String("Java");
String b = new String("Java");

System.out.println(a == b);      // false (different objects)
System.out.println(a.equals(b)); // true (same content)

4. Assuming Local Variables Have Default Values

Local variables must be initialized before use; there are no automatic defaults.

5. Misunderstanding static vs Instance Variables

• Static variables are shared across all instances.
• Instance variables are unique to each object.

Accidentally using static variables for per-object state leads to bugs.

6. Thinking var Makes Java Dynamically Typed

• With var, the compiler still decides a single, fixed type at compile time.
• You cannot assign a different type later.

var x = 10;  // int
// x = "Hello"; // Error: incompatible types

7. Variable Shadowing Confusion

Forgetting that a local or parameter variable shadows a field can lead to unexpected behavior.

class Demo {
    int value = 5;

    void setValue(int value) {
        value = value;        // assigns parameter to itself, field unchanged
    }
}

Correct version uses this:

void setValue(int value) {
    this.value = value;       // assigns parameter to field
}

Newer Language Features Related to Variables

1. var (Java 10+)

• Reduces verbosity in local variable declarations.
• Particularly useful with generics and complex types.

2. Pattern Variables in instanceof (Java 16+)

Pattern matching introduces pattern variables that combine type tests and casts.

Object obj = "Hello";
if (obj instanceof String s) { // s is a pattern variable
    System.out.println(s.toUpperCase());
}

3. Pattern Matching for switch (Newer Java Versions)

Enhanced switch expressions and pattern matching introduce variables bound in case labels, making code more expressive while still being statically typed.

Best Practices for Variables in Java

• Use meaningful names that clearly describe the purpose of the variable.
• Keep variable scope as small as possible to reduce bugs and improve readability.
• Prefer immutable variables where possible (final and effectively final).
• Avoid using magic numbers; use constants (static final) instead.
• Initialize variables close to where they are used.
• Be careful with static variables; overuse can lead to tight coupling and hidden dependencies.
• Use var when it improves readability, not just to save typing.

Summary

Variables in Java are fundamental building blocks that represent named storage locations associated with types. Understanding the different kinds of variables (local, parameter, instance, static), their scope, lifetime, initialization rules, and how they interact with newer language features like var and pattern matching is essential to writing clean, correct, and maintainable Java code. Many common bugs arise from misunderstandings about variable scope, initialization, and object references, so paying attention to these details is critical.

Type Casting in Java

Type casting in Java means converting a value of one data type into another compatible data type. There are two main categories:

• Primitive casting (between int, double, etc.)
• Reference casting (between classes in the same inheritance hierarchy)

1. Primitive Type Casting

1.1 Widening Casting (Automatic / Implicit)

Small type → bigger type. This is safe and done automatically by Java.

Order: byte → short → int → long → float → double

int i = 10;
double d = i;   // int to double (automatic)
long  l = i;    // int to long   (automatic)

1.2 Narrowing Casting (Manual / Explicit)

Bigger type → smaller type. This can lose data, so you must cast explicitly using (targetType).

double d = 9.7;
int i = (int) d;   // i = 9, fractional part is lost

long  big = 130L;
byte  b   = (byte) big; // overflow, b = -126

Syntax:

<targetType> variable = (<targetType>) value;

1.3 Common Examples

float f = 3.14f;
double d = f;           // widening, OK

double x = 3.99;
int    y = (int) x;     // narrowing, need (int)

short s = 100;
byte  bb = (byte) s;    // narrowing, need (byte)

1.4 Casting vs Parsing (for Strings)

You cannot cast a String directly to a number. Use parsing methods:

String s = "123";
// int n = (int) s;       // ❌ compile error

int n = Integer.parseInt(s);   // ✔ correct
double d = Double.parseDouble("3.14");

2. Reference Type Casting (Objects)

For reference types, you can cast only within the same inheritance hierarchy. There are two concepts:

• Upcasting – child → parent (implicit)
• Downcasting – parent → child (explicit, may fail at runtime)

2.1 Upcasting (Safe, Automatic)

class Animal {
    void speak() { System.out.println("Animal"); }
}

class Dog extends Animal {
    void bark() { System.out.println("Woof"); }
}

Dog d = new Dog();
Animal a = d;    // upcasting: Dog → Animal (automatic)

Upcasting is always safe because a Dog is an Animal.

2.2 Downcasting (Manual, Can Throw Exception)

Downcasting means casting a parent reference back to a child type. You must do it explicitly, and it can throw ClassCastException if the actual object is not of that type.

Animal a = new Dog();      // upcast
Dog d = (Dog) a;           // downcast, OK at runtime

Animal a2 = new Animal();
// Dog d2 = (Dog) a2;      // compiles, but at runtime: ClassCastException

2.3 Use instanceof Before Downcasting

To avoid ClassCastException, you should check with instanceof:

Animal a = getAnimal();  // returns some Animal

if (a instanceof Dog) {
    Dog d = (Dog) a;     // safe downcast
    d.bark();
} else {
    System.out.println("Not a Dog");
}

2.4 Pattern Matching instanceof (Newer Java)

Modern Java lets you combine instanceof and cast:

if (a instanceof Dog d) {
    d.bark();   // d is already a Dog
}

3. Important Notes About Casting

• Casting does not change the variable’s declared type, only the value in that expression.

double d = 5.9;
int x = (int) d;  // cast only here
// d is still double, only x is int

• You can only cast between compatible types (same hierarchy for objects, numeric types for primitives).
• Casting does not create a new object for reference types; it just treats the same object as another type.

4. Quick Cheat Sheet

• Primitive widening – automatic: int i = 10; double d = i;
• Primitive narrowing – need cast: double d = 9.8; int i = (int) d;
• Upcasting (child → parent) – automatic: Animal a = new Dog();
• Downcasting (parent → child) – explicit: Dog d = (Dog) a;
• Strings to numbers – use parseInt, parseDouble, etc., not casting.
• Use instanceof to check before downcasting to avoid ClassCastException.

Control flow is the order in which individual statements, instructions, or function calls are executed or evaluated in a program. By default, code runs from top to bottom, but control-flow constructs (like if, loops, and switch) let you change that order.

Table of Contents

1. Core Concepts
2. If Statements
3. Loops
4. Switch Statements
5. Exceptions (Error Handling)
6. What Is “Import All”?

// Pseudo-code example of basic control flow

read age

if (age >= 18) {
    print("You are an adult");
} else {
    print("You are not an adult");
}

for (i = 0; i < 3; i = i + 1) {
    print("Loop iteration: " + i);
}

if (condition) {
    // code that runs when condition is true
} else {
    // code that runs when condition is false
}

int score = 85;

if (score >= 90) {
    printf("Grade: A\n");
} else if (score >= 80) {
    printf("Grade: B\n");
} else if (score >= 70) {
    printf("Grade: C\n");
} else {
    printf("Grade: F\n");
}

// C / Java / JavaScript style for loop
for (int i = 0; i < 5; i++) {
    printf("i = %d\n", i);
}

int count = 0;

while (count < 3) {
    printf("count = %d\n", count);
    count++;
}

int x = 0;

do {
    printf("x = %d\n", x);
    x++;
} while (x < 3);

for (int i = 0; i < 10; i++) {
    if (i == 3) {
        continue;   // skip when i is 3
    }
    if (i == 8) {
        break;      // stop the loop entirely
    }
    printf("i = %d\n", i);
}

int day = 3;

switch (day) {
    case 1:
        printf("Monday\n");
        break;
    case 2:
        printf("Tuesday\n");
        break;
    case 3:
        printf("Wednesday\n");
        break;
    default:
        printf("Unknown day\n");
        break;
}

try {
    int result = 10 / 0; // this will cause an error (division by zero)
    System.out.println("Result: " + result);
} catch (ArithmeticException e) {
    System.out.println("Error: " + e.getMessage());
} finally {
    System.out.println("This always runs (cleanup, closing files, etc.)");
}

# Import everything from the math module into the current namespace
from math import *

print(sqrt(16))  # sqrt is available directly

// Import everything from 'utils.js' as an object called utils
import * as utils from './utils.js';

console.log(utils.add(2, 3));

// Import all classes from java.util package
import java.util.*;

public class Example {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
    }
}