0% found this document useful (0 votes)
33 views8 pages

Understanding Java Access Modifiers

Uploaded by

lakshmism46
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
33 views8 pages

Understanding Java Access Modifiers

Uploaded by

lakshmism46
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd

Indian Online Gaming CEO Fired After 46

Million Rupee Mistake READ MORE


sponsored by: Today Posts

Access Modifiers in Java


There are two types of modifiers in Java: access modifiers and non-access
modifiers.

The access modifiers in Java specifies the accessibility or scope of a field, method,
constructor, or class. We can change the access level of fields, constructors, methods,
and class by applying the access modifier on it.

There are four types of Java access modifiers:

Today Posts

O ›
1. Private: The access level of a private modifier is only within the class. It cannot
be accessed from outside the class.
2. Default: The access level of a default modifier is only within the package. It
cannot be accessed from outside the package. If you do not specify any access
level, it will be the default.
3. Protected: The access level of a protected modifier is within the package and
outside the package through child class. If you do not make the child class, it
cannot be accessed from outside the package.
4. Public: The access level of a public modifier is everywhere. It can be accessed
from within the class, outside the class, within the package and outside the
package.

There are many non-access modifiers, such as static, abstract, synchronized, native,
volatile, transient, etc. Here, we are going to learn the access modifiers only.

Understanding Java Access Modifiers


Let's understand the access modifiers in Java by a simple table.

Access within within outside package by outside


Modifier class package subclass only package

Private Y N N N

Default Y Y N N

Protected Y Y Y N

Public Y Y Y Y

Deploy Runtimes - Quick & Easy
Keep open source language builds up to date and
consistent across teams at scale.
ActiveState Open

1) Private
The private access modifier is accessible only within the class.

Simple example of private access modifier

In this example, we have created two classes A and Simple. A class contains private
data member and private method. We are accessing these private members from
outside the class, so there is a compile-time error.

class A{
private int data=40;
private void msg(){[Link]("Hello java");}
}

public class Simple{


public static void main(String args[]){
A obj=new A();
[Link]([Link]);//Compile Time Error
[Link]();//Compile Time Error
}
}

Role of Private Constructor

If you make any class constructor private, you cannot create the instance of that class
from outside the class. For example:

class A{
private A(){}//private constructor
void msg(){[Link]("Hello java");}
}
public class Simple{
public static void main(String args[]){
A obj=new A();//Compile Time Error

}
}

Note: A class cannot be private or protected except nested class.

2) Default
If you don't use any modifier, it is treated as default by default. The default modifier is
accessible only within package. It cannot be accessed from outside the package. It
provides more accessibility than private. But, it is more restrictive than protected, and
public.

Example of default access modifier

In this example, we have created two packages pack and mypack. We are accessing the
A class from outside its package, since A class is not public, so it cannot be accessed
from outside the package.

//save by [Link]
package pack;
class A{
void msg(){[Link]("Hello");}
}

//save by [Link]
package mypack;
import pack.*;
class B{
public static void main(String args[]){
A obj = new A();//Compile Time Error
[Link]();//Compile Time Error
}
}

In the above example, the scope of class A and its method msg() is default so it cannot
be accessed from outside the package.

3) Protected
The protected access modifier is accessible within package and outside the package
but through inheritance only.

The protected access modifier can be applied on the data member, method and
constructor. It can't be applied on the class.

It provides more accessibility than the default modifer.



Example of protected access modifier
In this example, we have created the two packages pack and mypack. The A class of
pack package is public, so can be accessed from outside the package. But msg method
of this package is declared as protected, so it can be accessed from outside the class
only through inheritance.

//save by [Link]
package pack;
public class A{
protected void msg(){[Link]("Hello");}
}

//save by [Link]
package mypack;
import pack.*;

class B extends A{
public static void main(String args[]){
B obj = new B();
[Link]();
}
}

Output:Hello

4) Public
The public access modifier is accessible everywhere. It has the widest scope among
all other modifiers.

Example of public access modifier

//save by [Link]

package pack;
public class A{
public void msg(){[Link]("Hello");}
}

//save by [Link]

package mypack;
import pack.*;

class B{
public static void main(String args[]){
A obj = new A(); ⇧
[Link]();
}
}

Output:Hello

Java Access Modifiers with Method Overriding


If you are overriding any method, overridden method (i.e. declared in subclass) must
not be more restrictive.

class A{
protected void msg(){[Link]("Hello java");}
}

public class Simple extends A{


void msg(){[Link]("Hello java");}//[Link]
public static void main(String args[]){
Simple obj=new Simple();
[Link]();
}
}

The default modifier is more restrictive than protected. That is why, there is a compile-
time error.

← prev next →

Help Others, Please Share


Learn Latest Tutorials

Openpyxl Tally Godot Spring Boot


Tutorial Tutorial Tutorial Tutorial

Openpyxl Tally Godot Spring Boot

Gradle UML Artificial ES6 Tutorial


Tutorial Tutorial Neural
Network ES6
Gradle UML Tutorial

ANN

Flutter Selenium Firebase Cobol


Tutorial Python Tutorial Tutorial

Flutter Selenium Py Firebase Cobol

Preparation

Aptitude Logical Verbal Interview


Reasoning Ability Questions
Aptitude
Reasoning Verbal A. Interview

Company
Interview
Questions

Company

Trending Technologies ⇧
Artificial AWS Selenium Cloud
Intelligence Tutorial tutorial tutorial
Tutorial
AWS Selenium Cloud
AI

Hadoop ReactJS Data Science Angular 7


tutorial Tutorial Tutorial Tutorial

Hadoop ReactJS D. Science Angular 7

Blockchain Git Tutorial Machine DevOps


Tutorial Learning Tutorial
Git Tutorial
Blockchain DevOps
ML

[Link] / MCA

DBMS Data DAA Operating


tutorial Structures tutorial System tutorial
tutorial
DBMS DAA OS
DS

Computer Compiler Computer Discrete


Network Design tutorial Organization Mathematics
tutorial and Tutorial
Compiler D. Architecture
C. Network D. Math.
COA

Ethical Computer Software html tutorial


Hacking Graphics Engineering
Tutorial Tutorial Tutorial Web Tech.

E. Hacking C. Graphics Software E.

Cyber Automata C Language C++ tutorial


Security Tutorial tutorial
tutorial C++
Automata C
Cyber Sec.

Java tutorial .Net Python List of


Framework tutorial Programs
Java tutorial
Python Programs
.Net


Control Data Mining
Systems Tutorial
tutorial
Data Mining
Control S.

Common questions

Powered by AI

A public method in a Java class is accessible from anywhere, including different packages, any class, and any subclass, providing the widest scope of accessibility among access modifiers . In contrast, a protected method is accessible only within the same package and can be accessed from outside its package only through subclasses via inheritance, making its scope more restricted compared to a public method .

The primary difference between the default and protected access modifiers in Java lies in their accessibility across packages. The default access modifier limits accessibility to within the same package only and cannot be accessed from outside the package . On the other hand, the protected access modifier also allows access within the package, but it extends accessibility to subclasses even if they are in different packages through inheritance .

If a subclass overrides a method and assigns it a higher access level than that defined in its superclass, it generally does not lead to a compile-time error. However, Java restricts assigning a more restrictive access level to an overriding method in a subclass than it is declared in the superclass. For example, if a protected method in a superclass is overridden as private in a subclass, a compile-time error will occur indicating that the overridden method cannot be more restrictive . This is because it would violate the principle of substitutability in inheritance, affecting the class's ability to be used polymorphically.

Using the public access modifier indiscriminately in API design could lead to design flaws, especially if internal methods or fields are exposed to the user unnecessarily. This can result in reliance on implementation details, making it difficult to maintain or upgrade the API. For example, if a class exposes its internal state directly through public fields, users might depend on these fields, leading to possible misuse and making it harder to change them without breaking existing client code. Encapsulation with more restrictive access modifiers would be beneficial to shield implementation details and ensure a stable API surface .

A private constructor is particularly beneficial in implementing the Singleton design pattern, where only one instance of a class is allowed to exist. By making the constructor private, it prevents other classes from instantiating the class directly, thus ensuring controlled instance creation through a static method within the same class that holds and returns the single instance . This promotes controlled access and lazy instantiation if needed.

Using the default access modifier can constrain modular application development in Java because it restricts class and member access strictly to within the same package . This restriction may hinder reusability and limit the modularity of the application as components cannot be easily accessed or extended from different packages. A more open access strategy using protected or public might be necessary for developing highly modular architectures where components interact across packages.

A developer might choose a protected access modifier over a default one when the developer intends to allow access to a class member across different packages through inheritance while still partially restricting access. For example, consider a scenario where a library developer wants to expose certain internal methods to subclasses used in different packages by application developers while not allowing direct access to classes in those packages. Using protected ensures that only classes that extend the library classes can access these methods, not other classes within the package .

Non-access modifiers complement access modifiers by providing additional control and security features within a class. For instance, the 'final' modifier prevents a class or method from being subclassed or overridden, enhancing security by preserving the intended behavior. The 'static' modifier allows shared access across instances while maintaining controlled access through access modifiers. The 'synchronized' modifier ensures that methods are thread-safe, preventing multiple threads from concurrently accessing critical sections. These non-access modifiers ensure that the integrity and state of the class's data are maintained securely, alongside the access control provided by access modifiers .

The private access modifier enforces encapsulation in Java by restricting access to the class's fields, methods, and constructors exclusively to within its own class. This way, data hiding is facilitated, preventing external classes from altering or accessing the internal data directly . This results in increased security and control over the data, ensuring that it can only be modified through methods within the class itself, creating a controlled environment for data manipulation.

When a class's constructor is private, it cannot be instantiated from outside the class, which impacts usability by preventing direct object creation. This is often used in single-instance (singleton) or factory design patterns. In practice, this might be seen in logging frameworks where ensuring only one logger instance exists avoids conflicts; by keeping the constructor private, controlled objects are created through provided static methods, which ensure managed instantiation and resource allocation .

You might also like