Active Outline

General Information

Course ID (CB01A and CB01B)
CISD035B
Course Title (CB02)
Advanced Java Programming
Course Credit Status
Credit - Degree Applicable
Effective Term
Fall 2023
Course Description
This course is an introduction to abstract classes, interfaces, generics using Object Oriented Design methodologies, design patterns, reflection, exception handling, multi-threading, Sockets, JDBC, and Web Programming. Students will design a project in a team-based environment working on creating multiple releases of the same project. Software engineering concepts and tools are also introduced.
Faculty Requirements
Course Family
Not Applicable

Course Justification

This advanced Java courses enable students to write enterprise applications in Java. It is part of the Java Programming, Certificate of Achievement. The course is required for transfer for many majors of the California State Universities (CSUs) and is also transferable to all CSUs and UCs.

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

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)

Corequisite(s)

Advisory(ies)

ESL D272. and ESL D273., or ESL D472. and ESL D473., or eligibility for EWRT D001A or EWRT D01AH or ESL D005.

CIS D035A

Limitation(s) on Enrollment

Entrance Skill(s)

General Course Statement(s)

Methods of Instruction

Lecture and visual aids

Discussion of assigned reading

Discussion and problem solving performed in class

Laboratory discussion sessions and quizzes that evaluate the proceedings weekly laboratory exercises

Assignments

  1. Readings from the text.
  2. Documenting, coding, testing, and debugging six to ten programs guided with clearly documented design, covering the Lab Topics specified in X. below, half-completed in the computer lab, half-completed as homework.

Methods of Evaluation

  1. One midterm examination requiring students to write code applying topics covered in the lectures and reading. Responses are evaluated on implementation of stated constructs and correctness of code.
  2. Final examination requiring students to write code applying topics covered in the lectures and reading. Responses are evaluated on implementation of stated constructs and correctness of code.
  3. Evaluation of programming assignments, based on correctness, documentation, code quality, and test plan executions.

Essential Student Materials/Essential College Facilities

Essential Student Materials: 
  • None
Essential College Facilities:
  • Access to a computer system with the Java 2 SDK, or an Integrated Development Environment tool supporting Java 2

Examples of Primary Texts and References

AuthorTitlePublisherDate/EditionISBN
Horstmann CayCore Java, Volume II--Advanced FeaturesPrentice Hall11th Edition, 2019
Ashmore, DerekThe Java EE Architect's Handbook, Second Edition: How to be a successful application architect for Java EE applicationsDVT Press2nd Edition, 2014
Online Reference at java.sun.com Tutorials and J2SE and J2EE API Documentation

Examples of Supporting Texts and References

AuthorTitlePublisher
None

Learning Outcomes and Objectives

Course Objectives

  • Write Java programs using Object Oriented Design and Principles.
  • Integrate the concept of abstract classes, interfaces and inheritance hierarchies for enabling data encapsulation in object components.
  • Design and create Java programs to support the error recovery needed for robust programming.
  • Compare and contrast the collections API and implement data structures for the given requirements to create scalable software.
  • Program reflection features of Java to determine object information at run time.
  • Program classes which support the ability to be cloned.
  • Program thread-safe applications using threading API and collections.
  • Program network enabled application using Sockets.
  • Write web applications using Servlets.
  • Use the JavaServer Faces to program full-featured GUI applications.
  • Write application programs using JDBC API.

CSLOs

  • Read, analyze and explain advanced Java programs.

  • Create algorithms, code, document, debug, and test advanced problems using appropriate design methodology incorporating object oriented programming constructs and advanced Java concepts.

Outline

  1. Write Java programs using Object-Oriented Design and Principles.
    1. Design a real-world application using Object-Oriented Analysis and Design Methodology applying encapsulation, association, association, inheritance, and polymorphism.
    2. Display the usage of design patterns for a given set of requirements.
    3. Compose a software framework in design and present the object design in UML.
    4. Choose an appropriate inner class type in a given class hierarchy and code it.
    5. Reflect on implementing serialization with inner classes.
  2. Integrate the concept of abstract classes, interfaces, and inheritance hierarchies for enabling data encapsulation in object components.
    1. Define and implement the role of abstract classes in software framework.
    2. Define and implement the role of interfaces in software framework and how data hiding is enabled.
    3. Integrate abstract classes and interfaces to develop API (A Programming Interface).
    4. Describe microservices architecture and program to build a self-contained, scalable, and flexible application.
    5. Code an orchestration layer using design pattern to integrate microservices.
  3. Design and create Java programs to support the error recovery needed for robust programming.
    1. Summarize and usage of try/catch clause and how it is used during runtime.
    2. Interpret Exception class API and implement it.
    3. Implement an exception numbering system for microservices to target source of software problems.
    4. Define the concept of exception number in software architecture and how it is used for software quality assurance.
    5. Compare and contract checked and unchecked exceptions.
    6. Implement a custom exception handler to build self-healing software.
    7. Define concept of Assertions and implement in unit-level testing.
    8. Summarize regular expressions (regex) API and implement it.
  4. Compare and contrast the collections API and implement data structures for the given requirements to create scalable software.
    1. Predict what data structures to use based on the requirements: size, usage (create versus read, update and delete operations), sorted / unsorted data, etc.
    2. Summarize how generics work and implement with collections.
    3. Journal and contrast algorithms used with lists, sets, trees, maps, and hashing.
    4. Exemplify scenarios used for specific data structures.
    5. Journal methods used in ArrayList, LinkedList, HashSet, HashMap, TreeSet, TreeMap, LinkedHashSet, and LinkedHashMap.
    6. Display understanding of generics by implementing custom templates.
  5. Program reflection features of Java to determine object information at run time.
    1. Articulate usage of Class API to find class information from an object.
    2. Use reflections API to find the information on class body: instance variables and methods, constructors, class inherited and implemented.
  6. Program classes which support the ability to be cloned.
    1. Define concept of call-by-value and call-by-reference and implement it.
    2. Program the usage of Cloneable interface.
  7. Program thread-safe applications using threading API and collections.
    1. Relate multithreading construct to creating microservices architecture.
    2. Compare and contract Thread class and Runnable interface from Java API.
    3. Implement synchronized methods and describe their implementation in Java Virtual Machine.
    4. Simulate usage of wait and notify methods and define its importance in software framework.
    5. Define deadlocks and strategies to avoid deadlocks.
    6. Define thread life cycle and its relation to the operating system it runs on.
  8. Program network-enabled application using Sockets.
    1. Compare and contrast OSI and Network architecture.
    2. Comprehend Socket and ServerSocket API to implement in network-based applications.
    3. Summarize usage of InetAddress API.
    4. Program URL class to mimic a custom browser/
  9. Write web applications using Servlets.
    1. Identify component architecture and review how Servlets are used to implement it.
    2. Outline the Servlet API and use it for programming web applications with Java Server Faces.
    3. Examine the Servlet lifecycle and implement configuration files in J2EE container.
  10. Use the JavaServer Faces to program full-featured GUI applications.
    1. Define and program JSF Web Application Framework and View Description Language
    2. Program JavaServer Face Pages using Facelets
    3. Implement Core Tag libraries in Facelet Pages
    4. Examine and implement HTML RenderKit Tag Library
    5. Define bean properties and bean scopes
    6. Bind UI Components with Managed Beans
    7. Interpret Unified Expression Language (EL)
    8. Journal and configure faces-config.xml configuration File
    9. Comprehend and implement implicit navigation rules in JSF 2.0
    10. Outline "Validating and Converting Data" process and implement it.
    11. Outline usage of DataTable component and implement it.
    12. Interpret the Facelets AJAX tag and implement it.
  11. Write application programs using JDBC API.
    1. Paraphrase usage of establishing a connection, connecting to a data source, setting up tables, retrieving and modifying values from the result set, using Prepared statement, and controlling transactions.
    2. Implement JDBC to persist and retrieve data, understanding the relationship between object model and relational data.

Lab Topics

  1. Design solution, write code, and debug code implementing Object Oriented Design.
  2. Design solution, write code, and debug code implementing Exception Handling.
  3. Design solution, write code, and debug code implementing Inner Classes.
  4. Design solution, write code, and debug code implementing Web Programming.
  5. Design solution, write code, and debug code implementing Socket Programming.
  6. Design solution, write code, and debug code implementing Java Server Faces.
  7. Design solution, write code, and debug code implementing JDBC.
  8. Design solution, write code, and debug code implementing Cloning.
  9. Design solution, write code, and debug code implementing Reflections.
  10. Design solution, write code, and debug code implementing Multithreading.
  11. Design solution, write code, and debug code implementing Servlets.
Back to Top