1 简介

类之间的泛化从两个或多个类中取出公共属性和功能并将它们组合成另一个类的过程，该类充当这些类的父类，或者我们可以说是这些特殊类的广义类。

如下此图中，我们有两种类型的航班，因此我们创建了一个航班类，该航班类将包含公共属性，然后有一个国际和国内航班，它们是航班类的扩展，将具有航班属性以及它们自己的属性。

• 泛化的限制特征

大多数人认为泛化主要起到扩展的作用，其实子类必须继承其父类的所有特征，尽管它可以通过覆盖它来改变其实现，但它不能忽略父类的任何特征。这表达了泛化的限制形式。

• 泛化的扩展特征

另外还需要看到 child 类有自己的属性，而 parent class 对象不能使用这些属性，因为这些扩展属性只属于子类。这种额外属性的添加显示了一种可扩展的泛化形式

2 扩展示例

所有的子类都是一种超类。所以我们可以说子类是一个超类。因此，泛化被称为 “子类关系” 以下是泛化的一个例子：

	// super or parent class
  class Person 
  {
      static int count = 1;
      String name;
      int age;
      String gender;
  }

  // subclass or child of Person
  class Student extends Person 
  { 
      // name, age and gender 
      // get inherited from Person
      int rollNo;
      String course;
  }

  // subclass of Person
  class Teacher extends Person 
  { 
      // name, age and gender 
      // get inherited from Person
      static int count = 20;
      String subject;
      int experience;
  }

两个类 Teacher 和 Student，它们具有 name、age 和 gender 等公共属性，因此我们创建了另一个具有这些属性的类 Person，然后从中扩展这两个类。

现在，当我们创建 teacher 类的对象时，我们也具有 person 类的所有属性。在这里，我们看到 teacher 类有自己的 count 值，因此这将隐藏 parent 的值。我们没有在 teacher class 中给出 “name” 属性，但我们仍在使用它。

这是因为父类的所有属性和方法都继承到子类中。我们在 teacher class 中提供了仅属于 teacher class 的附加属性。这些附加属性显示泛化为子类提供的扩展。

3 限制的示例

	// abstract super class
  abstract class User
  {
      String name;
      int age;
      String occupation;

      // abstract method
      abstract void fillForm(String name, String occupation); 
  }

  // non abstract sub class of User
  class Doctor extends User 
  {
      String specialization;

      // extra attributes
      int experience; 

      // doesn't give implementation of fillForm() method
  }

该实例中User 是一个抽象类，它有一个抽象 methodfillForm（），因为患者和医生的表单会有所不同，因此填写表单也会不同。

现在 doctor 类要么必须提供它的主体，要么必须声明自己是抽象的。这是 superclass 对其 child class 的限制，即 child class 必须继承其所有属性和功能，并且不能跳过任何属性和功能。

它们可以通过覆盖现有特征来提供另一种实现，但不能跳过它。

4 订单的示例

	type OrderProcessor interface {
			ProcessOrder(orderID string)
		}

		type OnlineOrderProcessor struct{}

		func (oop *OnlineOrderProcessor) ProcessOrder(orderID string) {
			fmt.Println("Processing online order with ID:", orderID)
		}

		type InStoreOrderProcessor struct{}

		func (iop *InStoreOrderProcessor) ProcessOrder(orderID string) {
			fmt.Println("Processing in-store order with ID:", orderID)
		}

		func main() {
			var processor OrderProcessor

			processor = &OnlineOrderProcessor{}
			processor.ProcessOrder("12345")

			processor = &InStoreOrderProcessor{}
			processor.ProcessOrder("67890")
		}

5 总结

  关系	描述											实现方法
  关联	两个类之间的连接，通常通过指针实现。			指针引用另一个类。
  聚合	“整体-部分”关系，部分可以独立存在。			指针集合引用部分对象。
  组合	“整体-部分”关系，部分依赖整体存在。			直接嵌套部分对象。
  依赖	一个类临时使用另一个类，通常作为参数或变量。	方法参数或局部变量使用另一个类。
  泛化	父类与子类关系，子类继承父类行为。			接口与实现。

本文通过示例，展示了如何实现泛化关系，结合实际业务场景灵活应用，可以构建清晰且可维护的代码架构。