as3——跳出方法,getter and setter,子类实施超类的译本

如何跳出一个方法？
    在方法内最后一条语句执行后，该方法会自动结束。用return语句可以提前跳出结束该方法。
    return语句跳出当前的方法且ActionScript编译程序会继续执行方法中最初的代码。方法中在return语句后面的任何语句都被忽略。
private function sampleFunction (  ):void {
  return;
  trace("Never called");
}

// Called from within another method:
sampleFunction(  );
// Execution continues here after returning from the sampleFuction(  ) invocation
    上面的例子中，return语句结束了方法中的任何动作，因此这不是一种有用的方法。更普遍的，你可以用return语句在特殊的条件下跳出一个方法。这是一个如果密码错误跳出该方法的例子：
private function checkPassword (password:String):void {

  // If password is not "SimonSays", exit the function.
  if (password != "SimonSays") {
    return;
  }

  // Otherwise, perform the rest of the actions.
  showForm ("TreasureMap");
}

// This method call uses the wrong password, so the
// function exits.
checkPassword("MotherMayI");

// This method call uses the correct password, so the function
// shows the TreasureMap form.
checkPassword("SimonSays");
    在上面的例子中，你可能注意到了这个方法被声明为void，然而在含有return语句的方法中没有的得到编译错误。当return语句用来简单的跳出方法时，在声明为void的方法中也是有效的。
然而，如果你要用这种方式return一个值的话，就会出现编译错误。
private function sampleMethod (  ):void {
  return "some value";  // This causes the compiler to generate an error.
}
    注意：在ActionScript2.0中是Void，在ActionScript3.0中它变成了小写void。

 

像方法一样创建属性的行为

    用隐性的getters和setters。
    所有的属性应当声明为private或protected。public属性因封装的原不是一个好方式。应该力求良好的封装。这意味着，一个类不能暴露它内在的容易被破坏的属性；public属性能被开发者轻易的破坏一个类或类的实例。看看下面使用public属性的简单事例：
package {
    public class Counter {
        public var count:uint;
        public function Counter(  ) {
            count = 0;
        }
    }
}
    你可以构造一个Counter实例，并且改变count属性的值。
var counter:Counter = new Counter(  );
counter.count++;
    然而，如果这个程序规定的商业规则要求一个Cound不能超过100呢？你可以看到含有public count属性的Counter类很容易破坏这个规则。
    一种方法是用显式的getters和setters，看下面的例子：
package {
    public class Counter {
        private var _count:uint;
        public function Counter(  ) {
            _count = 0;
        }
        public function getCount(  ):uint {
            return _count;
        }
        public function setCount(value:uint):void {
            if(value < 100) {
                 _count = value;
            }
            else {
                throw Error(  );
            }
        }
    }
}
    另一种方法是用隐式的getters和setters。隐式的getters和setters像方法一样定义，但是看起来像属性。   

下面是一个getter的语法：
public function get name(  ):Datatype {
   
}
    一个setter的语法：
public function set name(value:Datatype):void {

}
    下面用隐式getter和setter方法声明count：
package {
    public class Counter {
        private var _count:uint;
        public function Counter(  ) {
            _count = 0;
        }
        public function get count(  ):uint {
            return _count;
        }
        public function set count(value:uint):void {
            if(value < 100) {
                _count = value;
            }
            else {
                throw Error(  );
            }
        }
    }
}
    然后你可以像个public属性那样处理count：
counter.count = 5;
trace(counter.count);

 

    在子类中执行一个方法怎样让它与在超类中不同？
    这个超类的方法必须定义为public或protected。当决定在子类中运行时使用override特性。
通常子类直接继承超类的所有方法不需要改变实施。那些情况下，在子类的这些方法不需要再次定义。然而，有些情况子类实施一个不同于超类的方法。当这种情况发生，你必须放弃这种方法。要这样做，在超类中的方法必须定义为public或protected。然后可以用override特性在子类中定义该方法。举一个例子，首先定义一个类，Superclass：
package {
    public class Superclass {
        public function Superclass(  ) {}
        public function toString(  ):String {
            return "Superclass.toString(  )";
        }
    }
}
    接下来，定义Subclass使它继承Superclass:
package {
    public class Subclass extends Superclass {
        public function Subclass(  ) {}
    }
}
    自然，Subclass继承了toString()方法因为在超类中它被执行了。
var example:Subclass = new Subclass(  );
trace(example.toString(  )); // Displays: Superclass.toString(  )
    假如你要子类的toString()方法返回一个不同的值，就需要在超类中放弃它，象下面的：
package {
    public class Subclass extends Superclass {
        public function Subclass(  ) {}
        override public function toString(  ):String {
            return "Subclass.toString(  )";
        }
    }
}
    当放弃一个方法时，必须有和超类完全相同的签字。这就是说数字、参数类型和子类放弃的返回类型都必须完全和超类相同。假如不相同，编辑者抛出一个错误。
    有时你放弃一个方法，想让子类的实施完全不同于超类。有时只是想要增加超类的实施。在这样的情况下，你可以用super关键词引用超类从子类运行超类的实施：
super.methodName(  );