🧱Java OOP Programs

Defines a class that mixes an unimplemented method with a ready-to-use one.

Declares a method with no body that every concrete subclass is forced to implement.

Models a Library that holds Book objects created independently, outside of it.

Models a Student that references an assigned Teacher, with neither owning the other.

Models a Library that creates and owns its own Book objects internally.

Defines two constructors with different parameter lists for the same class.

Introduces constructors as the special method that initializes a newly created object.

Defines a simple class and creates an object from it.

Shows the no-argument constructor Java supplies automatically when a class declares none of its own.

Models a Printer that uses a Document only for the duration of a single method call.

A class with a private field that validates every value before storing it.

Defines a fixed set of constants as an enum, each carrying its own data.

Marks a class so it can never be extended by any subclass.

Marks a single method so it can never be overridden, while the rest of the class stays open to subclassing.

A final variable assigned once and never reassigned.

A class with private fields accessed only through matching getter and setter methods.

Defines a method that reads an object's own fields to produce a per-object result.

Shows that every object gets its own independent copy of a class's fields.

Checks an object's actual type at runtime before acting on it differently.

A single interface implemented by a single class.

Defines the same method name multiple times with different parameter lists.

A single class implementing two unrelated interfaces at once.

Introduces nested classes with the simplest case — a static nested class.

Shows the default toString(), equals(), and getClass() behavior every class inherits from Object, before any overriding.

Initializes an object's fields at creation time using constructor arguments.

One subclass extends one parent class and inherits its members directly.

Defines a utility method callable directly on the class, without creating an object.

Uses a static field to track a count shared across every object of a class.

Uses super to call a parent class's constructor and its overridden method.

Uses this to distinguish a constructor parameter from a field of the same name.

Overrides toString() to return a custom, readable string instead of Java's default format.

Assigns a subclass object to a variable typed as its parent class.

Implements an interface inline, without ever declaring a separate named class.

Implements Cloneable to create a duplicate object using Java's built-in clone() mechanism.

Builds a new object by copying another object's field values.

Writes a type-safe Stack<T> class once and reuses it for strings and integers without any casts.

Converts a parent-typed reference back to its actual subclass type.

Overrides equals() to compare two objects by their field values instead of reference identity.

An interface with a single abstract method, implemented inline with a lambda.

Overrides hashCode() so it stays consistent with an equals() override.

One parent class extended separately by multiple sibling subclasses.

A class whose objects can never be modified after they're constructed.

A base class extended by a subclass with overridden behavior.

Demonstrates a non-static inner class that needs an outer instance and can read the outer object's fields directly.

An interface extending another interface, adding its own extra method.

Multiple classes implementing a shared interface.

Defines a named class entirely inside a method body, scoped to that one method.

A static method in a subclass hides the parent's static method of the same signature.

A three-class chain where each class extends the one before it.

A static utility method defined directly on an interface, called through the interface name.

Uses a static nested Builder class to construct instances of the outer class step by step.

Notifies every subscribed observer whenever a product's price changes, using the Observer design pattern.