582103 Advanced course in programming
| Principal themes | Prerequisite knowledge | Approaches the learning objectives | Reaches the learning objectives | Deepens the learning objectives |
|---|---|---|---|---|
| Techniques for class specification | • Classes, objects, and encapsulation (Introduction to programming) | • Know that 'static' relates to class, 'non-static' to instance of a class. | • Can use static and non-static variables as well as methods in programming. • Know the possibilities and problems associated with scope rules: private attributes, package-level attributes, visibility to subclasses, public attributes. |
• Can design program architecture with class- and object-level techniques and different visibilities. |
| Inheritance | • Classes, objects (Introduction to programming) | • Start to realise how subclasses inherit the features, fields and methods of superclasses. • Can outline the tree-like inheritance hierarchy of classes that starts from the Object class. |
• Can understand the relationship between superclass and subclass and know how to program subclasses. • Know the value of encapsulation of inherited fields. • Know that constructors are not inherited and what the consequences are, and can take this into consideration when programming. Can use the expressions this, super, this() and super() in programming. • Can override inherited methods and inherited fields. • Can use (abstract or non-abstract) superclass- or interface type variables on reference-type values, and can thus implement general classes and methods. Undestanding polymorfism is necessary! • Kniow what kind of additions inheritance brings to the scope rules. |
• Have a deep understanding of the use of abstract classes, interface classes, and polymorphism in implementing programs. • Know the concept of multi-inheritance and can explain how we can try to attain the advantages of multi-inheritance in Java without the disadvantages with the help of interfaces. Can take part in a debate about this issue. |
| Handling of exceptions | • Can implement simple Java programs (Introduction to programming) • Have encountered errors |
• Know that you have to deal with exceptions somehow. • Understand how the handling of exceptions affects the performance of programs. |
• Know different methods for handling exceptions. • Know the principle of checked and unchecked exceptions, and can create a program where exceptions are handled at the Exception level. |
• Can program their own exception classes and assess how it is best to handle different errors. |
| Programming technique | • Can implement simple Java programs (Introduction to programming) | • Understand the need for type casts. • Can describe what recursion is. |
• Know primitive types and their assignment compatibility rules, as well as explicit type changes from broader to narrower primitive type. • Can explain the function of a simple recursive method. • Know the principle of packages. • Can use source material to create programs that can read and write text files. • Have learned a few generic collection classes, understand their concept, and can use material to program with them. • Know different principles for how programs work: programs that ask for information, command-line interpreters, filters, event-driven programs. Can also program with the three first-mentioned methods. |
• Can create recursive methods. Understand why the recursive method is exponentially time-consuming for computing the Fibonacci numbers, and binary search logarithmic, and think they understand why quick sort is O(n*log n) in the average case. • Know the concept of activation record stacks when implementing a block-structured language. • Can fluently write file-handling programs. Know serialisation. • Can program their own generic classes. • Can create simple GUI programs according to models. |
Printer-friendly version