as3参数和继承

Question

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

我操纵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类型的传递参数没有被视为引用。

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

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

DodgerThud，我很确定您的主张：

这不是因为强制转换，而是因为未将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

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