Class access

In

Java, the access specifiers can also be used to determine which classes

a library will be available to the users of that library. If you want a class

to be available to a client programmer, you place the

keyword somewhere before the opening brace of the class body. This controls

whether the client programmer can even create an object of the class.

To

control the access of a class, the specifier must appear before the keyword

.

Thus

you can say:

That

is, if the name of your library is

any client programmer can access

by saying

or

However,

there’s an extra pair of constraints:

1. There
   can be only one
   public
   class per compilation unit (file). The idea is that each compilation unit has a
   single public interface represented by that public class. It can have as many
   supporting “friendly” classes as you want. If you have more than one
   public
   class inside a compilation unit, the compiler will give you an error message.
2. The
   name of the
   public
   class must exactly match the name of the file containing the compilation unit,
   including capitalization. So for
   Widget,
   the name of the file must be
   Widget.java,
   not
   widget.java
   or
   WIDGET.java.
   Again, you’ll get a compile-time error if they don’t agree.
3. It
   is possible, though not typical, to have a compilation unit with no public
   class at all. In this case, you can name the file whatever you like.

What

if you’ve got a class inside

that you’re

Note

that a class cannot be

(that

would make it accessible to no one but the class), or

.

So you have only two choices for class access: “friendly” or

.

If you don’t want anyone else to have access to that class, you can make

all the constructors

,

thereby preventing anyone but you, inside a

member of the class, from creating an object of that class.

Here’s an example:

//: Lunch.java
// Demonstrates class access specifiers.
// Make a class effectively private
// with private constructors:
 
class Soup {
  private Soup() {}
  // (1) Allow creation via static method:
  public static Soup makeSoup() {
    return new Soup();
  }
  // (2) Create a static object and
  // return a reference upon request.
  // (The "Singleton" pattern):
  private static Soup ps1 = new Soup();
  public static Soup access() {
    return ps1;
  }
  public void f() {}
}
 
class Sandwich { // Uses Lunch
  void f() { new Lunch(); }
}
 
// Only one public class allowed per file:
public class Lunch {
  void test() {
    // Can't do this! Private constructor:
    //! Soup priv1 = new Soup();
    Soup priv2 = Soup.makeSoup();
    Sandwich f1 = new Sandwich();
    Soup.access().f();
  }
} ///:~ 

Up

to now, most of the methods have been returning either

or a primitive type so the definition:

  public static Soup access() {
    return ps1;
  }

might

look a little confusing at first. The word before the method name (

)

tells what the method returns. So far this has most often been

which means it returns nothing. But you can also return a handle to an object,

which is what happens here. This method returns a handle to an object of class

.

The

shows how to prevent direct creation of a class by making all the constructors

.

Remember that if you don’t explicitly create at least one constructor,

the default constructor (a constructor with no arguments) will be created for

you. By writing the default constructor, it won’t be created

automatically. By making it

,

no one can create an object of that class. But now how does anyone use this

class? The above example shows two options. First, a

method is created that creates a new

and returns a handle to it. This could be useful if you want to do some extra

operations on the

before returning it, or if you want to keep count of how many

objects to create (perhaps to restrict their population).

The

second option uses what’s called a

As

previously mentioned, if you don’t put an access specifier for class

access it defaults to “friendly.” This means that an object of that

class can be created by any other class in the package, but not outside the

package. (Remember, all the files within the same directory that don’t

have explicit

declarations

are implicitly part of the default package for that directory.) However, if a

member of that class is

,

the client programmer can still access that

member even though they cannot create an object of that class.

Actually, a Java 1.1

can be private or protected, but that’s a special case. These will be

introduced in Chapter 7.

You can also do it by inheriting (Chapter 6) from that class.

|

|