Java @ CCAC West: Unified Textbook  The LIANG9
Jump to a section
settings_input_componentLIANG9 chapterbased study guide and CCAC course mapping
attach_moneyExactly which book to buy (ISBN, price, vendor notes)
thumb_upWhy the Liang9?
Which book to buy
Introduction to Programming Java: Comprehensive Edition 9th Edition by Y. Daniel Liang. Published by Pearson.
NOTE: This is a PAST edition; Pearson, in their usual form, updates the editions far more frequently than needed in order to charge arms and legs for their books. Get the 9th Edition!
ISBN13: 9780132936521
ISBN10: 0132936526
NOTE: Your instructor has purchased over 20 of these from various sources online and has NEVER paid more than $40 for a single copy. Purchasing from the CCAC bookstore will result in a charge of over $180! Yikes! ( And shame on the Pearson corporation which is an enemy of students everywhere.)
LIANG9 chapterbased study guide and CCAC course mapping
The following table maps each chapter in Daniel Liang's Introduction to Programming Java to a Java course taught at CCAC's West Hills center.
Chapter No.  Title  Course mapping  Notes (§ = section; * = challenge, ** = tricky) 

1  Introduction to computers, programs, and Java  CIT111 
core:
§1.1  1.9 (all)
practice:
ex. 1.2: display five messages
ex. 1.5: compute expressions
miniprojects:
ex. 1.7: approximate π (advanced)

2  Elementary Programming  CIT111 
core:
§2.1  2.15, §2.17  2.18
supplemental:
§2.16, §2.19
practice:
ex. 2.1  2.5
miniprojects:
ex. 2.12 (physics  finding runway length)
ex. 2.14: (health application  computing bmi) ex. 2.17: (science  windchill temperatures) ex. 2.19: (distance of two points)
tricky:
ex. **2.6: (sum the digits in an integer)
ex. *2.15*: (geometry  area of a triangle) 
3  Selections (if, switch)  CIT111 
core:
§3.1  3.7 (intro  common errors)
§3.14 (switch statements) §3.15 (conditional expressions) §3.17 (precedence)
supplemental:
§3.8  3.10 (rand nums  taxes)
§3.12 (cs: leap years) §3.13 (cs: lottery) §3.16 (formatting console output)
practice:
ex. 3.11 (days in a month)
ex. 3.12 (check a number) ex. 3.26 (AND, OR, and XOR)
miniprojects:
ex. *3.1 (solve the quadratic)
ex. **3.4 (learn addition  great!) ex. **3.21 (science: day of the week) ex. **3.22 (geometry: points in a circle?) ex. **3.25 (intersecting points) ex. **3.28 (geometry: overlapping rectangles) ex. ****3.29 (geometry: overlapping circles) 
4  Loops  CIT111 
core:
§4.1  4.5 (intro  which loop to use)
§4.9 (break & continue)
advanced:
§4.6 (nested loops)
supplemental:
§4.7 (minimizing errors)
§4.10 (cs: primes) §4.11 (dialog boxes)
practice:
ex. 4.3 (conversion table from kg to lbs)
ex. 4.4 (conversions table from mi to km) ex. 4.10 (numbers divisible by 5 and 6) ex. 4.12 (math: smallest n) ex. 4.40 (one million heads?)
miniprojects:
ex. *4.18 (printing patterns with loopscool!)
ex. **4.19 (pyramidal numbers) ex. *4.30 (finance: compounded values) ex. *4.1 (count pos and neg nums) ex. **4.7 (compute future tuition) ex. *4.14 (math: compute gcd) ex. **4.26 (math: compute e) ex. **4.44 (monte carlo) 
5  Methods  CIT111 
core:
§5.1  5.5 (intro  passing parameters by value)
§5.9 (variable scope)
supplemental:
§5.6  5.7(modularizing code  case:dec to hex)
§5.10  5.12(Math class  method abstraction)
advanced:
§5.8 (overloading methods)
practice:
ex. 5.8 (conversion between C and F)
ex. 5.9 (conversion between ft and m) ex. 5.10 (isPrime(int num) method) ex. 5.11 (finance: compute commission) ex. 5.18 (use the Math.squt method)
miniprojects:
ex. *5.13 (sum series)
ex. *5.14 (estimate pi) ex. *5.36 (geometry: area of a regular polygon) ex. *5.17 (display a matrix of 0s and 1s) ex. **5.22 (math: approximate the sq. root) ex. **5.31 (finance: credit card num validation) 
6  SingleDimensional arrays  CIT111 
core:
§6.1  6.2 (intro  array basics)
§6.5  6.7(copying  returning an array from a method) §6.1  6.2 (intro  array basics) §6.12 (the Arrays class)
supplemental:
§6.3 (case: lotto)
§6.4 (case: cards) §6.8 (case: counting letters) §6.9 (variable length argument lists) §6.10 (searching arrays) §6.11 (sorting)
practice:
ex. 6.9 (smallest element)
ex. 6.10 (index of smallest element) ex. 6.26 (strictly identical arrays) ex. 6.1 (assign grades)
miniprojects:
ex. 6.4 (analyze scores)
ex. *6.11 (math: standard deviation) ex. *6.12 (reverse an array) ex. 6.15 (eliminate duplicates) ex. **6.18 (bubble sort) ex. **6.19 (sorted?) ex. **6.31 (merge two sorted lists) 
7  Multidimensional arrays  CIT130 
core:
§7.1  7.4 (intro  passing [][] as params)
§7.8 (multidimensional arrays)
cases:
§7.5 (grading a MC test)
§7.6 (closest pairs) §7.7 (sudoku)
practice:
ex. 7.28 (strictly identical arrays)
ex. 7.29 (identical arrays) ex. *7.26 (row sorting)
miniprojects:
ex. *7.1 (sum elements by column)
ex. 7.5 (math: add two matrices) ex. *7.31 (geometry: intersection points) ex. ***7.20 (game: connect four) 
8  Objects and Classes  CIT111 
also used in CIT130 and CIT244
core:
§8.1  8.5 (intro  reference vars)
§8.7  8.11 (static vars  passing objects)
supplemental:
§8.6 (using library classes)
§8.11 (arrays of objects)
practice:
ex. 8.8 (make a Fan class)
miniprojects:
ex. **8.9 (nsided regular polygon)
ex. *8.10 (math: quadratic equation) ex. *8.14 (stopwatch) ) 
9  Strings  CIT130 
core:
§9.1  9.2 (intro  the String class)
§9.5 (Character class) §9.6 (StringBuilder and StringBuffer)
supplemental:
§ 9.3 (palindromes)
§ 9.4 (hex to dec) § 9.7 (command line arguments)
practice:
ex. 9.4 (counting occurrences of a char)
ex. 9.6 (counting letters in a String)
miniprojects:
ex. *9.1 (ssns)
ex. *9.7 (telephone keypads) ex. *9.8 (binary to decimal) ex. **9.11 (sorting chars in a String) ex. ***9.25 (game: hangman) 
10  Thinking in objects  CIT111  also used in CIT130 and CIT244
core:
§10.1  10.8(intro  object composition )
§10.11 (class design guidelines) §10.12 (processing primitive data)
supplemental:
§10.8 (case: designing Course)
§10.9 (case: stack structures) §10.10 (case: GuessDate class) §10.14 (BigInteger and BigDecimal classes)
practice:
ex. 10.4 (design the MyPoint class)
ex. *10.15 (finding the bounding rectangle)
miniprojects:
ex. *10.11 (Circle2D class)
ex. ***10.8 (Tax class) ex. ***10.12 (Triangle2D class) 
11  Inheritance and Polymorphism  CIT130 
also used in CIT244
core:
§11.1  11.10 (intro  equals() )
supplemental:
§11.11 (AraryList class)
§11.12 (case: custom Stack) §11.13 (protected) §11.14 (preventing extending and overriding)
practice:
ex. 11.1 (Triangle class)
ex 11.2 (Person, Student, Employee...)
miniprojects:
ex. 11.8 (new Account class)

12  GUI Basics  CIT130 
core:
§12.1  12.15 (intro  text fields)
practice:
ex. 12.1 (FlowLayout manager)
ex. 12.2 (BorderLayout manager) ex. 12.3 (GridLayout manager) ex. 12.4 (JPanel)
miniprojects:
ex. 12.9 (game: display three cards)
ex. 12.10 (game: display a checkerboard) 
13  Graphics  optional in CIT130  
14  Exception handling and text i/o  CIT130 
core:
§14.1  14.8 (intro  chained catch clauses)
supplemental:
§14.9 (defining custom Exceptions)
§14.10  14.12 (file i/o) §14.13 (reading data from the web)
practice:
ex. 14.3 (ArrayIndexOutOfBoundsException)
miniprojects:
ex. *14.1 (NumberFormatException)
ex. *14.10 (OutOfMemoryError) ex. **14.21 (display a graph) 
15  Abstract classes and interfaces  CIT130 
core:
§15.1  15.2 (intro  abstract classes)
§15.5  15.8 (interfaces  interfaces v. abstract classes )
supplemental:
§15.3 (case: abstract Number class)
§15.4 (Calendar and GregorianCalendar) §15.9 (case: Rational class)
practice:
ex. 15.7 (enable GeometricObject comparable)
ex. 15.8 (ComparableCircle class)
miniprojects:
ex. **15.20 (Mandelbrot fractals)

16  EventDriven programming  CIT130 
core:
§16.1  16.5 (intro  Anonymous class listeners)
§16.8 (mouse events  key events)
supplemental:
§16.6 (alternatives to defining Listener classes)
§16.7 (case: loan calculator) §16.11 (animation with Timer)
practice:
ex. 16.2 (which button?)
ex. *16.7 (set background color with click) ex. *16.8 (display the mouse position) ex. *16.9 (draw lines with arrow keys)
miniprojects:
ex. *16.4 (create a calculator)
ex. *16.4 (create an investment value calc) ex. **16.6 (alternate two messages) ex. *16.11 (display a character) ex. *16.19 (geometry: inside a circle?) ex. ***16.25 (game: hit balloons) ex. ***16.28 (simulation: selfavoiding random walks) 
17  GUI Components  CIT244 
core:
§17.1  17.8 (all)
practice:
ex. *17.6 (mile/km converter)
ex. *17.14 (JComboBox and JList)
miniprojects:
ex. **17.4 (text viewer)
ex. **17.8 (select a font) ex. **17.10 (Mandelbrot fractal) ex. **17.15 (use JScroller to create colors!) 
18  Applets and Multimedia  deprecated API  
19  Binary I/O  extension to CIT244  
20  Recursion  CIT244 
core:
§20.1  20.5 (intro  helper methods)
supplemental:
§20.6  20.10 (directory size  tails)
practice:
ex. 20.4 (sum series)
ex. 20.6 (sum series) ex. *20.7 (Fibonacci series) ex. *20.8 (print digits recursively) ex. *20.9 (display digits backwards)
miniprojects:
ex. *20.1 (factorial of BigInteger objects)
ex. *20.8 (towers of Hanoi) ex. *20.8 (towers of Hanoi) ex. *20.20 (display circles) ex. *20.22 (decmial to hex) ex. **20.27 (Koch snowflake fractal) ex. ***20.27 (Hilbert curve) 
21  Generics  CIT244 
core:
§21.1  21.7 (intro to wildcards)
supplemental:
§21.8  21.9 (erasure  generic matrix)
practice:
ex. 21.3 (distinct elements in ArrayList)
miniprojects:
ex. 21.1 & 21.2 (GenericStack revisions)

22  Lists, Stacks, Queues, and Priority Queues  CIT130  also used extensively in CIT244
core:
§22.1  22.6 (intro  Static methods for Collections)
supplemental:
§22.7 (case: bouncing balls)
§22.8  22.10 (Vector & Stack eval expressions)
practice:
ex. 22.6 (iterating over 1m numbers)
miniprojects:
ex. ***22.7 (game: hangman)
ex. **22.14 (prefix notation) ex. **22.16 (convert infix to postfix) ex. *22.21 (directory size) 
23  Sets and Maps  CIT130  also used extensively in CIT244
core:
§23.1  23.2 (intro  Sets)
§23.4 (case: counting keywords) §23.5  23.6 (maps  case: occurrences)
supplemental:
§23.3 (comparing performance)
§23.7 (singleton and unmodifiable)
practice:
ex. 23.1 (perform set operations)
ex. 23.2 (display nonduplicate words)
miniprojects:
ex. 23.4 (count consonants and vowels)
ex. **23.8 (count occurrences of words in a file) 
24  Developing Efficient Algorithms  CIT244 
core:
§24.1  24.10 (all)
practice:
ex. *24.3 (pattern matching)
ex. *24.4 (pattern matching)
miniprojects:
ex. **24.24 (divide and conquer)

25  Sorting  CIT244 
core:
§25.1  25.7 (intro  external sort)
practice:
ex. 25.1 (generic bubble sort)
ex. 25.2 (generic merge sort) ex. 25.3 (generic quick sort) ex. 25.4 (improve quick sort)
miniprojects:
ex. 25.13 (execution time for sorting)

26  Implementing Lists, Stacks, Queues, and Priority Queues  extension to CIT244  
27  Binary Search Trees  CIT244 
core:
§27.1  27.3 (intro  deleting from a BST)
supplemental:
§27.4 (tree visualization)
§27.5 (BST is Iterable!) §27.6 (case: data compression)
practice:
ex. 27.1 (add methods to BST)
ex. 27.2 (test full BST)
miniprojects:
ex. **27.6 (find leaves)
ex. **27.7 (find nonleaves) 
28  Hashing  optional in CIT244  
29  AVL Trees  optional in CIT244  
30  Graphs and Applications  optional in CIT244  
31  Weighted Graphs and Applications  optional in CIT244  
32  Multithreading and parallel programming  CIT244 
core:
§32.1  32.7 (intro  case: clock)
§32.9  32.12 (synchronization  producer/consumer)
supplemental:
§32.8 (Thread pools)
§32.13  18 (blocking queues  parallel programming)
practice:
ex. 32.5 (bouncing balls)
miniprojects:
ex. 32.9 (demo ConcurrentModificationException)
ex. 32.10 (fix 32.9 with synchronization) 
33  Networking  extension to CIT244  
34  Java Database Programming  CodeConnect project 
About the Liang9
To facilitate continuity across courses, reduce student cost, and drastically simplify logistics, all three courses will be centered on the 9th edition of Daniel Liang's Introduction to Java Programming textbook.
Unifying the java series around the LIANG9 as several advantages:
 Great text: The LIANG9 is filled with oodles of fantastic diagrams, annotated code listings, complete example program source, and digestible explanations of core Java concepts. Your instructor has reviewed many dozens of text and the Daniel Liang's text was an easy pick.
 Cheap: The 9th edition of this Pearson text, published in 2013, is available online for between $2030. Students with serious financial pressures may borrow an instance of the LIANG9 at no cost for the duration of the course. (The current 11th edition ranges between $180 and $210.)
 Comprehensive: At over a 1000 pages spanning 34 print chapters, the text is able companion to each concept taught in all three courses. A class set of LIANG9 instances will be stored in S2113 for students to use if they don't want to cart their instance around.