Tuesday, March 3, 2020
How Static Fields in Java Work
How Static Fields in Java Work There can be times when its useful to have values that are shared across all instances of a particular class. Static fields and static constants enable this type of sharing by belonging to the class and not to the actual objects. The Static Modifier Normally fields and methods defined in a class can be used only when an object of that class type has been created. For example, consider a simple Item class that keeps track of goods in a store: public class Item {   private String itemName;   public Item(String itemName)   {     this.itemName itemName;   }   public String getItemName()   {     return itemName;   } } To be able to use the getItemName() method, we must first create an Item object, in this case, catFood: public class StaticExample {   public static void main(String[] args) {     Item catFood new Item(Whiskas);     System.out.println(catFood.getItemName());   } } However, if the static modifier is included in a field or method declaration, no instance of the class is required in order to use the field or method - they are associated with the class and not an individual object. If you look back at the above example, you will see that the static modifier is already being used in the main method declaration: public static void main(String[] args) { The main method is a static method that does not require an object to exist before it can be called. As main() is the starting point for any Java application, there are in fact no objects already in existence to call it. You could, if you felt like having a program that continually calls itself, do this: public class StaticExample {   public static void main(String[] args) {     String[] s {random,string};     StaticExample.main(s);     } } Not very useful, but notice how the main() method can be called without an instance of a StaticExample class. What Is a Static Field? Static fields are also known as class fields. They are simply fields that have the static modifier in their declarations. For example, lets go back to the Item class and add a static field: public class Item {   //static field uniqueId   private static int uniqueId 1;   private int itemId;   private String itemName;   public Item(String itemName)   {     this.itemName itemName;     itemId uniqueId;     uniqueId;   } } The fields itemId and itemName are normal non-static fields. When an instance of an Item class is created, these fields will have values that are held inside that object. If another Item object is created, it too will have itemId and itemName fields for storing values. The uniqueId static field, however, holds a value that will be the same across all Item objects. If there are 100 Item objects, there will be 100 instances of the itemId and itemName fields, but only one uniqueId static field. In the above example, uniqueId is used to give each Item object a unique number. This is easy to do if every Item object that is created takes the current value in the uniqueId static field and then increments it by one. The use of a static field means that each object does not need to know about the other objects to get a unique id. This could be useful if you wanted to know the order in which the Item objects were created. What Is a Static Constant? Static constants are exactly like static fields except that their values cannot be changed. In the field declaration, the final and static modifiers are both used. For example, perhaps the Item class should impose a restriction on the length of the itemName. We could create a static constant maxItemNameLength: public class Item {   private static int id 1;   public static final int maxItemNameLength 20;   private int itemId;   private String itemName;   public Item(String itemName)   {     if (itemName.length() maxItemNameLength)     {       this.itemName itemName.substring(0,20);     }     else     {       this.itemName itemName;     }     itemId id;     id;   } } As with static fields, static constants are associated with the class rather than an individual object: public class StaticExample {   public static void main(String[] args) {     Item catFood new Item(Whiskas);     System.out.println(catFood.getItemName());     System.out.println(Item.maxItemNameLength);     } } There are two important things to notice about the maxItemNameLength static constant: It is declared as a public field. Generally its a bad idea to make a field public in any class you design but in this case, it doesnt matter. The value of the constant cannot be changed.The static constant is used from the class name Item, not an Item object. Static constants can be seen throughout the Java API. For example, the integer wrapper class has two that store the maximum and minimum values an int data type can have: System.out.println(The max value for int is: Integer.MAX_VALUE); System.out.println(The min value for int is: Integer.MIN_VALUE); Output: The max value for int is: 2147483647 The min value for int is: -2147483648
Subscribe to:
Post Comments (Atom)
No comments:
Post a Comment
Note: Only a member of this blog may post a comment.