Java中的静态和非静态空白最终变量-yiteyi-C++库

变量为我们提供了程序可以操作的命名存储。一个类中有两种类型的数据变量： 实例变量： 实例变量在类中声明，但在方法、构造函数或任何块之外。为堆中的对象分配空间时，会为每个实例变量值创建一个插槽。实例变量在使用关键字“new”创建对象时创建，在销毁对象时销毁。它们是对象的属性，因此只能使用对象访问它们。

null

静态变量： 类变量也称为静态变量，在类中用static关键字声明，但在方法、构造函数或块之外。每个类的每个类变量只有一个副本，而不管从中创建了多少个对象。它们是类的属性，而不是对象的属性，因此可以直接使用类名和对象。

                     // Java code to illustrate use of instance and static variables                   
                     public                               class                               Emp {                   
                                         String name;                   
                                         int                               salary;                   
                                         static                               String company;                   
                                         public                               void                               printDetails()                   
                                         {                   
                                         System.out.println(                               "Name: "                               + name);                   
                                         System.out.println(                               "Company: "                               + company);                   
                                         System.out.println(                               "Salary: "                               + salary);                   
                                         }                   
                                         public                               static                               void                               main(String s[])                   
                                         {                   
                                         Emp.company =                               "GeeksForGeeks"                               ;                   
                                         Emp g =                               new                               Emp();                   
                                         g.name =                               "Shubham"                               ;                   
                                         g.salary =                               100000                               ;                   
                             
                                         Emp sp =                               new                               Emp();                   
                                         sp.name =                               "Chirag"                               ;                   
                                         sp.salary =                               200000                               ;                   
                             
                                         g.printDetails();                   
                                         sp.printDetails();                   
                             
                                         g.company =                               "Google"                               ;                   
                                         g.salary =                               200000                               ;                   
                                         System.out.println(                               "After change"                               );                   
                                         g.printDetails();                   
                                         sp.printDetails();                   
                                         }                   
                     }                   

输出：

Name: Shubham
Company: GeeksForGeeks
Salary: 100000
Name: Chirag
Company: GeeksForGeeks
Salary: 200000

After change

Name: Shubham
Company: Google
Salary: 200000
Name: Chirag
Company: Google
Salary: 200000

在上面的示例中，通过更改公司名称，它将反映在所有其他对象中，因为它是一个静态变量。但是改变g的薪水并不改变s的薪水，因为薪水是一个实例变量。

空白最终变量： A. 最终变量已声明但未赋值的变量称为空最终变量。它只能在构造函数中初始化。如果未初始化它，则会引发编译错误，因为它应该在程序中的某个位置被赋予一个值，并且也只能从构造函数中获得该值。

静态空白最终变量： 它是一个声明为静态的空白最终变量。也就是说，已声明但未给定值或未初始化的最终静态变量称为静态空白最终变量。它只能通过静态块初始化。下面是一个示例，演示了空白最终变量的初始化-

                     // Java program to illustrate initialization                   
                     // of blank final variables                   
                     public                               class                               GFG {                   
                                         private                               static                               final                               int                               a;                   
                                         private                               final                               int                               b;                   
                                         static                   
                                         {                   
                                         a =                               1                               ;                   
                                         }                   
                                         GFG(                               int                               c)                   
                                         {                   
                                         b = c;                   
                                         }                   
                                         public                               static                               void                               main(String s[])                   
                                         {                   
                                         GFG g1 =                               new                               GFG(                               10                               );                   
                                         GFG g2 =                               new                               GFG(                               20                               );                   
                                         System.out.println(GFG.a);                   
                                         System.out.println(g1.b);                   
                                         System.out.println(g1.b);                   
                                         }                   
                     }                   

输出：

1
10
10

在上面的示例中，b使用构造函数初始化，而a使用静态块。

预测以下程序的输出：

                     // Java program to illustrate                   
                     // static blank final variable                   
                     public                               class                               UserLogin {                   
                                         public                               static                               final                               long                               GUEST_ID = -                               1                               ;                   
                                         private                               static                               final                               long                               USER_ID;                   
                                         static                   
                                         {                   
                                         try                               {                   
                                         USER_ID = getID();                   
                                         }                   
                                         catch                               (IdNotFound e) {                   
                                         USER_ID = GUEST_ID;                   
                                         System.out.println(                               "Logging in as guest"                               );                   
                                         }                   
                                         }                   
                                         private                               static                               long                               getID()                   
                                         throws                               IdNotFound                   
                                         {                   
                                         throw                               new                               IdNotFound();                   
                                         }                   
                                         public                               static                               void                               main(String[] args)                   
                                         {                   
                                         System.out.println(                               "User ID: "                               + USER_ID);                   
                                         }                   
                     }                   
                     class                               IdNotFound                               extends                               Exception {                   
                                         IdNotFound() {}                   
                     }                   

输出：

prog.java:8: error: variable USER_ID might already have been assigned
USER_ID = GUEST_ID;
^
1 error

USER_ID字段是一个静态的空白final。很明显，只有在分配给USER_ID失败时，才能在try块中抛出异常，因此在catch块中分配给USER_ID是完全安全的。任何静态初始值设定项块的执行都会导致对用户_ID的一次赋值，这正是空白期末考试所需的。但是这个项目失败了，因为， 空白的最终字段只能在程序中明确未分配的点上分配。

在这里，编译器不确定它是否在try块中被赋值，所以程序不会编译。我们可以通过移除静态块并在声明时初始化用户ID来解决这个问题。

                     // Java program to illustrate                   
                     // static blank final variable                   
                     public                               class                               UserLogin {                   
                                         public                               static                               final                               long                               GUEST_ID = -                               1                               ;                   
                                         private                               static                               final                               long                               USER_ID = getUserIdOrGuest();                   
                                         private                               static                               long                               getUserIdOrGuest()                   
                                         {                   
                                         try                               {                   
                                         return                               getID();                   
                                         }                   
                                         catch                               (IdNotFound e) {                   
                                         System.out.println(                               "Logging in as guest"                               );                   
                                         return                               GUEST_ID;                   
                                         }                   
                                         }                   
                                         private                               static                               long                               getID()                   
                                         throws                               IdNotFound                   
                                         {                   
                                         throw                               new                               IdNotFound();                   
                                         }                   
                                         public                               static                               void                               main(String[] args)                   
                                         {                   
                                         System.out.println(                               "User ID: "                               + USER_ID);                   
                                         }                   
                     }                   
                     class                               IdNotFound                               extends                               Exception {                   
                                         IdNotFound() {}                   
                     }                   

输出：

Logging in as guest
User ID: -1

本文由 Shubham Juneja .如果你喜欢GeekSforgek，并想贡献自己的力量，你也可以使用贡献极客。组织或者把你的文章寄到contribute@geeksforgeeks.org.看到你的文章出现在Geeksforgeks主页上，并帮助其他极客。

如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写下评论。

文章版权归作者所有，未经允许请勿转载。

THE END

Java