1000 OOP Assignments in Java

Metadata

How to Use This Sheet

1. Solve Beginner in order if your base is weak.
2. Solve Intermediate after you are comfortable with classes, objects, constructors, encapsulation, inheritance, abstraction, and interfaces.
3. Solve Advanced strictly in order because the challenge is progressive.
4. Write code by hand.
5. Do not skip design questions. OOP skill is not only syntax.

Level 1: Beginner (300 Questions)

Classes, Objects, Fields, and Methods

1. Create a Student class with name and age fields.
2. Create two objects of Student and print their values.
3. Add a method introduce() in Student that prints student details.
4. Create a Car class with brand, model, and speed.
5. Write a method showCarInfo() inside Car.
6. Create three Car objects with different values.
7. Create a Book class with title and price.
8. Write a method in Book that prints whether the book is expensive if price > 500.
9. Create a MobilePhone class with brand, ram, and storage.
10. Write a method to display all phone details.
11. Create an Employee class with id, name, and salary.
12. Write a method to print yearly salary.
13. Create a Dog class with name and breed.
14. Add a method bark() that prints a sentence using the dog's name.
15. Create a Movie class with title, rating, and language.
16. Add a method to print whether the movie is family-friendly if rating is less than 13.
17. Create a Laptop class with brand, price, and processor.
18. Add a method to compare if the laptop price is above a given amount.
19. Create a Rectangle class with length and width.
20. Add methods area() and perimeter().
21. Create a Circle class with radius.
22. Add a method that returns the area of the circle.
23. Create a Fan class with brand, speedLevel, and isOn.
24. Add methods turnOn() and turnOff().
25. Create a Pen class with color and price.
26. Add a method to print whether the pen is premium if price is above 100.
27. Create a BankCustomer class with customerId and name.
28. Add a method to print a welcome message.
29. Create a Bus class with number, route, and seats.
30. Add a method to print whether seats are available if seats > 0.
31. Create a Shirt class with size, color, and price.
32. Add a method that prints discount eligibility if price is above 1000.
33. Create a Speaker class with brand, volume, and isBluetooth.
34. Add a method to increase volume by 1.
35. Create a Keyboard class with type, isMechanical, and price.
36. Add a method to print the keyboard category.
37. Create a Bottle class with capacity and material.
38. Add a method to print if the bottle is travel-friendly if capacity <= 1 liter.
39. Create a Course class with courseName and duration.
40. Add a method to print course summary.
41. Create a Train class with trainNumber, source, and destination.
42. Add a method printRoute().
43. Create a Song class with title, artist, and duration.
44. Add a method to print whether the song is short if duration < 3 minutes.
45. Create a Watch class with brand, type, and price.
46. Add a method to print whether the watch is digital or analog.
47. Create a Light class with isOn and watt.
48. Add methods switchOn() and switchOff().
49. Create a Mouse class with dpi, wireless, and brand.
50. Add a method to print mouse category.

Constructors

51. Create a Student class with a default constructor.
52. Print a message from inside the default constructor of Student.
53. Create a parameterized constructor for Student with name and age.
54. Create an object using the parameterized constructor and print values.
55. Create a Book class with both default and parameterized constructors.
56. Use constructor overloading in a MobilePhone class.
57. Create a Car constructor that sets default speed to 0.
58. Create a Rectangle constructor that receives length and width.
59. Write a constructor that validates price cannot be negative.
60. Create a Fan constructor that sets isOn to false by default.
61. Add a constructor to Employee that receives all fields.
62. Add a constructor to Movie that only receives title.
63. Add a constructor to Movie that receives title and rating.
64. Use this() constructor chaining in a Product class.
65. Create a Laptop class with three overloaded constructors.
66. Write a BankAccount constructor that sets balance to 0 if negative.
67. Create a Course constructor that stores course name and duration.
68. Add constructor chaining to a Circle class.
69. Create a Shirt class with constructors for different levels of initialization.
70. Add a constructor to Dog that prints the breed during creation.
71. Create a Pen class where price defaults to 10 if not passed.
72. Create a Bus class with constructor overloading for local and express buses.
73. Create a Speaker class with one constructor for wired and one for wireless.
74. Create a Bottle class that uses constructor chaining.
75. Create a Keyboard class and initialize all fields using constructor.
76. Create a Watch class with a constructor that rejects negative price.
77. Write a Light constructor that stores watt and default off state.
78. Create a Mouse constructor that takes only brand and defaults other fields.
79. Create a Song constructor that accepts title and artist only.
80. Create a Train constructor that prints source and destination.
81. Create a Student constructor that sets default grade to A.
82. Create an Employee constructor that auto-initializes salary to 10000 if omitted.
83. Create a Course constructor that validates duration > 0.
84. Create a BankCustomer constructor and print object state through a method.
85. Create a Movie constructor that rejects invalid rating.
86. Create a Rectangle class with constructor overloading for square and rectangle.
87. Create a Circle constructor that accepts integer radius and stores it as double.
88. Create a Book constructor that sets title to Unknown when null.
89. Create a Car constructor that increments a static object counter.
90. Create a Laptop constructor that initializes an object and prints a success message.
91. Write a Fan constructor that validates speed level range.
92. Create a Course constructor using this for field assignment.
93. Create a MobilePhone constructor using constructor chaining for common defaults.
94. Create a Bottle constructor that supports two capacities.
95. Create a Bus constructor that sets seats to 40 if not passed.
96. Create a Speaker class where one constructor calls another with default volume.
97. Create an Employee constructor that stores name in uppercase.
98. Create a Student constructor that prevents negative age.
99. Create a Train constructor that stores route code.
100. Create a Watch constructor that prints whether the object is premium during creation.

this, Instance State, and Validation

101. Create a Student constructor that uses this.name = name.
102. Create a Product class where field and parameter names are same, then resolve using this.
103. Create a Book class with this() constructor chaining.
104. Create a BankAccount class with this.balance.
105. Create a Car method setSpeed(int speed) and use this.speed.
106. Create a Laptop class and return this from a method.
107. Create a Rectangle class with method chaining for setting length and width.
108. Create a Circle method increaseRadius(double value) and use this.
109. Create a Dog method rename(String name) using this.
110. Create a MobilePhone method that returns current object after setting storage.
111. Create a Fan method to set speed level and return this.
112. Create a Watch method to update price only if positive.
113. Create a Speaker method to update volume only if between 0 and 100.
114. Create a Student method that prevents age from exceeding 100.
115. Create a BankAccount method deposit(double amount) with validation.
116. Create a BankAccount method withdraw(double amount) with validation.
117. Create a Pen method to update price only if positive.
118. Create a Bottle method to update capacity only if valid.
119. Create an Employee method to raise salary by a positive percentage.
120. Create a Movie method to update rating only if between 0 and 10.
121. Create a Bus method to reserve one seat if available.
122. Create a Train method to change destination and return this.
123. Create a Course method to extend duration by a given number of days.
124. Create a Keyboard method to mark keyboard as mechanical.
125. Create a Mouse method to change DPI safely.
126. Create a Light method toggle() using current object state.
127. Create a Song method to rename song using this.
128. Create a Car method to accelerate by given amount.
129. Create a Car method to brake without letting speed go below 0.
130. Create a Student method to print current object hash code.
131. Create a Product method that compares price of current object with another product.
132. Create a Rectangle method that compares area with another rectangle.
133. Create a Circle method that returns true if current circle is larger than another.
134. Create a Dog method that copies breed from another dog.
135. Create a Book method that copies price from another book.
136. Create a Laptop method to upgrade RAM by given GB.
137. Create an Employee method to reset salary to base value.
138. Create a Speaker method to mute and return current object.
139. Create a Watch method that doubles price only if luxury flag is true.
140. Create a MobilePhone method to combine storage upgrade and RAM upgrade.
141. Create a Student method to update both name and age.
142. Create a Train method to swap source and destination.
143. Create a Bottle method to mark bottle as reusable.
144. Create a Bus method to refill seat count for next trip.
145. Create a Movie method to reset rating.
146. Create a Light method that changes watt value only if above 0.
147. Create a Pen method that marks pen as out of stock.
148. Create a Course method to mark course completed.
149. Create a BankCustomer method to update mobile number with validation.
150. Create a Keyboard method that returns this for chained configuration.

Encapsulation and Access Modifiers

151. Create a BankAccount class with private balance.
152. Add a public getter for balance.
153. Add a public deposit method for BankAccount.
154. Prevent direct access to balance from main.
155. Create a User class with private password.
156. Add a setter that stores password only if length >= 8.
157. Add a getter for username but not for password.
158. Create an Employee class with private salary.
159. Add a public method showSalary() instead of direct getter.
160. Create a Student class with private marks.
161. Add a method that updates marks only if between 0 and 100.
162. Create a Movie class with private rating.
163. Add getter and validated setter for rating.
164. Create a Car class with private speed.
165. Add methods accelerate() and brake() instead of exposing speed setter.
166. Create a Circle class with private radius.
167. Add a constructor and getter for radius.
168. Prevent negative radius through constructor validation.
169. Create a Product class with private price.
170. Add a method to apply percentage discount.
171. Create a Fan class with private speedLevel.
172. Add methods to increase and decrease speed safely.
173. Create a BankCustomer class with private customerId and no setter.
174. Explain in code why customerId should not be changeable.
175. Create a Light class with private isOn.
176. Expose only switchOn, switchOff, and isLightOn.
177. Create a Bottle class with private capacity.
178. Add a setter that accepts only positive values.
179. Create a Course class with private courseName.
180. Add public method to rename course if non-empty.
181. Create a Bus class with private seats.
182. Add a method to decrement seat count when booking.
183. Create a Train class with private routeCode.
184. Add getter but no setter for route code.
185. Create a Watch class with private price.
186. Add method to apply tax and return final price.
187. Create a Speaker class with private volume.
188. Expose only safe methods for volume control.
189. Create a Laptop class with private ram.
190. Add method upgradeRam(int extra).
191. Create a Mouse class with private dpi.
192. Add a getter and validated setter.
193. Create a Keyboard class with private isMechanical.
194. Add a getter named isMechanical().
195. Create a Pen class with private stock.
196. Add method to reduce stock on sale.
197. Create a Song class with private duration.
198. Add a getter and a method to extend duration for remix.
199. Create a Book class with private title.
200. Add method to print uppercase title.

Static Members

201. Create a Car class with static field totalCars.
202. Increment totalCars every time an object is created.
203. Print total objects created after making three Car objects.
204. Create a Student class with static field schoolName.
205. Print the same schoolName from two student objects.
206. Change schoolName once and show the effect on all objects.
207. Create a Book class with static method libraryPolicy().
208. Call static method using class name.
209. Create an Employee class with static field companyName.
210. Create a static method changeCompanyName.
211. Create a BankAccount class with static interest rate.
212. Print simple interest using static rate and instance balance.
213. Create a Circle class with static method piValue().
214. Create a Product class with static tax rate.
215. Create a Fan class with static field counting running fans.
216. Increment and decrement static count when turning fan on or off.
217. Create a Train class with static field transportType = "Rail".
218. Create a Bus class with static field transportType = "Road".
219. Create a Laptop class with static field warrantyYears.
220. Update warranty years and show change across objects.
221. Create a Speaker class with static constant MAX_VOLUME.
222. Use MAX_VOLUME in volume validation.
223. Create a Watch class with static field brandCount.
224. Create a static method to print number of created watches.
225. Create a Mouse class with static utility method isGamingDpi(int dpi).
226. Create a Keyboard class with static method to compare two prices.
227. Create a Bottle class with static method converting liters to milliliters.
228. Create a Course class with static field platformName.
229. Create a Movie class with static method to validate rating.
230. Create a Pen class with static field manufacturer.
231. Create a Song class with static method to convert minutes to seconds.
232. Create a Student class with both static and instance fields and print both.
233. Create an Employee class with static initialization of company policy text.
234. Create a BankCustomer class with static method to validate phone number length.
235. Create a Car class with static method compareBrands(Car a, Car b).
236. Create a Bus class with static fare rate per km.
237. Create a Train class with static field for current fiscal year.
238. Create a Course class with static counter for total enrollments.
239. Create a Book class with static discount rate for all books.
240. Create a Laptop class with static method to print common configuration tips.
241. Create a MobilePhone class with static method to format IMEI.
242. Create a Circle class with static method to create a unit circle.
243. Create a Rectangle class with static helper to make square.
244. Create a Fan class with static method to validate speed level.
245. Create a Light class with static unit conversion for watts to kilowatts.
246. Create a Speaker class with static method to test if volume is safe.
247. Create a Watch class with static method to compare two models.
248. Create a Mouse class with static field for default DPI.
249. Create a Keyboard class with static field for default key count.
250. Create a Pen class with static factory-like method returning a blue pen.

Inheritance Basics

251. Create a parent class Animal and child class Dog.
252. Add eat() in Animal and bark() in Dog.
253. Create an object of Dog and call both methods.
254. Create parent Vehicle and child Car.
255. Add start() in Vehicle and openTrunk() in Car.
256. Create parent Person and child Student.
257. Add common fields in Person and student-specific field in Student.
258. Create parent Employee and child Manager.
259. Add common method work() in Employee.
260. Add specific method conductMeeting() in Manager.
261. Create parent Shape and child Rectangle.
262. Add parent displayType() and child-specific area().
263. Create parent Appliance and child Fan.
264. Add turnOn() in parent and changeSpeed() in child.
265. Create parent Account and child SavingsAccount.
266. Add balance field in parent and interestRate in child.
267. Create parent Book and child TextBook.
268. Add subject field in child.
269. Create parent Mobile and child SmartPhone.
270. Add internet-specific method in child.
271. Create parent Employee and child Developer.
272. Add coding hours field in Developer.
273. Create parent Furniture and child Chair.
274. Add fold feature in child.
275. Create parent Machine and child Printer.
276. Add printDocument() in child.
277. Create parent Payment and child CardPayment.
278. Add parent field amount and child field cardNumber.
279. Create parent Animal and child Cat.
280. Add meow() in child.
281. Create parent Device and child Laptop.
282. Add compileCode() in child.
283. Create parent Shape and child Circle.
284. Create parent User and child Admin.
285. Add manageUsers() in Admin.
286. Create parent Transport and child Bus.
287. Add openDoor() in child.
288. Create parent Worker and child Teacher.
289. Add teach() in child.
290. Create parent Account and child CurrentAccount.
291. Add transaction charge field in child.
292. Create parent Media and child Song.
293. Add singer field in child.
294. Create parent Course and child ProgrammingCourse.
295. Add language field in child.
296. Create parent Game and child Chess.
297. Add movePiece() in child.
298. Create parent Building and child School.
299. Add conductAssembly() in child.
300. Create parent FoodItem and child Pizza.

Level 2: Intermediate (300 Questions)

Inheritance, super, Overriding, and Runtime Behavior

301. Create Animal and Dog, then use super to initialize parent fields.
302. Create Vehicle and Car, then call parent constructor with super.
303. Override a method sound() in child class Dog.
304. Override a method start() in child class Car.
305. Create Employee and Developer, override calculateSalary().
306. Create Shape hierarchy and override area() in each child.
307. Create Account and SavingsAccount, override showAccountType().
308. Create Book and TextBook, override displayInfo().
309. Create Payment and CardPayment, override process().
310. Create Mobile and SmartPhone, override showSpecs().
311. Create Media and Song, override play().
312. Create Furniture and Chair, override showMaterial().
313. Create Game and Chess, override startGame().
314. Create Appliance and Fan, override powerConsumption().
315. Create Worker and Teacher, override work().
316. Create User and Admin, override login().
317. Create Transport and Bus, override showFare().
318. Create Course and ProgrammingCourse, override showSyllabus().
319. Create Building and School, override showPurpose().
320. Create FoodItem and Pizza, override prepare().
321. Create parent Message and child EmailMessage, override send().
322. Create parent Discount and child FestivalDiscount, override apply().
323. Create parent Sensor and child TemperatureSensor, override readValue().
324. Create parent Report and child PdfReport, override generate().
325. Create parent Player and child CricketPlayer, override play().
326. Create parent Subscription and child PremiumSubscription, override price().
327. Create parent Question and child MCQQuestion, override display().
328. Create parent Room and child ClassRoom, override showUsage().
329. Create parent HospitalStaff and child Doctor, override performDuty().
330. Create parent Machine and child WashingMachine, override operate().
331. Create Animal a = new Dog() and call overridden method.
332. Create Vehicle v = new Car() and call overridden start().
333. Store a Developer object in Employee reference and call calculateSalary().
334. Demonstrate runtime polymorphism using Shape array.
335. Demonstrate runtime polymorphism using Payment array.
336. Create a loop over Animal[] containing Dog and Cat objects.
337. Show that fields are not polymorphic but methods are.
338. Override method and call parent version using super.methodName().
339. Create child method that extends parent behavior instead of replacing it completely.
340. Override toString() in a child class.

Encapsulation, Class Design, and Validation

341. Design a BankAccount with private state and strict withdraw validation.
342. Design a Student class where marks update must stay within 0 to 100.
343. Design a Product class where price cannot be negative.
344. Design an Employee class where ID is immutable after object creation.
345. Design a Movie class where rating can change but title cannot.
346. Design a Rectangle class where dimensions must always remain positive.
347. Design a Circle class with controlled radius growth only.
348. Design a User class where password is write-only and validated.
349. Design a Course class where completed course cannot reduce duration.
350. Design a Bus class where booked seats cannot exceed total seats.
351. Design a TrainTicket class where cancellation is blocked after travel date.
352. Design a Laptop class where RAM can only be upgraded, not downgraded.
353. Design a MobilePhone class where IMEI cannot change after construction.
354. Design a Book class where ISBN is read-only.
355. Design a Speaker class where volume range is 0 to 100.
356. Design a Watch class where price update logs old and new values.
357. Design a Mouse class with validated DPI range.
358. Design a Keyboard class where key count cannot be less than 60.
359. Design a Pen class with stock that cannot go below zero.
360. Design a Bottle class where capacity must be in milliliters and positive.
361. Design an Order class with private status and controlled transitions.
362. Design a Task class with restricted priority values.
363. Design an Invoice class with immutable invoice number.
364. Design a Customer class with controlled email updates.
365. Design a Flight class where seats and fare are validated.
366. Design a LibraryMember class where membership status is internally controlled.
367. Design a Reservation class where confirmation only happens once.
368. Design a Wallet class with deposit and spend rules.
369. Design a Quiz class where marks are recalculated through methods only.
370. Design a Loan class where interest cannot be negative.

Abstract Classes and Interfaces

371. Create an abstract class Shape with abstract method area().
372. Implement Circle and Rectangle using abstract Shape.
373. Create an abstract class Payment with abstract processPayment().
374. Implement CardPayment and UpiPayment from Payment.
375. Create an interface NotificationSender with method send.
376. Implement EmailSender and SmsSender.
377. Create an interface Playable and implement it in Song.
378. Create an interface Flyable and implement it in Bird.
379. Create an abstract class Employee and derive Developer and Manager.
380. Create abstract class Appliance with common field brand.
381. Implement Fan and WashingMachine from abstract Appliance.
382. Create an interface DiscountStrategy with applyDiscount.
383. Implement NoDiscount, StudentDiscount, and FestivalDiscount.
384. Create an abstract class Report with method generate.
385. Implement PdfReport and ExcelReport.
386. Create an interface Logger and implement ConsoleLogger.
387. Implement FileLogger for same Logger interface.
388. Create an abstract class Vehicle with abstract fuelType.
389. Implement PetrolCar and ElectricCar.
390. Create an interface Searchable and implement it in BookCatalog.
391. Create an abstract class Account with abstract calculateInterest.
392. Implement SavingsAccount and FixedDepositAccount.
393. Create an interface Taxable and implement it in Product.
394. Create an abstract class GameCharacter with abstract attack.
395. Implement Warrior and Mage.
396. Create an interface Exportable and implement in CsvExporter.
397. Implement JsonExporter for same Exportable interface.
398. Create an abstract class Message with concrete validateRecipient.
399. Implement EmailMessage and SmsMessage.
400. Create an interface AuthenticationProvider and implement two providers.
401. Create abstract class ExamQuestion and subclasses for text and code questions.
402. Create an interface Cache and implement MemoryCache.
403. Create RedisCache class for same Cache interface.
404. Create abstract class Notification with abstract deliver.
405. Create interface Payable and make multiple unrelated classes implement it.
406. Create a class implementing two interfaces.
407. Create an interface with default method and override it in implementation.
408. Create an interface with static utility method and call it via interface name.
409. Compare abstract class and interface in one mini-system.
410. Create a Device abstraction and model behavior using both abstract class and interface.

Composition and Object Collaboration

411. Create a Car class that contains an Engine object.
412. Create a Computer class that contains Keyboard and Monitor.
413. Create a Library class that contains multiple Book objects.
414. Create a School class that contains multiple Student objects.
415. Create an Order class that contains multiple Product objects.
416. Create a Playlist class that contains multiple Song objects.
417. Create a Team class that contains multiple Player objects.
418. Create a Wallet class that contains multiple Transaction objects.
419. Create a Course class that contains multiple Lesson objects.
420. Create a Hospital class that contains multiple Doctor objects.
421. Create a Department class that holds employees and prints headcount.
422. Create a Company class containing departments and employees.
423. Create a Cart class with methods to add and remove products.
424. Create a ReportService that uses a Logger.
425. Create an OrderService that uses a NotificationSender.
426. Create a PaymentService that uses a PaymentGateway.
427. Create a StudentService that uses a StudentRepository.
428. Create a TicketService that uses a PricingStrategy.
429. Create a VideoPlayer that uses a SubtitleRenderer.
430. Create a RestaurantOrder that uses a BillCalculator.
431. Create a UserProfile that contains an Address value object.
432. Create a TravelPlan that contains multiple CityStop objects.
433. Create a ChessGame class that contains Board and Player objects.
434. Create a CabTrip that contains Driver, Rider, and FarePolicy.
435. Create a FoodDeliveryOrder that uses a DeliveryPartner.
436. Create a BlogPost that contains multiple Comment objects.
437. Create a ChatRoom that contains many Message objects.
438. Create a MovieTicketBooking that uses SeatAllocator.
439. Create a ParkingLot that contains ParkingSlot objects.
440. Create a Bank class that manages many BankAccount objects.

Method Overloading, Overriding, and Object Utility Methods

441. Overload add() for two integers and three integers.
442. Overload add() for int and double.
443. Overload printDetails() with different parameters.
444. Overload calculateArea() for square and rectangle.
445. Overload login() with username-password and mobile-OTP.
446. Overload setData() for different field combinations.
447. Overload constructor and also overload a behavior method in same class.
448. Override toString() in Student.
449. Override equals() in Student based on ID.
450. Override hashCode() consistently with equals().
451. Override toString() in Product and print object directly.
452. Override equals() in Book based on ISBN.
453. Override toString() in BankAccount.
454. Override toString() in Employee hierarchy and print polymorphically.
455. Override a method and call super before child logic.
456. Override a method and call super after child logic.
457. Create overloaded pay() methods with different signatures.
458. Create overloaded search() methods for id and name.
459. Create overloaded notifyUser() methods for email and SMS text.
460. Create overloaded bookSeat() methods for one seat and many seats.
461. Create overloaded deposit() methods for int and double.
462. Create overloaded withdraw() methods with and without remarks.
463. Create a class where overloading would cause ambiguity and resolve it.
464. Show invalid overloading by changing only return type and explain why.
465. Create parent-child classes and override display() correctly.
466. Create parent-child classes and intentionally break override using different parameters.
467. Use @Override annotation to catch override mistakes.
468. Create a class with overloaded build() methods returning different configured objects.
469. Create a child class that overrides calculate() and narrows behavior correctly.
470. Create utility class demonstrating toString, equals, and hashCode together.

Scenario-Based Intermediate Assignments

471. Design a LibraryBook system with borrow and return methods.
472. Design a BusPass system with validity and renewal behavior.
473. Design a StudentReportCard with subject marks and grade methods.
474. Design a FoodOrder with item count and billing logic.
475. Design a ShoppingCart with add, remove, and total methods.
476. Design an ATM model with withdraw, deposit, and balance inquiry.
477. Design a MovieBooking object with seat confirmation logic.
478. Design a FlightTicket model with cancel and reschedule rules.
479. Design a HotelRoom booking model with availability updates.
480. Design a GymMembership class with active and expired states.
481. Design a VehicleInsurance class with premium calculation.
482. Design a LoanApplication class with approval eligibility logic.
483. Design a QuizAppQuestion hierarchy with text and MCQ questions.
484. Design a RestaurantTableBooking class with reservation status changes.
485. Design a CourierPackage class with tracking status and fee.
486. Design a RideBooking model with fare and trip status.
487. Design a CinemaSeat class with lock and book actions.
488. Design a WarehouseItem with stock and reorder threshold.
489. Design a LibraryMember class with fine calculation.
490. Design an ECommerceProductReview class with rating validation.
491. Design a ClassroomAttendance class with present and absent counters.
492. Design a TournamentTeam class with wins, losses, and points.
493. Design a MusicPlaylist class with play next and remove song behavior.
494. Design a TaskManagerItem with state transitions.
495. Design a PrinterQueueJob model with queued, printing, and done states.
496. Design a TrainReservation class with RAC and waiting list states.
497. Design an InventoryMovement class with incoming and outgoing stock.
498. Design a FoodCoupon system using discount strategy objects.
499. Design a DocumentApproval workflow using status checks.
500. Design a CustomerSupportTicket with escalation behavior.
501. Design a BlogPost and Comment model with ownership rules.
502. Design a ParkingTicket system with time-based billing.
503. Design a CabDriver payout model with per-trip earnings.
504. Design a Medicine class with expiry-date validation.
505. Design a HospitalAppointment class with scheduling logic.
506. Design a MealPlan class with calorie calculations.
507. Design a ShoppingCoupon hierarchy with fixed and percentage discounts.
508. Design a NotificationCenter that supports multiple senders.
509. Design a UserSession class with login, logout, and timeout.
510. Design a TaxCalculator strategy-based system.

Mini Projects and Refactoring Questions

511. Refactor a student record program with raw variables into a Student class.
512. Refactor a product billing program into Product and Bill classes.
513. Refactor a banking script into encapsulated BankAccount.
514. Refactor a marks calculator into Student, Subject, and ReportCard.
515. Refactor a ticket booking script using classes and methods.
516. Refactor a restaurant bill calculator using object collaboration.
517. Refactor a print-all-in-main program into multiple classes.
518. Refactor a repeated-discount code block into discount strategy classes.
519. Refactor a large if-else payment selection into polymorphism.
520. Refactor duplicated Dog and Cat code into inheritance.
521. Refactor a Vehicle hierarchy that wrongly duplicates speed code.
522. Refactor a public-field Employee design into encapsulated design.
523. Refactor a class with too many setters into safer design.
524. Refactor a class with mixed responsibilities into two cohesive classes.
525. Refactor a GodService that handles orders, payment, and notifications.
526. Refactor a loyalty discount logic into an interface-based solution.
527. Refactor a file export utility into separate exporter classes.
528. Refactor a system that uses instanceof everywhere into polymorphism.
529. Refactor an immutable value object that currently has setters.
530. Refactor an inheritance design that should really use composition.
531. Refactor a chat app model where message sending is hardcoded.
532. Refactor a report generator to support PDF and CSV exporters.
533. Refactor a login system to support multiple authentication providers.
534. Refactor a direct-email dependency into interface-based notification.
535. Refactor a shopping cart to use CartItem objects instead of parallel arrays.
536. Refactor an exam system where all question types live in one huge class.
537. Refactor a game character class into parent and specialized child classes.
538. Refactor a device system to avoid repeated validation logic.
539. Refactor an invoice model to introduce a value object for money.
540. Refactor a library management model to protect book status changes.

Progressive Intermediate Challenge Set

541. Build a LibrarySystem with books, members, and issue logic.
542. Extend the LibrarySystem with fine calculation.
543. Extend the LibrarySystem with separate item types: book, magazine, journal.
544. Build an OrderSystem with products and order total.
545. Extend the OrderSystem with discount strategies.
546. Extend the OrderSystem with notification sending.
547. Build an EmployeePayroll hierarchy with salary overrides.
548. Extend EmployeePayroll with bonus policies.
549. Extend EmployeePayroll with tax calculation abstraction.
550. Build a ParkingLot with slots and parked vehicles.
551. Extend ParkingLot with different vehicle types.
552. Extend ParkingLot with ticket calculation rules.
553. Build a QuizSystem with multiple question types.
554. Extend QuizSystem with scoring strategies.
555. Extend QuizSystem with report export support.
556. Build a FoodDelivery model with restaurant, menu item, and order.
557. Extend FoodDelivery with coupon strategy support.
558. Extend FoodDelivery with delivery-partner assignment.
559. Build a HospitalManagement mini-model with doctor, patient, appointment.
560. Extend it with billing logic.
561. Extend it with notification reminders.
562. Build a RideBooking model with rider, driver, and trip.
563. Extend it with fare strategies.
564. Extend it with trip cancellation policies.
565. Build a SchoolSystem with student, teacher, classroom.
566. Extend it with attendance tracking.
567. Extend it with exam result generation.
568. Build a MovieBookingSystem with seat, screen, show.
569. Extend it with payment abstraction.
570. Extend it with ticket cancellation rules.
571. Build a WarehouseSystem with items and stock changes.
572. Extend it with supplier tracking.
573. Extend it with reorder alert logic.
574. Build a GymManagement system with member, plan, trainer.
575. Extend it with attendance log objects.
576. Extend it with plan-upgrade rules.
577. Build a MusicApp model with playlist and song objects.
578. Extend it with shuffle logic.
579. Extend it with favorite song tracking.
580. Build an ATMSystem with account operations and transaction history.
581. Extend it with transaction type hierarchy.
582. Extend it with receipt generation.
583. Build an InsurancePolicy model.
584. Extend it with policy type hierarchy.
585. Extend it with claim processing abstraction.
586. Build a TravelBooking model with traveler, ticket, hotel.
587. Extend it with cancellation rules.
588. Extend it with invoice generation.
589. Build an ECommerceReview system.
590. Extend it with moderation workflow.
591. Extend it with report abuse behavior.
592. Build a DocumentWorkflow model.
593. Extend it with approval roles.
594. Extend it with notification channels.
595. Build a CabFleet system with vehicles and availability.
596. Extend it with driver rating logic.
597. Extend it with maintenance status support.
598. Build a RestaurantBilling system.
599. Extend it with tax and discount policies.
600. Extend it with multiple payment modes.

Level 3: Advanced (400 Questions)

Important Note for Advanced Level

Questions 601 to 1000 are intentionally ordered from lower advanced difficulty to highest advanced difficulty. Do not solve them randomly if your goal is real growth.

Advanced Stage 1: Strong OOP Implementation and Design Reasoning (601-700)

601. Design a Money value object that is immutable and supports safe addition only for same currency.
602. Add subtraction support to Money while preventing negative results when business rule disallows it.
603. Add comparison methods to Money and define logical equality correctly.
604. Override equals, hashCode, and toString for Money.
605. Design an immutable EmailAddress value object that validates format at construction time.
606. Design an immutable DateRange object that rejects invalid start-end order.
607. Add overlap detection to DateRange.
608. Add containment checks to DateRange.
609. Design a Percentage value object that only allows 0 to 100.
610. Use Percentage inside a discount system instead of raw doubles.
611. Design a UserId value object and replace raw String IDs in a user model.
612. Design an immutable Address object and embed it inside Customer.
613. Design a mutable ShoppingCart that only accepts valid CartItem objects.
614. Prevent duplicate product entries in ShoppingCart by merging quantities.
615. Add total price calculation to ShoppingCart.
616. Add remove and decrement behaviors to ShoppingCart.
617. Introduce a PricingPolicy abstraction into ShoppingCart.
618. Add coupon application without modifying core cart logic directly.
619. Design CartItem so quantity can never become zero or negative.
620. Design a ProductCatalog class that exposes safe lookup operations but not internal storage directly.
621. Design a StudentRegistry that prevents duplicate roll numbers.
622. Add update behavior to StudentRegistry without exposing raw collection state.
623. Design an ExamResult object that computes grade lazily or eagerly and justify your choice.
624. Design a TransactionHistory class that records deposits and withdrawals as separate objects.
625. Add a rule that every transaction must carry timestamp and type.
626. Design a BankStatement report object from TransactionHistory.
627. Separate bank domain entities from report-generation concerns.
628. Design a PasswordPolicy abstraction and inject it into UserRegistrationService.
629. Implement two password policies and switch them without changing registration flow.
630. Design a LoginAttemptTracker with locked-state rules.
631. Prevent state corruption in LoginAttemptTracker under repeated failed attempts.
632. Design a CourseEnrollment object linking student and course with enrollment status.
633. Add state transitions such as enrolled, completed, dropped, and rejected.
634. Ensure invalid transitions are blocked.
635. Design a RoomBooking model that rejects overlapping bookings.
636. Separate booking validation from persistence concerns.
637. Design a SeatAllocator abstraction for theater booking.
638. Implement two seat-allocation strategies and switch them polymorphically.
639. Design a TaxPolicy abstraction for products of different categories.
640. Add country-specific tax calculation without rewriting product model.
641. Design a ShippingChargePolicy abstraction.
642. Combine TaxPolicy and ShippingChargePolicy in a checkout flow.
643. Design a Bill object that keeps line items immutable after generation.
644. Prevent recalculation bugs by freezing bill totals after confirmation.
645. Design a RefundRequest lifecycle model.
646. Add approval and rejection transitions to RefundRequest.
647. Design a SupportTicket model that tracks assignment and escalation cleanly.
648. Add comments to SupportTicket using composition.
649. Separate comment author identity from comment content through value objects.
650. Design a RideFareCalculator abstraction with multiple pricing modes.
651. Add surge pricing without modifying core ride entity.
652. Add coupon support on top of fare calculation.
653. Design a SubscriptionPlan hierarchy and explain where inheritance is justified.
654. Replace an incorrect SubscriptionPlan inheritance design with composition.
655. Design a NotificationTemplate system with different renderers.
656. Create renderer abstraction for email, SMS, and push formatting.
657. Prevent channel-specific logic from leaking into template model.
658. Design a PaymentReceipt object with immutable state.
659. Add a ReceiptFormatter abstraction and multiple implementations.
660. Design an AuditLog class that is append-only.
661. Prevent edits to historical log entries.
662. Design a FeatureFlag object that supports controlled evaluation.
663. Separate flag evaluation rules from flag storage.
664. Design a LibraryLoan object that tracks due date and renewal rules.
665. Prevent renewal after max renewal count.
666. Design a PenaltyPolicy abstraction for overdue items.
667. Add different penalties for book, DVD, and journal loans.
668. Design a VehicleAssignment model linking driver and cab.
669. Prevent assigning one active cab to multiple drivers at once.
670. Design a BatchProcessor that applies a common interface to many tasks.
671. Add result aggregation while keeping task interface small.
672. Design an ImportJob state machine with pending, running, failed, completed.
673. Prevent illegal state transitions in ImportJob.
674. Design a DocumentVersion model with immutable revisions.
675. Add a Document aggregate that owns versions safely.
676. Design a Leaderboard object that maintains top scores.
677. Prevent direct score tampering by exposing only update methods.
678. Design a StudentAttendancePolicy abstraction.
679. Implement strict and relaxed attendance policies.
680. Design a FeeCalculator using strategy objects.
681. Add scholarship policy composition to FeeCalculator.
682. Design a PromoCode domain model with expiration and usage rules.
683. Prevent reusing single-use promo codes.
684. Design a ParkingSession with entry time, exit time, and fee calculation.
685. Separate fee calculation from parking session entity.
686. Design a ReservationStatus model that avoids stringly typed code.
687. Replace raw status strings with enum-based or object-based modeling.
688. Design a QuestionBank class that groups question objects by topic.
689. Add polymorphic question evaluation without giant if-else chains.
690. Design a ChatMessage hierarchy and justify what should be common parent state.
691. Prevent a ChatRoom from exposing internal mutable message storage.
692. Design an InvoiceNumberGenerator with uniqueness guarantee at object level.
693. Separate identifier generation from invoice behavior.
694. Design an InventoryReservation object.
695. Prevent selling inventory already reserved by another order.
696. Design a GradePolicy abstraction.
697. Implement grade calculation by marks, percentile, and relative ranking.
698. Design a TranslationService abstraction with swappable providers.
699. Build a small cohesive model around Order, OrderLine, and Money.
700. Refactor that small order model to improve immutability and responsibility boundaries.

Advanced Stage 2: Polymorphism, Interfaces, and Behavior-Centric Design (701-800)

701. Design a report-export system where adding a new format requires zero changes to existing exporters.
702. Add PDF, CSV, and JSON exporters using interface-based design.
703. Introduce a common export coordinator that depends only on abstraction.
704. Design a command-processing system where each command is its own object.
705. Add undo capability to the command system.
706. Separate command validation from command execution.
707. Design a payment processing pipeline with validation, execution, and notification stages.
708. Keep the pipeline open for new payment methods without modifying coordinator logic.
709. Model a RuleEngine where each rule can approve or reject an input object.
710. Add rule composition using AND and OR combinations.
711. Design a PricingEngine where pricing rules are pluggable.
712. Add customer-tier pricing, coupon pricing, and seasonal pricing together.
713. Resolve rule ordering problems without hardcoded if-else chains.
714. Design a SearchFilter abstraction for product filtering.
715. Add category, price-range, and rating filters.
716. Allow combining filters dynamically.
717. Design a Serializer interface with implementations for XML, JSON, and plain text.
718. Introduce a service that works with any Serializer.
719. Design a StorageService abstraction for local, cloud, and in-memory storage.
720. Ensure calling code does not know storage implementation details.
721. Design a NotificationChannel hierarchy and add retry rules.
722. Separate message formatting from message sending.
723. Design a game skill system using object hierarchies or interfaces.
724. Add cooldown behavior without tightly coupling skill logic to player logic.
725. Introduce effect stacking rules through composition.
726. Design a discount engine that supports chained discounts with clear rules.
727. Prevent invalid discount combinations through policy objects.
728. Design an achievement system where each achievement is evaluated independently.
729. Add polymorphic conditions for time-based and event-based achievements.
730. Design a WorkflowStep abstraction for approval flows.
731. Create multiple steps and a coordinator that only depends on the step contract.
732. Add rollback or compensation behavior to failed workflow steps.
733. Design a ReportScheduler that runs different report tasks polymorphically.
734. Add result notification without mixing scheduler and notifier responsibilities.
735. Design an AuthenticationFlow where multiple strategies exist for login.
736. Add password login, OTP login, and OAuth-style placeholder login.
737. Ensure controller logic depends on abstraction only.
738. Design a FraudCheck pipeline for transactions.
739. Add velocity, amount, and device-based checks as interchangeable rules.
740. Design a classroom evaluation system where question type drives grading behavior.
741. Avoid type checking in grading logic.
742. Design a tax engine with composable policies and exemption rules.
743. Add a country-specific adapter layer without breaking existing tax abstractions.
744. Design a DocumentParser interface and create multiple parser implementations.
745. Add a coordinator that chooses parser based on document type cleanly.
746. Design a file-upload validation system using rule abstractions.
747. Add size, type, and virus-scan rules without giant controller logic.
748. Design a workflow where OrderService depends on InventoryChecker, PaymentProcessor, and Notifier.
749. Replace direct concrete dependencies with abstractions.
750. Demonstrate how test doubles become easier with this design.
751. Design an event-listener style interface for user actions.
752. Add multiple listeners without changing source event producer.
753. Design a PromotionEligibility system.
754. Add employee-based, purchase-count-based, and referral-based eligibility rules.
755. Design a RecommendationStrategy abstraction.
756. Add popular-item, recent-item, and similarity-based dummy strategies.
757. Design a QuestionEvaluationStrategy abstraction for coding platform questions.
758. Separate code execution result parsing from final score calculation.
759. Design a CachePolicy abstraction with eviction strategies.
760. Add LRU-like placeholder and no-eviction strategy behaviorally.
761. Design a booking confirmation system with channel-specific confirmation senders.
762. Ensure new channels do not require editing booking logic.
763. Design a mini game engine loop that calls polymorphic update() on entities.
764. Add player, enemy, and projectile entities without type checks.
765. Design a stateful MediaPlayer model and then refactor it into state-like behavior objects.
766. Design a PaymentFailureHandler abstraction.
767. Add different failure responses based on failure type.
768. Design a scheduler with task priorities using behavior-rich task objects.
769. Add logging decorators around task execution.
770. Design a DocumentFormatter abstraction for resume generation.
771. Add section-level formatters through composition.
772. Design a ShippingProvider abstraction with cost and ETA methods.
773. Add two providers and a service that compares them.
774. Design a RideMatchingStrategy abstraction.
775. Add nearest-driver and least-busy-driver strategies.
776. Design a DeliverySlotAllocator abstraction.
777. Add different slot-selection policies.
778. Design a fraud alert notification design using abstraction, composition, and strategy.
779. Build a reusable policy-driven validation framework using interfaces.
780. Add short-circuit evaluation rules to that framework.
781. Design a DocumentSigner abstraction.
782. Add manual and auto-sign signer implementations.
783. Build a FormFieldValidator framework with one validator per rule.
784. Add aggregation of errors without hardwiring validation logic.
785. Design a SurveyQuestion hierarchy with rendering and answer validation.
786. Add text, MCQ, checkbox, and rating questions.
787. Build a polymorphic Shape editor that can draw and resize objects without instanceof.
788. Extend it with grouping behavior while keeping responsibilities clear.
789. Design a TravelFareStrategy system that supports train, bus, cab, and flight placeholders.
790. Ensure route planner depends on abstraction only.
791. Design a RuleBasedMessageRouter using condition and handler abstractions.
792. Add route branching without nested conditional complexity.
793. Design a DeviceHealthCheck system with pluggable checks.
794. Add CPU, memory, disk, and network checks.
795. Design a TransactionProcessor with pluggable steps and handlers.
796. Make it testable without real gateway or notifier.
797. Design an interview-grade ParkingLot abstraction for vehicle type pricing.
798. Add polymorphic parking fee calculation and slot assignment.
799. Refactor a large billing if-else into strategy and policy objects.
800. Refactor a role-based access check into capability-based abstractions.

Advanced Stage 3: Composition, Aggregates, State, and Robust Domain Modeling (801-900)

801. Design an Order aggregate root that owns OrderLine objects and protects invariants.
802. Prevent OrderLine from existing in invalid quantity state.
803. Prevent confirmed orders from being edited directly.
804. Add explicit methods for adding, removing, and changing quantity safely.
805. Design an Invoice aggregate with immutable line snapshots from Order.
806. Explain why invoice should not hold mutable references back to live order lines.
807. Design a Library aggregate with Member, BookCopy, and Loan.
808. Protect the rule that one book copy cannot be loaned twice at the same time.
809. Add waiting-list behavior without corrupting loan rules.
810. Design a Trip aggregate with driver, rider, and fare breakdown.
811. Prevent invalid trip status transitions.
812. Add cancellation rules depending on trip stage.
813. Design a SeatMap object that owns seat state transitions.
814. Prevent double booking under repeated requests in the domain model.
815. Model a school exam aggregate with exam, sections, and questions.
816. Prevent score updates after publishing results.
817. Design a ShoppingCart to Order conversion flow as a domain transition.
818. Ensure cart mutability and order immutability are properly separated.
819. Design a Warehouse aggregate with stock lots instead of raw counts.
820. Prevent shipping more items than available across lots.
821. Design a PayrollRun object that owns employee salary calculations for a pay cycle.
822. Prevent recalculating archived payroll runs accidentally.
823. Design a Project aggregate with tasks, assignees, and status rules.
824. Ensure a project cannot be marked complete while active tasks remain incomplete.
825. Design a BlogPost aggregate with comments and moderation actions.
826. Prevent deleted posts from accepting new comments.
827. Design a CartPromotionApplication object that records which promotions were used.
828. Prevent stacking incompatible promotions.
829. Design a Reservation aggregate for restaurant booking with table assignment.
830. Prevent assigning two reservations to one table for overlapping times.
831. Design a LoanRepaymentSchedule object.
832. Protect repayment ordering rules and overdue calculations.
833. Design a HospitalVisit aggregate with patient, doctor notes, prescription, and billing.
834. Ensure closed visits cannot be modified except through explicit amendment flow.
835. Design a TicketConversation model with comment timeline and status changes.
836. Separate public replies and internal notes cleanly.
837. Design a ContestSubmission model with attempt history.
838. Prevent hidden mutation of historical attempts.
839. Design a GradeBook aggregate with student records and locked terms.
840. Ensure published term results cannot be changed without revision workflow.
841. Design a HotelStay model with check-in, extension, and check-out rules.
842. Prevent room reassignment after checkout completion.
843. Design a FoodOrder aggregate with line items, kitchen status, and billing status.
844. Ensure kitchen-prepared items cannot be silently removed.
845. Design a SubscriptionAccount model with renew, suspend, cancel, and resume transitions.
846. Prevent invalid state transitions.
847. Design a ParcelShipment aggregate with checkpoints and delivery status.
848. Prevent delivered parcels from re-entering in-transit state.
849. Design a RecruitmentPipeline model with candidates and interview stages.
850. Ensure rejected candidates cannot move to later interview rounds directly.
851. Design a ClassSession aggregate with attendance, topic coverage, and homework.
852. Prevent attendance changes after session lock unless admin amendment exists.
853. Design a PaymentAttempt history model for an order.
854. Separate order payment status from individual payment attempts.
855. Design a Budget aggregate with categories and allocations.
856. Prevent overspending relative to category allocation unless override policy exists.
857. Design a WarehouseTransfer object moving stock between locations.
858. Prevent transfer completion without source deduction and destination addition both succeeding.
859. Design a ReturnRequest aggregate that owns item-level return reasons.
860. Prevent approving return quantities greater than purchased quantities.
861. Design a DriverShift model with start, end, breaks, and active-trip rules.
862. Prevent shift closure while an active trip exists.
863. Design a FoodDeliveryBatch model grouping multiple deliveries.
864. Ensure batch status reflects child delivery statuses coherently.
865. Design a MedicalPrescription aggregate with medicine lines and dosage rules.
866. Prevent editing dosage after doctor approval without amendment note.
867. Design an ExamPaper model with section ordering and total marks validation.
868. Prevent total marks mismatch from final publication.
869. Design a Playlist model where position ordering is explicit.
870. Prevent inconsistent ordering after song insertions and removals.
871. Design a ResearchSubmission workflow with draft, submitted, reviewed, accepted, rejected.
872. Encode valid transitions without stringly typed branching.
873. Design an AccessControlPolicy aggregate with roles and permissions.
874. Prevent duplicate permission assignment bugs.
875. Design a TravelItinerary model with legs and total duration calculations.
876. Prevent invalid overlapping travel legs.
877. Design a PatientQueue model with priority and arrival order.
878. Prevent queue corruption after reprioritization.
879. Design an Auction aggregate with bids and close rules.
880. Prevent late bids after close time.
881. Design a ScoreBoard aggregate with rounds and participants.
882. Prevent out-of-order round score entry.
883. Design a LoanApplicationReview process with multiple review decisions.
884. Require final decision only after mandatory checks pass.
885. Design a PolicyDocument aggregate with versions and publish rules.
886. Prevent editing already published versions directly.
887. Design a RefundSettlement model with settlement attempts.
888. Prevent marking refund complete when settlement attempt failed.
889. Design a FleetMaintenanceSchedule with service records and due checks.
890. Prevent closing maintenance jobs without mandatory checklist completion.
891. Design a GameMatch aggregate with players, turns, and result locking.
892. Prevent further moves after result declaration.
893. Design a DigitalWalletTransfer model with sender, receiver, limits, and state.
894. Prevent balance deduction and receiver credit from going out of sync in domain logic.
895. Design a DonationCampaign aggregate with pledges and fulfillment status.
896. Prevent campaign closure when unresolved pledges exist unless explicitly allowed.
897. Design a ProcurementRequest aggregate with approval chain and vendor quotes.
898. Prevent quote selection before minimum vendor response count is satisfied.
899. Design a UniversitySemesterPlan aggregate with courses and credit rules.
900. Refactor one of the above aggregates to improve cohesion and lower coupling.

Advanced Stage 4: High-Difficulty OOP Engineering and Refactoring Challenges (901-1000)

901. Refactor a deep inheritance hierarchy of vehicles into a cleaner composition-heavy design.
902. Refactor a payment system where concrete classes are created directly inside services.
903. Replace direct new calls across services with injected abstractions where appropriate.
904. Refactor a UserManager class that handles login, reporting, email, and audit.
905. Extract cohesive services from that UserManager while preserving behavior.
906. Refactor a giant OrderService with 12 responsibilities into a clear object collaboration model.
907. Identify aggregate roots and supporting services in that OrderService design.
908. Refactor a school management model where every class has public fields.
909. Add invariant-protecting methods and remove direct state mutation.
910. Refactor a class hierarchy where child classes constantly override methods with empty bodies.
911. Diagnose why that hierarchy violates substitutability and redesign it.
912. Refactor a Bird hierarchy where some birds cannot fly without breaking behavior contracts.
913. Replace inheritance with capability interfaces where needed.
914. Refactor a design where instanceof checks determine payment behavior everywhere.
915. Replace those checks with runtime polymorphism and strategies.
916. Refactor a discount engine that modifies one giant method every festival season.
917. Make the discount system open for extension and closed for modification.
918. Refactor a report generator that hardcodes output format strings in business logic.
919. Separate report data preparation from report rendering.
920. Refactor a chat application where message sending is mixed with persistence and notification.
921. Separate domain model, sender abstraction, and notification behavior.
922. Refactor a product system where money is modeled as double everywhere.
923. Introduce a Money value object and explain where API boundaries change.
924. Refactor an order model where status is a raw string used in many places.
925. Replace string status with safer domain modeling and explicit transitions.
926. Refactor a booking system where seat selection, payment, and ticket issuance are tightly coupled.
927. Separate them into collaborating objects without losing consistency.
928. Refactor a reporting system that returns large mutable internal collections.
929. Prevent clients from mutating internal aggregate state accidentally.
930. Refactor a customer service model where comments, escalations, and assignment are all methods on one class.
931. Improve cohesion and event traceability.
932. Refactor a batch job framework where each job contains logging, error handling, retry, and business logic mixed together.
933. Separate cross-cutting concerns from job-specific logic.
934. Refactor an exam system where all question types use one giant class with many nullable fields.
935. Replace it with a more explicit object model.
936. Refactor a loyalty program where tier logic is duplicated in multiple services.
937. Centralize tier rules without creating a god class.
938. Refactor a payroll system where different pay rules are encoded with nested if-else trees.
939. Introduce a pay-rule abstraction and explain testing benefits.
940. Refactor a warehouse system where inventory counts can become inconsistent because updates happen from multiple places.
941. Centralize mutation paths inside a proper aggregate.
942. Refactor a media player model where state logic is spread across UI and domain classes.
943. Introduce a better state-oriented design.
944. Refactor a cart system where discounts and taxes are applied in inconsistent order across codebase.
945. Model pricing pipeline explicitly.
946. Refactor a user-notification system where each service chooses its own notification formatting rules.
947. Centralize message composition without hard-coding sender channel behavior.
948. Refactor a support-ticket workflow that allows invalid status jumps due to open setters.
949. Replace open setters with explicit domain operations.
950. Refactor an invoice model where invoice totals are recalculated on every getter call from mutable lines.
951. Make invoice snapshots stable and predictable.
952. Refactor a cab booking system where fare, trip, and driver availability are changed by multiple services independently.
953. Identify consistency boundaries and redesign around them.
954. Refactor a document approval system where permissions are checked ad hoc in many methods.
955. Introduce clear policy abstractions or authorization services.
956. Refactor a fitness app where workout, nutrition, and subscription logic live in one large member class.
957. Split responsibilities while maintaining a coherent domain.
958. Refactor an e-commerce product model where digital and physical products share wrong inheritance.
959. Replace fragile inheritance with capabilities or composition.
960. Refactor a shopping cart system to support plug-in pricing rules from external teams.
961. Design extension points without exposing domain internals dangerously.
962. Refactor a monolithic billing class to support auditability of each applied rule.
963. Introduce objects representing intermediate calculation stages where needed.
964. Refactor a survey platform where all answer types are strings.
965. Model answer types explicitly and validate them polymorphically.
966. Refactor a game engine where weapons are subclasses of characters due to bad inheritance.
967. Correct the model with composition and explain why.
968. Refactor a loan approval flow where rule ordering changes frequently and is brittle.
969. Introduce configurable rule objects and a rule engine coordinator.
970. Refactor a codebase where constructors perform database calls, network calls, and validation all together.
971. Split object construction, validation, and infrastructure concerns appropriately.
972. Refactor a command-processing app where handler selection is hardcoded in controller logic.
973. Move to a registration-based or map-based polymorphic dispatch design.
974. Refactor a report-export subsystem to support streaming large outputs without changing callers.
975. Redesign abstractions so scalability concern does not leak badly.
976. Refactor a school result system where one object both stores marks and renders HTML reports.
977. Improve cohesion and testing ability.
978. Refactor a package-shipping workflow where address parsing logic is scattered.
979. Introduce a proper address value object and supporting parser boundary.
980. Refactor a user-account model where security-sensitive fields are mutable from UI layer directly.
981. Introduce safe mutation APIs and boundary validation.
982. Refactor a collaborative editing model where document changes are applied by arbitrary services.
983. Centralize change application and versioning rules.
984. Refactor an audit system where every service creates audit entries in different formats.
985. Introduce consistent audit abstractions without overengineering.
986. Refactor a chat moderation system where blocked content checks are duplicated.
987. Create a reusable moderation rule model.
988. Refactor a travel itinerary system where each transport type duplicates scheduling rules.
989. Extract common scheduling behavior without forcing invalid inheritance.
990. Refactor a CRM where customer, lead, and prospect models share partial overlapping state badly.
991. Decide which parts belong in shared abstractions and which do not.
992. Refactor a parking lot system that stores all vehicles in one mutable map with weak invariants.
993. Introduce stronger domain boundaries and behavior-rich slot assignments.
994. Refactor a marketplace checkout system to support future split payments and partial refunds.
995. Prepare the object model for those changes with minimal rewrite risk.
996. Refactor a ride-sharing domain where one huge class handles rider, driver, payment, and trip status.
997. Break it into proper entities, value objects, and services while preserving the workflow.
998. Choose one earlier advanced system and redesign it to maximize low coupling and high cohesion.
999. Choose one earlier advanced system and redesign it to maximize testability and replaceable dependencies.
1000. Design and implement a complete interview-grade OOP mini-system of your choice, then write a design note explaining where you used encapsulation, abstraction, polymorphism, composition, immutable value objects, and dependency inversion.

Closing Note

If a student solves this entire sheet honestly, OOP will stop feeling like a classroom chapter and start feeling like an engineering discipline.

That is exactly the point.