从活字印刷到ArkTS封装：探索代码复用的智慧传承

本文链接：https://blog.csdn.net/hqy1989/article/details/145693843

活字印刷术：古老的封装智慧

在漫长的人类文明进程中，活字印刷术的出现无疑是一座具有划时代意义的里程碑。它诞生于北宋庆历年间，由平民发明家毕昇创造，这一伟大发明的出现并非偶然，而是社会发展与技术进步的必然结果。

在活字印刷术发明之前，雕版印刷术盛行一时。这种印刷方式需要在一整块木板上雕刻出整页的文字或图案，然后进行印刷。虽然它在一定程度上满足了当时社会对书籍复制的需求，但随着时间的推移，其局限性也日益凸显。雕版印刷不仅耗时费力，每印一页书都需要雕刻一块版，而且一旦雕刻过程中出现错误，整个雕版就可能报废，成本极高。此外，雕版印刷的灵活性较差，难以对内容进行修改和调整。

毕昇敏锐地察觉到了雕版印刷的这些问题，经过反复的试验和探索，发明了活字印刷术。活字印刷术的基本原理是将单个的文字或符号制成独立的可移动部件，即活字。这些活字可以根据需要进行排列组合，形成不同的内容，然后进行印刷。使用完毕后，活字可以拆卸下来，重复使用。

活字印刷术的工艺流程主要包括制活字、排版、印刷三个关键步骤。在制活字环节，毕昇最初使用胶泥制作活字，他将胶泥制成一个个小方块，在上面刻上反字，然后用火烧硬，使其成为坚固耐用的活字。后来，人们又逐渐发明了木活字、金属活字等，如元朝王祯对木活字进行了改进与完善，13 世纪前后出现了锡活字，明清以后金属活字印刷逐渐占据主流。

排版时，工匠们会根据文稿内容，从众多的活字中挑选出所需的字，按照顺序排列在一个特制的铁框或木框内，并用松脂、蜡、纸灰等混合物将活字固定，使其成为一个完整的印版。这种排版方式极大地提高了印刷的灵活性和效率，不再需要像雕版印刷那样为每一页书都雕刻一块版。

印刷过程则是将调好的墨汁均匀地涂抹在排好版的活字上，然后铺上纸张，通过一定的压力使活字上的墨汁转移到纸张上，从而完成印刷。印完后，将活字版加热，使松脂、蜡等熔化，便可轻松地将活字拆卸下来，分类存放，以备下次使用。

从封装的角度来看，活字印刷术堪称是早期人类对封装概念的一次精妙实践。每个活字都可以看作是一个独立的 “封装单元”，它们被赋予了特定的功能 —— 代表一个特定的文字。这些活字在制作完成后，被整齐地存放在特制的木格子中，按照一定的规律进行分类，就像现代编程中封装好的模块被妥善管理一样。当需要印刷时，工匠们根据文稿内容，从这些 “封装单元” 中挑选出合适的活字，将它们组合在一起，形成一个完整的印版，这就如同在编程中调用各种封装好的模块来构建一个完整的功能。

活字印刷术的出现，彻底改变了书籍的印刷方式，大大提高了印刷效率，降低了印刷成本，使得知识的传播变得更加容易和广泛。它不仅对中国的文化、教育、科技等领域产生了深远的影响，还通过丝绸之路等途径传播到世界各地，对世界文明的发展进程起到了重要的推动作用。

编程中的封装概念

在编程的世界里，封装同样是一个至关重要的概念，它是面向对象编程（OOP）的核心特性之一，其重要性不言而喻。简单来说，封装就是将数据和操作这些数据的方法捆绑在一起，形成一个独立的单元，即对象，并对外部隐藏其内部的具体实现细节，只对外暴露必要的接口。

以现实生活中的汽车为例，汽车可以看作是一个封装的对象。汽车的内部结构，如发动机的工作原理、各种零部件之间的协同运作等，对于大多数驾驶者来说都是隐藏的。驾驶者只需要通过操作方向盘、油门、刹车等外部接口，就可以实现对汽车的控制，完成驾驶的行为。同样，在编程中，封装的目的就是将复杂的内部实现隐藏起来，只提供简单易用的接口给外部调用，从而提高代码的安全性、可维护性和可复用性。

在 ArkTS 语言中，封装的实现主要是通过类（class）来完成的。类是一种自定义的数据类型，它可以包含属性（数据）和方法（操作数据的行为）。通过将相关的数据和方法封装在一个类中，可以将它们组织成一个逻辑上的整体，便于管理和维护。

例如，我们可以创建一个简单的Person类，用来表示人的信息和行为：

class Person {
    // 私有属性，只能在类内部访问
    private name: string; 
    private age: number; 

    // 构造函数，用于初始化对象的属性
    constructor(name: string, age: number) { 
        this.name = name;
        this.age = age;
    }

    // 公共方法，用于获取name属性
    getName(): string { 
        return this.name;
    }

    // 公共方法，用于设置name属性
    setName(name: string): void { 
        this.name = name;
    }

    // 公共方法，用于获取age属性
    getAge(): number { 
        return this.age;
    }

    // 公共方法，用于设置age属性
    setAge(age: number): void { 
        if (age >= 0) {
            this.age = age;
        } else {
            console.error('年龄不能为负数');
        }
    }
}

在上述代码中，Person类封装了name和age两个属性，并且通过getName、setName、getAge和setAge等公共方法来提供对这些属性的访问和修改接口。这些属性被声明为private，这意味着它们只能在类的内部被访问，外部代码无法直接访问和修改这些属性，从而保证了数据的安全性和一致性。

如果在外部代码中尝试直接访问或修改private属性，会导致编译错误。例如：

let person = new Person('张三', 20);
// 以下代码会报错，因为name是private属性，无法直接访问
console.log(person.name); 
// 以下代码会报错，因为age是private属性，无法直接修改
person.age = 21;

正确的做法是通过类提供的公共方法来访问和修改属性：

let person = new Person('张三', 20);
console.log(person.getName()); // 输出: 张三
person.setName('李四');
console.log(person.getName()); // 输出: 李四
console.log(person.getAge());  // 输出: 20
person.setAge(21);
console.log(person.getAge());  // 输出: 21

通过这种方式，封装不仅保护了数据的安全性，还提高了代码的可维护性。如果将来需要修改Person类的内部实现，比如修改age属性的存储方式或者添加一些验证逻辑，只需要在类的内部进行修改，而不会影响到外部使用该类的代码。

除了保护数据和提高可维护性外，封装还可以提高代码的复用性。一旦一个类被封装好，它就可以在不同的项目或模块中被重复使用。例如，我们可以在一个电商系统中使用Person类来表示用户信息，也可以在一个社交网络应用中使用它来表示用户资料。只要类的接口保持不变，就可以方便地在不同的场景中复用该类，减少了代码的重复编写，提高了开发效率。

ArkTS 中的封装实践

封装网络请求

在应用开发中，网络请求是非常常见的操作。以一个简单的网络请求封装为例，假设我们正在开发一个新闻客户端应用，需要从服务器获取新闻列表数据。我们可以创建一个NetworkManager类来封装网络请求相关的操作。

首先，定义网络请求的参数和返回结果的数据结构：

// 请求参数
interface RequestParams {
  url: string;
  method: string;
  headers?: Record<string, string>;
  body?: string;
}

// 网络请求返回结果
interface ResponseData {
  statusCode: number;
  headers: Record<string, string>;
  body: string;
}

然后，实现NetworkManager类，其中包含一个request方法来执行网络请求：

class NetworkManager {
  async request(params: RequestParams): Promise<ResponseData> {
    return new Promise((resolve, reject) => {
      const request = http.createHttp();
      request.request(params.url, {
        method: params.method as http.RequestMethod,
        extraData: params.body,
        expectDataType: http.HttpDataType.STRING
      }, (err, data) => {
        if (err) {
          reject(err);
        } else {
          const responseData: ResponseData = {
            statusCode: data.responseCode,
            body: data.result as string,
            headers: {
              'Content-Type': 'application/json',
              'Server': 'Apache'
            },
          };
          resolve(responseData);
        }
        request.destroy();
      });
    });
  }
}

在上述代码中，NetworkManager类封装了网络请求的具体实现细节。通过request方法，我们只需要传入请求参数，就可以发起网络请求并获取返回结果。外部调用者不需要了解网络请求的底层实现，如如何创建http请求对象、如何设置请求参数、如何处理响应等，只需要关注业务逻辑即可。

使用时，我们可以这样调用：

// 假设这是错误类型
type RequestError = Error;

const networkManager = new NetworkManager();

const requestParams: RequestParams = {
    url: 'https://example.com/api/news',
    method: 'GET'
};

networkManager.request(requestParams).then((response: ResponseData) => {
    console.log('Response:', response);
    // 处理新闻列表数据，展示在界面上
    // 这里可以添加展示新闻列表的逻辑
}).catch((error: RequestError) => {
    console.error('Request Error:', error);
});

通过这种封装方式，不仅提高了代码的复用性，使得在不同的页面或模块中发起网络请求变得更加简单和统一，而且降低了代码的维护成本。如果后续需要修改网络请求的实现方式，比如更换网络库或者添加一些通用的请求头，只需要在NetworkManager类中进行修改，而不会影响到其他使用网络请求的地方。

UI 组件封装

在鸿蒙应用开发中，UI 组件的封装是提高开发效率和代码复用性的重要手段。以一个常见的导航栏组件为例，我们可以使用@Component和struct来封装一个可复用的导航栏组件。

首先，创建一个导航栏组件NavigationBar：

@Component
export struct NavigationBar {
  @Prop title: string;
  @Prop onBack?: () => void;
  @Prop onMore?: () => void;

  build() {
    Row({ space: 10 }) {
      if (this.onBack) {
        Image($r('app.media.ic_back'))
          .objectFit(ImageFit.Contain)
          .width(24)
          .height(24)
          .onClick(this.onBack);

      }
      Text(this.title)
        .fontSize(18)
        .fontWeight(FontWeight.Bold)
        .layoutWeight(1);
      if (this.onMore) {
        Image($r('app.media.ic_more'))
          .objectFit(ImageFit.Contain)
          .width(24)
          .height(24)
          .onClick(this.onMore);
      }
    }
    .padding({
      left: 16,
      right: 16,
      top: 12,
      bottom: 12
    })
    .backgroundColor(Color.White)
    .shadow({
      color: Color.Black,
      radius: 4
    });
  }
}

在这个NavigationBar组件中，通过@Prop装饰器定义了三个属性：title用于显示导航栏的标题，onBack是返回按钮的点击回调函数，onMore是更多按钮的点击回调函数。在build方法中，实现了导航栏的 UI 布局，包括返回按钮、标题和更多按钮。

使用这个导航栏组件时，可以在其他组件中这样引入：



@Component
export struct HomePage {
    build() {
        Column() {
            NavigationBar({
                title: '首页',
                onBack: () => {
                    console.log('返回按钮被点击');
                },
                onMore: () => {
                    console.log('更多按钮被点击');
                }
            });
            // 其他页面内容
        }
      .width('100%')
      .height('100%');
    }
}

通过这种方式，将导航栏的 UI 和逻辑封装在一个组件中，在不同的页面中只需要传入不同的属性值，就可以轻松地复用这个导航栏组件，减少了代码的重复编写，提高了开发效率。同时，也使得代码的结构更加清晰，维护起来更加方便。如果需要修改导航栏的样式或功能，只需要在NavigationBar组件中进行修改，而不会影响到其他使用该组件的地方。

活字印刷术与 ArkTS 封装的共通之处

活字印刷术与 ArkTS 中的封装虽然处于不同的时代和领域，但它们在本质上却有着许多惊人的共通之处，这些共通之处深刻地体现了封装思想的重要性和通用性。

从提高效率的角度来看，活字印刷术通过将单个活字作为可复用的单元，极大地提高了印刷的效率。在需要印刷不同内容时，只需重新排列活字，而无需像雕版印刷那样重新雕刻整版，大大节省了时间和人力成本。同样，在 ArkTS 中，封装将相关的代码和功能封装成独立的模块，如网络请求模块、数据库操作模块、UI 组件模块等。这些模块可以在不同的地方被重复使用，避免了重复编写代码，提高了开发效率。例如，在开发多个页面都需要获取新闻数据时，只需要调用封装好的NetworkManager类中的request方法，而不需要在每个页面都重新编写网络请求的代码。

在实现复用方面，活字印刷术的活字可以反复使用，无论印刷多少书籍，只要有足够的活字，就可以满足不同内容的排版需求。这使得活字印刷术具有很强的复用性，降低了印刷成本。在 ArkTS 中，封装后的类和组件也具有高度的复用性。一个封装好的 UI 组件，如前面提到的NavigationBar组件，可以在多个页面中使用，只需传入不同的属性值，就可以适应不同页面的导航栏需求。这种复用性不仅提高了代码的利用率，还减少了代码的冗余，使得项目的结构更加清晰。

降低复杂度是活字印刷术和 ArkTS 封装的又一共通点。活字印刷术将复杂的印刷过程分解为制活字、排版、印刷等相对简单的步骤，每个步骤都有明确的操作规范和流程。工匠们只需要专注于自己负责的步骤，而不需要了解整个印刷过程的所有细节。这种分工合作的方式降低了印刷的复杂度，使得印刷技术更容易被掌握和应用。在 ArkTS 中，封装将复杂的功能和实现细节隐藏在模块内部，对外只暴露简单易用的接口。开发者在使用这些模块时，不需要了解其内部的具体实现，只需要关注接口的使用方法即可。例如，在使用封装好的数据库操作类时，开发者只需要调用insert、query等方法，而不需要了解数据库的连接、SQL 语句的编写等细节，从而降低了开发的复杂度。

活字印刷术和 ArkTS 封装都体现了对功能和数据的组织与管理。活字印刷术中，活字按照一定的规律分类存放，便于查找和使用。排版时，根据文稿内容将活字有序地排列在版面上，形成一个完整的印版。这种对活字的组织和管理方式，使得印刷过程更加高效和有序。在 ArkTS 中，封装通过类和模块将相关的属性和方法组织在一起，形成一个逻辑上的整体。例如，在Person类中，将name和age属性以及对它们的操作方法封装在一起，使得对人的信息的管理更加方便和清晰。同时，通过命名空间、模块导入导出等机制，对不同的类和模块进行管理，避免了命名冲突和代码的混乱。