Java Basics:Access Modifiers in Java

 

Access Modifiers in Java


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 two types of modifiers in Java: access modifiers and non-access modifiers.

There are four types of Java access modifiers:

  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 Modifierwithin classwithin packageoutside package by subclass onlyoutside package
PrivateYNNN
DefaultYYNN
ProtectedYYYN
PublicYYYY

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.

  1. class A{  
  2. private int data=40;  
  3. private void msg(){System.out.println("Hello java");}  
  4. }  
  5.   
  6. public class Simple{  
  7.  public static void main(String args[]){  
  8.    A obj=new A();  
  9.    System.out.println(obj.data);//Compile Time Error  
  10.    obj.msg();//Compile Time Error  
  11.    }  
  12. }  

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:

  1. class A{  
  2. private A(){}//private constructor  
  3. void msg(){System.out.println("Hello java");}  
  4. }  
  5. public class Simple{  
  6.  public static void main(String args[]){  
  7.    A obj=new A();//Compile Time Error  
  8.  }  
  9. }  

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.

  1. //save by A.java  
  2. package pack;  
  3. class A{  
  4.   void msg(){System.out.println("Hello");}  
  5. }  
  1. //save by B.java  
  2. package mypack;  
  3. import pack.*;  
  4. class B{  
  5.   public static void main(String args[]){  
  6.    A obj = new A();//Compile Time Error  
  7.    obj.msg();//Compile Time Error  
  8.   }  
  9. }  

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.

  1. //save by A.java  
  2. package pack;  
  3. public class A{  
  4. protected void msg(){System.out.println("Hello");}  
  5. }  
  1. //save by B.java  
  2. package mypack;  
  3. import pack.*;  
  4.   
  5. class B extends A{  
  6.   public static void main(String args[]){  
  7.    B obj = new B();  
  8.    obj.msg();  
  9.   }  
  10. }  
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

  1. //save by A.java  
  2.   
  3. package pack;  
  4. public class A{  
  5. public void msg(){System.out.println("Hello");}  
  6. }  
  1. //save by B.java  
  2.   
  3. package mypack;  
  4. import pack.*;  
  5.   
  6. class B{  
  7.   public static void main(String args[]){  
  8.    A obj = new A();  
  9.    obj.msg();  
  10.   }  
  11. }  
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.

  1. class A{  
  2. protected void msg(){System.out.println("Hello java");}  
  3. }  
  4.   
  5. public class Simple extends A{  
  6. void msg(){System.out.println("Hello java");}//C.T.Error  
  7.  public static void main(String args[]){  
  8.    Simple obj=new Simple();  
  9.    obj.msg();  
  10.    }  
  11. }  

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


Comments

Post a Comment

Popular posts from this blog

Java OOPS:OOPS Concepts Overview

Image
  OOPs concepts in Java Object-oriented programming System(OOPs) is a programming paradigm based on the concept of “objects” that contain data and methods. The primary purpose of object-oriented programming is to increase the flexibility and maintainability of programs. Object oriented programming brings together data and its behaviour(methods) in a single location(object) makes it easier to understand how a program works. We will cover each and every feature of OOPs in detail so that you won’t face any difficultly understanding  OOPs Concepts . OOPs Concepts – Table of Contents What is an Object What is a class Constructor in Java Object Oriented Programming Features Abstraction Encapsulation Inheritance Polymorphism Abstract Class and Methods Interfaces in Java What is an Object Object:  is a bundle of data and its behaviour(often known as methods). Objects have two characteristics: They have  states  and  behaviors . Examples of states and behaviors Exam...
Read more

Java OOPS:Constructors in Java – A complete study!!

Image
  Constructors in Java – A complete study!! Constructor is a block of code that initializes the newly created object. A constructor resembles an instance method in java but it’s not a method as it doesn’t have a return type. In short constructor and method are different(More on this at the end of this guide). People often refer constructor as special type of method in Java. Constructor has same name as the class and looks like this in a java code. public class MyClass { //This is the constructor MyClass (){ } .. } Note that the constructor name matches with the class name and it doesn’t have a return type. How does a constructor work To understand the working of constructor, lets take an example. lets say we have a class  MyClass . When we create the object of  MyClass  like this: MyClass obj = new MyClass () The  new keyword  here creates the object of class  MyClass  and invokes the constructor to initialize this newly crea...
Read more

Java Basics:Data Types

  Data Types in Java Data types specify the different sizes and values that can be stored in the variable. There are two types of data types in Java: Primitive data types:  The primitive data types include boolean, char, byte, short, int, long, float and double. Non-primitive data types:  The non-primitive data types include Classes,Interfaces,Arrays. 1) Primitive data types In Java, we have eight primitive data types: boolean, char, byte, short, int, long, float and double. Java developers included these data types to maintain the portability of java as the size of these primitive data types do not change from one operating system to another. byte ,  short ,  int  and  long  data types are used for storing whole numbers. float  and  double  are used for fractional numbers. char  is used for storing characters(letters). boolean  data type is used for variables that holds either true or false. byte: This can hold whole numb...
Read more