CS 108 Intermediate Programming (Java)
Fall 2014
Credits: 3 units
Contact Hours: Section 1: Tues and Thurs, 1600-1715, Room P-148
Section 2: Tues and Thurs, 1400-1515, Room GMCS-301
Instructors: Ivan Bajic Office: GMCS 538 Email: ibajic@rohan.sdsu.edu Phone: 619-594-7253
Office Hours: Mon-Thurs 1515-1600, and by appointment
*Course Materials
1. Required text: Horstmann, Java for Everyone: Late Objects , Wiley, 2013.
ISBN-13: 978-1-118-06331-6.
2. Optional text: Hahn, Harley Hahn's Guide to UNIX and Linux , McGraw-Hill, 2008.
ISBN-13: 978-0-073-13361-4 .
3. CS108 lecture notes/slides (available on Blackboard)
*Course Information for CS 108
Description from the Official Course Catalog
Further training in program design and development. Object-oriented programming to include inheritance, polymorphism, and generic code. Extensive programming in Java. Introduction to data structures.
Prerequisites: Computer Science 107
Course Type: Required course in the program
*Specific Goals for CS 108
Course-Level Student Learning Outcomes
* Produce clearly written code in an industry standard style appropriate for Java.
* Configure a Java Development Kit (JDK) and Integrated Development Environment (IDE) for advanced
Java programming.
* Write Java programs using object-oriented design, and contrast the difference between object-oriented and procedural code.
* Design, implement, and test Java programs that use class inheritance, and explain why this is an example of the "is-a" relationship.
* Use both instance members and static members, as appropriate, in class design.
* Explain what abstract classes and Java interfaces are and how they are used.
* Define various types of Java generics and show how each is specialized to a class by the client program.
* Solve problems that have origins in a variety of disciplines including math, science, the Internet.
* Use Object-oriented programming concepts to design applications and computer programs.
* Create programs which use Inner Classes.
* Design and implement classes that use inheritance.
* Design and implement abstract data types using classes, encapsulation, inheritance and polymorphism.
* Use inheritance relationships to create polymorphic references.
* Explain how errors can be reported to the calling function.
* Explain what an algorithm is and give examples of how algorithms are implemented in a Java program.
* Design and implement algorithms using various data structures.
* Analyze the time and space required for algorithms.
* Identify the appropriate data structure and algorithm to solve a programming problem.
* Evaluate appropriate data structures for a given problem.
* Analyze and apply appropriate sorting and/or searching algorithms.
* Design and implement recursive solutions.
* Describe how iterators access the elements of a container.

* Incorporate user-interaction input and output in a program through either console or graphical user interface methods.
* Produce a program that interacts with the user using intermediate GUI elements such as buttons and text-boxes.
* Design and implement simple graphical user interfaces including events and listeners.
* Write to and read from files using intermediate file I/O operations in a Java program.
*Relationship to CS Program Course Outcomes
CS 108 addresses the following CS Program course outcomes (CS Program Student Outcomes):
* a) An ability to apply knowledge of computing and mathematics
* b) An ability to analyze a problem, and identify and define the computing requirements appropriate to its solution
* c) An ability to design, implement, and evaluate a computer-based system, process, component, or program to meet desired needs
* d) An ability to function effectively on teams to accomplish a common goal
* f) An ability to communicate effectively with a range of audiences
* h) Recognition of the need for and an ability to engage in continuing professional development
* i) An ability to use current techniques, skills, and tools necessary for computing practice
* j) An ability to apply mathematical foundations, algorithmic principles, and computer science theory in the modeling and design of computer-based systems in a way that demonstrates comprehension of the tradeoffs involved in design choices.
* k) An ability to apply design and development principles in the construction of software systems of varying complexity.
*Topics Covered
The following topics are covered in CS 108:
* Introduction to classes, objects, and object-oriented techniques for problem solving
* Encapsulation and information hiding
* Instance variables, instance methods, static/class variables, static/class methods, constructors
* Programming with classes and methods
* Inheritance, class hierarchies, derived classes ("is a" relationships)
* Interfaces ; Abstract classes ; Inner classes
* Non/static nested classes ; non/static local classes ; non/static anonymous classes
* Generics ; Iterators (in separate classes, and in inner classes) ; the Comparable interface
* Exception handling: try-catch, throw, throws, exception propagation, checked/unchecked exceptions
* Abstract Data Types (ADTs) and Interfaces
* Polymorphism, dynamic binding and polymorphic method invocation, using inheritance relationships to create polymorphic references
* Graphical User Interfaces (GUIs), events, listeners
* Recursion, implementation of recursive functions
* Solving problems: choice of data structures and algorithms, pseudocode and the language of algorithms
* The timing and efficiency of algorithms; Greek notation, running time functions
* Searching: linear, binary, searching trees
* Sorting: bin sort, bubble sort, insertion sort, selection sort, heap sort, merge sort, quick sort, multi-field
* Lists: array-based list implementation, linked list implementation ; Linked Lists
* Stacks: implementations, basic operations, push, pop, peek, applications
* Queues: implementations, basic operations, enqueue, dequeue, peek, applications; Priority Queues, sorts
* Trees: general trees, binary trees, binary search trees, traversals, searches, using trees
* Hashing: simple hash functions, collision resolution techniques
* File access: file access methods, file handling

*Course Schedule and Grading Policies
Due Dates for Major Assignments and Exams
Week Topic
1 Overview of course; Review of CS107 topics
2 Arrays; Multi-dimensional Arrays; ArrayLists
HW1: 9/5
3 ArrayLists; Recursion
4 Input/output; File input/output; Java Exceptions (Java runtime errors: trapping, handling, generating)
HW2: 9/19
5 Classes and objects
1st Midterm, 9/25
6 Classes and objects (continued)
HW3: 10/3
7 Classes and objects (continued)
8 Object-oriented programming: encapsulation, inheritance, polymorphism
HW4: 10/17
9 OOP (continued)
HW5: 10/24
10 OOP (continued)
2nd Midterm, 10/30
11 OOP (continued)
HW6: 11/7
12 OOP (continued)
13 GUI programming
HW7: 11/21
14-15 Stacks; Queues; Lists; Linked Lists; Binary Trees; Binary
Search Trees
HW8: 12/5
Final Exam, Section 1 (TTH 1600-1715):
Tue., Dec. 16, 2014, from 3:30pm-5:30pm
Final Exam, Section 2 (TTH 1400-1515):
Tue., Dec. 16, 2014, from 1:00pm-3:00pm
Scored activities and weighting by percentage of total score:
Programming assignments (100 points, 8 at 12-13 points each, 20%)
First Midterm (100 points, 20%)
Second Midterm (100 points, 20%)
Final Exam (200 points, 40%)
Grading Scale:
A 95% and above
A– 90%
B+ 87%
C+ 75%
C 70%
C– 65%
B 83%
B– 80%
D
F
55% below 55%
Readings
Ch 1-5
Ch 6
Ch 6; Ch 5
Ch 7
Ch 8
"
"
Ch 9
"
"
"
"
Ch 10

*Other Course Policies
Special Assistance: If you are a student with a disability and believe you will need accommodations for this class, it is your responsibility to contact Student Disability Services at (619) 594-6473. To avoid any delay in the receipt of your accommodations, you should contact Student Disability Services as soon as possible. Please note that accommodations are not retroactive, and that accommodations based upon disability cannot be provided until you have presented your instructor with an accommodation letter from
Student Disability Services. Your cooperation is appreciated.