java tutorial - Java modifiers | Access and class modifiers

Learn Java - Java tutorial - Java modifiers - Java examples - Javaprograms

Modifiers are keywords that you add when initializing to change values. The Java language has a wide range of modifiers, the main ones are:

To use a modifier in Java, you need to include its keyword in the definition of a class, method, or variable. The modifier must be ahead of the rest of the statement, as shown in the following examples:

public class className {
   // ...
}
private boolean myFlag;
static final double weeks = 9.5;
protected static final int BOXWIDTH = 42;
public static void main (String [] arguments) {
   // the body of the method
}

In Java, it provides access modifiers to state access levels for classes, variables, methods as well as constructors. There are four accesses are given below:

Variables and methods can be declared in Java without any modifiers, as shown in the following example:

String version = "1.5.1";

boolean processOrder() {
   return true;
}
}

The following class uses private access control:

public class Logger {
   private String format;
   public String getFormat() {
      return this.format;
   }
   public void setFormat(String format) {
      this.format = format;
   }
}

The following function uses public access control:

public static void main(String[] arguments) {
   // ...
}

The main () method must be public. Otherwise, it cannot be called using the java interpreter to start the class.

The following parent class uses protected access control so that its child class redefines the openSpeaker () method:

class AudioPlayer {
   protected boolean openSpeaker (Speaker sp) {
      // implementation details
   }
}

class StreamingAudioPlayer {
   boolean openSpeaker (Speaker sp) {
      // implementation details
   }
}

The given below rules in Java apply to inherited methods:

Java provides a number of modifiers not for access, but for implementing much other functionality:

The static modifier in Java is used to create class and variable methods, as shown in the following example:

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 () + "instance");
      for (int i = 0; i <500; ++ i) {
         new InstanceCounter ();
}
      System.out.println ("Created" +
      InstanceCounter.getCount () + "instances");
   }
}

Output

Starting with 0 instance
500 copies created

The final modifier is used to complete the implementation of classes, methods, and variables.

public class Test {
  final int value = 10;
  // Below are examples of declaring constants:
  public static final int BOXWIDTH = 6;
  static final String TITLE = "Manager";
  
  public void changeValue () {
     value = 12; // get an error
  }
}

The declaration of the method that uses the final modifier in the class declaration is shown in the following example:

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

The main purpose in Java of using a class declared as final is to prevent the class from being a subclass. If the class is marked as final, then no class can inherit any function from the final class.

public final class Test {
   // class body
}

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

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

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

The synchronized modifier is used in Java for threads.

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

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

public class MyRunnable implements Runnable {
    private volatile boolean active;
 
    public void run () {
        active = true;
        while (active) {// line 1
            // here is some code
        }
    }
    
    public void stop () {
        active = false; // line 2
    }
}