The Structure of the Exam

• For all topics, you should be able to trace, analyze, and write Java code.
  • Questions will for the most part consist of:
    • presenting you with a piece of code and asking you what is output — or what the value of one or more variables are — once the code is executed
    • presenting you with a problem description and asking you to write the corresponding code
    • asking you what is wrong with a piece of code and/or asking you to repair it
    • presenting you with a piece of code and asking you to trace the value of one or more variables as the code is executed
  • There will be a 25 point question consisting of a full program.
• Although you will not be asked for definitions of terms (e.g. literal, method header, loop body), you should know them as they will be used in the text of the questions.
• Around 50% of the exam will be taken from the Exercises, Reading, and Coding Labs of the covered lectures
  • I am also posting Sample questions; they are essentially the same format/type as the ones you are assigned.
• While the book is a good supplement, you are only responsible for topics and material in the lecture notes and the CodeLab exercises / labs. The labs are a great way for you to prepare yourself for the exam.

The exam covers Lectures 1-5.

Detailed Topic List

Java Programs

• Basic structure
  • class header /main header boilerplate
  • import statement — when are which ones needed
  • use of {}'s, ;'s
  • comments and indentation

Developing and Executing Java Programs

• IDE's — what they are
  • IntelliJ — the basic interface … creating a project and source file; building/running; error indicators
• Compiling
  • Compilation errors
• Executing
  • Execution/logic errors
• source (.java) files / class (.class) files / data files
• What changes require recompilation and/or re-execution
• Debugging
• Common mistakes

The Software Lifecycle

• problem statement (natural language)
• algorithm (step-by-step solution in formalized natural language)
• implementation/program (programming language)

Literals, Constants, Variables, Types, and Declarations

• integer (1), floating point (3.14), string ("Hello"), character ('H') ) literal
• Variable, etc. naming conventions
  • Camel-case
  • Variables (and methods) begin with lower case
  • Class names begin with upper case
  • most types (other than String) begin with lower case (for now at least)
• int, double, String, char
• Declaring before first use
• constants declared using final

Expressions

• Operators, operands, subexpressions, evaluation (result) of an expression
• Operators
  • Arithmetic
    • +, -, *, / (int and double)
    • % int only
  • Assignment
    • =
    • right-hand side vs left-hand side
  • (String) Concatenation
    • +
    • Using concatenation to convert other types to string (e.g., for printing)
• precedence of arithmetic operators

Conditionals (if/else)

• condition / 'true' part / 'false' part
• when {}'s are needed
• using {}'s
• Simple if (no else)
• Simple if/else
• Nested if/else

  if (…) 
  	if (…)
  		…
  	else
  		…
  else
  	if (…)
  		…
  	else
  		…
  		

• Cascaded

  if (…) 
  	…
  else if (…)
  	…
  else if (…)
  	…
  …
  else
  	…
  		

• Waterfall if
  • Using waterfall approach with a candidate variable

  if (…) …
  if (…) …
  if (…) …
  		

Simple 'for' Loops

• for loops
  • loop / index variable
  • loop header
    • Declaration of loop variable in loop header (for (int i = 1; …)
    • parts of the header
      • initialization (i = 1)
      • test for termination (i <= 5)
      • progress of loop variable (i++)
  • 'Fixed' number of iterations

    for (int i = 1; i <= 10; i++)
    	…
    					

  • User enters the number of iterations to be performed (i.e., variable number of iterations)

    System.out.println("How many students? ");
    int n = scanner.nextInt();
    for (int i = 1; i <= n; i++)
    	…
    					

  • using a variable for the initial value or limit
  • start values other than 1
  • progress other than increment by 1
• loop body
• when {}'s are needed
• infinite loops

Keyboard & File Input / Screen Output (I/O)

• Output
  • the System.out object
  • the print / println methods
  • The PrintStream class
    • Creating objects of the PrintStream class
    • Writing data to files using PrintStream objects
• Input
  • Scanner objects
  • Creating a Scanner object from the keyboard (System.in) and from a data file (File)
  • The next, nextInt, nextDouble, nextLine methods
  • Using more than one scanner object
    • keyboard and file(s)
    • multiple files
• the throws Exception clause when opening a file; FileNotFoundException

Methods

• Calling methods from other classes
• Math class: sqrt, abs, round
• Writing methods
  • method header
    • public static boilerplate
    • return type — void or data type of returned value
    • method name
    • parameter list
  • method body
  • return statement (void and value-returning)
    • implicit return for void method upon reaching closing }
• Calling methods
  • arguments
  • argument → parameter transmission
  • caller / callee
  • the call (caller suspension) / callee executes / callee returns / caller resumes life-cycle
• Variables in methods are local to methods and bear no relationship to variables in other methods (unless receiving their values through parameter passing)

Techniques

• Minimum, maximum
  • of 2 numbers
  • of 3, 4, …
  • Using
    • 'brute force'
    • cascaded
    • method composition
• Divisibility
• Averages / Weighted averages