Names

CS 884 (Prasad) Java Names 1

Names

Scope and Visibility

Access Control

Packages


Declaration

• A declaration introduces an entity into a Java program and includes an identifier that can be used in a name.

• A name is used to refer to an entity declared in a Java program.– Simple Name (identifier)– Qualified Name (period-separated sequence of identifiers)


Declarations/Definitions• package definition (e.g., package one;)

• single-type import declarationsingle-type import declaration (e.g., import java.io.File;)

• type-import-on-demand declarationtype-import-on-demand declaration (e.g., import java.io.*;)

• class definition (e.g., class Point { };)

• interface definition (e.g., interface Colorable { };)

• field definition (e.g., int x_coord;)

• method definition (e.g., int distance (Point pt) {}; )

• formal parameter definitionformal parameter definition (e.g., catch (Exception e) {};)

• local variable definition (e.g., int iterations = 0;)


Scope of a declaration• Region of program text within which the declared

entity can be referred to using simple name.

– scope of package is host system dependent.

– scope of imported types is the compilation unit.

– scope of class/interface types is the package.

– scope of fields/methods is the entire class/interface. • The declaration must precede use in a field initialization expression.

– scope of parameters/local vars is the rest of the block. • “int i = (i = 3) + 2 ;” is legal.


• Ordering of declarations is immaterial except for initialization context

class C {

f() {g();}

g() {f();}

int i;

int j = i;

}

• Name conflicts due to multiple inheritance of interfaces?

class C

implements I, J {

. . . }

interface I {

int i;

}

interface J {

int i;

}


• Lexical nesting of scopes

class C {

int i;

int f(int i) {

return this.i + i;

}

}

• Static nesting of scopes

class B extends A {

static int i;

int j;

}

class C extends B {

int i;

void f(){

i = B.i + j;

}

}


Resolving Names• Scopes can overlap. (Same name for different entities.)

• To disambiguate a name:– Use contextual information to determine if name

refers to a package, a type, a method, a label, a variable (field/local/formal) etc.

– Use signature to resolve method names.

– Within nested scopes, type names, variable names & method names resolved by shadowing, hiding, or overriding.

• Otherwise, “Ambiguity error”.

• Possible remedy: use fully qualified name.


“Name in Context”

The meaning of a name depends on the context of its use. (This permits certain kinds of “multiple definitions”.)

package Reuse;

class Reuse {

Reuse Reuse Reuse(Reuse Reuse) {

Reuse : for (;;) {

if (Reuse . Reuse (Reuse) == Reuse)

break Reuse;

}

return Reuse;

}

}


Members (Cf. Namespaces)• Package

– sub-package, class, interface• every member of a package has a unique name.

• Class type– fields and (non-constructor) methods, declared or inherited

• hiding, overriding, overloading

• Interface type– constants and method signatures, declared or (multiply)

inherited • ambiguity resolved using qualified names

• Array type– length, plus those inherited from class Object


Syntactic Classification of Names• Method/Constructor name

• Integer.parseInt(“15”)• new StreamTokenizer(inFile)

• Package name• package abc.pqr;• import java.io.*;• import java.applet.Applet;

• Type name • class SquarePanel extends java.awt.Button {}


Syntactic Classification of Names

• Expression name – int i = argv[0] + j++;

• Ambiguous name – Local.field = Package.Package.Class.field;

– Parameter.field.field = Class. method() + Local.method(1,2);

An ambiguous name is reclassified as package / type / package / type / expressionexpression name. Reclassification uses declarations and additional scoping rules. In Java 1.0, it implicitly assumed that classes cannot be nested.


Resolving Simple Names by Ordering Namespaces

• Local variables in a code block, for loop, or the parameters to an exception handler.

• Parameters to method or constructor.• Fields of enclosing class or interface.• Class or interface types in the compilation unit.• Explicitly named imported types in the compilation unit.• Other class or interface types in the other compilation

units of the same package.• Implicitly named imported types in the compilation unit.• Packages available on the host system.


Additional Constraints• Interpretation of keywords static and final

as applied to classes, fields, and methods.

• See name resolution for class members.

• Disallow hiding of local variables by for loop parameter. However, allow non-overlapping for loops to have same loop parameter.


Access Control

Access control is different from scope; it specifies the part of the program text within which the declared entity can be referred to by a qualified name.

In the context of classes, it applies to access to class members by qualified names, in subclasses, and to the constructor invocation.


(cont.)

• Class / Interface type • public : wherever the package is accessible.

• default : local to the package.

• Members of Reference type

• public : wherever the type is accessible.

• protected : accessible in the package, class and its subclasses

• default : accessible in the package

• private : accessible in the class


Access to private members

• Private members of an object are accessible to other objects of the same class.

Objects are not “shielded” from each other. “Privacy is only class deep.”

complex plus (complex c) { c . real = this . real + c . real ; c . imag = this . imag + c . imag ; return c ; }


Default Access to members

package points;

public class Point {public int x, y;void move(int dx, int dy) {

x += dx; y += dy; }public void moveAlso(int dx, int dy) {

move(dx, dy); }}


package morepoints;

public class PlusPoint extends points.Point {public void move(int dx, int dy) {//super.move(dx, dy); // compile-time error

moveAlso(dx, dy);}

}

• move in class Point is not accessible outside package points. So super.move(…) is illegal. (No question of overriding move in PlusPoint.)

• Invoking moveAlso on PlusPoint instance invokes move in package Points (and not that in PlusPoints). (No dynamic binding and infinite loop).


private Method: Accessibility and Overriding

• A method can be overridden only if it is accessible.– A private method of a class cannot be

overridden in a subclass.– A private method is not accessible outside its

own class, so an invocation of a private method always invokes the same implementation. (cf. dynamic binding)


• The protected members of a subclass object (defined in another package) are not accessible in the superclass.

public class Point { protected int x, y; int dummy (threePoint.Point3D p) { return p.x + p.z ; // one compile-time error } } package threePoint; public class Point3D extends Point { protected int z; }

Access to protected members


Access to protected members• The protected members of a class are accessible to the code in a

subclass (outside the package) only when the members belong to the subclass object being implemented.

package threePoint; public class Point3D extends Point { protected int z; public void delta (Point p) { p.x += this.x ; p.y += this.y; // compile-time

errors } public void delta3D (Point3D p) { p.x += this.x ; p.y += this.y; p.z += this.z; } }


Motivating protected Restriction

• The protected members of a class are accessible to the code in a subclass (outside the package) only when the members belong to the subclass object being implemented.

• Otherwise:

class Secret { // in: package A; protected int i;}class Sneaky extends Secret {// in: package B; public int violateProtection (Secret s) { return (s.i); // compile-time error }}


class S extends C { public int i; protected int j; private int k; int p(C c) { return c.x ; // + c.y + c.z ; } int q(S s) { return s.x + s.y + // s.z + s.i + s.j + s.k ;

}}

class C { public int x; protected int y; private int z; int p(C c) { return c.x + c.y + c.z ; } int q(S s) { return s.x + s.y // + s.z + s.i ; // + s.j + s.k ;

}}

private, protected, public (diff package)


Access control : super• The protected constructors of a class are

accessible to a subclass (outside the package) through the use of super in a constructor definition, but not in a class instantiation expression.

• The protected methods of a class are accessible to a subclass (outside the package) using its name when it is inherited, or using super (in method definitions) when it is overridden.


Packages

• Java Program : set of packages.• Package : set of compilation units.• Package Members: sub-packages and types.• Compilation unit with no package

declaration is part of unnamed package.

• There is no special access relationship between a package and a sub-package.


Importing into Compilation Unit• Implicit import java.lang.* ; in all packages.

• Types, but not sub-packages, may be imported. • import java.io ; is illegal.

• Types-imported-on-demand may be hidden by explicit type definitions and single-type-import declarations.

• A public type in a package is exported.


Packages to UNIX File System• (Sub) Packages are mapped to (sub) directories.

• p.q. ... to p/q/ ...• The names of Java source file and the

corresponding bytecode file for public class C are required to be C.java and C.class resp.

• The environment variable CLASSPATH contains path to each top-level package (roots of forest of trees).

• Each subdirectory can contain an unnamed package. However, only the one associated with the CurrentWorkingDirectory is available.


CLASSPATH

= (Sub-)Package

= Compilation Unit


Further Updates

• Java 1.1: Nested and Inner classes

• Java 5: Importing static fields, Enumerated types

• Java 5: Overload resolution : Varargs, Co-variant types

Documents

Names