Loading...

Access Control in Java

java tech
Ram Patra Published on May 22, 2019
Image placeholder

Modifiers fall into two categories:

  • Access modifiers: public, protected, private and default (package-level access).
  • Non-access modifiers: transient, synchronized, native, strictfp, final, abstract and static.

Access Modifiers

Two types of access are there:

  • Whether method code in one class can access a member of another class
  • Whether a subclass can inherit a member of its superclass

A default member may be accessed only if the class accessing the member belongs to the same package, whereas a protected member can be accessed by a subclass in the same package (through dot operator and inheritance) and even if it is in a different package (through inheritance only).

You cannot access a protected member using the dot (.) operator in the subclass if the subclass is in a different package from the parent class.

The following code snippet makes it clear:

package certification;
public class Parent {
    protected int x = 9; // protected access
    
    protected int getX() {
        return x;
    }
}

package other; // different package
import certification.Parent;
class Child extends Parent {
    public void testIt() {
        System.out.println("x is " + x); // No problem; Child
                                         // inherits x
        Parent p = new Parent(); // Can we access x using
                                 // p reference?
        System.out.println("X in parent is " + p.x); // Compiler
                                                     // error
        System.out.println("X in parent is " + p.getX()); // Compiler
                                                          // error
    }
}

NOTE: If Child class would have been in the same package as Parent then there would be no compiler error.

The below table gives the picture of all access modifiers:

Visibility Public Protected Default Private
From the same class Yes Yes Yes Yes
From any class in the same package Yes Yes Yes No
From a subclass in the same package Yes Yes Yes No
From a subclass outside the same package Yes Yes, through inheritance No No
From any non-subclass class outside the package Yes No No No

Non-Access Modifiers

Final is the only modifier which can be applied to local variables. It can also be used in method arguments like:

// final in method arguments, can't be altered inside the method
public Record getRecord(int fileNumber, final int recordNumber) {}

Final when applied to a method prevents it to be overridden and when applied to a class makes it un-inheritable i.e, it can never be subclassed (no class can extend it).

An abstract method is a method that’s been declared (as abstract) but not implemented. In other words, the method contains no functional code. And the class which contains at least one of such methods is an abstract class and has to be declared abstract. An abstract class can never be instantiated.

A method can never, ever, ever be marked as both abstract and final, or both abstract and private or both abstract and static.

A class having even a single abstract method has to be declared abstract or if it extends an abstract class then it must implement all abstract methods of the superclass otherwise you have make it abstract as well.

Comparison of modifiers on variables vs. methods:

Local Variables Non-local Variables Methods
final final final
  public public
  protected protected
  private private
  static static
  transient abstract
  volatile synchronized
    strictfp
    native
Presentify

Take your presentation to the next level.

FaceScreen

Put your face and name on your screen.

ToDoBar

Your to-dos on your menu bar.

Ram Patra Published on May 22, 2019
Image placeholder

Keep reading

If you liked this article, you may like these as well

November 28, 2019 How I got 800 stars on GitHub in a day

Is your project solving a pain point that no other project is solving or is it solving a problem in a way better than others? If the answer is yes then read on.

life-in-ireland income-tax tax-credits January 8, 2021 How to claim electricity, heat, and internet expenses in Ireland for COVID-19?

In Ireland, you get back 10% of your total electricity/heat expenses and 30% of your internet bill for the days you’re working from home. This will be the case for the year 2020 and 2021. For 2022, you will get back even more, 30% for both electricity/heat and internet.

August 20, 2019 Nested Classes in Java

A class inside another class is called a Nested Class. In other words, as a class has member variables and member methods it can also have member classes.