Java Notes
HubArray IntroductionArray OperationsArray Programs — FundamentalsArray Interview QuestionsJagged Array in JavaMulti Dimensional ArrayOne Dimensional Arraybreak and continue in JavaDo-While Loop in JavaFor Loop in JavaIf-Else Statements in JavaNested Loops in JavaSwitch-Case in JavaWhile Loop in JavaJava Compilation ProcessFeatures of JavaYour First Java ProgramHistory of JavaJava EditionsJava Program StructureJDK, JRE, and JVMWhat is Java?Immutable Strings in JavaString Class in JavaString Interview QuestionsString MethodsString Programs — FundamentalsStringBuffer in JavaStringBuilder in JavaComments in JavaData Types in JavaIdentifiers in JavaInput and Output in JavaKeywords in JavaOperators in JavaType Casting in JavaVariables in JavaAbstract Class in JavaAbstraction in JavaAnonymous Class in JavaClass and Object in JavaConstructor in JavaEncapsulation in JavaInheritance in JavaInner Class in JavaInterface in JavaMethod Overloading in JavaMethod Overriding in JavaObject Class in JavaObject Cloning in JavaOOPs IntroductionPolymorphism in Javastatic Keyword in Javasuper Keyword in Javathis Keyword in JavaWrapper Class in JavaCollections Framework OverviewCollections Practice ProgramsComparable vs Comparator in JavaGenerics in JavaIterator in JavaArrayList in JavaLinkedList in JavaStack in Java — Collections FrameworkVector in JavaHashMap in JavaHashtable in JavaLinkedHashMap in JavaTreeMap in JavaArrayDeque in JavaDeque Interface in JavaPriorityQueue in JavaHashSet in JavaLinkedHashSet in JavaTreeSet in JavaException Handling Best PracticesCustom Exceptions in JavaException Hierarchy in JavaFinally Block in JavaException Handling Introductionthrow and throws Keywords in JavaTry-Catch Block in JavaBuffered Streams in JavaByte Streams in JavaCharacter Streams in JavaDeserialization in JavaFile Class in JavaJava NIO PackageSerialization in JavaDate and Time API in Java 8Default and Static Methods in InterfacesFunctional Interface in Java 8Lambda Expression in Java 8Method Reference in Java 8Optional Class in Java 8Stream API in Java 8Creating Threads in JavaDaemon Threads in JavaExecutor Framework in JavaInter-Thread Communication in JavaMultithreading Programs in JavaRunnable Interface in JavaSynchronization in JavaThread Class in JavaThread IntroductionThread Life Cycle in JavaThread Priority in JavaBatch Processing in JDBCCallableStatement in JDBCJDBC ArchitectureJDBC IntroductionJDBC ProjectsMySQL Connection with JDBCPreparedStatement in JDBCResultSet in JDBCStatement Interface in JDBCTransaction Management in JDBCCookies in ServletsExpression Language (EL)GenericServletHttpServletJSP IntroductionJSP Tags and JSTLMVC ArchitectureRequest and Response ObjectsServlet IntroductionServlet Life CycleSession TrackingDependency InjectionAPI GatewayConfig ServerDocker DeploymentEureka Server - Service DiscoverySpring BeansCRUD ApplicationException Handling in Spring BootJWT Authentication — Java ProgrammingREST API with Spring BootSpring SecuritySpring Boot IntroductionSpring Data JPAValidation in Spring BootSpring Core ContainerSpring Framework IntroductionDynamic Programming in JavaGraph Data Structure in JavaHashing in JavaHeap (DSA)Linked List in JavaQueue in JavaRecursion in JavaSearching Algorithms in JavaSorting Algorithms in JavaStack in Java — DSA in JavaTime ComplexityTree Data Structure in JavaAdapter Design PatternBuilder Design PatternFactory Design PatternMVC Pattern — Java ProgrammingObserver Design PatternSingleton Design PatternArray Programs — PracticeBasic Java ProgramsCollection ProgramsJDBC ProgramsMultithreading ProgramsOOP ProgramsPlacement Coding QuestionsString Programs — PracticeBanking System — Java ProgrammingChat ApplicationE-Commerce BackendEmployee Management SystemLibrary Management System — Java ProgrammingSpring Boot Fullstack ProjectStudent Management System — Java ProgrammingCoding Interview QuestionsCollections Interview QuestionsCore Java Interview QuestionsJDBC Interview QuestionsMultithreading Interview QuestionsOOPs Interview QuestionsSpring Framework Interview QuestionsJava Cheat SheetImportant Formulas & ConceptsImportant Java ProgramsQuick Revision Notes — Java ProgrammingJava Master Course - Learning Roadmap
Complete guide to Observer pattern — publish-subscribe mechanism, event handling, loose coupling, Java implementation with real-world examples.
Intent
Define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.
UML Structure
| Subject | Observer | |
|---|---|---|
| (interface) | (interface) | |
| + attach(Observer) | ───────▶ | + update(event) |
When to Use
- When changes in one object require changing others, and you don't know how many
- When an object should notify other objects without knowing who they are
- Event handling systems (GUI, message queues)
- Real-time data feeds (stock prices, notifications)
- MVC architecture (Model notifies Views)
Type-Safe Observer with Generics
java example
// Generic event system
interface Observer<T> {
void onEvent(T event);
}
class EventBus<T> {
private final List<Observer<T>> observers = new CopyOnWriteArrayList<>();
public void subscribe(Observer<T> observer) {
observers.add(observer);
}
public void unsubscribe(Observer<T> observer) {
observers.remove(observer);
}
public void publish(T event) {
observers.forEach(o -> o.onEvent(event));
}
}
// Typed events
record OrderCreatedEvent(long orderId, String customer, double total) {}
record OrderShippedEvent(long orderId, String trackingNumber) {}
// Usage
EventBus<OrderCreatedEvent> orderBus = new EventBus<>();
orderBus.subscribe(event ->
System.out.println("Sending confirmation to: " + event.customer()));
orderBus.subscribe(event ->
System.out.println("Updating inventory for order: " + event.orderId()));
orderBus.publish(new OrderCreatedEvent(1001, "Alice", 99.99));Real-World: Stock Market Observer
java example
class StockMarket {
private Map<String, Double> prices = new HashMap<>();
private Map<String, List<StockObserver>> watchers = new HashMap<>();
public void addStock(String symbol, double price) {
prices.put(symbol, price);
watchers.putIfAbsent(symbol, new ArrayList<>());
}
public void watch(String symbol, StockObserver observer) {
watchers.computeIfAbsent(symbol, k -> new ArrayList<>()).add(observer);
}
public void updatePrice(String symbol, double newPrice) {
double oldPrice = prices.getOrDefault(symbol, 0.0);
prices.put(symbol, newPrice);
double changePercent = ((newPrice - oldPrice) / oldPrice) * 100;
StockUpdate update = new StockUpdate(symbol, oldPrice, newPrice, changePercent);
watchers.getOrDefault(symbol, List.of())
.forEach(w -> w.onPriceChange(update));
}
}
interface StockObserver {
void onPriceChange(StockUpdate update);
}
record StockUpdate(String symbol, double oldPrice, double newPrice, double changePercent) {}
class AlertObserver implements StockObserver {
private double threshold;
public AlertObserver(double thresholdPercent) {
this.threshold = thresholdPercent;
}
@Override
public void onPriceChange(StockUpdate update) {
if (Math.abs(update.changePercent()) > threshold) {
System.out.printf("⚠️ ALERT: %s moved %.2f%% ($%.2f → $%.2f)%n",
update.symbol(), update.changePercent(), update.oldPrice(), update.newPrice());
}
}
}Observer with Java Built-in Support
Example
// java.beans.PropertyChangeSupport (still valid in modern Java)
import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
class UserProfile {
private PropertyChangeSupport pcs = new PropertyChangeSupport(this);
private String name;
private String email;
private int loginCount;
public void addPropertyChangeListener(PropertyChangeListener listener) {
pcs.addPropertyChangeListener(listener);
}
public void addPropertyChangeListener(String property, PropertyChangeListener listener) {
pcs.addPropertyChangeListener(property, listener);
}
public void setName(String name) {
String old = this.name;
this.name = name;
pcs.firePropertyChange("name", old, name);
}
public void setEmail(String email) {
String old = this.email;
this.email = email;
pcs.firePropertyChange("email", old, email);
}
public void login() {
int old = this.loginCount;
this.loginCount++;
pcs.firePropertyChange("loginCount", old, loginCount);
}
}
// Usage
UserProfile profile = new UserProfile();
profile.addPropertyChangeListener("email", evt ->
System.out.println("Email changed: " + evt.getOldValue() + " → " + evt.getNewValue()));
profile.addPropertyChangeListener(evt ->
System.out.println("Property " + evt.getPropertyName() + " changed"));
profile.setEmail("new@email.com");
Thread-Safe Observer
java example
class ThreadSafeEventManager<T> {
private final List<Observer<T>> observers = new CopyOnWriteArrayList<>();
private final ExecutorService executor = Executors.newFixedThreadPool(4);
public void subscribe(Observer<T> observer) {
observers.add(observer);
}
public void unsubscribe(Observer<T> observer) {
observers.remove(observer);
}
// Synchronous notification
public void notifySync(T event) {
for (Observer<T> observer : observers) {
try {
observer.onEvent(event);
} catch (Exception e) {
System.err.println("Observer error: " + e.getMessage());
}
}
}
// Asynchronous notification
public void notifyAsync(T event) {
for (Observer<T> observer : observers) {
executor.submit(() -> {
try {
observer.onEvent(event);
} catch (Exception e) {
System.err.println("Async observer error: " + e.getMessage());
}
});
}
}
public void shutdown() {
executor.shutdown();
}
}Interview Questions
Q1: What is the Observer pattern and where is it used?
Answer: Observer defines a one-to-many dependency where subject state changes automatically notify all observers. Used in: event systems, GUI frameworks, MVC (Model→View), reactive programming, message brokers, and real-time updates.
Q2: What is the difference between Observer and Pub/Sub?
Answer: In Observer, subject knows about observers directly (tight coupling to interface). In Pub/Sub, publishers and subscribers are completely decoupled via a message broker/event bus. Pub/Sub is more scalable for distributed systems.
Q3: How do you prevent memory leaks with Observer?
Answer: Use weak references for observers, provide explicit unsubscribe methods, use CopyOnWriteArrayList for thread-safe iteration, and ensure long-lived subjects don't hold references to short-lived observers (common in Android/GUI).
Q4: What is the difference between push and pull models?
Answer: Push: subject sends all data in the update notification (observers may get data they don't need). Pull: subject sends minimal notification, observers query the subject for specific data they need. Push is simpler; Pull is more flexible.
Q5: Where is Observer used in Java standard library?
Answer: java.beans.PropertyChangeListener, java.util.EventListener, Swing listeners (ActionListener, MouseListener), JavaFX observable properties, java.util.concurrent.Flow (reactive streams since Java 9).
Summary
In this chapter, we learned about Observer Design Pattern in detail. Here are the key points:
- Basic introduction to the concept and why it is needed
- Syntax and structure with complete examples
- Internal working and best practices
- Real-world applications and use cases
- Common mistakes and how to avoid them
- How this topic is asked in interviews
To practice these concepts, write and run the code in your IDE and verify the output. Modify each example and experiment so that you deeply understand the concept.
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Observer Design Pattern.
Interview Use
Prepare one clear explanation, one practical example, and one common mistake for this Java Master Course topic.
Search Terms
java-master-course, java master course, java, master, course, design, patterns, observer
Related Java Master Course Topics
Continue learning this concept
Design PatternsAdapter Design PatternComplete guide to Adapter pattern — class adapter vs object adapter, real-world integration scenarios, and bridging incompatible interfaces in Java.Design PatternsBuilder Design PatternComplete guide to Builder pattern — step-by-step construction, fluent interfaces, Director, telescoping constructor problem, and real-world Java implementations.Design PatternsFactory Design PatternComplete guide to Factory patterns — Simple Factory, Factory Method, and Abstract Factory with UML, Java implementations, and real-world applications.Design PatternsMVC Pattern — Java ProgrammingComplete guide to Model-View-Controller pattern — separation of concerns, Java implementation, comparison with other architectural patterns, and real-world applications.Design PatternsSingleton Design PatternComplete guide to Singleton pattern — all implementation approaches, thread safety, serialization protection, enum singleton, and when to use vs avoid.Collections FrameworkCollections Framework OverviewComplete guide to Java Collections Framework covering hierarchy, interfaces, implementations, algorithms, and choosing the right collection for your use case.