1. Lesson: Language Basics
  2. Variables
    1. Naming
    2. Primitive Data Types
    3. Default Values
    4. Literals
    5. Using Underscore Characters in Numeric Literals
    6. Arrays
    7. Declaring a Variable to Refer to an Array
    8. Creating, Initializing, and Accessing an Array
    9. Copying Arrays
    10. Summary of Variables
    11. Questions and Exercises: Variables
  3. Expressions, Statements, and Blocks
    1. Expressions
    2. Statements
    3. Blocks
    4. Questions and Exercises: Expressions, Statements, and Blocks
  4. Control Flow Statements
    1. The if-then Statement
    2. The if-then-else Statement
    3. The switch Statement
    4. Using Strings in switch Statements
    5. The while and do-while Statements
    6. The for Statement
    7. The break Statement
    8. The continue Statement
    9. The return Statement
    10. Summary of Control Flow Statements
    11. Questions and Exercises: Control Flow Statements
  5. Lesson: Classes and Objects
    1. Classes
    2. Declaring Classes
    3. Declaring Member Variables
    4. Access Modifiers
    5. Types
    6. Variable Names
    7. Defining Methods
    8. Naming a Method
    9. Overloading Methods
    10. Providing Constructors for Your Classes
    11. Passing Information to a Method or a Constructor
    12. Parameter Types
    13. Arbitrary Number of Arguments
    14. Parameter Names
    15. Passing Primitive Data Type Arguments
    16. Passing Reference Data Type Arguments
    17. Objects
    18. Creating Objects
    19. Declaring a Variable to Refer to an Object
    20. Instantiating a Class
    21. Initializing an Object
    22. Using Objects
    23. Referencing an Object's Fields
    24. Calling an Object's Methods
    25. The Garbage Collector
    26. More on Classes
    27. Returning a Value from a Method
    28. Returning a Class or Interface
    29. Using the this Keyword
    30. Using this with a Field
    31. Using this with a Constructor
    32. Controlling Access to Members of a Class
    33. Understanding Instance and Class Members
    34. Class Variables
    35. Class Methods
    36. Constants
    37. The Bicycle Class
    38. Initializing Fields
    39. Static Initialization Blocks
    40. Initializing Instance Members
    41. Summary of Creating and Using Classes and Objects
    42. Questions and Exercises: Classes
    43. Questions and Exercises: Objects
  6. Nested Classes
    1. Why Use Nested Classes?
    2. Static Nested Classes
    3. Inner Classes
    4. Inner Class Example
    5. Local and Anonymous Inner Classes
    6. Modifiers
    7. Summary of Nested Classes
    8. Questions and Exercises: Nested Classes
  7. Enum Types
    1. Questions and Exercises: Enum Types
  8. Annotations
    1. Documentation
    2. Annotations Used by the Compiler
    3. Annotation Processing
    4. Questions and Exercises: Annotations
  9. Lesson: Interfaces and Inheritance
    1. Interfaces
    2. Interfaces in Java
    3. Interfaces as APIs
    4. Interfaces and Multiple Inheritance
    5. Defining an Interface
    6. The Interface Body
    7. Implementing an Interface
    8. A Sample Interface, Relatable
    9. Implementing the Relatable Interface

4.6.The for Statement #

The for statement provides a compact way to iterate over a range of values. Programmers often refer to it as the “for loop” because of the way in which it repeatedly loops until a particular condition is satisfied. The general form of the for statement can be expressed as follows:
for (initialization; termination; increment) {
When using this version of the for statement, keep in mind that:
• The initialization expression initializes the loop; it’s executed once, as the loop begins.
• When the termination expression evaluates to false, the loop terminates.
• The increment expression is invoked after each iteration through the loop; it is perfectly acceptable for this expression to increment or decrement a value.
The following program, ForDemo, uses the general form of the for statement to print the numbers 1 through 10 to standard output:

class ForDemo {
     public static void main(String[] args){
          for(int i=1; i<11; i++){
               System.out.println("Count is: " + i);

The output of this program is:
Count is: 1
Count is: 2
Count is: 3
Count is: 4
Count is: 5
Count is: 6
Count is: 7
Count is: 8
Count is: 9
Count is: 10
Notice how the code declares a variable within the initialization expression. The scope of this variable extends from its declaration to the end of the block governed by the for statement, so it can be used in the termination and increment expressions as well. If the variable that controls a for statement is not needed outside of the loop, it’s best to declare the variable in the initialization expression. The names i, j, and k are often used to control for loops; declaring them within the initialization expression limits their life span and reduces errors.
The three expressions of the for loop are optional; an infinite loop can be created as follows:
for ( ; ; ) { // infinite loop

// your code goes here
The for statement also has another form designed for iteration through Collections and arrays This form is sometimes referred to as the enhanced for statement, and can be used to make your loops more compact and easy to read. To demonstrate, consider the following array, which holds the numbers 1 through 10:
int[] numbers = {1,2,3,4,5,6,7,8,9,10};
The following program, EnhancedForDemo, uses the enhanced for to loop through the array:

class EnhancedForDemo {
     public static void main(String[] args){
          int[] numbers = {1,2,3,4,5,6,7,8,9,10};
          for (int item : numbers) {
            System.out.println("Count is: " + item);

In this example, the variable item holds the current value from the numbers array. The output from this program is the same as before:
Count is: 1
Count is: 2
Count is: 3
Count is: 4
Count is: 5
Count is: 6
Count is: 7
Count is: 8
Count is: 9
Count is: 10
We recommend using this form of the for statement instead of the general form whenever possible.

Suggest Edit