import java.util.*;
 
// One-to-One: a Person is associated with exactly one Passport.
class Passport {
    private String number;
 
    public Passport(String number) {
        this.number = number;
    }
 
    public String getNumber() {
        return number;
    }
}
 
class Person {
    private String name;
    private Passport passport; // a reference — the Passport is not owned by Person
 
    public Person(String name, Passport passport) {
        this.name = name;
        this.passport = passport;
    }
 
    public String getName() {
        return name;
    }
 
    public Passport getPassport() {
        return passport;
    }
}
 
// One-to-Many: one Teacher is associated with many Students.
class Student {
    private String name;
 
    public Student(String name) {
        this.name = name;
    }
 
    public String getName() {
        return name;
    }
}
 
class Teacher {
    private String name;
    private List<Student> students; // a collection of references
 
    public Teacher(String name, List<Student> students) {
        this.name = name;
        this.students = students;
    }
 
    public void teach() {
        for (Student s : students) {
            System.out.println(name + " teaches " + s.getName());
        }
    }
}
 
// ── Driver ──────────────────────────────────────────────
class Main {
    public static void main(String[] args) {
        // One-to-One
        Passport passport = new Passport("P-4417");
        Person person = new Person("Alex", passport);
        System.out.println(person.getName() + " holds passport " + person.getPassport().getNumber());
 
        // One-to-Many
        List<Student> students = new ArrayList<>();
        students.add(new Student("Sam"));
        students.add(new Student("Riya"));
        Teacher teacher = new Teacher("Mrs. Rao", students);
        teacher.teach();
 
        // Both objects are merely linked — neither owns the other, so each can
        // outlive the relationship. That is what makes this association.
        System.out.println("Students still exist independently: " + students.size());
    }
}

from typing import List
 
 
# One-to-One: a Person is associated with exactly one Passport.
class Passport:
    def __init__(self, number: str) -> None:
        self._number = number  # single underscore: "internal by convention" (no `private`)
 
    @property
    def number(self) -> str:
        return self._number
 
 
class Person:
    def __init__(self, name: str, passport: Passport) -> None:
        self._name = name
        self._passport = passport  # a reference — the Passport is not owned by Person
 
    @property
    def name(self) -> str:
        return self._name
 
    @property
    def passport(self) -> Passport:
        return self._passport
 
 
# One-to-Many: one Teacher is associated with many Students.
class Student:
    def __init__(self, name: str) -> None:
        self._name = name
 
    @property
    def name(self) -> str:
        return self._name
 
 
class Teacher:
    def __init__(self, name: str, students: List[Student]) -> None:
        self._name = name
        self._students = students  # a collection of references
 
    def teach(self) -> None:
        for s in self._students:
            print(f"{self._name} teaches {s.name}")
 
 
# ── Driver ──────────────────────────────────────────────
if __name__ == "__main__":
    # One-to-One
    passport = Passport("P-4417")
    person = Person("Alex", passport)
    print(f"{person.name} holds passport {person.passport.number}")
 
    # One-to-Many
    students = [Student("Sam"), Student("Riya")]
    teacher = Teacher("Mrs. Rao", students)
    teacher.teach()
 
    # Both objects are merely linked — neither owns the other, so each can
    # outlive the relationship. That is what makes this association.
    print(f"Students still exist independently: {len(students)}")

import java.util.*;
 
// Department Class
class Department {
    private List<Employee> employees;
 
    public Department(List<Employee> employees) {
        this.employees = employees;
    }
}
 
// Employee Class
class Employee {
    private String name;
 
    public Employee(String name) {
        this.name = name;
    }
 
    public String getName() {
        return name;
    }
}
 
// ── Driver ──────────────────────────────────────────────
class Main {
    public static void main(String[] args) {
        // The employees are created OUTSIDE the department and passed in.
        List<Employee> staff = new ArrayList<>();
        staff.add(new Employee("Alex"));
        staff.add(new Employee("Sam"));
 
        Department department = new Department(staff);
        System.out.println("Department created with " + staff.size() + " employees.");
 
        // Drop the department; the employees are untouched.
        department = null;
        System.out.println("Department deleted. Employees still alive:");
        for (Employee e : staff) {
            System.out.println("  " + e.getName());
        }
    }
}

from typing import List
 
 
class Employee:
    def __init__(self, name: str) -> None:
        self._name = name
 
    @property
    def name(self) -> str:
        return self._name
 
 
class Department:
    def __init__(self, employees: List[Employee]) -> None:
        self._employees = employees
 
 
# ── Driver ──────────────────────────────────────────────
if __name__ == "__main__":
    # The employees are created OUTSIDE the department and passed in.
    staff = [Employee("Alex"), Employee("Sam")]
 
    department = Department(staff)
    print(f"Department created with {len(staff)} employees.")
 
    # Drop the department; the employees are untouched. Python has no
    # explicit "delete the object" statement like Java's `= null` — this
    # just drops the only reference to `department`, making it eligible
    # for garbage collection. `staff` still holds its own references.
    department = None
    print("Department deleted. Employees still alive:")
    for e in staff:
        print(f"  {e.name}")

import java.util.*;
 
class House {
    private List<Room> rooms;
 
    public House() {
        rooms = new ArrayList<>();
        rooms.add(new Room("Living Room"));
        rooms.add(new Room("Bedroom"));
    }
 
    public List<Room> getRooms() {
        return rooms;
    }
}
 
class Room {
    private String name;
 
    public Room(String name) {
        this.name = name;
    }
 
    public String getName() {
        return name;
    }
}
 
// ── Driver ──────────────────────────────────────────────
class Main {
    public static void main(String[] args) {
        // The rooms are created INSIDE the House constructor — nothing outside
        // ever holds a reference to them.
        House house = new House();
        System.out.println("House built with these rooms:");
        for (Room r : house.getRooms()) {
            System.out.println("  " + r.getName());
        }
 
        // Drop the house and its rooms become unreachable with it — that is the
        // difference from aggregation.
        house = null;
        System.out.println("House destroyed — its rooms are unreachable and go with it.");
    }
}

from typing import List
 
 
class Room:
    def __init__(self, name: str) -> None:
        self._name = name
 
    @property
    def name(self) -> str:
        return self._name
 
 
class House:
    def __init__(self) -> None:
        # The rooms are created INSIDE the House constructor — nothing
        # outside ever holds a reference to them.
        self._rooms: List[Room] = [Room("Living Room"), Room("Bedroom")]
 
    @property
    def rooms(self) -> List[Room]:
        return self._rooms
 
 
# ── Driver ──────────────────────────────────────────────
if __name__ == "__main__":
    house = House()
    print("House built with these rooms:")
    for r in house.rooms:
        print(f"  {r.name}")
 
    # Drop the house and its rooms become unreachable with it — that is the
    # difference from aggregation. (No `= null` in Python; reassigning to
    # None just drops the last reference, so the Rooms become collectible.)
    house = None
    print("House destroyed — its rooms are unreachable and go with it.")

import java.util.*;
 
// Address class
class Address {
    String city;
 
    // Constructor
    Address(String city) {
        this.city = city;
    }
}
 
// Person class (which is clonable)
class Person implements Cloneable {
    String name; // Primitive field
    Address address; // Reference-type field
 
    // Constructor
    Person(String name, Address address) {
        this.name = name;
        this.address = address;
    }
 
    // clone() method is inherited from Object class and must be Overriden
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();  // Shallow copy
    }
}
 
class Main {
    public static void main(String[] args) throws CloneNotSupportedException {
        Address address = new Address("Mumbai");
        Person person = new Person("Rahul", address);
 
        Person clonedPerson = (Person) person.clone(); // Cloning person
 
        // Modifying the address in the cloned object
        clonedPerson.address.city = "New Delhi";
 
        // Output to check if changes are reflected in the original
        System.out.println(person.name + " lives in " + person.address.city);
        System.out.println(clonedPerson.name + " lives in " + clonedPerson.address.city);
    }
}

import java.util.*;
// Address class (which is cloneable)
class Address implements Cloneable {
    String city;
 
    // Constructor
    Address(String city) {
        this.city = city;
    }
 
    // Overriding default clone() method
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return new Address(this.city);  // Creating a new object
    }
}
 
 
// Person class which is cloneable
class Person implements Cloneable {
    String name; // Primitive field
    Address address; // Reference-type field
 
    // Constructor
    Person(String name, Address address) {
        this.name = name;
        this.address = address;
    }
 
    // Overriding
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Person clonedPerson = (Person) super.clone(); // Shallow copy
 
        // Cloning nested object for Deep Cloning
        clonedPerson.address = (Address) address.clone();
        return clonedPerson;
    }
}
 
class Main {
    public static void main(String[] args) throws CloneNotSupportedException {
        Address address = new Address("Mumbai");
        Person person = new Person("Rahul", address);
 
        Person clonedPerson = (Person) person.clone(); // Deep Cloning
 
        // Modifying the address in the cloned object
        clonedPerson.address.city = "New Delhi";
 
        // Output to check if changes are reflected in the original
        System.out.println(person.name + " lives in " + person.address.city);  // Mumbai
        System.out.println(clonedPerson.name + " lives in " + clonedPerson.address.city);  // New Delhi
    }
}

import copy
 
 
class Address:
    def __init__(self, city: str) -> None:
        self.city = city
 
 
class Person:
    def __init__(self, name: str, address: Address) -> None:
        self.name = name
        self.address = address
 
 
# ── Driver ──────────────────────────────────────────────
if __name__ == "__main__":
    address = Address("Mumbai")
    person = Person("Rahul", address)
 
    # Shallow clone: copy.copy() duplicates the Person but reuses the SAME
    # Address object underneath, just like Java's default super.clone().
    shallow_clone = copy.copy(person)
    shallow_clone.address.city = "New Delhi"
    print(f"{person.name} lives in {person.address.city}")            # Mumbai -> New Delhi (shared)
    print(f"{shallow_clone.name} lives in {shallow_clone.address.city}")
 
    # Reset the shared Address before demonstrating the deep-clone half.
    person.address.city = "Mumbai"
 
    # Deep clone: copy.deepcopy() recursively duplicates every nested
    # object too, so the two Address instances end up fully independent —
    # no manual per-field clone() overrides required, unlike Java.
    deep_clone = copy.deepcopy(person)
    deep_clone.address.city = "New Delhi"
    print(f"{person.name} lives in {person.address.city}")            # stays Mumbai
    print(f"{deep_clone.name} lives in {deep_clone.address.city}")

name = "Central_Library"
title = [ "Frankestein", "King_Arthur_and_the_Round_Table" ]
author = [ "Mary_Shelley", "Rosemary_Sutcliff" ]
changeIndex = 1
newTitle = "Treasure_Island"
new_author = "Robert_Louis_Stevenson"

Original Library :
Library : Central_Library
Book : Frankestein, Author : Mary_Shelley
Book : King_Arthur_and_the_Round_Table, Author : Rosemary_Sutcliff
 
After Modifications :
Library : Central_Library
Book : Frankestein, Author : Mary_Shelley
Book : Treasure_Island, Author : Robert_Louis_Stevenson
 
Shallow Clone :
Library : Central_Library
Book : Frankestein, Author : Mary_Shelley
Book : Treasure_Island, Author : Robert_Louis_Stevenson
 
Deep Clone :
Library : Central_Library
Book : Frankestein, Author : Mary_Shelley
Book : King_Arthur_and_the_Round_Table, Author : Rosemary_Sutcliff

import java.util.*;
 
// Book class supports cloning
class Book implements Cloneable {
    String title;
    String author;
 
    // Constructor to initialize book details
    Book(String title, String author) {
        this.title = title;
        this.author = author;
    }
 
    @Override
    protected Book clone() throws CloneNotSupportedException {
        // default shallow copy (safe since String is immutable)
        return (Book) super.clone();
    }
}
 
 
// Library class supports shallow and deep cloning
class Library implements Cloneable {
    String name;
    List<Book> books;
 
    // Initialize library with empty book list
    Library(String name) {
        this.name = name;
        this.books = new ArrayList<>();
    }
 
    // Add a book to the library
    void addBook(Book book) {
        books.add(book);
    }
 
    // Shallow clone → shares same books list reference
    Library shallowClone() throws CloneNotSupportedException {
        // list reference copied, not duplicated
        return (Library) super.clone();
    }
 
    // Deep clone → creates new list + new Book objects
    Library deepClone() throws CloneNotSupportedException {
        // copy primitive + references first
        Library cloned = (Library) super.clone();
 
        cloned.books = new ArrayList<>(); // create independent list
 
        for (Book book : this.books) {
            cloned.books.add(book.clone()); // clone each book separately
        }
 
        return cloned;
    }
 
    // Display library details
    void display() {
        System.out.println("Library : " + name);
        for (Book book : books) {
            System.out.println("Book : " + book.title + ", Author : " + book.author);
        }
    }
}
 
class Main {
    public static void main(String[] args) throws CloneNotSupportedException {
        // Hardcoded input
        String libraryName = "Central_Library";
        String[] titles = { "Frankestein", "King_Arthur_and_the_Round_Table" };
        String[] authors = { "Mary_Shelley", "Rosemary_Sutcliff" };
        int changeIndex = 1;
        String newTitle = "Treasure_Island";
        String newAuthor = "Robert_Louis_Stevenson";
 
        // Create library and add books
        Library library = new Library(libraryName);
        for (int i = 0; i < titles.length; i++) {
            library.addBook(new Book(titles[i], authors[i]));
        }
 
        // Display original library
        System.out.println("Original Library :");
        library.display();
 
        // Create the clones BEFORE modifying, so the deep clone captures the original state
        Library shallowClonedLibrary = library.shallowClone();
        Library deepClonedLibrary = library.deepClone();
 
        // Modify the book at changeIndex on the original library
        library.books.get(changeIndex).title = newTitle;
        library.books.get(changeIndex).author = newAuthor;
 
        System.out.println("\nAfter Modifications :");
        library.display();
 
        // Display shallow clone — it shares the books list, so it reflects the change
        System.out.println("\nShallow Clone :");
        shallowClonedLibrary.display();
 
        // Display deep clone — it is independent, so it keeps the original data
        System.out.println("\nDeep Clone :");
        deepClonedLibrary.display();
    }
}