Introduction to Statements

• What is a Statement in Java?
• A statement in Java is a complete unit of execution. It is an instruction that the Java compiler can execute. Statements are the building blocks of any Java program. Each statement performs a specific task, such as assigning a value to a variable, making decisions, or repeating an action.
• Types of Statements in Java:
• Declaration Statements: These statements declare variables and assign values to them.
  • Example: int age = 25;
• Expression Statements: These perform calculations or invoke methods.
  • Example: x = x + 1;
• Control Flow Statements: These dictate the flow of program execution based on conditions or loops.
  • Examples: if, while, for, switch
• Return Statements: These are used to exit from a method and optionally return a value.
  • Example: return result;

Types of Statements

• Expression Statements:
• These statements evaluate expressions and can change the state of the program.
  Example: Assignment and increment operations:
  int a = 5; // Declaration statement
a = a + 1; // Expression statement (assignment)
• Control Flow Statements:
• These are used to control the execution flow of a program. The most commonly used control flow statements include:
  • Conditional Statements (if, else, switch): Control the program flow based on conditions.
  • Looping Statements (for, while, do-while): Execute a block of code repeatedly.
  • Jump Statements (break, continue): Change the control flow of loops.
  Example of Conditional Statements:

    int age = 18;
    if (age >= 18) {
      System.out.println("Adult");
    } else {
      System.out.println("Minor");
    }

Example of Looping Statements:

    for (int i = 0; i < 5; i++) {
      System.out.println(i);
    }

Example of Switch Statement:

    int day = 3;
    switch (day) {
      case 1:
        System.out.println("Monday");
        break;
      case 2:
        System.out.println("Tuesday");
        break;
      default:
        System.out.println("Invalid day");
    }

Scope of Variables

• What is Scope?
• Scope refers to the region or area in a program where a variable can be accessed or modified. In Java, variables have different scopes depending on where they are declared.
• Types of Variable Scopes:
• Local Scope:
  • A variable is said to have local scope if it is declared inside a method, constructor, or block. It can only be accessed within that method or block.
    Example:

      public class Example {
        public void exampleMethod() {
          int localVar = 10; // Local variable
          System.out.println(localVar); // Can access localVar here
        }
      }

  The variable localVar cannot be accessed outside the method exampleMethod().

• Instance Scope:
  • A variable declared inside a class but outside any method is called an instance variable. It is accessible to all methods of the class and is tied to the instance of the class (each object of the class has its own copy).
    Example:

      class Car {
        String color; // Instance variable
        public void displayColor() {
          System.out.println("The car color is " + color);
        }
      }

• Class Scope:
  • A class variable is a variable declared using the static keyword. It is shared by all instances (objects) of the class and can be accessed using the class name.
    Example:

      class Car {
        static int numberOfWheels = 4; // Class variable
        public void displayWheels() {
          System.out.println("The car has " + numberOfWheels + " wheels.");
        }
      }

Block Scope

• What is Block Scope?
• Variables defined inside a block (such as a loop, if statement, or method) are only accessible within that block. A block is defined by curly braces {}.

Example of Block Scope:

  public class BlockScopeExample {
    public void testBlockScope() {
      if (true) {
        int blockVar = 10; // Local to this block
        System.out.println(blockVar);
      }
      // System.out.println(blockVar); // Error: blockVar is not accessible here
    }
  }

In this example, blockVar is only accessible inside the if block and cannot be accessed outside of it.

Lifetime of Variables

• Lifetime of Local Variables:
• Local variables exist only during the execution of the method or block in which they are defined. Once the method or block completes, the variable is destroyed, and its memory is reclaimed by the garbage collector.
• Lifetime of Instance Variables:
• Instance variables live as long as the object they belong to exists. When the object is no longer referenced, the instance variables are destroyed.
• Lifetime of Class Variables:
• Class variables exist for the duration of the program and are shared across all instances of the class. They are initialized when the class is loaded into memory.

The final Keyword in Java

• What is the final Keyword?
• In Java, the final keyword is used to define constants and prevent modification. When applied to variables, it means the variable cannot be reassigned once initialized.
• Use of final Keyword:
• Final Variables: A final variable can only be assigned once, either during declaration or in the constructor. It is commonly used for constants.
• Final Methods: A method declared as final cannot be overridden in subclasses.
• Final Classes: A class declared as final cannot be subclassed. Example:

    class MyClass {
      final int MAX_SIZE = 100; // Final variable
      public void printMaxSize() {
        System.out.println("Max Size: " + MAX_SIZE);
      }
    }

In this example, the value of MAX_SIZE cannot be changed once it is assigned.

Scope and Lifetime Example

• Complete Example:

  public class ScopeExample {
    int instanceVar = 20; // Instance variable
    public void method() {
      int localVar = 10; // Local variable
      System.out.println("Local Variable: " + localVar); // Accessible here
      System.out.println("Instance Variable: " + instanceVar); // Accessible here
    }
    public static void main(String[] args) {
      ScopeExample obj = new ScopeExample();
      obj.method();
    }
  }

In this example:
- instanceVar is accessible throughout the class and belongs to the object.
- localVar is accessible only within the method() and is destroyed when the method finishes.

Conclusion

• Summary of Key Points:
• Statements in Java are individual instructions that perform operations or control the flow of the program.
• Scope determines the region of a program where a variable is accessible. It is important to understand the different types of scopes (local, instance, class, and block scope) when managing variables in a program.
• The final keyword is used to define constants and prevent modification of variables, methods, or classes.
• The Importance of Understanding Statements and Scope:
• Understanding how statements and variables work in Java is fundamental to writing effective programs. Proper use of variable scope helps in preventing errors, ensuring code readability, and making programs efficient and maintainable.