Non-Access Modifiers

Non-Access Modifiers

Non-access modifiers do not control visibility (like public or private), but instead add other features to classes, methods, and attributes.

The most commonly used non-access modifiers are final, static, and abstract.

Final

If you don't want the ability to override existing attribute values, declare attributes as final:

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 a final variable
    myObj.PI = 25; // will generate an error: cannot assign a value to a final variable
    System.out.println(myObj.x);
  }
}

Static

A static method belongs to the class, not to any specific object. This means you can call it without creating an object of the class.

Example

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: A static 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

An abstract method belongs to an abstract 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;
  public abstract 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");
  }
}

Non-Access Modifiers List

For classes, you can use either final or abstract:

For attributes and methods, you can use the one of the following: