CCST Course | Java Programming Module | Teaching Guidelines 90 Hours | 16T + 14L

CCST COURSE
Teaching Guidelines

Module 2: Java Programming

90 Hours | 16 Theory Sessions + 14 Lab Sessions

For Classroom and Lab Faculty Use

Page 1 | Java Programming Teaching Guidelines | CCST Course

CCST Course | Java Programming Module | Teaching Guidelines 90 Hours | 16T + 14L

1. Course Overview

Course Overview
Course Module Java Programming

Total Duration 90 Hours (Theory + Lab)

Theory Sessions 16 Sessions (T)

Lab Sessions 14 Sessions (L)

Session Format 16T + 14L

Target Audience Students / Trainee Software Testers

Prerequisites Basic programming concepts; completion of OS & Software Engineering

module

Delivery Mode Classroom + Hands-on Lab

2. Course Learning Outcomes

Course Learning Outcomes (CLOs)

CL
O Bloom's Level Learning Outcome
#
1 Knowledge Recall Java syntax, JVM architecture, and OOP
terminology

2 Comprehension Explain the Java class lifecycle, exception hierarchy,

and collections framework

3 Application Write Java programs using OOP principles, collections,

and exception handling

4 Analysis Identify bugs and design issues using static analysis

and code review

5 Synthesis Build complete Java programs integrated with a

database via JDBC

6 Evaluation Write and execute JUnit test cases to validate program

correctness

3. Session-wise Teaching Plan

Page 2 | Java Programming Teaching Guidelines | CCST Course

CCST Course | Java Programming Module | Teaching Guidelines 90 Hours | 16T + 14L

Session-wise Teaching Plan

Se
ss
Topic Key Content Points T/L Duration
io
n
1 Introduction to Java Intro to Java, Features, JVM T 2 hrs
Architecture, JDK, Class
Structure, Primitive Data Types,
Java Tokens, Variables, Methods,
Type Compatibility, Operators

2 Basic Programming Conditional Statements, T 2 hrs

Concepts Control/Loop Statements, 1D &
Multidimensional Arrays

La Java Environment & Setup Java environment; print L 4 hrs

b Patterns patterns using loops (e.g., asterisk
1– triangles)
2

3 OOP Concepts Introduction to OOP, Classes & T 2 hrs

Objects, OOP Principles:
Encapsulation, Abstraction,
Inheritance, Polymorphism

4 Abstract Class & Upcasting/Downcasting, Abstract T 2 hrs

Interfaces Class/Methods, Interfaces, Final
keyword, Functional Interface,
Java 8 & 11 features, Lambda
Expressions, Inner Classes (all
types), Enum, Packages

La OOP in Practice Array of objects; abstract class & L 4 hrs

b subclass; multiple interface
3– implementation; enums
4 demonstration

5 Exception Handling & Exception Hierarchy, T 2 hrs

Java Classes Checked/Unchecked Exceptions,
Propagation, try-catch-finally,
throws/throw, Multi-catch, User-
defined Exceptions, Wrapper
Classes,
String/StringBuffer/StringBuilder,
String Pool, Date/Calendar
Classes, Object Class overriding

La Exceptions & User-defined exceptions; boxing & L 2 hrs

b5 Wrapper Classes unboxing with Wrapper classes

6– Introduction to Collection Hierarchy, T 4 hrs

7 Collections List/Queue/Set/Map,
ArrayList/LinkedList/Vector
operations, Comparable &
Comparator, Lambda expressions
& Stream API, Annotations, JDBC
basics & integration

Page 3 | Java Programming Teaching Guidelines | CCST Course

CCST Course | Java Programming Module | Teaching Guidelines 90 Hours | 16T + 14L

La JUnit Test Cases Write and execute JUnit test L 4 hrs

b cases; use annotations and
6– assertions (assertEquals,
7 assertTrue, assertFalse)

8 Writing JUnit Test Introduction to JUnit, JUnit T 2 hrs

Cases Annotations, Writing Basic Test
Cases, Assertions

4. Detailed Session-wise Teaching Guidelines

Session 1: Introduction to Java

Session Objectives 1. Explain the origin, features, and evolution of Java.
2. Describe JVM architecture and how Java achieves platform
independence.
3. Demonstrate Java class structure and declare variables, methods, and
data types.

Topics & Content • Brief history of Java and its design philosophy (Write Once, Run
Anywhere)
• Features of Java: Object-Oriented, Platform Independent, Secure,
Robust, Multithreaded
• JVM Architecture: ClassLoader, Memory Areas (Heap, Stack, Method
Area), Execution Engine
• JDK vs JRE vs JVM – differences and roles
• Structure of a Java class: access modifiers, main method, class body
• Primitive Data Types: byte, short, int, long, float, double, char, boolean
• Java Tokens: keywords, identifiers, literals, operators, separators
• Declaring variables, assigning values, declaring methods
• Type compatibility and implicit vs explicit type casting
• Arithmetic, Relational, Logical, Bitwise, Assignment, Ternary Operators

Teaching Methods • Lecture with whiteboard diagram for JVM architecture

• Live coding demonstration of a first Java class with main method
• Show class compilation and execution in terminal (javac, java
commands)
• Quick quiz: ask students to identify data type for given values
• Interactive: students declare variables of each primitive type

Resources • JDK (Java 11 or 17) installed on all machines

Required • IDE: IntelliJ IDEA or Eclipse
• Projector for live coding
• JVM Architecture diagram (printout or slide)
• Whiteboard / markers

Assessment / • Verbal Q&A: What is JVM? What is bytecode?

Check • Quick written quiz: identify data types (5 questions)
• Exit ticket: student writes one Java class with 3 variables of different
types

Page 4 | Java Programming Teaching Guidelines | CCST Course

CCST Course | Java Programming Module | Teaching Guidelines 90 Hours | 16T + 14L

Session 2: Basic Programming Concepts

Session Objectives 4. Write Java programs using if-else, switch-case, and ternary operator.
5. Use for, while, and do-while loops with break and continue.
6. Declare and manipulate one-dimensional and multi-dimensional arrays.

Topics & Content • Conditional Statements: if, if-else, nested if-else, switch-case
• Ternary operator as shorthand conditional
• Loops: for loop, while loop, do-while loop
• Loop control: break, continue, labeled break
• Enhanced for-loop (for-each) for arrays
• 1-D Arrays: declaration, initialization, traversal
• Multi-dimensional Arrays: 2D arrays, jagged arrays
• Common array operations: search, sort (manual), reverse

Teaching Methods • Code-and-explain: write each loop type on projector with students
• Challenge: students re-write the same problem using all three loop
types
• Array visualization using whiteboard (draw boxes for memory)
• Pair exercise: students work in pairs on pattern-printing problems
• Incremental complexity: start with simple 1D arrays, then 2D

Resources • IDE with Java project ready for live coding

Required • Whiteboard for array memory diagrams
• Problem sheet: loop and array exercises for self-practice

Assessment / • Students write a loop to print numbers 1–10 in 3 ways (for, while, do-
Check while)
• Quick challenge: find sum of all elements in a given 1D array
• Viva: explain the difference between break and continue

Session 3: Object Oriented Programming (OOP) Concepts

Session Objectives 7. Define and explain the four pillars of OOP with real-world examples.
8. Create Java classes with constructors, instance variables, and
methods.
9. Demonstrate inheritance and method overriding in Java.

Topics & Content • Introduction to OOP: procedural vs object-oriented paradigm

• Classes and Objects: defining a class, creating objects, this keyword
• Constructors: default, parameterized, constructor overloading,
constructor chaining
• Encapsulation: private fields, public getters/setters, data hiding
• Abstraction: hiding implementation details, abstract thinking
• Inheritance: single and multilevel inheritance, super keyword
• Polymorphism: compile-time (method overloading), runtime (method
overriding)
• IS-A vs HAS-A relationship (Inheritance vs Composition)

Page 5 | Java Programming Teaching Guidelines | CCST Course

CCST Course | Java Programming Module | Teaching Guidelines 90 Hours | 16T + 14L

Teaching Methods • Use real-world analogy: Car class – color, brand, speed as attributes;
drive(), brake() as methods
• Draw class diagram before writing code for each concept
• Live coding: build an inheritance hierarchy step by step (Animal → Dog
→ GoldenRetriever)
• Show output difference before and after method overriding
• Group discussion: identify OOP principles in everyday objects

Resources • Whiteboard for class/object diagrams

Required • IDE with Java project
• Printed class diagram template for students to fill in

Assessment / • Students design a 3-class hierarchy on paper before coding

Check • Live demo: modify inherited method and observe output change
• Short written quiz: match OOP concepts with definitions (10 questions)

Session 4: Abstract Classes, Interfaces & Java 8 Features

Session Objectives 10. Differentiate abstract classes from interfaces and know when to use
each.
11. Implement multiple interfaces in a class.
12. Write functional interfaces and lambda expressions.
13. Use enums, inner classes, and understand packages.

Topics & Content • Upcasting and Downcasting of reference variables, instanceof operator
• Abstract class: abstract methods, partially abstract classes
• Interface: default & static methods (Java 8), private methods (Java 11)
• Implementing multiple interfaces: resolving diamond problem
• final variables, final methods, final class – uses and restrictions
• Functional Interface: @FunctionalInterface annotation, single abstract
method
• Lambda expressions: syntax, use with functional interfaces
• Inner Classes: Regular, Method-local, Anonymous, Static inner class
• Enum: defining, using in switch, adding methods to enum
• Packages: creating packages, import statements, access modifiers
with packages

Teaching Methods • Side-by-side comparison table: abstract class vs interface on

whiteboard
• Demo: why Java doesn't support multiple class inheritance; show
interface as solution
• Refactor existing code: convert anonymous class to lambda expression
live
• Enum demo: DayOfWeek enum with switch statement
• Live coding: create a package structure and show import resolution

Resources • IDE with multi-package project structure

Required • Comparison chart: abstract class vs interface (printed handout)
• Java 8 official documentation for lambda syntax reference

Page 6 | Java Programming Teaching Guidelines | CCST Course

CCST Course | Java Programming Module | Teaching Guidelines 90 Hours | 16T + 14L

Assessment / • Code challenge: implement an interface in 3 ways (class, anonymous

Check class, lambda)
• Students explain when to choose abstract class over interface (verbal)
• Quick written exercise: write a lambda for Comparator<String>

Session 5: Exception Handling & Important Java Classes

Session Objectives 14. Explain Java's exception hierarchy and categorize checked vs
unchecked exceptions.
15. Use try-catch-finally, throw, and throws in programs.
16. Create user-defined exceptions.
17. Use Wrapper classes, String classes, and Object class effectively.

Topics & Content • Exception hierarchy: Throwable → Error vs Exception

• Checked Exceptions (compile-time) vs Unchecked Exceptions
(runtime)
• Exception propagation up the call stack
• try-catch-finally block: execution order, nested try blocks
• throws clause: declaring checked exceptions; throw keyword: explicitly
throwing
• Multi-catch block (Java 7+): catching multiple exceptions in one catch
• User-defined exceptions: extending Exception (checked) or
RuntimeException (unchecked)
• Wrapper Classes: Integer, Double, Boolean; autoboxing & unboxing;
constant pools
• String class: immutability, common methods; String pool; ==
vs .equals()
• StringBuffer vs StringBuilder: thread-safety, performance differences
• Date, LocalDate, LocalDateTime, Calendar class (Java 8 Date API)
• Object class: toString(), equals(), hashCode() – overriding and
contracts

Teaching Methods • Draw exception hierarchy tree on whiteboard before coding

• Show call stack in IDE debugger during exception propagation
• Live demo: write code that throws NullPointerException, then handle it
• String pool visualization: draw intern pool on whiteboard
• Show == vs .equals() gotcha with String literals
• Create a simple banking exception example for user-defined
exceptions

Resources • IDE with debugger enabled

Required • Exception hierarchy diagram (printed or slide)
• String pool diagram for visual learners

Assessment / • Students trace exception propagation through 3-level method calls

Check • Quiz: checked or unchecked? (10 exceptions listed)
• Code review: check student's equals() and hashCode() overrides

Session 6–7: Introduction to Collections, JDBC & Advanced Java

Page 7 | Java Programming Teaching Guidelines | CCST Course

CCST Course | Java Programming Module | Teaching Guidelines 90 Hours | 16T + 14L

Session Objectives 18. Use List, Set, and Map collections with appropriate implementations.
19. Sort collections using Comparable and Comparator.
20. Write lambda expressions and use Stream API for collection
processing.
21. Connect Java to a database using JDBC and perform CRUD
operations.

Topics & Content • Collection framework hierarchy: Collection → List/Queue/Set, Map

(separate hierarchy)
• ArrayList: dynamic resizing, index-based access, common operations
• LinkedList: node-based, doubly linked, use as Queue/Deque
• Vector: legacy, synchronized; when to use vs ArrayList
• HashSet, LinkedHashSet, TreeSet: uniqueness, ordering differences
• HashMap, LinkedHashMap, TreeMap: key-value storage, iteration
• Iterator and ListIterator: forward and backward traversal
• Comparable interface: natural ordering with compareTo()
• Comparator interface: custom ordering, multiple comparators
• Sorting: [Link](), [Link](), with lambda Comparators
• Lambda expressions in collections: Predicate, Function, Consumer,
Supplier
• Stream API: filter(), map(), reduce(), collect(), findFirst(), count()
• Annotations: built-in (@Override, @Deprecated,
@SuppressWarnings); custom annotations
• Database concepts: tables, rows, SQL basics (SELECT, INSERT,
UPDATE, DELETE)
• JDBC: DriverManager, Connection, Statement, PreparedStatement,
ResultSet
• JDBC workflow: load driver → connect → create statement → execute
→ close

Teaching Methods • Show collection hierarchy diagram before coding

• Live comparison: add duplicates to ArrayList vs HashSet
• Demo: sort a List<Employee> by name, then by salary using
Comparator
• Stream pipeline demo: filter + map + collect on a list of names
• JDBC demo: connect to MySQL/H2, insert and retrieve a record live
• Use H2 in-memory DB to avoid setup issues in classroom

Resources • IDE with database driver (MySQL connector or H2 JAR) on classpath

Required • Database installed (MySQL) or H2 in-memory DB as alternative
• Collection hierarchy diagram (slide/printout)
• JDBC cheat sheet for students

Assessment / • Code challenge: given a List<String>, use streams to filter strings > 5
Check chars and print uppercase
• JDBC task: students connect to a test DB and retrieve data from one
table
• Quiz: which collection to use for each scenario? (5 scenarios)

Session 8: Writing JUnit Test Cases

Page 8 | Java Programming Teaching Guidelines | CCST Course

CCST Course | Java Programming Module | Teaching Guidelines 90 Hours | 16T + 14L

Session Objectives 22. Explain the purpose and benefits of unit testing with JUnit.
23. Use JUnit 5 annotations to structure and run test cases.
24. Write assertions to validate expected behavior.

Topics & Content • Introduction to unit testing: why test? Test pyramid overview
• JUnit 5 vs JUnit 4 – key differences
• JUnit Annotations: @Test, @BeforeEach, @AfterEach, @BeforeAll,
@AfterAll, @Disabled
• Writing basic test cases: test method structure, naming conventions
• Assertions: assertEquals(), assertNotEquals(), assertTrue(),
assertFalse(), assertNull(), assertThrows()
• Testing edge cases and negative scenarios
• Running tests in IDE; reading test reports (pass/fail/error)
• Test coverage concept: line coverage, branch coverage (overview)

Teaching Methods • Show a broken Java method and write tests that reveal the bug (TDD
approach)
• Live demo: run tests in IDE and show red/green/refactor cycle
• Demonstrate assertThrows() with an exception-throwing method
• Show what happens when assertEquals fails – read the failure
message
• Pair coding: one student writes the method, another writes the tests

Resources • IDE with JUnit 5 dependency (Maven [Link] or Gradle [Link])

Required • Sample Java class ([Link]) for test writing exercises
• Maven/Gradle project template pre-configured

Assessment / • Students write 5 test cases for a provided Calculator class

Check • Include positive, negative, and edge cases in the test suite
• Viva: explain what assertThrows() does and when to use it

5. Lab-wise Teaching Guidelines

Lab 1–2: Java Environment Setup & Pattern Printing

Lab Objectives 25. Set up the Java development environment (JDK + IDE).
26. Write and execute a first Java program.
27. Use loops to print various asterisk patterns.

Tasks / Exercises • Install JDK and verify using java -version and javac -version in terminal.
• Set up IntelliJ IDEA / Eclipse; create first Java project and class.
• Write and run 'Hello, World!' program.
• Pattern 1: Print a right-angle triangle of asterisks using nested for
loops.
• Pattern 2: Print an inverted triangle.
• Pattern 3: Print a pyramid / diamond shape.
• Pattern 4: Print a hollow square border using if-else inside loops.
• Extension: allow user to input the number of rows via Scanner.

Page 9 | Java Programming Teaching Guidelines | CCST Course

CCST Course | Java Programming Module | Teaching Guidelines 90 Hours | 16T + 14L

Tools & Setup • JDK 11 or 17 installed on lab machines

• IntelliJ IDEA Community Edition or Eclipse IDE
• Terminal / Command Prompt for initial javac/java commands
• Lab instruction sheet with pattern diagrams

Submission Criteria • Submit working Java class files for each pattern.
• Screenshot of successful IDE run output.
• Code should be cleanly indented with meaningful variable names.

Lab 3–4: OOP in Practice: Arrays, Abstract Classes & Interfaces

Lab Objectives 28. Create an array of objects and initialize with different subclass
instances.
29. Implement abstract classes and extend them with concrete
subclasses.
30. Implement multiple interfaces in a single class.
31. Demonstrate the use of enums in a program.

Tasks / Exercises • Task 1: Create a Shape abstract class with area() and perimeter() as
abstract methods. Create Circle, Rectangle, and Triangle subclasses.
Create an array of Shape objects, initialize with different shapes, and
call area() on each.
• Task 2: Create interface Drawable with draw() method and interface
Resizable with resize(double factor) method. Create a class Canvas
that implements both interfaces.
• Task 3: Create an enum Season (SPRING, SUMMER, MONSOON,
WINTER) with a method getDescription(). Use it in a switch statement
to print seasonal advice.
• Extension: Add an interface Printable and demonstrate a class
implementing 3 interfaces.

Tools & Setup • IDE with Java project

• Lab instruction sheet with UML class diagram templates
• Reference: Java documentation for abstract classes and interfaces

Submission Criteria • Submit all 3 task Java files with correct output screenshots.
• Code must demonstrate runtime polymorphism (dynamic dispatch).
• Enum must include at least one custom method.

Lab 5: Exception Handling & Wrapper Classes

Lab Objectives 32. Create and throw user-defined checked and unchecked exceptions.
33. Handle exceptions using try-catch-finally.
34. Demonstrate autoboxing, unboxing, and integer constant pool
behavior.

Tasks / Exercises • Task 1: Create a checked exception InsufficientFundsException. Build

a BankAccount class with withdraw() that throws this exception. Handle
it in main().
• Task 2: Create an unchecked exception InvalidAgeException. Write a

Page 10 | Java Programming Teaching Guidelines | CCST Course

CCST Course | Java Programming Module | Teaching Guidelines 90 Hours | 16T + 14L

Voter class that validates age and throws this exception if age < 18.
• Task 3: Demonstrate autoboxing: assign int to Integer and Double to
double. Print results.
• Task 4: Show integer constant pool: compare Integer objects using ==
vs .equals() for values -128 to 127 and beyond. Explain the output.
• Extension: Use multi-catch block to handle both exceptions in one
catch clause.

Tools & Setup • IDE with Java project

• Reference: [Link]() source code explanation (concept only)

Submission Criteria • Submit Java files for all 4 tasks.

• Must include at least one user-defined checked and one unchecked
exception.
• Task 4 must include explanation comments in code about constant
pool behavior.

Lab 6–7: JUnit Test Cases – Writing & Executing

Lab Objectives 35. Write JUnit 5 test cases for a given Java class.
36. Use JUnit annotations correctly (@Test, @BeforeEach, etc.).
37. Use multiple assertion methods to validate expected outputs.
38. Test both positive (happy path) and negative (exception/edge case)
scenarios.

Tasks / Exercises • Given: A Calculator class with add(), subtract(), multiply(), divide()
methods.
• Task 1: Write @Test methods for each operation with at least 2 test
cases each.
• Task 2: Write a test for divide() that passes 0 as denominator. Use
assertThrows([Link], ...) to verify exception is
thrown.
• Task 3: Add @BeforeEach to initialize Calculator instance before each
test.
• Task 4: Use @Disabled to skip one test and observe how it appears in
the test report.
• Task 5: Add a test for boundary values (Integer.MAX_VALUE addition).
• Extension: Write tests for a StringUtils class with methods: reverse(),
isPalindrome(), countVowels().

Tools & Setup • Maven project with JUnit 5 dependency in [Link]

([Link]:junit-jupiter:5.10.0)
• [Link] starter class provided to students
• IDE with Maven support (IntelliJ auto-downloads dependencies)

Submission Criteria • Minimum 12 test methods across all tasks.

• All tests must pass (except the @Disabled one).
• Test method names must follow:
methodName_scenario_expectedResult naming convention.
• Submit Maven project folder (including [Link] and src directory).

Page 11 | Java Programming Teaching Guidelines | CCST Course

CCST Course | Java Programming Module | Teaching Guidelines 90 Hours | 16T + 14L

6. Assessment Strategy

Assessment Strategy
Component Description Weightage When
Lab Exercises (7 Hands-on coding tasks, 40% After each lab
labs) correctness, and code quality

Session Quizzes Short MCQs and theory 15% End of each

questions at session end session

Mid-Module Test Written test covering Sessions 20% After Session 5

1–5 (OOP, Exceptions,
Classes)

Final Practical Full Java program with JDBC + 20% End of module
Exam JUnit test cases

Attendance & Active participation in 5% Ongoing

Participation discussions and labs

7. Faculty Teaching Tips & Do's / Don'ts

Faculty Teaching Tips & Do's / Don'ts

✔ Do's ✘ Don'ts
• Always start with real-world analogies • Do not rush through JVM internals; it is
(e.g., OOP = Blueprint & Object). foundational for debugging.
• Draw JVM architecture diagram on board • Do not skip the String pool concept — it is
before coding. frequently misunderstood.
• Use live coding: write code on projector as • Do not teach Generics and Lambda in the
students follow. same session; space them out.
• Relate exceptions to real life: • Do not ignore compile errors during demos
FileNotFoundException = file not found on — use them as teaching moments.
desktop. • Avoid dictating code; let students type and
• Encourage students to break the code discover errors themselves.
intentionally to understand exception flow. • Do not use complex DB schemas for
• Use compare-and-contrast: ArrayList vs JDBC; use a simple 2-table example.
LinkedList, == vs .equals(). • Do not test only happy-path in JUnit
• Always recap previous session for first 5 examples; show negative test cases.
minutes. • Avoid mixing too many concepts in one
• Pair students for lab exercises to lab; keep each lab focused.
encourage collaborative learning. • Do not skip the Comparable vs
• Show stack traces from real bugs to make Comparator difference — often asked in
exception handling relatable. interviews.
• For JUnit, start with a broken function and • Do not end labs without a code review or
fix it using test-driven approach. debrief discussion.

Page 12 | Java Programming Teaching Guidelines | CCST Course

CCST Course | Java Programming Module | Teaching Guidelines 90 Hours | 16T + 14L

8. Recommended Books & Resources

Recommended Books & Resources

S.
No Book Title Author(s) Publisher Covers
.
1 Head First Java Kathy Sierra & Bert Shroff / OOP, Core
Bates O'Reilly Java

2 Effective Java (3rd Ed.) Joshua Bloch Addison- Best Practices

Wesley

3 Java: The Complete Herbert Schildt McGraw-Hill All Topics

Reference

4 JUnit in Action Perez, Tahchiev et al. Manning JUnit Testing

5 Java 8 in Action Urma, Fusco, Mycroft Manning Lambda,

Streams

6 JDBC API Tutorial Seth White et al. Addison- JDBC & DB

Wesley

Online Resources:
• Oracle Java Documentation: [Link]
• JUnit 5 User Guide: [Link]
• Baeldung Java Tutorials: [Link]
• GeeksForGeeks Java: [Link]
• JDBC Tutorial (TutorialsPoint): [Link]

Page 13 | Java Programming Teaching Guidelines | CCST Course