BCA 104T Object Oriented Programming using Java Notes from Unnati Educations run to 118 pages across 4 units, with 75 Java programs with output, 94 two-mark and 37 ten-mark solved questions. They follow the GGSIPU BCA Semester 2 syllabus for students admitted in academic session 2024-25 onwards. The full notes come as a printed book, ordered on WhatsApp.
Written by Prateek Talwar, Founder, Unnati Educations · Reviewed by Ritik Rawat, B.Tech, Senior Full Stack Developer · Checked against the BCA First Year Syllabus and the BCA Scheme and Syllabus (w.e.f. 2024-25) on ipu.ac.in, 12 October 2026 · Updated 12 October 2026 · Editorial policy
Scheme: BCA Scheme and Syllabus w.e.f. Academic Session 2024-25 | Applies to: batch admitted in 2024-25 onwards | Verified against: syllBCA1styr240124.pdf and syll4yrBCA240124.pdf, 12 October 2026
On this page
BCA 104T Object Oriented Programming using Java at a glance: GGSIPU BCA Sem 2 credits, units and exam pattern
| Paper | BCA 104T · Object Oriented Programming using Java |
|---|---|
| Course and semester | BCA, Semester 2 |
| Category and credits | CCT, 4 credits (L-T 4-0) |
| Marks | 100: 40 internal + 60 end-term |
| Applies to | Batch admitted in academic session 2024-25 onwards |
| End-term pattern | Q1 compulsory: 10 × 2 marks, at least 2 per unit; then one of two questions from each unit, 10 marks each (20 + 40 = 60 marks) |
| Units | 4 (teaching hours 12, 12, 10 and 10) |
| Paired lab | BCA 104P Object Oriented Programming Using Java Lab · CCP · 2 credits · 100 marks (40 + 60) |
BCA 104T sits with nine other papers in the GGSIPU BCA Semester 2 papers.
BCA 104T Object Oriented Programming using Java Notes unit-wise: 75 solved programs across 4 units
Notes for every other paper of the course sit on GGSIPU BCA notes.
BCA 104T Unit 1: Object Oriented Paradigm and Java Basics
Unit 1 sets procedural and object-oriented design side by side, then covers Java history, buzzwords, JDK/JRE/JVM, tokens, data types, casting, operators, loops and arrays.
Pages 4 to 35 · 17 sections · 19 programs (1.1 to 1.19) · 24 two-mark and 10 ten-mark solved questions.
| Basis | C++ | Java |
|---|---|---|
| Platform | Compiled to machine code, platform dependent | Bytecode + JVM, platform independent |
| Pointers | Explicit pointers allowed | No pointers for programmers, uses references |
| Multiple inheritance | Allowed with classes | Only through interfaces |
| Memory | Manual new/delete and destructors | Automatic garbage collection |
Quick look: Java vs C++ (from page 11)
- Basis
- Platform
- C++
- Compiled to machine code, platform dependent
- Java
- Bytecode + JVM, platform independent
- Basis
- Pointers
- C++
- Explicit pointers allowed
- Java
- No pointers for programmers, uses references
- Basis
- Multiple inheritance
- C++
- Allowed with classes
- Java
- Only through interfaces
- Basis
- Memory
- C++
- Manual
new/deleteand destructors - Java
- Automatic garbage collection
BCA 104T Unit 2: Classes, Inheritance, Interfaces, Packages and Polymorphism
Unit 2 covers constructors, access modifiers, this, static and final, the String class, inheritance with super, overriding, abstract classes, interfaces, user-defined packages, dynamic binding, instanceof and generics.
Pages 36 to 68 · 20 sections · 20 programs (2.1 to 2.20) · 25 two-mark and 11 ten-mark solved questions.
| Basis | Static binding | Dynamic binding |
|---|---|---|
| Also called | Early binding | Late binding |
| Resolved at | Compile time | Run time |
| Based on | Declared reference type | Actual object type |
| Used for | private, static, final methods, overloading, fields | Overridden instance methods |
Quick look: static vs dynamic binding (from page 61)
- Basis
- Also called
- Static binding
- Early binding
- Dynamic binding
- Late binding
- Basis
- Resolved at
- Static binding
- Compile time
- Dynamic binding
- Run time
- Basis
- Based on
- Static binding
- Declared reference type
- Dynamic binding
- Actual object type
- Basis
- Used for
- Static binding
private,static,finalmethods, overloading, fields- Dynamic binding
- Overridden instance methods
BCA 104T Unit 3: Using I/O, Byte Streams, Character Streams and File Handling
Unit 3 maps the java.io hierarchy, then works through console and file I/O with byte streams, BufferedReader, FileWriter, FileReader, PrintWriter and the File class.
Pages 69 to 91 · 10 sections · 17 programs (3.1 to 3.17) · 20 two-mark and 8 ten-mark solved questions.
| Basis | FileInputStream / FileOutputStream | FileReader / FileWriter |
|---|---|---|
| Reads / writes | Bytes (0 to 255) | Characters (0 to 65535) |
| Super class | InputStream / OutputStream | Reader / Writer |
| Writing a String | Needs s.getBytes() | write(String) directly |
| Use for | Any file, binary or text | Text files only |
Quick look: byte file streams vs character file streams (from page 86)
- Basis
- Reads / writes
FileInputStream/FileOutputStream- Bytes (0 to 255)
FileReader/FileWriter- Characters (0 to 65535)
- Basis
- Super class
FileInputStream/FileOutputStreamInputStream/OutputStreamFileReader/FileWriterReader/Writer
- Basis
- Writing a String
FileInputStream/FileOutputStream- Needs
s.getBytes() FileReader/FileWriterwrite(String)directly
- Basis
- Use for
FileInputStream/FileOutputStream- Any file, binary or text
FileReader/FileWriter- Text files only
BCA 104T Unit 4: Exception Handling and Multithreaded Programming
Unit 4 first covers the exception hierarchy, try, catch, finally, throw, throws and custom exceptions like InsufficientBalanceException, then threads: life cycle, Thread vs Runnable and synchronization.
Pages 92 to 118 · 16 sections · 19 programs (4.1 to 4.19) · 25 two-mark and 8 ten-mark solved questions.
Quick look: validating input with throw (from page 100)
static void checkAge(int age) {
if (age < 0)
throw new IllegalArgumentException("Negative age: " + age);
if (age < 18)
throw new ArithmeticException("Not eligible to vote, age " + age);
}Output for checkAge(15): ArithmeticException: Not eligible to vote, age 15.
BCA 104T exam corner: 94 two-mark and 37 ten-mark solved questions by unit
| Unit | 2 Marks | 10 Marks | Solved programs |
|---|---|---|---|
| Unit 1 | 24 | 10 | 19 |
| Unit 2 | 25 | 11 | 20 |
| Unit 3 | 20 | 8 | 17 |
| Unit 4 | 25 | 8 | 19 |
| Total | 94 | 37 | 75 |
BCA 104T solved questions and programs by unit
- Unit
- Unit 1
- 2 Marks
- 24
- 10 Marks
- 10
- Solved programs
- 19
- Unit
- Unit 2
- 2 Marks
- 25
- 10 Marks
- 11
- Solved programs
- 20
- Unit
- Unit 3
- 2 Marks
- 20
- 10 Marks
- 8
- Solved programs
- 17
- Unit
- Unit 4
- 2 Marks
- 25
- 10 Marks
- 8
- Solved programs
- 19
- Unit
- Total
- 2 Marks
- 94
- 10 Marks
- 37
- Solved programs
- 75
The BCA 104T notes solve 94 two-mark and 37 ten-mark questions across 4 units, plus 75 programs with output.
Four GGSIPU-pattern questions, one per unit:
- Unit 1 (2 marks): Why is Java called platform independent?
javacmakes bytecode, not machine code, so any system with a JVM runs the same.classfile. - Unit 2 (10 marks): What is an abstract class? Write a program to find the area of different shapes using one. Rules, then Program 2.13 (
Shapewith three sub classes) and its output. - Unit 3 (10 marks): Write a program to count the characters, words and lines in a text file. Program 3.12, its word-counting logic and output.
- Unit 4 (2 marks): Differentiate
start()andrun().start()creates a new thread; callingrun()directly runs it on the current thread.
More practice for this paper sits in the BCA 104T important questions.
Who writes and checks the BCA 104T Java notes?
- Prateek Talwar, author · Founder, Unnati Educations · Associate Company Secretary (ACS), ICSI, membership no. 58704, since 15 May 2019 · B.Com, University of Delhi (School of Open Learning), 2012 · Author bio
- Ritik Rawat, subject reviewer · Senior Full Stack Developer, Unnati Educations · B.Tech · Reviewer bio
The BCA 104T Java IPU notes are mapped unit by unit to the 2024-25 scheme. Ritik Rawat reviews the theory and all 75 programs with output, from Hello.java to ProducerConsumer.java.
The 2026-27 edition has 118 pages, 35 figures and 49 tables, last updated 12 October 2026 under our editorial policy.
The same team prepares GGSIPU important questions for each course it covers.
How to write BCA 104T answers: class-plus-output programs and ten-mark difference tables
Two-mark answers (Q1). The notes advise 3 to 5 lines: keyword, one-line definition, tiny example. Q1 takes at least 2 parts from each unit, so no unit can be skipped.
Worked example. "What is type casting? Give an example." Answer: Converting a value of one data type into another is type casting. Widening, such as int to double, is automatic; narrowing needs an explicit cast, so int x = (int) 9.75; stores 9.
Ten-mark program answers. Write the full class, the main() method and the expected output. The Unit 2 exam corner notes that examiners give marks for output.
Ten-mark difference answers. Overloading vs overriding or abstract class vs interface need an 8-point table plus one small example. The Unit 1 tip: for POP vs OOP, add that C struct data is open to every function while Java private fields are not.
Diagrams. Draw the JVM architecture (Unit 1), the stream hierarchy (Unit 3), and the exception hierarchy and thread life cycle (Unit 4).
Common mistakes the notes flag. A missing break in switch falls through; a FileWriter without true wipes the old file; calling start() twice throws IllegalThreadStateException. For thread programs, note that output order may vary.
Practise this answer format on GGSIPU BCA important questions.
BCA 104T and the BCA 104P Java lab, plus other GGSIPU BCA Sem 2 papers
The practical paper has its own page: BCA 104P Java lab notes.
BCA 104P is a CCP paper (2 credits, 100 marks) with the same course outcomes; the teacher notifies its practical list in week one.
These GGSIPU BCA Semester 2 Java notes help at the lab bench by unit: Unit 1 loops and arrays (Programs 1.8 to 1.19), Unit 2 constructors, inheritance and interfaces (Programs 2.2 to 2.15), Unit 3 file reading and writing (Programs 3.3 to 3.17) and Unit 4 thread creation and synchronization (Programs 4.11 to 4.19).
Other Semester 2 papers: BCA 102T Database Management System (DBMS), BCA 106T Data Structures and Algorithms, BCA 108T Software Engineering, BCA 142T Soft Skills, BCA 192T Environment Studies, and the labs BCA 102P, BCA 106P and BCA 108P.
try-with-resources in Java file handling: excerpt from page 77 of the BCA 104T notes
Excerpt from page 77 (Unit 3, section 3.5, Automatically Closing a File)
An open stream holds a resource from the operating system called a file handle. If the stream is never closed, the file can stay locked, data still sitting in a buffer may never reach the disk, and a long-running program can run out of handles. Java gives two safe ways to close a stream.
Way 1: closing in a finally block (before Java 7)
FileInputStream fin = null;
try {
fin = new FileInputStream("a.txt");
// use fin
} catch (IOException e) {
// handle
} finally {
try { if (fin != null) fin.close(); }
catch (IOException e) { }
}This works, but the code is long and easy to forget, and it needs a nested try because close() itself throws IOException. The inner close() call in finally runs even when an exception occurred inside the try block.
Way 2: try-with-resources (Java 7 and later)
This is also called automatic resource management. In try-with-resources, one or more resources are declared inside parentheses after try. When the block ends, normally or because of an exception, Java calls close() on each resource by itself. A resource is any object whose class implements java.lang.AutoCloseable or its sub-interface java.io.Closeable, and every stream class does.
try (FileInputStream fin = new FileInputStream("a.txt");
FileOutputStream fout = new FileOutputStream("b.txt")) {
// use fin and fout
} catch (IOException e) {
// handle
} // fout is closed first, then finAdvantages of try-with-resources
- No
finallyblock is needed, so there is less code and fewer mistakes. - Resources are always closed, even when an exception is thrown.
- Several resources are closed in the reverse order of their creation.
- If both the
tryblock andclose()throw exceptions, the one fromclose()is kept as a suppressed exception (e.getSuppressed()), so the main error is not lost.
Do the BCA 104T notes cover the full GGSIPU syllabus?
Yes for all four units: every official unit topic has its own section. One gap: Java Swing, named in the learning objectives but in no unit, is not covered.
| Official unit | Official topics | Notes sections | Status |
|---|---|---|---|
| Unit I | Procedural vs object-oriented development, OOP concepts and benefits; Java history, features, Java vs C++, JDK, JVM, JRE, tokens, data types, literals, variables, operators, control structures, arrays | 1.1 to 1.15, pp. 5 to 31 | Covered |
| Unit II | Classes, constructors, access modifiers, this, static, final, String class; inheritance, super, overriding, covariant return type, abstract class; interfaces, packages; dynamic binding, generics, casting objects, instanceof, overloading | 2.1 to 2.18, pp. 37 to 64 | Covered |
| Unit III | I/O concepts, byte streams, automatically closing a file, character streams, FileWriter and FileReader | 3.1 to 3.8, pp. 70 to 87 | Covered |
| Unit IV | Exception class, checked and unchecked, user-defined exceptions, try, catch, throw, throws, finally; Thread, Runnable, life cycle, multiple threads, thread methods, synchronization | 4.1 to 4.14, pp. 93 to 114 | Covered |
Official BCA 104T units mapped to the notes
- Official unit
- Unit I
- Official topics
- Procedural vs object-oriented development, OOP concepts and benefits; Java history, features, Java vs C++, JDK, JVM, JRE, tokens, data types, literals, variables, operators, control structures, arrays
- Notes sections
- 1.1 to 1.15, pp. 5 to 31
- Status
- Covered
- Official unit
- Unit II
- Official topics
- Classes, constructors, access modifiers,
this,static,final, String class; inheritance,super, overriding, covariant return type, abstract class; interfaces, packages; dynamic binding, generics, casting objects,instanceof, overloading - Notes sections
- 2.1 to 2.18, pp. 37 to 64
- Status
- Covered
- Official unit
- Unit III
- Official topics
- I/O concepts, byte streams, automatically closing a file, character streams,
FileWriterandFileReader - Notes sections
- 3.1 to 3.8, pp. 70 to 87
- Status
- Covered
- Official unit
- Unit IV
- Official topics
- Exception class, checked and unchecked, user-defined exceptions,
try,catch,throw,throws,finally;Thread,Runnable, life cycle, multiple threads, thread methods, synchronization - Notes sections
- 4.1 to 4.14, pp. 93 to 114
- Status
- Covered
Official sources: GGSIPU BCA First Year Syllabus (batch 2024-25 onwards) and GGSIPU BCA Scheme and Syllabus w.e.f. 2024-25.
Every course in GGSIPU notes is mapped to its official PDF the same way, unit by unit.
BCA 104T Java notes FAQs
How do I get the full BCA 104T notes?
Tap "Get Full Notes" on this page to message 9899436384 on WhatsApp; the paper code is filled in for you. The full BCA 104T notes are a 118-page printed book covering all 4 units, with 75 programs and 131 solved questions. They are not available as a PDF; our team shares the order details on WhatsApp.
Is BCA 104T the same as the BCA 104P Java lab?
No. BCA 104T is the theory paper: CCT, 4 credits, 100 marks with a written end-term. BCA 104P is the matching practical paper: CCP, 2 credits, 100 marks, with a practical list your teacher announces in the first week. They share the same course outcomes, so the 75 programs in these notes help with both.
Which unit of BCA 104T has the most programs?
Unit 2 does, with 20 solved programs (2.1 to 2.20) over 33 pages, covering constructors, the static keyword, inheritance, interfaces, packages, dynamic binding and generics. Units 1 and 4 have 19 programs each and Unit 3 has 17. Unit 2 also has the most ten-mark questions in the notes, 11 of the 37, so give it the most practice time.
Do the BCA 104T notes match my batch and scheme?
The BCA 104T notes follow the GGSIPU BCA scheme that applies to students admitted in academic session 2024-25 onwards. If you joined BCA in 2024-25 or later, the four units and the 60-mark end-term pattern here match your syllabus. If you joined earlier, check your own scheme on ipu.ac.in before you rely on any IPU paper code.
What is the passing mark for BCA 104T?
BCA 104T is marked out of 100: 40 internal and 60 end-term. The BCA scheme of examination does not print a pass percentage for this paper. For minimum marks in the end-term, grading and re-appear rules, refer to GGSIPU Ordinance 11 on ipu.ac.in, which the BCA scheme cites for its grading system. Ordinance 11 is the official source for these rules.
Do the BCA 104T notes cover Java Swing?
No. The BCA 104T learning objectives mention developing GUI applications with Java Swing, but none of the four official units lists Swing, and the end-term questions are set unit by unit. The notes therefore stick to the unit topics: OOP basics, classes and inheritance, I/O streams, exceptions and threads. Ask your teacher if Swing is taught at your institute.
Get the full BCA 104T Object Oriented Programming using Java Notes on WhatsApp
Order the full Object Oriented Programming using Java notes in English as a printed book through WhatsApp. They are not available as a PDF.
| Unit | Pages |
|---|---|
| Unit 1 | 4 to 35 (32) |
| Unit 2 | 36 to 68 (33) |
| Unit 3 | 69 to 91 (23) |
| Unit 4 | 92 to 118 (27) |
| Total | 118, with cover and contents |
Pages per unit in the full BCA 104T notes
- Unit
- Unit 1
- Pages
- 4 to 35 (32)
- Unit
- Unit 2
- Pages
- 36 to 68 (33)
- Unit
- Unit 3
- Pages
- 69 to 91 (23)
- Unit
- Unit 4
- Pages
- 92 to 118 (27)
- Unit
- Total
- Pages
- 118, with cover and contents
Format: printed book only, with a contents page for all 63 sections.
Order the BCA 104T notes book on WhatsApp (4 units, 118 pages)
Unnati Educations is an independent education provider based in Vikaspuri, Delhi. We are not affiliated with, authorised by, or endorsed by Guru Gobind Singh Indraprastha University (GGSIPU). 'GGSIPU' and 'IPU' are used only to describe the syllabus our notes follow. For official information, visit ipu.ac.in.
Ready for the full notes?
Discuss coverage and delivery with our team.