Access Control

A piece of work isn’t good until it’s been rewritten, often many times.
Thus a primary consideration in object-oriented design is to “separate the things that change from the things that stay the same.”
Java provides access specifiers to allow the library creator to say what is available to the client programmer and what is not.
As a library designer, you’ll want to keep everything as “private” as possible, and expose only the methods that you want the client programmer to use.
How the components are bundled together into a cohesive library unit.
The access specifiers are affected by whether a class is in the same package or in a separate package.

package: the library unit

The reason for all this importing is to provide a mechanism to manage namespaces.
This potential clashing of names is why it’s important to have complete control over the namespaces in Java, and to create a unique identifier combination for each class.
Inside the compilation unit there can be a public class that must have the same name as the file.
There can be only one public class in each compilation unit.
Additional classes in that compilation unit comprise “support” classes for the main public class.

A working program is a bunch of .class files, which can be packaged and compressed into a Java ARchive (JAR) file. The Java interpreter is responsible for finding, loading, and interpreting these files.
Each source file usually has a public class and any number of non-public classes, so there’s one public component for each source file.

A logical thing to do is to place all the .class files for a particular package into a single directory.
By convention, the first part of the package name is the reversed Internet domain name of the creator of the class.
The second part of this trick is resolving the package name into a directory on your machine.
CLASSPATH contains one or more directories that are used as roots in a search for .class files.
The package statement must be the first non-comment code in the file.
You must put the actual name of the JAR file in the classpath, not just the path where it’s located.

You can use the single-class import form or fully specify the names to prevent clashes.

You can create your own libraries of tools to reduce or eliminate duplicate code.

The debugging features are enabled during development and disabled in the shipping product.
You can accomplish this by changing the package that’s imported in order to change the code used in your program from the debug version to the production version.

Unless you adhere to the package-name to directory-path rule, you’ll get a lot of mysterious runtime messages about not being able to find a particular class, even if that class is sitting there in the same directory.

The default access has no keyword, but it is commonly referred to as package access.
It means that all the other classes in the current package have access to that member, but to all the classes outside of this package, the member appears to be private.
All the classes within a single compilation unit are automatically available to each other via package access.
Package access allows you to group related classes together in a package so that they can easily interact with each other.
In many languages the way you organize your definitions in files can be arbitrary, but in Java you’re compelled to organize them in a sensible fashion.
The only way to grant access to a member is to:
1.Make the member public
2.Give the member package access and put the other classes in the same package.
3.Inherited class can access a protected member as well as a public member.
4.Provide “accessor/mutator” methods.

It means that the member declaration that immediately follows public is available to everyone.
Don’t make the mistake of thinking that Java will always look at the current directory as one of the starting points for searching.

The reason that they are available in Cake.java is because they are in the same directory and have no explicit package name.
Java treats files like this as implicitly part of the “default package” for that directory, and thus they provide package access to all the other files in that directory.

It means that no one can access that member except the class that contains that member, inside methods of that class.
private allows you to freely change that member without concern that it will affect another class in the same package.
It turns out that the consistent use of private is very important, especially where multithreading is concerned.
Making a method private guarantees that you retain this option.
A reference to an object is private inside a class doesn’t mean that some other object can’t have a public reference to the same object.

If you create a new package and inherit from a class in another package, the only members you have access to are the public members of the original package.
Sometimes the creator of the base class would like to take a particular member and grant access to derived classes but not the world in general.

Access control is often referred to as implementation hiding.
Access control puts boundaries within a data type for two important reasons: The first is to establish what the client programmers can and can’t use, the second is to separate the interface from the implementation.
Displaying the interface to the consumer of a class is really the job of the class browser

This controls whether the client programmer can even create an object of the class.
There can be only one public class per compilation unit.It can have as many supporting package-access classes as you want.
The name of the public class must exactly match the name of the file containing the compilation unit, including capitalization.
It is possible, though not typical, to have a compilation unit with no public class at all.
When you create a package-access class, it still makes sense to make the fields of the class private, but it’s generally reasonable to give the methods the same access as the class.
Note that a class cannot be private or protected(an inner class can be private or protected, but that’s a special case).
If you don’t want anyone else to have access to that class, you can make all the constructors private.
If you don’t put an access specifier for class access, it defaults to package access. This means that an object of that class can be created by any other class in the package, but not outside the package.
If a static member of that class is public, the client programmer can still access that static member even though they cannot create an object of that class.