Class Zero · The trailer for the whole course
This session runs two ways. Pick the one that matches where you're sitting — you can switch any time from the top bar.
Vasavi College of Engineering (Autonomous) · CSE · B.E. III Sem · R-24
Sixty classes and sixteen labs are coming. This one session shows you the shape of all of them — the five units we'll climb, the exam we'll beat, and the four tools on your machine that will carry you there.
THE CONTRACT
No paraphrasing here. What follows is the R-24 syllabus exactly as printed in your scheme booklet — the same text your examiners hold. Every one of the sixty classes maps back to a line on this sheet, and every word lands on screen exactly as the committee wrote it.
VASAVI COLLEGE OF ENGINEERING (AUTONOMOUS) · DEPARTMENT OF COMPUTER SCIENCE & ENGINEERING
OBJECT ORIENTED PROGRAMMING THROUGH JAVA
SYLLABUS FOR B.E. III-SEMESTER · A.Y. 2025–26 · R-24
Object Oriented System Development: Understanding Object Oriented Development, Understanding Object Concepts, Benefits of Object Oriented Development.
Java Programming Fundamentals: Introduction, Overview of Java, JVM Architecture, Data types, Variables and Arrays, Operators, Control Statements, Classes and Methods, Garbage Collection, this keyword, final, Inheritance, Method Overriding.
Classes and Interfaces: Singleton class, Abstract class, Nested class, Interface, Package.
Exception Handling: Introduction, types of exceptions, syntax of exception handling code, multiple catch statements, using finally statement, user-defined exceptions.
Multithreaded Programming: Introduction to threads, creating threads, extending the Thread class, implementing the Runnable interface, life cycle of a thread, priority of a thread, synchronization, and Inter-thread Communication, Deadlock.
StringHandling: String, StringBuffer and StringBuilder
Java.lang: Type Wrapper, Process, Runtime, Object class, Generics
IO: Java I/O Classes and Interfaces, Files and Directories, Byte and Character Streams, Serialization.
Introduction to Collection: Interfaces, Collection Classes, Iterators, List, Set, Maps, Comparator, Arrays.
Legacy Classes and Interfaces, StringTokenizer, BitSet, Date, Calendar, Random, Flow, Timer.
Lambda expressions: Expressions, Functions, lambda as argument
Stream API: Basics, Filter, Sort, Map, Collect
Regular Expressions: Pattern, Matcher, Regular expression Syntax
JAVA Beans: Architecture
THE LAB CONTRACT
Fourteen programming exercises, printed in the R-24 booklet exactly as below. Each one becomes a full lab session with prelab homework, and every printed word appears here unchanged.
VASAVI COLLEGE OF ENGINEERING (AUTONOMOUS) · DEPARTMENT OF COMPUTER SCIENCE & ENGINEERING
OBJECT ORIENTED PROGRAMMING THROUGH JAVA LAB
SYLLABUS FOR B.E. III-SEMESTER · A.Y. 2025–26 · R-24
INSTRUCTOR ADDITION — NOT PRINTED R-24 TEXTLab 0 (warm-up) and Lab 15 (integrated revision) are added by your instructor — the fourteen printed exercises above map one-to-one onto Labs 1–14. Your lab exam stays strictly on the printed list.
THE CLIMB
Each unit builds on the one before it, a little more powerful each time.
Why software needs organising, told with zero jargon — then classes, objects, Scanner, types, arrays, operators, control flow, methods and constructors.
You build your first real classes and objects.Singleton, abstract and nested classes, interfaces as contracts, packages — then the full exception-handling machinery and threads with synchronization.
Your programs learn to refuse bad data — and survive many threads at once.String, StringBuffer and StringBuilder mastery, wrappers, the Object class and generics — then files, byte and character streams, and serialization.
Your data saves itself to a file and comes back.List, Set, Map and friends, iterators, Comparable vs Comparator — and the legacy classes exams still love to ask about.
You stop reinventing data structures.Functional interfaces and lambda expressions, the Stream pipeline, regular expressions, JavaBeans — then the course close and integrated revision.
Whole questions answered in one stream pipeline.THE RHYTHM
The pattern never breaks: strictly four classes, then one lab, sixty classes and sixteen labs in all. Before every lab you'll do prelab homework in your notebook — solutions stay locked until your own attempt is written down. That's the honesty deal, and it's how the lab exam becomes routine instead of terror.
THE EXAM, DEMYSTIFIED
A 3-hour semester-end paper worth 60, plus 40 continuous internal marks. Every mark category is rehearsed inside the classes that teach its concepts.
A 3-hour lab exam worth 50, plus 30 internal. All fifteen syllabus lab exercises are practised twice — once as prelab homework, once at the machine.
Real questions from the Feb 2024 and Dec 2024 papers land inside the exact class where their concept is taught — solved fully, never dumped in an appendix.
YOUR MACHINE, READY
JDK 21 LTS
The platform itself — javac compiles, java runs. Installed together in Class 2, checked before Lab 0.
Java one line at a time — type an expression, see the answer instantly. Ships free inside the JDK; our scratchpad from day one.
Notepad++
First real programs are typed here, with zero magic between you and the compiler — Labs 0 and 1 live in this editor.
Eclipse IDE
The professional workbench, adopted from Lab 2 onward — once you've earned it by knowing what it automates.
ONE GLIMPSE — THEN WE GO
This is how every program in this course will arrive — one line per press, never a wall of code, always with its output landing live in the terminal below. Press NEXT LINE (or PgDn in teaching mode) and watch your first Java program land brace by brace, then compile and run before your eyes.
Notice the braces: every { and every } stands on its own line — Allman style. It's how all code in this course is written, because you can always see exactly where a block opens and where it closes.