public class Animal {
  private String name;
  public Animal (String name) {
    this.name = name;
  }
  public String getName () {
    return this.name;
  }
  public void setName (String name) {
    this.name = name;
  }
}

public interface AnimalAddedListener {
  public void onAnimalAdded (Animal animal);
}

public class Zoo {
  private List<Animal> animals = new ArrayList<>();
  private List<AnimalAddedListener> listeners = new ArrayList<>();
  public void addAnimal (Animal animal) {
    // Add the animal to the list of animals
    this.animals.add(animal);
    // Notify the list of registered listeners
    this.notifyAnimalAddedListeners(animal);
  }
  public void registerAnimalAddedListener (AnimalAddedListener listener) {
    // Add the listener to the list of registered listeners
    this.listeners.add(listener);
  }
  public void unregisterAnimalAddedListener (AnimalAddedListener listener) {
    // Remove the listener from the list of the registered listeners
    this.listeners.remove(listener);
  }
  protected void notifyAnimalAddedListeners (Animal animal) {
    // Notify each of the listeners in the list of registered listeners
    this.listeners.forEach(listener -> listener.updateAnimalAdded(animal));
  }
}

public class PrintNameAnimalAddedListener implements AnimalAddedListener {
  @Override
  public void updateAnimalAdded (Animal animal) {
    // Print the name of the newly added animal
    System.out.println("Added a new animal with name '" + animal.getName() + "'");
  }
}

public class Main {
  public static void main (String[] args) {
    // Create the zoo to store animals
    Zoo zoo = new Zoo();
    // Register a listener to be notified when an animal is added
    zoo.registerAnimalAddedListener(new PrintNameAnimalAddedListener());
    // Add an animal notify the registered listeners
    zoo.addAnimal(new Animal("Tiger"));
  }
}

Added a new animal with name 'Tiger'

public class CountingAnimalAddedListener implements AnimalAddedListener {
  private static int animalsAddedCount = 0;
  @Override
  public void updateAnimalAdded (Animal animal) {
    // Increment the number of animals
    animalsAddedCount++;
    // Print the number of animals
    System.out.println("Total animals added: " + animalsAddedCount);
  }
}

public class Main {
  public static void main (String[] args) {
    // Create the zoo to store animals
    Zoo zoo = new Zoo();
    // Register listeners to be notified when an animal is added
    zoo.registerAnimalAddedListener(new PrintNameAnimalAddedListener());
    zoo.registerAnimalAddedListener(new CountingAnimalAddedListener());
    // Add an animal notify the registered listeners
    zoo.addAnimal(new Animal("Tiger"));
    zoo.addAnimal(new Animal("Lion"));
    zoo.addAnimal(new Animal("Bear"));
  }
}

Added a new animal with name 'Tiger'
Total animals added: 1
Added a new animal with name 'Lion'
Total animals added: 2
Added a new animal with name 'Bear'
Total animals added: 3

public class Main {
  public static void main (String[] args) {
    // Create the zoo to store animals
    Zoo zoo = new Zoo();
    // Register listeners to be notified when an animal is added
    zoo.registerAnimalAddedListener(new AnimalAddedListener() {
      @Override
      public void updateAnimalAdded (Animal animal) {
        // Print the name of the newly added animal
        System.out.println("Added a new animal with name '" + animal.getName() + "'");
      }
    });
    // Add an animal notify the registered listeners
    zoo.addAnimal(new Animal("Tiger"));
  }
}

public class Main {
  public static void main (String[] args) {
    // Create the zoo to store animals
    Zoo zoo = new Zoo();
    // Register listeners to be notified when an animal is added
    zoo.registerAnimalAddedListener(
      (animal) -> System.out.println("Added a new animal with name '" + animal.getName() + "'")
    );
    // Add an animal notify the registered listeners
    zoo.addAnimal(new Animal("Tiger"));
  }
}

public AnimalAddedListener registerAnimalAddedListener (AnimalAddedListener listener) {
  // Add the listener to the list of registered listeners
  this.listeners.add(listener); 
  return listener;
}

public class Main {
  public static void main (String[] args) {
    // Create the zoo to store animals
    Zoo zoo = new Zoo();
    // Register listeners to be notified when an animal is added
    AnimalAddedListener listener = zoo.registerAnimalAddedListener(
      (animal) -> System.out.println("Added a new animal with name '" + animal.getName() + "'")
    );
    // Add an animal notify the registered listeners
    zoo.addAnimal(new Animal("Tiger"));
    // Unregister the listener
    zoo.unregisterAnimalAddedListener(listener);
    // Add another animal, which will not print the name, since the listener
    // has been previously unregistered
    zoo.addAnimal(new Animal("Lion"));
  }
}

public class AnimalAddedListenerReceipt {
  private final AnimalAddedListener listener;
  public AnimalAddedListenerReceipt (AnimalAddedListener listener) {
    this.listener = listener;
  }
  public final AnimalAddedListener getListener () {
    return this.listener;
  }
}

public class ZooUsingReceipt {
  // ...Existing attributes and constructor...
  public AnimalAddedListenerReceipt registerAnimalAddedListener (AnimalAddedListener listener) {
    // Add the listener to the list of registered listeners
    this.listeners.add(listener);
    return new AnimalAddedListenerReceipt(listener);
  }
  public void unregisterAnimalAddedListener (AnimalAddedListenerReceipt receipt) {
    // Remove the listener from the list of the registered listeners
    this.listeners.remove(receipt.getListener());
  }
  // ...Existing notification method...
}

public class ZooContainer implements AnimalAddedListener {
  private Zoo zoo = new Zoo();
  public ZooContainer () {
    // Register this object as a listener
    this.zoo.registerAnimalAddedListener(this);
  }
  public Zoo getZoo () {
    return this.zoo;
  }
  @Override
    public void updateAnimalAdded (Animal animal) {
    System.out.println("Added animal with name '" + animal.getName() + "'");
  }
  public static void main (String[] args) {
    // Create the zoo container
    ZooContainer zooContainer = new ZooContainer();
    // Add an animal notify the innerally notified listener
    zooContainer.getZoo().addAnimal(new Animal("Tiger"));
  }
}

public synchronized AnimalAddedListener registerAnimalAddedListener (AnimalAddedListener listener) { /*...*/ }
public synchronized void unregisterAnimalAddedListener (AnimalAddedListener listener) { /*...*/ }
public synchronized void notifyAnimalAddedListeners (Animal animal) { /*...*/ }

public class ThreadSafeZoo {
  private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
  protected final Lock readLock = readWriteLock.readLock();
  protected final Lock writeLock = readWriteLock.writeLock();
  private List<Animal> animals = new ArrayList<>();
  private List<AnimalAddedListener> listeners = new ArrayList<>();
  public void addAnimal (Animal animal) {
    // Add the animal to the list of animals
    this.animals.add(animal);
    // Notify the list of registered listeners
    this.notifyAnimalAddedListeners(animal);
  }
  public AnimalAddedListener registerAnimalAddedListener (AnimalAddedListener listener) {
    // Lock the list of listeners for writing
    this.writeLock.lock();
    try {
      // Add the listener to the list of registered listeners
      this.listeners.add(listener);
    }
    finally {
      // Unlock the writer lock
      this.writeLock.unlock();
    }
    return listener;
  }
  public void unregisterAnimalAddedListener (AnimalAddedListener listener) {
    // Lock the list of listeners for writing
    this.writeLock.lock();
    try {
      // Remove the listener from the list of the registered listeners
      this.listeners.remove(listener);
    }
    finally {
      // Unlock the writer lock
      this.writeLock.unlock();
    }
  }
  public void notifyAnimalAddedListeners (Animal animal) {
    // Lock the list of listeners for reading
    this.readLock.lock();
    try {
      // Notify each of the listeners in the list of registered listeners
      this.listeners.forEach(listener -> listener.updateAnimalAdded(animal));
    }
    finally {
      // Unlock the reader lock
      this.readLock.unlock();
    }
  }
}

public class ThreadSafeCountingAnimalAddedListener implements AnimalAddedListener {
  private static AtomicLong animalsAddedCount = new AtomicLong(0);
  @Override
  public void updateAnimalAdded (Animal animal) {
    // Increment the number of animals
    animalsAddedCount.incrementAndGet();
    // Print the number of animals
    System.out.println("Total animals added: " + animalsAddedCount);
  }
}

public class CountingAnimalAddedListener implements AnimalAddedListener {
  private static int animalsAddedCount = 0;
  @Override
  public synchronized void updateAnimalAdded (Animal animal) {
    // Increment the number of animals
    animalsAddedCount++;
    // Print the number of animals
    System.out.println("Total animals added: " + animalsAddedCount);
  }
}

public class OrderedThreadSafeZoo {
  private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock(true);
  protected final Lock readLock = readWriteLock.readLock();
  protected final Lock writeLock = readWriteLock.writeLock();
  private List<Animal> animals = new ArrayList<>();
  private List<AnimalAddedListener> listeners = new ArrayList<>();
  public void addAnimal (Animal animal) {
    // Add the animal to the list of animals
    this.animals.add(animal);
    // Notify the list of registered listeners
    this.notifyAnimalAddedListeners(animal);
  }
  public AnimalAddedListener registerAnimalAddedListener (AnimalAddedListener listener) {
    // Lock the list of listeners for writing
    this.writeLock.lock();
    try {
      // Add the listener to the list of registered listeners
      this.listeners.add(listener);
    }
    finally {
      // Unlock the writer lock
      this.writeLock.unlock();
    }
    return listener;
  }
  public void unregisterAnimalAddedListener (AnimalAddedListener listener) {
    // Lock the list of listeners for writing
    this.writeLock.lock();
    try {
      // Remove the listener from the list of the registered listeners
      this.listeners.remove(listener);
    }
    finally {
      // Unlock the writer lock
      this.writeLock.unlock();
    }
  }
  public void notifyAnimalAddedListeners (Animal animal) {
    // Lock the list of listeners for reading
    this.readLock.lock();
    try {
      // Notify each of the listeners in the list of registered listeners
      this.listeners.forEach(listener -> listener.updateAnimalAdded(animal));
    }
    finally {
      // Unlock the reader lock
      this.readLock.unlock();
    }
  }
}

public abstract class ObservableSubjectMixin<ListenerType> {
  private List<ListenerType> listeners = new ArrayList<>();
  public ListenerType registerListener (ListenerType listener) {
    // Add the listener to the list of registered listeners
    this.listeners.add(listener);
    return listener;
  }
  public void unregisterAnimalAddedListener (ListenerType listener) {
    // Remove the listener from the list of the registered listeners
    this.listeners.remove(listener);
  }
  public void notifyListeners (Consumer<? super ListenerType> algorithm) {
    // Execute some function on each of the listeners
    this.listeners.forEach(algorithm);
  }
}

public class ZooUsingMixin extends ObservableSubjectMixin<AnimalAddedListener> {
  private List<Animal> animals = new ArrayList<>();
  public void addAnimal (Animal animal) {
    // Add the animal to the list of animals
    this.animals.add(animal);
    // Notify the list of registered listeners
    this.notifyListeners((listener) -> listener.updateAnimalAdded(animal));
  }
}

public interface ZooListener {
  public void onAnimalAdded (Animal animal);
  public void onAnimalRemoved (Animal animal);
}

public class ZooUsingMixin extends ObservableSubjectMixin<ZooListener> {
  private List<Animal> animals = new ArrayList<>();
  public void addAnimal (Animal animal) {
    // Add the animal to the list of animals
    this.animals.add(animal);
    // Notify the list of registered listeners
    this.notifyListeners((listener) -> listener.onAnimalAdded(animal));
  }
  public void removeAnimal (Animal animal) {
    // Remove the animal from the list of animals
    this.animals.remove(animal);
    // Notify the list of registered listeners
    this.notifyListeners((listener) -> listener.onAnimalRemoved(animal));
  }
}

public class ZooAdapter implements ZooListener {
  @Override
  public void onAnimalAdded (Animal animal) {}
  @Override
  public void onAnimalRemoved (Animal animal) {}
}

public class NamePrinterZooAdapter extends ZooAdapter {
  @Override
  public void onAnimalAdded (Animal animal) {
    // Print the name of the animal that was added
    System.out.println("Added animal named " + animal.getName());
  }
}

public interface ZooListener {
  default public void onAnimalAdded (Animal animal) {}
  default public void onAnimalRemoved (Animal animal) {}
}

public class ZooListener {
  public void onAnimalAdded (Animal animal) {}
  public void onAnimalRemoved (Animal animal) {}
}

public class