The driver class (aka driver program) is the class in a larger program containing the public static void main(String[] args) method designed to start the program.
A scope is an enclosing context in a program where variables and expressions are associated.
A member is a term used for fields (or instance variable) and methods defined within the scope of a class or object.
When using the static keyword to declare a variable or method, that member is defined in the class scope. Absence of static in a variable or method declaration means that member belongs to the object scope.
The scope of a method or field name may be specified by preceding it with the name of the class or object and connected by a dot. This is the dot operator and is referred to as dot-notation.
It may be necessary to specify the scope of a static member with the class name in which it was defined in order to access the proper member.
Regardless of the number of instances created, there is only one of each class and therefore one set of static class members.
Every object instantiated using a constructor will get its own members declared without using the static keyword.
A custom class constructor defines the code executed when the new keyword is used to construct a new instance of the class.
A constructor must have the same name as the class, have no return type, not even void, and no return statement.
The this keyword always resolves to a reference to the current object.
You may invoke one constructor from another constructor in the same class using the this keyword followed by parentheses containing the specific constructor argument list.
The visibility of members encapsulated by an object and class are controlled using certain keywords, including public and private.
The combination of a method name, parameters, and parameter types, are referred to as a method’s signature.
Multiple methods having the same name may be defined within a class, provided their signatures are distinct. This is called method overloading.
Members declared with private visibility are accessible only from within the scope of an object.
A common Java best practice is to declare as private all object instance variables, and to control access to these variables using methods.
Methods that control access to private fields are called accessor methods or "getters".
Accessor methods often are named using camel case, which are formed by adding get to the front of the field name being accessed. For example getAge().
Methods that modify private fields are called mutator methods or "setters".
Mutator methods often are named using camel case, and formed by adding set to the front of the field name that is modified. For example setAge(double age).
Objects should be designed to be self-governing. That is, an object should contain all the code and internal variables necessary to manage its fields. This is a core concept of object-oriented programming called encapsulation.
In addition to class scope and object scope, block scope is an enclosing context for a code block, such as when defining the statements that make up an if-statement or for-statement.
Scopes are nested. Block scopes are nested within a method scope, and method scopes are nested within an object or class scope.
Shadowing occurs when variables defined in an inner scope have names identical to variables defined in an outer scope.
To access a shadowed variable in an outer scope, it is necessary to specify the outer scope of the shadowed variable explicitly using dot-notation and the this keyword or the class name.
When choosing a scope to declare a variable, always use the most narrow scope feasible. This avoids program bugs that emerge when a variable value set by one method has an unexpected impact on the execution of another method.
The scope within which a variable is declared governs its lifetime. For example, when declaring a variable within a method, it comes into existence when the method is invoked and the declaration statement is executed. It goes out of existence when the method scope exits. When declaring an instance variable in an object, it comes into existence when the object is instantiated and goes out of existence when the object is garbage collected.
Anonymous objects are objects created temporarily but never assigned to a variable. They occur when chaining methods, or when invoking a constructor to set a parameter value as part of calling a method.
The toString() method of an object is a special method that returns a String representation of the object. toString() is invoked by Java’s print methods such as print(…) and println(…), and it is the String representation that is printed to the terminal.
