Java Non Access Modifiers

Java applies numerous non-access modifiers to attain many other functionalities.

• The still modifier for developing class techniques and variables
• The last modifier for finalizing the completion of classes, methods, and variables
• The abstract modifier for developing abstract groups and methods
• The synchronized and unstable modifiers, which are employed for threads

The Static Modifier

Static Variables

The static keyword is utilized to generate changeably that will live separately from any examples made for the group. Only one copy of the still changeable exists despite the number of examples of the class.

Static inconsistent is also recognized as class capricious. Local variables are never declared static.

Static Methods

The static keyword is exercised to generate techniques that will live separately from any examples created for the class.

Static techniques do not utilize any example variables of any entity of the class they are described in the methods. Static methods get entire the data from parameters and work out something from those limits, with no orientation to variables.

public class InstanceCounter {

   private static int numInstances = 0;

   protected static int getCount() {
      return numInstances;
   }

   private static void addInstance() {
      numInstances++;
   }

   InstanceCounter() {
      InstanceCounter.addInstance();
   }

   public static void main(String[] arguments) {
      System.out.println("Starting with " + InstanceCounter.getCount() + " instances");

      for (int i = 0; i < 500; ++i) {
         new InstanceCounter();
      }
      System.out.println("Created " + InstanceCounter.getCount() + " instances");
   }
}

This will produce the following result

Output

Started with 0 instances
Created 500 instances

The Final Modifier

Final Variables

A final changeable can be openly initialized only one time. A position changeable declared closing can never be reassigned to pass on to a dissimilar object.

However, the data inside the thing can be altered. So, the state of the entity can be changed except not the reference.

With variables, the last modifier frequently is exercised with static to create the steady class variable.

Example

public class Test {
   final int value = 10;

   // The following are examples of declaring constants:
   public static final int BOXWIDTH = 6;
   static final String TITLE = "Manager";

   public void changeValue() {
      value = 12;   // will give an error
   }
}

Final Methods

A final method never is overridden by any subclasses. As stated previously, the last modifier stops a method from being modified in a subclass.

The main intention of making a method final would be that the content of the method should not be changed by any outsider.

Example

You declare methods using the final modifier in the class declaration, as in the following example

public class Test {
   public final void changeName() {
      // body of method
   }
}

Final Classes

The core reason for utilizing a class being stated as concluding is to avert the class from being subclass If a class is blotted as last then no class can be left any feature from the final class.

Example

public final class Test {
   // body of class
}

The abstract Modifier

Abstract Class

An abstract class can not at all be instantiated. If a group is stated as abstract then the sole reason is for the class to be expanded.

A class never is equally abstracted and final (while a final class never be extended). If a class is comprised of abstract techniques then the class should be stated abstract. Or else, a compile error will be terrified.

An abstract class may hold both abstract techniques as well as usual methods.

Example

abstract class Caravan {
   private double price;
   private String model;
   private String year;
   public abstract void goFast();   // an abstract method
   public abstract void changeColor();
}

Abstract Methods

An abstract technique is a method asserted without any completion. The ways body (implementation) is offered by the subclass. Abstract methods can never be last or strict.

Any class that expands an abstract class has to apply entirely the abstract methods of the superclass, if not the subclass is also an abstract class.

If a class comprises one or more abstract ways, then the class must be stated abstract. An abstract class does not require holding abstract methods.

The abstract method ends with a semicolon. Example: public abstract sample();

Example

public abstract class SuperClass {
   abstract void m();   // abstract method
}

class SubClass extends SuperClass {
   // implements the abstract method
   void m() {
      .........
   }
}

The Synchronized Modifier

The synchronized keyword utilized points to that a technique can be entranced by only one strand at a time. The synchronized modifier is used with various four access level modifiers.

Example

public synchronized void showDetails() {
   .......
}

The Transient Modifier

An instance inconsistent is marked brief to designate the JVM to skip the exacting objects when serializing the purpose containing it.

This modifier is incorporated in the declaration that develops the variable, previous the class or data type of the object.

Example

public transient int limit = 55;   // will not persist
public int b;   // will persist

The Volatile Modifier

The volatile modifier is utilized to allow the JVM to identify that a thread way in the changeable must always combine its own private copy of the object with the master copy in the stored memory.

Contacting an unstable variable synchronizes entire the cached copy of the patchy in the main memory. Unstable can only be utilized to example variables, which are of a kind object or confidential. Unstable object orientation can be null.

Example

public class MyRunnable implements Runnable {
   private volatile boolean active;

   public void run() {
      active = true;
      while (active) {   // line 1
         // some code here
      }
   }

   public void stop() {
      active = false;   // line 2
   }
}

Usually, run() is called in one thread (the one you start using the Runnable), and stop() is called from another thread. If in line 1, the cached value of active is used, the loop may not stop when you set active to false in line 2. That's when you want to use volatile.

Here at Intellinuts, we have created a complete Java tutorial for Beginners to get started in Java.