Question

这个问题有点傻。我正在尝试实施技能更新系统。所以要解释一下。

有一个班级

class AppInfo
{
    public static var power:int = 10;
    public static var speed:int = 20;

}

和类SmartButton，它应该引用一个静态变量，例如在构造函数中强大并在给定值上增加它。

e.g。

class SmartButton
{
   public function onClick(skillReference:int = <AppInfo.power>, incrementVAlue:int = 10)
   {
        skillReference += incrementVAlue

   }

}

我希望这段代码能够更新AppInfo类中的权力值。但这不会发生......我假设因为技能作为价值传递而不是作为参考......

你能建议一种解决任务的方法吗？

由于

Answer 1

您的假设是正确的，ints是按值而不是引用传递的。一种直接的方法是将功率封装到引用类型（class）而不是值类型中：

class Skill {
    public var value:int;

    public function Skill(val:int) {
        this.value = val;
    }
}

class AppInfo
{
    public static var power:Skill = new Skill(10);
    public static var speed:Skill = new Skill(20);

}

然后传递power应该将其作为对实例的引用传递。虽然您需要稍微更改一下实现，但要使用skillReference.value。

除此之外，我认为有几种方法可以抽象出你想要的东西。一种方法是使用接口并利用一些依赖注入。

interface ISkills
{
    function get power():int;
    function set power(val:int):void;
}

class AppInfo implements ISkills
{
    private static _power:int = 0;

    public function get power():int { return _power; }  
    public function set power(val:int):void { _power = val; }
}

class SmartButton
{
   public function onClick(skills:int = ISkills, skill:String = "power", incrementVAlue:int = 10)
   {
        skills[skill] += incrementVAlue
   }
}

这里的想法是你想要将你的用法与你的实现分开。在这种情况下，SmartButton不需要知道技能如何运作如何操作它们。它失去了对静态类AppInfo的引用，转而支持可注入实例。这种方法有一些优点，如果你决定静态类不是最好的实现思路而不必更新一堆类/代码，它会使测试更容易，以后更容易交换实现。此外，不是将ISkills注入到方法中，而是将其注入SmartButton的构造函数中，并保留对技能容器的private引用。

另一种方法是使用功能性方法。

class SmartButton
{
    public var defaultWorker:Function = function(val:int):void {
        AppInfo.power += val;
    }

    public function onClick(worker:Function = undefined, incrementValue:int = 10):void
    {
        if(worker == undefined) worker = defaultWorker;
        worker.call(this, incrementValue);
    }
}

同样，在这种情况下，不是将您的实现紧密耦合以直接使用AppInfo类，而是为其注入一个“工作者”，为您完成工作（如果工作者是undefined那么使用默认工作程序。然后您可以通过更改传入的闭包来换出更改的属性。例如，如果您想要更改speed，则可以调用：

var smartButton:SmartButton;
smartButton.onClick(function(val:int):void { AppInfo.speed += val});

不尽如人意，但它完成了工作。

Answer 2

使用command pattern：

的强制性“优雅复杂”方法

Interface Command {
    function execute():void;
}

Class UpdatePower implements Command {
    private var appInfo:AppInfo;
    private var delta:int;

    public function UpdatePower(appInfo:AppInfo, delta:int) {
        this.appInfo = appInfo;
        this.delta = delta;
    }

    public function execute():void {
        appInfo.delta += delta;
    }
}

Class SmartButton {
    var command:Command;

    public function SmartButton(command:Command) {
        this.command = command; 
    }

    public function onClick(event:Event):void {
        command.execute();
    }
}

Answer 3

我可能会以稍微不同的方式实现它。

也许像是;

class Properties {
 private var _properties:Dictionary = new Dictionary();

     public function setValue(key:String, value:int) {
       _properties[key] = value;
    }

    public function getValue(key:String):int {
        if( !_properties[key] ) return 0;
        else return _properties[key];
    }

    public function modifyValue(key:String, value:int) {
        setValue(key, getValue(key) + value);
    }
}

class SmartButton
{
    public function onClick(target:Properties, key:String, incrementValue:int = 10) {
        target.modifyValue(key, incrementValue);
    }
}

或类似的东西。

如何将对类的引用传递给另一个类

3 个答案: