Hexadecimal Numbers

A particularly important relationship that both the octal number system and the hexadecimal number system have to the binary system is that the bases of octal and hexadecimal (8 and 16 respectively) are powers of the base of the binary number system (base 2). Consider the following 12-digit binary number and its octal and hexadecimal equivalents. See if you can determine how this relationship makes it convenient to abbreviate binary numbers in octal or hexadecimal. The answer follows the numbers.

To see how the binary number converts easily to octal, simply break the 12-digit binary number into groups of three consecutive bits each, and write those groups over the corresponding digits of the octal number as follows

Notice that the octal digit you have written under each group of thee bits corresponds precisely to the octal equivalent of that 3-digit binary number as shown in Fig. E.7.

The same kind of relationship may be observed in converting numbers from binary to hexadecimal. In particular, break the 12-digit binary number into groups of four consecutive bits each and write those groups over the corresponding digits of the hexadecimal number as follows

Notice that the hexadecimal digit you wrote under each group of four bits corresponds precisely to the hexadecimal equivalent of that 4-digit binary number as shown in Fig. E.7.

E.3 Converting Octal Numbers and Hexadecimal Numbers to Binary Numbers

In the previous section, we saw how to convert binary numbers to their octal and hexadecimal equivalents by forming groups of binary digits and simply rewriting these groups as their equivalent octal digit values or hexadecimal digit values. This process may be used in reverse to produce the binary equivalent of a given octal or hexadecimal number.

For example, the octal number 653 is converted to binary simply by writing the 6 as its 3-digit binary equivalent 110, the 5 as its 3-digit binary equivalent 101, and the 3 as its 3- digit binary equivalent 011 to form the 9-digit binary number 110101011.

The hexadecimal number FAD5 is converted to binary simply by writing the F as its 4-digit binary equivalent 1111, the A as its 4-digit binary equivalent 1010, the D as its 4- digit binary equivalent 1101, and the 5 as its 4-digit binary equivalent 0101 to form the 16digit 1111101011010101.

E.4 Converting from Binary, Octal, or Hexadecimal to Decimal

Because we are accustomed to working in decimal, it is often convenient to convert a binary, octal, or hexadecimal number to decimal to get a sense of what the number is “really” worth. Our diagrams in Section E.1 express the positional values in decimal. To convert a number to decimal from another base, multiply the decimal equivalent of each digit by its

Then we discard the column with positional value 64 leaving:

Next we work from the leftmost column to the right. We divide 32 into 57 and observe that there is one 32 in 57 with a remainder of 25, so we write 1 in the 32 column. We divide 16 into 25 and observe that there is one 16 in 25 with a remainder of 9 and write 1 in the 16 column. We divide 8 into 9 and observe that there is one 8 in 9 with a remainder of 1. The next two columns each produce quotients of zero when their positional values are divided into 1 so we write 0s in the 4 and 2 columns. Finally, 1 into 1 is 1 so we write 1 in the 1 column. This yields:

and thus decimal 57 is equivalent to binary 111001.

To convert decimal 103 to octal, we begin by writing the positional values of the columns until we reach a column whose positional value is greater than the decimal number. We do not need that column, so we discard it. Thus, we first write:

Then we discard the column with positional value 512, yielding:

Next we work from the leftmost column to the right. We divide 64 into 103 and observe that there is one 64 in 103 with a remainder of 39, so we write 1 in the 64 column. We divide 8 into 39 and observe that there are four 8s in 39 with a remainder of 7 and write 4 in the 8 column. Finally, we divide 1 into 7 and observe that there are seven 1s in 7 with no remainder so we write 7 in the 1 column. This yields:

and thus decimal 103 is equivalent to octal 147.

To convert decimal 375 to hexadecimal, we begin by writing the positional values of the columns until we reach a column whose positional value is greater than the decimal number. We do not need that column, so we discard it. Thus, we first write

Positional values: 4096 256 16 1

Then we discard the column with positional value 4096, yielding:

Next we work from the leftmost column to the right. We divide 256 into 375 and observe that there is one 256 in 375 with a remainder of 119, so we write 1 in the 256 column. We divide 16 into 119 and observe that there are seven 16s in 119 with a remainder of 7 and write 7 in the 16 column. Finally, we divide 1 into 7 and observe that there are seven 1s in 7 with no remainder so we write 7 in the 1 column. This yields:

by adding the two’s complement of value to a as follows:

x = a + (~value + 1);

Suppose a is 27 and value is 13 as before. If the two’s complement of value is actually the negative of value, then adding the two’s complement of value to a should produce the result 14. Let us try this:

which is indeed equal to 14.

SUMMARY

•When we write an integer such as 19 or 227 or -63 in a Java program, the number is automatically assumed to be in the decimal (base 10) number system. The digits in the decimal number system are 0, 1, 2, 3, 4, 5, 6, 7, 8, and 9. The lowest digit is 0 and the highest digit is 9—one less than the base of 10.

•Internally, computers use the binary (base 2) number system. The binary number system has only two digits, namely 0 and 1. Its lowest digit is 0 and its highest digit is 1—one less than the base of 2.

•The octal number system (base 8) and the hexadecimal number system (base 16) are popular primarily because they make it convenient to abbreviate binary numbers.

•The digits of the octal number system range from 0 to 7.

•The hexadecimal number system poses a problem because it requires sixteen digits—a lowest digit of 0 and a highest digit with a value equivalent to decimal 15 (one less than the base of 16). By convention, we use the letters A through F to represent the hexadecimal digits corresponding to decimal values 10 through 15.

•Each number system uses positional notation—each position in which a digit is written has a different positional value.

•A particularly important relationship that both the octal number system and the hexadecimal number system have to the binary system is that the bases of octal and hexadecimal (8 and 16 respectively) are powers of the base of the binary number system (base 2).

•To convert an octal number to a binary number, simply replace each octal digit with its three-digit binary equivalent.

•To convert a hexadecimal number to a binary number, simply replace each hexadecimal digit with its four-digit binary equivalent.

•Because we are accustomed to working in decimal, it is convenient to convert a binary, octal or hexadecimal number to decimal to get a sense of the number’s “real” worth.

•To convert a number to decimal from another base, multiply the decimal equivalent of each digit by its positional value, and sum these products.

•Computers represent negative numbers using two’s complement notation.

•To form the negative of a value in binary, first form its one’s complement by applying Java’s bitwise complement operator (~). This reverses the bits of the value. To form the two’s complement of a value, simply add one to the value’s one’s complement.

1366 Number Systems (on CD) Appendix E

TERMINOLOGY

SELF-REVIEW EXERCISES

E.2 In general, the decimal, octal, and hexadecimal representations of a given binary number contain (more/fewer) digits than the binary number contains.

E.3 (True/False) A popular reason for using the decimal number system is that it forms a convenient notation for abbreviating binary numbers simply by substituting one decimal digit per group of four binary bits.

E.4 The (octal / hexadecimal / decimal) representation of a large binary value is the most concise (of the given alternatives).

E.5 (True/False) The highest digit in any base is one more than the base.

E.6 (True/False) The lowest digit in any base is one less than the base.

E.9 Fill in the missing values in this chart of positional values for the rightmost four positions in each of the indicated number systems:

E.10 Convert binary 110101011000 to octal and to hexadecimal.

E.11 Convert hexadecimal FACE to binary.

E.12 Convert octal 7316 to binary.

E.13 Convert hexadecimal 4FEC to octal. (Hint: First convert 4FEC to binary then convert that binary number to octal.)

E.14 Convert binary 1101110 to decimal.

E.15 Convert octal 317 to decimal.

E.16 Convert hexadecimal EFD4 to decimal.

E.17 Convert decimal 177 to binary, to octal, and to hexadecimal.

E.18 Show the binary representation of decimal 417. Then show the one’s complement of 417, and the two’s complement of 417.

E.19 What is the result when the one’s complement of a number is added to itself?

SELF-REVIEW ANSWERS

E.1 10, 2, 8, 16.

E.2 Fewer.

E.3 False.

E.4 Hexadecimal.

E.5 False. The highest digit in any base is one less than the base.

E.6 False. The lowest digit in any base is zero.

E.7 1 (the base raised to the zero power).

E.8 The base of the number system.

E.9 Fill in the missing values in this chart of positional values for the rightmost four positions in each of the indicated number systems:

E.10 Octal 6530; Hexadecimal D58.

E.11 Binary 1111 1010 1100 1110.

E.12 Binary 111 011 001 110.

E.13 Binary 0 100 111 111 101 100; Octal 47754.

E.14 Decimal 2+4+8+32+64=110.

E.15 Decimal 7+1*8+3*64=7+8+192=207.

E.16 Decimal 4+13*16+15*256+14*4096=61396.

E.17 Decimal 177

to binary:

256 128 64 32 16 8 4 2 1

128 64 32 16 8 4 2 1 (1*128)+(0*64)+(1*32)+(1*16)+(0*8)+(0*4)+(0*2)+(1*1) 10110001

to octal:

512 64 8 1

64 8 1 (2*64)+(6*8)+(1*1) 261

to hexadecimal:

256 16 1

16 1 (11*16)+(1*1) (B*16)+(1*1) B1

E.18 Binary:

512 256 128 64 32 16 8 4 2 1

256 128 64 32 16 8 4 2 1 (1*256)+(1*128)+(0*64)+(1*32)+(0*16)+(0*8)+(0*4)+(0*2)+ (1*1)

110100001

One’s complement: 001011110 Two’s complement: 001011111

Check: Original binary number + its two’s complement

110100001

001011111

---------

000000000

E.19 Zero.

EXERCISES

E.20 Some people argue that many of our calculations would be easier in the base 12 number system because 12 is divisible by so many more numbers than 10 (for base 10). What is the lowest digit in base 12? What might the highest symbol for the digit in base 12 be? What are the positional values of the rightmost four positions of any number in the base 12 number system?

E.21 How is the highest symbol value in the number systems we discussed related to the positional value of the first digit to the left of the rightmost digit of any number in these number systems?

E.22 Complete the following chart of positional values for the rightmost four positions in each of the indicated number systems:

E.23 Convert binary 100101111010 to octal and to hexadecimal.

E.24 Convert hexadecimal 3A7D to binary.

E.25 Convert hexadecimal 765F to octal. (Hint: First convert 765F to binary, then convert that binary number to octal.)

E.26 Convert binary 1011110 to decimal.

E.27 Convert octal 426 to decimal.

E.28 Convert hexadecimal FFFF to decimal.

E.29 Convert decimal 299 to binary, to octal, and to hexadecimal.

E.30 Show the binary representation of decimal 779. Then show the one’s complement of 779, and the two’s complement of 779.

E.31 What is the result when the two’s complement of a number is added to itself?

E.32 Show the two’s complement of integer value -1 on a machine with 32-bit integers.

F

Creating HTML Documentation with javadoc (on CD)

Objectives

•To introduce the javadoc J2SDK tool.

•To introduce documentation comments.

•To understand javadoc tags.

• To be able to generate HTML API documentation with javadoc.

• To understand javadoc generated documentation files.

Oh I get by with a little help from my friends.

John Lennon and Paul McCartney

I feel

The link of nature draw me.

John Milton

I think I shall never see

A poem lovely as a tree.

Joyce Kilmer

There is only one religion, though there are a hundred versions of it.

George Bernard Shaw

What I like in a good author is not what he says, but what he whispers.

Logan Pearsall Smith

I shall return.

Douglas MacArthur

Outline

F.1 Introduction

F.2 Documentation Comments

F.3 Documenting Java Source Code

F.4 javadoc

F.5 Files Produced by javadoc

Summary • Terminology

F.1 Introduction

In this appendix, we provide an introduction to the Java 2 Software Developent Kit’s javadoc utility for creating HTML files that document Java code. This is the tool used by Sun Microsystems to create the Java API documentation (Fig. F.1). We discuss the special Java comments and tags required by javadoc to create documentation based on your source code and how to execute the javadoc tool.

For detailed information on javadoc, visit the javadoc home page at

java.sun.com/j2se/1.3/docs/tooldocs/javadoc/index.html

F.2 Documentation Comments

Before HTML files can be generated with the javadoc tool, programmers must insert special comments—called documentation comments—into their source files. Documentation comments are the only comments recognized by javadoc. Documentation comments begin with /** and end with */. An example of a simple documentation comment is

/** Sorts integer array using MySort algorithm */

Like other comments, documentation comments are not translated into bytecodes. Because javadoc is used to create HTML files, documentation comments can contain HTML tags. For example, the documentation comment

/** Sorts integer array using <em>MySort</em> algorithm */

which contains the HTML emphasis tags <em> and </em> is valid. In the generated HTML files, MySort will appear as emphasized text (normally italic). As we will see, javadoc tags can be inserted into the documentation comments to help javadoc document your source code. These tags—which begin with an @ symbol—are not HTML tags.

F.3 Documenting Java Source Code

Figure F.2 presents a modified version of the Time3 class from Fig. 8.8 that contains documentation comments. In the text that follows the example, we thoroughly discuss each of the javadoc tags used in the documentation comments. We discuss how to use the javadoc tool to generate HTML documentation from this file in Section F.4.

links to classes and interfaces are displayed in this frame. Interfaces are italicized

Fig. F.1 Java API documentation.

1// Fig. F.2: Time3.java

2 // Time3 class definition with set and get methods 3 package com.deitel.jhtp4.appenF;

4

5// Java core packages

6 import java.text.DecimalFormat;

7

8/**

9 * This class maintains the time in 24-hour format.

10* @see java.lang.Object

11* @author Deitel & Associates, Inc.

12*/

13public class Time3 extends Object {

Fig. F.2 A Java source code file containing documentation comments (part 1 of 5).

Fig. F.3 HTML documentation for class Time3.

Software Engineering Observation F.1

Defining several fields in one comma-separated statement with a single comment above that statement, will result in javadoc using that comment for all of the fields.

The documentation comment on lines 32–37 describes one of the Time3 constructors. The tag @param describes a parameter to the method. Parameters appear in the HTML document in a Parameters: note (Fig. F.4) that is followed by a list of all parameters specified with the @param tag. For this constructor, the parameter’s name is h and its description is “the hour.” Tag @param can be used only with methods and constructors.

The tag @throws specifies the exceptions thrown by this method. Like @param tags, @throws tags are only used with methods and constructors. One @throws should be supplied for each type of exception thrown by the method.

Software Engineering Observation F.2

To produce proper javadoc documentation, you must declare every instance variable on a separate line.

Documentation comments can contain multiple @param and @see tags. The documentation comment at lines 79–89 describes method setTime. The HTML generated for this method is shown in Fig. F.5. Three @param tags describe the method’s parameters. This results in one Parameters: note which lists the three parameters. Methods setHour, setMinute and setSecond are tagged with @see to create hyperlinks to their descriptions in the HTML document. A # character is used instead of a dot when tagging a method or a field. This creates a link to the name that follows the # character. We demon-

F.4 javadoc

In this section, we discuss how to execute the javadoc tool on a Java source file to create HTML documentation for the class in the file. Like other tools, javadoc is executed from the command line. The general form of the javadoc command is

javadoc options packages sources @files

where options is a list of command line options, packages is a list of packages the user would like to document, sources is a list of java source files to document and @files is a text file containing the names of packages and/or source files to send to the javadoc utility, so that it can create documentation for those packages and classes. The wildcard character * can be used to specify multiple sources. (e.g., c:\*.java) [Note: All items are separated by spaces and @files is one word.] Figure F.8 shows a DOS window containing the javadoc command we typed to generate the HTML documentation.

In Fig. F.8, the -d argument specifies the directory (e.g., c:\docs) where the HTML files will be stored on disk. We use the -link option so that our documentation links to Sun’s documentation. This creates a hyperlink between our documentation and Sun’s documentation (see Fig. F.5 where Java class Exception from package java.lang is hyperlinked). Without the -link argument, Exception appears as text in the HTML doc- ument—not a hyperlink. The -author argument instructs javadoc to process the @author tag (it ignores this tag by default).

F.5 Files Produced by javadoc

In the last section, we executed the javadoc tool on the Time3.java file. When javadoc executes, it displays the name of each HTML file it creates (see Fig. F.8). From the source file, javadoc created an HTML document named Time3.html for the class. If the source file contained multiple classes or interfaces, a separate HTML document is created for each class. Because class Time3 belongs to a package, the page is created in the directory C:\docs\com\deitel\jhtp4\appenF (on Win32 platforms). The c:\docs directory was specified with the -d command line option of javadoc, and the remaining directories were created based on the package statement.

Fig. F.8 Using the javadoc tool.

Another file that javadoc creates is index.html the starting HTML page in the documentation. To view the documentation you generate with javadoc, load index.html into your web browser. In Fig. F.9, the right frame contains the page index.html and the left frame contains the page allclasses-frame.html which contains links to the source code’s classes. [Note: Because our example does not contain multiple packages, there is no frame listing the packages. Normally this frame would appear above the left frame (containing “All Classes”) as in Fig. F.1.]

The navigation bar (at the top of the right frame in Fig. F.9) indicates which HTML page is currently loaded by highlighting the page’s link (e.g., the Class link in Fig. F.9).

Clicking the Tree link (Fig. F.10) displays a class hierarchy for all the classes displayed in the left frame. In our example, we documented only class Time3—which extends Object. Clicking the Deprecated link loads deprecated-list.html into the right frame. This page contains a list of all deprecated names. Because we did not use the @deprecated tag in this example, this page does not contain any information. Clicking the Index link loads the index-all.html page which contains an alphabetical list of all classes, interfaces, methods and fields.

Figure F.11 shows class Time3’s index-all.html page loaded into a Web browser. Clicking the Help link loads helpdoc.html (Fig. F.12). This is a help file for navigating the documentation. A default help file is provided, however the programmer can specify other help files.

Among the other files generated by javadoc are serialized-form.html which documents Serializable and Externalizable classes and package-list.txt which is used by the -link command-line argument and is not actually part of the documentation.

Appendix F Creating HTML Documentation with javadoc (on CD) 1383

TERMINOLOGY

G

Elevator Events

and Listener Interfaces

(on CD)

G.1 Introduction

In “Thinking About Objects” Section 10.22, we discussed how event handling works in our elevator simulation. We mentioned that for an object to receive an event, that object must register as a listener for that event. Therefore, the class of that object must implement an appropriate listener interface that contains methods that receive an event object as a parameter. In this section, we present the events and listener interfaces used in our simulation.

G.2 Events

The next eight figures (Fig. G.1–Fig. G.7) contain the events of the system. Each event inherits from class ElevatorModelEvent in Fig. G.1. This class contains a Location reference (line 11) that represent where the event was generated—in our simulation, this reference is the Elevator object or either Floor object. Class ElevatorModelEvent also contains an Object reference (line 14) representing the source object that generated the event. Methods getLocation (lines 30–33) and getSource (lines 42–45) return the Location and Object references, respectively. Note that each subclass of ElevatorModelEvent (Fig. G.2–Fig. G.7) provides only a constructor calling the constructor of class ElevatorModelEvent. As we mentioned in Section 10.22, dividing class ElevatorModelEvent into several subclass events makes event handling easier to understand in our simulation.

1// ElevatorModelEvent.java

2 // Basic event packet in Elevator simulation

3 package com.deitel.jhtp4.elevator.event;

4

Fig. G.1 ElevatorModelEvent superclass for events in the elevator simulation model (part 1 of 2).

5// Deitel packages

6 import com.deitel.jhtp4.elevator.model.*;

7

8 public class ElevatorModelEvent {

9

10// Location where ElevatorModelEvent was generated

11private Location location;

12

13// source Object that generated ElevatorModelEvent

14private Object source;

15

16// ElevatorModelEvent constructor sets Location

17public ElevatorModelEvent( Object source, Location location )

18{

19setSource( source );

20setLocation( location );

21}

22

23// set ElevatorModelEvent Location

24public void setLocation( Location eventLocation )

25{

26location = eventLocation;

27}

28

29// get ElevatorModelEvent Location

30public Location getLocation()

31{

32return location;

33}

34

35// set ElevatorModelEvent source

36private void setSource( Object eventSource )

37{

38source = eventSource;

39}

40

41// get ElevatorModelEvent source

42public Object getSource()

43{

44return source;

45}

46}

Fig. G.1 ElevatorModelEvent superclass for events in the elevator simulation model (part 2 of 2).

1// BellEvent.java

2// Indicates that Bell has rung

3 package com.deitel.jhtp4.elevator.event;

4

Fig. G.2 BellEvent ElevatorModelEvent subclass indicating that the

Bell has rung (part 1 of 2).

5// Deitel packages

6 import com.deitel.jhtp4.elevator.model*;

7

8 public class BellEvent extends ElevatorModelEvent {

9

10// BellEvent constructor

11public BellEvent( Object source, Location location )

12{

13super( source, location );

14}

15}

Fig. G.2 BellEvent ElevatorModelEvent subclass indicating that the

Bell has rung (part 2 of 2).

1// ButtonEvent.java

2 // Indicates that a Button has changed state

3 package com.deitel.jhtp4.elevator.event;

4

5// Deitel packages

6 import com.deitel.jhtp4.elevator.model.*;

7

8 public class ButtonEvent extends ElevatorModelEvent {

9

10// ButtonEvent constructor

11public ButtonEvent( Object source, Location location )

12{

13super( source, location );

14}

15}

Fig. G.3 ButtonEvent ElevatorModelEvent subclass indicating that a

Button has changed state.

1// DoorEvent.java

2 // Indicates that a Door has changed state

3 package com.deitel.jhtp4.elevator.event;

4

5// Deitel packages

6 import com.deitel.jhtp4.elevator.model.*;

7

8 public class DoorEvent extends ElevatorModelEvent {

9

10// DoorEvent constructor

11public DoorEvent( Object source, Location location )

12{

13super( source, location );

14}

15}

Fig. G.4 DoorEvent ElevatorModelEvent subclass indicating that a Door has changed state.

1// ElevatorMoveEvent.java

2 // Indicates on which Floor the Elevator arrived or departed 3 package com.deitel.jhtp4.elevator.event;

4

5// Deitel packages

6 import com.deitel.jhtp4.elevator.model.*;

7

8 public class ElevatorMoveEvent extends ElevatorModelEvent {

9

10// ElevatorMoveEvent constructor

11public ElevatorMoveEvent( Object source, Location location )

12{

13super( source, location );

14}

15}

Fig. G.5 ElevatorMoveEvent ElevatorModelEvent subclass indicating on which Floor the Elevator has either arrived or departed.

1// LightEvent.java

2 // Indicates on which Floor the Light has changed state 3 package com.deitel.jhtp4.elevator.event;

4

5// Deitel packages

6 import com.deitel.jhtp4.elevator.model.*;

7

8 public class LightEvent extends ElevatorModelEvent {

9

10// LightEvent constructor

11public LightEvent( Object source, Location location )

12{

13super( source, location );

14}

15}

Fig. G.6 LightEvent ElevatorModelEvent subclass indicating on which

Floor the Light has changed state.

Class PersonMoveEvent (Fig. G.7) has a slightly different structure than that of the other event classes. Line 11 declares int attribute ID. We will discover in Appendix I that the ElevatorView obtains this attribute through method getID (lines 22–25) to determine which Person sent the event.

1// PersonMoveEvent.java

2// Indicates that a Person has moved

3 package com.deitel.jhtp4.elevator.event;

4

5// Deitel packages

6import com.deitel.jhtp4.elevator.model.*;

Fig. G.7 PersonMoveEvent ElevatorModelEvent subclass indicating that a Person has moved (part 1 of 2).

7

8 public class PersonMoveEvent extends ElevatorModelEvent {

9

10// identifier of Person sending Event

11private int ID;

12

13// PersonMoveEvent constructor

14public PersonMoveEvent( Object source, Location location,

15int identifier )

16{

17super( source, location );

18ID = identifier;

19}

20

21// return identifier

22public int getID()

23{

24return( ID );

25}

26}

Fig. G.7 PersonMoveEvent ElevatorModelEvent subclass indicating that a Person has moved (part 2 of 2).

G.3 Listeners

The next eight figures (Fig. G.8–Fig. G.14) contain the listener interfaces for the elevator simulation. BellListener (Fig. G.8) provides method bellRang (lines 8), which is invoked when the Bell has rung. ButtonListener (Fig. G.9) provides methods buttonPressed (line 8) and buttonReset (line 11), which listen when a Button is pressed or reset. DoorListener (Fig. G.10) provides methods doorOpened (line 8) and doorClosed (line 11), which listen for a Door opening or closing. ElevatorMoveListener (Fig. G.11) provides methods elevatorDeparted (line 8) and elevatorArrived (line 11), which listen for Elevator departures and arrivals. LightListener (Fig. G.12) provides methods lightTurnedOn (line 8) and lightTurnedOff (line 11) that listen for Light state changes. PersonMoveListener (Fig. G.13) provides methods personCreated (line 8), personArrived

(line 11), personDeparted (line 14), personPressedButton (line 17–18), personEntered (line 21) and personExited (line 24). These methods listen for when a Person has been created, has arrived at or departed from the Elevator, pressed a Button, entered the Elevator, or exited the simulation, respectively. Lastly, ElevatorModelListener (Fig. G.14) inherits behaviors from all listener interfaces. The

ElevatorView uses interface ElevatorModelListener in Section 13.17 and Appendix I to receive events from the ElevatorModel.

1// BellListener.java

2// Method invoked when Bell has rung

3 package com.deitel.jhtp4.elevator.event;

4

Fig. G.8 Interface BellListener method when Bell has rung (part 1 of 2).

5 public interface BellListener {

6

7// invoked when Bell has rungs

8 public void bellRang( BellEvent bellEvent );

9}

Fig. G.8 Interface BellListener method when Bell has rung (part 2 of 2).

1// ButtonListener.java

2 // Methods invoked when Button has been either pressed or reset 3 package com.deitel.jhtp4.elevator.event;

4

5 public interface ButtonListener {

6

7// invoked when Button has been pressed

8 public void buttonPressed( ButtonEvent buttonEvent );

9

10// invoked when Button has been reset

11public void buttonReset( ButtonEvent buttonEvent );

12}

Fig. G.9 Interface ButtonListener methods when Button has been either pressed or reset.

1// DoorListener.java

2 // Methods invoked when Door has either opened or closed 3 package com.deitel.jhtp4.elevator.event;

4

5 public interface DoorListener {

6

7// invoked when Door has opened

8 public void doorOpened( DoorEvent doorEvent );

9

10// invoked when Door has closed

11public void doorClosed( DoorEvent doorEvent );

12}

Fig. G.10 Interface DoorListener methods when Door has either opened or closed.

1// ElevatorMoveListener.java

2 // Methods invoked when Elevator has either departed or arrived 3 package com.deitel.jhtp4.elevator.event;

4

5 public interface ElevatorMoveListener {

6

7// invoked when Elevator has departed

8 public void elevatorDeparted( ElevatorMoveEvent moveEvent );

9

Fig. G.11 Interface ElevatorMoveListener methods when Elevator has either departed from or arrived on a Floor (part 1 of 2).

10// invoked when Elevator has arrived

11public void elevatorArrived( ElevatorMoveEvent moveEvent );

12}

Fig. G.11 Interface ElevatorMoveListener methods when Elevator has either departed from or arrived on a Floor (part 2 of 2).

1// LightListener.java

2 // Methods invoked when Light has either turned on or off 3 package com.deitel.jhtp4.elevator.event;

4

5 public interface LightListener {

6

7// invoked when Light has turned on

8 public void lightTurnedOn( LightEvent lightEvent );

9

10// invoked when Light has turned off

11public void lightTurnedOff( LightEvent lightEvent );

12}

Fig. G.12 Interface LightListener method for when Light has either turned on or off.

1// PersonMoveListener.java

2// Methods invoked when Person moved

3 package com.deitel.jhtp4.elevator.event;

4

5 public interface PersonMoveListener {

6

7// invoked when Person has been instantiated in model

8 public void personCreated( PersonMoveEvent moveEvent );

9

10// invoked when Person arrived at elevator

11public void personArrived( PersonMoveEvent moveEvent );

13// invoked when Person departed from elevator

14public void personDeparted( PersonMoveEvent moveEvent );

16// invoked when Person pressed Button

17public void personPressedButton(

18PersonMoveEvent moveEvent );

19

20// invoked when Person entered Elevator

21public void personEntered( PersonMoveEvent moveEvent );

23// invoked when Person exited simulation

24public void personExited( PersonMoveEvent moveEvent );

25}

Fig. G.13 Interface PersonMoveListener methods when Person has moved.

1// ElevatorModelListener.java

2 // Listener for ElevatorView from ElevatorModel

3 package com.deitel.jhtp4.elevator.event;

4

5// ElevatorModelListener inherits all Listener interfaces

6 public interface ElevatorModelListener extends BellListener,

7 ButtonListener, DoorListener, ElevatorMoveListener,

8 LightListener, PersonMoveListener {

9}

Fig. G.14 Interface ElevatorModelListener allows the model to send all events to the view.

G.4 Component Diagrams Revisited

In Section 13.17, we introduced the component diagram for the elevator simulation. In our simulation, the ElevatorView and every object in the model import package event. Figure G.15 presents the component diagram for package event. Each component in package event maps to a class from Fig. G.1–Fig. G.14. According to the component diagram, ElevatorView.java of package view aggregates package event. In Java, this aggregation translates to class ElevatorView importing package event. Also according to Fig. G.15, package model aggregates package event—i.e., each component in package model contains an aggregation with all components in pacckage event. (We show all components of package model in a separate component diagram in Appendix H.) In Java, this aggregation translates to each class in package model that imports ‘package event.

This concludes the appendix on the events and listener interfaces of the elevator simulation. We hope you have found it a useful reference for the material on event handling discussed in “Thinking About Objects” Section 10.22. In the next two appendices, we implement the design for the model and the view, and we provide the component diagrams for packages model and view.

event

11

Fig. G.15 Component diagram for package event.

H

Elevator Model (on CD)

H.1 Introduction

After reading the “Thinking About Objects” sections, you should have a comfortable grasp of the design process and of the UML diagrams that pertain to our simulation. This appendix presents the code for all 10 classes that collectively represent the model, and concludes the discussion of its workings. We discuss each class separately and in detail.

H.2 Class ElevatorModel

As discussed in Section 13.17, class ElevatorModel (Fig. H.1) ties together the objects that comprise the elevator simulation model. The ElevatorModel serves to send events from the model to the view. The ElevatorModel also instantiates new Persons and allows each Floor to obtain a reference to the ElevatorShaft.

1// ElevatorModel.java

2 // Elevator simulation model with ElevatorShaft and two Floors 3 package com.deitel.jhtp4.elevator.model;

4

5 // Java core packages

6 import java.util.*;

7

8// Deitel packages

9import com.deitel.jhtp4.elevator.event.*;

10 import com.deitel.jhtp4.elevator.ElevatorConstants;

11

12public class ElevatorModel implements ElevatorModelListener,

13ElevatorConstants {

14

Fig. H.1 Class ElevatorModel represents the model in our elevator simulation (part 1 of 7).

15// declare two-Floor architecture in simulation

16private Floor firstFloor;

17private Floor secondFloor;

18

19// ElevatorShaft in simulation

20private ElevatorShaft elevatorShaft;

22// objects listening for events from ElevatorModel

23private Set personMoveListeners;

24private DoorListener doorListener;

25private ButtonListener buttonListener;

26private LightListener lightListener;

27private BellListener bellListener;

28private ElevatorMoveListener elevatorMoveListener;

30// cumulative number of people in simulation

31private int numberOfPeople = 0;

32

33// constructor instantiates ElevatorShaft and Floors

34public ElevatorModel()

35{

36// instantiate firstFloor and secondFloor objects

37firstFloor = new Floor( FIRST_FLOOR_NAME );

38secondFloor = new Floor( SECOND_FLOOR_NAME );

39

40// instantiate ElevatorShaft object

41elevatorShaft =

44// give elevatorShaft reference to first and second Floor

45firstFloor.setElevatorShaft( elevatorShaft );

46secondFloor.setElevatorShaft( elevatorShaft );

47

48// register for events from ElevatorShaft

49elevatorShaft.setDoorListener( this );

50elevatorShaft.setButtonListener( this );

51elevatorShaft.addElevatorMoveListener( this );

52elevatorShaft.setLightListener( this );

53elevatorShaft.setBellListener( this );

54

55// instantiate Set for ElevatorMoveListener objects

56personMoveListeners = new HashSet( 1 );

57

58 } // end ElevatorModel constructor

59

60// return Floor with given name

61private Floor getFloor( String name )

62{

63if ( name.equals( FIRST_FLOOR_NAME ) )

64return firstFloor;

65else

66

Fig. H.1 Class ElevatorModel represents the model in our elevator simulation (part 2 of 7).

74// add Person to Elevator Simulator

75public void addPerson( String floorName )

76{

77// instantiate new Person and place on Floor

78Person person =

79new Person( numberOfPeople, getFloor( floorName ) );

80person.setName( Integer.toString( numberOfPeople ) );

82// register listener for Person events

83person.setPersonMoveListener( this );

85// start Person thread

86person.start();

87

88// increment number of Person objects in simulation

89numberOfPeople++;

90

91 } // end method addPerson

92

93// invoked when Elevator has departed from Floor

94public void elevatorDeparted(

95ElevatorMoveEvent moveEvent )

96{

97elevatorMoveListener.elevatorDeparted( moveEvent );

98}

99

100// invoked when Elevator has arrived at destination Floor

101public void elevatorArrived(

102ElevatorMoveEvent moveEvent )

103{

104elevatorMoveListener.elevatorArrived( moveEvent );

105}

106

107// send PersonMoveEvent to listener, depending on event type

108private void sendPersonMoveEvent(

109int eventType, PersonMoveEvent event )

110{

111Iterator iterator = personMoveListeners.iterator();

Fig. H.1 Class ElevatorModel represents the model in our elevator simulation (part 3 of 7).

153}

154}

155} // end method sendPersonMoveEvent

157// invoked when Person has been created in model

158public void personCreated( PersonMoveEvent moveEvent )

159{

160sendPersonMoveEvent( Person.PERSON_CREATED, moveEvent );

161}

162

163// invoked when Person has arrived at Floor's Button

164public void personArrived( PersonMoveEvent moveEvent )

165{

166sendPersonMoveEvent( Person.PERSON_ARRIVED, moveEvent );

167}

168

Fig. H.1 Class ElevatorModel represents the model in our elevator simulation (part 4 of 7).

169// invoked when Person has pressed Button

170public void personPressedButton( PersonMoveEvent moveEvent )

171{

172sendPersonMoveEvent( Person.PERSON_PRESSING_BUTTON,

173moveEvent );

174}

175

176// invoked when Person has entered Elevator

177public void personEntered( PersonMoveEvent moveEvent )

178{

179sendPersonMoveEvent( Person.PERSON_ENTERING_ELEVATOR,

180moveEvent );

181}

182

183// invoked when Person has departed from Elevator

184public void personDeparted( PersonMoveEvent moveEvent )

185{

186sendPersonMoveEvent( Person.PERSON_EXITING_ELEVATOR,

187moveEvent );

188}

189

190// invoked when Person has exited Simulation

191public void personExited( PersonMoveEvent moveEvent )

192{

193sendPersonMoveEvent( Person.PERSON_EXITED, moveEvent );

194}

195

196// invoked when Door has opened

197public void doorOpened( DoorEvent doorEvent )

198{

199doorListener.doorOpened( doorEvent );

200}

201

202// invoked when Door has closed

203public void doorClosed( DoorEvent doorEvent )

204{

205doorListener.doorClosed( doorEvent );

206}

207

208// invoked when Button has been pressed

209public void buttonPressed( ButtonEvent buttonEvent )

210{

211buttonListener.buttonPressed( buttonEvent );

212}

213

214// invoked when Button has been reset

215public void buttonReset( ButtonEvent buttonEvent )

216{

217buttonListener.buttonReset( buttonEvent );

218}

219

Fig. H.1 Class ElevatorModel represents the model in our elevator simulation (part 5 of 7).

220// invoked when Bell has rung

221public void bellRang( BellEvent bellEvent )

222{

223bellListener.bellRang( bellEvent );

224}

225

226// invoked when Light has turned on

227public void lightTurnedOn( LightEvent lightEvent )

228{

229lightListener.lightTurnedOn( lightEvent );

230}

231

232// invoked when Light has turned off

233public void lightTurnedOff( LightEvent lightEvent )

234{

235lightListener.lightTurnedOff( lightEvent );

236}

237

238// set listener for ElevatorModelListener

239public void setElevatorModelListener(

240ElevatorModelListener listener )

241{

242// ElevatorModelListener extends all interfaces below

243addPersonMoveListener( listener );

244setElevatorMoveListener( listener );

245setDoorListener( listener );

246setButtonListener( listener );

247setLightListener( listener );

248setBellListener( listener );

249}

250

251// set listener for PersonMoveEvents

252public void addPersonMoveListener(

253PersonMoveListener listener )

254{

255personMoveListeners.add( listener );

256}

257

258// set listener for DoorEvents

259public void setDoorListener( DoorListener listener )

260{

261doorListener = listener;

262}

263

264// set listener for ButtonEvents

265public void setButtonListener( ButtonListener listener )

266{

267buttonListener = listener;

268}

269

Fig. H.1 Class ElevatorModel represents the model in our elevator simulation (part 6 of 7).

270// add listener for ElevatorMoveEvents

271public void setElevatorMoveListener(

272ElevatorMoveListener listener )

273{

274elevatorMoveListener = listener;

275}

276

277// set listener for LightEvents

278public void setLightListener( LightListener listener )

279{

280lightListener = listener;

281}

282

283// set listener for BellEvents

284public void setBellListener( BellListener listener )

285{

286bellListener = listener;

287}

288}

Fig. H.1 Class ElevatorModel represents the model in our elevator simulation (part 7 of 7).

The class diagram in Fig. 15.21 shows that class ElevatorModel contains one instance of class ElevatorShaft and two instances of class Floor, so ElevatorModel declares object elevatorShaft (line 20) and objects firstFloor and secondFloor (lines 16–17). Lines 37–46 instantiate these objects and give each Floor object a reference to the ElevatorShaft object. Fig. 15.21 also shows that class ElevatorModel creates Person objects. According to Fig. 15.21, class ElevatorModel contains method addPerson (lines 75–91), which creates and places a Person on the specified Floor. Line 86 of method addPerson starts the Person’s thread and line 89 increments the cumulative number of Person objects in the simulation.

As previously mentioned, class ElevatorModel sends events from the model to the view. The class declaration (lines 12–13) and lines 49–53 reveal that the ElevatorModel listens for several types of events from the ElevatorShaft—this is how the ElevatorModel receives events from the objects that comprise the model. Specifically, class ElevatorModel implements interface ElevatorModelListener, which implements all interfaces in package event. Lines 23–28 declare the listener objects to which the ElevatorModel sends the events it receives from the ElevatorShaft. As mentioned in Section 13.17, the ElevatorFrame (the application) registers the ElevatorView as a listener for events from the ElevatorModel—this is how the ElevatorModel sends events from the model to the view.

Lines 94–236 of class ElevatorModel implement all methods of interface ElevatorModelListener, and lines 239–288 provide addListener methods to register a listener (in this case, the listener is the ElevatorView) for all events. In fact, twothirds of the class devotes itself to “bubbling up” messages from the model to the view.

We presented a class diagram that showed the realizations of the elevator model in Fig. 11.27. We alter this diagram to accommodate the fact that class ElevatorModel implements all interfaces through interface ElevatorModelListener. In addition, class ElevatorShaft must implement more interfaces to receive events from class

ElevatorModelListener

ElevatorModel

Fig. H.3 Class diagram showing realizations in the elevator model (Part 2).

Fig. H.4 Classes and implemented listener interfaces from Fig. H.2.

H.3 Classes Location and Floor

We need to represent the location of the Person in the simulation. The Person could have an int attribute describing on which Floor the Person is walking; however, the Person does not occupy either Floor when riding the Elevator. As described in “Thinking About Objects” Section 9.23, our solution is for the Person to maintain a Location reference, which references either a Floor or the Elevator, depending on the whereabouts of the Person. To implement this feature, classes Floor and Elevator extend abstract superclass Location (Fig. H.5).

1// Location.java

2 // Abstract superclass representing location in simulation

3 package com.deitel.jhtp4.elevator.model;

4

5// Deitel packages

6 import com.deitel.jhtp4.elevator.event.*;

7

8 public abstract class Location {

9

10// name of Location

11private String locationName;

13// set name of Location

14protected void setLocationName( String name )

15{

16locationName = name;

17}

18

19// return name of Location

20public String getLocationName()

21{

22return locationName;

23}

24

25// return Button at Location

26public abstract Button getButton();

28// return Door object at Location

29public abstract Door getDoor();

30}

Fig. H.5 Location abstract superclass that represents a location in the simulation.

Location contains String locationName (line 11), which may contain either value firstFloor, secondFloor or elevator to describe the three locations the Person may occupy. Lines 26 and 29 declare abstract methods getButton and getDoor, respectively. Using these methods, a Floor returns references to objects associated with that Floor, and the Elevator returns references to the objects associated with the Elevator. The Location reference allows a Person to press a Button and to know when a Door has opened. For example, if we wish a Person to press a Button, we write

person.getLocation().getButton().pressButton();

Therefore, our use of an abstract superclass provides an alternate means for objects in our model to interact. Figure H.6 presents class Floor, a subclass of class Location. The Floor constructor (lines 15–18) takes as a String argument the value firstFloor or secondFloor to identify the Floor. Line 17 invokes method setLocationName to assign the value of this String to attribute locationName, inherited from superclass Location.

1// Floor.java

2 // Represents a Floor located next to an ElevatorShaft 3 package com.deitel.jhtp4.elevator.model;

4

5// Deitel packages

6 import com.deitel.jhtp4.elevator.ElevatorConstants;

7

8 public class Floor extends Location

9 implements ElevatorConstants {

10

11// reference to ElevatorShaft object

12private ElevatorShaft elevatorShaft;

14// Floor constructor sets name of Floor

15public Floor( String name )

16{

17setLocationName( name );

18}

19

20// get first or second Floor Button, using Location name

21public Button getButton()

22{

23if ( getLocationName().equals( FIRST_FLOOR_NAME ) )

24return getElevatorShaft().getFirstFloorButton();

25else

35// get first or second Floor Door, using Location name

36public Door getDoor()

37{

38if ( getLocationName().equals( FIRST_FLOOR_NAME ) )

39return getElevatorShaft().getFirstFloorDoor();

40else

50// get ElevatorShaft reference

51public ElevatorShaft getElevatorShaft()

52{

Fig. H.6 Class Floor—a subclass of Location—represents a Floor across which a Person walks to the Elevator (part 1 of 2).

53return elevatorShaft;

54}

55

56// set ElevatorShaft reference

57public void setElevatorShaft( ElevatorShaft shaft )

58{

59elevatorShaft = shaft;

60}

61}

Fig. H.6 Class Floor—a subclass of Location—represents a Floor across which a Person walks to the Elevator (part 2 of 2).

Class Floor provides concrete methods getButton (lines 21–33) and getDoor (lines 36–48). Methods getButton and getDoor return a Button and Door reference on either the first or second Floor, depending on which Floor returns the reference. Lastly, method getElevatorShaft (lines 51–54) returns a reference to the ElevatorShaft. We will see later how a Person uses this method, in conjunction with that Person’s Location reference, to enter the Elevator.

H.4 Class Door

The Doors are an essential part of the model, because they inform a Person when to enter and exit the Elevator—without the Doors, no Person would ride the Elevator. The collaboration diagrams of Fig. 7.20, Fig. 10.25 and Fig. 15.18 presented the collaborations among the Doors, the Elevator and the Person. Now, we provide a walkthrough of class Door (Fig. H.7).

1// Door.java

2 // Sends DoorEvents to DoorListeners when opened or closed 3 package com.deitel.jhtp4.elevator.model;

4

5 // Java core packages

6 import java.util.*;

7

8// Deitel packages

9 import com.deitel.jhtp4.elevator.event.*;

10

11 public class Door implements ElevatorMoveListener {

12

13// represent whether Door is open or closed

14private boolean open = false;

15

16// time before Door closes automatically

17public static final int AUTOMATIC_CLOSE_DELAY = 3000;

19// Set of DoorListeners

20private Set doorListeners;

Fig. H.7 Class Door, which represents a Door in the model, informs listeners when a Door has opened or closed (part 1 of 4).

22// location where Door opened or closed

23private Location doorLocation;

24

25// Door constructor instantiates Set for DoorListeners

26public Door()

27{

28doorListeners = new HashSet( 1 );

29}

30

31// add Door listener

32public void addDoorListener( DoorListener listener )

33{

34// prevent other objects from modifying doorListeners

35synchronized( doorListeners )

36{

37doorListeners.add( listener );

38}

39}

40

41// remove Door listener

42public void removeDoorListener( DoorListener listener )

43{

44// prevent other objects from modifying doorListeners

45synchronized( doorListeners )

46{

47doorListeners.remove( listener );

48}

49}

50

51// open Door and send all listeners DoorEvent objects

52public void openDoor( Location location )

53{

54if ( !open ) {

Fig. H.7 Class Door, which represents a Door in the model, informs listeners when a Door has opened or closed (part 2 of 4).

97closeThread.start();

98}

99} // end method openDoor

100

101// close Door and send all listeners DoorEvent objects

102public void closeDoor( Location location )

103{

104if ( open ) {

123}

124}

125} // end method closeDoor

Fig. H.7 Class Door, which represents a Door in the model, informs listeners when a Door has opened or closed (part 3 of 4).

126

127// return whether Door is open or closed

128public boolean isDoorOpen()

129{

130return open;

131}

132

133// invoked after Elevator has departed

134public void elevatorDeparted( ElevatorMoveEvent moveEvent ) {}

136// invoked when Elevator has arrived

137public void elevatorArrived( ElevatorMoveEvent moveEvent )

138{

139openDoor( moveEvent.getLocation() );

140}

141}

Fig. H.7 Class Door, which represents a Door in the model, informs listeners when a Door has opened or closed (part 4 of 4).

Figure 15.12 indicates that class Door contains boolean attribute open (line 14) to represent the state of the Door (open or closed). Figure 15.12 also indicates that class Door contains methods openDoor (lines 52–99) and closeDoor (lines 102–125). Method openDoor sends a doorOpened event to all registered DoorListeners (the Door passes a DoorEvent object to the doorOpened method of each registered DoorListener), and method closeDoor sends a doorClosed event to all registered DoorListeners. Set doorListeners (line 20) stores all registered DoorListeners. A

DoorListener wishing to receive DoorEvents from a Door must invoke method addDoorListener (lines 32–39); those listeners that no longer wish to be a DoorListener for that Door must invoke removeDoorListener (lines 42–49).

Line 56 of method openDoor opens the Door by setting open to true. Lines 66– 73 iterate Set doorListeners and send each object a doorOpened event. Lines 60– 63 use a synchronized block obtaining the Iterator from Set doorListeners, because a Person, at any time, can add or remove itself from this Set. If method openDoor iterates doorListeners as a Person adds or removes itself from doorListeners, the JVM throws a ConcurrentModificationException—the Person is modifying the Set as method openDoor is iterating the same Set. Method openDoor avoids this situation with the synchronized block.

Method openDoor receives as an argument a Location reference on what Floor that Door should open. Lines 71–72 send a DoorEvent using the Location reference to all registered DoorListeners. Method closeDoor sets open to false (thus closing the Door) and invokes the doorClosed method on all registered DoorListeners.

We decided in Section 15.12 to make class Door an active class, so that the Door closes itself after three seconds of being open. Lines 78–95 of method openDoor instantiate a thread that handles this responsibility. Method run (lines 81–93) puts this thread to sleep for three seconds then closes the Door. Line 97 of method openDoor starts the thread.

Lastly, according to Fig. H.2, Door implements ElevatorMoveListener. In our simulation, the Elevator invokes method elevatorDeparted (line 134) when the

Elevator has departed and invokes method elevatorArrived (lines 137–140) when the Elevator has arrived. Method elevatorArrived calls method open- Door—the Door opens when the Elevator has arrived. Method elevatorDeparted does not perform any action. At a first glance, you may wonder why this method does not call method closeDoor. The reason is that a Door should close before the Elevator has departed so the passenger will not be injured—in our model, the Elevator calls method closeDoor before calling elevatorDeparted.

H.5 Class Button

Buttons (Fig. H.8) are important to the model as well, because they signal the Elevator to move between Floors. Figure 15.12 indicates that class Button contains boolean attribute pressed (line 14) to represent the state of the Button (pressed or reset). Figure 15.12 indicates also that class Button contains methods pressButton (lines 23–29) and resetButton (lines 32–38).

1// Button.java

2 // Sends ButtonEvents to ButtonListeners when accessed

3 package com.deitel.jhtp4.elevator.model;

4

5// Deitel packages

6 import com.deitel.jhtp4.elevator.event.*;

7

8 public class Button implements ElevatorMoveListener {

9

10// ButtonListener

11private ButtonListener buttonListener = null;

13// represent whether Button is pressed

14private boolean pressed = false;

15

16// set listener

17public void setButtonListener( ButtonListener listener )

18{

19buttonListener = listener;

20}

21

22// press Button and send ButtonEvent

23public void pressButton( Location location )

24{

25pressed = true;

26

27 buttonListener.buttonPressed(

28new ButtonEvent( this, location ) );

29}

30

31// reset Button and send ButtonEvent

32public void resetButton( Location location )

33{

34pressed = false;

Fig. H.8 Class Button, which represents a Button in the model, informs listeners when a Button has been pressed or reset (part 1 of 2).

35

36 buttonListener.buttonReset(

37new ButtonEvent( this, location ) );

38}

39

40// return whether button is pressed

41public boolean isButtonPressed()

42{

43return pressed;

44}

45

46// invoked when Elevator has departed

47public void elevatorDeparted( ElevatorMoveEvent moveEvent ) {}

49// invoked when Elevator has arrived

50public void elevatorArrived( ElevatorMoveEvent moveEvent )

51{

52resetButton( moveEvent.getLocation() );

53}

54}

Fig. H.8 Class Button, which represents a Button in the model, informs listeners when a Button has been pressed or reset (part 2 of 2).

Method pressButton sends a buttonPressed event to the registered ButtonListener (line 11), and method resetButton sends a buttonReset event to the ButtonListener. Method setButtonListener (lines 17–20) allows an object to receive ButtonEvents by registering itself as the ButtonListener.

Line 25 of method pressButton sets attribute pressed to true, and lines 27–28 pass a ButtonEvent to method buttonPressed of the buttonListener. Line 34 of method resetButton sets attribute pressed to false and line 36–37 pass a ButtonEvent to method buttonReset of the buttonListener.

Lastly, according to Fig. H.2, classes Button implements interface ElevatorMoveListener. Method elevatorArrived (lines 50–53) calls method resetButton to reset the Button.

H.6 Class ElevatorShaft

Class ElevatorShaft (Fig. H.9) represents the ElevatorShaft in which the Elevator travels in the model. Most methods in class ElevatorShaft access private variables, listen for messages from the Elevator and send “bubble up” events to the ElevatorModel, which sends them to the ElevatorView. According to the class diagram of Fig. 15.21, class ElevatorShaft contains one Elevator object, two Button objects, two Door objects and two Light objects. The Button, Door and Light objects refer to the buttons, doors and lights on each Floor. Line 15 declares the Elevator object—elevator. Lines 18–19 declare the Buttons firstFloorButton and secondFloorButton. Lines 22–23 declare the Doors firstFloorDoor and secondFloorDoor. Lines 26–27 declare the Lights firstFloorLight and secondFloorLight. Lines 169–208 provide methods to access references to these objects.

1// ElevatorShaft.java

2 // Represents elevator shaft, which contains elevator

3 package com.deitel.jhtp4.elevator.model;

4

5 // Java core packages

6 import java.util.*;

7

8// Deitel packages

9 import com.deitel.jhtp4.elevator.event.*;

10

11public class ElevatorShaft implements ElevatorMoveListener,

12LightListener, BellListener {

13

14// Elevator

15private Elevator elevator;

17// Buttons on Floors

18private Button firstFloorButton;

19private Button secondFloorButton;

21// Doors on Floors

22private Door firstFloorDoor;

23private Door secondFloorDoor;

25// Lights on Floors

26private Light firstFloorLight;

27private Light secondFloorLight;

29// listeners

30private DoorListener doorListener;

31private ButtonListener buttonListener;

32private LightListener lightListener;

33private BellListener bellListener;

34private Set elevatorMoveListeners;

35

36// constructor initializes aggregated components

37public ElevatorShaft( Floor firstFloor, Floor secondFloor )

38{

39// instantiate Set for ElevatorMoveListeners

40elevatorMoveListeners = new HashSet( 1 );

41

42// anonymous inner class listens for ButtonEvents

43ButtonListener floorButtonListener =