Swift 我可以指定类实例可以转换为某种类型吗？

假设我有一个泛型类

class Foo<T> { … }

---

你不能按你的要求去做。即使Foo定义了泛型类型T，Foo的实例仍然是Foo，不能转换为泛型类型。在类级别声明泛型类型的原因是在类的多个位置使用它

class Foo<T> {
    var value: T

    init(withValue: T) {
       self.value = withValue
    }

    func getSomeValue() -> T {
        return self.value
    }
}

class-Foo{
var值：T
初始值（带值：T）{
self.value=withValue
}
func getSomeValue（）->T{
回归自我价值
}
}

---

泛型并不意味着类本身是泛型的并且可以转换。

实现您想要的目标的一种方法是为您的类应转换为的每个目标类型使用专用协议。下面是一个非常基本的例子：

protocol BoolAdaptable {
    func adaptToBool() -> Bool
}

protocol IntAdaptable {
    func adaptToInt() -> Int
}

protocol FloatAdaptable {
    func adaptToFloat() -> Float
}

class Foo: BoolAdaptable, IntAdaptable, FloatAdaptable {

    var v: NSNumber

    init(_ v: NSNumber) {
        self.v = v
    }

    func adaptToBool() -> Bool {
        return v.boolValue
    }

    func adaptToInt() -> Int {
        return v.integerValue
    }

    func adaptToFloat() -> Float {
        return v.floatValue
    }

}

let foo = Foo(NSNumber(double: 1.23))

let getTheBool = foo.adaptToBool() // true
let getTheInt = foo.adaptToInt() // 1
let getTheFloat = foo.adaptToFloat() // 1.23

---

这可以很容易地扩展以支持更复杂的转换。

为什么不只使用底层类型呢？（类似于@MrBeardsley的回答）

class-Foo{
变量t:t
初始（t:t）{
self.t=t
}
}
设foo=foo（t:3）
func useAnInt（a:Int）{}
让getTheInt:Int=foo.t
useAnInt（foo.t）

我喜欢这个，因为它可以变得如此简洁。不幸的是，在我的场景中，

t

会有所不同，这取决于foo的初始化方式（在我的问题中，我只指定它的类型为

t

）。但这可以通过一个只获取变量来处理。好主意和好设计。然而，我的Foo是泛型的，不能适应所有的prodocol，因为一次只保存一个类型的实例。

protocol BoolAdaptable {
    func adaptToBool() -> Bool
}

protocol IntAdaptable {
    func adaptToInt() -> Int
}

protocol FloatAdaptable {
    func adaptToFloat() -> Float
}

class Foo: BoolAdaptable, IntAdaptable, FloatAdaptable {

    var v: NSNumber

    init(_ v: NSNumber) {
        self.v = v
    }

    func adaptToBool() -> Bool {
        return v.boolValue
    }

    func adaptToInt() -> Int {
        return v.integerValue
    }

    func adaptToFloat() -> Float {
        return v.floatValue
    }

}

let foo = Foo(NSNumber(double: 1.23))

let getTheBool = foo.adaptToBool() // true
let getTheInt = foo.adaptToInt() // 1
let getTheFloat = foo.adaptToFloat() // 1.23

class Foo<T> {
    var t : T

    init(t: T) {
        self.t = t
    }
}


let foo = Foo(t: 3)
func useAnInt(a: Int) {}

let getTheInt: Int = foo.t
useAnInt(foo.t)