Foothill CollegeApproved Course Outlines

Physical Sciences, Mathematics & Engineering Division
C S 1BINTERMEDIATE SOFTWARE DESIGN IN JAVAWinter 2014
4 hours lecture, 3 hours laboratory.5 Units

Total Quarter Learning Hours: 84 (Total of All Lecture, Lecture/Lab, and Lab hours X 12)
 
 Lecture Hours: 4 Lab Hours: 3 Lecture/Lab:
 Note: If Lab hours are specified, see item 10. Lab Content below.

Repeatability -
Statement: Not Repeatable.

Status -
 Course Status: ActiveGrading: Letter Grade with P/NP option
 Degree Status: ApplicableCredit Status: Credit
 Degree or Certificate Requirement: AS Degree,   Foothill GE
 GE Status: Communication & Analytical Thinking

Articulation Office Information -
 Transferability: BothValidation: 07/01/2013

1. Description -
Systematic treatment of intermediate concepts in computer science through the study of Java object-oriented programming (OOP). Coding topics include Java interfaces, class extension, generics, the Java collections framework, multi-dimensional arrays and file I/O. Concept topics include OOP project design, inheritance, polymorphism, method chaining, functional programming, linked-lists, FIFOs, LIFOs, event-driven programming and guarded code.
Prerequisite: C S 1A.
Co-requisite: None
Advisory: Demonstrated proficiency in English by placement into ENGL 1A as determined by score on the English placement test or through an equivalent placement process.

2. Course Objectives -
The student will be able to:
  1. Configure a Java Development Kit (JDK) and Integrated Development Environment (IDE) for advanced Java programming.
  2. Use both instance members and static members, as appropriate, in class design.
  3. Analyze and demonstrate the use of multi-dimensional arrays in Java.
  4. Design, implement, and test Java programs that use class inheritance, and explain why this is an example of the is-a relationship.
  5. Demonstrate the use of function chaining between derived class and base class methods.
  6. Describe the difference between deep copies and shallow copies in Java, and write programs that effectively handle deep memory.
  7. Explain how guarded code is implemented in Java through exceptions.
  8. Express numbers in decimal, binary and hexadecimal representations and use bitwise logical operators to process data at the bit and byte level.
  9. Identify an inner class and note its use in event-driven Graphical User Interface (GUI) code.
  10. Demonstrate a working knowledge of basic abstract data types and their Java-based API classes.
  11. Produce end-user programs which feature event-driven techniques that provide a sensible and easy-to-use GUI.
  12. Explain what abstract classes and Java interfaces are and how they are used.
  13. Describe declaration models for run-time storage allocation, garbage collection and type checking.
  14. Use some of the Java Collections Framework collections to write efficient and portable application programs.
  15. Define various types of Java generics and show how each is specialized to a class by the client program.
  16. Write to and read from files using intermediate file I/O operations in a Java program.
  17. Design, implement, test, and debug intermediate-level Java programs that use each of the following fundamental programming constructs: string processing, numeric computation, simple I/O, arrays and the Java API.
  18. Write applications that solve problems in one or more application area: mathematics, physics, chemistry, cellular automata, 3-D simulation, astronomy, biology, business, Internet.
3. Special Facilities and/or Equipment -
  1. Access to a computer laboratory with Java compilers.
  2. Website or course management system with an assignment posting component (through which all lab assignments are to be submitted) and a forum component (where students can discuss course material and receive help from the instructor). This applies to all sections, including on-campus (i.e., face-to-face) offerings.
  3. When taught via Foothill Global Access on the Internet, the college will provide a fully functional and maintained course management system through which the instructor and students can interact.
  4. When taught via Foothill Global Access on the Internet, students must have currently existing e-mail accounts and ongoing access to computers with internet capabilities.

4. Course Content (Body of knowledge) -
  1. Setting up a complete Java environment.
    1. The JDK
    2. Eclipse
    3. Configuring the IDE for advanced Java programming
  2. The proper use of class members and methods
    1. When to use instance members and methods
    2. When to use static members and methods
    3. Implicit and explicit use of the "this" object
  3. Multi-dimensional arrays
    1. 2-D arrays
    2. Ragged 2-D arrays
    3. Instantiation of objects in multi-dimensional arrays
  4. Inheritance
    1. The "is a" relationship
    2. Base classes
    3. Derived classes (subclasses) and class heirarchy
    4. Derived class constructors
    5. Member method overriding vs. simple overloading
    6. Private, protected, public and default members
    7. Encapsulation and Polymorphism
  5. Function Chaining
    1. Constructor chaining
    2. Member method chaining
  6. Deep vs. Shallow Copies of Objects
    1. Instantiation of member objects in constructors
    2. Cloning objects
    3. Deep copy cloning and its uses
    4. Shallow copy cloning and its uses
  7. Exception Handling and Event-Driven Programming
    1. Built-in Java exception classes
    2. User-defined exceptions
    3. When to re-throw and when to handle an exception
    4. Alternatives to exceptions
    5. Event-handling methods
  8. Non-decimal arithmetic
    1. Bitwise numeric operators
    2. Bitwise logical operators
    3. Binary and hexadecimal constants
  9. Inner Classes
    1. When to use an inner class
    2. Inner classes in event-driven GUI programs
  10. Topics in Abstract Data Types (ADTs)
    1. The vector ADT and Java's ArrayList
    2. The linked-list ADT and Java's LinkedList
    3. The Stack and Queue ADT
    4. Implementing ADTs through inheritance
    5. Using existing ADTs from java.util
  11. Topics in Graphical User Interface (GUI) design
    1. GUI through applets
    2. GUI through applications
    3. The Font class
    4. Swing
    5. Multi-threaded GUIs
  12. Abstract Classes and Interfaces
    1. Defining and using abstract classes
    2. Defining and using interfaces
    3. Implementing interfaces and abstract classes
  13. Storage Allocation Methods
    1. Run time binding and storage management of activation records.
    2. Declaration consequences of pointers, references and value parameters.
    3. Strong type-checking and run-time vs. compile time error detection.
    4. Effect of declaration strategy on binding, visibility and lifetime of variables.
    5. Effect of declaration strategy on scope and persistence of variables.
  14. Java Collections Frameworks
    1. Java ArrayLists and ListIterators
    2. Java LinkedLists and ListIterators
    3. Java PriorityQueues
  15. Java Generics
    1. Generic classes
    2. Type Parameters
    3. The occasional need for wrapper classes
    4. Autoboxing
    5. Static generic methods
    6. Type bounds
    7. Wildcards
  16. Topics in Java File I/O
    1. Binary I/O and FileInput/OutputStream
    2. Handling file exceptions
    3. Buffered input readers and writers and BufferedInput/OutputStream
    4. Primitive data and DataInput/OutputStream
    5. Print Writers and PrintWriter
  17. Essential examples and Assignment Areas
    1. String/text processing
    2. Numeric computation
    3. User interaction
    4. Multi-class projects and compound data types
    5. Inheritance-based projects
    6. Representative GUI project with event-driven design
    7. Multi-threading GUI project
  18. Applications used throughout course in selected areas
    1. Math
    2. Physics
    3. Chemistry
    4. Biology
    5. Astronomy
    6. Business and finance
    7. Internet
5. Repeatability - Moved to header area.
 
6. Methods of Evaluation -
  1. Tests and quizzes
  2. Written laboratory assignments which include source code, sample runs and documentation.
  3. Final examination
7. Representative Text(s) -
Liang, Y. Daniel, Introduction to Java Programming, 8th Edition, Prentice Hall, 2010.

8. Disciplines -
Computer Science
 
9. Method of Instruction -
  1. Lectures which include motivation for syntax and use of the Java language and OOP concepts, example programs, and analysis of these programs.
  2. On-line labs (for all sections, including those meeting face-to-face/on campus) consisting of
    1. A programming assignment web-page located on a college-hosted course management system or other department-approved Internet environment. Here, the students will review the specification of each programming assignment and submit their completed lab work.
    2. A discussion web-page located on a college hosted course management system or other department-approved Internet environment. Here, students can request assistance from the instructor and interact publically with other class members.
  3. Detailed review of programming assignments which includes model solutions and specific comments on the student submissions.
  4. In person or on-line discussion which engages students and instructor in an ongoing dialog pertaining to all aspects of designing, implementing and analyzing programs.
  5. When course is taught fully on-line:
    1. Instructor-authored lecture materials, handouts, syllabus, assignments, tests, and other relevant course material will be delivered through a college hosted course management system or other department-approved Internet environment.
    2. Additional instructional guidelines for this course are listed in the attached addendum of CS department on-line practices.
 
10. Lab Content -
  1. Familiarization with the intermediate-level online lab environment
    1. Modify and customize project-specific and global settings of an Integrated Development Environment (IDE).
    2. Use the IDE to create multi-file programming projects.
    3. Organize projects within an IDE so as to support easy project-switching and orderly submission of labs.
    4. Gain experience with the steps needed to edit a complex program.
    5. Modify IDE settings to produce an industry standard code style.
  2. Organizing and debugging multi-class projects
    1. Demonstrate the ability to debug programs that contain multiple classes.
    2. Distinguish between interface and implementation in projects by creating classes that are independent of I/O modality.
    3. Write individual component classes that are independent of client use and can serve several client programs.
    4. Incorporate symbolic constants, statics and instance members into classes in a way that demonstrates a mature understanding of object-oriented programming (OOP) in a lab project.
    5. Debug a multi-class project to produce a working program.
  3. Exploring advanced array constructs in class design
    1. Gain experience in effectively using single and multi-dimensional arrays as class members.
    2. Apply nested loops to process multi-dimensional arrays.
    3. Use the IDE to debug errors in multi-dimensional arrays.
    4. Solve problems using fixed-size and dynamic sized arrays, as appropriate.
  4. Demonstrating competence in intermediate level algorithm design using classes within the IDE
    1. Use the IDE to implement a multi-faceted algorithm and/or simulation that makes effective use of OOP.
    2. Evaluate and comment on other students' algorithms.
    3. Utilize a combination of string processing and numeric processing to address various aspects of the algorithm implementation.
    4. Produce clear program runs which demonstrate that the algorithm addresses a variety of cases and/or input states.
    5. Incorporate bitwise and logical operations to address binary logic tasks within an algorithm.
  5. Building a program that uses class inheritance to demonstrate how re-use is handled in OOP.
    1. Create a project that contains at least one class intended to be used as a base class.
    2. Derive (sub-class) one or more classes from the base class.
    3. Use function chaining to avoid code duplication between base classes and derived classes.
    4. Differentiate between, and document in your lab, the distinct use of method overloading and method overriding.
  6. Incorporating basic abstract data types in programming projects
    1. Implement a fundamental abstract data type (ADT) such as a queue or stack in a programming lab.
    2. Use a previously written ADT from the programming language's application programmer interface (API) .
    3. Incorporate inheritance in a project that uses ADTs.
    4. Provide a client program that tests and demonstrates the correct behavior of the ADT.
  7. The proper use of deep and shallow copies in conjunction with inheritance and other advanced techniques learned in previous labs
    1. Create the proper set of methods within a class that enables an object to be cloned (copied deeply) correctly.
    2. Utilize inheritance to reinforce the segregation of data into base- and derived-level behavior.
    3. Utilize at least one other lab concept previously, such as binary logic or multi-dimensional arrays to further improve integration of intermediate concepts.
    4. Separate I/O and implementation in advanced programs.
  8. Building projects that use generics (A.K.A. templates)
    1. Demonstrate the difference in a lab project between deriving from a base class and specializing a generic.
    2. Practice writing a generic as well as using a language-defined generic (template) in a project.
    3. Use generics to exercise some aspect of ADTs such as specializing a generic ADT to make its behavior specific to an assigned project specification..
    4. Employ debugging techniques to solve problems that arise when designing with generic (template) classes.
  9. Exceptions and File I/O in Programming
    1. Write a class that has methods which use exception handling to report errors to the client.
    2. Write a test client that uses try/catch blocks to detect exceptions.
    3. Implement an algorithm or simulation that reads from and/or writes to files rather than the user screen
    4. Demonstrate various ways errors are handled and reported besides exceptions.
 
11. Honors Description - No longer used. Integrated into main description section.
 
12. Types and/or Examples of Required Reading, Writing and Outside of Class Assignments -
  1. Reading
    1. Textbook assigned reading averaging 30 pages per week.
    2. Reading the supplied handouts and modules averaging 10 pages per week.
    3. Reading on-line resources as directed by instructor though links pertinent to programming.
    4. Reading library and reference material directed by instructor through course handouts.
  2. Writing
    1. Writing technical prose documentation that supports and describes the programs that are submitted for grades.
13. Need/Justification -
This course is a required core course for the AS Degree in Computer Science.


Course status: Active
Last updated: 2014-06-18 17:05:35


Foothill CollegeApproved Course Outlines