Java Access Specifier

Java/J2EE Programming Training
Access Specifier

Classification: Restricted
Agenda
• Declarations and Access Control
• Class Modifiers
• Access Modifiers for Members
• Non-Access Modifiers for Members
• More Member Modifiers
• Modifiers for Inner Classes
• Class Declarations
• Interface Declarations
• Implementing an Interface
• main() Method
• Extra points to remember

Declarations and Access
Control

Objective
• Declare classes, nested classes, methods, instance variables, static variables
and automatic (method local) variables making appropriate use of all
permitted modifiers (such as public, final, static, abstract, etc.). State the
significance of each of these modifiers both singly and in combination and
state the effect of package relationships on declared items qualified by
these modifiers.

Objective
•Identify correctly constructed package declarations, import
statements, class declarations (of all forms including inner
classes) interface declarations, method declarations (including
the main method that is used to start execution of a class),
variable declarations, and identifiers.
•Identify classes that correctly implement an interface where
that interface is either java.lang.Runnable or a fully specified
interface in the question

Class Modifiers
• Access Modifiers for Classes
Top level classes and interfaces can be specified as public. If no access
modifier is specified, the access level is default access
• Other Modifiers for Classes
abstract – The class cannot be instantiated
final - The class cannot be extended ie; it cannot be subclassed

Access Modifiers for Members
• private - can only be accessed from inside the class.
• protected - can only be accessed by classes in the same package or
subclasses of this class
• public - can be accessed by any other class.
• If there is no access modifier specified- the members have default access
level ie; they can be accessed only by other classes in the same package

Non-Access Modifiers for Members
• synchronized – only for methods. Can be accessed only by one thread at a
time.
• transient – only for variables. Cannot be serialized.
• abstract – only for methods. Method is not implemented. Has to be
implemented by the first concrete subclass
• final – For methods, it means that the method cannot be inherited. For
variables, it makes the variable a constant.

More Member Modifiers
• native – only for methods, means that the method is not written in Java,
but in a native language.
• strictfp – only for methods and classes. Forces floating points to adhere to
IEE754 standard.
• volatile – only for variables. The compiler will not perform optimization on
the variables if this is specified.
• static – for variables and methods. Static variables are shared by all
instances of the class. Static methods and variables can be used without
having any instances of that class at all.

Modifiers for Inner Classes
• Modifiers which can be applied to non-static inner classes are final,
abstract, public and protected.
• A non-static inner class has access to all member variables and methods of
the containing class.
• The only modifiers which can be applied to method local inner classes are
abstract and final
• Static nested classes are inner classes marked with the static modifier

Class Declarations
• In a source file, there can be only one public class, and name of the file
should match that of the class
• Import and package declarations apply to all the classes in a source code
file
• Eg:
public class MyClass
{}

Package Declarations
• If there is no package statement, the classes in the source file belong to the
default package, else they belong to the named package
• If there is a package statement, it should be the first line in the source file.
• Not more than one package statement is allowed in a source file
Eg:
package com.whiz.test;
class TestQuiz {}

Import Statements
• Any import statements must be placed after the package statement, but
before the class declaration
• Import statements can be of 2 types – wildcard import and explicit class
import
eg:
import java.util.*;
// wildcard import - imports all classes in java.util package
import java.util.ArrayList;
// explicit import- imports ArrayList class in java.util package

Determining Access to Class Members
Visibility public protected default private
From the same class Yes Yes Yes Yes
From any class in the same package Yes Yes Yes No
From any non-subclass class
outside the package
Yes No No No
From a subclass in the same
package
Yes Yes Yes No
From a subclass outside the same
package
Yes Yes No No

Interface Declarations
• An interface is like a fully abstract class, it is implicitly public and abstract
• Variables declared in an interface are implicitly public, static and final
• Interface methods are implicitly public, cannot be static
• A class can implement any number of interfaces
• An interface can extend any number of interfaces
Eg:
interface MyInterface{
void f();
}

Implementing an Interface
• A concrete class implementing an interface has to implement all the
methods declared in it
• The implemented method should not throw any new checked exception
not thrown by the interface method
• Interface methods are implicitly public, so cannot be overridden to be of
private, protected or default access
Eg:
interface MyInterface { void f(); }
class MyClass implements MyInterface{
public void f() {}
}
• The implemented method should maintain the exact signature and
return types of the interface method

main() Method
• The main() method must be public and static
• The return type of the main() method should be void
• It should take only one argument, which should be an array of String
objects(name of the argument can be anything)
• The modifiers static and public can be in any order
Eg:
public static void main(String args[]) // Valid
{ }
static public void main(String abc[]) // Valid
{ }

Extra points to remember
• A class or method cannot be both final and abstract
• A class with public modifier can be seen by classes in every package, else
it can be seen only by classes in the same package
• A class can be declared abstract even if it has no abstract methods, but it
has to be declared abstract if at least one of it methods is abstract
• The only modifier available for local variables is final
• Abstract methods cannot be private, final, synchronized, strictfp or
native

Extra points to Remember…continued
• Final reference variables cannot refer to a different object, once they are
assigned to an object
• Abstract methods have no body, they end in a semicolon
• Protected members can be accessed by classes in the same package and
by subclasses anywhere
• A static method cannot access non-static variables
• A method local inner class cannot use the method’s local variables,
unless they are final
• A static nested class cannot access nonstatic members of the enclosing
class
• Static methods cannot be overridden

Thank You

Java Access Specifier

More Related Content

What's hot (19)

Similar to Java Access Specifier (20)

More from DeeptiJava (9)

Recently uploaded (20)

Java Access Specifier