Object Class, Cloneable & Comparable — Inherited Tools

7. Practice Problems

1. Write a Book class implementing Comparable<Book> so books sort alphabetically by title.
   Book class তৈরি করুন — title-এ alphabetical order-এ sort হবে।
   ✨ Show Answer

   Main.java

   import java.util.*;
   class Book implements Comparable<Book> {
       String title;
       Book(String t) { title = t; }
       @Override public int compareTo(Book o) { return title.compareTo(o.title); }
       @Override public String toString() { return title; }
   }
   class Main {
       public static void main(String[] args) {
           List<Book> bs = new ArrayList<>(List.of(
               new Book("Padma Nadir Majhi"),
               new Book("Lal Shalu"),
               new Book("Aagun Pakhi")));
           Collections.sort(bs);
           System.out.println(bs);
       }
   }

   Run Copy

2. Given a list of strings, sort them by length using a Comparator without implementing Comparable.
   Comparable ছাড়াই Comparator দিয়ে কিছু string-কে দৈর্ঘ্য অনুযায়ী sort করুন।
   ✨ Show Answer

   Main.java

   import java.util.*;
   class Main {
       public static void main(String[] args) {
           List<String> cities = new ArrayList<>(List.of("Dhaka", "Chattogram", "Sylhet", "Cox"));
           cities.sort(Comparator.comparingInt(String::length));
           System.out.println(cities);
       }
   }

   Run Copy

3. In 2 sentences: why is return a.value - b.value; a dangerous compareTo body for ints?
   দুই বাক্যে — return a.value - b.value; int তুলনায় কেন বিপজ্জনক?
   ✨ Show Answer

   Answer: When the values span a large range (e.g., one near Integer.MAX_VALUE and one negative), the subtraction can overflow and silently flip sign — breaking the ordering in just one tricky case. Use Integer.compare(a, b) instead; it handles the edge cases correctly.

   Subtraction overflow করলে sign উল্টে যেতে পারে এবং ordering ভেঙে পড়ে — কেবল নির্দিষ্ট কিছু মানে। Integer.compare নিরাপদ।

4. Write a copy constructor for a class Person with a String name and an Address (Address already shown above). Modify the copy's city and prove the original is untouched.
   Person class-এর জন্য copy constructor লিখুন — name String এবং Address। Copy-এর city বদলে দেখান original একই আছে।
   ✨ Show Answer

   Main.java

   class Address {
       String city;
       Address(String c) { city = c; }
       Address(Address o) { city = o.city; }
   }
   class Person {
       String name;
       Address addr;
       Person(String n, Address a) { name = n; addr = a; }
       Person(Person o) { name = o.name; addr = new Address(o.addr); }  // deep copy
   }
   class Main {
       public static void main(String[] args) {
           Person p = new Person("Raju", new Address("Dhaka"));
           Person q = new Person(p);
           q.addr.city = "Khulna";
           System.out.println(p.addr.city + " vs " + q.addr.city);
       }
   }

   Run Copy

5. Name two concrete reasons Joshua Bloch advises against implementing Cloneable.
   Joshua Bloch কেন Cloneable এড়াতে বলেন — দুটি নির্দিষ্ট কারণ।
   ✨ Show Answer

   Answer:

   • Object.clone() bypasses the constructor, so any invariants you enforce in your constructor can be silently violated.
   • The default clone() is shallow — cloned objects share references to inner mutable objects, creating subtle aliasing bugs. Correct deep-cloning code is fragile and easy to get wrong as the class evolves.

   Clone constructor bypass করে — তাই invariants ভেঙে যেতে পারে; এছাড়া shallow copy — inner mutable object share হয়ে aliasing bug তৈরি করে।