Skip to main content

Why an outer Java class can’t be private or protected

As soon as we try to use private or protected keyword while declaring an outer class compiler gives a compilation error saying “Illegal modifier for the class your_class_name; only public, abstract & final are permitted”.

Here in this article, we are going to study why we are not allowed to use these keywords while declaring outer classes. But before understating the reason behind this we need to understand Java access specifiers and their use cases. There is total 4 access specifier in Java mentioned below in the order of their accessibility.

  1. private: anything (field, class, method, interface etc.) defined using private keyword is only accessible inside the entity (class or package or interface) in which it is defined. 
  2. default: only accessible inside the same package and it is also known as package-private (No modifiers needed).
  3. protected: only accessible inside the same package plus outside the package within child classes through inheritance only. 
  4. public: can be accessed from anywhere.

Why an outer class can not be private

As we already know a field defined in a class using private keyword can only be accessible within the same class and is not visible to outside world.

So what will happen if we will define a class private, that class will only be accessible within the entity in which it is defined which in our case is its package?

Let’s consider below example of class A

package com.example;
class A {
private int a = 10;

// We can access a private field by creating object of same class inside the same class
// But realy no body creates object of a class inside the same class
public void usePrivateField(){
A objA = new A();
System.out.println(objA.a);
}
}

Field ‘a’ is declared as private inside ‘A’ class and because of it ‘a’ field becomes private to class ‘A' and can only be accessed within ‘A’. Now let’s assume we are allowed to declare class ‘A’ as private, so in this case class ‘A’ will become private to package ‘com.example’ and will not be accessible from outside of the package.

So defining private access to the class will make it accessible inside the same package which default keyword already do for us, Therefore there is no benefit of defining a class private it will only make things ambiguous.

Why an outer class can not be protected

Access specifier protected is sometimes got confused with the default keyword, for some programmers it becomes hard to identify the exact difference between default and protected accesses. But it is very clear as mentioned below

    default → only accessible within the same package.
    protected → accessible within the same package as well as outside of the package in child classes  through inheritance only.

Let’s consider below example of class A

package com.example;
public class A {
protected int a = 10;
}

And suppose there is one more class in another package

package com.experiment;
public class B extends A {

// Outside of the package protected field can be accessed through inheritance
public void printUsingInheritance() {
System.out.println(a);
}

// In child class we can access protected field through instantiation of child class
// But should we do that ? .... No
public void printUsingInstantiation() {
B b = new B();
System.out.println(b.a);

// But not through instantiation of the class which contains the protected field
A a = new A();
System.out.println(a.a); // Compilation error “The field A.a is not visible”
}
}

And suppose there is one more class in the same package

package com.experiment;
public class C {

// We can not access protected field outside of the child class through instantiation
public void printUsingInstantiation() {
B b = new B();
System.out.println(b.a); // Compilation error “The field B.a is not visible”
}
}

And if same class 'C' extends 'B', Then again we will be able to access 'a' the same way we are able to access it in B class

package com.experiment;
public class C extends B {

// outside of the package protected field can only be accessed through inheritance
public void printUsingInheritance() {
System.out.println(a);
}

// In child class we can access protected field through instantiation as well
public void printUsingInstantiation() {
C c = new C();
System.out.println(c.a);
}
}

Because ‘a’ field is protected, we can access it in any way we want to inside the package but outside of the package ‘com.example’ it is only accessible through inheritance and because class ‘B’ is extending class ‘A’ we can use field ‘a’ inside class ‘B’ only as we are doing in printUsingInheritance() method. And we can not use ‘a’ outside of class ‘B’ without inheriting 'B' in another class.

Field ‘a’ will be accessible inside class B in through inheritance only but if we try to create an instance of class ‘B’ in ‘B’ class and then try to access ‘a’ from that instance we will able to use it in a similar manner we can use a private variable in the same class by instantiation of same class.

So If we are allowed to make a class protected then we can access it inside the package very easily but for accessing that class outside of the package we first need to extend that entity in which this class is defined which is again is its package.

And since a package can not be extended (can be imported) defining a class protected will again make it similar to defining it as default which we can already do. So again there is no benefit of defining a class protected.

Please feel free to reach me if you face any problem in understanding it or found any problem in the article.

Comments

  1. Dear Naresh:
    I typed in your code and did not get a compilation error in printUsingInstantiation. Furthermore, it was necessary to import A, otherwise it wouldn't compile. Am I doing something wrong?
    Here's the code, along with the main()


    package com.psi.outer;

    public class A {
    protected int a = 10;

    }
    ===================================
    package com.psi.outer.experiment;

    import com.psi.outer.A;

    public class B extends A {
    //a = 20;
    // Outside of the package protected fields can only be accessed through inheritance
    public void printUsingInheritance() {
    System.out.println(a);
    }

    // Even in a child class we can't access protected fields through instantiation
    public void printUsingInstantiation() {
    B b = new B();
    System.out.println(b.a);
    }
    }
    ==============================================================
    package com.psi.outer.experiment;

    public class M {

    public static void main(String[] args) {

    B bb = new B();
    System.out.println("PrintUsingInheritance: ");
    bb.printUsingInheritance();
    System.out.println("");
    System.out.println("PrintUsingInstantiation: ");
    bb.printUsingInstantiation();
    }

    }

    ReplyDelete
    Replies
    1. Sorry Jorge, It was a mistake, I have updated the article.

      We can access it within the same class through instantiation as well but not outside of the class.

      Delete

Post a Comment

Popular posts from this blog

What is Variable Shadowing and Hiding in Java

Java allows us to declare a variable whenever we need it, We can categorize all our variables into 3 categories which have different-different scopes Instance Variables - Defined inside a class and have object level scope. Class Variables - Defined inside a class with static keyword, have class level scope common to all objects of the same class Local Variables - Defined inside a method or in any conditional block, have the block-level scope and only accessible in the block where it defined. What is Variable Shadowing Variable shadowing happens when we define a variable in a closure scope with a variable name and we have already defined a variable in outer scope with the same name. In other words, when a local variable has the same name as one of the instance variable, the local variable shadows the instance variable inside the method block. In the following example, there is an instance variable named x and inside method printLocalVariable(), we are shadowing it by the local ...

Why String is Immutable and Final in Java

While coding in any programming language we always require some predefined types which we can use to write the code and every programming language provides these types in its way e.g. Java provides primitive types ( int, long, char float etc) and reference types (custom types like Object, String, Thread ). For string manipulation, Java provides a class java.lang.String which gives us a way to create string objects and provides different behaviors to operate on those objects e.g. replace(), length() String name = "Naresh"; System.out.print(name.length()); System.out.print(name.isEmpty()); Whenever we talk about String class in Java we say it is i mmutable in nature and all string literals are stored in String Constant Pool (SCP) . Prior to Java 7 String Constant Pool belongs to Permanent Generation area of heap which means Garbage Collector will not touch it in normal scenarios. But from Java 7 onwards string constant pool is not part of Perm Gen but live with o...

Creating objects through Reflection in Java with Example

In Java, we generally create objects using the new keyword or we use some DI framework e.g. Spring to create an object which internally use Java Reflection API to do so. In this Article, we are going to study the reflective ways to create objects. There are two methods present in Reflection API which we can use to create objects Class.newInstance() → Inside java.lang package Constructor.newInstance() → Inside java.lang.reflect package However there are total 5 ways create objects in Java, if you are not aware of them please go through this article 5 Different ways to create objects in Java with Example . Both Class.newInstance() and java.lang.reflect.Constructor.newInstance() are known as reflective methods because these two uses reflection API to create the object. Both are not static and we can call earlier one on a class level object while latter one needs constructor level object which we can get by using the class level object. Class.newInstance() The Class class is th...