Mysql, Java, Jsp, Servlet, Tomcat, Ssh, Shared Web Hosting Blog

388 Object-Based Programming Chapter 8 usually designed to be client oriented rather than implementation oriented. Clients need not be concerned with a class s implementation. Interfaces do change, but less frequently than implementations. When an implementation changes, implementation-dependent code must change accordingly. By hiding the implementation, we eliminate the possibility of other program parts becoming dependent on the details of the class implementation. Often, classes do not have to be created from scratch. Rather, they can be derived from other classes that provide operations the new classes can use, or classes can include objects of other classes as members. Such software reuse can greatly enhance programmer productivity. Deriving new classes from existing classes is called inheritance a distinguishing feature between object-based programming and object-oriented programming and is discussed in detail in Chapter 9. Including class objects as members of other classes is called composition or aggregation and is discussed later in this chapter. 8.3 Class Scope A class s instance variables and methods belong to that class s scope. Within a class s scope, class members are accessible to all of that class s methods and can be referenced simply by name. Outside a class s scope, class members cannot be referenced directly by name. Those class members (such as public members) that are visible can be accessed only through a handle (i.e., primitive data type members can be referred to by object- ReferenceName.primitiveVariableName and object members can be referenced by object- ReferenceName.objectMemberName). For example, a program can determine the number of elements in an array object by accessing the array s public member length as in arrayName.length. Variables defined in a method are known only to that method (i.e., they are local variables to that method). Such variables are said to have block scope. If a method defines a variable with the same name as a variable with class scope (i.e., an instance variable), the class-scope variable is hidden by the method-scope variable in the method scope. A hidden instance variable can be accessed in the method by preceding its name with the keyword this and the dot operator, as in this.variableName. Keyword this is discussed Section 8.13. 8.4 Controlling Access to Members The member access modifiers public and private control access to a class s instance variables and methods. (In Chapter 9, we will introduce the additional access modifier protected.) As we stated previously, the primary purpose of public methods is to present to the class s clients a view of the services the class provides (i.e., the public interface of the class). Clients of the class need not be concerned with how the class accomplishes its tasks. For this reason, the private instance variables and privatemethods of a class (i.e., the class s implementation details) are not accessible to the clients of a class. Restricting access to class members via keyword private is called encapsulation. Common Programming Error 8.3 An attempt by a method that is not a member of a particular class to access a private member of that class is a syntax error. Figure 8.3 demonstrates that private class members are not accessible by name outside the class. Line 10 attempts to access directly the private instance variable hourof Copyright 1992 2002 by Deitel & Associates, Inc. All Rights Reserved. 7/3/01
Note: If you are looking for cheap webhost to host and run your apache application check Vision jboss web hosting services

Chapter 8 Object-Based Programming 387 reasonable for the class to represent the time internally as the number of seconds since midnight. Clients could use the same public methods and get the same results without being aware of this. In this sense, implementation of a class is said to be hidden from its clients. Exercise 8.18 asks you to make precisely this modification to the Time1 class of Figure 8.1 and show that there is no change visible to the clients of the class. Software Engineering Observation 8.6 Information hiding promotes program modifiability and simplifies the client s perception of a class. The client should not require knowledge of a class s implementation (known as implementation knowledge) to be able to reuse a class. Software Engineering Observation 8.7 Clients of a class can (and should) use the class without knowing the internal details of how the class is implemented. If the class implementation is changed (to improve performance, for example), the class clients source code need not change, provided that the class s interface remains constant. This makes it much easier to modify systems. In this program, the Time1 constructor simply initializes the instance variables to 0 (i.e., the universal time equivalent of 12 AM). This ensures that the object is created in a consistent state (i.e., all instance variable values are valid). Invalid values cannot be stored in the instance variables of a Time1 object, because the constructor is automatically called when the Time1 object is created and subsequent attempts by a client to modify the instance variables are scrutinized by the method setTime. Instance variables can be initialized where they are declared in the class body, by the class s constructor, or they can be assigned values by set methods. (Remember, instance variables that are not initialized explicitly receive default values (primitive numeric variables are set to 0, booleans are set to false and references are set to null). Good Programming Practice 8.2 Initialize instance variables of a class in that class s constructor. Every class may include a finalizer method called finalize that does termination housekeeping on each class object before the memory for the object is garbage collected by the system. We will discuss garbage collection and finalizers in detail in Section 8.14 and Section 8.15. It is interesting that the toUniversalString and toString methods take no arguments. This is because these methods implicitly know that they are to manipulate the instance variables of the particular Time1 object for which they are invoked. This makes method calls more concise than conventional function calls in procedural programming. It also reduces the likelihood of passing the wrong arguments, the wrong types of arguments and/or the wrong number of arguments, as often happens in C function calls. Software Engineering Observation 8.8 Using an object-oriented programming approach can often simplify method calls by reducing the number of parameters to be passed. This benefit of object-oriented programming derives from the fact that encapsulation of instance variables and methods within an object gives the methods the right to access the instance variables. Classes simplify programming because the client (or user of the class object) need only be concerned with the public operations encapsulated in the object. Such operations are Copyright 1992 2002 by Deitel & Associates, Inc. All Rights Reserved. 7/3/01
Note: In case you are looking for affordable and reliable webhost to host and run your business application check Vision php5 hosting services

386 Object-Based Programming Chapter 8 33 JOptionPane.showMessageDialog( null, output, 34 “Testing Class Time1″, 35 JOptionPane.INFORMATION_MESSAGE ); 36 37 System.exit( 0 ); 38 } 39 40 } // end class TimeTest1 Fig. 8.2 Using an object of class Time1in a program (part 2 of 2). The statement at lines 15 18 defines a String reference output, which stores the string containing the results that will be displayed in a message box. Initially, the program assigns to output the time in universal-time format (by sending message toUniversalString to the object to which time refers) and standard-time format (by sending message toStringto the object to which timerefers) to confirm that the data were initialized properly. Note that line 18 uses a special string concatenation feature of Java. Concatenating a Stringwith any object results in an implicit call to the object s toString method to convert the object to a String; then the Strings are concatenated. Lines 17 18 illustrate that you can call toStringboth explicitly and implicitly in a Stringconcatenation operation. Line 21 sends the setTimemessage to the object to which timerefers to change the time. Then lines 22 24 append the time to outputagain in both formats to confirm that the time was set correctly. To illustrate that method setTime validates the values passed to it, line 28 calls method setTime and attempts to set the instance variables to invalid values. Then lines 29 31 append the time to output again in both formats to confirm that setTime validated the data. Lines 33 35 display a message box with the results of our program. Notice in the last two lines of the output window that the time is set to midnight the default value of a Time1 object. Now that we have seen our first non-applet, non-application class, let us consider several issues of class design. Again, note that the instance variables hour, minuteand secondare each declared private. Instance variables declared private are not accessible outside the class in which they are defined. The philosophy here is that the actual data representation used within the class is of no concern to the class s clients. For example, it would be perfectly Copyright 1992 2002 by Deitel & Associates, Inc. All Rights Reserved. 7/3/01
Note: If you are looking for high quality webhost to host and run your jsp application check Vision florida web design services

Chapter 8 Object-Based Programming 385 new object, and that reference is assigned to time. Similarly, line 32 in class Time1 (Fig. 8.1) uses new to allocate the memory for a DecimalFormatobject, then calls the DecimalFormat constructor with the argument “00″ to indicate the number format control string. Software Engineering Observation 8.5 Every time new creates an object of a class, that class s constructor is called to initialize the instance variables of the new object. Note that class Time1 was not imported into the TimeTest1.java file. Actually, every class in Java is part of a package (like the classes from the Java API). If the programmer does not specify the package for a class, the class is automatically placed in the default package, which includes the compiled classes in the current directory. If a class is in the same package as the class that uses it, an import statement is not required. We import classes from the Java API because their .class files are not in the same package with each program we write. Section 8.5 illustrates how to define your own packages of classes for reuse. 1 // Fig. 8.2: TimeTest1.java 2 // Class TimeTest1 to exercise class Time1 3 4 // Java extension packages 5 import javax.swing.JOptionPane; 6 7 public class TimeTest1 { 8 9 // create Time1 object and manipulate it 10 public static void main( String args[] ) 11 { 12 Time1 time = new Time1(); // calls Time1 constructor 13 14 // append String version of time to String output 15 String output = “The initial universal time is: ” + 16 time.toUniversalString() + 17 “nThe initial standard time is: ” + time.toString() + 18 “nImplicit toString() call: ” + time; 19 20 // change time and append String version of time to output 21 time.setTime( 13, 27, 6 ); 22 output += “nnUniversal time after setTime is: ” + 23 time.toUniversalString() + 24 “nStandard time after setTime is: ” + time.toString(); 25 26 // use invalid values to change time and append String 27 // version of time to output 28 time.setTime( 99, 99, 99 ); 29 output += “nnAfter attempting invalid settings: ” + 30 “nUniversal time: ” + time.toUniversalString() + 31 “nStandard time: ” + time.toString(); 32 Fig. 8.2 Using an object of class Time1in a program (part 1 of 2). Copyright 1992 2002 by Deitel & Associates, Inc. All Rights Reserved. 7/3/01
Note: In case you are looking for affordable webhost to host and run your web application check Vision cheap hosting services

384 Object-Based Programming Chapter 8 range is an invalid value and is set to zero ensuring that a Time1 object always contains valid data. This is also known as keeping the object in a consistent state or maintaining the object s integrity. In cases where invalid data is supplied to setTime, the program may want to indicate that an invalid time setting was attempted. We explore this possibility in the exercises. Good Programming Practice 8.1 Always define a class so its instance variables are maintained in a consistent state. Method toUniversalString (lines 30 37) takes no arguments and returns a String. This method produces a universal-time-format string consisting of six digits two for the hour, two for the minute and two for the second. For example, 13:30:07 represents 1:30:07 PM. Line 32 creates an instance of class DecimalFormat (from package java.text imported at line 3) to help format the universal time. Object twoDigitsis initialized with the format control string “00″, which indicates that the number format should consist of two digits each 0 is a placeholder for a digit. If the number being formatted is a single digit, it is automatically preceded by a leading 0 (i.e., 8 is formatted as 08). The return statement at lines 34 36 uses method format (which returns a formatted String containing the number) from object twoDigits to format the hour, minute and second values into two-digit strings. Those strings are concatenated with the + operator (separated by colons) and returned from method toUniversalString. Method toString (line 40 48) takes no arguments and returns a String. This method produces a standard-time-format string consisting of the hour, minute and second values separated by colons and an AM or PM indicator, as in 1:27:06PM. This method uses the same DecimalFormat techniques as method toUniversalString to guarantee that the minute and second values each appear with two digits. Method toString is special, in that we inherited from class Objecta toString method with exactly the same first line as our toStringon line 40. The original toString method of class Object is a generic version that is used mainly as a placeholder that can be redefined by a subclass (similar to methods init, start and paint from class JApplet). Our version replaces the version we inherited to provide a toString method that is more appropriate for our class. This is known as overriding the original method definition (discussed in detail in Chapter 9). Once the class has been defined, it can be used as a type in declarations such as Time1 sunset, // reference to object of type Time1 timeArray[]; // reference to array of Time1 objects The class name is a new type specifier. There may be many objects of a class, just as there may be many variables of a primitive data type such as int. The programmer can create new class types as needed; this is one of the reasons that Java is known as an extensible language. The TimeTest1 application of Fig. 8.2 uses class Time1. Method main of class TimeTest1 declares and initializes an instance of class Time1 called time in line 12. When the object is instantiated, operator new allocates the memory in which the Time1 object will be stored; then new calls the Time1constructor to initialize the instance variables of the new Time1 object. The constructor invokes method setTime to explicitly initialize each private instance variable to 0. Operator newthen returns a reference to the Copyright 1992 2002 by Deitel & Associates, Inc. All Rights Reserved. 7/3/01
Note: If you are looking for cheap webhost to host and run your apache application check Vision apache web hosting services

Chapter 8 Object-Based Programming 383 Software Engineering Observation 8.4 Methods tend to fall into a number of different categories: methods that get the values of private instance variables; methods that set the values of private instance variables; methods that implement the services of the class; and methods that perform various mechanical chores for the class, such as initializing class objects, assigning class objects, and converting between classes and built-in types or between classes and other classes. Access methods can read or display data. Another common use for access methods is to test whether a condition is true or false such methods are often called predicate methods. An example of a predicate method would be an isEmpty method for any container class a class capable of holding many objects such as a linked list, a stack or a queue (these data structures are discussed in depth in Chapter 19, Chapter 20 and Chapter 21). A program might test isEmptybefore attempting to read another item from the container object. A program might test isFull before attempting to insert another item into the container object. Class Time1 contains the following public methods Time1 (lines 15 18), set- Time (lines 22 27), toUniversalString (lines 30 37) and toString (line 40 48). These are the public methods, public services or public interface of the class. These methods are used by clients (i.e., portions of a program that are users of a class) of the class to manipulate the data stored in objects of the class. The clients of a class use references to interact with an object of the class. For example, method paint in an applet is a client of class Graphics. Method paint uses a reference to a Graphics object (such as g) that it receives as an argument to draw on the applet by calling methods that are public services of class Graphics (such as drawString, drawLine, drawOval and drawRect). Notice the method with the same name as the class (lines 15 18); it is the constructor method of that class. A constructor is a special method that initializes the instance variables of a class object. Java calls a class s constructor method when a program instantiates an object of that class. In this example, the constructor simply calls the class s setTime method (discussed shortly) with hour, minute and second values specified as 0. It is common to have several constructors for a class; this is accomplished through method overloading (as we will see Fig. 8.6). Constructors can take arguments but cannot specify a return data type. Implicitly, the constructor returns a reference to the instantiated object. An important difference between constructors and other methods is that constructors are not allowed to specify a return data type (not even void). Normally, constructors are public methods of a class. Nonpublic methods are discussed later. Common Programming Error 8.2 Attempting to declare a return type for a constructor and/or attempting to return a value from a constructor is a logic error. Java allows other methods of the class to have the same name as the class and to specify return types. Such methods are not constructors and will not be called when an object of the class is instantiated. Method setTime(lines 22 27) is a public method that receives three integer arguments and uses them to set the time. Each argument is tested in a conditional expression that determines whether the value is in range. For example, the hour value must be greater than or equal to 0 and less than 24 because we represent the time in universal time format (0 23 for the hour, 0 59 for the minute and 0 59 for the second). Any value outside this Copyright 1992 2002 by Deitel & Associates, Inc. All Rights Reserved. 7/3/01
Note: In case you are looking for affordable and reliable webhost to host and run your j2ee application check Vision j2ee hosting services

382 Object-Based Programming Chapter 8 Software Engineering Observation 8.2 Class definitions that begin with keyword public must be stored in a file that has exactly the same name as the class and ends with the .java file name extension. Common Programming Error 8.1 Defining more than one public class in the same file is a syntax error. Figure 8.1 contains a simple definition for class Time1. Our Time1 class definition begins with line 6, which indicates that class Time1extends class Object (from package java.lang). Remember that you never create a class definition from scratch. In fact, when you create a class definition, you always use pieces of an existing class definition. Java uses inheritance to create new classes from existing class definitions. Keyword extends followed by class name Object indicates the class (in this case Time1) from which our new class inherits existing pieces. In this inheritance relationship, Object is called the superclass or base class and Time1 is called the subclass or derived class. Using inheritance results in a new class definition that has the attributes (data) and behaviors (methods) of class Object as well as new features we add in our Time1class definition. Every class in Java is a subclass of Object (directly or indirectly). Therefore, every class inherits the 11 methods defined by class Object. One key Object method is toString, discussed later in this section. Other methods of class Object are discussed as they are needed throughout the text. For a complete list of class Object s methods, see the online API documentation at java.sun.com/j2se/1.3/docs/api/index.html Software Engineering Observation 8.3 Every class defined in Java must extend another class. If a class does not explicitly use the keyword extends in its definition, the class implicitly extends Object. The body of the class definition is delineated with left and right braces ({ and }) on lines 7 and 50. Class Time1 contains three integer instance variables hour, minute and second that represent the time in universal-time format (24-hour clock format). Keywords public and private are member access modifiers. Instance variables or methods declared with member access modifier public are accessible wherever the program has a reference to a Time1 object. Instance variables or methods declared with member access modifier private are accessible only to methods of the class in which they are defined. Every instance variable or method definition should be preceded by a member access modifier. The three integer instance variables hour, minute and second are each declared (lines 8 10) with member access modifier private, indicating that these instance variables are accessible only to methods of the class. When a program creates (instantiates) an object of the class, such instance variables are encapsulated in the object and can be accessed only through methods of that object s class (normally through the class s public methods). Typically, instance variables are declared private, and methods are declared public. It is possible to have private methods and publicdata, as we will see later. The private methods are known as utility methods or helper methods because they can be called only by other methods of that class and are used to support the operation of those methods. Using public data is uncommon and is a dangerous programming practice. Copyright 1992 2002 by Deitel & Associates, Inc. All Rights Reserved. 7/3/01
Note: If you are looking for high quality webhost to host and run your jsp application check Vision jsp web hosting services

Chapter 8 Object-Based Programming 381 separate files, because they are both public classes. [Note: The output of this program appears in Fig. 8.2.] 1 // Fig. 8.1: Time1.java 2 // Time1 class definition maintains the time in 24-hour format. 3 4 // Java core packages 5 import java.text.DecimalFormat; 6 7 public class Time1 extends Object { 8 private int hour; // 0 - 23 9 private int minute; // 0 - 59 10 private int second; // 0 - 59 11 12 // Time1 constructor initializes each instance variable 13 // to zero. Ensures that each Time1 object starts in a 14 // consistent state. 15 public Time1() 16 { 17 setTime( 0, 0, 0 ); 18 } 19 20 // Set a new time value using universal time. Perform 21 // validity checks on the data. Set invalid values to zero. 22 public void setTime( int h, int m, int s ) 23 { 24 hour = ( ( h >= 0 && h < 24 ) ? h : 0 ); 25 minute = ( ( m >= 0 && m < 60 ) ? m : 0 ); 26 second = ( ( s >= 0 && s < 60 ) ? s : 0 ); 27 } 28 29 // convert to String in universal-time format 30 public String toUniversalString() 31 { 32 DecimalFormat twoDigits = new DecimalFormat( "00" ); 33 34 return twoDigits.format( hour ) + ":" + 35 twoDigits.format( minute ) + ":" + 36 twoDigits.format( second ); 37 } 38 39 // convert to String in standard-time format 40 public String toString() 41 { 42 DecimalFormat twoDigits = new DecimalFormat( "00" ); 43 44 return ( (hour == 12 || hour == 0) ? 12 : hour % 12 ) + 45 ":" + twoDigits.format( minute ) + 46 ":" + twoDigits.format( second ) + 47 ( hour < 12 ? " AM" : " PM" ); 48 } 49 50 } // end class Time1 Fig. 8.1Abstract data type Time1implementation as a class. Fig. 8. Copyright 1992 2002 by Deitel & Associates, Inc. All Rights Reserved. 7/3/01
Note: In case you are looking for affordable webhost to host and run your servlet application check Vision servlet hosting services

380 Object-Based Programming Chapter 8 Let us briefly review some key concepts and terminology of object orientation. OOP encapsulates data (attributes) and methods (behaviors) into objects; the data and methods of an object are intimately tied together. Objects have the property of information hiding. This means that although objects might know how to communicate with one another across well-defined interfaces, objects normally are not allowed to know how other objects are implemented implementation details are hidden within the objects themselves. Surely it is possible to drive a car effectively without knowing the details of how engines, transmissions and exhaust systems work internally. We will see why information hiding is so crucial to good software engineering. In C and other procedural programming languages, programming tends to be action- oriented. In Java, programming is object-oriented. In C, the unit of programming is the function (called methods in Java). In Java, the unit of programming is the class from which objects are eventually instantiated (i.e., created). Functions do not disappear in Java; rather, they are encapsulated as methods with the data they process within the walls of classes. C programmers concentrate on writing functions. Groups of actions that perform some task are formed into functions, and functions are grouped to form programs. Data is certainly important in C, but the view is that data exists primarily in support of the actions that functions perform. The verbs in a system-requirements document help the C programmer determine the set of functions that will work together to implement the system. Java programmers concentrate on creating their own user-defined types called classes. Classes are also referred to as programmer-defined types. Each class contains data as well as the set of methods that manipulate the data. The data components of a class are called instance variables (these are called data members in C++). Just as an instance of a built-in type such as int is called a variable, an instance of a user-defined type (i.e., a class) is called an object. The focus of attention in Java is on objects rather than methods. The nouns in a system-requirements document help the Java programmer determine an initial set of classes with which to begin the design process. These classes are then used to instantiate objects that will work together to implement the system. This chapter explains how to create and use objects, a subject called object-based programming (OBP). Chapter 9 introduces inheritance and polymorphism two key technologies that enable true object-oriented programming (OOP). Although inheritance is not discussed in detail until Chapter 9, inheritance is part of every Java class definition. Performance Tip 8.1 When passing an object to a method in Java, only a reference to the object is passed, not a copy of a possibly large object (as would be the case in a pass by value). Software Engineering Observation 8.1 It is important to write programs that are understandable and easy to maintain. Change is the rule rather than the exception. Programmers should anticipate their code s being modified. As we will see, classes facilitate program modifiability. 8.2 Implementing a Time Abstract Data Type with a Class The next example consists of two classes Time1 (Fig. 8.1) and TimeTest (Fig. 8.2). Class Time1 is defined in file Time1.java. Class TimeTest is defined in a separate file called TimeTest.java. It is important to note that these classes must be defined in Copyright 1992 2002 by Deitel & Associates, Inc. All Rights Reserved. 7/3/01
Note: If you are looking for best quality webspace to host and run your tomcat application check Vision tomcat hosting services

Chapter 8 Object-Based Programming 379 Outline 8.1 Introduction 8.2 Implementing a Time Abstract Data Type with a Class 8.3 Class Scope 8.4 Controlling Access to Members 8.5 Creating Packages 8.6 Initializing Class Objects: Constructors 8.7 Using Overloaded Constructors 8.8 Using Set and Get Methods 8.8.1 Executing an Applet that Uses Programmer-Defined Packages 8.9 8.10 Software Reusability Final Instance Variables 8.11 Composition: Objects as Instance Variables of Other Classes 8.12 Package Access 8.13 Using the this Reference 8.14 Finalizers 8.15 Static Class Members 8.16 Data Abstraction and Encapsulation 8.16.1 Example: Queue Abstract Data Type 8.17 (Optional Case Study) Thinking About Objects: Starting to Program the Classes for the Elevator Simulation Summary Terminology Self-Review Exercises Answers to Self-Review Exercises Exercises 8.1 Introduction Now we investigate object orientation in Java in greater depth. Why did we defer this until now? First, the objects we will build will be composed in part of structured program pieces, so we needed to establish a basis in structured programming with control structures. Second, we wanted to study methods in depth. Third, we wanted to familiarize the reader with arrays that are Java objects. Through our discussions of object-oriented Java programs in Chapter 2 through Chapter 7, we introduced many basic concepts (i.e., object think ) and terminology (i.e., object speak ) of object-oriented programming in Java. We also discussed our program- development methodology: We analyzed many typical problems that required a program either a Java applet or a Java application to be built, determined what classes from the Java API were needed to implement the program, determined what instance variables were needed, determined what methods were needed and specified how an object of our class collaborated with objects of Java API classes to accomplish the overall goals of the program. Copyright 1992 2002 by Deitel & Associates, Inc. All Rights Reserved. 7/3/01
Note: If you are looking for best quality webspace to host and run your tomcat application check Vision shared web hosting services