public
, then it may be accessed by any Java code that can access the package in which it is declared. If a class or interface type is not declared public
, then it may be accessed only from within the package in which it is declared.public
, then access is permitted. All members of interfaces are implicitly public
.protected
, then access is permitted only when one of the following is true:
private
, then access is permitted only when it occurs from within the class in which it is declared.protected
AccessA protected
member or constructor of an object may be accessed from outside the package in which it is declared only by code that is responsible for the implementation of that object. Let C be the class in which a protected
member or constructor is declared and let S be the subclass of C in whose declaration the use of the protected
member or constructor occurs. Then:
protected
member (field or method), let Id be its name. Consider then the means of qualified access:
super.
Id, then the access is permitted..
Id, where Q is a TypeName, then the access is permitted if and only if Q is S or a subclass of S..
Id, where Q is an ExpressionName, then the access is permitted if and only if the type of the expression Q is S or a subclass of S..
Id, where E is a Primary expression, or by a method invocation expression E.
Id(
. . .)
, where E is a Primary expression, then the access is permitted if and only if the type of E is S or a subclass of S.protected
constructor:
super(
. . .)
, then the access is permitted.new
T(
. . .)
, then the access is not permitted. (A protected
constructor can be accessed by a class instance creation expression only from within the package in which it is defined.) newInstance
of class Class
(§20.3.6), then the access is not permitted.public
and Non-public
ClassesIf a class lacks the public
modifier, access to the class declaration is limited to the package in which it is declared (§6.6). In the example:
package points;
public class Point { public int x, y; public void move(int dx, int dy) { x += dx; y += dy; } }
class PointList { Point next, prev; }
two classes are declared in the compilation unit. The class Point
is available outside the package points
, while the class PointList
is available for access only within the package. Thus a compilation unit in another package can access points.Point
, either by using its fully qualified name:
package pointsUser;
class Test { public static void main(String[] args) { points.Point p = new points.Point(); System.out.println(p.x + " " + p.y); } }
or by using a single-type-import declaration (§7.5.1) that mentions the fully qualfied name, so that the simple name may be used thereafter:
package pointsUser;
import points.Point;
class Test { public static void main(String[] args) { Point p = new Point(); System.out.println(p.x + " " + p.y); } }
However, this compilation unit cannot use or import points.PointList
, which is not declared public
and is therefore inaccessible outside package points
.
If none of the access modifiers public
, protected
, or private
are specified, a class member or constructor is accessible throughout the package that contains the declaration of the class in which the class member is declared, but the class member or constructor is not accessible in any other package. If a public
class has a method or constructor with default access, then this method or constructor is not accessible to or inherited by a subclass declared outside this package.
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); } }
then a subclass in another package may declare an unrelated move
method, with the same signature (§8.4.2) and return type. Because the original move
method is not accessible from package morepoints
, super
may not be used:
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); } }
Because move of Point
is not overridden by move
in PlusPoint
, the method moveAlso
in Point
never calls the method move in PlusPoint
.
Thus if you delete the super.move
call from PlusPoint
and execute the test program:
import points.Point; import morepoints.PlusPoint; class Test { public static void main(String[] args) { PlusPoint pp = new PlusPoint(); pp.move(1, 1); }
}
it terminates normally. If move of Point
were overridden by move
in PlusPoint
, then this program would recurse infinitely, until a StackoverflowError
occurred.
protected
Fields, Methods, and ConstructorsConsider this example, where the point
package declares:
package points;
public class Point {
protected int x, y;
void warp(threePoint.Point3d a) { if (a.z > 0) // compile-time error: cannot access a.z a.delta(this); }
}
and the threePoint
package declares:
package threePoint;
import points.Point;
public class Point3d extends Point {
protected int z;
public void delta(Point p) { p.x += this.x; // compile-time error: cannot access p.x p.y += this.y; // compile-time error: cannot access p.y }
public void delta3d(Point3d q) { q.x += this.x; q.y += this.y; q.z += this.z; }
}
which defines a class Point3d
. A compile-time error occurs in the method delta
here: it cannot access the protected members x
and y
of its parameter p
, because while Point3d
(the class in which the references to fields x
and y
occur) is a subclass of Point
(the class in which x
and y
are declared), it is not involved in the implementation of a Point
(the type of the parameter p
). The method delta3d
can access the protected members of its parameter q
, because the class Point3d
is a subclass of Point
and is involved in the implementation of a Point3d
.
The method delta
could try to cast (§5.4, §15.15) its parameter to be a Point3d
, but this cast would fail, causing an exception, if the class of p
at run time were not Point3d
.
A compile-time error also occurs in the method warp: it cannot access the protected member z
of its parameter a
, because while the class Point
(the class in which the reference to field z
occurs) is involved in the implementation of a Point
(the type of the parameter a), it is not a subclass of Point
(the class in which z
is declared).