site_logo

SCJP Java Programming Exam Cram Notes : Modifiers

  1. Java SCJP 6 Exam Download
  2. Java SCJP 6 Exam Details

3. Modifiers

1. Modifiers are Java keywords that provide information to compiler about the nature of the code, data and classes.

2. Access modifiers - public, protected, private

  • Only applied to class level variables. Method variables are visible only inside the method.
  • Can be applied to class itself (only to inner classes declared at class level, no such thing as protected or private top level class)
  • Can be applied to methods and constructors
  • If a class is accessible, it doesn't mean, the members are also accessible. Member's accessibility determines what is accessible and what is not. But if the class is not accessible, the members are not accessible, even though they are declared public.
  • If no access modifier is specified, then the accessibility is default package visibility. All classes in the same package can access the feature. It's called as friendly access. But friendly is not a Java keyword. Same directory is same package in Java's consideration.
  • 'private' means only the class can access it, not even sub-classes. So, it'll cause access denial to a sub-class's own variable/method.
  • These modifiers dictate, which classes can access the features. An instance of a class can access the private features of another instance of the same class.
  • 'protected' means all classes in the same package (like default) and sub-classes in any package can access the features. But a subclass in another package can access the protected members in the super-class via only the references of subclass or its subclasses. A subclass in the same package doesn't have this restriction. This ensures that classes from other packages are accessing only the members that are part of their inheritance hierarchy.
  • Methods cannot be overridden to be more private. Only the direction shown in following figure is permitted from parent classes to sub-classes.

3. final

  • final features cannot be changed.
  • final classes cannot be sub-classed.
  • final variables cannot be changed. (Either a value has to be specified at declaration or an assignment statement can appear only once).
  • final methods cannot be overridden.
  • Method arguments marked final are read-only. Compiler error, if trying to assign values to final arguments inside the method.
  • Member variables marked final are not initialized by default. They have to be explicitly assigned a value at declaration or in an initializer block. Static finals must be assigned to a value in a static initializer block, instance finals must be assigned a value in an instance initializer or in every constructor. Otherwise the compiler will complain.
  • Final variables that are not assigned a value at the declaration and method arguments that are marked final are called blank final variables. They can be assigned a value at most once.
  • Local variables can be declared final as well.

4. abstract

  • Can be applied to classes and methods.
  • For deferring implementation to sub-classes.
  • Opposite of final, final can't be sub-classed, abstract must be sub-classed.
  • A class should be declared abstract,
    • if it has any abstract methods.
    • if it doesn't provide implementation to any of the abstract methods it inherited
    • if it doesn't provide implementation to any of the methods in an interface that it says implementing.
  • Just terminate the abstract method signature with a ';', curly braces will give a compiler error.
  • A class can be abstract even if it doesn't have any abstract methods.

5. static

  • Can be applied to nested classes, methods, variables, free floating code-block (static initializer)
  • Static variables are initialized at class load time. A class has only one copy of these variables.
  • Static methods can access only static variables. (They have no this)
  • Access by class name is a recommended way to access static methods/variables.
  • Static initializer code is run at class load time.
  • Static methods may not be overridden to be non-static.
  • Non-static methods may not be overridden to be static.
  • Abstract methods may not be static.
  • Local variables cannot be declared as static.
  • Actually, static methods are not participating in the usual overriding mechanism of invoking the methods based on the class of the object at runtime. Static method binding is done at compile time, so the method to be invoked is determined by the type of reference variable rather than the actual type of the object it holds at runtime.
  • Let's say a sub-class has a static method which 'overrides' a static method in a parent class. If you have a reference variable of parent class type and you assign a child class object to that variable and invoke the static method, the method invoked will be the parent class method, not the child class method.

The following code explains this.

public class StaticOverridingTest {

public static void main(String s[]) {
Child c = new Child();

c.doStuff(); // This will invoke Child.doStuff()

Parent p = new Parent();

p.doStuff(); // This will invoke Parent.doStuff()

p = c;

p.doStuff(); // This will invoke Parent.doStuff(), rather than Child.doStuff() 

}

}

class Parent {

static int x = 100;

public static void doStuff() {

System.out.println("In Parent..doStuff");

System.out.println(x);

}

}

class Child extends Parent {

static int x = 200;

public static void doStuff() {

System.out.println("In Child..doStuff");

System.out.println(x);

}

}

6. native

  • Can be applied to methods only. (static methods also)
  • Written in a non-Java language, compiled for a single machine target type.
  • Java classes use lot of native methods for performance and for accessing hardware Java is not aware of.
  • Native method signature should be terminated by a ';', curly braces will provide a compiler error.
  • native doesn't affect access qualifiers. Native methods can be private.
  • Can pass/return Java objects from native methods.
  • System.loadLibrary is used in static initializer code to load native libraries. If the library is not loaded when the static method is called, an UnsatisfiedLinkError is thrown.

7. transient

  • Can be applied to class level variables only.(Local variables cannot be declared transient)
  • Transient variables may not be final or static.(But compiler allows the declaration, since it doesn't do any harm. Variables marked transient are never serialized. Static variables are not serialized anyway.)
  • Not stored as part of object's persistent state, i.e. not written out during serialization.
  • Can be used for security.

8. synchronized

  • Can be used for security.
  • Used to control access to critical code in multi-threaded programs.

9. volatile

  • Can be applied to variables only.
  • Can be applied to static variables.
  • Cannot be applied to final variables.
  • Declaring a variable volatile indicates that it might be modified asynchronously, so that all threads will get the correct value of the variable.
  • Used in multi-processor environments.
Modifier Class Inner classes (Except local and anonymous classes) Variable Method Constructor Free floating Code block
public Y Y Y Y Y N
protected N Y Y Y Y N
(friendly)

No access modifier

 Y Y (OK for all) Y Y Y N
private N Y Y Y Y N
final Y Y (Except anonymous classes) Y Y N N
abstract Y Y (Except anonymous classes) N Y N N
static N Y Y Y N Y (static initializer)
native N N N Y N N
transient N N Y N N N
synchronized N N N Y N Y (part of method, also need to specify an object on which a lock should be obtained)
volatile N N Y N N N

Previous    Contents    Next


certexams ad

simulationexams ad
  1. Java SCJP 6 Exam Download
  2. Java SCJP 6 Exam Details

Disclaimer: examguides.com is neither associated nor affiliated with CompTIA® or any other company. A+, Network+, Server+, Security+ are trademarks of CompTIA® and duly acknowledged. The Exam Cram notes material is a copyright of examguides.com and the same is not approved or endorsed by respective certifying bodies.