First, to assuage any fears, the code you've provided is perfectly valid Java syntax.
In effect, you've created a class that can only be instantiated/used by other classes in the default package. It would also work if you defined it in a package (e.g. package foo;
) since only the classes in package foo
could see this class).
Now, to the crux of the question.
There are different ways to control access to fields and members. and they each do different things.
private
visibility is the least visible. Only the defining class can access the field.
No modifier, or package private
is the second least visible. The defining class and all classes within the package may access the field, but subclasses and the rest of the world cannot.
protected
is the second most visible. Only other classes are prohibited from accessing the field.
public
is the most visible. Everything can access the field.
Modifiers at the level of the class get interesting. This comes from the Java Language Specification, §8.1.1:
The access modifier public
(§6.6) pertains only to top level classes
(§7.6) and to member classes (§8.5), not to local classes (§14.3) or
anonymous classes (§15.9.5).
The access modifiers protected
and private
(§6.6) pertain only to
member classes within a directly enclosing class or enum declaration
(§8.5).
The modifier static pertains only to member classes (§8.5.1), not to
top level or local or anonymous classes.
It is a compile-time error if the same modifier appears more than once
in a class declaration.
If two or more (distinct) class modifiers appear in a class
declaration, then it is customary, though not required, that they
appear in the order consistent with that shown above in the production
for ClassModifier
.
In general, a class declaration appears something like this:
ClassDeclaration:
NormalClassDeclaration
EnumDeclaration
NormalClassDeclaration:
ClassModifiers(opt) class Identifier TypeParameters(opt)
Super(opt) Interfaces(opt) ClassBody
Anything with (opt) is considered optional.
So, what does this pare down to?
- The JLS mandates that a class does not need a [class] modifier.
- The JLS mandates that, if a [class] modifier is present, then it follows one of these rules:
- If the modifier is
public
, then it is only applicable to top level classes and member classes.
- If the modifier is
protected
or private
, then it is only applicable to member classes within a directly enclosing class or enumeration.
- The
static
modifier may appear, but is only applicable to member classes.
Constructors have a similar rule set.
ConstructorDeclaration:
ConstructorModifiers(opt) ConstructorDeclarator
Throws(opt) ConstructorBody
ConstructorDeclarator:
TypeParameters(opt) SimpleTypeName ( FormalParameterList(opt) )
Again, this breaks down to:
- The JLS mandates that a constructor does not need a [constructor] modifier.
- The JLS mandates that a constructor modifier cannot contain
abstract
, static
, final
, native
, strictfp
, or synchronized
.
- The JLS mandates, if no access modifier is specified for the constructor of a normal class, the constructor has default access (§8.8.3, emphasis mine).