Question

在flex项目中，我创建了一种名为AbstractAlert的抽象类，以及AbstractAlert的一些子类Alert1，Alert2 ......

我操纵Vector类Alert1，Alert2 ......就像这样：

var alerts1:Vector.<Alert1> = new Vector.<Alert1>();
var alerts2:Vector.<Alert2> = new Vector.<Alert2>();

我怎样才能处理通用函数来操纵这些向量？

我无法调用此功能：

private function someFunction(from:Vector.<AbstractAlerte>):void
{
...
}

someFunction(alerts1);

有没有办法制作通用功能？

Answer 1

编辑：此部分不正确

关于你的第二个评论，是的，你不会修改原始对象，如果它是一个Vector（iirc？同样也适用于Array，我认为）。这不是因为强制转换，但因为传递的Array和Vector类型的参数不被视为引用。

如果要修改传递的Vector，可以执行以下操作：

var alerts1:Vector<Alert1> = new Vector.<Alert1>();
...fill with objects
alerts1[0].property = "hey";
trace(alerts1[0].property); //output : "hey"
alerts1 = Vector.<Alert1>(someFunction(Vector.<AbstractAlerte>(alerts1)));
trace(alerts1[0].property); //output : "sup"

private function someFunction(from:Vector.<AbstractAlerte>):Vector.<AbstractAlerte>
{
    from[0].property = "sup";
    return from;
}

但这看起来有点麻烦，你觉得呢？使用所有警报类实现的接口，您可以来回放弃所有这些转换。

假设您有一个名为IAlert的接口。而不是写

var alerts1:Vector<Alert1> = new Vector.<Alert1>();

你可以写

var alerts1:Vector<IAlert> = new Vector.<IAlert>();

并用Alert1类型的对象填充它。给IAlert一个名为

的函数

public function get type():String

包含一个变量来保存AbstractAlert中类的类型，并在Alert1和Alert2的构造函数中设置类型，本质上就是这样：

public interface IAlert{
    function get type():String;
}

public class AbstractAlert implements IAlert{
    private var _type:String;

    public function AbstractAlert(type:String){
        this._type = type;
    }

    public function get type():String{return "AbstractAlert";}
}

public class Alert1 extends AbstractAlert implements IAlert{
    public function Alert1(){
        super("Alert1");
    }

    public function get type():String {return super.type;}
}

然后，最后在你的someFunction函数中：

private function someFunction(from:Vector.<IAlert>):Vector.<IAlert>{
    if(from{0].type == "Alert1"){
       //do stuff with Alert1 classes
    }
    etc.

    return from;
}

这是未经测试的代码，但我希望您了解我所说的内容。

Answer 2

道奇德，我很确定你的断言：

这不是因为强制转换，而是因为Array和Vector类型的传递参数不被视为引用

是假的，因为我测试了这段代码：

<s:Application xmlns:fx="http://ns.adobe.com/mxml/2009" 
           xmlns:s="library://ns.adobe.com/flex/spark" 
           xmlns:mx="library://ns.adobe.com/flex/mx" 
           minWidth="955" minHeight="600"
           creationComplete="onCreationComplete(event)">


<fx:Script>
    <![CDATA[
        import mx.events.FlexEvent;

        private var _vector:Vector.<Alert1> = new Vector.<Alert1>();            

        protected function onCreationComplete(event:FlexEvent):void
        {
            // Alert1 is extending AbstractAlert
            _vector.push(new Alert1());
            _vector.push(new Alert1());

            trace(_vector.length);
            modify(Vector.<AbstractAlert>(_vector));
            trace(_vector.length);
            modify2(_vector);
            trace(_vector.length);

        }

        protected function modify(vector:Vector.<AbstractAlert>):void
        {
            vector.splice(0, 1);
        }

        protected function modify2(vector:Vector.<Alert1>):void
        {
            vector.splice(0, 1);
        }

    ]]>
</fx:Script>

结果是：

2 2 1

因此我们可以通过引用传递向量（我相信只有基元类型通过值传递）。

as3参数和继承

2 个答案: