通过C++设计模式提升代码可维护性

1/1通过C++设计模式提升代码可维护性第一部分面向对象设计原则的指导 2第二部分设计模式的概念与分类 4第三部分工厂模式提高代码灵活性和可扩展性 6第四部分观察者模式实现解耦和事件处理 10第五部分单例模式确保全局唯一实例 13第六部分策略模式支持算法或行为的可替换 16第七部分模板方法模式提供算法框架及步骤细节 20第八部分迭代器模式遍历集合对象统一接口 24

第一部分面向对象设计原则的指导关键词关键要点【封装】：

1.封装是将数据的表示和操作细节隐藏在抽象接口之后，只向外部暴露必要的接口，从而实现数据和操作的安全性。

2.封装有助于提高代码的可维护性，因为修改底层实现不会影响客户端代码。

3.封装还提供了安全性，因为外部代码无法访问内部数据或操作细节。

【抽象】：

#面向对象设计原则的指导

面向对象设计原则是一组指导准则，旨在帮助开发者创建可维护性、可扩展性和可重用的代码。这些原则包括：

1.单一职责原则（SRP）：每个类或模块都应该只负责一项任务，并且该任务应该封装在一个类或模块中。这可以提高代码的可维护性，因为更容易理解和修改单个类的代码，而不是一大堆相互依赖的类的代码。

2.开放-封闭原则（OCP）：一个软件实体（如类、模块或函数）应该对扩展开放，对修改封闭。这意味着你可以通过扩展现有代码来添加新功能，而无需修改现有代码。这可以提高代码的可维护性，因为当需要添加新功能时，你不必担心破坏现有代码。

3.里氏替换原则（LSP）：任何基类对象都可以被其子类对象替换，并且程序的行为不会改变。这可以提高代码的可重用性，因为你可以使用子类对象来替换基类对象，而无需修改调用该对象的代码。

4.接口隔离原则（ISP）：一个接口应该只包含相关的方法，并且不应该包含无关的方法。这可以提高代码的可维护性，因为更容易理解和修改单个接口的代码，而不是一大堆包含许多无关方法的接口的代码。

5.依赖倒置原则（DIP）：高层模块不应该依赖于低层模块。相反，它们应该依赖于抽象。这可以提高代码的灵活性，因为你可以很容易地更换低层模块，而无需修改高层模块的代码。

6.合成/聚合复用原则（CARP）：通过合成或聚合的方式来复用代码，而不是通过继承。这可以提高代码的可维护性，因为更容易理解和修改合成或聚合的代码，而不是一大堆继承的类的代码。

7.对象-关系原则（ORCP）：对象应该与它所表示的现实世界的实体之间保持一致。这可以提高代码的可理解性，因为更容易理解对象所表示的现实世界的实体，而不是一大堆抽象的概念。

8.通用接口原则（GIP）：接口应该被设计成通用的，以便于不同的类可以实现它们。这可以提高代码的可重用性，因为你可以使用一个接口来代表许多不同的类，而无需创建许多不同的接口。

9.最小接口原则（MIP）：接口应该只包含必要的成员。这可以提高代码的可维护性，因为更容易理解和修改单个接口的代码，而不是一大堆包含许多无关成员的接口的代码。

10.分离接口原则（SIP）：接口应该被分解成较小的、更易于管理的接口。这可以提高代码的可维护性，因为更容易理解和修改单个接口的代码，而不是一大堆包含许多无关成员的接口的代码。第二部分设计模式的概念与分类关键词关键要点【设计模式的概念】：

1.设计模式是软件工程中复用常见解决方案的模板，它将抽象的算法与具体实现分离，使软件系统更易于维护和扩展。

2.设计模式在不同场景下有多种用法，包括：创建模式、结构模式、行为模式。

3.设计模式可以提高代码可重用性、可维护性和灵活性，减少开发时间和成本。

【设计模式的分类】：

设计模式的概念与分类

1.设计模式的概念

设计模式是指软件开发人员在软件开发过程中应用的通用解决方案。这些解决方案可以帮助开发者更轻松地构建和维护软件，以及解决常见问题，从而提高软件的可维护性、可扩展性和可复用性。

2.设计模式的分类

设计模式可以根据其解决的问题类型或其结构特征进行分类。一些常用的设计模式分类包括：

2.1创建型模式

创建型模式用于创建对象，包括：

-工厂模式：工厂模式旨在将对象的创建过程与使用该对象的方式分离。它提供了一种创建对象的方法，而无需显式指定类的名称。

-抽象工厂模式：抽象工厂模式提供了一种创建一系列相关或相互依赖对象的接口。它允许您在不指定具体类的情况下创建这些对象。

-单例模式：单例模式确保一个类只有一个实例，并提供了一个全局访问点来访问该实例。

-建造者模式：建造者模式允许您使用不同的零件和组件来构建复杂的对象。它分离了对象的构建和表示。

-原型模式：原型模式提供一种机制来创建对象的副本。您可以通过指定要复制的对象来创建新对象，而无需重新创建整个对象。

2.2结构型模式

结构型模式用于组织和组合对象，包括：

-适配器模式：适配器模式将一个类的接口转换成另一个类所期望的接口，从而使原本不兼容的类可以一起工作。

-桥接模式：桥接模式将抽象和实现解耦，从而使二者可以独立变化。

-组合模式：组合模式允许您创建树形结构来表示对象层次结构。它允许您将对象组合成更复杂的对象。

-装饰器模式：装饰器模式允许您动态地添加或删除对象的责任，而无需更改它们原来的结构。

-外观模式：外观模式提供了一个统一的接口来访问一个子系统中的多个接口。它简化了子系统的使用。

2.3行为型模式

行为型模式用于描述对象之间的通信和交互，包括：

-策略模式：策略模式允许您在运行时选择算法或行为。它允许您在不改变对象结构的情况下改变其行为。

-模板方法模式：模板方法模式定义了一个算法的骨架，而允许子类定义算法的具体步骤。它允许您创建可重用的算法。

-观察者模式：观察者模式定义了一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖它的对象都会得到通知。

-责任链模式：责任链模式将请求传递给一系列处理程序，每个处理程序都有机会处理该请求。它允许您解耦请求的发送者和接收者。

-命令模式：命令模式将一个请求封装成一个对象，以便您可以在不同的时间或不同的地点对其进行参数化、排队或执行。

-解释器模式：解释器模式将一个语言的文法表示为一个树形结构。它允许您使用递归的方法来解释该语言中的句子。

-迭代器模式：迭代器模式提供了一种顺序访问聚合对象中的元素的方式，而无需暴露其内部表示。它允许您遍历不同的数据结构，而无需了解其具体实现。

-中介者模式：中介者模式定义了一个中介对象，用于集中处理不同对象之间的通信。它允许您减少对象之间的耦合。

-访问者模式：访问者模式允许您在不改变对象结构的情况下添加新的操作。它允许您定义一个访问者类，该类可以访问不同类型的对象并执行不同的操作。第三部分工厂模式提高代码灵活性和可扩展性关键词关键要点工厂模式提高代码耦合性

1.降低组件之间的依赖关系：工厂方法模式通过将组件的实例化与具体组件的实现分离，降低了组件之间的依赖关系。这使得组件更容易维护和扩展，因为修改一个组件不会影响其他组件。

2.提高代码的可读性和可理解性：工厂方法模式使代码更加模块化和易读。通过将组件的实例化集中在一个地方，更容易理解组件是如何创建和使用的。

3.提高代码的可重用性和可扩展性：工厂方法模式提高了代码的可重用性和可扩展性。通过将组件的实例化与具体组件的实现分离，可以很容易地创建新的组件类型而不会影响现有代码。

工厂模式提高代码灵活性

1.提高代码的可配置性：工厂方法模式使代码更加可配置。通过将组件的实例化与具体组件的实现分离，可以很容易地配置组件的行为而不会影响现有代码。

2.提高代码的可扩展性：工厂方法模式提高了代码的可扩展性。通过将组件的实例化与具体组件的实现分离，可以很容易地添加新的组件类型而不会影响现有代码。

3.提高代码的可维护性和可读性：工厂方法模式提高了代码的可维护性和可读性。通过将组件的实例化集中在一个地方，更容易理解组件是如何创建和使用的。#工厂模式提高代码灵活性和可扩展性

前言

工厂模式是一种创建型设计模式，它提供了一种创建对象的机制，使代码更灵活和可扩展。在工厂模式中，一个工厂对象负责创建其他对象，这使得你可以轻松地更改创建对象的方式，而无需修改客户端代码。

工厂模式的优点

工厂模式具有许多优点，包括：

*提高代码灵活性。工厂模式使你可以轻松地更改创建对象的方式，而无需修改客户端代码。这使得代码更灵活，更易于维护。

*提高代码可扩展性。工厂模式使你可以轻松地添加或删除创建对象的类型，而无需修改客户端代码。这使得代码更可扩展，更易于添加新功能。

*提高代码可重用性。工厂模式使你可以将创建对象的代码重用在多个项目中。这可以节省时间和精力，提高代码的可重用性。

工厂模式的实现

工厂模式可以通过多种方式实现。最常见的一种实现方法是使用一个工厂类。工厂类负责创建其他对象，客户端代码只需调用工厂类的创建方法即可。

```c++

public:

virtualProduct*createProduct()=0;

};

public:

returnnewProduct1();

}

};

public:

returnnewProduct2();

}

};

public:

virtualvoiddoSomething()=0;

};

public:

//dosomething

}

};

public:

//dosomethingelse

}

};

Factory*factory=newConcreteFactory1();

Product*product=factory->createProduct();

product->doSomething();

factory=newConcreteFactory2();

product=factory->createProduct();

product->doSomething();

return0;

}

```

在上面的示例中，`Factory`类是一个抽象类，它定义了一个`createProduct()`方法。`ConcreteFactory1`和`ConcreteFactory2`是两个具体工厂类，它们继承自`Factory`类并实现了`createProduct()`方法。`Product`类是一个抽象类，它定义了一个`doSomething()`方法。`Product1`和`Product2`是两个具体产品类，它们继承自`Product`类并实现了`doSomething()`方法。

在主函数中，我们首先创建一个`ConcreteFactory1`对象，然后调用它的`createProduct()`方法创建一个`Product1`对象。接下来，我们又创建一个`ConcreteFactory2`对象，然后调用它的`createProduct()`方法创建一个`Product2`对象。最后，我们调用`Product1`和`Product2`对象的`doSomething()`方法，分别执行不同的操作。

总结

工厂模式是一种创建型设计模式，它提供了一种创建对象的机制，使代码更灵活和可扩展。工厂模式可以轻松地更改创建对象的方式，而无需修改客户端代码，因此提高了代码的可维护性。工厂模式还使你可以轻松地添加或删除创建对象的类型，而无需修改客户端代码，因此提高了代码的可扩展性。工厂模式还使你可以将创建对象的代码重用在多个项目中，因此提高了代码的可重用性。第四部分观察者模式实现解耦和事件处理关键词关键要点【观察者模式简介】：

1.观察者模式是一种设计模式，它定义了一种一对多的依赖关系，使得每当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。

2.观察者模式可以解耦对象之间的耦合关系，使它们可以独立地变化，从而提高代码的可维护性。

3.观察者模式可以实现事件处理，当一个事件发生时，观察者对象可以自动执行相应的操作，从而简化代码的编写。

【观察者模式的应用】：

#通过C++设计模式提升代码可维护性

观察者模式实现解耦和事件处理

观察者模式是一种设计模式，它允许一个对象（称为被观察者）将其状态变化通知给多个其他对象（称为观察者）。观察者模式可以用于解耦被观察者和观察者，使它们可以独立地变化。

在C++中，观察者模式可以通过使用事件和委托来实现。事件是一种通知机制，它允许一个对象将一个消息发送给另一个对象，而无需知道接收消息的对象是谁。委托是一种编程技术，它允许一个对象将一个方法的调用委托给另一个对象。

为了实现观察者模式，我们可以创建一个被观察者类，该类包含一个事件，用于通知观察者其状态发生变化。我们还可以创建一个观察者类，该类包含一个方法，用于处理被观察者状态变化的通知。

当被观察者状态发生变化时，它可以调用事件，以通知观察者。观察者收到通知后，可以调用其方法来处理状态变化。

观察者模式可以用于解决许多不同的问题。例如，它可以用于实现GUI应用程序中的事件处理。在GUI应用程序中，被观察者可以是GUI控件，而观察者可以是GUI窗口。当GUI控件的状态发生变化时，它可以调用事件，以通知GUI窗口。GUI窗口收到通知后，可以调用其方法来处理状态变化。

观察者模式还可用于实现消息传递系统。在消息传递系统中，被观察者可以是消息来源，而观察者可以是消息接收方。当消息来源发送消息时，它可以调用事件，以通知消息接收方。消息接收方收到通知后，可以调用其方法来处理消息。

观察者模式是一种非常有用的设计模式。它可以用于解耦被观察者和观察者，使它们可以独立地变化。观察者模式还可用于实现事件处理和消息传递系统。

观察者模式的优点

*解耦性：观察者模式将被观察者和观察者解耦，使它们可以独立地变化。这使得代码更容易维护。

*灵活性：观察者模式允许观察者动态地注册和取消注册被观察者。这使得代码更灵活，更容易适应变化。

*可扩展性：观察者模式允许新的观察者轻松地添加到系统中。这使得代码更容易扩展。

观察者模式的缺点

*性能开销：观察者模式会增加一些性能开销，因为当被观察者状态发生变化时，它需要通知所有观察者。

*代码复杂性：观察者模式会使代码更复杂，因为需要定义被观察者和观察者类以及它们的交互方式。

观察者模式的应用场景

*GUI应用程序中的事件处理：观察者模式可以用于实现GUI应用程序中的事件处理。在GUI应用程序中，被观察者可以是GUI控件，而观察者可以是GUI窗口。当GUI控件的状态发生变化时，它可以调用事件，以通知GUI窗口。GUI窗口收到通知后，可以调用其方法来处理状态变化。

*消息传递系统：观察者模式还可用于实现消息传递系统。在消息传递系统中，被观察者可以是消息来源，而观察者可以是消息接收方。当消息来源发送消息时，它可以调用事件，以通知消息接收方。消息接收方收到通知后，可以调用其方法来处理消息。

*其他场景：观察者模式还可用于实现其他场景，例如：

*进程间通信

*线程间通信

*分布式系统中的事件处理

*数据库中的触发器第五部分单例模式确保全局唯一实例关键词关键要点【单例模式确保全局唯一实例】：

1.单例模式是一种设计模式，它确保一个类只有一个实例，并且提供一个全局访问点来访问该实例。

2.单例模式的优点包括：

-确保全局唯一实例，防止类被多次实例化。

-提供一个全局访问点来访问该实例，方便其他类访问。

-减少内存消耗，因为只创建一个实例。

3.单例模式的实现通常有两种方法：

-懒汉模式：在第一次需要该实例时才创建它。

-饿汉模式：在类加载时就创建它。

【单例模式的应用】：

单例模式确保全局唯一实例

单例模式是一种设计模式，它确保一个类只有一个实例，并提供一个全局访问点。这对于需要全局访问的资源非常有用，例如数据库连接、配置文件、日志记录器等。

单例模式的实现非常简单，只需要将类的构造函数私有化，并在类中提供一个静态方法来获取该类的唯一实例。例如，以下是用C++实现的单例模式：

```c++

private:

//构造函数私有化，防止直接创建实例

//析构函数私有化，防止直接销毁实例

public:

//获取类的唯一实例

//使用静态变量保存类的唯一实例

staticSingletoninstance;

//返回类的唯一实例

returninstance;

}

//其他需要实现的方法

};

```

要使用单例模式，只需要调用`GetInstance()`方法即可。例如：

```c++

//获取类的唯一实例

Singleton&instance=Singleton::GetInstance();

//使用类的唯一实例

instance.DoSomething();

return0;

}

```

单例模式具有以下优点：

*确保全局唯一实例，防止资源重复创建和销毁。

*提供一个全局访问点，方便访问共享资源。

*降低代码复杂度，提高代码的可维护性。

单例模式也具有以下缺点：

*限制了类的可扩展性，因为不能直接创建新的实例。

*如果类的唯一实例发生错误，则可能影响到整个应用程序。

总体来说，单例模式是一种非常有用的设计模式，但需要谨慎使用。只有在确实需要全局唯一实例时，才应该使用单例模式。

#单例模式的应用场景

单例模式在以下场景中非常有用：

*数据库连接池：单例模式可以确保数据库连接池只有一个实例，并提供一个全局访问点。这可以提高数据库连接的效率，并防止数据库连接泄漏。

*配置文件：单例模式可以确保配置文件只有一个实例，并提供一个全局访问点。这可以方便地管理配置文件，并防止配置文件被意外修改。

*日志记录器：单例模式可以确保日志记录器只有一个实例，并提供一个全局访问点。这可以方便地记录日志，并防止日志记录器被意外关闭。

*对象池：单例模式可以确保对象池只有一个实例，并提供一个全局访问点。这可以提高对象的复用率，并防止对象泄漏。

总之，单例模式是一种非常有用的设计模式，但需要谨慎使用。只有在确实需要全局唯一实例时，才应该使用单例模式。第六部分策略模式支持算法或行为的可替换关键词关键要点策略模式概述

1.策略模式定义了一系列算法，并让它们可以互相替换，而不影响使用它们的客户端。

2.这种模式可以使算法的变化与使用它们的代码分离，从而提高代码的可维护性和可扩展性。

3.策略模式通常用于需要动态切换算法或行为的场景，例如排序算法、压缩算法或安全算法的选择。

策略模式的优点

1.提高代码的可维护性：策略模式将算法或行为与使用它们的代码分离，使代码更容易理解和维护，因为算法的变化不会影响使用它们的代码。

2.提高代码的可扩展性：策略模式使代码更容易扩展，因为可以轻松地添加新的算法或行为，而不影响现有代码。

3.提高代码的灵活性：策略模式使代码更具灵活性，可以在运行时动态切换算法或行为，以满足不同的需求。

策略模式的实现

1.定义一个策略接口，该接口定义了策略类需要实现的方法。

2.创建一个策略类的集合，每个策略类实现策略接口中的方法，并提供不同的算法或行为。

3.创建一个上下文类，该类负责维护策略对象，并调用策略对象的方法来执行算法或行为。

策略模式的应用场景

1.排序算法的选择：策略模式可以用于选择不同的排序算法，如冒泡排序、选择排序、快速排序等，根据不同的数据结构和性能要求，动态切换排序算法。

2.数据压缩算法的选择：策略模式可以用于选择不同的数据压缩算法，如LZW算法、Huffman算法等，根据不同的压缩率和压缩时间要求，动态切换压缩算法。

3.安全算法的选择：策略模式可以用于选择不同的安全算法，如AES加密算法、RSA加密算法等，根据不同的安全级别和性能要求，动态切换加密算法。策略模式支持算法或行为的可替换

策略模式是一种设计模式，它定义了一系列算法或行为，并将它们封装在独立的类中。这样，就可以在运行时根据不同的需求选择并替换不同的算法或行为，而无需修改客户端代码。

策略模式的优点在于：

*提高代码的可维护性：策略模式将算法或行为与客户端代码分离，使得客户端代码更加简洁和易于维护。

*提高代码的可扩展性：策略模式允许在不修改客户端代码的情况下添加新的算法或行为。

*提高代码的可重用性：策略模式中的算法或行为可以被多个客户端代码重用。

策略模式的实现通常使用工厂方法模式或简单工厂模式。工厂方法模式允许客户端代码在不知道具体算法或行为的情况下创建算法或行为对象。简单工厂模式则直接创建算法或行为对象，客户端代码无需知道具体算法或行为的实现细节。

策略模式在软件开发中得到了广泛的应用。一些常见的策略模式包括：

*排序算法策略：该策略模式用于选择不同的排序算法，如快速排序、归并排序、堆排序等。

*数据压缩算法策略：该策略模式用于选择不同的数据压缩算法，如LZ77、LZ78、Huffman编码等。

*加密算法策略：该策略模式用于选择不同的加密算法，如AES、DES、RSA等。

策略模式是一种非常有用的设计模式，它可以帮助我们提高代码的可维护性、可扩展性和可重用性。因此，在软件开发中，我们应该积极考虑使用策略模式。

下面是一个使用策略模式的示例代码：

```c++

public:

virtualvoidAlgorithm()=0;

};

public:

//ImplementalgorithmA

}

};

public:

//ImplementalgorithmB

}

};

private:

Strategy*strategy_;

public:

strategy_=strategy;

}

strategy_=strategy;

}

strategy_->Algorithm();

}

};

Strategy*strategyA=newConcreteStrategyA();

Strategy*strategyB=newConcreteStrategyB();

Contextcontext(strategyA);

context.Algorithm();

context.SetStrategy(strategyB);

context.Algorithm();

deletestrategyA;

deletestrategyB;

return0;

}

```

在这个示例中，`Strategy`类是抽象策略类，它定义了算法接口。`ConcreteStrategyA`和`ConcreteStrategyB`是具体策略类，它们实现了不同的算法。`Context`类是上下文类，它持有一个策略对象，并调用策略对象的`Algorithm()`方法来执行算法。

在`main()`函数中，我们创建了两个具体策略对象和一个上下文对象。我们将第一个具体策略对象设置给上下文对象，并调用上下文对象的`Algorithm()`方法来执行算法。然后，我们将第二个具体策略对象设置给上下文对象，并再次调用上下文对象的`Algorithm()`方法来执行算法。

这个示例演示了如何使用策略模式来选择和替换不同的算法。策略模式可以帮助我们提高代码的可维护性、可扩展性和可重用性。第七部分模板方法模式提供算法框架及步骤细节关键词关键要点【模板方法模式概述】：

1.模板方法模式：将算法分步骤分解,并将算法逻辑与步骤细节分离,为算法提供了通用框架及结构。

2.模板方法模式的作用：提升代码的可维护性和可扩展性,提高代码的灵活性,并简化算法的实现。

3.模板方法模式的优点：封装通用的算法步骤,避免重复代码,提高算法的重用性,并且易于修改算法的步骤或细节。

【模板方法模式关键步骤】：

模板方法模式提供算法框架及步骤细节

模板方法模式（TemplateMethodPattern）是一种设计模式，它为一个算法定义一个模板，该模板中的步骤可以由子类来实现。这使得子类可以在不改变算法结构的情况下，改变算法的某些步骤。

模板方法模式的结构如下：

*抽象类：定义算法的模板，并包含算法的步骤。

*具体类：实现抽象类中的步骤。

模板方法模式的优点如下：

*可重用性：模板方法模式可以使算法的步骤被重用，从而提高代码的可重用性。

*可扩展性：模板方法模式可以使算法的步骤被扩展，从而提高代码的可扩展性。

*可维护性：模板方法模式可以使算法的步骤被独立维护，从而提高代码的可维护性。

模板方法模式的缺点如下：

*抽象性：模板方法模式的抽象性可能会降低代码的可读性。

*灵活性：模板方法模式的灵活性可能会降低代码的性能。

模板方法模式的应用场景如下：

*当需要定义一个算法的模板，并允许子类实现算法的某些步骤时。

*当需要重用算法的某些步骤时。

*当需要扩展算法的某些步骤时。

*当需要独立维护算法的某些步骤时。

模板方法模式的示例

以下是一个模板方法模式的示例：

```

#include<iostream>

usingnamespacestd;

public:

virtualvoiddraw()=0;

};

public:

cout<<"Drawarectangle."<<endl;

}

};

public:

cout<<"Drawacircle."<<endl;

}

};

public:

cout<<"Drawasquare."<<endl;

}

};

public:

virtualShape*createShape()=0;

};

public:

returnnewRectangle();

}

};

public:

returnnewCircle();

}

};

public:

returnnewSquare();

}

};

ShapeFactory*shapeFactory=newRectangleFactory();

Shape*shape=shapeFactory->createShape();

shape->draw();

shapeFactory=newCircleFactory();

shape=shapeFactory->createShape();

shape->draw();

shapeFactory=newSquareFactory();

shape=shapeFactory->createShape();

shape->draw();

return0;

}

```

在这个示例中，Shape类是一个抽象类，它定义了draw()方法。Rectangle类、Circle类和Square类是Shape类的具体类，它们实现了draw()方法。ShapeFactory类是一个抽象类，它定义了createShape()方法。RectangleFactory类、CircleFactory类和SquareFactory类是ShapeFactory类的具体类，它们实现了createShape()方法。

在main()函数中，我们创建了三个ShapeFactory对象，分别是RectangleFactory、CircleFactory和SquareFactory。然后，我们调用createShape()方法来创建三个Shape对象，分别是Rectangle、Circle和Square。最后，我们调用draw()方法来绘制这些形状。

模板方法模式通过使用抽象类和具体类来定义算法的模板和步骤，从而提高了