Quick Revision

Key Terms

• Class: Blueprint or template (reference type); groups fields/methods; no data until instantiated.
• Object: Runtime instance with its own state; variables hold references to objects.
• Method: Named behavior tied to a class/object; can read/write fields.
• Constructor: Special method that runs on new; no return type; sets initial state.
• Overloading: Same method name, different parameters; compile-time resolution.
• Overriding: Subclass replaces superclass implementation; runtime dispatch.
• Constructor Overloading: Multiple constructors with varied parameters.
• Encapsulation: Keep fields private; expose getters/setters to protect invariants.
• Inheritance: Subclass reuses/extends parent members using extends.
• Polymorphism: Supertype reference to subtype; overridden methods chosen at runtime.

Threads basics

• Q1 – Java thread: Lightweight unit of execution inside a process; multiple threads share the same process memory and run concurrently.
• Q2 – Creating a thread: Extend Thread and override run(), then call start(); or implement Runnable and pass an instance to new Thread(r).start().
• Q3 – Life cycle: NEW → RUNNABLE → RUNNING → (WAITING / TIMED_WAITING / BLOCKED) → RUNNABLE → TERMINATED via start(), scheduler, wait()/sleep()/join(), monitor lock, notify()/notifyAll(), timeout, and run() completion.

3x3 matrix operations

• Q4 – Addition: Read two 3×3 arrays; triple nested loops; C[i][j] = A[i][j] + B[i][j].
• Q5 – Multiplication: Triple nested loops; inner loop accumulates sum += A[i][k] * B[k][j], then C[i][j] = sum.
• Q6 – Subtraction: Same structure as addition; C[i][j] = A[i][j] - B[i][j].

Exception handling programs

• Q7 – SafeDivide: Wrap input and division in try–catch–finally; handle ArithmeticException (divide by zero) and InputMismatchException (non‑int), always closing Scanner.
• Q7 – ArrayAccessTest: Catch ArrayIndexOutOfBoundsException (index 0–4 only) and InputMismatchException; show friendly messages.
• Q7 – FileReadTest: Use File, Scanner, handle FileNotFoundException and generic Exception, close Scanner in finally.

Small multithreading tasks

• Q8 – 7 strings: Store in ArrayList<String>; two Runnable tasks with start indices 0 and 1, step by i += 2, sleep 200 ms between prints for interleaving.
• Q9 – 12 chars: Shared ArrayList<Character>; helper isVowel; one thread prints vowels, another consonants; skip non‑letters using Character.isLetter.
• Q10 – 10 ints (foreach): ArrayList<Integer> filled with 1..10; Runnable uses foreach and an index counter; threads distinguished by idx % 2.

SQL + JSP + threads

• Q11 – Exam table: ExamID PK, DurationMinutes CHECK (DurationMinutes > 0); JSP uses PreparedStatement to INSERT and handles SQLException in try–catch–finally; three threads print multiples of 2, 3, and 5 up to X.
• Q12 – Teacher table: TeacherID PK, Email UNIQUE; JSP selects with PreparedStatement and parameter Department; three threads print all odd numbers from 1 to X.
• Q13 – Employee table: Salary NOT NULL; JSP updates salary by EmpID using PreparedStatement; three threads print primes from 1 to X, splitting work by i % 3.

OOP design questions

• Q14 – Course + AssessmentPolicy: Base Course (id, name, instructor, isAvailable, enrollStudent()); AssessmentPolicy with calculateScore; VideoCourse returns normal percentage; TextCourse adds 5% bonus.
• Q15 – Bank system: Base Account (no, holder, balance, deposit, protected withdraw); custom InsufficientFundsException; SavingsAccount and CheckingAccount implement Transaction.performTransaction with try–catch around withdraw, and override displayInfo.
• Q16 – Course Enrollment: Base Course (id, name, maxSeats, enrolledStudents, safeEnroll() that throws IllegalStateException if full); OnlineCourse and OfflineCourse implement EnrollmentPolicy.register() with try–catch to show messages instead of crashing.

Simple threading patterns

• Q17 – Fib + primes: Two Thread subclasses; one prints first 10 Fibonacci numbers; the other prints first 10 primes.
• Q18 – Evens & odds (Runnable): Two Runnable implementations; one prints even numbers 2–20, the other prints odd numbers 1–19.
• Q19 – Numbers & letters: Two Runnable tasks; one prints numbers 1–5, the other prints letters A–E.

Important Concepts

Constructor Best Practices

• Parameter names should match field names for clarity.
• Use this.fieldName = fieldName to assign constructor parameters to fields.
• Call super() in subclass constructors to initialize parent class fields.
• Initialize subclass-specific fields after calling super().

Encapsulation

• Make fields private to prevent direct access.
• Provide public getter methods to read values.
• Provide public setter methods to modify values safely.
• Use this.fieldName in setters when parameter name matches field name.

Inheritance

• Use extends keyword to create subclass.
• Subclass inherits all public and protected members from parent.
• Subclass can add new fields and methods.
• Subclass can override parent methods.
• Use super.methodName() to call parent class methods.
• Use super() to call parent constructor.

Polymorphism

• A supertype reference can point to a subtype object.
• Method calls are resolved at runtime based on actual object type.
• Use instanceof to check object type before downcasting.
• Downcast only when necessary: SubClass obj = (SubClass) superRef.

Key Comparisons

Class vs Object

• Class: Blueprint/template; logical structure; no memory allocated.
• Object: Instance; physical entity; memory allocated when created.
• Summary: Class = Design, Object = Product

Encapsulation vs Abstraction

• Encapsulation: Data protection; hides variables; uses access modifiers.
• Abstraction: Complexity reduction; hides implementation; shows only essentials.
• Summary: Encapsulation = Security | Abstraction = Simplicity

Method Overloading vs Method Overriding

• Overloading: Same class; different parameters; compile-time resolution.
• Overriding: Parent-child classes; same signature; runtime resolution.
• Summary: Overloading → Same class | Overriding → Parent–Child classes

Inheritance vs Composition

• Inheritance: IS-A relationship; strongly coupled; uses extends.
• Composition: HAS-A relationship; loosely coupled; uses object references.
• Summary: Inheritance = Reuse by extension | Composition = Reuse by inclusion

Compile-time vs Run-time Polymorphism

• Compile-time: Method overloading; resolved at compile time; faster.
• Run-time: Method overriding; resolved at execution time; based on object type.
• Summary: Compile-time = Overloading | Runtime = Overriding

Common Patterns

Base Class Pattern

• Create base class with common attributes.
• Use private fields with getters/setters.
• Initialize all fields in constructor using this.fieldName = fieldName.

Subclass Pattern

• Extend base class using extends.
• Call super() with parent constructor parameters.
• Initialize subclass-specific fields after super().
• Override parent methods when needed.

Service Class Pattern (Polymorphism)

• Create base service class with generic method.
• Create subclass that extends service class.
• Override method to handle specific types.
• Use instanceof to check type before downcasting.
• Call specific methods after downcasting.

Important Points to Remember

• Always use this. when parameter names match field names.
• Private fields require getters/setters for access.
• Constructor parameters should match field names.
• Use super() to call parent constructor (must be first line).
• Method overriding requires same signature as parent method.
• Use @Override annotation for clarity (optional but recommended).
• instanceof checks object type before downcasting.
• Downcasting: SubClass obj = (SubClass) superRef.
• Polymorphism allows supertype reference to subtype object.
• Runtime polymorphism uses actual object type, not reference type.

Common Scenarios

Student Management

• Base class: Person (name, ID)
• Subclass: Student (adds courses, attendance)
• Service: ReportService → StudentReportService

Library System

• Base class: LibraryItem (title, year, ID)
• Subclass: Book (adds borrowCount, availability)
• Service: LibraryService → BookService

Membership Tracking

• Base class: Member (name, joinYear, ID)
• Subclass: GymMember (adds workoutHours, membershipType)
• Service: MembershipService → GymMembershipService

Course Progress

• Base class: Course (name, modules, code)
• Subclass: ProgrammingCourse (adds completedModules, difficulty)
• Service: CourseService → ProgrammingCourseService

Error Prevention Checklist

• Use String (capital S), not string.
• Match parameter names with field names in constructors.
• Use this.fieldName when assigning in constructors/setters.
• Include closing parentheses in constructors.
• Match variable names consistently (no typos like tittle vs title).
• Don't compare different types (int vs String).
• Return correct type (boolean, not String).
• Include semicolons at end of statements.
• Use proper access modifiers (private for fields, public for getters/setters).

---

IUS Preps - Your Academic Success Partner