Are there any rules for OOP?

by

Seems like what you’re looking for are the Principles of Object-Oriented Design.

Summarized from Agile Software Development Principles, Patterns, and Practices. These principles are the hard-won product of decades of experience in software engineering. They are not the product of a single mind, but they represent the integration and writings of a large number of software developers and researchers. Although they are presented here as principles of object-oriented design, they are really special cases of long-standing principles of software engineering.

SRP The Single Responsibility Principle A class should have only one reason to change.

OCP The Open-Closed Principle Software entities (classes, packages, methods, etc.) should be open for extension, but closed for modification.

LSP The Liskov Substition Principle Subtypes must be substitutable for their base types.

DIP The Dependency Inversion Principle Abstractions should not depend upon details. Details should depend upons abstractions.

ISP The Interface Segregation Principle
Clients shold not be forced to depend upon methods that they do not use. Interfaces belong to clients, not to hierarchies.

REP The Release-Reuse Equivalency Principle
The granule of reuse is the granule of release.

CCP The Common Closure Principle
The classes in a package should be closed together against the same kinds of changes. A change that affects a closed package affects all the classes in that package and no other packages.

CRP The Common Reuse Principle
The classes in a package are reused together. If you reuse one of the classes in a package, you reuse them all.

ADP The Acylcic Dependencies Principle
Allow no cycles in the dependency graph.

SDP The Stable Dependencies Principle
Depend in the direction of stability.

SAP The Stable Abstractions Principle
A package should be as abstract as it is stable.

More Related Contents:

  1. What is an example of the Liskov Substitution Principle?
  2. What is the dependency inversion principle and why is it important?
  3. What is the scope of the Single Responsibility Principle? [closed]
  4. What is the meaning and reasoning behind the Open/Closed Principle?
  5. Interface Segregation Principle- Program to an interface
  6. What is an example of the Single Responsibility Principle? [closed]
  7. Can’t seem to understand SOLID principles and design patterns [closed]
  8. Does the Single Responsibility Principle work in OOP?
  9. In SOLID, what is the distinction between SRP and ISP? (Single Responsibility Principle and Interface Segregation Principle)
  10. Why doesn’t Rust support trait object upcasting?
  11. Inheritance vs. Aggregation [closed]
  12. Constructors vs Factory Methods [closed]
  13. Why would I want to use Interfaces? [closed]
  14. When should one use interfaces?
  15. What is the difference between an abstract method and a virtual method?
  16. What is the difference between aggregation, composition and dependency? [duplicate]
  17. Do write-only properties have practical applications?
  18. R and object oriented programming
  19. is it possible to call overridden method from parent struct in Golang?
  20. DDD – the rule that Entities can’t access Repositories directly
  21. When to use interfaces or abstract classes? When to use both?
  22. Are Polymorphism , Overloading and Overriding similar concepts? [closed]
  23. Can you explain Liskov Substitution Principle with a good C# example? [closed]
  24. When to implement an interface and when to extend a superclass?
  25. Mixin vs inheritance
  26. What does ‘low in coupling and high in cohesion’ mean
  27. Learning/Implementing Design Patterns (For Newbies) [closed]
  28. When to use a Class in VBA?
  29. VBA: how to test for object equality (whether two variables reference the same object)
  30. Overloading functions

Leave a Comment