Declarations and Access Control (2)

【 tulaoshi.com - 编程语言 】

Civilization
·igfxpers - igfxpers.exe - Process In
　　Objective 2
Declare classes, inner classes, methods, instance variables static, variables and automatic (method local) variables, making appropriate use of all permitted modifiers (such as public final static abstract and so forth). 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.
1. Two types of variables.
1.    Member variables
·    Accessible anywhere in the class.
·    Automatically initialized before invoking any constructor.
·    Static variables are initialized at class load time.
·    Can have the same name as the class.
2.    Automatic variables(method local)
·    Must be initialized explicitly. (compiler will catch it when using, but doesn’t catch it if no using) Object references can be initialized to null to make the compiler happy.
·    Can have the same name as a member variable, resolution is based on scope.
·    Can only be final.  Not other modifiers.

2.   Modifiers are Java keywords that provide information to compiler about the nature of the code, data and classes.   The visibility modifiers are part of the encapsulation mechanism for Java. Encapsulation allows separation of the interface from the implementation of methods.

3.  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. 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.
·    Only one outer class per file can be declared public.  If you declare more than one class in a file to be public, a compile time error will occur.
·    ‘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.

private à friendly (default) à protected à public

    Parent classes                     Sub-classes

4.  final
·    final classes cannot be sub-classed.
·    final variables cannot be changed.
·    final methods cannot be overridden.  Any methods in a final class are automatically final.   
·    Method arguments marked final are read-only. Compiler error, if trying to assign values to final arguments inside the method.
·    Final variables that are not assigned a value at the declaration and method arguments that are marked final are called blank final variables. Try to use blank final variables will give compile error.  They can only be assigned a value at most once in all constructor or initialized block.
·    Static final variables have to be assigned at the declaration time or in static initialized block.
·    Local variables can be declared final as well.

5.  abstract
·    Can be applied to classes and methods.
·    Opposite of final, abstract must be sub-classed.
·    A class should be declared abstract,
1.    if it has any abstract methods.
2.    if it doesn’t provide implementation to any of the abstract methods it inherited
3.    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.
·    Abstract methods may not be static, final, private, native, synchonized.
·    A class that is abstract may not be instantiated (ie, you may not call its constructor, but in subclass’s constructor, super() works)

6.  static
·    Can be applied to nested classes, methods, variables, free floating code-block (static initializer)
·    static means one per class, not one for each object no matter how many instance of a class might
exist. This means that you can use them without creating an instance of a class.
·    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 methods may not be overridden to be non-static.
·    Non-static methods may not be overridden to 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.

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 invok