meta description: Learn key techniques for mastering generalization in object-oriented programming, including pull-up, push-down, extract interface, and superclass strategies, with clear examples and practical applications.

1. Pull Up Field

• Scenario: Two child classes share the same attribute.
• Solution: Move the attribute to the parent class to reduce redundancy.
• Example: If Employee and Manager both have an Email attribute, move Email to the parent class Person:

  public class Person
  {
      public string Email { get; set; }
  }

  public class Employee : Person { ... }
  public class Manager : Person { ... }

2. Pull Up Method

• Scenario: Two child classes have the same method implementation.
• Solution: Move the method to the parent class.
• Example: If Rectangle and Circle both have a CalculateArea() method, move it to the parent class Shape:

  public abstract class Shape
  {
      public abstract double CalculateArea();
  }

3. Push Down Field

• Scenario: Only one child uses an attribute in the parent class.
• Solution: Move the attribute to the child class to avoid unused fields or null values.
• Example: If only Car uses the EngineType field in the parent class Vehicle, move EngineType to Car:

  public class Vehicle { ... }

  public class Car : Vehicle
  {
      public string EngineType { get; set; }
  }

4. Push Down Method

• Scenario: Only one child implements a specific method in the parent class.
• Solution: Move the method to the child class to avoid throwing NotImplementedException.
• Example: If only MobileApp implements the SendPushNotification() method in Software, move SendPushNotification() to MobileApp:

  public class Software { ... }

  public class MobileApp : Software
  {
      public void SendPushNotification() { ... }
  }

5. Extract Interface

• Scenario: Two or more classes have similar methods or properties.
• Solution: Create an interface and move the shared declarations to it.
• Example: For Printer and Scanner, create an IMachine interface:

  public interface IMachine
  {
      void Start();
      void Stop();
  }

  public class Printer : IMachine { ... }
  public class Scanner : IMachine { ... }

6. Extract Subclass

• Scenario: A class has features used only in specific cases.
• Solution: Create a subclass and move these features to it.
• Example: If Document has a GenerateDigitalSignature() method used only for LegalDocument, move the method to a LegalDocument subclass:

  public class Document { ... }

  public class LegalDocument : Document
  {
      public void GenerateDigitalSignature() { ... }
  }

7. Extract Superclass

• Scenario: Multiple classes share fields or methods.
• Solution: Create a shared parent class and move the shared functionality to it.
• Example: If Mobile, Tablet, and Laptop all have common fields (ModelName, Price, Brand) and methods, create a Gadget superclass:

  public class Gadget
  {
      public string ModelName { get; set; }
      public decimal Price { get; set; }
      public string Brand { get; set; }
  }

  public class Mobile : Gadget { ... }
  public class Tablet : Gadget { ... }
  public class Laptop : Gadget { ... }

Key Takeaways

• These generalization techniques are effective for refactoring and improving code structure.
• Updated examples ensure applicability across various domains, such as business, software, and devices.
• Refactoring tools like those in Visual Studio can assist in implementing these techniques efficiently.

\