Design patterns swift程序到接口

类Car和Truck在这里作为示例编写，但在编译时程序可能不知道它们

可能还有更多种类的汽车还不知道

例如，可能会有一种叫做法拉利（Ferrari）的特殊车型，兰博基尼（Lamborgini），这种车型可能会沿着系统未知的道路行驶

我们的目标是编程到接口，而不是特定的实现

我们需要做如下类似的事情

创建一个实例

var-vehicle:IDrive=vehicle（）

vehicle.drive（）

我们尝试了一些技术，但如果不将其转换为特定的实现，就无法使其工作，我们需要一个独立的解决方案，而不需要转换为特定的实现

任何横向方法都是受欢迎的，也许我们的方法是完全错误的，但请记住函数

实例化地址

必须有一个基于

协议的参数

给消极选民（又称傻瓜）的提示：相反，你可以问一些问题来澄清这对你来说是否有意义，或者给自己买一本“白痴设计模式书”

公共协议IDrive{
func驱动器（）
}
公车：IDrive{
公共init（）{}
公用func驱动器（）{}
}
等级：IDrive{
公共init（）{}
公用func驱动器（）{}
}
类测试{//我们的尝试
func实例化地址（车辆：IDrive.Type）{
var车辆=车辆（）
车辆驾驶
}
func实例化地址2（车辆：T）{
var车辆=车辆（）
车辆驾驶
}
}
var test=test（）
test.实例化地址（Car.self）

编辑-在空速回答后尝试使用课堂

public protocol Drivable {
    init()
    func drive()
}

public class Car: Drivable {
    public required init() {}
    public func drive() { println("vroom") }
}

public class Truck: Drivable {
    public required init() {}

    public func drive() { println("brrrrrrm") }
}

class Test {
    func instantiateAndDrive(Vehicle:Drivable.Type) {
        var vehicle = Vehicle()
        vehicle.drive()
    }

    func instantiateAndDrive2<T:Drivable>(Vehicle: T) {
        ver vehicle = Vehicle()
        vehicle.drive()
    }
}
//var test = Test()
//test.instantiateAndDrive(Car.self)
//test.instantiateAndDrive(Truck.self)

公共协议驱动{
init（）
func驱动器（）
}
公车：可驾驶{
公共必需的init（）{}
公用func驱动器（）{println（“vroom”）}
}
公共级卡车：可驾驶{
公共必需的init（）{}
public func drive（）{println（“brrrrm”）}
}
课堂测试{
func实例化地址（车辆：Drivable.Type）{
var车辆=车辆（）
车辆驾驶
}
func实例化地址2（车辆：T）{
ver vehicle=车辆（）
车辆驾驶
}
}
//var test=test（）
//test.实例化地址（Car.self）
//test.实例化地址（Truck.self）
您想使用
Self
。在协议中，它意味着“实际采用我的类型”。在类的方法中，它表示“实际调用此方法的类”。
您要使用
Self
。在协议中，它意味着“实际采用我的类型”。在类的方法中，它表示“实际调用此方法的类”。
您要使用
Self
。在协议中，它意味着“实际采用我的类型”。在类的方法中，它表示“实际调用此方法的类”。
您要使用
Self
。在协议中，它意味着“实际采用我的类型”。在类的方法中，它意味着“实际调用此方法的类”。
要能够通用地创建泛型类型，您需要知道它支持初始值设定项。您可以通过向协议添加
init（）
函数来实现这一点：

public protocol Drivable {
    // enable drivable things to be
    // created with a  default initializer
    init()

    // (you could instead require a type implement
    // an initializer that took parameters)

    func drive()
}

然后，您可以编写创建和操作它们的函数：

struct Car: Drivable {
    init() { }
    func drive() { println("vroom") }
}

struct Truck: Drivable {
    init() { }
    func drive() { println("brrrrrrm") }
}

struct Test<D: Drivable> {
    func instantiateAndDrive() {
        // whatever D is, it implements init()
        let d = D()
        // and drive()
        d.drive()
    }
}

Test<Car>().instantiateAndDrive()
Test<Truck>().instantiateAndDrive()

为了能够一般地创建泛型类型，您需要知道它支持初始值设定项。您可以通过向协议添加
init（）
函数来实现这一点：

public protocol Drivable {
    // enable drivable things to be
    // created with a  default initializer
    init()

    // (you could instead require a type implement
    // an initializer that took parameters)

    func drive()
}

然后，您可以编写创建和操作它们的函数：

struct Car: Drivable {
    init() { }
    func drive() { println("vroom") }
}

struct Truck: Drivable {
    init() { }
    func drive() { println("brrrrrrm") }
}

struct Test<D: Drivable> {
    func instantiateAndDrive() {
        // whatever D is, it implements init()
        let d = D()
        // and drive()
        d.drive()
    }
}

Test<Car>().instantiateAndDrive()
Test<Truck>().instantiateAndDrive()

为了能够一般地创建泛型类型，您需要知道它支持初始值设定项。您可以通过向协议添加
init（）
函数来实现这一点：

public protocol Drivable {
    // enable drivable things to be
    // created with a  default initializer
    init()

    // (you could instead require a type implement
    // an initializer that took parameters)

    func drive()
}

然后，您可以编写创建和操作它们的函数：

struct Car: Drivable {
    init() { }
    func drive() { println("vroom") }
}

struct Truck: Drivable {
    init() { }
    func drive() { println("brrrrrrm") }
}

struct Test<D: Drivable> {
    func instantiateAndDrive() {
        // whatever D is, it implements init()
        let d = D()
        // and drive()
        d.drive()
    }
}

Test<Car>().instantiateAndDrive()
Test<Truck>().instantiateAndDrive()

为了能够一般地创建泛型类型，您需要知道它支持初始值设定项。您可以通过向协议添加
init（）
函数来实现这一点：

public protocol Drivable {
    // enable drivable things to be
    // created with a  default initializer
    init()

    // (you could instead require a type implement
    // an initializer that took parameters)

    func drive()
}

然后，您可以编写创建和操作它们的函数：

struct Car: Drivable {
    init() { }
    func drive() { println("vroom") }
}

struct Truck: Drivable {
    init() { }
    func drive() { println("brrrrrrm") }
}

struct Test<D: Drivable> {
    func instantiateAndDrive() {
        // whatever D is, it implements init()
        let d = D()
        // and drive()
        d.drive()
    }
}

Test<Car>().instantiateAndDrive()
Test<Truck>().instantiateAndDrive()

我们已经使用了.self，但是遇到了一些问题，这些问题仍然需要转换到我们不想要的特定实现。请在操场试一试，如果您能提供一个有效的解决方案，我们将不胜感激。
Self
不是
Self
。这对我来说是新的，请您帮助我们编写代码，或者参考一些文档来解决这些问题。我们已经使用.self完成了这些工作，但是遇到了一些问题，这些问题仍然需要转换到特定的实现中，这是我们不希望看到的。请在操场试一试，如果您能提供一个有效的解决方案，我们将不胜感激。
Self
不是
Self
。这对我来说是新的，请您帮助我们编写代码，或者参考一些文档来解决这些问题。我们已经使用.self完成了这些工作，但是遇到了一些问题，这些问题仍然需要转换到特定的实现中，这是我们不希望看到的。请在操场试一试，如果您能提供一个有效的解决方案，我们将不胜感激。
Self
不是
Self
。这对我来说是新的，请您帮助我们编写代码，或者参考一些文档来解决这些问题。我们已经使用.self完成了这些工作，但是遇到了一些问题，这些问题仍然需要转换到特定的实现中，这是我们不希望看到的。请在操场试一试，如果你能提供一个有效的解决方案，我将不胜感激。
Self
不是
Self
。嗯，这对我来说是新的，你能帮我解决代码或参考一些文档吗。。。你懂的，我们可以通过上课来完成吗？或者只通过结构？我用建议的方法编辑了我的问题，但尝试使用类，你能在这方面帮助我吗tooAirspeed，谢谢你的尝试，我确实同意了，但实际上我还没有，但我在这个过程中学到了一些东西…：）这是我的另一次尝试，请继续