带编译时间常数的While循环

While循环是一个控制流语句，它允许根据给定的布尔条件重复执行代码。 while循环可被视为重复的if语句。它通常用于事先有确切迭代次数的情况。下面的图像说明了while循环：

句法：

while(test_expression)
{
   // statements 
   update_expression;
}

程序1：以下是实现基本while循环的程序：

Java

// Java program to illustrate the
// while loop
  
class GFG {
  
    // Driver Code
    public static void main(String args[])
    {
        // Initialization expression
        int i = 1;
  
        // Test expression
        while (i < 6) {
            System.out.println("Hello World");
  
            // Update the expression
            i++;
        }
    }
}

输出：

Hello World
Hello World
Hello World
Hello World
Hello World

带有布尔值的While循环

程序1：以下是另一个while循环的示例，其中在test_expression部分中使用了布尔变量：

Java

// Java program to demonstrate while loop
import java.io.*;
  
class GFG {
    // Driver Code
    public static void main(String[] args)
    {
        boolean flag = false;
  
        while (flag) {
            System.out.println(
                "While Loop Executed");
        }
  
        System.out.println("Done!");
    }
}

输出：

Done!

说明：上面的代码可以正常工作，因为该标志不是编译时常量。该标志的值为false，因此不执行while循环。

程序2：下面是while循环的示例，其中在test_expression部分中使用了恒定的布尔值，而不是像上面的示例中那样使用布尔变量。

Java

// Java program to demonstrate the
// above statement
  
import java.io.*;
class GFG {
    // Driver Code
    public static void main(String[] args)
    {
        while (false) {
            System.out.println(
                "While Loop Executed");
        }
        System.out.println("Done!");
    }
}

输出：

说明：由于无法访问while循环内的代码，因此上述代码无法编译。

程序3：下面的程序演示test_expression为“ true”时的情况：

Java

// Java program to demonstrate the
// above statement
import java.io.*;
  
class GFG {
  
    // Driver Code
    public static void main(String[] args)
    {
        while (true) {
            System.out.println(
                "While Loop Executed");
        }
        System.out.println("Done!");
    }
}

输出：

说明：在上面的代码中，while循环将被成功编译，但最终将陷入无限循环，因此while循环之后的代码不可访问。因此，它也将最终导致编译错误。

程序4：以下是上述程序的另一个版本，在while循环中带有break语句：

Java

// Java program to demonstrate the
// above approach
import java.io.*;
  
class GFG {
  
    // Driver Code
    public static void main(String[] args)
    {
        while (true) {
            System.out.println(
                "Inside Loop");
            break;
        }
        System.out.println("Done!");
    }
}

输出：

Inside Loop
Done!

说明：在上面的程序中，如果while循环包含break语句，则编译不会失败，因为在某些情况下，循环后的代码可以访问。在这里，我们退出了while循环，将执行print语句。

编译时常量：

编译时常数是在编译时其各个值已知的常数。基本数据类型和字符串的最终变量可以是编译时常量。必须使用声明对其进行初始化。下面是一个编译时常量的示例：

final int i = 100;
final String str = "Hello";

以下不是编译时常量：

final int j;
j = 10;
final Integer k = 20;

程序1：假设在while循环内使用最终变量作为条件变量。下面是说明相同内容的程序：

Java

// Java program to demonstrate the
// while loop with compile-time
// constant
import java.io.*;
  
class GFG {
  
    // Driver Code
    public static void main(String[] args)
    {
        final boolean flag = false;
  
        while (flag) {
            System.out.println(
                "Inside Loop");
        }
        System.out.println("Done!");
    }
}

输出

说明：由于标志是最终变量，因此它是编译时常量。由于不能更改标志的值，因此while循环内的代码不可访问。这就是为什么它无法编译的原因。

程序2：如果最终变量在声明时未初始化，则它不是编译时常量。下面是说明相同内容的程序：

Java

// Java program to demonstrate the
// above statement
import java.io.*;
  
class GFG {
  
    // Driver Code
    public static void main(String[] args)
    {
        final boolean flag;
        flag = false;
  
        while (flag) {
            System.out.println("Inside Loop");
        }
        System.out.println("Done!");
    }
}

输出：

Done!

说明：在上面的程序中，将没有任何编译错误，因为声明该标志时未对其进行初始化。它在单独的行上初始化。因此，在这种情况下，flag不是编译时常量，因此不会出现任何编译错误。

注意：同样，如果final标志变量的值为true且在声明它时进行了初始化，则while块之后的代码将无法编译。但是，如果最终布尔标志的值在单独的行中用值“ true”初始化，则不会有任何编译错误。这意味着，如果在while循环内使用的条件变量是编译时常量，则取决于上下文，代码可能会编译也可能不会编译。未在同一行上初始化的最终变量不是编译时常量。因此，在这种情况下没有问题。

程序3：

Java

// Java program to demonstrate the while
// loop with compiled time constant
import java.io.*;
  
class GFG {
  
    // Driver Code
    public static void main(String[] args)
    {
        boolean anotherFlag = false;
        final boolean flag = anotherFlag;
  
        // While loop
        while (flag) {
            System.out.println("Inside Loop");
        }
        System.out.println("Done!");
    }
}

输出：

Done!

说明：在上面的代码中，不会出现任何编译错误，尽管该标志是最终变量并且在同一行上初始化，“ anotherFlag”不是最终变量，这就是为什么该标志不是编译时的原因常量，因此编译没有问题。

程序4：如果“ anotherFlag”是最终变量，则结果将有所不同。下面是说明相同内容的程序：

Java

// Java program to demonstrate the
// above statement
import java.io.*;
  
class GFG {
  
    // Driver Code
    public static void main(String[] args)
    {
        final boolean anotherFlag = false;
        final boolean flag = anotherFlag;
  
        while (flag) {
            System.out.println("Inside Loop");
        }
        System.out.println("Done!");
    }
}

输出

说明：在上面的代码中，该标志是一个编译时常量。因此，while循环内的代码不可访问，从而导致编译错误。