ch29.htm

Java_by_Example,初级经典例子哦,珍藏版本

<TT>PackageName</TT>. The package line must be the first line

in the class's source code (except for blank lines or comments).

<H3><A NAME="ExampleCreatingaSimplePackage">

Example: Creating a Simple Package</A></H3>

<P>

Suppose that you want to create a class called <TT>DisplayClass</TT>

that returns a test string to be displayed in an applet. You want

this class to be part of a package called DISPLAY. Listing 29.1

shows the source code for the <TT>DisplayClass</TT> class:

<HR>

<BLOCKQUOTE>

<B>Listing 29.1&nbsp;&nbsp;DisplayClass.java: The </B><I>DisplayClass</I><B>

Class.<BR>

</B>

</BLOCKQUOTE>

<BLOCKQUOTE>

<PRE>

package MyPackages.Display;



public class DisplayClass

{

    public String GetDisplayText()

    {

        return &quot;Display Text&quot;;

    }

}

</PRE>

</BLOCKQUOTE>

<HR>

<P>

<CENTER>

<TABLE BORDER=1 WIDTH=80%>

<TR VALIGN=TOP><TD><B>NOTE</B></TD></TR>

<TR VALIGN=TOP><TD>

<BLOCKQUOTE>

When you examine Listing 29.1, you may wonder how <TT>DisplayClass</TT> can reference Java's <TT>String</TT> class without including an <TT>import</TT> line at the top of the listing. The class gets away with this because Java automatically imports the java.lang package, where the <TT>String</TT> class is defined.

</BLOCKQUOTE>



</TD></TR>

</TABLE>

</CENTER>

<P>

<P>

The first line of Listing 29.1 determines not only the name of

the package, but also the way it must be stored on your hard drive.

That is, the DisplayClass.class file must end up in a folder called

Display, which itself must be in a folder called MYPACKAGES. To

compile DisplayClass.java, follow these steps:

<OL>

<LI>In your CLASSES folder, create a folder called MYPACKAGES.

This is where you will create the folders needed by each of the

packages you create.

<LI>In the MYPACKAGES folder, create a folder called DISPLAY.

This folder will hold any of the classes that are part of the

<TT>Display</TT> package.

<LI>Type in Listing 29.1 and save it in the DISPLAY folder, under

the name DisplayClass.java. (If you don't want to type, you can

copy the file from this book's CD-ROM.)

<LI>Select the MS-DOS Prompt command from the Start menu's Program

group and switch to the CLASSES\MYPACKAGES\DISPLAY folder, as

shown in Figure 29.1.<BR>

<A HREF="f29-1.gif"><B> Figure 29.1 : </B><I>To compile a package's class, you must switch to the folder in which the class's source code is stored.



</I></A><P>

<LI>At the MS-DOS prompt, type <TT>javac DisplayClass.java</TT>.

Java's compiler then compiles the DisplayClass.java file, creating

the DisplayClass.class file in your DISPLAY folder.

</OL>

<P>

As you can see in Figure 29.2, if you now look in your DISPLAY

folder, you'll have not only the original source code file for

the <TT>DisplayClass</TT> class, but also the DisplayClass.class

file, which is the class's byte-code representation that Java

can understand. Congratulations! You've just created your first

package.

<P>

<A HREF="f29-2.gif"><B> Figure 29.2 : </B><I>After compiling, you will have the class's .CLASS file on your disk.



</I></A><P>

<H3><A NAME="ExampleUsingtheNewPackage">

Example: Using the New Package</A></H3>

<P>

Now that you've created a package, you'd probably like to use

it in an applet. To do this, you must first import the class into

the applet's source code file. You can then use the class in exactly

the same way you've been using Java's classes throughout this

book. Listing 29.2 is an applet, called PackageApplet, that demonstrates

how to use your new package. Listing 29.3 is the applet's HTML

document.

<HR>

<BLOCKQUOTE>

<B>Listing 29.2&nbsp;&nbsp;PackageApplet.java: An Applet That

Uses Your New Package.<BR>

</B>

</BLOCKQUOTE>

<BLOCKQUOTE>

<PRE>

import java.awt.*;

import java.applet.*;

import MyPackages.Display.DisplayClass;



public class PackageApplet extends Applet

{

    public void paint(Graphics g)

    {

        Font font = new Font(&quot;TimesRoman&quot;, Font.PLAIN, 24);

        g.setFont(font);



        DisplayClass myClass = new DisplayClass();

        String s = myClass.GetDisplayText();



        g.drawString(s, 60, 80);

    }

}

</PRE>

</BLOCKQUOTE>

<HR>

<HR>

<BLOCKQUOTE>

<B>Listing 29.3&nbsp;&nbsp;PACKAGEAPPLET.htmL: PackageApplet's

HTML Document.<BR>

</B>

</BLOCKQUOTE>

<BLOCKQUOTE>

<PRE>

&lt;title&gt;Applet Test Page&lt;/title&gt;

&lt;h1&gt;Applet Test Page&lt;/h1&gt;

&lt;applet

    code=&quot;PackageApplet.class&quot;

    width=250

    height=250

    name=&quot;PackageApplet&quot;&gt;

&lt;/applet&gt;

</PRE>

</BLOCKQUOTE>

<HR>

<P>

Notice how the third line in Listing 29.2 imports the <TT>DisplayClass</TT>

class from the <TT>Display</TT> package. You also could have used

the line <TT>import MyPackages.Display.*</TT>, as you did with

the Java packages in the first two lines of the listing. Because

there is currently only one class in the package, using the asterisk

achieves exactly the same results as specifying the class's name

in the <TT>import</TT> line. However, when you add other classes

to the package, the asterisk will tell Java to include those classes,

as well.

<P>

To see how all this package stuff works with the PackageApplet

applet, follow these steps:

<OL>

<LI>Type in Listings 29.2 and 29.3 and save them in your CLASSES

folder (the same folder that contains your new MYPACKAGES folder).

If you prefer, you can copy the listings from this book's CD-ROM.

<LI>In your DOS window, switch to the CLASSES directory.

<LI>Type <TT>javac PackageApplet.java</TT> to compile the applet

into a .class file.

<LI>Run the applet by typing appletviewer packageapplet.html.

</OL>

<P>

When you run the PackageApplet applet, you see the window shown

in Figure 29.3. The text that's displayed in the applet is acquired

by the call to the <TT>DisplayClass</TT> class's <TT>GetDisplayText()</TT>

method. This class is part of your new <TT>Display</TT> class.

When you run the applet, Java knows where to find the <TT>Display</TT>

class because of the hierarchy of folders you created to mirror

the MYPACKAGES\DISPLAY \ DisplayClass.class hierarchy.

<P>

<A HREF="f29-3.gif"><B> Figure 29.3 : </B><I>PackageApplet displays the text string obtained from a class defined in your new Display package.



</I></A><P>

<H3><A NAME="ExampleExtendingthePackage">

Example: Extending the Package</A></H3>

<P>

Now that you've got the package started, you can extend it simply

by creating new classes that have the line <TT>package MyPackages.Display</TT>

at the top of the source code. Thanks to the folder hierarchy

you've developed (and that Java insists upon), all the class files

(both source and byte-code) in the <TT>Display</TT> package will

end up in the DISPLAY folder. You could have one or a hundred.

<P>

You can add new packages to your growing library by creating folders

inside the MYPACKAGES folder and storing the new classes there.

Suppose, for example, that you want to start a new package called

<TT>Shapes</TT>. The classes you want to add to this package are

called <TT>Star</TT>, <TT>Hexagon</TT>, and <TT>Triangle</TT>.

You'd then follow the steps given here:

<OL>

<LI>Create a folder called SHAPES inside the MYPACKAGES folder.

This is where you'll store all the files associated with the <TT>Shapes</TT>

package.

<LI>Create the <TT>Star</TT>, <TT>Hexagon</TT>, and <TT>Triangle</TT>

classes in separate source-code files, being sure to place the

line <TT>package MyPackages.Shapes;</TT> at the top of each file.

<LI>Switch to the C:\CLASSES\MYPACKAGES\SHAPES folder and type

<TT>javac Star.java</TT> to compile the <TT>Star</TT> class. Compile

the <TT>Hexagon</TT> and <TT>Triangle</TT> classes in the same

way.

<LI>Write the source code for the applet that uses your new <TT>Shapes</TT>

package, storing the file in the C:\CLASSES directory. Remember

to put the line <TT>import MyPackages.Shapes.*;</TT> at the top

of the file. The asterisk ensures that all classes in the <TT>Shapes</TT>

package are imported into the program.

</OL>

<H2><A NAME="Interfaces"><FONT SIZE=5 COLOR=#Ff0000>

Interfaces</FONT></A></H2>

<P>

Packages are fairly easy to understand, being little more than

a way to organize related classes, whether supplied with Java

or created by a programmer like yourself. Interfaces, on the other

hand, are a concept that is a bit harder to grasp. To really understand

Java's interfaces, you have to know about something called multiple

inheritance, which is not allowed in Java, but which is often

used in other object-oriented languages.

<P>

Multiple inheritance means creating a new class that inherits

behavior directly from more than one superclass. To make this

concept a little clearer, look at how you derive classes from

superclasses in Java. For example, every applet you've created

so far has been derived from Java's <TT>Applet</TT> class, like

this:

<BLOCKQUOTE>

<PRE>

public class AppletName extends Applet

</PRE>

</BLOCKQUOTE>

<P>

The preceding line tells Java that you want to create a new class

that inherits the data fields and methods of the <TT>Applet</TT>

class. This is a sample of single inheritance. Now, suppose that

you had a class of your own, called <TT>MyClass</TT>, that implemented

some capabilities that you also want your new applet to inherit.

In a language like C++, you simply add the class to a list of

superclasses, like this:

<BLOCKQUOTE>

<PRE>

public class AppletName extends Applet, MyClass

</PRE>

</BLOCKQUOTE>

<P>

This would be an example of multiple inheritance if Java allowed

such a thing. However, for many reasons, Java's designers decided

that multiple inheritance was too cumbersome and unpredictable

to be useful. They still liked the idea, though, of being able