What topics are covered in Core Java at PBA Institute?

The course covers 18 modules: Introduction to Java, Control Flow & Arrays, Data Types & Variables, Operators, OOP Concepts, Important Keywords, Classes & Objects, Constructors, Inheritance, Packages, Exception Handling, I/O Streams, Collections Framework, Interfaces & Abstract Classes, Multithreading, File Handling, Strings, and JDBC.

Is prior programming experience required for Core Java at PBA Institute?

No prior programming experience is required. The course starts from absolute basics — what Java is, how JVM works, setting up the environment — and builds progressively to advanced topics like Multithreading, Collections, and JDBC. Students from any educational background can join confidently.

Core Java Programming Course in Howrah & Kolkata | PBA Institute — OOP, Collections, Multithreading, JDBC & More

Course Details

What You Get

The most comprehensive Core Java foundation in Howrah — 18 modules, 500+ programs, and the skills that every Java interview and every IT company assessment tests for.

60 Classes · 60 Hours

60 structured hours of instructor-led live coding across 18 modules — from writing your first Java program to implementing multithreaded applications and JDBC database operations.

ISO & MSME Certificate

Earn a government-recognized, ISO-certified completion certificate that carries real weight with IT employers in TCS, Infosys, Wipro, Cognizant, and every major Indian IT company.

500+ Solved Programs

50+ intro programs, 250+ control flow programs, 60+ OOP programs, 110+ collections programs, 40+ string programs — more hands-on practice than any other Java course in Howrah.

Small Batch Sizes

Only 10–15 students per batch ensures personal attention — critical when debugging constructor chaining, understanding thread synchronization, or configuring JDBC connections correctly.

Bengali & Hindi Medium

Complex topics like thread lifecycle, the Collections hierarchy, and JDBC architecture explained clearly in Bengali and Hindi — removing every language barrier from learning Java.

Interview-Ready Curriculum

Every topic that Java interviewers ask is covered — the Diamond Problem, static vs dynamic binding, HashMap vs TreeMap, thread states, checked vs unchecked exceptions, and more.

Your Journey

The Core Java Roadmap

Five sequential phases — each one builds on the last. Master the language basics, then OOP, then the powerful standard library, then concurrency, and finally database connectivity.

PHASE 1 · MODULES 1–4

Java Foundations — Language, Types & Operators

Introduction to Java and JVM architecture, control flow and arrays (250+ programs), data types and variables, and operators with precedence rules. This phase ends with you being able to write and debug fluent Java programs — before touching any OOP concept.

PHASE 2 · MODULES 5–9

OOP — All Four Pillars, Classes, Constructors & Inheritance

The heart of Java — all four OOP pillars, 26 deep-dive lessons on classes and objects, all constructor types and patterns (including Singleton), and every form of inheritance (including the Diamond Problem). 150+ programs across these five modules build genuine OOP thinking.

PHASE 3 · MODULES 10–14

Standard Library — Packages, Exceptions, I/O & Collections

Java's three most important packages (java.io, java.lang, java.util), complete exception handling, all I/O stream types, the full Collections framework (Set, List, Map — 110+ programs), and interfaces with abstract classes — the standard library knowledge that separates beginners from intermediate developers.

PHASE 4 · MODULES 15–17

Advanced Topics — Multithreading, File Handling & Strings

23 lessons on Java multithreading and concurrency (thread lifecycle, synchronization, deadlock, thread pools, Callable/Future), File handling with the File class and all reading methods, and all four String classes (String, StringBuffer, StringBuilder, StringTokenizer) with 40+ programs — the advanced topics that interviewers love to ask about.

PHASE 5 · MODULE 18

JDBC — Bridging Java to Databases

JDBC architecture, all four driver types, database connections with DriverManager, Statement objects (Statement, PreparedStatement, CallableStatement), ResultSet traversal, and transaction management (commit/rollback/savepoints) — giving your Java programs the ability to read and write real relational databases.

Full Curriculum

Course Syllabus

18 comprehensive modules organized into six topic groups — every lesson, every program type, and every concept listed in detail so you know exactly what you're learning.

Modules 1–4: Java Foundations, Data Types, Operators & Control Flow

The bedrock of everything Java. Four modules that establish your complete programming foundation — from understanding JVM architecture and writing your first Java program, to mastering data types, all operators, and 350+ practice programs across control flow and arrays. No shortcuts, no skipped basics.

4 ModulesJVM ArchitectureData TypesOperatorsArrays350+ Programs

M1

Introduction to Java — What, Why & HowWhat Java is, why Java dominates enterprise software, JVM architecture (class loader, runtime data areas, execution engine), the differences between JDK, JRE, and JVM, setting up Eclipse and NetBeans, writing and running the very first Java program, Java naming conventions, and 50+ introduction programs with complete solutions.

M2

Control Flow Statements & ArraysAll selection statements (if, if-else, nested if, switch-case), all iteration types (while, do-while, for, enhanced for-each, nested loops), jump statements (break, continue, return), whether Java supports goto, and Arrays — followed by 250+ control flow and array programs with solutions. The most practice-intensive section of the entire course.

M3

Data Types, Variables & Type ConversionJava identifiers and naming rules, all 8 primitive data types (byte, short, int, long, float, double, char, boolean), defining custom data types with enum, numeric/character/string literals, local vs instance vs static variables, scope and lifetime, the final keyword for constants, widening and narrowing conversions, explicit casting — and 20+ programs covering every type conversion edge case.

M4

Operators, Expressions & PrecedenceExpressions in Java, arithmetic operators, bitwise operators (AND, OR, XOR, left/right shift), relational operators, logical operators (short-circuit && and ||), assignment and compound assignment, prefix and postfix increment/decrement, the conditional ternary operator, operator precedence table — and 30+ programs covering every edge case interviewers ask about.

Modules 5–9: OOP Pillars, Keywords, Classes, Constructors & Inheritance

The heart of Java — five dense modules covering all four OOP pillars with real-world analogies, every important keyword in depth (11 keywords, 12 lessons), 26 deep-dive lessons on classes and objects, all constructor types and the Singleton pattern, and all forms of inheritance including the Diamond Problem. 150+ practice programs.

5 Modules4 OOP Pillars11 Keywords26 Class LessonsSingleton Pattern150+ Programs

M5

OOP Concepts — All Four PillarsIntroduction to object-oriented programming, Inheritance (IS-A relationships, code reuse), Encapsulation (private fields and getters/setters), Abstraction (hiding implementation behind interfaces), Polymorphism (compile-time overloading and runtime overriding), why Java is not a purely object-oriented language (primitives), and 60+ OOP programs covering all four pillars with complete solutions.

M6

Important Keywords — 11 Keywords in DepthComplete list of all 67 Java keywords, then deep-dive coverage of: this, super, static, final, the crucial distinction between final/finally/finalize, abstract, transient (serialization exclusion), volatile (thread visibility), strictfp (floating-point precision) — and 30+ programs showing every keyword used in real contexts.

M7

Classes & Objects — 26 Comprehensive LessonsClass definition, object creation, Java object storage (stack vs heap), 5 ways to create objects, Association/Composition/Aggregation, all 4 access modifiers, this reference, the Object class, static classes, method overloading vs overriding, "public static void main" explained, method hiding, static vs instance methods, static final variables, covariant return types, overriding toString() and equals(), variable hiding, static and instance initializer blocks, static vs dynamic binding — 60+ programs.

M8

Constructors — All Types & PatternsWhat constructors are, default and parameterized constructors, copy constructors, assigning values to static final variables in constructors, constructor chaining with this() and super(), private constructors and Singleton class implementation, constructor overloading — and 20+ programs covering every constructor pattern used in production Java code.

M9

Inheritance — All Forms, Edge Cases & Diamond ProblemTypes of inheritance (single, multilevel, hierarchical), Multiple Inheritance and the Diamond Problem (why Java avoids it), Java object creation in inherited classes, inheritance and constructors (super() call order), interfaces enabling multiple inheritance, using final with inheritance, overriding private methods (why you can't), more restrictive access in derived classes, parent and child classes with same data members, serialization with inheritance, subclass vs superclass references, overloading with inheritance — 20+ programs.

Modules 10–12: Packages, Exception Handling & I/O Streams

Java's standard library layers — the three most important packages in depth, complete exception handling covering every scenario interviewers ask about, and all I/O stream types for reading user input and writing formatted output. These modules are what separate a beginner from a working Java developer.

3 Modulesjava.io · java.lang · java.utilChecked vs UncheckedCustom ExceptionsScanner70+ Programs

M10

Packages — Java's Three Most ImportantIntroduction to packages and why they prevent name collisions, then in-depth coverage of the three packages every Java developer must know: java.io (streams, readers, writers, file I/O), java.lang (String, Math, Object, System, wrapper classes — the package Java automatically imports), and java.util (Collections, Arrays, Scanner, Date, Random — the workhorse utility package).

M11

Exception Handling — Complete CoverageWhat exceptions are and why they exist, OutOfMemoryError, 3 ways to print exception messages, try-catch-finally flow control, types of exceptions, catching base and derived exception classes in the same catch block, checked vs unchecked exceptions, throw vs throws keyword distinction, creating custom user-defined exceptions, floating-point Infinity vs ArithmeticException, multi-catch blocks (Java 7+), chained exceptions, NullPointerException causes and prevention — 20+ programs.

M12

Input/Output Streams — All TypesCharacter streams vs byte streams, DoubleStream.mapToObj(), command-line arguments with args[], the Scanner class for console input, Scanner and nextChar() behavior, Scanner vs BufferedReader (when to use each), formatted output with printf() and String.format(), fast I/O techniques for competitive programming, reading input from console — and 20+ programs covering every standard I/O pattern.

Modules 13–14: Collections Framework & Interfaces/Abstract Classes

The two modules that define intermediate-to-advanced Java skill. The Collections framework with 110+ programs across every Set, List, and Map implementation — and Interfaces & Abstract Classes with all their nuances including functional interfaces, nested classes, and the Comparator pattern. These are the most-tested topics in Java technical interviews.

2 ModulesSet · List · MapHashMap · TreeMapComparatorFunctional Interfaces120+ Programs

M13

Collections Framework — 110+ ProgramsThe Collections hierarchy and why it exists, the Set interface (HashSet for O(1) lookup, LinkedHashSet for insertion order, TreeSet for sorted order), the List interface (ArrayList for random access, LinkedList for insertion/deletion, Vector for thread safety, Stack for LIFO), the Map interface (HashMap for key-value storage, LinkedHashMap for ordered maps, TreeMap for sorted maps, Hashtable for legacy thread-safe maps) — with 110+ programs covering every collection class, iterator usage, sorting, and real interview scenarios.

M14

Interfaces & Abstract Classes — 18 LessonsInterfaces and all their rules, access specifiers for interface methods, abstract classes (what they are and when to use each over the other), the Comparator interface for custom sorting, default and static interface methods (Java 8+), nested interfaces, nested classes in Java (static nested, inner, local, anonymous), inner class, local inner class, anonymous inner class, functional interfaces, what marker interfaces are, static methods in interfaces, the Function interface — 10+ programs including lambda-style patterns.

Modules 15–17: Multithreading, File Handling & Strings

The advanced topics that turn a Core Java student into a senior developer. 23 detailed lessons on Java's concurrency model — threads, synchronization, deadlock, and thread pools. File handling with the File class and all reading strategies. And all four String classes with 40+ string manipulation programs. These are the modules interviewers love to test.

3 Modules23 Thread LessonsSynchronizationDeadlock4 String Classes80+ Programs

M15

Multithreading — 23 Lessons on Java ConcurrencyIntroduction to multithreading and why it matters, thread lifecycle (NEW → RUNNABLE → BLOCKED → WAITING → TERMINATED), the main thread, methods to prevent thread execution (sleep, yield, join, wait, notify), inter-thread communication, the Thread class, start() vs run() distinction, thread priority, joining threads, naming threads, synchronization (method-level and block-level), the Producer-Consumer solution with wait/notify, thread pools with ExecutorService, Semaphore, java.util.concurrent.Semaphore, CountDownLatch, deadlock in Java (causes and prevention), daemon threads, ReentrantLock, CyclicBarrier, Callable and Future, the Runtime class.

M16

File Handling in JavaThe File class (creating, deleting, checking existence, listing directory contents), all ways of reading a text file in Java (FileReader, BufferedReader, Scanner on a File, Files.readAllLines, Files.lines stream), file permissions and access control in Java — and 20+ programs building complete file-based applications: log writers, CSV file readers, student record managers, and file copy utilities.

M17

Strings in Java — 4 Classes & 40+ ProgramsThe String class and string pool (immutability, string interning, memory implications of == vs .equals()), StringBuffer (thread-safe, synchronized, mutable — when to use in concurrent code), StringBuilder (fast, unsynchronized, mutable — the default choice for string manipulation), StringTokenizer for splitting strings by delimiter, StringJoiner (Java 8) for building delimited strings — and 40+ programs covering every string manipulation, parsing, comparison, and transformation pattern that appears in Java interviews and assessments.

Module 18: JDBC — Connecting Java to Relational Databases

The capstone module that bridges Core Java to the real world. Every Java enterprise application needs a database — JDBC is how Java talks to MySQL, Oracle, PostgreSQL, and every other relational database. This module covers JDBC architecture end-to-end: driver types, connections, statements, result sets, and transaction control.

1 Module4 Driver TypesConnection & StatementPreparedStatementResultSetTransactions

L1

Introduction to JDBCWhat JDBC is and why it exists — the standard Java API for connecting to relational databases, JDBC's role in the Java ecosystem, JDBC vs raw SQL, and why every Java application that needs to persist data eventually uses JDBC (directly or through ORM frameworks like Hibernate that wrap it).

L2

Architecture of JDBCThe JDBC architecture layers — Java application, JDBC API, JDBC Driver Manager, JDBC drivers, and the database itself. The two JDBC tiers (2-tier and 3-tier models) and when each is used in real applications. Understanding the architecture makes every subsequent JDBC operation make intuitive sense.

L3

Types of JDBC Architecture (Tier Models)The four types of JDBC drivers in depth: Type 1 (JDBC-ODBC Bridge — legacy), Type 2 (Native API driver), Type 3 (Network Protocol driver), and Type 4 (Thin driver — the pure Java driver used in production). Understanding which driver type to use and why is a standard interview question.

L4

Database ConnectionEstablishing a JDBC connection step-by-step: loading the driver class (Class.forName), getting a Connection via DriverManager.getConnection() with URL/username/password, the Connection URL format for MySQL/Oracle, and testing the connection — plus best practices for connection management in real applications.

L5

Driver Types in PracticeHow to choose and configure the right JDBC driver for MySQL (mysql-connector-java), Oracle (ojdbc), and other databases. Adding the driver JAR to the classpath in Eclipse/NetBeans, common connection errors and how to fix them — the practical setup knowledge that gets students running their first database-connected Java program.

L6

Statement Objects — Statement, PreparedStatement & CallableStatementThe Statement interface for simple queries, PreparedStatement for parameterized queries (SQL injection prevention, performance benefits with precompiled execution plans), and CallableStatement for executing stored procedures. When to use each — and why PreparedStatement is always preferred in production code over raw Statement.

L7

ResultSet — Navigating Query ResultsThe ResultSet interface, forward-only traversal with next(), reading column values by name and index (getString, getInt, getDouble, getDate), scrollable and updatable ResultSets, ResultSet metadata (column count, column names, column types), and converting ResultSet rows to Java objects — the foundation of all JDBC data retrieval.

L8

Transaction Processing — Commit, Rollback & SavepointsWhat database transactions are (ACID properties), disabling auto-commit mode in JDBC, grouping multiple SQL operations into a single transaction, committing on success, rolling back on failure, using Savepoints for partial rollbacks — and a complete bank transfer example demonstrating why transactions are essential for data integrity in Java applications.

Skills You'll Gain

Core Java JVM Architecture OOP Principles Encapsulation Inheritance Polymorphism Abstraction Collections HashMap ArrayList Multithreading Synchronization Exception Handling File I/O Strings StringBuilder Interfaces Abstract Classes JDBC PreparedStatement Transactions Constructor Patterns

What You'll Learn

Learning Outcomes

Graduate with a complete Core Java skill set — the exact foundation that TCS NQT, Infosys InfyTQ, Wipro Elite, and Cognizant GenC written tests assess.

Write Professional Java Programs

Write clean, efficient Java code using proper naming conventions, data types, operators, and control structures — with the fluency that comes from solving 500+ programs across every concept, not just reading theory.

Apply All Four OOP Principles

Design and implement Java programs using Encapsulation, Inheritance, Abstraction, and Polymorphism correctly — not just explain them, but use them to build properly structured applications with clean class hierarchies.

Master the Collections Framework

Choose the right data structure (ArrayList vs LinkedList, HashMap vs TreeMap, HashSet vs TreeSet) for every use case, and implement sorting, searching, and iteration with confidence — the #1 Java interview topic.

Build Concurrent Java Programs

Create multithreaded applications using Thread, Runnable, synchronization, wait/notify, and thread pools — and prevent common concurrency bugs like deadlocks, race conditions, and visibility issues using Java's concurrency tools.

Handle Exceptions & Files Professionally

Write robust Java programs that handle checked and unchecked exceptions gracefully, create custom exception hierarchies, and read/write files using Java's I/O streams — the reliability skills every production Java developer needs.

Connect Java to Databases with JDBC

Write Java applications that connect to relational databases, execute CRUD SQL operations using PreparedStatement, navigate ResultSets, and manage transactions — the foundation for all Java enterprise and web development.

Who Should Join?

This Course Is For You

Core Java is the entry point to every Java career path — Full Stack Java, Android Development, Spring Boot, and Enterprise Java. Every one of these paths starts here.

🎓

CS/IT Students

BCA, MCA, BTech, and BSc IT students who want a rock-solid Java foundation before campus placements. Java is the most-tested language in TCS NQT, Infosys InfyTQ, Wipro Elite NTH, and Cognizant GenC competitive exams.

🔄

Career Switchers

Non-IT professionals or graduates from other streams entering software development. The course starts from absolute zero — what Java is, how JVM works — and builds every concept logically. No prior programming background needed.

🚀

Future Full Stack Developers

Students who plan to join the Full Stack Java Development course — Core Java is its essential prerequisite. Master the foundation here, then advance to Spring Boot, Hibernate, Servlets, and MySQL with confidence.

FAQ

Frequently Asked Questions

What is the fee for the Core Java course at PBA Institute?

The batch class fee is ₹6,000 for the complete Core Java course — 60 classes, 60 hours, 18 modules. This covers everything from the JVM architecture through OOP, Collections, Multithreading, and JDBC. The fee includes study materials, software setup support, 500+ solved programs, and an ISO-certified completion certificate.

Do I need programming experience to join the Core Java course?

No prior programming experience is required. Module 1 begins with "What is Java?" and explains JVM architecture before writing the first program. The course is specifically structured for absolute beginners — students from arts, commerce, and science backgrounds have all completed this course successfully. The small batch size (10–15) ensures every student gets individual attention.

Is Core Java enough to get a job as a Java developer?

Core Java is the essential foundation that every Java developer must master. For entry-level Java developer roles and service company (TCS, Infosys, Wipro) assessments, strong Core Java knowledge is the primary requirement. For product companies and Full Stack roles, completing Core Java and then advancing to the Full Stack Java Development course (Spring Boot, Hibernate, MySQL) gives you the complete profile.

What topics does the Core Java course cover at PBA Institute?

The 18-module course covers: Introduction to Java and JVM Architecture, Control Flow and Arrays (250+ programs), Data Types and Variables, Operators and Expressions, OOP Concepts (all 4 pillars), Important Keywords (11 keywords), Classes and Objects (26 lessons), Constructors, Inheritance, Packages (java.io, java.lang, java.util), Exception Handling, I/O Streams, Collections Framework (Set/List/Map — 110+ programs), Interfaces and Abstract Classes, Multithreading (23 lessons), File Handling, Strings (4 String classes), and JDBC.

Is there an online option for the Core Java course?

Yes. PBA Institute offers both online (live virtual classes) and offline (Howrah campus) options with the same instructor, same 18-module curriculum, and the same live coding sessions. Online students join via screen share, ask questions in real-time, and get their code reviewed. Students from across West Bengal and other states have completed this course fully online with the same results.

Can I continue to the Full Stack Java course after completing Core Java?

Absolutely — and this is the recommended path. Core Java is the official prerequisite for the Full Stack Java Development course. After mastering Core Java at PBA Institute, you seamlessly continue into Advanced Java (Servlets, JSP, Spring MVC, Hibernate) and MySQL — the complete path to becoming a Full Stack Java developer ready for enterprise roles.

Explore More

Continue your Java journey or explore complementary technologies at PBA Institute.

View All 50+ Courses