Experiments in Java: An Introductory Lab Manual Book

Session J1: An Introduction to Java.

Discussion.

A hello world program.

Compilation.

Reading input.

Concatenating strings.

Variables.

Numeric input and output.

Applets.

Experiments.

Experiment J1.1: Executing your first program.

Experiment J1.2: Extending your first program.

Experiment J1.3: When things go wrong.

Experiment J1.4: Executing and extending a program with input.

Experiment J1.5: Numeric input and output.

Experiment J1.6: Your first applet.

Experiment J1.7: Some common applet errors.

Post-Laboratory Problems.

Problem J1-A: Generating verse.

Problem J1-B: Name replication.

Problem J1-C: Errors galore.

Problem J1-D: Predicting output.

Problem J1-E: Temperature conversion.

Problem J1-F: Bar graphs.

Notes.

Session J2: Objects and Methods.

Discussion.

Objects.

Creating objects.

Coordinating objects.

Building your own methods.

Creating your own classes.

Return values.

Static methods.

Detour: The main method.

Assigning objects.

Fonts and graphics for applets.

Experiments.

Experiment J2.1: Printing out a point.

Experiment J2.2: Coordinating classes.

Experiment J2.2A: Coordinating classes (graphical application).

Experiment J2.2B: Coordinating classes (textual application).

Experiment J2.3: Your own method.

Experiment J2.4: Your own class.

Experiment J2.5: Return values.

Experiment J2.6: Static methods.

Experiment J2.7: Copying objects.

Experiment J2.8: Changing the font.

Experiment J2.9: Some simplepictures.

Post-Laboratory Problems.

Problem J2-A: Shifting points.

Problem J2-B: Shifting points, revisited.

Problem J2-C: Drawing a grid.

Problem J2-D: Drawing a grid, revisited.

Problem J2-E: Happiness.

Problem J2-F: Initials.

Problem J2-G: Rainbow Text.

Problem J2-H: Other Drawing Methods.

Problem J2-I: Determining Text Width.

Notes.

Session J3: Building Your Own Classes.

Discussion.

Class capabilities.

Program state.

Object state.

Constructors.

Overloading.

Creating a bordered square class.

Experiments.

Experiment J3.1: Program state.

Experiment J3.2: Fields.

Experiment J3.3: Fields, revisited.

Experiment J3.4: Constructors.

Experiment J3.5: Constructors, revisited.

Experiment J3.6: Overloading read methods.

Experiment J3.7: Overloading.

Experiment J3.8: Borders.

Experiment J3.9: A bordered-square class.

Post-Laboratory Problems.

Problem J3-A: Shifting points.

Problem J3-B: Refined points.

Problem J3-C: Distance from origin.

Problem J3-D: A date class.

Problem J3-E: Converting dates to strings.

Problem J3-F: Stick figures.

Problem J3-G: House components.

Problem J3-H: Boxed text.

Notes.

Session J4: Boolean Expressions and Conditionals.

Discussion.

Boolean expressions.

Operations on Booleans.

Conditionals.

The switch statement.

Applet parameters.

Experiments.

Experiment J4.1: Extending the SimpleDate class.

Experiment J4.2: Simple boolean methods.

Experiment J4.3: More boolean methods.

Experiment J4.4: Improved output.

Experiment J4.5: More fun with conditionals.

Experiment J4.6: Using the switch statement.

Experiment J4.7: Applet parameters.

Experiment J4.8: More applet parameters.

Post-Laboratory Problems.

Problem J4-A: Rethinking precedes.

Problem J4-B: Incrementing a date.

Problem J4-C: Is the date valid?

Problem J4-D: Correcting dates.

Problem J4-E: Printing dates, revisited.

Problem J4-F: Printing dates, revisited again.

Problem J4-G: isWinter, revisited.

Problem J4-H: Selecting colors, revisited.

Problem J4-I: Selecting colors, revisited again.

Problem J4-J: Multiple greetings.

Problem J4-K: Parameterized drawings.

Problem J4-L: Stick figures.

Notes.

Session J5: Control Structures for Repetition.

Discussion.

Repetition while loops.

Detour: Overloading revisited for loops.

Detour: Arithmetic shorthand Loops and applets.

Experiments.

Experiment J5.1: Simple loops.

Experiment J5.2: Counting the day of the year.

Experiment J5.3: Simple for loops.

Experiment J5.4: Arithmetic shorthand.

Experiment J5.5: Rainbow text.

Experiment J5.6: A grid applet.

Experiment J5.7: A bouncing ball.

Post-Laboratory Problems.

Problem J5-A: daysUntil.

Problem J5-B: daysSince.

Problem J5-C: Reflection.

Problem J5-D: Loop mechanisms.

Problem J5-E: Grade averaging.

Problem J5-F: Maximum grade.

Problem J5-G: Revising the rainbow's shape.

Problem J5-H: Revising the rainbow.

Problem J5-I: A complete grid.

Problem J5-J: Improving the bouncing simulation.

Notes.

Session J6: Arrays and Hash Tables.

Discussion.

Counting scores.

Arrays.

Some important details.

Counting words.

Hash tables.

Experiments.

Experiment J6.1: Counting scores.

Experiment J6.2: Introducing arrays.

Experiment J6.3: Arrays and references.

Experiment J6.4: Counting words.

Experiment J6.5: Hash tables.

Post-Laboratory Problems.

Problem J6-A: Improving daysUntilStartnOfMonth.

Problem J6-B: Counting grades.

Problem J6-C: Counting different scores.

Problem J6-D: Copying arrays.

Problem J6-E: Hashing words.

Problem J6-F: Game boards.

Notes.

Session A1: Recursion.

Discussion.

Mathematics and recursion.

Fibonacci numbers.

A guessing game.

Exponentiation.

Experiments.

Experiment A1.1: Simple recursive functions.

Experiment A1.2: Factorial.

Experiment A1.3: Fibonacci numbers.

Experiment A1.4: Exponentiation.

Post-Laboratory Problems.

Problem A1-A: Printing information on recursive calls, revisited.

Problem A1-B: How large can a factorial be?

Problem A1-C: Large Fibonacci numbers.

Problem A1-D: More efficient iterative computation of Fi-bonacci numbers.

Problem A1-E: More efficient recursive computation of the Fibonacci numbers.

Problem A1-F: Understanding the Fibonacci numbers.

Problem A1-G: Counting steps during exponentiation.

Problem A1-H: From recursion to iteration.

Notes.

Session A2: Searching.

Discussion.

Sequences.

Detour: Random sequences.

Sequential search.

Detour: The number game, revisited.

Binary search.

Problems with binary search.

Finding the smaller elements of a sequence.

Experiments.

Experiment A2.1: Integer sequences.

Experiment A2.2: Random sequences.

Experiment A2.3: Sequential search.

Experiment A2.4: The guessing game.

Experiment A2.5: Binary search.

Experiment A2.6: Problems with binary search.

Post-Laboratory Problems.

Problem A2-A: An iterative binary search.

Problem A2-B: Evaluating binary search.

Problem A2-C: Searching through names.

Problem A2-D: Finding the first element.

Problem A2-E: Extending the number game.

Problem A2-F: Variations on search.

Problem A2-G: Smallest, revisited.

Problem A2-H: Further readings.

Session A3: Analyzing Algorithms.

Discussion.

Timing algorithms.

Problems with wall-clock timing.

Counting steps.

Problems with counting.

Binary search, revisited.

Finding groups of smallest entries.

Experiments.

Experiment A3.1: Wall-clock timing.

Experiment A3.2: Comparing wall-clock times.

Experiment A3.3: Counting steps.

Experiment A3.4: Comparing steps.

Experiment A3.5: Binary search.

Experiment A3.6: Finding the smallest element.

Experiment A3.7: Finding smaller elements.

Post-Laboratory Problems.

Problem A3-A: Plotting exponentiation.

Problem A3-B: Comparing exponentiation.

Problem A3-C: Plotting exponentiation, revisited.

Problem A3-D: Comparing exponentiation, revisited.

Problem A3-E: Sorting.

Problem A3-F: Sorting, revisited.

Notes.

Session G1: Graphics and Applets.

Discussion.

Applets.

Painting pictures.

A circle applet.

Colors.

Pixels vs. coordinates.

Applet dimensions.

Repainting.

Applet parameters.

Experiments.

Experiment G1.1: A colored circle applet.

Experiment G1.2: Experimenting with colors.

Experiment G1.3: Drawing vs. filling.

Experiment G1.4: Getting boundaries.

Experiment G1.5: Repainting.

Experiment G1.6: Setting parameters.

Post-Laboratory Problems.

Problem G1-A: A "real" drawing.

Problem G1-B: A parameterized face.

Problem G1-C: Rainbow text.

Problem G1-D: Repositioning the moving circle.

Problem G1-E: Multiple circles.

Problem G1-F: Looping circles.

Problem G1-G: Colors, revisited.

Notes.

Session G2: Java's Abstract Windowing Toolkit.

Discussion.

Components.

Events and control flow.

An important event.

Your first graphical application.

Adding a Quit button.

Adding more buttons.

Separate listeners.

Experiments.

Experiment G2.1: Your first AWT program.

Experiment G2.2: Creating multiple windows.

Experiment G2.3: Adding a Quit button.

Experiment G2.4: Adding a Help button.

Experiment G2.5: Improving actionPerformed.

Experiment G2.6: Building separate listeners.

Post-Laboratory Problems.

Problem G2-A: A customizable alert.

Problem G2-B: Multiple frames.

Problem G2-C: Multiple frames, revisited.

Problem G2-D: Separate frames.

Problem G2-E: Layout managers.

Problem G2-F: Widgets.

Problem G2-G: AWT widgets.

Notes.

Session G3: Java's Abstract Windowing Toolkit, Continued.

Discussion.

The AWT, reviewed.

Getting user input.

Getting numeric input.

Experiments.

Experiment G3.1: The AWT, reviewed.

Experiment G3.2: Getting input from the user.

Experiment G3.3: String manipulation.

Experiment G3.4: A simple calculator.

Experiment G3.5: Supporting real numbers.

Experiment G3.6: Adding a quit button.

Post-Laboratory Problems.

Problem G3-A: Observing the user.

Problem G3-B: Capitalization.

Problem G3-C: Passwords.

Problem G3-D: Setting the size of text fields.

Problem G3-E: Beginning a real calculator.

Problem G3-F: Adding calculation.

Notes.

Session O1: Object-Oriented Design.

Discussion.

Narratives.

Question and answer sessions.

Beginning coding.

Narrating interactions.

Diagrams of relationships.

Generalization and encapsulation.

Experiments.

Experiment O1.1: Determine potential objects and classes for an Othello simulation.

Experiment O1.2: Refining your descriptions.

Experiment O1.3: Beginning coding.

Experiment O1.4: Narrating interactions.

Experiment O1.5: Selective coding.

Experiment O1.6: Diagramming.

Experiment O1.7: Generalization.

Post-Laboratory Problems.

Problem O1-A: Describe a game.

Problem O1-B: A simple Othello interface.

Problem O1-C: Update Board.

Problem O1-D: Update Rules.

Problem O1-E: Changing Othello's board.

Problem O1-F: Changing Othello's rules.

Problem O1-G: Changing Othello's pieces.

Session O2: Inheritance.

Discussion.

Reuse.

Inheritance.

Overriding methods.

From rectangles to squares.

Multiple inheritance.

Experiments.

Experiment O2.1: Building a new point class.

Experiment O2.2: A simple extension of the Point class.

Experiment O2.3: Adding functionality to ExtendedPoints.

Experiment O2.4: Overriding methods.

Experiment O2.5: Overriding the toString method.

Experiment O2.6: From Rectangle to Square.

Post-Laboratory Problems.

Problem O2-A: Extending Points.

Problem O2-B: Putting Points on a grid.

Problem O2-C: Validating Squares.

Problem O2-D: A hierarchy of shapes.

Notes.

Session O3: Interfaces and Polymorphism.

Discussion.

Polymorphism.

Interfaces.

Generalized methods.

Generality through inheritance.

Building generalized methods with Java's interfaces.

Experiments.

Experiment O3.1: Polymorphism.

Experiment O3.2: NewPoints and PointPrinters.

Experiment O3.3: Using ExtendedPoints.

Experiment O3.4: Printing points.

Experiment O3.5: Printing revisited.

Post-Laboratory Problems.

Problem O3-A: makePrintable vs. toString.

Problem O3-B: Cloning points.

Problem O3-C: Abstract classes.

Problem O3-D: Interfaces vs. inheritance.

Problem O3-E: Defining polymorphism.

Notes.

Session X1: Primitive Types.

Discussion.

Representing integers.

Representing reals.

Coercion and casting.

Representing characters.

Precedence.

Experiments.

Experiment X1.1: Facts about integers.

Experiment X1.2: Other integer types.

Experiment X1.3: Exceeding limits.

Experiment X1.4: Facts about reals.

Experiment X1.5: The limits of reals.

Experiment X1.6: Casting.

Experiment X1.7: Facts about characters.

Experiment X1.8: Precedence.

Experiment X1.9: Concatenating strings and numbers.

Post-Laboratory Problems.

Problem X1-A: Converting cases.

Problem X1-B: Rounding or truncation?

Problem X1-C: Rounding or truncation, revisited.

Problem X1-D: Encryption.

Problem X1-E: Coercion.

Problem X1-F: Unicode representation.

Problem X1-G: Operators and precedence.

Problem X1-H: Big integers and big reals.

Notes.

Session X2: Vectors.

Discussion.

Vectors.

Other vector capabilities.

Determining the class of vector elements.

Storing primitive values in vectors.

Experiments.

Experiment X2.1: Heterogeneity and arrays.

Experiment X2.2: Vector basics.

Experiment X2.3: Testing limits.

Experiment X2.4: Additional vector methods.

Experiment X2.5: Course management.

Experiment X2.6: Modifying vector elements.

Experiment X2.7: Primitive objects.

Post-Laboratory Problems.

Problem X2-A: Default size of vectors.

Problem X2-B: Implement sets.

Problem X2-C: Other vector capabilities.

Problem X2-D: Implementing vectors.

Problem X2-E: Printing arrays.

Problem X2-F: A grading program.

Notes.

Session X3: Input, Output, Files, and Exceptions.

Discussion.

Output and System.out.

Starting to build SimpleOutput.

Output files.

Exceptions.

Closing files.

Input.

Input and System.in.

Converting strings to other types.

Experiments.

Experiment X3.1: Using System.out.

Experiment X3.2: Building your own output class.

Experiment X3.3: Output to files.

Experiment X3.4: Output to files, revisited.

Experiment X3.5: Starting to build your own input class.

Experiment X3.6: Reading numeric input.

Post-Laboratory Problems.

Problem X3-A: Printing integer arrays.

Problem X3-B: Printing string arrays.

Problem X3-C: Redirecting output to a different file.

Problem X3-D: Redirecting output to standard output.

Problem X3-E: Reading input from files.

Problem X3-F: Reading parts of lines.

Problem X3-G: Redirecting input.

Notes. 0201612674T04062001