Lehigh University

CSE 366 Object-oriented Programming (3)

Instructor:

Current Catalog Description
The implementation of object orientation in languages such as Smalltalk and Java. Objects, classes, inheritance, graphical interfaces, applets, exception-handling, and multi-threading. Prerequisite: CSE 17

Textbook
Budd T. An Introduction to Object-Oriented Programming, 3rd Ed., 2002, Addison-Wesley. Deitel HM & Deitel PJ. Java: How to Program, 5th Ed, 2003, Prentice-Hall.

References

Course Goals
Understanding of OO language concepts.
Fluency in writing code in Smalltalk (or another dynamically-typed OO language).
Familiarity with core Smalltalk infrastructure classes.
Fluency in writing code in Java (or another statically-typed OO language).
Familiarity with core J2SE infrastructure classes.
Ability to use a design pattern.
Ability to write multi-threaded programs.
Ability to use interfaces.
Ability to use introspection.
Ability to model OO classes in UML.

Prerequisites by Topic
Fluency in C++.
Classes and objects.
Inheritance.
Control structures.
Primitive data types, arrays, and strings.
Recursion.
Basic data structures (linked lists, stacks, queues).

Major Topics Covered in the Course
Statically-typed versus dynamically-typed OO languages
Pointers and memory allocation
Inheritance and substitution
Subclassing versus subtyping
Interfaces
Multiple inheritance
Polymorphism
Overloading
Overriding
UML class diagrams
Container classes
Application frameworks
Design patterns
Cohesion and coupling
Reflection and introspection
Multi-threading
Exception handling and assertions and files and streams

Laboratory projects (specify number of weeks on each)
There are ten programming projects, one week per project.

Estimate CSAB Category Content
                                                                     CORE      ADVANCED
Data Structures
Computer Organization and Architecture
Algorithms Software Design                                                   1.0
Concepts of Programming Languages                                     2.0

Oral and Written Communications
Every student is required to submit at least _0_ written reports (not including exams, tests, quizzes, or commented programs) of typically __0__ pages and to make __0___ oral presentations of typically __0__ minutes duration. Include only material that is graded for grammar, spelling, style, and so forth, as well as for technical content, completeness, and accuracy.

Social and Ethical Issues

Theoretical Content
Object-oriented language concepts (static/dynamic typing, memory allocation, inheritance, substitution, subclassing, subtyping, interfaces, multiple inheritance, polymorphism, overloading, overriding): 10 classes
Concurrency and locking (multi-threading): 1 class
Design principles (container classes, application frameworks, design patterns, cohesion and coupling, reflection, introspection): 9 classes
(There are 42 classes per semester.)

Problem Analysis
The students are exposed to problem analysis in their programming assignments in two ways. First, each assignment presents some analysis results that the student must understand in order to complete the assignment, thus the students are learning about analysis by example. Second, in the assignments they typically apply their own analysis on more tightly constrained problems. An example of this is understanding the introspection classes provided by J2SE and figuring out which classes and methods to use in order to obtain certain results required by the assignment.

Solution Design
The programming assignments typically require the students to understand a specification and implement the corresponding solution. In each assignment many aspects of the design are given, but certain aspects are not specified, in order to focus the students’ attention on these design issues (e.g. which resources need to be locked in a multi-threaded program).

		CSE 366 Object-oriented Programming (3) Instructor: Current Catalog Description The implementation of object orientation in languages such as Smalltalk and Java. Objects, classes, inheritance, graphical interfaces, applets, exception-handling, and multi-threading. Prerequisite: CSE 17 Textbook Budd T. An Introduction to Object-Oriented Programming, 3rd Ed., 2002, Addison-Wesley. Deitel HM & Deitel PJ. Java: How to Program, 5th Ed, 2003, Prentice-Hall. References Course Goals Understanding of OO language concepts. Fluency in writing code in Smalltalk (or another dynamically-typed OO language). Familiarity with core Smalltalk infrastructure classes. Fluency in writing code in Java (or another statically-typed OO language). Familiarity with core J2SE infrastructure classes. Ability to use a design pattern. Ability to write multi-threaded programs. Ability to use interfaces. Ability to use introspection. Ability to model OO classes in UML. Prerequisites by Topic Fluency in C++. Classes and objects. Inheritance. Control structures. Primitive data types, arrays, and strings. Recursion. Basic data structures (linked lists, stacks, queues). Major Topics Covered in the Course Statically-typed versus dynamically-typed OO languages Pointers and memory allocation Inheritance and substitution Subclassing versus subtyping Interfaces Multiple inheritance Polymorphism Overloading Overriding UML class diagrams Container classes Application frameworks Design patterns Cohesion and coupling Reflection and introspection Multi-threading Exception handling and assertions and files and streams Laboratory projects (specify number of weeks on each) There are ten programming projects, one week per project. Estimate CSAB Category Content CORE ADVANCED Data Structures Computer Organization and Architecture Algorithms Software Design 1.0 Concepts of Programming Languages 2.0 Oral and Written Communications Every student is required to submit at least _0_ written reports (not including exams, tests, quizzes, or commented programs) of typically __0__ pages and to make __0___ oral presentations of typically __0__ minutes duration. Include only material that is graded for grammar, spelling, style, and so forth, as well as for technical content, completeness, and accuracy. Social and Ethical Issues Theoretical Content Object-oriented language concepts (static/dynamic typing, memory allocation, inheritance, substitution, subclassing, subtyping, interfaces, multiple inheritance, polymorphism, overloading, overriding): 10 classes Concurrency and locking (multi-threading): 1 class Design principles (container classes, application frameworks, design patterns, cohesion and coupling, reflection, introspection): 9 classes (There are 42 classes per semester.) Problem Analysis The students are exposed to problem analysis in their programming assignments in two ways. First, each assignment presents some analysis results that the student must understand in order to complete the assignment, thus the students are learning about analysis by example. Second, in the assignments they typically apply their own analysis on more tightly constrained problems. An example of this is understanding the introspection classes provided by J2SE and figuring out which classes and methods to use in order to obtain certain results required by the assignment. Solution Design The programming assignments typically require the students to understand a specification and implement the corresponding solution. In each assignment many aspects of the design are given, but certain aspects are not specified, in order to focus the students’ attention on these design issues (e.g. which resources need to be locked in a multi-threaded program).