CSSE 230 Weiss Textbook Review Pointers

These are some things that I want you to especially notice as you look over the textbook chapters.

Chapter 1

Almost everything here should be review. If any of these things are not review for you, please read those parts carefully and seek help from me or the F217 lab TAs as needed.

• Section 1.2 System.out.println() and System.out.print()
• Section 1.3 The eight primitive types in Java. Numeric, character, string and Boolean constants.
• Section 1.4 Operators. Note that = (and the other = operators, like +=) return a value, so that z = x = Y+1; is allowed. Type conversion operators, such as (double) or (int)
• Section 1.5 logical operators. A few things you might not have noticed before:
  • short-circuit evaluation of && and ||
  • break and continue
  • switch
  • the conditional operator: ? : It is like if (..) .. else .., but it returns a value. For example, (3 < 2) ? 4 : 5 evaluates to 5
• Section 1.6 method header vs. method declaration, formal parameters vs. actual arguments, overloading, static, final.
• Exercises 1.3, 1.5, 1.7, 1.8, 1.10, 1.13, 1.14, 1.18, 1.19

Chapter 2

Again, almost everything here should be review. If any of these things are not review for you, or if you don’t remember the details, read carefully and seek help as needed.

• 2.1–1.2 Objects and references, new. The meaning of = and == when applied to objects.
• 2.3 Strings are immutable, concatenation, no comparison operators (use equals and compareTo), length, charAt, substring. Also look up the StringBuilder class in the JDK documentation.

• 2.4 Declaring an array of objects does not create an actual array object; use new. If the base type of the array is an object type, all of the array entries are initially null, unless that array is created by an initializer. = copies an array reference, not the array itself.

  Dynamic array expansion is the most important thing in this chapter.

  Figure 2.6:

  • Notice the use of the InputStreamReader and BufferedReader wrappers for System.in. For now, think of lines 12–13 as a magic incantation for setting up line-by-line input.
  • Lines 21–24 are a standard way to read a text file line-by-line. For a newer, better alternative, read about the Scanner class from JDK 1.5
  • Be sure to understand how resize() works (Figure 2.7).
  • Also why resize is called with argument array.length * 2

  Ragged 2D arrays

• 2.5 try, catch, finally, throw, throws. runtime exceptions, checked exceptions, errors.
• 2.6 I/O streams, StringTokenizer, opening files for reading and writing. (Again, Scanner from JDK 1.5 might be better here.)
• Exercises: 2.1, 2.6, 2.7, 2.8, 2.10, 2.13

Chapter 3

Even more of this Chapter should be review.

• 3.1–3.5 Objects, classes, methods, fields, this, static fields and methods, instanceof, static initializers.
• 3.6 Importing from packages, creating your own packages.
• 3.7 The Composite (pair) pattern. Used for returning multiple values.
• Exercises. 3.1, 3.9, 3.10, 3.11

Chapter 4

Weiss condenses the most important concepts in object-oriented programming into this single key chapter.

• 4.1–4.3 Inheritance basics: adding fields and methods, overloading vs. overriding, visibility (public, private, protected, package (default) visibility), type compatibility, dynamic binding and polymorphism, IS-A vs. HAS-A, use of super in constructors and methods, final methods and classes, the need for class cast, abstract classes and methods.
• 4.4–4.5 Interfaces, the Object class, decorator pattern and its application to I/O classes.
• 4.6–4.7 Generic components, Wrapper classes, the adapter pattern,
• 4.8 Function objects, Comparable vs. Comparator. Local, nested, and anonymous classes.
• 4.9 Dynamic binding applies to method selection, but signature selection is static.
• Exercises: 4.6, 4.7–4.14, 4.18, 4.21–4.22 , 4.28–4.30

Chapter 5

Much, but not all, of the material in this chapter should be review. I list the review items here. We will cover the rest of the chapter in this course.

• 5.1 Basics of algorithm analysis, the huge difference in the growth rates of different kinds of functions, the fundamental questions on page 165. Why we look at big-Oh instead of exact running times.
• 5.2 More on classes of running times, and the kinds of algorithms that have these times.
• 5.4 Formal definition of big-Oh.
• 5.5 Logarithms and their relationship to big-Oh analysis; where do logarithmic running times come from?
• 5.6 (not 5.6.3) Sequential and binary search in a static array, analysis of these algorithms.
• 5.7–5.8 Practical considerations.
• Exercises: 5.4, 5.6, 5.7, 5.8, 5.11, 5.12, 5.14–5.17, 5.23–5.25

Chapter 6

You should know the main data structures, interfaces, and classes of the Collections API

• Intro. What is an abstract data type? A data structure? Specification, implementation, application.
• 6.1 The purpose of the weiss.nonstandard package.
• 6.2 The iterator pattern, approaches to implementation. Factory methods.
• 6.3 Collections API approach to collections and iterators
• 6.4 Generic algorithms for arrays and collections (the Arrays and Collections classes). Comparators.
• 6.5 Lists, and their implementations as ArrayLists and LinkedLists.
• 6.6 Stacks, parenthesis matching, queues.
• 6.7–6.9 I will not assume that you know about these before this course begins.
• Exercises: 6.1, 6.5, 6.8, 6.9, 6.10, 6.18 (use the Arrays class).

Chapter 7

Recursion and induction

• 7.1 Basic idea of recursion.
• 7.2 The section discusses proofs by mathematical induction. Since MA 275 (Disco) is no longer a prerequisite, we will deemphasize induction proofs in this course.
• 7.3 Basic recursion, printing numbers recursively, Fibonacci numbers, four rules for recursion; recursive definition of tree, recursive calculations of factorial, binary search.
• Exercises: 7.3, 7.18, 7.19, 7.25

Chapter 8

Sorting

• 8.1–8.3 Why is sorting important, interface to sorting algorithms. Insertion sort. Selection sort (not actually in this chapter, look it up on-line). Why is insertion sort slow? Why is bubble sort slower?
• 8.5 Merge sort. You should be able to write merge and mergesort “from scratch” and to understand their analysis and limitations.
• Exercises: 8.10, 8.15, 8.19, 8.27 (use the Arrays class).