Core Java Programming

Most graduates arrive able to write Java that compiles and unable to say why it behaves the way it does. They can produce a class, but not explain why their object vanished from a HashMap, why the API returned the wrong total under load, or why the file handle stayed open. The syntax was taught; the model underneath it was not.

This course teaches that model. Eighty guided hours, forty sessions, building from a first compiled class to a layered, tested, Maven-built application. Every topic is taught against code that runs, and most are taught twice — once in the version that fails, once in the version that does not.

Participation requirements

No prior Java knowledge and no prior Deesha course is required, though learners who have already completed DTA-01 Professional Developer Foundations will be more comfortable with the command line, Git and the debugging discipline used from session one. Learners need regular access to a 64-bit Windows, Linux or macOS computer with at least 8 GB of memory, basic file-and-folder skills, and permission to install the course toolchain.

Plan approximately 45–60 minutes of practice after most sessions, and up to two hours between final-project sessions. This practice is recommended for fluency and is not counted in the 80 guided hours.

Who should choose a different course

This course is not intended for experienced Java developers who already work confidently with generics, streams and concurrent code. It does not teach Spring or Spring Boot, JPA or Hibernate, web frameworks, Android, build pipelines, cloud deployment, microservice architecture, JVM performance tuning or garbage-collector engineering. Those belong in follow-on programmes once the language foundation is secure.

Learners who complete this course and want backend depth continue to DTA-07 Spring Boot Backend Engineering, which assumes everything taught here.

If you have never programmed at all and want the smallest possible language surface first, DTA-16 C Programming covers control flow, functions and memory with no objects and no standard library. It is not a prerequisite; it is an alternative route into the same fundamentals.

Java version and toolchain

The course is taught on a current Long-Term Support JDK (Java 17 or Java 21), because that is what employers run and what learners should install on their own machines. All required exercises and all assessed material are written to the Java 8 language surface, so that everything a learner is examined on is also valid certification material.

Modern conveniences — var, records, enhanced switch, text blocks, pattern matching for instanceof — are demonstrated as clearly-labelled awareness so learners can read a modern codebase, and are never required in an assessed exercise. Where a modern feature replaces an older idiom, both are shown and the reason for the change is explained.

Learners use Maven for builds and JUnit 5 for tests from the module in which each is introduced, not only in the final project. Early sessions invoke javac and java directly so that compilation, the classpath and bytecode remain visible before any tool hides them.

Development environment options

1. Recommended: IntelliJ IDEA Community Edition with a current LTS JDK. It is free, is what most Java teams use, and its debugger and refactoring tools are used directly in teaching.
2. Alternative: Visual Studio Code with the Extension Pack for Java. Lighter on system resources and familiar to learners arriving from other languages, with the same build and debug workflow available.

Eclipse is supported for learners whose college or employer standardises on it, but session demonstrations are recorded against IntelliJ IDEA.

How each session works

Each two-hour session follows a consistent rhythm:

• approximately 35 minutes of concept explanation and live demonstration
• approximately 70 minutes of guided and independent coding
• approximately 15 minutes of review, debugging discussion or a short formative learning check

The balance changes during final-project sessions, when most of the time is used for implementation, review and correction.

Certification alignment — Java SE 8 Programmer I

The syllabus covers the full Java SE 8 Programmer I objective domain: Java basics, working with Java data types, using operators and decision constructs, creating and using arrays, using loop constructs, working with methods and encapsulation, working with inheritance, handling exceptions, and working with selected classes from the Java API including String, StringBuilder, Arrays, ArrayList, the java.time classes and basic lambda expressions with Predicate.

Two things learners should understand before planning an examination:

• The course is deliberately larger than the examination. Collections beyond ArrayList, generics, the full Streams API, files, concurrency, Maven and JUnit are taught because professional work requires them, not because the Programmer I examination tests them. Several of these appear in the Programmer II examination instead.
• Examination codes and availability change. Oracle periodically retires and renumbers its Java certifications. Confirm the current code, price and availability on Oracle's certification site before booking. The fundamentals taught here map closely onto Oracle's current Java SE Programmer I examination for later Java versions, so the preparation is not wasted if the Java 8 examination is unavailable in your region.

Certification preparation material — objective mapping, topic-wise practice questions and two timed mock examinations — is supplied to enrolled learners. Deesha does not administer the examination, and enrolment does not include the examination fee or guarantee a pass.

The course project — Campus Placement Desk, built incrementally

The course is organised around one product, not a series of disconnected labs. In session one, learners compile and run the first version of the Campus Placement Desk — a console application for a college placement cell: student records, visiting companies, applications, interview rounds and outcomes. Every module then grows it. The domain is deliberately neutral — no specialist knowledge is needed — and the brief provides acceptance criteria and sample data without providing the completed implementation.

Each session is scenario-driven: it opens with a request the current version of the desk cannot handle — a new batch of students, a report the coordinator wants, a duplicate registration, a crash on registration day — and the day's topic arrives as the tool that handles it. Learners therefore practise the thing courses usually skip: extending and refactoring code that already works, which is what professional Java actually is. Earlier decisions are deliberately revisited — arrays give way to collections, hand-written stores collapse into a generic repository, loops become streams — so refactoring is taught as normal work rather than as failure. Session-level trainer and participant guides drive each increment; the module table above shows the state of the product at the end of every module.

The final two sessions integrate and harden rather than start: by then the product exists, and the work is finishing it against the published acceptance criteria, reviewing it and demonstrating it.

By completion the project requires learners to:

• model the domain with classes that protect their own invariants, using enums for fixed sets
• define a repository behind an interface, with an in-memory implementation supplied first
• select collections deliberately for the access pattern each feature needs
• implement correct equals, hashCode and at least one Comparator
• produce reports with stream pipelines, including a grouping and an aggregation
• model every date with the java.time API rather than strings
• persist and reload data as documented CSV, recovering from missing or malformed input
• define its own exception types and handle them at the application boundary, never in the domain
• cover the domain layer with JUnit 5 tests, including at least one assertThrows
• build and package cleanly with Maven from an empty target directory
• include a README, sample data and a short learner demonstration

Recommended depth and boundaries

Object-oriented design

Classes, interfaces, inheritance and enums are taught deeply enough for learners to design a type with a clear responsibility and defend it in review. Design patterns are introduced only where the project genuinely uses them — strategy through interfaces, factory through static creation methods. A full patterns catalogue is out of scope.

Collections and generics

Learners must be able to choose a collection for a stated access pattern and justify it, and to read and write generic signatures including bounded types and wildcards. Writing a generic library, implementing a custom collection, and the finer points of type inference are reserved for follow-on work.

Java 8 features

Lambdas, method references, the standard functional interfaces, stream pipelines, collectors, Optional and the java.time API are required and assessed. Custom collectors, Spliterator, reactive streams and functional-programming theory are not.

Concurrency

Threads, shared-state hazards, synchronized, volatile, atomics, thread pools and CompletableFuture are taught as essentials, because concurrency bugs surface in ordinary application code. The Java Memory Model is explained operationally rather than formally, and lock-free algorithms, ForkJoinPool tuning and virtual threads are demonstrated as awareness only.

Performance and the JVM

Learners develop cost intuition — why concatenating in a loop is expensive, why an ArrayList lookup differs from a LinkedList traversal, why a HashMap degrades with a poor hashCode. Profiling, benchmarking methodology, garbage-collector selection and JVM flag tuning are not covered.

Assessment and completion

Each session includes a formative learning check. The required final quiz is delivered in Moodle; session checks may also be assembled there after platform import review. Course completion requires:

• at least 80% attendance
• at least 60% on the required final quiz, with a maximum of two attempts

For the pilot batch, attendance and the final quiz are recorded and verified manually by the trainer. Automated tracking arrives with the learning platform; the completion criteria above are the same either way.

The final project is reviewed and demonstrated as applied learning evidence, but it is not an additional completion gate for this pilot. The completion record confirms the attendance and knowledge-check criteria above; project evidence is recorded separately and does not claim an independently certified level of professional capability. Deesha course completion is separate from any Oracle certification, which is awarded only by Oracle on passing its examination.

Learning materials

Active enrolled learners receive session study guides, starter projects, exercises, the course quick reference, certification preparation material and interview-preparation material. Approved session recordings may be provided when a batch records them with the required notice, consent, review and access controls. Learner material is shared through restricted access. Study material is view-only where the platform supports it; starter code and exercise data are downloadable so learners can compile, run and edit a personal working copy. Trainer plans, source presentations, solutions and question rationales remain private.

Interview-preparation material

Learners receive supplementary material covering the Java questions most commonly asked of freshers and early-career developers, together with code-reading exercises and "what does this print" drills of the kind used in written screening rounds. It will be exported to an accessible participant format before release. This material supports revision; the course does not promise interview or employment outcomes.