ch37.htm

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

the text string to display, and the column and row at which to

display the text.

<LI>The <TT>paint()</TT> method draws whatever needs to be displayed

in the applet's display area. Java calls <TT>paint()</TT> whenever

the applet needs to be redrawn.

<LI>One way to get user input is to add a <TT>TextField</TT> control

to your applet.

<LI>Java calls the <TT>init()</TT> method almost immediately after

an applet starts up in order to enable you to initialize objects

needed by the applet.

<LI>Java calls the <TT>action()</TT> method whenever the user

does something with the applet's controls. For example, when the

user types text into a <TT>TextField</TT> control and presses

Enter, Java calls <TT>action()</TT> so that the applet can respond

to the user's input.

<LI>To convert a numerical value to a string, you call the <TT>String</TT>

class's <TT>valueOf()</TT> method.

</OL>

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

Chapter 7</FONT></A></H2>

<OL>

<LI>The addition, subtraction, multiplication, and division operators

are +, &ETH;, *, and /, respectively.

<LI><TT>5*3</TT> equals 15.

<LI><TT>3 &ETH; 2 + 5 + 6 &ETH;1</TT> equals 11.

<LI>The ++ operator increments the variable, so <TT>num</TT> ends

up equal to 13.

<LI><TT>12 % 5</TT> equals 2.

<LI>If <TT>num</TT> equals 25, the expression <TT>num += 5</TT>

makes <TT>num</TT> equal to 30.

<LI>You set the text is a <TT>TextField</TT> object by calling

<TT>TextField's</TT> <TT>setText()</TT> method.

<LI><TT>12 + 3 * 6 / 2</TT> equals 21.

<LI>You can change <TT>3 / 5</TT> from integer to floating-point

division by changing one or both of the numbers to a floating-point

value, like this: <TT>3f / 5f</TT>.

<LI>You cast the result of <TT>56 &ETH; 34.56f</TT> to integer

like this: <TT>(int)(56 &ETH; 34.56f)</TT>.

<LI>You convert digits in a string to an integer by calling the

<TT>Integer</TT> class's <TT>parseInt()</TT> method.

<LI> (12 &ETH; 8) * 10 / 2 * 2 equals 40.

</OL>

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

Chapter 8</FONT></A></H2>

<OL>

<LI>An expression is a line of program code that can be reduced

to a value or that assigns a value to a variable or constant.

<LI> The three types of expressions are numerical, assignment,

and logical.

<LI>The expression <TT>(3 &lt; 5)</TT> equals <TT>true</TT>.

<LI>The expression <TT>(3 &lt; 5) &amp;&amp; (5 == 4 + 1)</TT>

equals <TT>true</TT>.

<LI>Expressions are recursive because they can contain other smaller

expressions, which in turn may contain other expressions.

<LI>The six comparison operators are <TT>==</TT> (equals), <TT>!=</TT>

(not equal), <TT>&lt;</TT> (less than), <TT>&gt;</TT> (greater

than), <TT>&lt;=</TT> (less than or equals), and <TT>&gt;=</TT>

(greater than or equals).

<LI>The four logical operators are  <TT>!</TT> (NOT), <TT>&amp;&amp;</TT>

(AND), <TT>||</TT> (OR), and <TT>^</TT> (exclusive OR).

<LI>The result of the expression <TT>(3 &lt; 5) || (6 == 5) ||

(3 != 3)</TT> is <TT>true</TT>.

<LI>The result of the expression <TT>(5 != 10) &amp;&amp; ((3

== 2 + 1) || (4 &lt; 2 + 5))</TT> is <TT>true</TT>.

<LI>The result of the expression <TT>!(5 == 2 + 3) &amp;&amp;

!(5 + 2 != 7 - 5)</TT> is false.

</OL>

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

Chapter 9</FONT></A></H2>

<OL>

<LI>Program flow is the order in which program statements are

executed.

<LI>Conditional branching occurs when a program branches to a

new section based on the value of some data. Unconditional branching

is when a computer instruction causes the program to branch regardless

of any conditions.

<LI>Two ways to control program flow are <TT>if</TT> and <TT>switch</TT>

statements.

<LI>No. The second line will execute only when <TT>choice</TT>

equals 3.

<LI>You can write an <TT>if</TT> statement without opening and

closing braces when only one program line will execute if the

condition evaluates to <TT>true</TT>. 

<LI>There is no difference between a logical and a Boolean expression.

They are both expressions that evaluate to <TT>true</TT> or <TT>false</TT>.

<LI>The program skips over both the <TT>if</TT> and the <TT>else

if</TT>.

<LI>The <TT>if</TT> and <TT>switch</TT> statements are similar

in that they both enable the computer to choose a path of execution

based on the value of a control variable. They are different in

that a <TT>switch</TT> statement is more appropriate for situations

in which there are many possible outcomes.

<LI>The variable <TT>num</TT> ends up with the value 3. If your

answer was 2, you didn't notice that the second <TT>case</TT>

has no <TT>break</TT> statement, causing program execution to

drop through to the third <TT>case</TT>.

</OL>

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

Chapter 10</FONT></A></H2>

<OL>

<LI>You should use a loop when your program must perform some

sort of repetitive task.

<LI>The body of the loop comprises the program lines that are

executed each time the loop's conditional expression is true.

<LI>When the conditional expression evaluates to <TT>false</TT>,

the loop ends.

<LI>There is no guarantee on how many times a <TT>while</TT> loop

will execute. It could be any number of times from 0 on up. A

<TT>do-while</TT> loop, on the other hand, always executes at

least once.

<LI>You must properly initialize the loop control variable because

the loop's conditional expression relies on the value of the variable

to determine how many times to loop.

<LI>An infinite loop occurs when a loop's conditional expression

can never result in <TT>false</TT>, causing the loop to repeat

endlessly.

<LI>Both the <TT>while</TT> and <TT>do-while</TT> loops can be

used to perform repetitive tasks in a program. However, the <TT>while</TT>

loop may execute any number of times, including 0, whereas a <TT>do-while</TT>

loop always executes at least once. This is because a <TT>do-while</TT>

loop's conditional expression is at the end of the loop, whereas

a <TT>while</TT> loop's conditional expression is at the beginning

of the loop.

<LI>The loop will execute six times, and <TT>count</TT> will be

equal to 16 at the end of the loop.

</OL>

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

Chapter 11</FONT></A></H2>

<OL>

<LI>You should use a <TT>for</TT> loop when you have a repetitive

task that must be performed a specific number of times.

<LI>The three parts of a <TT>for</TT> loop are the initialization,

condition, and increment sections.

<LI>A <TT>for</TT> loop stops looping when the condition section

becomes false.

<LI>A <TT>for</TT> loop can count backward by decrementing the

control variable in the increment section, rather than incrementing

it.

<LI>A <TT>for</TT> loop can count by tens by adding 10 to the

control variable in the increment section.

<LI>It's possible to create an infinite loop with a <TT>for</TT>

loop, but it's unlikely because the loop control variable is handled

by the loop itself.

<LI>The loop will execute five times, and <TT>x</TT> will be equal

to 13 at the end of the loop.

</OL>

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

Chapter 12</FONT></A></H2>

<OL>

<LI>Top-down programming means organizing source code into levels

that go from general functions to more detailed functions the

further down the hierarchy you go.

<LI>Functions make top-down programming possible by enabling you

to organize source code into well-defined tasks.

<LI>All functions have a return type, but the return type of <TT>void</TT>

means that the function returns no actual value.

<LI>Arguments are values that you pass to a function when you

call it. The receiving function can then access the values almost

as if they were local to the function.

<LI>Defining a function is the act of writing the function's source

code.

<LI>You return a value from a function by using the keyword <TT>return</TT>

followed by the value to be returned. The returned value must

be the same type as the function's defined return type.

<LI>The arguments in the function call must be in the same order

and be of the same type as the arguments given in the function's

definition.

<LI>The best way to break source code up into functions is to

locate the groups of commands that perform a specific task and

then replace those lines with a function call. The lines that

are replaced become the body of the new function.

</OL>

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

Chapter 13</FONT></A></H2>

<OL>

<LI>An array is a data structure that enables you to store many

related values under one variable name.

<LI>You can access the values of an array using loops, which greatly

reduces the amount of source code needed to handle large numbers

of related values.

<LI>An array subscript identifies a specific element of an array.

The subscript is a number or variable enclosed in square brackets.

A subscript and an index are exactly the same thing.

<LI>A two-dimensional array can store values in a table, with

a specific number of columns and rows.

<LI>The largest subscript you can use with a fifty-element array

is 49.

<LI>If you try to access a nonexistent array element, Java generates

an exception.

<LI>A <TT>for</TT> loop is perfect for array access because you

can use the loop control variable as an array subscript.

<LI>To initialize a two-dimensional array with <TT>for</TT> loops,

you'd use nested loops. The outer loop counts through the columns

and the inner loop counts through the rows.

</OL>

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

Chapter 14</FONT></A></H2>

<OL>

<LI>A class is a template from which you create an object. A class

usually contains data fields and methods.

<LI>A class provides an additional level of program abstraction

that enables you to organize data fields, and the methods that

interact with those data fields, within a single structure.

<LI>The three parts of a simple, empty class are the keyword <TT>class</TT>,

followed by the name of the class and the braces that mark off

the body of the class.

<LI>The two program elements that you must add to the empty class

in order to create a complete class are data fields and methods.

<LI>To create an object of a class, you use the <TT>new</TT> operator

followed by a call to the class's constructor.

<LI>To use a class that's defined in a different file, you place

the <TT>import</TT> keyword, followed by the class's name, at

the top of the file that needs access to the class. You must also

be sure that the compiler can find the class, usually by placing

the class files all in the same directory.

<LI>Using inheritance, a new class (subclass) derived from a base

class (superclass) inherits the data fields and methods defined

in the base class. The programmer then only needs to add whatever

additional functionality is required by the new class.

<LI>A subclass is a class that's been derived from another class

using the <TT>extends</TT> keyword. A superclass is the class

from which a subclass is derived. That is, the terms subclass

and base class are equivalent.

<LI>You create a subclass by using the <TT>extends</TT> keyword

like this:<BR>

<TT>class SubClass extends SuperClass<BR>

<FONT FACE="Courier New">{<BR>

}</FONT></TT>

<LI>To override a method, you provide, in your subclass, a method

with exactly the same name, return type, and arguments as the

method of the superclass you want to override. Then, Java will

call your class's version of the method rather than the superclass's

version.

</OL>

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

Chapter 15</FONT></A></H2>

<OL>

<LI>All applets must be derived from Java's <TT>Applet</TT> class.

<LI>Applet classes must be public so that the system can run the

applet. If you fail to declare an applet as <TT>public</TT>, it

will compile fine, but it will not run.

<LI>The five life-cycle stages of an applet are initialization,

start, paint, stop, and destroy.

<LI>The paint cycle isn't an &quot;official&quot; stage in the

applet's life cycle. It isn't, in fact, even defined within the

<TT>Applet</TT> class. Instead, the <TT>paint()</TT> method is

inherited from Java's <TT>Component</TT> class.

<LI>The initialize cycle occurs only once in the applet's life

cycle (when the applet is loaded and prepared to run), whereas

start can occur numerous times (after initialization or whenever

the applet is restarted).

<LI>The <TT>init()</TT>, <TT>start()</TT>, <TT>stop()</TT>, and

<TT>destroy()</TT> methods as they are implemented in the <TT>Applet</TT>

class do absolutely nothing. They are only placeholders that you

can override in your applet class. The same is true of the <TT>paint()</TT>

method.

</OL>

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

Chapter 16</FONT></A></H2>

<OL>

<LI>The area of an applet in which you can draw is called the

canvas.

<LI>The origin of Java's graphical coordinate system is in the

upper left corner with values of X increasing to the right and

values of Y increasing downwards.

<LI>The <TT>drawRect()</TT> method draws a hollow rectangle, whereas

the <TT>fillRect()</TT> method draws a filled (solid) rectangle.

<LI>The four arguments for the <TT>drawRect()</TT> method are

the X,Y coordinates of the rectangle's upper left corner and the

width and height of the rectangle.

<LI>The first four arguments for both <TT>drawRect()</TT> and

<TT>drawRoundRect()</TT> are exactly the same, being the X,Y coordinates,

width, and height of the rectangle. The <TT>drawRoundRect()</TT>

method, however, has two additional arguments that are the width

and height of a rectangle that determines the size of the rounded

corners.

<LI>The <TT>drawPolygon()</TT> method uses arrays to store its

coordinates because a polygon can have any number of sides, which

means that the method call must have a way to pass differing numbers

of points. The arrays enable you to define as many sides as you

need while keeping the method's argument count consistent.

<LI>The six arguments required by the <TT>drawArc()</TT> method

are the X,Y coordinates, width, and height of the bounding rectangle,

as well as the starting drawing angle and the number of degrees

around to draw.

<LI>The <TT>Polygon</TT> class provides several methods that enable

you to manipulate a polygon in various ways.

</OL>

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

Chapter 17</FONT></A></H2>

<OL>

<LI>To get a reference to the currently active font object, you

call the <TT>Graphics</TT> class's <TT>getFont()</TT> method.

<LI>To get a font's name, you can call the <TT>Font</TT> class's

<TT>getName()</TT> method.

<LI>To get a font's height, you can call the <TT>Font</TT> class's

<TT>getHeight()</TT> method.