added many index terms

Author: ChrisMayfield

appa.tex

@@ -71,6 +71,8 @@ \section{DrJava interactions}
 It provides the ability to try out code quickly, without having to write a class definition and save/compile/run the program.
 Figure~\ref{fig.drjava2} shows an example.
 
+\index{interactions}
+
 \begin{figure}[!ht]
 \begin{center}
 \includegraphics[width=\textwidth]{figs/drjava-logic.png}
@@ -125,6 +127,8 @@ \section{Command-line interface}
 \section{Command-line testing}
 \label{cltesting}
 
+\index{testing}
+
 As described in Section~\ref{sec:examples}, it's more effective to program and debug your code little by little than to attempt writing everything all at once.
 And after you've completed programming an algorithm, it's important to test that it works correctly on a variety of inputs.
 
@@ -165,6 +169,7 @@ \section{Command-line testing}
 \end{enumerate}
 
 \index{redirection operator}
+\index{operator!redirection}
 \index{System.in}
 \index{System.out}
 
@@ -284,6 +289,8 @@ \section{Tracing with a debugger}
 \end{center}
 \end{figure}
 
+\index{tracing}
+
 To the right are several buttons that allow you to step through the code at your own pace.
 You can also press {\sf Automatic Trace} to watch DrJava run your code one line at a time.
 

appb.tex

@@ -250,6 +250,8 @@ \section{Example source file}
 So we use a multi-line comment (\java{/*}).
 Our example source file, {\tt Convert.java}, includes the MIT License (\url{https://opensource.org/licenses/MIT}).
 
+\index{Convert.java}
+
 \begin{scriptsize}
 \begin{code}
 /*
@@ -369,6 +371,8 @@ \section{Example source file}
 
 \begin{enumerate}
 
+\index{command-line interface}
+
 \item From the command line, go to the location for {\tt Convert.java}.
 The {\tt -d} option of {\tt javadoc} indicates where to generate the HTML files.
 

appd.tex

@@ -247,6 +247,7 @@ \subsubsection*{Flow of execution}
 \label{flowexec}
 
 \index{flow of execution}
+\index{tracing}
 
 If you are not sure how the flow of execution is moving through your program, add print statements to the beginning of each method with a message like ``entering method foo'', where \java{foo} is the name of the method.
 Now when you run the program, it displays a trace of each method as it is invoked.
@@ -319,6 +320,8 @@ \subsection*{I added so many print statements I get inundated with output.}
 For example, if you are sorting an array, sort a {\em small} array.
 If the program takes input from the user, give it the simplest input that causes the error.
 
+\index{nested}
+
 Also, clean up the code.
 Remove unnecessary or experimental parts, and reorganize the program to make it easier to read.
 For example, if you suspect that the error is in a deeply-nested part of the program, rewrite that part with a simpler structure.

appe.tex

@@ -25,6 +25,7 @@ \section{Unreachable code}
 As soon as either of them executes, the method terminates without executing any more statements.
 
 \index{dead code}
+\index{unreachable}
 
 Code that appears after a \java{return} statement (in the same block), or any place else where it can never be executed, is called {\bf dead code}.
 The compiler will give you an ``unreachable statement'' error if part of your code is dead.

ch01.tex

@@ -91,6 +91,8 @@ \section{The hello world program}
 % more precise, but also to reduce the number of times ``print'' appears,
 % which is a lot!
 
+\index{Hello.java}
+
 % height = 130 + 15 * num_lines
 \begin{trinket}[235]{Hello.java}
 public class Hello {
@@ -119,8 +121,8 @@ \section{The hello world program}
 %In fact, we won't be able to explain all of them for several more chapters.
 %But we can start with the structure.
 
-\index{class!definition}
-\index{method!definition}
+\index{class!declaration}
+\index{method!declaration}
 \index{statement}
 \index{print statement}
 
@@ -297,6 +299,8 @@ \section{Displaying two messages}
 \java{System.out.println} appends a special character, called a {\bf newline}, that moves to the beginning of the next line.
 If you don't want a newline at the end, you can use \java{print} instead of \java{println}:
 
+\index{Goodbye.java}
+
 \begin{trinket}[235]{Goodbye.java}
 public class Goodbye {
 
@@ -367,6 +371,7 @@ \section{Formatting source code}
 %However, with that freedom comes responsibility, both to yourself (when you look at the code in the future) and others who will be reading, understanding, and debugging it.
 
 \index{Google style}
+\index{style guide}
 
 Organizations that do a lot of software development usually have strict guidelines on how to format source code.
 For example, Google publishes its Java coding standards for use in open-source projects: \url{https://google.github.io/styleguide/javaguide.html}.

ch02.tex

@@ -430,6 +430,7 @@ \section{Rounding errors}
 %Even with double-precision, you will frequently run into problems.
 
 \index{rounding error}
+\index{error!rounding}
 \index{arithmetic!floating-point}
 
 The difference between the number we want and the floating-point number we get is called {\bf rounding error}.
@@ -651,6 +652,8 @@ \section{Other types of errors}
 Instead, it will do exactly what you told it to do.
 For example, here is a version of the hello world program with a logic error:
 
+\index{Hello.java}
+
 \begin{trinket}[235]{Hello.java}
 public class Hello {
 

ch03.tex

@@ -104,6 +104,8 @@ \section{The Scanner class}
 The \java{Scanner} class provides a method called \java{nextLine} that reads a line of input from the keyboard and returns a \java{String}.
 The following example reads two lines and repeats them back to the user:
 
+\index{Echo.java}
+
 \begin{trinket}{Echo.java}
 import java.util.Scanner;
 
@@ -135,6 +137,8 @@ \section{The Scanner class}
 
 \section{Language elements}
 
+\index{language!elements}
+
 At this point, we have seen nearly all of the organizational units that make up Java programs.
 Figure~\ref{fig.package} shows how these ``language elements'' are related.
 
@@ -163,7 +167,6 @@ \section{Language elements}
 Knowing this terminology is helpful, because error messages often say things like ``not a statement'' or ``illegal start of expression'' or ``unexpected token''.
 Comparing Java to English, statements are complete sentences, expressions are phrases, and tokens are individual words and punctuation marks.
 
-
 Note there is a big difference between the Java {\em language}, which defines the elements in Figure~\ref{fig.package}, and the Java {\em library}, which provides the built-in classes that you can import.
 For example, the keywords \java{public} and \java{class} are part of the Java language, but the names \java{PrintStream} and \java{Scanner} are not.
 
@@ -356,7 +359,7 @@ \section{Formatting output}
 However when you run the program, it will display:
 
 \index{MissingFormatArgumentException}
-\index{run-time error}
+\index{exception!MissingFormatArgument}
 
 \begin{small}
 \begin{stdout}
@@ -449,6 +452,7 @@ \section{Remainder operator}
 \index{modulo}
 \index{\% operator}
 \index{operator!remainder}
+\index{remainder}
 
 We have already seen the division operation (\java{/}), which computes the quotient of two numbers.
 If the numbers are integers, it performs integer division.
@@ -465,6 +469,8 @@ \section{Remainder operator}
 The second line, which is pronounced ``76 mod 12'', yields 4.
 So 76 inches is 6 feet, 4 inches.
 
+\index{modulus}
+
 Many people (and textbooks) incorrectly refer to \java{\%} as the ``modulus operator''.
 In mathematics, however, {\bf modulus} is the number you're dividing by.
 In the previous example, the modulus is 12.
@@ -493,6 +499,8 @@ \section{Putting it all together}
 %Since we've looked at each of these topics in isolation, it's important to see how they fit together in a complete program.
 %If you've been working through the examples on your computer as you've been reading (like we recommended in Section~\ref{sec:examples}), then good job!
 
+\index{Convert.java}
+
 \begin{trinket}{Convert.java}
 import java.util.Scanner;
 
@@ -765,6 +773,8 @@ \section{Exercises}
 To choose a random number, you can use the \java{Random} class in \java{java.util}.
 Here's how it works:
 
+\index{GuessStarter.java}
+
 \begin{trinket}{GuessStarter.java}
 import java.util.Random;
 

ch04.tex

@@ -211,6 +211,8 @@ \section{Chaining and nesting}
 The first branch contains a \java{print} statement, and the second branch contains another conditional statement, which has two branches of its own.
 These two branches are also \java{print} statements, but they could have been conditional statements as well.
 
+\index{nested!conditions}
+
 These kinds of nested structures are common, but they can become difficult to read very quickly.
 Good indentation is essential to make the structure (or intended structure) apparent to the reader.
 
@@ -330,6 +332,7 @@ \section{De Morgan's laws}
 \section{Boolean variables}
 
 \index{expression!boolean}
+\index{type!boolean}
 
 To store a \java{true} or \java{false} value, you need a \java{boolean} variable.
 You can declare and assign them like other variables.
@@ -535,8 +538,8 @@ \section{Validating input}
 What if the user doesn't enter a number at all?
 What would happen if they typed the word ``hello'', either on accident or on purpose?
 
-\index{exception!InputMismatch}
 \index{InputMismatchException}
+\index{exception!InputMismatch}
 
 \begin{small}
 \begin{stdout}
@@ -549,6 +552,7 @@ \section{Validating input}
 \end{small}
 
 \index{run-time error}
+\index{testing}
 
 If the user inputs a \java{String} when we expect a \java{double}, Java reports an ``input mismatch'' exception.
 We can prevent this run-time error from happening by testing the input first.
@@ -589,6 +593,8 @@ \section{Example program}
 In this chapter we have seen relational and logical operators, \java{if} statements, the \java{Math} class, and validating input.
 The following program shows how the individual code examples in the last section fit together.
 
+\index{Logarithm.java}
+
 \begin{trinket}{Logarithm.java}
 import java.util.Scanner;
 
@@ -639,11 +645,9 @@ \section{Vocabulary}
 \term{boolean}
 A data type with only two possible values, \java{true} and \java{false}.
 
-\index{operator!relational}
 \term{relational operator}
 An operator that compares two values and produces a \java{boolean} indicating the relationship between them.
 
-\index{statement!conditional}
 \term{conditional statement}
 A statement that uses a condition to determine which statements to execute.
 
@@ -660,7 +664,6 @@ \section{Vocabulary}
 \term{nesting}
 Putting a conditional statement inside one or both branches of another conditional statement.
 
-\index{operator!logical}
 \term{logical operator}
 An operator that combines boolean values and produces a boolean value.
 

ch05.tex

@@ -12,7 +12,7 @@ \chapter{Methods and testing}
 \section{Defining new methods}
 \label{adding_methods}
 
-\index{method!definition}
+\index{method!declaration}
 
 %You have probably guessed by now that you can define more than one method in a class.
 
@@ -22,6 +22,8 @@ \section{Defining new methods}
 Java uses the keyword \java{void} to define such methods.
 Here's a simple example:
 
+\index{NewLine.java}
+
 \begin{trinket}[310]{NewLine.java}
 public class NewLine {
 
@@ -120,6 +122,7 @@ \section{Defining new methods}
 
 
 \section{Flow of execution}
+
 \index{flow of execution}
 
 When you look at a class definition that contains several methods, it is tempting to read it from top to bottom.
@@ -162,6 +165,8 @@ \section{Parameters and arguments}
 When you define a method, you name the {\bf parameters}, which are variables that indicate what arguments are required.
 The following class shows an example:
 
+\index{PrintTwice.java}
+
 \begin{trinket}[295]{PrintTwice.java}
 public class PrintTwice {
 
@@ -277,6 +282,8 @@ \section{Parameters and arguments}
 
 Pulling together the code fragments, here is the complete program:
 
+\index{PrintTime.java}
+
 \begin{trinket}[340]{PrintTime.java}
 public class PrintTime {
 
@@ -340,6 +347,7 @@ \section{Stack diagrams}
 %Stack diagrams help you to visualize the {\bf scope} of a variable, which is the area of a program where a variable exists.
 
 \index{Java Tutor}
+\index{tracing}
 
 Stack diagrams are a good mental model for how variables and methods work at run-time.
 Learning to trace the execution of a program on paper (or on a whiteboard) is a useful skill for communicating with other programmers.
@@ -483,6 +491,8 @@ \section{Incremental development}
 The return statement is a placeholder that is only necessary for the program to compile.
 At this stage the program doesn't do anything useful, but it is good to compile it so we can find any syntax errors before we add more code.
 
+\index{testing}
+
 It's usually a good idea to think about testing {\em before} you develop new methods; doing so can help you figure out how to implement them.
 To test the method, we can invoke it from \java{main} using the sample values:
 

ch06.tex

@@ -231,6 +231,9 @@ \section{The for statement}
 \section{Nested loops}
 \label{nested}
 
+\index{loop!nested}
+\index{nested!loops}
+
 Like conditional statements, loops can be nested one inside the other.
 Nested loops allow you to iterate over two variables.
 For example, we can generate a ``multiplication table'' like this:
@@ -446,6 +449,9 @@ \section{The indexOf method}
 To visualize how \java{indexOf} and other \java{String} methods work, it helps to draw a picture like Figure~\ref{fig.banana}.
 The previous code starts at index 2 (the first \java{'n'}) and finds the next \java{'a'}, which is at index 3.
 
+\index{memory diagram}
+\index{diagram!memory}
+
 \begin{figure}[!ht]
 \begin{center}
 \includegraphics{figs/banana.pdf}
@@ -477,6 +483,7 @@ \section{String comparison}
 \label{strcmp}
 
 \index{equals}
+\index{string!comparing}
 
 To compare two strings, it may be tempting to use the \java{==} and \java{!=} operators.