Access Modifiers in Java

We have already been talking about Java variables, classes, fields and methods. Whenever they are declared, you will have to indicate how they are controlled and how they are accessed in the entire program. Whether they are restricted or not, their accessibility feature will be determined by access modifiers.

Deciding on what modifier to use depends on your program’s goal and what you are trying to achieve. The following are the different types of modifiers:

  • Default
  • Private
  • Public
  • Protected

This is the type that is assigned when there is no access modifier specified. Due to its absence, any command or function can access a part of the program. However, its availability is only limited to access by fields that belong to a similar package. A program without a modifier can look effective but not entirely clean. The access level is usually open to the public, but it is not included in an interface.

		String version = “ 1.00.1”
		Boolean process_order () {
		Return true

In this example, the program declared a string order version at the beginning. Since a specific type of access modifier is undefined, any command of function can be used to access the program component. Therefore, process_order can be modified easily.


This is the type of modifier that accommodates the most restrictive fields in the program. It cannot be accessed, thus, cannot also be used by any command or function. Let’s say a particular instruction is from an unlisted source. It cannot be granted recognition.

		public class arcadia extends bay {
		private int name_of_residents
		private boolean in_city
		public arcadia () {
		name_of_residents = joy
		in_city = false
		private void shrill ()
		system.out.printIn (quiet);
		public void action ()
		system.out.printIn (talk);

For this example, the program defined a public class arcadia, which is allowed an extensive function bay. Although arcadia bay is set to public, some of its internal properties are set to private. Besides, since one of its internal components (action) is set to public, different fields can acknowledge it.


This is the type of modifier that allows access from about any other field. It is less troublesome for a programmer to visit other parts of his work with a public access level. All the commands, functions and different components of the program belonging to the public class can be accessed through a recognized set of instructions in Java programming language. However, being publicly declared has some drawbacks or limitations. Even if all the commands and functions are set to public, they cannot be accessed by classes that belong to a different package.

		public static void (string arguments) {

This type of access modifier belongs to what we call a superclass and is characterized by being less hidden and secure than the default type. It also signifies two things:

  • It can only be accessed by the fields that are declared in a particular superclass
  • The subclasses of a similar package can only access it.

Such categorization is implemented to improve program structure while limiting the access of an irrelevant element. Protected access modifiers also impose strict protocols, and the application is limited (cannot be applied to classes and interfaces). If a field is not connected to any class or interface, it can be declared as protected.

		class seven_fields
		protected boolean open_fields (field1 sp) {
		// implementation
		Class opening seven_fields (field1 sp) {
		// implementation

In this example, class seven_fields was declared, and since it is under the protected access modifier, its Boolean logic open_fields is inaccessible with the use of just any function or command. Unless a new access modifier is declared, this particular part of the program cannot be modified.

Each of the four access modifiers has its characteristic and functionality that will affect how objects are accessed in a given Java program.

Copyright 1999- Ducat Creative, All rights reserved.