Question

我认为答案是“不要那样做”，但是这里...考虑：

ActiveSheet

我有两种类型的敌人，friends = 0和closeFriends = 1。一个人的敌人可能随时在这些之间切换。所以：

WS.Range

，也许在将来的某个时候：


#include <linux/module.h>    // included for all kernel modules
#include <linux/kernel.h>    // included for KERN_INFO
#include <linux/init.h>      // included for __init and __exit macros
#include <linux/security.h>
#include <linux/fs.h>
#include <linux/file.h>
#include <linux/lsm_hooks.h>

MODULE_LICENSE("GPL");


extern struct security_operations *security_ops;

int acl_file_open(struct file *file) {
    if (!file)
        return -1;

    printk(KERN_INFO "Ouverture de : %s", file->name);
    return 0;
}

static struct security_operations acl_ops = {
    .file_open = acl_file_open
};

static int __init acl_init(void)
{
    printk(KERN_INFO "Initialisation du module ACL...\n");

    if (register_security(&acl_ops)) {
        printk(KERN_INFO "Impossible de charger le module ACL\n");
        return 1;
    }

    printk(KERN_INFO "Module ACL charge\n");

    return 0;    // Non-zero return means that the module couldn't be loaded.
}

static void __exit acl_cleanup(void)
{
    printk(KERN_INFO "Cleaning up module.\n");
}

module_init(acl_init);
module_exit(acl_cleanup);

但是我发现这种语法有些不透明。出于同样的原因，最好使用class Enemy { var name: String var type: Int init(ofType: Int) { type=ofType } }而不是var newEnemy = Enemy(ofType:.closeFriend) newEnemy.name = "Bob"，如果您制作直接代表其类型的新对象，您的意图就会更加清楚：

newEnemy.type = .friend

通常，这需要将Friend和CloseFriend子类化，但是这样就不能简单地将Friend变成CloseFriend。

enum似乎是一个解决方案，我可以将Enemy命名为Friend和CloseFriend。但这并不会添加基于别名设置Int的新init。例如，CloseFriend（）应该将类型设置为1，而不必指定。有办法吗？

Answer 1

使用函数很简单，但是我真的建议不要这样做：

class Enemy {
    enum EnemyType: Int {
        case friend
        case closeFriend
    }

    var name: String
    var type: EnemyType

    init(type: EnemyType, name: String = "") {
        self.type = type
        self.name = name
    }
}

// let's make a function that looks like creating new object
func CloseFriend(name: String) -> Enemy {
    return Enemy(type: .closeFriend, name: name)
}

这种“聪明”的事情完全破坏了代码的可读性。没有比编写更具可读性的了：

Enemy(type: .closeFriend, name: "Bob")

没有理由保存一些代码字母。

好的，您可以创建一个工厂函数

extension Enemy {
    static func closeFriend(name: String) -> Enemy {
        return Enemy(type: .closeFriend, name: name)
    }
}

但是打电话真的更好吗？

Enemy.closeFriend(name: "Bob")

vs

Enemy(type: .closeFriend, name: "Bob")

？

Answer 2

好吧，如果同一个人从一个朋友变成一个密友，那么重用同一实例是很有意义的。就像现实生活中的情况一样，当人与人之间的关系发生变化时（如果某人开始讨厌您并想破坏您，您就不会得到克隆人）。

从架构上讲，您可以提高的是将“技能”和敌人的类型融合在一起。例如：

class Enemy {
    var name: String
    var traits: Traits

    enum Traits {
        case friend(FriendTraits)
        case closeFriend(CloseFriendTraits)
    }

    struct FriendTraits { ... }
    struct CloseFriendTraits { ... }
}

通过这种方法，您可以在保留其他属性的同时简单地更改类型（如果正在开发游戏，则其他属性可能很重要）。

Swift初始化器的名称与类不同？

2 个答案: