Java Access Specifiers/Modifier

The access to classes, constructors, methods and fields are regulated using access modifiers i.e. a class can control what information or data can be accessible by other classes. To take advantage of encapsulation, you should minimize access whenever possible.

Java provides a number of access modifiers to help you set the level of access you want for classes as well as the fields, methods and constructors in your classes. A member has package or default accessibility when no accessibility modifier is specified.

Access Modifiers

1. private
2. protected
3. default
4. public

public access modifier

Fields, methods and constructors declared public (least restrictive) within a public class are visible to any class in the Java program, whether these classes are in the same package or in another package.

private access modifier

The private (most restrictive) fields or methods cannot be used for classes and Interfaces. It also cannot be used for fields and methods within an interface. Fields, methods or constructors declared private are strictly controlled, which means they cannot be accesses by anywhere outside the enclosing class. A standard design strategy is to make all fields private and provide public getter methods for them.

protected access modifier

The protected fields or methods cannot be used for classes and Interfaces. It also cannot be used for fields and methods within an interface. Fields, methods and constructors declared protected in a super class can be accessed only by subclasses in other packages. Classes in the same package can also access protected fields, methods and constructors as well, even if they are not a subclass of the protected member’s class.

default access modifier

Java provides a default specifier which is used when no access modifier is present. Any class, field, method or constructor that has no declared access modifier is accessible only by classes in the same package. The default modifier is not used for fields and methods within an interface.

Below is a program to demonstrate the use of public, private, protected and default access modifiers while accessing fields and methods. The output of each of these java files depict the Java access specifiers.

The first class is SubclassInSamePackage.java which is present in pckage1 package. This java file contains the Base class and a subclass within the enclosing class that belongs to the same class as shown below.

package pckage1;

class BaseClass {

 public int x = 10;
 private int y = 10;
 protected int z = 10;
 int a = 10; //Implicit Default Access Modifier
 public int getX() {
  return x;
 }
 public void setX(int x) {
  this.x = x;
 }
 private int getY() {
  return y;
 }
 private void setY(int y) {
  this.y = y;
 }
 protected int getZ() {
  return z;
 }
 protected void setZ(int z) {
  this.z = z;
 }
 int getA() {
  return a;
 }
 void setA(int a) {
  this.a = a;
 }
}

public class SubclassInSamePackage extends BaseClass {

 public static void main(String args[]) {
  BaseClass rr = new BaseClass();
  rr.z = 0;
  SubclassInSamePackage subClassObj = new SubclassInSamePackage();
  //Access Modifiers - Public
  System.out.println("Value of x is : " + subClassObj.x);
  subClassObj.setX(20);
  System.out.println("Value of x is : " + subClassObj.x);
  //Access Modifiers - Public
  //     If we remove the comments it would result in a compilaton
  //     error as the fields and methods being accessed are private
  /*     System.out.println("Value of y is : "+subClassObj.y);

   subClassObj.setY(20);

   System.out.println("Value of y is : "+subClassObj.y);*/
  //Access Modifiers - Protected
  System.out.println("Value of z is : " + subClassObj.z);
  subClassObj.setZ(30);
  System.out.println("Value of z is : " + subClassObj.z);
  //Access Modifiers - Default
  System.out.println("Value of x is : " + subClassObj.a);
  subClassObj.setA(20);
  System.out.println("Value of x is : " + subClassObj.a);
 }
}

Output

Value of x is : 10
Value of x is : 20
Value of z is : 10
Value of z is : 30
Value of x is : 10
Value of x is : 20

The second class is SubClassInDifferentPackage.java which is present in a different package then the first one. This java class extends First class (SubclassInSamePackage.java).

import pckage1.*;

public class SubClassInDifferentPackage extends SubclassInSamePackage {

 public int getZZZ() {
  return z;
 }

 public static void main(String args[]) {
  SubClassInDifferentPackage subClassDiffObj = new SubClassInDifferentPackage();
  SubclassInSamePackage subClassObj = new SubclassInSamePackage();
  //Access specifiers - Public
  System.out.println("Value of x is : " + subClassObj.x);
  subClassObj.setX(30);
  System.out.println("Value of x is : " + subClassObj.x);
  //Access specifiers - Private
  //      if we remove the comments it would result in a compilaton
  //      error as the fields and methods being accessed are private
  /*      System.out.println("Value of y is : "+subClassObj.y);

   subClassObj.setY(20);

   System.out.println("Value of y is : "+subClassObj.y);*/
  //Access specifiers - Protected
  //      If we remove the comments it would result in a compilaton
  //      error as the fields and methods being accessed are protected.
  /*      System.out.println("Value of z is : "+subClassObj.z);

   subClassObj.setZ(30);

   System.out.println("Value of z is : "+subClassObj.z);*/
  System.out.println("Value of z is : " + subClassDiffObj.getZZZ());
  //Access Modifiers - Default
  //      If we remove the comments it would result in a compilaton
  //      error as the fields and methods being accessed are default.
  /*

   System.out.println("Value of a is : "+subClassObj.a);

   subClassObj.setA(20);

   System.out.println("Value of a is : "+subClassObj.a);*/
 }
}

Output

Value of x is : 10
Value of x is : 30
Value of z is : 10

The third class is ClassInDifferentPackage.java which is present in a different package then the first one.

import pckage1.*;

public class ClassInDifferentPackage {

 public static void main(String args[]) {
  SubclassInSamePackage subClassObj = new SubclassInSamePackage();
  //Access Modifiers - Public
  System.out.println("Value of x is : " + subClassObj.x);
  subClassObj.setX(30);
  System.out.println("Value of x is : " + subClassObj.x);
  //Access Modifiers - Private
  //      If we remove the comments it would result in a compilaton
  //      error as the fields and methods being accessed are private
  /*      System.out.println("Value of y is : "+subClassObj.y);

   subClassObj.setY(20);

   System.out.println("Value of y is : "+subClassObj.y);*/
  //Access Modifiers - Protected
  //      If we remove the comments it would result in a compilaton
  //      error as the fields and methods being accessed are protected.
  /*      System.out.println("Value of z is : "+subClassObj.z);

   subClassObj.setZ(30);

   System.out.println("Value of z is : "+subClassObj.z);*/
  //Access Modifiers - Default
  //      If we remove the comments it would result in a compilaton
  //      error as the fields and methods being accessed are default.
  /*      System.out.println("Value of a is : "+subClassObj.a);

   subClassObj.setA(20);

   System.out.println("Value of a is : "+subClassObj.a);*/
 }
}

Output

Value of x is : 10
Value of x is : 30

Java Non Access Modifier

There are different non access modifiers available.

Final
Abstract
Static
Strictfp
Native
Synchronized
Transient

Final Non Access Modifiers:

Applicable to :

Class
Method
Instance Variable
Local Variable
Method arguments

Final Class :

Once Final non access modifier is applied to Class. Class can not be Extended by any other class.

Example: String Class in java.util package

Final Method :

Once Final non access modifier is applied to Method. That method can not be Overriden in subclass.
Example :

Final Variable :

Once Final non access modifier is applied to Variable. That variable’s value can not be Changed once assigned. Final variable are like constants.
Example : public static final int i = 10;

Abstract Non Access Modifier

Keyword: abstract

Applied to:

Class
Method

Abstract Class:

Abstract class can have(Not compulsary) abstract method. A class can also be an abstract class without having any abstract method in it. But once a class have an abstract method class becomes abstract class.

Abstract Method :

Abstract method are those methods which doesn’t have a body but only specification.
Example : public void method();
[cudazi_iconlist_icon icon='warning32.png' heading='There is no bracket in the end of method.' text='' link='#']

Synchronized Non Access Modifier

Applied to

Method(Only)

Synchronized Method

Synchronized method can be accessed by only one thread at a time.

Native Non Access Modifier

Applied to

Method(Only)

Native Method

Naive method indicates that a method is implemented in platform dependent code.

Strictfp Non Access Modifier

Applied to

Class
Method

Strictfp Class / Method

Strictfp non access modifier forces floating point or floating point operation to adhere to IEEE 754 standard.
Note*: Strictfp non access modifier can not be applied to variable.

Java Guide For All

Monday 25 February 2013

Access specifiers and Access modifiers in java

Java Access Specifiers/Modifier

Java Non Access Modifier

Final Non Access Modifiers:

Applicable to :

Final Class :

Example: String Class in java.util package

Final Method :

Final Variable :

Abstract Non Access Modifier

Keyword: abstract

Applied to:

Abstract Class:

Abstract Method :

Synchronized Non Access Modifier

Applied to

Synchronized Method

Native Non Access Modifier

Applied to

Native Method

Strictfp Non Access Modifier

Applied to

Strictfp Class / Method

0 comments:

Post a Comment

Connect

Search This Blog

Labels

Follow By Mail

About Me

Total Pageviews

Archive