|
||||||
Here is a list of most of the basic the object-oriented concepts used
in Java that you can use as a study guide. Read over the list and make
sure you undestand the concepts and statements and can apply them as appropriate.
This is not a list of facts to be memorized.
A class describes the data and the methods of its objects. Every object belongs to some class. An object contains data (instance variables) representing its state, and instance methods, which are the things it can do. A class may also contain its own data (class variables) and class
methods. The keyword An object "knows" what class it belongs to, and can use class data and class methods, but a class does not "know" about its objects. Classes form a hierarchy (tree), with A class contains one or more constructors for making new objects of
that class. If (and only if) the programmer does not write a constructor,
Java provides a default constructor with no arguments. The default constructor
sets instance variables as follows: numeric types are set to zero, The purpose of a constructor is to create an object in a valid state. No other work should be done in a constructor. When a constructor executes, the very first thing it does is call the constructor
for its superclass. You can write this constructor call explicitly, with A constructor for a class can call another constructor for the same class by
putting Objects are declared just like primitive values, with the syntax Classes inherit all the data and all the methods of their superclasses, but do not inherit constructors. You can assign an object of a class to a variable (that is, Casting an object to a more general type is called upcasting, and is always legal. Casting an object to a more specific type is called downcasting, and Java inserts a run-time check to ensure that the cast is legal. Casting does not affect what the object is, it only changes what fields and methods are available on the object at the position the cast occurs. A class that is declared as The A Java source file may contain only one Classes should be as self-contained and independent as it is reasonable to make them. The interface (the fields and methods it makes available outside the class) should be kept small. An object is responsible for keeping itself in a valid state. Therefore, it should limit write access to essential fields.
Variables and methods are accessed by name. There are three dimensions to accessing names: namespaces, scope, and access modifiers. Java uses six different namespaces: package names, type names, field (variable) names, method names, local variable names (including parameters), and labels. Identical names of different types do not conflict; for example, a method may be named the same as a local variable. However, it's best to avoid reusing names in this manner. The scope of a name is the part of a class in which it can be seen.
Class variables and class methods (denoted by the keyword Instance variables and instance methods can be used anywhere within the class except in static methods. Within an instance method, the keyword When an instance variable and a formal parameter have the same name, the name
refers to the formal parameter; prefix the name with To refer to an instance name in a different object, use the syntax You can refer to a name (class or instance) in another class if and only if you have access privileges. Possible access privileges are:
You can refer to a name in a class in another package in either of two ways:
A method is a named executable chunk of code. All executable statements must be in methods. (Exception: "initialization blocks," not covered here.) A method has a signature consisting of its name and the number and types of its parameters (also called "arguments"). The parameters in the method declaration are its formal parameters. A method has a return type, which is not part of its signature. If the
return type is other than A method may have local variables (also called method variables).
These follow the scope rules, and are never available anywhere outside the method.
The concepts Every method must have a signature that is unique within its class. Methods in other classes (even superclasses and subclasses) may have the same signature. An instance method is executed by sending a message to its object. The message consists of: a reference to the object (typically its name), a dot, the name of the method, and zero or more actual parameters enclosed in parentheses. The object will respond by executing the corresponding method in the actual class of the object, which may be different from the type of the variable holding the object. A class method is executed by sending a message to the class. The message consists of: the name of the class, a dot, the name of the method, and zero or more actual parameters enclosed in parentheses. The class will respond by executing the corresponding static method in that class. When a message is sent, and before the method executes, the values of the actual parameters are copied into the corresponding formal parameters. Then the method body executes. Then the return value replaces the message, and all local names are forgotten.
The two kinds of polymorphism are overloading and overriding. Overloading occurs when a class declares two or more methods with the same name but different signatures. When a message is sent to an object or class with overloaded methods, the method with the best matching signature is the one that is used ("invoked").
Overriding occurs when a class declares a method with the same signature as that of an inherited method. When a message is sent to the object (or class, if it's a class method), the locally-defined method is the one that is used.
A class can declare a variable with the same name as an inherited variable, thus "hiding" or shadowing the inherited version. (This is like overriding, but for variables.)
The purpose of interfaces and abstract methods is to ensure that any classes derived from them will share the same set of methods. An abstract method is a method that is declared but not defined. It is declared with the keyword An abstract class is one that contains one or more abstract methods;
it must itself be declared with the An abstract class cannot be instantiated; that is, no objects of that class can be created. Instead, you can create subclasses that define (in the usual way) the inherited abstract methods, and these subclasses can be instantiated. An interface is declared with the keyword A class may extend only one other class, but it may implement any number of interfaces. The syntax is: A variable may be declared to have a type that is an abstract class
or an interface; any object whose type implements or extends the variable's
type may be assigned to that variable. The
An inner class is a class declared within another class. The four kinds of inner class are: (1) member class, (2) static member class, (3) local inner class, and (4) anonymous inner class. Unlike "outer" classes, the usual scope rules apply to inner classes. A member class is defined at the top level of the class, along with
fields and methods. It may have the same access modifiers as variables
( An anonymous inner class is one that is declared and used to create
one object (typically as a parameter to a method), all within a single
statement. The anonymous inner class may either extend a class or implement
an interface; the syntax is the same for both: |