Core Java fundamentals and OOP, then SQL, Spring Boot, REST APIs, JPA/Hibernate, testing and a backend project.
What you will cover
Core Java fundamentals
OOP
then SQL
Spring Boot
REST APIs
JPA/Hibernate
testing
a backend project
Topic list from the institute's programme record.
Certification
Certificate terms for this programme are confirmed by the institute at admission. Any ADIVAS course-completion certificate is an institute certificate; it is not a university degree, an externally accredited qualification or a vendor certification (such as AWS or Microsoft) unless the institute states so in writing.
Curriculum 0.1 · Draft: written for ADIVAS and awaiting academic review and approval. Topics and weeks may change before your batch starts.
Your skill trail
You move through 7 stations. Each week builds one skill you can show, not just a topic you have heard.
1
Java foundations
Write and run Java programs using types, decisions, loops, arrays and strings.
Week 1 Java setup and first programs
Week 2 Types, operators and decisions
Week 3 Loops, arrays and strings
2
Object-oriented Java
Design classes with encapsulation, inheritance and interfaces.
Week 4 Classes and objects
Week 5 Encapsulation, static and packages
Week 6 Inheritance, polymorphism and interfaces
3
Robust Java and the console project
Handle errors, use collections and files, test and deliver a console project.
Week 7 Exceptions and validation
Week 8 Collections, generics and lambdas
Week 9 File I/O and dates
Week 10 Testing and project demo
4
Data layer and web foundations
Design a database, use JDBC safely and understand servlets.
Week 11 SQL for backend developers
Week 12 JDBC and the DAO pattern
Week 13 Maven and Servlet/JSP basics
5
Spring Boot and REST
Build layered REST APIs with validation and error handling.
Week 14 Spring Boot foundations
Week 15 REST controllers
Week 16 Layers, DTOs, validation and errors
6
JPA, Git and testing
Persist data with JPA, work with Git and Maven, and test the backend.
Week 17 JPA and Hibernate basics
Week 18 Relationships, queries and transactions
Week 19 Git workflow and builds
Week 20 Testing backend applications
7
Backend project
Build, harden and present the backend project.
Week 21 Backend project: build
Week 22 Hardening and final demo
★
Library Management Console App
Your project, reviewed by a trainer.
The ADIVAS mastery ladder: how each skill is recognised
Explored You have seen the idea and tried a first example.
Practising You can do it with hints and keep improving.
Proficient You complete the weekly practical task correctly on your own.
Proven You apply it in a project reviewed by your trainer.
Skill-level tracking is being added to the learner workspace. Your trainer already reviews weekly practical work.
What you will be able to do
Write Java programs with types, control flow, arrays and strings, and explain how the JVM runs them.
Design object-oriented Java classes using encapsulation, inheritance, interfaces and polymorphism.
Handle errors with exceptions and use collections, generics, files and dates.
Write unit tests for Core Java code and deliver a console project.
Design a relational schema and use SQL and JDBC safely from Java.
Build layered Spring Boot REST APIs with validation and consistent error handling.
Map data with JPA/Hibernate, manage transactions and use Maven and Git in a team workflow.
Test and deliver a documented backend project.
Who it suits
School Strong Class 11-12 students who want a complete path from first Java program to a working backend, with patient step-by-step teaching.
College College students who want one continuous programme covering Core Java and backend development for projects and interviews.
Professional Career changers and working professionals starting Java from the beginning and aiming for backend work.
Prerequisites: Comfortable use of a computer and basic school mathematics. No prior Java experience needed. Tools: JDK 17 or 21 (LTS), IntelliJ IDEA Community or VS Code with Java extensions, Maven, JUnit 5, Git, MySQL Community Server and MySQL Workbench, Spring Boot 3.x via Spring Initializr, Postman or curl.
Weekly plan
Java foundations Weeks 1–3
Week 1: Java setup and first programs
Theory
JDK, JVM and bytecode
Compiling with javac and running with java
Structure of a class and main method
Reading input with Scanner
Lab
Install a JDK (17 or 21) and an IDE, run Hello World from the command line and the IDE, then read a name and print a greeting.
Homework
Write a program that reads two numbers and prints sum, difference and product.
Deliverable
Hello.java and Greeting.java with sample runs.
Weekly checkpoint
Explain compile versus run; predict output of two short programs.
You will be able to
Write Java programs with types, control flow, arrays and strings, and explain how the JVM runs them.
Week 2: Types, operators and decisions
Theory
Primitive types and String
Casting and operator precedence
if, else-if and switch
Ternary operator
Lab
Build a bill calculator with 18% GST and a grade program using switch; test boundary values.
Homework
Write a program that classifies a triangle from three side lengths.
Deliverable
Bill and grade programs with a test table.
Weekly checkpoint
Predict results of casting and integer division snippets.
You will be able to
Write Java programs with types, control flow, arrays and strings, and explain how the JVM runs them.
Week 3: Loops, arrays and strings
Theory
for, while, do-while and enhanced for
Arrays and 2D arrays
String methods and StringBuilder
Common index errors
Lab
Compute the average and highest mark in an array, count vowels in a string and print a multiplication table.
Homework
Write a palindrome checker and trace it with two inputs.
Deliverable
Three programs and a trace of one loop.
Weekly checkpoint
Find an array index bug; predict String method output.
You will be able to
Write Java programs with types, control flow, arrays and strings, and explain how the JVM runs them.
Object-oriented Java Weeks 4–6
Week 4: Classes and objects
Theory
Fields, methods and constructors
Objects, references and the heap
this, toString and equals
Class diagrams
Lab
Create a Student class with a validating constructor and grade() method; build an array of objects and print each.
Homework
Draw a class diagram for Book and Member.
Deliverable
Student.java plus a class diagram.
Weekly checkpoint
Class versus object questions; read a class and predict output.
You will be able to
Design object-oriented Java classes using encapsulation, inheritance, interfaces and polymorphism.
Week 5: Encapsulation, static and packages
Theory
private fields and getters/setters
static members and final
Packages and access modifiers
Immutable objects
Lab
Add a static counter to Student, make a class immutable, and organise code into packages.
Homework
Explain where you would use static and where you would not.
Deliverable
Refactored package structure.
Weekly checkpoint
Predict output with a static counter; choose access modifiers.
You will be able to
Design object-oriented Java classes using encapsulation, inheritance, interfaces and polymorphism.
Week 6: Inheritance, polymorphism and interfaces
Theory
extends, super and method overriding
Abstract classes and interfaces
Polymorphism and instanceof
Composition over inheritance
Lab
Model Employee, Teacher and Admin with a shared base class and an interface Payable; print salaries through a List<Payable>.
Homework
Write two examples: one where inheritance fits and one where composition is better.
Deliverable
Payroll hierarchy with an explanation.
Weekly checkpoint
Match OOP ideas; predict which override runs.
You will be able to
Design object-oriented Java classes using encapsulation, inheritance, interfaces and polymorphism.
Robust Java and the console project Weeks 7–10
Week 7: Exceptions and validation
Theory
Checked and unchecked exceptions
try, catch, finally and try-with-resources
throw and custom exceptions
Defensive input validation
Lab
Make a quantity-entry program that handles bad numbers and negative values with custom exceptions and friendly messages.
Homework
Find three places in earlier labs that need exception handling.
Deliverable
Robust input program.
Weekly checkpoint
Predict try/catch/finally output; choose the right exception type.
You will be able to
Handle errors with exceptions and use collections, generics, files and dates.
Week 8: Collections, generics and lambdas
Theory
ArrayList, HashMap and HashSet
Generics and type safety
Comparable, Comparator and sorting
Lambdas and a first look at streams
Lab
Store customers in a HashMap keyed by email, sort them by name and filter those with unpaid bills using a lambda.
Homework
Explain when to choose a list, set or map for three scenarios.
Deliverable
Customer manager with sorting and filtering.
Weekly checkpoint
Choose a collection; spot a generics compile error.
You will be able to
Handle errors with exceptions and use collections, generics, files and dates.
Week 9: File I/O and dates
Theory
Path and Files, BufferedReader and BufferedWriter
try-with-resources for files
Parsing CSV lines
LocalDate and date arithmetic
Lab
Load and save members to a CSV file, skipping and reporting bad lines; compute due dates and late days with LocalDate.
Homework
Add a feature that writes a daily report file.
Deliverable
CSV load/save module.
Weekly checkpoint
Order the steps of a safe file read; predict date calculations.
You will be able to
Handle errors with exceptions and use collections, generics, files and dates.
Week 10: Testing and project demo
Theory
JUnit 5 basics: @Test and assertions
Test-case design and boundary values
Debugging in the IDE
Packaging a runnable JAR
Lab
Write JUnit tests for the late-fee rule and the duplicate-member rule, debug one failing test, package a JAR and demo the Library Management app.
Homework
Write a short README that explains how to run and test the app.
Deliverable
Final project, test report and README.
Weekly checkpoint
Choose boundary tests; viva on design decisions.
You will be able to
Write unit tests for Core Java code and deliver a console project.
Data layer and web foundations Weeks 11–13
Week 11: SQL for backend developers
Theory
Tables, keys and relationships
SELECT, JOIN and GROUP BY
Indexes and constraints
MySQL installation and tools
Lab
Install MySQL, design and create a shop database (products, customers, orders, order_items) with constraints, and write ten queries including joins and totals.
Homework
Draw an ER diagram for the campus store project.
Deliverable
schema.sql, seed data and a query sheet.
Weekly checkpoint
Predict query results; choose keys and constraints.
You will be able to
Design a relational schema and use SQL and JDBC safely from Java.
Week 12: JDBC and the DAO pattern
Theory
Drivers, Connection, Statement and PreparedStatement
ResultSet mapping and transactions
DAO pattern and connection handling
SQL injection and how to prevent it
Lab
Write a ProductDao with create, read, update and delete using PreparedStatement; demonstrate SQL injection on a concatenated query, then fix it.
Homework
Add a transaction that moves stock between two products and rolls back on error.
Deliverable
ProductDao with a security note.
Weekly checkpoint
Spot unsafe SQL; order the steps of a JDBC query.
You will be able to
Design a relational schema and use SQL and JDBC safely from Java.
Week 13: Maven and Servlet/JSP basics
Theory
Maven project structure, pom.xml and lifecycle
How a servlet container handles requests
Servlets, request/response and JSP views
Forms and sessions at a basic level
Lab
Create a Maven web project, write a servlet that lists products from the DAO in a JSP and add a form to create a product.
Homework
Explain the request path from browser to JSP in a diagram.
Deliverable
Working Servlet/JSP product list.
Weekly checkpoint
Describe the servlet lifecycle; read a pom.xml dependency.
You will be able to
Design a relational schema and use SQL and JDBC safely from Java.
Spring Boot and REST Weeks 14–16
Week 14: Spring Boot foundations
Theory
Spring Initializr and project layout
Inversion of control and dependency injection
Beans, configuration and application.properties
Profiles and logging
Lab
Generate a Spring Boot project, create a service bean injected into a controller, read a setting from application.properties and add a dev profile.
Homework
Explain constructor injection versus creating objects with new.
Deliverable
Running Spring Boot app with profile config.
Weekly checkpoint
Explain dependency injection with an example; locate a startup error.
You will be able to
Build layered Spring Boot REST APIs with validation and consistent error handling.
Week 15: REST controllers
Theory
HTTP methods, status codes and JSON
RestController, PathVariable, RequestBody
Resource-oriented URL design
Testing with curl and Postman
Lab
Build an in-memory product API with GET, POST, PUT and DELETE; test each endpoint and record the status codes.
Homework
Design URLs and methods for customers.
Deliverable
Product API and a request/response log.
Weekly checkpoint
Match status codes; choose the right method and URL.
You will be able to
Build layered Spring Boot REST APIs with validation and consistent error handling.
Week 16: Layers, DTOs, validation and errors
Theory
Controller, service and repository layers
DTOs and mapping
Bean Validation annotations
Central exception handling with ControllerAdvice
Lab
Refactor the API into layers with request/response DTOs, add validation for name and price, and return consistent JSON errors.
Homework
List five invalid requests and the status and message you would return for each.
Deliverable
Layered API with an error catalogue.
Weekly checkpoint
Choose 400 versus 404 versus 409; order a request through the layers.
You will be able to
Build layered Spring Boot REST APIs with validation and consistent error handling.
JPA, Git and testing Weeks 17–20
Week 17: JPA and Hibernate basics
Theory
Entities, @Id and column mapping
Spring Data JPA repositories
Derived queries and @Query
MySQL configuration and schema management
Lab
Replace the in-memory store with JPA entities and a repository connected to MySQL; add findByNameContaining and a custom query.
Homework
Compare the SQL you wrote in week 2 with the SQL Hibernate logs.
Deliverable
API persisting to MySQL with SQL logging evidence.
Weekly checkpoint
Read an entity class; choose repository methods.
You will be able to
Map data with JPA/Hibernate, manage transactions and use Maven and Git in a team workflow.
Week 18: Relationships, queries and transactions
Theory
@ManyToOne and @OneToMany
Lazy and eager loading; the N+1 problem
JPQL, pagination and sorting
@Transactional
Lab
Add Order and OrderItem entities, list orders with customers, observe an N+1 query in the logs and fix it with a join fetch; add pagination.
Homework
Write down when a transaction is necessary in the order flow.
Deliverable
Order model with N+1 before/after evidence.
Weekly checkpoint
Identify N+1; predict what a rollback does.
You will be able to
Map data with JPA/Hibernate, manage transactions and use Maven and Git in a team workflow.
Week 19: Git workflow and builds
Theory
Branches, pull requests and merge conflicts
.gitignore and keeping secrets out of the repository
Maven profiles and building a runnable JAR
Commit message habits
Lab
Create two branches that edit the same line, resolve the conflict, tag a release and build the JAR; load the database password from an environment variable.
Homework
Write a team branching convention for the project.
Deliverable
Repository with history, a tag and a conflict-resolution note.
Weekly checkpoint
Order a pull-request workflow; resolve a conflict snippet.
You will be able to
Map data with JPA/Hibernate, manage transactions and use Maven and Git in a team workflow.
Week 20: Testing backend applications
Theory
JUnit 5 and AssertJ
Mockito for service tests
MockMvc for controllers and @DataJpaTest
Test naming and coverage
Lab
Write unit tests for the order service with a mocked repository, MockMvc tests for two endpoints and one repository test using an in-memory test database.
Homework
Add tests for three error cases (invalid input, missing id, out-of-stock).
Deliverable
Test suite that passes with mvn test.
Weekly checkpoint
Choose what to mock; read a failing test report.
You will be able to
Test and deliver a documented backend project.
Backend project Weeks 21–22
Week 21: Backend project: build
Theory
Requirements and API design
OpenAPI documentation
Logging with SLF4J
Working in small, reviewed increments
Lab
Implement the Campus Store Order API endpoints for products, customers and orders with GST calculation and stock checks.
Homework
Update the API documentation and add log statements for key events.
Deliverable
Feature-complete API on a feature branch.
Weekly checkpoint
Code review of a classmate's pull request against a checklist.
You will be able to
Test and deliver a documented backend project.
Week 22: Hardening and final demo
Theory
Pagination, sorting and error cases
README and Postman collection
Performance check of slow queries
Demo and retrospective
Lab
Fix review comments, add pagination, profile one slow endpoint, finalise README and Postman collection and present a demo.
Homework
Write a short retrospective: what you would improve with more time.
Deliverable
Final project, demo and retrospective.
Weekly checkpoint
Project viva with scenario questions.
You will be able to
Test and deliver a documented backend project.
Sample lessons
Week 4
Classes, objects and encapsulation in Java
A class describes what an object has (fields) and what it can do (methods). An object is one concrete instance created with new. Encapsulation means keeping fields private and exposing only the methods that keep the object valid, for example a BankAccount that refuses a negative deposit. A constructor sets the object up with valid starting values.
Public fields
Any code can set marks = 500
Rules are scattered
Private fields + methods
Only valid values get in
Rules live in one place
Step by step
Create class Student with private String name and private int marks.
Write a constructor that rejects marks below 0 or above 100.
Add getters and a method grade() that returns "A", "B" or "C".
In main, create two Student objects and print their grades.
Add toString() so printing a Student shows readable text.
In real life
A bank counter does not let customers reach into the vault. They ask the teller (a method) who checks the rules first.
Worked example
Problem. Why is making marks private better than a public field?
Solution. With a private field, the only way to change marks is through a method that can check 0-100. A public field could be set to 500 by any code.
Common mistakes
Making every field public.
Forgetting this. when a parameter has the same name as a field.
Comparing objects with == instead of equals.
Try it yourself
Add a method that returns true when the student has passed (35 or more).
Create an array of 3 Student objects and print the class average.
Explain what happens to marks if no constructor check exists.
Week 11
SQL joins for real reports
Relational databases keep data in separate tables to avoid repetition: customers in one table, orders in another. A join connects them using a key, usually a primary key in one table and a foreign key in the other. INNER JOIN keeps only matching rows; LEFT JOIN keeps every row from the left table even when there is no match, which is how you find customers who have never ordered.
customers.id
name
orders.customer_id
amount
1
Anu
1
500
1
Anu
1
200
2
Ravi
2
300
3
Meena
NULL
NULL
Step by step
Create customers(id, name) and orders(id, customer_id, amount).
Insert three customers and four orders; leave one customer without orders.
Write SELECT c.name, o.amount FROM customers c INNER JOIN orders o ON o.customer_id = c.id;
Change it to LEFT JOIN and notice the extra row with NULL.
Add GROUP BY c.name and SUM(o.amount) to produce a total per customer.
In real life
A shop keeps a customer register and a separate bill book. To see what each customer bought, you match the customer number written on each bill with the register.
Worked example
Problem. Customers: Anu, Ravi, Meena. Orders: Anu 500, Anu 200, Ravi 300. Which query lists customers with no orders?
Solution. SELECT c.name FROM customers c LEFT JOIN orders o ON o.customer_id = c.id WHERE o.id IS NULL; It returns Meena.
Common mistakes
Forgetting the ON condition, which produces every combination of rows.
Using INNER JOIN when the unmatched rows are exactly what you need.
Selecting columns with the same name from two tables without aliases.
Try it yourself
Write a query that shows each customer and the number of orders (0 included).
Find the customer with the highest total spend.
Explain why a foreign key helps data quality.
Week 15
Designing a REST endpoint with Spring Boot
A REST API exposes resources such as products through URLs and uses HTTP methods for actions: GET reads, POST creates, PUT or PATCH updates and DELETE removes. In Spring Boot a controller class maps a URL and method to a Java method, which calls a service and returns an object that Spring converts to JSON along with a suitable status code. Keeping the controller thin and the rules in a service makes the code easy to test.
Client: curl, browser, mobile app
Controller: URL + HTTP method
Service: business rules
Repository: database access
Step by step
Create a Product class with id, name and price.
Create ProductController annotated with @RestController and @RequestMapping("/api/products").
Add @GetMapping("/{id}") that calls productService.find(id).
Return 404 with a clear message when the product does not exist.
Add @PostMapping that validates the body and returns 201 with the saved product.
Call the endpoints with curl or Postman and compare the status codes.
In real life
A restaurant menu app calls the server to read the menu (GET) and to place an order (POST); the server answers with data and a status such as 201 Created.
Worked example
Problem. A client calls GET /api/products/99 and no product 99 exists. What should the API return?
Solution. Status 404 Not Found with a short JSON error such as {"message":"Product 99 not found"}. Returning 200 with an empty body would hide the problem.
Common mistakes
Putting database or business logic directly in the controller.
Returning 200 for every outcome, including errors.
Using verbs in URLs, such as /getProduct, instead of nouns and HTTP methods.
Try it yourself
Design the URLs and methods for customers: list, view, create, update, delete.
Add a query parameter ?minPrice= to filter products and test it.
Write the JSON body and expected status for a failed POST with a negative price.
Try the questions
The same skills are asked at three levels: School (Classes 6–12), College and Professional. Switch the level and the language (English or Tamil), and say how sure you are before you check: knowing what you are unsure about is part of learning.
Classes 6–12: everyday examples, no prior knowledge. Practice only. Nothing here is graded or saved.
Question 1 / 8 · Idea of the JVM
A film saved in a standard format plays on any phone that has a suitable player. Which Java idea is similar?
Projects
Library Management Console App
A school library tracks books and members on paper. Build a Java console application that manages books, members and loans using OOP, collections, exceptions and a CSV file, with JUnit tests for the main rules.
Tasks
Design classes Book, Member and Loan with private fields, constructors and validation.
Store books and members in collections keyed by id; reject duplicates with a custom exception.
Implement issue and return with a ₹2 per day late fee after 14 days using LocalDate.
Save and load data from CSV files using try-with-resources.
Write at least 8 JUnit tests, including boundary days 14 and 15 and error cases.
Sample input
Issue book B101 to member M7 on 2025-01-01; return on 2025-01-20
Expected output
Late by 5 days; fee ₹10. Returning a book that was never issued gives a clear error message.
How it is assessed
Criterion
Weight
Class design and encapsulation
20%
Correct rules and exception handling
25%
Collections and file persistence
20%
Tests and edge cases
20%
Code readability and README
15%
Stretch challenge: Add search by title using streams and a report of overdue loans sorted by fee.
Campus Store Order API (Spring Boot, JPA, MySQL)
Build a backend REST API for a campus store: products, customers and orders with 18% GST calculation. Use Spring Boot, Spring Data JPA with MySQL, Maven and Git, with validation, consistent error responses and automated tests.
Tasks
Design the schema (products, customers, orders, order_items) and draw an ER diagram.
Implement CRUD endpoints for products and customers with validation and correct status codes.
Implement POST /api/orders that checks stock, calculates GST and saves the order in one transaction.
Add a central exception handler that returns JSON errors with 400, 404 and 409 where suitable.
Write unit tests with Mockito for the order service and MockMvc tests for two controllers.
Document the API in a README with sample curl calls and keep the work in Git with meaningful commits.
Sample input
POST /api/orders {"customerId":1,"items":[{"productId":3,"qty":2}]}
Expected output
201 Created with the order total including 18% GST; stock reduced by 2; a request for more than the available stock returns 409 with a clear message.
How it is assessed
Criterion
Weight
Working endpoints and correct business rules
25%
Data model, JPA mapping and transactions
20%
Validation and error handling
15%
Automated tests
20%
Git history, README and build
20%
Stretch challenge: Add pagination and sorting for GET /api/products and an endpoint that returns monthly sales totals.
How you are assessed
Each week: five short questions (code reading, output prediction, one debugging or scenario item), a graded lab with a test table or automated tests, and a two-line reflection. Weeks 1-10 focus on Core Java; weeks 11-22 add SQL, REST and persistence scenarios.
Practical work. Two practical assessments: the Core Java console project at week 10 (run, test, explain, fix a seeded bug) and the backend API at week 22 (call endpoints, show passing tests, explain the generated SQL).
What trainers look for
Weight
Working, correct behaviour
30%
Design: OOP, layers and data model
25%
Testing
20%
Error handling and secure habits
10%
Git, documentation and explanation
15%
Where this can lead
Prepares you for junior Java developer and backend API tasks.
Gives a complete path from Core Java to a Git-hosted backend project you can explain.
These describe skills you will build. ADIVAS does not guarantee jobs, placement or salary.
Other programmes in Programming & Software Development
