Exam 2 Topics
CS141: Introduction to Programming, Spring 2018

Exam 2 will take place on Friday, April 11, 2018.

General Comments and Recommendations

• The exam will be focused on Chapters 6-11 of the text. However, since the material is cumulative, you are still expected to be familiar with the earlier material.
• The exam will be 1 hour long. It will be closed book. Electronic devices, of any kind, will not be allowed.
• It is strongly recommended that students:
  • Re-read the text.
  • Do the self-check exercises in each chapter.
  • Review the reading quizzes.
  • Review the lab assignments.
• Practice Problems which could appear on the exam:
  • Basic Looping Problems (pdf)
  • Nested Loop Problems (pdf)
  • Practice Array problems (solutions are here.)
  • Old exams.
• Examples/Pictures
  • Pass by Value vs Pass by Reference (pdf)
  • Object Diagram Practice
  • Instance vs Static variables
    • Instance Variables
    • Class vs Instance Variables
    • Class vs Instance Methods
• You may or may not need to create objects of the following types:
  • Card class:

    Card c1 = new Card();  // create a random card
    Card c2 = new Card(0);  // create a card with index 0 
    System.out.println(c2); // prints:   Ace of spades  

  • Die class:

    Die d1 = new Die();  // create a die with 6 sides.
    System.out.println(d1); // prints: Die with 6 sides
    int r = d1.roll();  // rolls the die object and returns a value from 1 to 6
    Die d2 = new Die(12);  // create a die with 12 sides.
    int r = d2.roll();  // rolls the die object and returns a value from 1 to 12 

  • Person class:

    Person p = new Person("Frank", 18);  // create a Person with name Frank and age 18
    System.out.println(p); // prints: Frank, age 18 

Chapter 6 Looping

• Components of any loop:
  • Loop variable - the variable that controls the looping
  • Loop variable initialization - the starting value of the loop variable.
  • Loop condition - this must be true for loop to continue
  • Loop variable update - how does loop variable change after each loop
  • Loop body - sequence of statements that are executed in the loop
• Types of loops:
  • while-loops - used when the number of repetitions can't be predicted ahead of time (indefinite)
  • for-loops - when you know precisely how many times you will loop (definite). Loop variable only defined within loop.
  • do-while-loops - checks condition at end; always executes the body at least once
• Hand tracing, unraveling the loop
• Common Errors: infinite loops, off-by-one
• Sentinel values - the user controls when to stop
• Checking for correct user input and break statements
• Common Examples:
  • computing sums, averages, all matches, first match, max values, min values, comparing adjacent values
  • Basic Looping Problems (pdf)
  • Nested loops. See Nested Loop Problems (pdf)

Chapter 7 Arrays and ArrayLists

• Declaring 1-dimensional arrays. (Here are some old notes on 1D Arrays.)
• Accessing array elements
• Initializing arrays
  • one at a time.
  • Using for-loop
  • Using Arrays class.
• Printing or Using arrays
  • one at a time.
  • Using for-loop
  • Using an enhanced loop
  • Using Arrays class.
• Array of primitives vs array of object/references
• Swapping elements in an array.
• Copying arrays.
• Comparing arrays.
• Accumulating values in an array.
• Be sure you understand how to draw Object Diagrams
• Arrays as return values and parameters in methods. Arrays are passed by reference. Recall Pass by Value vs Pass by Reference (pdf)
• ArrayLists: declaring, adding/removing elements, look at method list, copying, wrappers for primitive types
• Declaring multi-dimensional arrays. (Here are some old notes on 2D Arrays.)

Chp 11: Input/Output and Exception Handling

Chp 8: Designing Classes

• Class (static) methods and variables - class methods can only access class variables
  • Instance Variables
  • Class vs Instance Variables
  • Class vs Instance Methods
  • Only one copy exists of a static field regardless of how many objects that that type exist.
  • Don't need to create an object in order to access static fields, e.g. see Math class.
• Write a .equals method for the Card class. Need to do this if you want to compare objects. Also write a compareTo() method and using the Comparable interface.
• Deep copying - don't create a copy using references of the member variables.
  Also, when returning a member variable, it can be safer to return a copy and not the reference.

Chapter 9 Inheritance and Chp 10: Interfaces

• What is inheritance and why use it?
• Subclasses vs superclasses - See Hierarchy
• A class can have only one direct superclass. A class can have multiple subclasses.
• Don't overuse subclasses.
• Subclasses:
  • How are they defined (using extends)
  • Overriding methods
  • What variables and methods in the super class can be accessed by the subclass?
    • public vs protected: Protected modifier allows access by all subclasses and all classes in the same package (folder).
    • private variables in the superclass are not accessible from the subclass except using setter/getters.
    • Using super() in the first line of constructor
    • Using super.method_name() anywhere in a subclass method.
• Polymorphism:

      Employee[] employees = new Employee[3];
      employees[0] = new HourlyEmployee();
      employees[1] = new SalariedEmployee();
      for (int i=0; i < employees.length; i++) {
  	     System.out.println("The employee is " + employees[i].getName() + 
  		               " and their pay is " + employees[i].calcPaycheck());
       }
  

  • Which getName() is called? Which calcPaycheck() method is called? The one in superclass (Employee) or in the subclass (HourlyEmployee, SalariedEmployee)?
• Abstract class:
  • Declare as

    public abstract class Employee { 
    	    public abstract double calcPaycheck(); 
    	    ... 
    

    Must define method in the subclass. Can't create an Employee object; can only create a subclass.
• Using the keyword final so that one can't override a method in the subclass.
• The universal super class: Object
  All Java classes are subclasses of the Object class and inherit the methods: toString(), equals(), hashCode(). These methods should generally be overriden.
• instanceof operator can be used to check what type of object you have. For example, if you need to cast an object. Should be used sparingly. Don't use as a way to implement different behavior, i.e. to bypass polymorphism.
• Interface - using the implements keyword.
  • An interface (typically) has no variables, only methods which are not implemented. Any variables must be static and final.
  • An interface is used to force a class to define a set of methods so as to force consistency across a set a classes.
  • Examples: The Comparable interface
  • A class can have only one superclass but can implement multiple interfaces.