At the time of the Final Exam, a student should be able to:
- Design and write code that makes use of the while loop construct.
- Design and write code that makes use of the for loop construct.
- Generate sequences of integers using loops.
- Rewrite a given while and a for and vice versa.
- Use the Scanner class and its methods (next(), nextInt(), nextDouble() etc.) appropriately.
- Use an array (of a given size) to store primitive and object types.
- Loop through an array.
- Pass an array as an argument.
- Create and return an array from a method.
- Create and use an ArrayList (of primitives as well as instances of classes) as an alternative to an array.
- Apply ArrayList methods add(), size(), get(), remove().
- Iterate through the ArrayList to get/update information from the contents stored in the ArrayList.
- Use the enhanced style for loop to iterate through arrays and ArrayLists.
- Select appropriate test cases (ranges, parameter interactions, etc.).
- Apply various methods of testing software: user input, file input, test methods.
- Use the debugger to monitor program execution, including spotting unexpected values of variables and object attributes.
- Explain the problem that exception handling solves.
- Define exception; explain the concepts of "catch" and "throw" as they relate to exceptions.
- For a given program and input condition, determine the control flow of a try-catch block, with and without the finally clause.
- Implement a method that catches an exception thrown by a class in the Java Standard Library.
- Implement a method that uses a try-catch block and a repetition statement (i.e., loop) to validate user input.
- Distinguish between checked and unchecked exceptions.
- Understand the consequences in code of not handling a checked exception within a method where the checked exception occurs.
- Write a method that creates and throws an exception of a specific type.
- Explain the concept of exception propagation; explain the outcome if an exception is thrown and no catch block for that exception is found on the program stack.
GUIs and Event-Driven Programming
- Create graphical user interface (GUI) application programs using components such as JButton, JLabel, JPanel, and JTextField classes from the Java Swing package.
- Explain the roles of event sources and event listeners in event-driven programming.
- Explain the concept of the Java inner class, and how an inner class compares to a "regular" Java class.
- Explain the relationship between an inner class and an enclosing class.
- Implement code to handle an action event from a JButton or JTextField object, using both regular classes or inner classes.
- Explain the purpose of an interface in Java.
- Declare and implement a custom interface.
- Explain the concept of polymorphism.
- Use an interface to access objects sharing a common interface polymorphically.
- Use inheritance in creating classes.
- Use the protected visibility modifier in defining an inheritance hierarchy.
- Explain why a class with a superclass other than object should make an explicit call to a constructor of the superclass.
- Describe when to use an abstract class.
- Create an abstract method; describe the purpose of abstract methods.
- Analyze code that uses inheritance and polymorphism and determine its output on execution.
- Describe the differences between an abstract class and an interface.
This page was based on a similar set of pages developed originally by
Dr. Eric Durant.