Scribd
Upload
51 views

Access Modifiers in Java

The document discusses access modifiers in Java. It describes the four main types of access modifiers - private, default, protected, and public - and explains what access level each provides. Private access is only within the class, default is within the package, protected is within the package and subclasses outside the package, and public is unrestricted access. The document provides examples to illustrate the scope of each access modifier.

Uploaded by

avav
Copyright
© © All Rights Reserved
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
51 views

Access Modifiers in Java

The document discusses access modifiers in Java. It describes the four main types of access modifiers - private, default, protected, and public - and explains what access level each provides. Private access is only within the class, default is within the package, protected is within the package and subclasses outside the package, and public is unrestricted access. The document provides examples to illustrate the scope of each access modifier.

Uploaded by

avav
Copyright
© © All Rights Reserved
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
You are on page 1/ 28

Access Modifiers in Java

• The access modifiers in Java specifies the


accessibility or scope of a field, method,
constructor, or class.

• Access modifiers

• Non-access modifiers.
Types of Java access modifiers
• Private: The access level of a private modifier
is only within the class. It cannot be accessed
from outside the class.
• 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.
• 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.
• 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.
Access within class within package outside outside
Modifier package by package
subclass only

Private Y N N N

Default Y Y N N

Protected Y Y Y N

Public Y Y Y Y
Private

• The private access modifier is accessible only


within the class.
• 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(){System.out.println("Hello java");}  
• }  
•   
• public class Simple{  
•  public static void main(String args[]){  
•    A obj=new A();  
•    System.out.println(obj.data); //Compile Time Error  
•    obj.msg(); //Compile Time Error  
•    }  
• }  
• If you make any class constructor private, you
cannot create the instance of that class from
outside the class.
• class A{  
• private A(){} //private constructor  
• void msg() {System.out.println("Hello java");}  
• }  
• public class Simple{  
•  public static void main(String args[]){  
•    A obj=new A(); //Compile Time Error  
•  }  
• }  
A class cannot be private or
protected except nested class.
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

• //save by A.java  
• package pack;  
• class A{  
•   void msg(){System.out.println("Hello");}  
• }  
• //save by B.java  
• package mypack;  
• import pack.*;  
• class B{  
•   public static void main(String args[]){  
•    A obj = new A(); //Compile Time Error  
•    obj.msg();// 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.
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
•  Here 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 B.java  
//save by A.java   package mypack;  
package pack;   import pack.*;  
public class A{     
protected void msg() class B extends A{  
{System.out.println("Hello public static void main(Strin
"); g args[]){  
}   B obj = new B();  
}    obj.msg();  
  }  
}  
Public

• The public access modifier is accessible


everywhere. It has the widest scope among all
other modifiers.
Example of public access modifier
• //save by A.java  
•   
• package pack;  
• public class A{  
• public void msg()
{System.out.println("Hello");}  
• }  
Cont…
• //save by B.java  
•   
• package mypack;  
• import pack.*;  
•   
• class B{  
•   public static void main(String args[]){  
•    A obj = new A();  
•    obj.msg();  
•   }  
• }  
• The modifiers which are applicable for inner
classes but not for outer classes : Private ,
Protected and static.

• The only modifiers which are applicable for


constructors are : Public , Private , Protected
and Default.
Controlling Access to Methods
• Let's begin with the most restrictive access
level--private. Only the class in which a private
method is defined can call that method. To
declare a private method, use the
keyword private. For example, the following
class defines one private method within it:
Private
• class Alpha {
• private void iamprivate()
• {
• System.out.println("iamprivate");
• }
• }
• class Beta {
• void accessMethod()
• {
• Alpha a = new Alpha();
• a.iamprivate(); // illegal
• }
• }
• Objects of type Alpha can call
the iamprivate() method, but objects of other
types cannot.
• For example, the following class, regardless of
which package it is in or its parentage, cannot
call the iamprivate() method within the Alpha
class.
Private Protected

• The next most restrictive access specified is


private protected. This access level includes
the private access level plus allows any of the
class's subclasses to call the method.
• To declare a private protected method, use
the keywords private protected in the method
declaration.
• class Alpha {
• private protected void iamprivateprotected()
{ System.out.println("iamprivateprotected");
• }
• }
• Objects of type Alpha can call
the iamprivateprotected() method. In addition,
subclasses of Alpha also have access
to iamprivateprotected(). For instance, this subclass
of Alpha, Beta, can call
the iamprivateprotected() method of an Alpha object.
• class Beta extends Alpha {
• void modifyVariable(Alpha a)
• {
• a.iamprivateprotected(); // legal
• }
• }

You might also like