Notes BCA 104T

BCA 104T Object Oriented Programming using Java Notes for GGSIPU BCA Sem 2

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.

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

  1. BCA 104T at a glance
  2. BCA 104T notes unit-wise
    1. Unit 1: Object Oriented Paradigm and Java Basics
    2. Unit 2: Classes, Inheritance, Interfaces, Packages and Polymorphism
    3. Unit 3: Using I/O, Byte Streams, Character Streams and File Handling
    4. Unit 4: Exception Handling and Multithreaded Programming
  3. BCA 104T exam corner
  4. Who writes and checks these notes
  5. How to write BCA 104T answers
  6. BCA 104P Java lab and other Sem 2 papers
  7. Excerpt: try-with-resources (page 77)
  8. Syllabus coverage check
  9. BCA 104T FAQs
  10. Get the full notes on WhatsApp

BCA 104T Object Oriented Programming using Java at a glance: GGSIPU BCA Sem 2 credits, units and exam pattern

BCA 104T snapshot from the official GGSIPU BCA PDFs
PaperBCA 104T · Object Oriented Programming using Java
Course and semesterBCA, Semester 2
Category and creditsCCT, 4 credits (L-T 4-0)
Marks100: 40 internal + 60 end-term
Applies toBatch admitted in academic session 2024-25 onwards
End-term patternQ1 compulsory: 10 × 2 marks, at least 2 per unit; then one of two questions from each unit, 10 marks each (20 + 40 = 60 marks)
Units4 (teaching hours 12, 12, 10 and 10)
Paired labBCA 104P Object Oriented Programming Using Java Lab · CCP · 2 credits · 100 marks (40 + 60)
View complete table: BCA 104T snapshot from the official GGSIPU BCA PDFs

This view preserves the original alignment. Scroll within it if needed to read the complete content.

BCA 104T snapshot from the official GGSIPU BCA PDFs
PaperBCA 104T · Object Oriented Programming using Java
Course and semesterBCA, Semester 2
Category and creditsCCT, 4 credits (L-T 4-0)
Marks100: 40 internal + 60 end-term
Applies toBatch admitted in academic session 2024-25 onwards
End-term patternQ1 compulsory: 10 × 2 marks, at least 2 per unit; then one of two questions from each unit, 10 marks each (20 + 40 = 60 marks)
Units4 (teaching hours 12, 12, 10 and 10)
Paired labBCA 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.

Quick look: Java vs C++ (from page 11)
BasisC++Java
PlatformCompiled to machine code, platform dependentBytecode + JVM, platform independent
PointersExplicit pointers allowedNo pointers for programmers, uses references
Multiple inheritanceAllowed with classesOnly through interfaces
MemoryManual new/delete and destructorsAutomatic 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/delete and 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.

Quick look: static vs dynamic binding (from page 61)
BasisStatic bindingDynamic binding
Also calledEarly bindingLate binding
Resolved atCompile timeRun time
Based onDeclared reference typeActual object type
Used forprivate, static, final methods, overloading, fieldsOverridden 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, final methods, 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.

Quick look: byte file streams vs character file streams (from page 86)
BasisFileInputStream / FileOutputStreamFileReader / FileWriter
Reads / writesBytes (0 to 255)Characters (0 to 65535)
Super classInputStream / OutputStreamReader / Writer
Writing a StringNeeds s.getBytes()write(String) directly
Use forAny file, binary or textText 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 / FileOutputStream
InputStream / OutputStream
FileReader / FileWriter
Reader / Writer
Basis
Writing a String
FileInputStream / FileOutputStream
Needs s.getBytes()
FileReader / FileWriter
write(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);  
}
View preformatted content

This view preserves the original alignment. Scroll within it if needed to read the complete content.

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

BCA 104T solved questions and programs by unit
Unit2 Marks10 MarksSolved programs
Unit 1241019
Unit 2251120
Unit 320817
Unit 425819
Total943775

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:

  1. Unit 1 (2 marks): Why is Java called platform independent? javac makes bytecode, not machine code, so any system with a JVM runs the same .class file.
  2. 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 (Shape with three sub classes) and its output.
  3. 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.
  4. Unit 4 (2 marks): Differentiate start() and run(). start() creates a new thread; calling run() 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.

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) { }  
}
View preformatted content

This view preserves the original alignment. Scroll within it if needed to read the complete content.

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 fin
View preformatted content

This view preserves the original alignment. Scroll within it if needed to read the complete content.

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 fin

Advantages of try-with-resources

  • No finally block 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 try block and close() throw exceptions, the one from close() 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 BCA 104T units mapped to the notes
Official unitOfficial topicsNotes sectionsStatus
Unit IProcedural 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, arrays1.1 to 1.15, pp. 5 to 31Covered
Unit IIClasses, constructors, access modifiers, this, static, final, String class; inheritance, super, overriding, covariant return type, abstract class; interfaces, packages; dynamic binding, generics, casting objects, instanceof, overloading2.1 to 2.18, pp. 37 to 64Covered
Unit IIII/O concepts, byte streams, automatically closing a file, character streams, FileWriter and FileReader3.1 to 3.8, pp. 70 to 87Covered
Unit IVException class, checked and unchecked, user-defined exceptions, try, catch, throw, throws, finally; Thread, Runnable, life cycle, multiple threads, thread methods, synchronization4.1 to 4.14, pp. 93 to 114Covered

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, FileWriter and FileReader
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.

Pages per unit in the full BCA 104T notes
UnitPages
Unit 14 to 35 (32)
Unit 236 to 68 (33)
Unit 369 to 91 (23)
Unit 492 to 118 (27)
Total118, 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.