Tagged articles
Object-Oriented Design
28 articles · Page 1 of 1
The article explains how the Bridge design pattern separates two orthogonal dimensions—such as order type and notification channel—into independent hierarchies, replacing inheritance‑driven class explosion with compositional bridges, and demonstrates its rationale, code, real‑world examples, and differences from similar patterns.
Bridge PatternComposition Over InheritanceJava
0 likes · 14 min read

This article explains the five SOLID object‑oriented design principles with everyday Java scenarios, showing bad implementations, proper refactorings, practical criteria for each rule, and common pitfalls to help developers write more maintainable and extensible code.
Design PrinciplesJavaObject-Oriented Design
0 likes · 9 min read

The article explains that design patterns rely on solid design principles—SRP, OCP, LSP, DIP, ISP, LoD, and CARP—using a flawed order‑processing example to show each principle, how to refactor the code, and why over‑engineering must be avoided.
Design PrinciplesJavaObject-Oriented Design
0 likes · 24 min read

This article expands the SOLID principles into a three‑layer framework—class, pattern, and component levels—clarifying common misinterpretations, presenting correct definitions with concrete examples, and showing how GRASP and design patterns operationalize these principles for stable, low‑coupling software.
Design PrinciplesGRASPObject-Oriented Design
0 likes · 14 min read

This article explains the Adapter design pattern, demonstrates step‑by‑step how to wrap existing PayPal payment code with a Stripe adapter in TypeScript, and discusses best practices, common pitfalls, and extensions such as factories and nested adapters for flexible payment integration.
Object-Oriented DesignPayment IntegrationTypeScript
0 likes · 13 min read

This article examines Kubernetes’ Kubelet component through an object‑oriented lens, detailing its role, key responsibilities, abstract properties and methods, and illustrating implementation steps such as resource checks and pod scheduling, to show how OO abstraction clarifies complex system behavior.
KubernetesObject-Oriented Designcloud-native
0 likes · 5 min read

The article explains how object‑oriented analysis and design should treat exceptions by using RAII for automatic resource cleanup, avoiding error‑code patterns, and adopting a throw‑by‑default policy with strongly‑typed exceptions, illustrating concepts with C++ and VB.NET examples and framework design recommendations.
C++Exception HandlingObject-Oriented Design
0 likes · 38 min read

This article provides a comprehensive explanation of the Composite Reuse Principle (CRP), covering its definition, background, advantages over inheritance, UML representation, practical Java code examples, and guidelines for choosing between composition and inheritance in object‑oriented design.
Composite Reuse PrincipleComposition Over InheritanceJava
0 likes · 11 min read

This article explains why hard‑coded if‑else logic hinders extensibility, introduces the Strategy pattern, shows its structure and Java implementation for data synchronization, then enhances the design with a Factory to decouple object creation, concluding with best‑practice recommendations.
Factory PatternJavaObject-Oriented Design
0 likes · 8 min read

This article explains the five SOLID object‑oriented design principles—Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion—while also promoting a PHP online training program that covers modern web technologies and offers enrollment via QR code or contact details.
BackendObject-Oriented DesignPHP
0 likes · 2 min read

The article discusses how to give each class object a unique identifier, compares inheritance and composition for associating objects, and examines the trade‑offs of each approach using C++ examples, ultimately suggesting that the choice should depend on hierarchy depth and maintenance cost.
C++CompositionInheritance
0 likes · 5 min read

Anemic domain models separate data and behavior, leading to procedural code and maintenance challenges, while rich (or “充血”) models embed logic within objects, offering clearer OOP design, better encapsulation, and scalability, though they require careful design to avoid complexity.
Object-Oriented DesignRich Modelanemic model
0 likes · 10 min read

The article explains the differences between the anemic (transaction‑script) and rich (domain‑model) approaches in DDD, discusses their historical origins, advantages, drawbacks, and provides guidance on when and how to apply each model in software design.
Object-Oriented DesignRich Modelanemic model
0 likes · 9 min read


ByteFEOct 14, 2021 · Fundamentals
This article explains the Strategy Design Pattern, a behavioral design pattern that enables defining a family of algorithms, encapsulating each one, and making them interchangeable to improve code maintainability and flexibility in software development.
Form ValidationObject-Oriented DesignStrategy Pattern
0 likes · 7 min read

This article explains the philosophical basis of object‑oriented thinking, distinguishes objects from things, discusses attributes and methods, compares object‑oriented and data‑model designs with Java and SQL examples, and clarifies composition and aggregation through real‑world and code illustrations.
CompositionJavaObject-Oriented Design
0 likes · 13 min read

This article explains why understanding the underlying logic of design patterns—identifying change and encapsulating it—is essential for writing flexible, maintainable code, and shows how this principle applies to both software architecture and real‑world business scenarios.
EncapsulationObject-Oriented Designdesign patterns
0 likes · 15 min read

This article explains behavioral design patterns—how they manage complex runtime interactions among classes or objects, outlines the eleven classic patterns with their motivations, class diagrams, advantages, disadvantages, and typical scenarios, and shows why object‑based patterns offer greater flexibility than class‑based ones.
Object-Oriented Designbehavioral patternsdesign pattern examples
0 likes · 22 min read

This article explains why mastering the underlying logic of design patterns—recognizing what changes and how to encapsulate those changes—is essential for developers to select appropriate patterns, improve object‑oriented design, and solve real‑world software problems effectively.
Object-Oriented Designchange encapsulationsoftware architecture
0 likes · 15 min read

This article examines the anemic (transaction‑script) versus rich (active) domain model patterns, explaining their origins, drawbacks, and benefits, and shows why embedding behavior in domain objects aligns with true object‑oriented design while over‑reliance on service layers leads to costly anti‑patterns.
Object-Oriented DesignRich Modelanemic model
0 likes · 8 min read

The article explains the fundamental differences between the anemic (transaction‑script) and rich (domain‑model) approaches in DDD, discusses their historical origins, advantages, disadvantages, and provides concrete examples to help developers decide when to apply each model in software architecture.
Object-Oriented DesignRich Modelanemic model
0 likes · 8 min read

This article explains the five SOLID object‑oriented design principles—Single Responsibility, Open‑Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion—using clear diagrams and concrete examples to show their goals, proper usage, and common pitfalls.
Object-Oriented DesignSOLIDdesign patterns
0 likes · 7 min read

This article explains the six core object‑oriented design principles—Single Responsibility, Open/Closed, Liskov Substitution, Dependency Inversion, Interface Segregation, and Law of Demeter—detailing their definitions, benefits, and Java code examples to illustrate proper application.
Design PrinciplesJavaOCP
0 likes · 12 min read

This article walks through creating a lightweight Plants vs Zombies‑style game in Java, covering object‑oriented design of plants, zombies and bullets, pause handling, collision detection, movement and attack logic, as well as several code‑level optimizations and background music integration.
Collision DetectionJavaObject-Oriented Design
0 likes · 19 min read

This article details the design, architecture, and code implementation of a simplified Plants vs Zombies game in Java, covering game objects, pause functionality, object interactions, movement, collision detection, optimization techniques, and additional features such as rewards, background music, and future enhancements.
Audio IntegrationCollision DetectionJava
0 likes · 18 min read

The article explains essential object‑oriented design principles—SOLID for class design and six package‑level rules—showing how proper dependency management and modular organization create flexible, reusable, and maintainable software, and why developers must understand these concepts beyond basic procedural programming.
Dependency ManagementDesign PrinciplesObject-Oriented Design
0 likes · 6 min read

After years of coding without guidance, the author shares practical insights on developing object‑oriented design thinking, when to use interfaces, the limits of OOD, and how continuous refactoring and learning design patterns can gradually build a junior developer’s architectural competence.
Object-Oriented Designdesign patternsrefactoring
0 likes · 11 min read

This article explains core refactoring techniques—Move Method, Move Field, Extract Class, Inline Class, Hide Delegate, Remove Middle Man, Introduce Foreign Method, and Introduce Local Extension—showing when to apply each, how to identify candidates, and the benefits for cleaner, more maintainable object‑oriented code.
Object-Oriented Designextract classmove method
0 likes · 11 min read

This article introduces the GRASP (General Responsibility Assignment Software Patterns) principles, outlines its nine core patterns—including Information Expert, Creator, High Cohesion, Low Coupling, Controller, Polymorphism, Pure Fabrication, Indirection, and Protected Variations—and explains how they guide responsibility assignment, object discovery, and design decisions to achieve high cohesion and low coupling in object‑oriented systems.
GRASPObject-Oriented Designresponsibility assignment
0 likes · 25 min read
