Skip to content
NEB • Syllabus
BCA Second Semester Syllabus: OOP in Java (BCA153)
← Back to Syllabus

BCA Second Semester Syllabus: OOP in Java (BCA153)

Course Code: BCA153 | Credit Hours: 3 | Teaching Hours: Lecture 3 hrs + Practical 3 hrs/week | Year/Semester: I/II | Workload: 6 hours/week | Prerequisite: Basic understanding of programming logic and technique

Overview

OOP in Java is where BCA students shift from procedural thinking to object-oriented thinking — one of the most important mental shifts in the entire degree. Instead of writing code as a sequence of steps, you start modeling real-world entities as objects with properties and behaviors, which is how the vast majority of modern software (from Android apps to enterprise backend systems) is actually built.

Java is a deliberate choice for teaching this: it enforces object-oriented principles more strictly than languages like C++ or Python, which makes it a genuinely good teaching language for understanding concepts like encapsulation, inheritance, and polymorphism properly, rather than treating them as optional. The course assumes only a basic grasp of programming logic coming in, and builds all the way up to design patterns, lambda expressions, and the Stream API — concepts that show up constantly in real Java job postings.

What You’ll Learn

The course runs through eight units, moving from Java basics to advanced modern-Java features.

Unit 1: Introduction to Java and OOP Concept (4 hrs)

Covers Java’s history and key buzzwords/features, the JVM/JDK/JRE architecture that makes Java “write once, run anywhere,” and a direct comparison between procedural and object-oriented programming. You’ll set up a Java development environment and IDE locally, write and run your first sample programs, work with command-line arguments and the Scanner class for input, and learn to handle common beginner errors.

Unit 2: Basics of Java Programming (8 hrs)

The largest early unit, covering comments, Java tokens (keywords, identifiers, literals, operators, separators), primitive and user-defined data types, variable declaration and expressions, control statements (selection, looping, and jump statements), single and multi-dimensional arrays (including rectangular and jagged arrays), type conversion and casting, garbage collection, and a deep dive into Java’s String class — creation, concatenation, comparison, modification, and searching — plus the StringBuffer class for mutable strings.

Unit 3: Class and Objects in Java (8 hrs)

Where OOP really begins. Covers defining classes, adding methods, creating objects and calling them, abstraction and encapsulation, the three constructor types (default, parameterized, and copy), the this keyword, static fields and methods, passing arguments by value vs. by reference, recursion, nested and inner classes, variable-length arguments (varargs), and defining/importing packages.

Unit 4: Inheritance and Polymorphism (6 hrs)

Covers inheritance basics and the four inheritance types (single-level, multi-level, multiple, and hierarchical), the super keyword, polymorphism through method overloading and overriding, the Object class, the final keyword, abstract classes and methods, access control (private, protected, default, public), and interfaces — defining, implementing, and applying them. This unit is where Java’s stricter object-oriented rules (like no direct multiple inheritance between classes) become clear, and why interfaces exist to work around that limitation.

Unit 5: Exception Handling and Multithreading (6 hrs)

Covers Java’s exception hierarchy, proper exception-handling practice using try, catch, throw, throws, and finally, built-in exceptions, and how to define your own custom exceptions. The multithreading half introduces thread basics, the Thread class and Runnable interface, thread priorities, and thread synchronization/inter-thread communication — concepts essential for any application that needs to do more than one thing at once.

Unit 6: File Handling in Java (6 hrs)

Covers console and file I/O, reading and writing files using both byte streams and character streams, serialization and deserialization (turning objects into a storable/transmittable format and back), and the RandomAccessFile class for non-sequential file access.

Unit 7: Collections and Generics (6 hrs)

Covers wrapper classes and their methods, the Java Collections Framework (List, Set, and Map interfaces), commonly used implementations like ArrayList, LinkedList, HashSet, HashMap, and TreeSet, and how to access collections using Iterator and Comparator. The generics half covers defining generic classes and methods, wildcard arguments, generic interfaces and hierarchies, and generic restrictions — the type-safety features that let you write reusable, type-checked code.

Unit 8: Advanced OOP Concepts in Java (4 hrs)

The most modern unit, covering design patterns (singleton, factory, and observer patterns), lambda expressions, an introduction to the Stream API, the Optional class, and method references. These are the features that separate “classic” Java code from the more concise, functional-style Java written in modern codebases.

The Lab Component (48 Hours)

Practical work is a core part of this course, with lab reports expected to include theory, source code, and output for each task. You’ll:

  • Install Java SE and an IDE (Notepad++, NetBeans, or Eclipse) locally
  • Compile and run Java programs, implementing command-line arguments and the Scanner class
  • Implement Java basics — tokens, control statements, arrays, type casting
  • Use String and StringBuffer class methods
  • Define classes and objects, implementing encapsulation, inheritance, polymorphism, and abstraction
  • Handle built-in and user-defined exceptions, and implement multithreading
  • Create, write, and read files using byte and character streams, plus serialization, deserialization, and RandomAccessFile
  • Implement the Java Collections Framework and generic concepts
  • Apply advanced OOP concepts covered in Unit 8
  • Submit a final programming project demonstrating object-oriented concepts in Java

Why This Course Matters

OOP in Java is one of the most job-relevant courses in the early BCA curriculum. Object-oriented design is the default paradigm for enterprise software, Android development (which is built on Java/Kotlin), and most backend systems. The concepts here — inheritance, polymorphism, exception handling, collections — reappear directly in later courses like Software Engineering, Mobile Application Development, and any advanced programming elective. Employers screening for “Java developer” or “backend developer” roles will typically expect fluency in exactly what this course covers: OOP fundamentals, collections, and increasingly, modern features like streams and lambdas.

Recommended Reference Books

  • Balagurusamy, E. (2024). Programming with Java (7th ed.)
  • Deitel, P. J., & Deitel, H. M. (2024). Java How to Program: An Objects-Natural Approach (12th ed.)
  • Horstmann, C. S. (2024). Core Java, Volume I: Fundamentals (13th ed.)
  • Schildt, H., & Coward, D. (2024). Java: The Complete Reference (13th ed.)

Study Tips for BCA153

  1. Don’t rush past Unit 2. Java’s syntax quirks (data types, type casting, array structures) trip up more students than the actual OOP concepts later — get comfortable here first.
  2. Build small programs for every concept, not just read about them. The difference between method overloading and overriding, for example, becomes obvious the moment you actually write both and run them.
  3. Interfaces vs. abstract classes is a classic exam and interview question. Know not just the syntax difference but when you’d choose one over the other.
  4. Practice exception handling with real scenarios, like file-not-found or divide-by-zero cases, rather than memorizing the try-catch-finally syntax in isolation.
  5. Collections Framework questions often ask you to pick the right structure (ArrayList vs. LinkedList vs. HashMap vs. TreeSet) for a given scenario — understand the performance trade-offs, not just the class names.
  6. Treat the final programming project seriously. A well-built OOP project is exactly the kind of thing worth keeping in a portfolio for internship applications later.

Frequently Asked Questions

Do I need prior Java experience for BCA153? No specific Java experience is required, but the course does assume a basic conceptual understanding of programming logic — meaning you should already be comfortable with variables, loops, and conditionals from a prior course or self-study.

How much of this course is practical vs. theory? It’s evenly split — 3 hours of lecture and 3 hours of lab work per week — with a 48-hour practical component and a required final project on object-oriented concepts.

What Java features does this course cover beyond the basics? Beyond core OOP (classes, inheritance, polymorphism), the course also covers multithreading, file handling, the Collections Framework, generics, and modern features like lambda expressions, the Stream API, and design patterns.

Is this course useful outside of Java specifically? Yes — the object-oriented principles taught here (encapsulation, inheritance, polymorphism, abstraction) apply broadly across other OOP languages like C++, C#, and Python, even though the syntax differs.

This page summarizes the official TU BCA syllabus for BCA153 (OOP in Java). For the complete, authoritative syllabus document, refer to your college’s official curriculum handbook.