JavaNon-Access Modifiers
Non-Access Modifiers
Non-access modifiers do not control visibility (likepublic orprivate), but instead addother features to classes, methods, and attributes.
The most commonly used non-access modifiers arefinal,static, andabstract.
Final
If you don't want the ability to override existing attribute values, declare attributes asfinal:
Example
public class Main { final int x = 10; final double PI = 3.14; public static void main(String[] args) { Main myObj = new Main(); myObj.x = 50; // will generate an error: cannot assign a value to afinal variable myObj.PI = 25; // will generate an error: cannot assign a value to afinal variable System.out.println(myObj.x); }}Static
Astatic method belongs to the class, not to any specific object. This means you can call it without creating an object of the class.
Example
A simple example showing how to call astatic method directly:
public class Main { // Static method static void myStaticMethod() { System.out.println("Static methods can be called without creating objects"); } // Main method public static void main(String[] args) { myStaticMethod(); // Call the static method Main.myStaticMethod(); // Or call it using the class name }}Note: Astatic method belongs to the class itself. You can call it without creating an object, but it cannot use variables or methods that belong to an object.
Abstract
Anabstract method belongs to anabstract class, and it does not have a body. The body is provided by the subclass:
// abstract class
abstract class Main { public String fname = "John"; public int age = 24; publicabstract void study(); // abstract method}// Subclass (inherit from Main)class Student extends Main { public int graduationYear = 2018; public void study() { // the body of the abstract method is provided here System.out.println("Studying all day long"); }}// Code from filename: Second.javaclass Second { public static void main(String[] args) { // create an object of the Student class (which inherits attributes and methods from Main) Student myObj = new Student(); System.out.println("Name: " + myObj.fname); System.out.println("Age: " + myObj.age); System.out.println("Graduation Year: " + myObj.graduationYear); myObj.study(); // call abstract method
}}Non-Access Modifiers List
Forclasses, you can use eitherfinal orabstract:
| Modifier | Description | Try it |
|---|---|---|
final | The class cannot be inherited by other classes (You will learn more about inheritance in theInheritance chapter) | Try it » |
abstract | The class cannot be used to create objects (To access an abstract class, it must be inherited from another class. You will learn more about inheritance and abstraction in theInheritance andAbstraction chapters) | Try it » |
Forattributes and methods, you can use the one of the following:
| Modifier | Description |
|---|---|
final | Attributes and methods cannot be overridden/modified |
static | Attributes and methods belong to the class, not to objects. This means all objects share the samestatic attribute, andstatic methods can be called without creating objects. |
abstract | Can only be used in an abstract class, and can only be used on methods. The method does not have a body, for exampleabstract void run();. The body is provided by the subclass (inherited from). You will learn more about inheritance and abstraction in theInheritance andAbstraction chapters |
transient | Attributes and methods are skipped when serializing the object containing them |
synchronized | Methods can only be accessed by one thread at a time |
volatile | The value of an attribute is not cached thread-locally, and is always read from the "main memory" |
