top of page

Avoid God Class in OO Programming

When we learn programming we tend to put all the code in the same function or even in the same file. Especially in the functional programming paradigm, for example in C, where the program logic is driven by sequence of method calls and execution logic rather than communication between objects. Object oriented programming supports communication driven program execution among representations of real world objects. In functional programming as the starting point is the main method we tend to write the whole program in the same method. Sometimes we factor out the logic in separate methods which are called sequentially from the main method. At best we create separate files that contain few methods, this file can be reused. In Object oriented programming everything revolves around a few objects where one of the classes contains the main method and acts as the entry point. Object Oriented design principles suggest that there should not be one single God class. Today we will discuss what that exactly means and how to avoid creating God class.




What is a God Class or a God Object?

A God class is a class that tends to have every solution possible logic. Rather than provisioning a solution to a specific problem a God Glass tends to have different kinds of code logic that solve different problems. When we can call different methods on the same object to perform different tasks we can say the object is doing too much and it's a God object. Wikipedia has a good explanation on the God object.

Why do we need to avoid God Class and God Object ?

There are many problems that are associated with God classes and God objects. Few of them I have mentioned here:

  • The size of code with a class increases and makes it unnecessarily complex.

  • God Class and God objects creates tight coupling between unrelated code which becomes difficult to enhance and maintain in future.

  • The single responsibility principle in object oriented design principles says one class should only do one thing. This principle is not followed in God classes and God objects.

  • As these classes and objects do many tasks they lack modularization concept which hinders code reusability.

  • Different independent code logics are intertwined in God classes and God objects. For this reason, testing of each functionality separately becomes difficult.

How to detect God Class ?

I have listed a few tips that will help you detect God Class and God Object.

  • Like the main method in C which is the entry point and central component that manages the whole working and dataflow, when you find similar classes or methods you can smell God Class.

  • Generally Gog Classes have a large number of code lines.

  • A class that performs several tasks to solve different not related or less related problems are candidates for God Class. Generally these classes offer a lot of functionality which are not related.

  • When a class has many unrelated properties and exposes methods to manipulate or fetch those properties, this class becomes a God Class.

How to refactor a God class ?

A systematic approach will let you identify, plan and get rid of the God classes and God objects.

  • The first step is to identify the God classes and objects in each package and module.

  • Next, we need to identify the clients of the God classes and objects who use these classes and objects. It will help us to assess the impact of the change we are going to perform.

  • Then we need to come up with a new low level design to remove God classes and objects. In the design we need to take care of these below points.

a. For the static methods a separate utility class needs to be created because an object is not needed to invoke the static methods.

b. Similarly the static and final variables can be separated out.

c. Group common methods and properties following single responsibility principle. Create separate classes for each group.

d. Use inheritance, association and aggregation to establish a clear relationship among the classes.

e. Use high cohesion and low coupling principles.

  • Factor out the less frequently used part first and then work on refactoring other parts.

  • Create unit tests to test the new code thoroughly.

How to avoid creating a God class ?

There should not be one single class that does all. Instead there should be a bunch of classes which are needed to perform some tasks in a certain sequence, and will be used at different points of time in the sequence. In certain scenarios it makes sense that, once the work of a class is completed it can be garbage destroyed or collected. To avoid one class performing more than one task, before creating a class create an interface and define the methods the interface will contain. Carefully, look at the interface methods to judge whether the methods solve only one task and the contract as a whole provides one functionality. Once you are sure, implement the interface in a class.

Example of God Class and its solution

Here is an example of a God class that does many things. We can use it to fetch and save employee details. Then, it also calculates tax on salary and it also prints the employee details.

public class EmployeOperation {
 public Employee getEmployeeDetails() { … }
 public void saveEmployeeDetails(Employee employee) { … }
 public double calculateTaxOnSalary(Employee employee) { … }
 public void printEmployeeDetails(Employee employee) { … }

Clearly, we can group, fetch and save employee details together and keep it in one class. We can create a separate class that works on tax calculation and print employee details.

In this blog post we have learned about God class and God object, their impact on code. We have also learned how to detect them, how to refactor code to remove God classes and objects and how to avoid creating new God classes and objects.


bottom of page