Active Outline

General Information

Course ID (CB01A and CB01B)
CIS D036B
Course Title (CB02)
Intermediate Problem Solving in Java
Course Credit Status
Credit - Degree Applicable
Effective Term
Fall 2022
Course Description
In this course, students will learn a systematic approach to the design, construction, and management of computer programs, emphasizing design, programming style, documentation, testing, and debugging techniques. Topics include strings, multi-dimensional arrays, and classes, as well as references and their use in arrays, parameters, and containment. The course concludes with an introduction to linked lists.
Faculty Requirements
Course Family
Not Applicable

Course Justification

This course is a major preparation requirement in the discipline of computer science for at least one CSU or UC. This course belongs on the Systems Programming A.A. degree. This course teaches intermediate-level object-oriented constructs and is the second course in a sequence that is compliant with the standards of the Association for Computing Machinery.

Foothill Equivalency

Does the course have a Foothill equivalent?
No
Foothill Course ID

Course Philosophy

Formerly Statement

Course Development Options

Basic Skill Status (CB08)
Course is not a basic skills course.
Grade Options
  • Letter Grade
  • Pass/No Pass
Repeat Limit
0

Transferability & Gen. Ed. Options

Transferability
Transferable to both UC and CSU
C-IDArea(s)StatusDetails
COMPComputer ScienceApprovedCIS D036B & (CIS D022C or CIS D22CH ) required for C-ID COMP 132

Units and Hours

Summary

Minimum Credit Units
4.5
Maximum Credit Units
4.5

Weekly Student Hours

TypeIn ClassOut of Class
Lecture Hours4.08.0
Laboratory Hours1.50.0

Course Student Hours

Course Duration (Weeks)
12.0
Hours per unit divisor
36.0
Course In-Class (Contact) Hours
Lecture
48.0
Laboratory
18.0
Total
66.0
Course Out-of-Class Hours
Lecture
96.0
Laboratory
0.0
NA
0.0
Total
96.0

Prerequisite(s)

CIS D036A

Corequisite(s)

Advisory(ies)

Limitation(s) on Enrollment

(Students may receive credit for either (CIS D036A and CIS D036B) or CIS D035A.)

Entrance Skill(s)

General Course Statement(s)

Methods of Instruction

Lecture and visual aids

Discussion of assigned readings

Discussion and problem solving performed in class

Collaborative learning in small group exercises

Examination review performed in class

Laboratory discussion sessions

Laboratory experience which involves students in designing, coding, testing, and debugging efficient Java programs

Assignments

  1. Reading: required readings from the text.
  2. Programs: 6-10 programming homework assignments, which include design as well as coding and employ sequential text files for the input and output of information; at least two should be about 500 lines of code, including standard documentation, covering the Lab Topics specified in X. below, half-completed in the computer lab, half-completed as homework, with some labs requiring teams to work in a collaborative way to complete.

Methods of Evaluation

  1. Successful completion of programming assignments with output verifying program correctness; use of structured design principles, documentation, programming style, efficiency, and testing methods.
  2. One or more examinations requiring some programming, concepts clarification, and exhibiting mastery of programming principles.
  3. A final examination requiring concepts clarification and exhibiting mastery of programming principles.

Essential Student Materials/Essential College Facilities

Essential Student Materials: 
  • None
Essential College Facilities:
  • Access to a computer with a Java compiler

Examples of Primary Texts and References

AuthorTitlePublisherDate/EditionISBN
Tony GaddisStarting Out With Java: From Control Structures through ObjectsPearson8th Edition, 2021

Examples of Supporting Texts and References

AuthorTitlePublisher
Introduction to Java Programming, Comprehensive Version
Core Java(TM), Volume I--Fundamentals

Learning Outcomes and Objectives

Course Objectives

  • Create programs which demonstrate knowledge of manipulating data in arrays of one or more dimensions.
  • Use Java String and StringBuilder classes for manipulation of strings.
  • Use Object-oriented programming concepts to design applications and computer programs.
  • Create programs which use Inner Classes.
  • Design, code, and test programs using linked lists.
  • Create Programs which use Exception Handling

CSLOs

  • Read, analyze and explain intermediate level Java programs.

  • Design solutions for intermediate level problems using appropriate design methodology incorporating intermediate programming constructs.

  • Create algorithms, code, document, debug, and test intermediate level Java programs.

Outline

  1. Create programs that demonstrate knowledge of manipulating data in arrays of one or more dimensions.
    1. One-Dimensional Arrays
      1. Binary Search
      2. Bubble Sort and Insertion Sort
    2. Two-Dimensional Arrays
      1. Declaration
      2. Initialization
      3. Access of individual elements
      4. Use with methods
    3. Arrays of more than two dimensions
      1. Declaration
      2. Initialization
      3. Access of individual elements
      4. Ragged Arrays
    4. Test design and debugging strategies
  2. Use Java String and StringBuilder classes for manipulation of strings.
    1. String Class
      1. Character testing and case conversion functions
      2. Software engineering: Strings stored as arrays
      3. String class member methods
      4. Using references to pass Strings
      5. The String pool
    2. StringBuilder Class
      1. I/O with StringBuilder objects
      2. Sorting with String Objects
      3. StringBuilder class member methods
      4. Mutability of StringBuilder class vs Immutability of the String class
  3. Use Object-oriented programming concepts to design applications and computer programs.
    1. Object-oriented design
      1. Encapsulation and information-hiding
      2. Separation of behavior and implementation
      3. Unified Modeling Language (UML)
      4. Creating a set of objects (records) with classes.
      5. Data representation in memory using JVM (static memory area, stack, heap, and garbage collection).
      6. Object references and automated memory management.
      7. Trade-offs of Objected Oriented Design over structured programming.
      8. Introduction to Object-Oriented Design strategy.
      9. Abstraction
      10. Differentiate between static and dynamic binding before and during computation.
    2. Classes and Subclasses
      1. Constructors
      2. Fields
      3. Accessors and Mutators
      4. Association
      5. Inheritance
      6. Encapsulation - Hiding fields
      7. Use of overloaded methods
      8. Class hierarchies
      9. Overriding methods
      10. Polymorphism
      11. Internal representations of objects and method tables
      12. Final Classes
      13. Object type compatibility, binding, visibility, and lifetime management.
      14. Scope management across classes with packages, inheritance, and abstraction using interfaces and abstract classes.
      15. Overview of Garbage Collection algorithms and lifetime management of types.
      16. Overriding toString and equals methods from the Object class
      17. Illustrate usage of an instance of and Reflection API to defend the importance of type and type-checking for abstraction and safety.
    3. Abstract Classes and Methods
      1. Definitions
      2. Implementing abstract classes
      3. Contract implementation
    4. Interfaces
      1. Defining an Interface
      2. Implementing an Interface
      3. Using Interface as a datatype
      4. Extending Interfaces
      5. Implementing the Comparable interface and overriding the compareTo method
    5. Generics (Templates)
      1. Creation of reusable types.
      2. Usage of generics to manage components.
      3. Inheritance and Generics
  4. Create programs that use Inner Classes.
    1. Software engineering: abstract data types
    2. Declare an inner class
    3. Access fields in inner classes
    4. References to inner classes
    5. Nested inner classes
    6. Inner classes and methods
      1. Inner class as parameters passed by reference
      2. Return an inner class from a method
    7. Arrays of inner classes
  5. Design, code, and test programs using linked lists.
    1. Traversal
    2. Search
    3. Insertion
    4. Deletion
    5. Dynamic Allocation
    6. Iterators for traversing Linked List.
  6. Create Programs that use Exception Handling
    1. Errors, Checked and Unchecked Exceptions
    2. Exception Propagation
    3. Try-Catch-Finally and Exception Flow of Control

Lab Topics

  1. Array of References.
  2. Searching a one-dimensional array using binary search.
  3. Sorting a one-dimensional array using insertion/bubble sort.
  4. Two-dimensional arrays.
  5. Passing Objects by reference
  6. Inner Classes
  7. Strings.
  8. Design classes and subclasses
  9. Implementing Interfaces and Abstract Classes
Back to Top