Effectively Final Variable in Java with Examples - GeeksforGeeks

17 Aug, 2021
A final variable is a variable that is declared with a keyword known as ‘final‘.
Example:
final int number;
number = 77;
The Effectively Final variable is a local variable that follows the following properties are listed below as follows:
Not defined as final
Assigned to ONLY once.
Any local variable or parameter that’s assigned a worth just one occasion right now(or updated only once). It may not remain effectively final throughout the program. so this suggests that effectively final variable might lose its effectively final property after immediately the time it gets assigned/updated a minimum of another assignment. Additionally, an effectively final variable may be a variable whose value isn’t changed, but it isn’t declared with the ultimate keyword.
int number;
number = 7;
Note: Final and Effective Final are similar but just that effective Final variables are not declared with Keyword final.
Example:
Java
// Java Program to Illustrate Effective Final Keyword  // Importing input output classesimport java.io.*;  // Main classclass GFG {      // Main friver method    public static void main(String[] args)    {          // Calling the method where custom operands        // are passed as parameters        calculateValue(124, 53);    }      // Method 2    // To calculate the value by passing operands as    // parameters    public static void calculateValue(int operand1,                                      int operand2)    {          // Operands and remainder are effectively final here        int rem = 0;          // Remainder lost its effectively final property        // here because it gets its second assignment        rem = operand1 % 5;          // Operands are still effectively final here          // Class 2        class operators {              // Method 1            void setNum()            {                  // operand1 lost its effectively final                // property here because it gets its second                // assignment                operand1 = operand2 % 2;            }              // Method 2            int add()            {                  // It does not compile because rem is not                // effectively final                return rem + operand2;            }              // Method 3            int multiply()            {                  // It does not compile because both                // remainder and operand1 are not                // effectively final                return rem * operand1;            }        }    }}
Output: An error will be thrown as expected which can be perceived from the terminal output as shown below:
Lambda expression capture values
When a lambda expression uses an assigned local variable from its enclosing space there’s a crucial restriction. A lambda expression may only use a local variable whose value doesn’t change. That restriction is referred to as “variable capture” which is described as; lambda expression capture values, not variables.
The local variables that a lambda expression may use are referred to as “effectively final”.
An effectively final variable is one whose value doesn’t change after it’s first assigned. There is no need to explicitly declare such a variable as final, although doing so would not be an error.
Implementation: Consider we do have an area variable let it be ‘i’ which is initialized with the worth say be ‘7’, with within the lambda expression we try to vary that value by assigning a new value to i. This will end in compiler error – “Local variable i defined in an enclosing scope must be final or effectively final”.
Java
// Java Program to Illustrate Effective Final Keyword  // Importing input output classesimport java.io.*;  // Defining an interface@FunctionalInterface  interface IFuncInt {      // Method 1    int func(int num1, int num2);    public String toString();}  // Main driver methodpublic class GFG {      // Main driver method    public static void main(String[] args)    {          int i = 7;          IFuncInt funcInt = (num1, num2) ->        {              // It produces an error due to effectively final            // variable not declared            i = num1 + num2;            return i;        };    }}
Output:
java-basics
Picked
Java
Java
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Stream In Java
Constructors in Java
Different ways of Reading a text file in Java
Exceptions in Java
Functional Interfaces in Java
Generics in Java
Comparator Interface in Java with Examples
Introduction to Java
HashMap get() Method in Java
Strings in Java