http://www.javaworld.com/article/2979739/learn-java/java-101-classes-and-objects-in-java.html?page=3
class Book
{
// ...
static int count;
}
This example declares a count integer field that stores the number of Book objects created. The declaration begins with the static keyword to indicate that there is only one copy of this field in memory. Each Book object can access this copy, and no object has its own copy. For this reason, count is known as a class field.
The previous fields were not assigned values. When you don't explicitly initialize a field, it's implicitly initialized with all of its bits set to zero. You interpret this default value as false (for boolean), '\u0000' (for char), 0 (for int), 0L (for long), 0.0F (for float), 0.0 (for double), or null (for a reference type).
class Book
{
// ...
static void showCount()
{
System.out.println("count = " + count);
}
}
This example declares a showCount() method that will output the value of the count field. The declaration begins with the static keyword to indicate that this method belongs to the class and cannot access individual object state; no objects need to be created. For this reason, showCount() is known as a class method.
Method overloading
Java lets you declare methods with the same name but with different parameter lists in the same class. This feature is known as method overloading. When the compiler encounters a method-call expression, it compares the called method's comma-separated list of arguments with each overloaded method's parameter list as it looks for the correct method to call.
Two same-named methods are overloaded when their parameter lists differ in number or order of parameters. Alternatively, two same-named methods are overloaded when at least one parameter differs in type. For example, consider the following four draw() methods, which draw a shape or string at the current or specified draw position:
void draw(Shape shape)
{
// drawing code
}
void draw(Shape shape, double x, double y)
{
// drawing code
}
void draw(String string)
{
// drawing code
}
void draw(String string, double x, double y)
{
// drawing code
}
When the compiler encounters draw("abc");, it will select the third method because it offers a matching parameter list. However, what will the compiler do when it encounters draw(null, 10, 20);? It will report a "reference to draw is ambiguous" error message because there are two methods from which to choose.
You cannot overload a method by changing only the return type. For example, you couldn't specify int add(int x, int y) and double add(int x, int y) because the compiler doesn't have enough information to distinguish between these methods when it encounters add(4, 5); in source code. The compiler would report a "redefinition" error.
Constructors: Initializing objects
As well as explicitly assigning values to fields, a class can declare one or more blocks of code for more extensive object initialization. Each code block is a constructor. Its declaration consists of a header followed by a brace-delimited body. The header consists of a class name (a constructor doesn't have its own name) followed by an optional parameter list:
className ( [parameterList] )
{
// constructor body
}
The following example declares a constructor in the Book class. The constructor initializes a Book object's title and pubYear fields to the arguments that were passed to the constructor's _title and _pubYear parameters when the object was created. The constructor also increments the count class field:
class Book
{
// ...
Book(String _title, int _pubYear)
{
title = _title;
pubYear = _pubYear;
++count;
}
// ...
}
The parameter names have leading underscores to prevent a problem with the assignments. For example, if you renamed _title to title and specified title = title;, you would have merely assigned the parameter's value to the parameter, which accomplishes nothing. However, you can avoid this problem by prefixing the field names with this.:
class Book
{
// ...
Book(String title, int pubYear)
{
this.title = title;
this.pubYear = pubYear;
++count;
}
// ...
void setTitle(String title)
{
this.title = title;
}
void setPubYear(int pubYear)
{
this.pubYear = pubYear;
}
// ...
}
A parameter (or local variable) name that's identical to an instance field name shadows (meaning hides or masks) the field. Keyword this represents the current object (actually, its reference). Prepending this. to the field name removes the shadowing by accessing the field name instead of the same-named parameter.
Although you can initialize fields such as title and pubYear through the assignments shown above, it's preferable to perform the assignments via setter methods such as setTitle() and setPubYear(), as demonstrated below:
class Book
{
// ...
Book(String title, int pubYear)
{
setTitle(title);
setPubYear(pubYear);
++count;
}
// ...
}
Constructor calling
Classes can declare multiple constructors. For example, consider a Book constructor that accepts a title argument only and sets the publication year to -1 to indicate that the year of publication is unknown. This extra constructor along with the original constructor are shown below:
class Book
{
// ...
Book(String title)
{
setTitle(title);
setPubYear(-1);
++count;
}
Book(String title, int pubYear)
{
setTitle(title);
setPubYear(pubYear);
++count;
}
// ...
}
But there is a problem with this new constructor: it duplicates code setTitle(title); located in the existing constructor. Duplicate code adds unnecessary bulk to the class. Java provides a way to avoid this duplication by offering this() syntax for having one constructor call another:
class Book
{
// ...
Book(String title)
{
this(title, -1);
// Do not include ++count; here because it already
// executes in the second constructor and would
// execute here after this() returns. You would end
// up with one extra book in the count.
}
Book(String title, int pubYear)
{
setTitle(title);
setPubYear(pubYear);
++count;
}
// ...
}
The first constructor uses keyword this followed by a bracketed argument list to call the second constructor. The single parameter value is passed unchanged as the first argument, and -1 is passed as the second argument. When using this(), remember that it must be the first piece of code in a constructor; otherwise, the compiler reports an error.
Objects: Working with class instances
Once you have declared a class, you can create objects from it. An object is nothing more than a class instance. For example, now that the Book class has been declared, you can create one or more Book objects. Accomplish this task by specifying the new operator followed by a Book constructor, as follows:
Book book = new Book("A Tale of Two Cities", 1859);
new loads Book into memory and then calls its constructor with arguments "A Tale of Two Cities" and 1859. The object is initialized to these values. When the constructor returns from its execution, new returns a reference (some kind of pointer to an object) to the newly initialized Book object. This reference is then assigned to the book variable.
Constructor return type
If you were wondering why a constructor doesn't have a return type, the answer is that there is no way to return a constructor value. After all, the new operator is already returning a reference to the newly-created object.
After creating a Book object, you can call its getTitle() and getPubYear() methods to return the instance field values. Also, you can call setTitle() and setPubYear() to set new values. In either case, you use the member access operator (.) with the Book reference to accomplish this task:
System.out.println(book.getTitle()); // Output: A Tale of Two Cities
System.out.println(book.getPubYear()); // Output: 1859
book.setTitle("Moby Dick");
book.setPubYear(1851);
System.out.println(book.getTitle()); // Output: Moby Dick
System.out.println(book.getPubYear()); // Output: 1851
Messaging objects
Calling a method on an object is equivalent to sending a message to the object. The name of the method and its arguments are conceptualized as a message that is being sent to the object on which the method is called.
You don't have to create any Book objects to call class methods. Instead, you prepend the class name and member access operator to the class method's name when calling these methods:
Book.showCount(); // Output: count = 1
Finally, it's possible to get and set the values of Book's instance and class fields. Use an object reference to access an instance field and a class name to access a class field:
System.out.println(book.title); // Output: Moby Dick
System.out.println(Book.count); // Output: 1
book.pubYear = 2015;
System.out.println(book.pubYear); // Output: 2015
I previously mentioned that instance methods affect only the objects on which they are called; they don't affect other objects. The following example reinforces this truth by creating two Book objects and then accessing each object's title, which is subsequently output:
Book book1 = new Book("A Tale of Two Cities", 1859);
Book book2 = new Book("Moby Dick", 1851);
Book book3 = new Book("Unknown");
System.out.println(book1.getTitle()); // Output: A Tale of Two Cities
System.out.println(book2.getTitle()); // Output: Moby Dick
System.out.println(book3.getPubYear()); // Output: -1
Book.showCount(); // Output: count = 3
Information hiding and access levels
A class's body is composed of interface and implementation. The interface is that part of the class that's accessible to code located outside of the class. The implementation is that part of the class that exists to support the interface. Implementation should be hidden from external code so that it can be changed to meet evolving requirements.
Consider the Book class. Constructor and method headers form this class's interface. The code within the constructors and methods, and the various fields are part of the implementation. There is no need to access these fields because they can be read or written via the getter and setter methods.
However, because no precautions have been taken, it's possible to directly access these fields. Using the previous book reference variable, you could specify book.title and book.pubYear, and that would be okay with the Java compiler. To prevent access to these fields (or at least determine who can access them), you need to take advantage of access levels.
An access level is an indicator of who can access a field, method, or constructor. Java supports four access levels: private, public, protected, and package (the default). Java provides three keywords that correspond to the first three access levels:
- private: Only code in the same class as the member can access the member.
- public: Any code in any class in any package can access the member.
- protected: Any code in the same class or its subclasses can access the member.
If there is no keyword then package access is implied. Package access is similar to public access in that code outside of the class can access the member. However, unlike public access, the code must be located in a class that belongs to the same package (discussed later in the Java 101 series) as the class containing the member that is to be accessed.
You can prevent external code from accessing Book's title and pubYear fields so that any attempt to access these fields from beyond Book will result in a compiler error message. Accomplish this task by prepending private to their declarations, as demonstrated below:
