1. Slides 4/22 COP 3330

2. Topics Final Exam Review

3. Final Exam The final exam is Friday, April 29 th at 10:00 AM in the usual room No notes, books, calculators, etc. Don't forget! Duration is officially 2 hrs and 50 minutes – not likely to take more than 90 minutes though.

4. Topics Focus is largely on the fundamentals covered during the first two exams. The newer material will still be covered, but not in great detail. I'll give some examples of what you can expect further along.

5. Enums An enum defines a finite number objects of the same type - Begins by explicitly enumerating those objects - After the semicolon, it's just like any other class (except that the enumerated objects are the only ones that can exist) The default toString() method returns the name of the object – you can override this, though. The static values() method returns an array of the enumerated values

6. Generics Generic polymorphism allows classes to be defined in terms of other classes - E.g. Vector is a Vector of Strings You can make your own generic class by putting after the name of your class (where T can be any valid identifier) Then, inside your class, T refers to whatever is passed in as the generic formal parameter - E.g. If you have public MyClass and someone constructs a MyClass, then T refers to Integer

7. Threads To create a Thread: - Pass a Runnable object to the constructor of Thread - Call the start() method on the Thread object to start the run() method of the Runnable object in a new thread

8. UML

9. Access modifiers: The visibility of fields and methods are represented by the first character before their names - Private: - - Public: + - Protected: # Other modifiers: - If a method or field is underlined that indicates that it is static - If a method, field, or class name is italicized, that indicates that it is abstract

10. UML Inter-class relationships - Generalization (extends)  Arrow points at the superclass - Realization (implements)  Arrow points at the interface  Lollipop doesn’t allow for details - Composition (has-a: built out of)  Closed diamond is next to the class that holds things - Aggregation (has-a: container)  Open diamond is next the class that holds things - Association

11. Class Basics Instance Variables (Fields) Instance Methods Static Variables (Fields) Static Methods Constructors

12. Inheritance The keyword extends defines an is-a relationship between classes - If Foo extends Bar, then Foo is-a Bar - That means that variables of type Bar can also hold objects of type Foo The keyword implements also defines an is-a relationship, but between classes and interfaces - If Foo implements Comparable, then Foo is-a Comparable Dynamic binding refers to waiting until runtime to determine what code a method call will go to

13. Inheritance Interfaces provide a set of methods that must be written in anything that implements the interface Abstract classes provide partial implementations of a class, but it’s left to anything that inherits from it to fill in the gaps

14. Polymorphism This is the ability to have objects of different types that possess similar structure or behavior, though they may implement it in their own way. For example, a Cat object and a Dog object can both respond to a makeNoise() method, even though the results of that method call will vary.

15. Polymorphism These different objects need to 'look the same' to the methods that make use of them. - If the object is passed as a parameter, the type of the object needs to be fixed. If it's a Cat, then we can't pass a Dog object. The is-a relationships imposed by inheritance or implementing an interface is Java's way to make them look the same. For example, Cat and Dog could both inherit from Animal, so a method that uses either Cat or Dog objects can just take a reference of type Animal. Since both Cat and Dog are also Animals, they 'look the same' in that respect. Similarly, if Cat and Dog both implemented the same interface ( Noisy, for example) then the method could just take a reference of type Noisy.

16. Example public void sing(Animal a) { for(int i = 0; i < 10; i++) a.makeNoise(); }.... Cat c = new Cat(); sing(c); Dog d = new Dog(); sing(d);

17. Dynamic Binding This is really what makes polymorphism useful. With our Cat and Dog example, remember that if we use an Animal reference to hold either of these objects, we can only 'see' (and therefore call) the methods that they inherit from Animal. However, if Cat and Dog override Animal 's makeNoise() method, then when we call it on our Animal reference – the correct overridden version will be called. If the reference points to a Cat, it'll call Cat 's version of the method. If it's a Dog, it'll call Dog 's version. If it's an Animal, it'll call Animal 's version.

18. Dynamic Binding In our sing() example, when the compiler processes the sing() method, it doesn't know whether it will be passed a Cat or a Dog object. So it doesn't link up the call to makeNoise() with an actual method at compile-time. When the program is run, it examines the actual object it was passed, figures out the type, and then binds the call to the correct code. This is why we call the binding 'dynamic'. It's also sometimes called late binding. The normal approach is usually called static binding (not to be confused with static methods!).

19. instanceof foo instanceof Bar evaluates to - true: only if foo holds an object that can be treated as a Bar - Compile error: if it is illegal for foo to hold something that could be treated as a Bar - false: if foo could hold something that can be treated as a Bar, but doesn’t

20. super super refers to the parent class - In a constructor, the very first thing that happens is a call to the super constructor - In any instance method, super is the part of this object that comes from the parent class

21. Method Modifiers public – Anything can access it protected – Can only be accessed by things that inherit from the class (or that are in the same package) private – Can only be accessed from within the class abstract – Must be overridden (only allowed in abstract classes) final – Cannot be overridden

22. Errors Compilation Errors Runtime Errors Logic Errors

23. Exceptions Catching exceptions - Use try/catch/finally Throwing exceptions

24. Exceptions Unchecked exceptions - Anything that inherits from RuntimeException is an unchecked Exception - You don’t need to declare that your method throws unchecked exceptions Checked exceptions - Checked exceptions are exceptions that don’t inherit from RuntimeException

25. GUI JOptionPane is used to pop up canned dialogs: - JOptionPane.showMessageDialog() – Pop up a message and an OK button - JOptionPane.showConfirmDialog() – Pop up a message and Yes, No, and Cancel buttons - JOptionPane.showInputDialog() – Pop up a message and collect a string from the user

26. GUI Useful Swing Components - JFrame – A window - JTextArea – A multi-line text entry area - JTextField – A single line text entry area - JLabel – A text or image display area - JButton – A push button - Canvas – (From java.awt) A drawing area  To draw on a Canvas, you need to get access to its Graphics object

27. Examples for newer material Given a simple UML class diagram, write skeleton code for the class (method stubs instead of full-fledged methods). Write an enum representing coin denominations Write a generic method to reverse an array of any type.