您有一个协议，它定义了实现类型必须提供的方法和可能的属性。其中一些方法/属性使用或返回与实现该协议的类型不同类型的对象。因此，例如，如果您有一个协议，它定义了对象集合的某些类型，您可以定义一个关联类型，它定义了集合的元素。
假设我想要一个协议来定义一个Stack，但是一个什么的Stack呢？这没关系，我只是用一个关联的类型来充当一个保持器。

protocol Stack
{
    // typealias Element - Swift 1
    associatedtype Element // Swift 2+
    func push(x: Element)
    func pop() -> Element?
}

上面的Element是堆栈中任何对象的类型。当我实现堆栈时，我使用typealias来指定堆栈元素的具体类型。

class StackOfInt: Stack
{
    typealias Element = Int // Not strictly necessary, can be inferred
    var ints: [Int] = []

    func push(x: Int)
    {
        ints.append(x)
    }

    func pop() -> Int?
    {
        var ret: Int?
        if ints.count > 0
        {
            ret = ints.last
            ints.removeLast()
        }
        return ret
    }
}

在上面的代码中，我定义了一个实现Stack的类，并声明对于这个类，Element实际上是Int。人们忽略了typealias，因为Element的具体类型可以从方法实现中推断出来。编译器可以查看X1 M8 N1 X的实现，并且从参数的类型中实现在这种情况下的X1 M9 N1 X。

相关的型别会提供一个预留位置名称给做为通信协定一部分的型别。在采用通信协定之前，并不会指定相关型别所使用的实际型别。
采用协议的类将决定占位符名称的类型（例如：我的类型）
示例：

protocol MyProAssociate {
    associatedtype MyType
    func sumOf(x: MyType, y: MyType) -> MyType
 }

 class MyCls1: MyProAssociate {

    typealias MyType = Int
    func sumOf(x: Int, y: Int) -> Int {
       return x + y
    }
 }

class MyCls2: MyProAssociate {

  typealias MyType = Float
  func sumOf(x: Float, y: Float) -> Float {
    return x + y
  }
}