WSDL 介绍

WSDL是一种基于XML的语言。它的作用是描述和访问Web服务。

什么是WSDL？
• WSDL是Web服务描述语言 
• WSDL是写在XML内的
• WSDL是一份XML文档
• WSDL用于描述Web服务
• WSDL也可以用于定位Web服务
• WSDL目前还不是W3C标准

WSDL描述了Web服务

WSDL是Web服务描述语言。
WSDL是写在XML内的文档。该文档描述了Web服务。它指定了服务的具体位置以及触发这些服务的操作方法。

一份WSDL文档仅是一份简单的XML文档。
它包含了几组描述Web服务的定义。

WSDL文档结构

一份WSDL文档使用了下面这些重要元素来描述Web服务：

元素	定义
<portType>	定义Web服务执行的操作
<message>	定义Web服务使用的信息
<types>	定义Web服务使用的数据类型
<binding>	定义Web服务使用的通信协议

一份WSDL文档的主要结构如下所示：

 
<definitions>
<types>
   definition of types........
</types>

<message>
   definition of a message....
</message>

<portType>
   definition of a port.......
</portType>

<binding>
   definition of a binding....

</binding>

</definitions>

一份WSDL文档可能也会包含其它元素，如：extension（扩展）元素和service（服务）元素。它们可以把若干个Web服务的定义在一份单独的WSDL文档中。

WSDL 端口
<portType>元素是最重要的WSDL元素。
它描述了Web服务、可执行的操作以及所涉及的信息。
<portType>元素可以喻为传统程序设计语言里的函数库（或着是一个模块、一个类）。

WSDL信息
<message>元素定义了一项具体操作的数据元素。 
每条信息都由一部分或几部分组成。这些部分可以比作是在传统程序语言中用于请求一个函数的参数。

WSDL 类型

<types>元素定义了被Web服务所用的数据类型。

为了能够最大限度地与所处的平台兼容，WSDL使用了XML Schema 语法来定义数据类型。

WSDL 绑定

<binding>元素为每个端口定义了信息格式和协议细节。

WSDL 案例
下面列举一份WSDL文档的简化片段：

 
 
<message name="getTermRequest">

   <part name="term" type="xs:string"/>
</message>

<message name="getTermResponse">
   <part name="value" type="xs:string"/>

</message>
<portType name="glossaryTerms">
  <operation name="getTerm">
      <input message="getTermRequest"/>
      <output message="getTermResponse"/>
  </operation>
</portType>

在上述案例中，<portType> 元素将 "glossaryTerms" 定义为一个端口的名称，将 "getTerm" 定义为一项操作的名称。

"getTerm" 操作包含一条名为"getTermRequest" 的输入信息和一条名为"getTermResponse".的输出信息。

<message>元素定义了每条元素的一部分内容和相联系的数据类型。

与传统程序设计相比，“glossaryTerms”是一个函数库，"getTerm"是一个以"getTermRequest"作为输入参数、以“getTermResponse”作为输出参数的函数。

WSDL 端口

WSDL 端口描述了由Web服务所揭示的交互界面（合法操作）。

WSDL 端口

<portType>元素是最重要的WSDL元素。
它定义了一个Web服务，可执行的操作以及所涉及的信息。
端口定义了指向Web服务的连接点。它好比是传统程序设计语言里的函数库（或着是一个模块、一个类）。每项操作好比是传统程序设计语言里的一个函数。

操作类型

“请求（request）——回复（response）”类型是最常见的操作类型，但WSDL只定义了其中的四种：

类型	定义
One-way	定义了可以接受信息但不可以回复信息的操作
Request-response	定义了可以接受并回复信息的操作
Solicit-response	定义了可以发送请求并等待回复的操作
Notification	定义了可以发送信息但不等待回复的操作

单向操作

单向操作的案例：

<message name="newTermValues">
   <part name="term" type="xs:string"/>
   <part name="value" type="xs:string"/>

</message>

<portType name="glossaryTerms">
   <operation name="setTerm">
      <input name="newTerm" message="newTermValues"/>

   </operation>
</portType >

在这个案例中，“glossaryTerms” 端口定义了名为"setTerm"的单向操作。
"setTerm"操作允许使用包含“term”和“value”输入参数的"newTermValues"信息输入大量条款。 但是，这项操作并未定义输出信息。

“请求—回复”操作

下面列举一个“请求—回复”操作的案例：

<message name="getTermRequest">
   <part name="term" type="xs:string"/>

</message>

<message name="getTermResponse">
   <part name="value" type="xs:string"/>
</message>

<portType name="glossaryTerms">
  <operation name="getTerm">
      <input message="getTermRequest"/>
      <output message="getTermResponse"/>
  </operation>
</portType>

这个案例中的端口"glossaryTerms"定义了一个名为"getTerm"的“请求—回复”操作。

"getTerm"操作要求发送一条包含“term”参数的"getTermRequest"的输入信息，并且返回一条包含"value"参数的“etTermResponse"的输出信息。

如何安装eclipse和设置就不说了,网上一大把

安装之前,先说说版本的问题,最好还是用Macromedia公司的,其余什么破解的什么玩意最好别用了.

先说安装FDT3 点击"help"--"software updates"--"Find and...."

然后"next" 选着"new Remote Site.."

在Name里面随意填写比如:FDT3.在URL里面:http://fdt.powerflasher.com/update 也就是FDT3的更新地址.然后选择"Finish"这样会在网上自动下载FDT.

现在说说Core Libraries,这个是关键.

选择"add"在这里主要是把flashcs3的编辑器和类以及组件都加到eclipse里面去

选择"Browse"然后选择"New"分别添加如图:

这样就完成了.

这里给个视频文件是如果使用eclipse+FDT3开发as3的视频.是俺那单纯的同事jack录制的.地址在这

这里说说如何把flash里面的帮助放到fdt里面去,如图:

谈谈正则表达式，AS3.0中引进了正则表达式。正则表达式是用于验证文本值是否符合特定模式。
正则表达式有四个部分。1元子符。2元序列。3标志。4数量表达符。
可以这样看  pattern RegExp= /匹配字符串 元字符 元序列/标志 当然顺序可能不完全是这样.别把他想的太复杂其实他就是个组合。
现在我们来看看元字符: ^ $ \ . * + ? ( ) [ ] { } |
前面说的是转义字符串的使用
1.^的用法:匹配字符串的开头
var pattern:RegExp=/^小虫/;
var str:String="小虫是好人";
trace(str, " is valid:", pattern.test(str));小虫是好人  is valid: true
2.$的用法:匹配字符串的结尾
var pattern:RegExp=/lizhen$/; 
var str:String="My name is lizhen";
trace(str, " is valid:", pattern.test(str));小虫是好人  is valid: true
仔细看一下两个符号在匹配字符串中的位置，注意：如果同时使用^符号和$符号，将进行精确匹配。
3.\的用法:匹配字符串的结尾
如果匹配字符串中包含有"/"比如 1/2 的时候，使用如下定义
var pattern:RegExp = /1\/2/;
var str:String="1/2是多少？";
trace(str, " is valid:", pattern.test(str));1/2是多少？  is valid: true
如果匹配字符串中包含有""比如 "lizhen" 的时候，使用如下定义
var pattern:RegExp=/\"lizhen"/;
var str:String="My name is \"lizhen\"";

trace(str, " is valid:", pattern.test(str));My name is "lizhen"  is valid: true
4.*的用法:匹配0个或多个前面的字符.
var pattern:RegExp=/我的*/;
var str:String="我的我的我的";或者var str:String="我的"

trace(str, " is valid:", pattern.test(str));我的我的...  is valid: true
5.+的用法:匹配至少一个前面的字符
var pattern:RegExp=/我的+/;
var str:String="我的ID是...";或者var str:String="我的"

trace(str, " is valid:", pattern.test(str));我的ID是...  is valid: true
注意+和*的区别。如果var str:String="我的"那就会显示false
6.?的用法:匹配0个或1个前面的字符
var pattern:RegExp=/天?/;
var str:String="一天快乐";或者var str:String="天天快乐";
trace(str, " is valid:", pattern.test(str));一天快乐  is valid: true
7..的用法:匹配任意单个字符
var pattern:RegExp=/天./;
var str:String="一天快乐";或者var str:String="天天快乐";
trace(str, " is valid:", pattern.test(str));一天快乐  is valid: true
8.[ ]的用法:匹配某一个范围而不局限于具体的单个字符
var pattern:RegExp=/[a-z]/ 
var str:String="a"
trace(str, " is valid:", pattern.test(str));a  is valid: true
9.( )的用法:这个就相当于是个集合。
var pattern:RegExp=/([a-z][A-Z][0-9])+/  比如说这个就是定义了一个四个字符的字符串第一个字符是a到z之间的字符第二个是A到Z之间的字符第三个是0-9之间的字符，第四个重复前面的数字。
var str:String="aD77aaaaaaaaaaaaaaaa"
trace(str, " is valid:", pattern.test(str));aD77aaaaaaaaaaaaaaaa  is valid: true
10.|的用法:匹配左边或者右边的字符。
var pattern:RegExp=/小虫|lizhen/ 
var str:String="小虫是好人"
trace(str, " is valid:", pattern.test(str));小虫是好人  is valid: true
现在说说元序列 元序列是在正则表达式模式中具有特殊含义的字符序列{n} {n,} {n,m} \b \B \d \D \f \n \r \s \S \t \unnnn \v \w \w \W \xnn
1.{n}的用法:匹配恰好n个（n为非负整数）前面的字符。
var pattern:RegExp=/(小虫){2}/ 对象中连续出现2次小虫.注意下()，如果用var pattern:RegExp=/小虫{2}/ 那么就是var str:String="小虫虫"
var str:String="小虫小虫"
trace(str, " is valid:", pattern.test(str));小虫小虫  is valid: true.
2.{n,}的用法:匹配恰好n个(n为非负整数）或更多个前面的字符。
3.{n,m}的用法:匹配至少n个，至多m个前面的字符。
4.\b的用法:匹配单词字符和非单词字符之间的位置只能放在开头和结尾。NN的，他不支持中文.用中文还是用^.
var pattern:RegExp=/\b小虫/
var pattern:RegExp=/.mp3\b/
var str:String="小虫.mp3"可以判断是否是mp3格式。
trace(str," is valid:", pattern.test(str));小虫.mp3  is valid: true
5.\B的用法:匹配对象必须位于目标字符串的开头和结尾两个边界之内，即匹配对象既不能作为目标字符串的开头，也不能作为目标字符串的结尾和\b相反。
var pattern:RegExp=/\B是/
var str:String="我是虫子"
trace(str," is valid:", pattern.test(str));我是虫子  is valid: true
6.\d的用法:用于匹配从0到9的数字；
var pattern:RegExp=/\b\d/ 开头的第一字符必须为数字
var str:String="900/元"
trace(str," is valid:", pattern.test(str)); 900/元  is valid: true
7.\D的用法:匹配除数字以外的任何字符
var pattern:RegExp=/\b\D/ 开头的第一字符必须不为数字
var str:String="a900/元"
trace(str," is valid:", pattern.test(str)); a900/元  is valid: true
8.\f的用法:匹配换页符DOS操作时代的概念
9.\n的用法:匹配换行符
var pattern:RegExp=/\n/
var str:String="欢迎来到虫子的空间!\n"
trace(str," is valid:", pattern.test(str));
10.\r的用法:匹配回车符
var pattern:RegExp=/\r/
var str:String="欢迎来到虫子的空间!\r"
trace(str," is valid:", pattern.test(str));
11.\s的用法:匹配任何空白字符（空格、制表符、换行符或回车符）
var pattern:RegExp=/\s/
var str:String="欢迎来到虫子的 空间!"
trace(str," is valid:", pattern.test(str)); 欢迎来到虫子的 空间!  is valid: true
12.\S的用法:匹配除空白字符以外的任何字符
var pattern:RegExp=/\S/
var str:String="欢迎来到虫子的空间!"
trace(str," is valid:", pattern.test(str)); 欢迎来到虫子的空间!  is valid: true
13.\t的用法:匹配制表符DOS操作时代的概念
14.\unnnn用法:匹配字符代码由十六进制数字 nnnn 指定的 Unicode 字符。例如，\u263a 是一个笑脸字符
var pattern:RegExp=/\u263a/
var str:String="欢迎来到虫子的空间!\u263a"
trace(str," is valid:", pattern.test(str)); 欢迎来到虫子的空间!☺  is valid: true
15.\v 用法:匹配垂直换页符DOS操作时代的概念
16.\w用法:匹配单词字符（A-Z、a-z、0-9 或 _）。请注意，\w不匹配非英文字符，如é、ñ 或 ç。他和[]是有区别的。
var pattern:RegExp=/^\w/
var str:String="a虫子"
var str:String="0虫子"
var str:String="A虫子"
var str:String="_虫子"
trace(str," is valid:", pattern.test(str));_虫子  is valid: true
17.\W用法:匹配除单词字符以外的任何字符。
var pattern:RegExp=/^\W/
var str:String="虫子"
trace(str," is valid:", pattern.test(str));虫子  is valid: true
18.\xnn用法:匹配具有指定 ASCII 值（由十六进制数字 nn 定义）的字符。
var pattern:RegExp=/^\x41/;"A"
var str:String="ABCD";
trace(str," is valid:", pattern.test(str));ABCD  is valid: true
标志:标志可以作为正则表达式对象属性进行访问。正则表达式有五个标志:g i m s x
1.g的用法:如果不指定g,那么在查找的时候只会返回一个。如：
var str:String = "she sells seashells by the seashore.";
var pattern:RegExp = /sh\w*/;
trace(str.match(pattern))  输出：she
指定g后:
var str:String = "she sells seashells by the seashore.";
var pattern:RegExp = /sh\w*/g;
trace(str.match(pattern))  输出：she,shells,shore
2.i的用法:默认情况下，正则表达式匹配区分大小写。如果设置 i (ignoreCase) 标志，将忽略区分大小写。
var str:String = "She sells seaShells by the seaShore.";
var pattern:RegExp = /sh\w*/gi;
trace(str.match(pattern))  输出：She,Shells,Shore
3.m的用法:匹配"行"的开头和结尾.注意这里的行只有 \n 字符表示行的结束，其余的都不行。包括\r。比如：
var str:String = "She sells seaShells by the seaShore.\n";
str+="She's your mother"
var pattern:RegExp = /^sh\w*/gim;
trace(str.match(pattern))  输出：She,She
也可以在结尾使用.比如:
var str:String = "She sells seaShells by the seaShore.\n";
str+="She's your mother.\n"
var pattern:RegExp = /\n\$\w*/gim;
trace("====="+str.match(pattern))  输出：=====
4.s的用法:用点来匹配换行符
var str:String = "<p>Test\n";
str += "Multiline</p>";
var re:RegExp = /<p>.*?<\/p>/s;
trace(str.match(re));
5.x的用法:在正则表达式中使用 x (extended) 标志时，则会忽略在模式中键入的所有空格。
var str:String = "lizhen";
var re:RegExp = /li zhen/x
trace(str.match(re));输出：lizhen

我把正则表达式的一些基本语法都写出来了,基本上每个都有例子。看上去不难，而正则表达式的难处就在于这些基本元素的组合。有些人觉得看正则表达式就像看天书一样，一大堆符号在那里，的确是这样，但是你掌握了他的基础以后，你就能慢慢的看的懂它了，还是老话，多学多用。

今天说下AS3.0的核心--事件.

先说说事件在AS3.0中是怎么样运行的吧.AS3.0的事件流是先从根显示对象开始查找事件目标,找到目标后然后在返回根显示对

象.一个"U"型的.从根显示对象到目标事件的父对象这个阶段叫做捕获阶段.第二个阶段叫做目标阶段.也就是发生事件的显示

对象.第三个阶段也就是从发生事件的显示对象的父对象返回到根显示对象叫冒泡阶段.当然这是在显示列表中的对象产生事件

时的事件流.如果不是显示列表.则直接到目标阶段.

现在说说如何实现事件机制.在AS3.0中,有两个办法,一个是实现IEventDispatcher 接口,一个是继承EventDispatcher类或他

的子类(EventDispatcher也是实现IEventDispatcher 的接口).比如如果要自定义事件机制.可以 

package {
        import flash.events.Event;
        import flash.display.Sprite;
      
        public class IEventDispatcherExample extends Sprite {
                public function IEventDispatcherExample() {
                        var decorDispatcher:DecoratedDispatcher = new DecoratedDispatcher();
                        decorDispatcher.addEventListener("doSomething", didSomething);
                        decorDispatcher.dispatchEvent(new Event("doSomething"));
                }
              
                public function didSomething(evt:Event):void {
                        trace(">> didSomething");
                }
        }
}

import flash.events.IEventDispatcher;
import flash.events.EventDispatcher;
import flash.events.Event;
              
class DecoratedDispatcher implements IEventDispatcher { //实现IEventDispatcher接口.  
    private var dispatcher:EventDispatcher;
              
    public function DecoratedDispatcher() {
        dispatcher = new EventDispatcher(this);
    }
          
    public function addEventListener(type:String, listener:Function, useCapture:Boolean = false, priority:int

= 0, useWeakReference:Boolean = false):void{
        dispatcher.addEventListener(type, listener, useCapture, priority);
    }
          
    public function dispatchEvent(evt:Event):Boolean{
        return dispatcher.dispatchEvent(evt);
    }
   
    public function hasEventListener(type:String):Boolean{
        return dispatcher.hasEventListener(type);
    }
   
    public function removeEventListener(type:String, listener:Function, useCapture:Boolean = false):void{
        dispatcher.removeEventListener(type, listener, useCapture);
    }
                  
    public function willTrigger(type:String):Boolean {
        return dispatcher.willTrigger(type);
    }
}

如果是继承EventDispatcher或他的子类,则可以直接使用

btn.addEventListener(MouseEvent.CLICK,btnf);//注册该侦听器
this.addEventListener("rebuild",build);
function btnf(e:MouseEvent):void {//广播.

 dispatchEvent(new Event("rebuild"));
}
function build(e:Event):void {
 trace(e.currentTarget);
}

在说说事件的参数Event类.Event类作为创建EVENT对象的基类,当发生事件时Event对象将作为参数传递给事件侦听器.有时候

你可能想传个值给事件函数。在AS2.0中，一般都是在广播的前面定义个Object对象，然后定义些属性，把这个Object对象传

给事件函数使用，现在由于广播的都是Event的基类，我们不能使用以前的办法了，呵呵，那就继承他吧。
自定义一个类.叫PingEvent

package {
 import flash.events.Event;
 public class PingEvent extends Event {
  public static  const Rebuild:String="Rebuild";//自定义事件类型。
  public var _arg:Array=new Array();
  public function PingEvent(type:String,bubbles:Boolean = false,cancelable:Boolean = false) {
   super(type,bubbles,cancelable);
   //t=0;
  }
  public function setValue(...arg):void {
   _arg=arg;

  }
  public function getValue():Array {
   return _arg;
  }
 }
}

在fla中()

btn.addEventListener(MouseEvent.CLICK,btnf);//注册该侦听器
this.addEventListener(PingEvent.Rebuild,build);
function btnf(e:MouseEvent):void {//广播.
 var tt:PingEvent=new PingEvent(PingEvent.Rebuild);

 tt.setValue(1,2,3,4,5,6,7,8,9,10);//这个地方你可以传递你想要传递的值，当然你也可以和AS2中一样，定义一

个对象传出去。
 dispatchEvent(tt);
}
function build(e:PingEvent):void {
 trace(e.getValue());
}

这样就可以了.

1.
所有的类（无论是内置类还是用户定义的类）都是从 Object 类派生的。以前在 ActionScript方面有经验的程序员一定要注意到，Object 数据类型不再是默认的数据类型，尽管其它所有类仍从它派生。在 ActionScript 2.0 中，下面的两行代码等效，因为缺乏类型注释意味着变量为 Object 类型：
var someObj:Object;
var someObj;
但是，ActionScript 3.0 引入了无类型变量这一概念，这一类变量可通过以下两种方法来指定：
var someObj:*;
var someObj;
无类型变量与 Object 类型的变量不同。二者的主要区别在于无类型变量可以保存特殊值undefined，而 Object 类型的变量则不能保存该值。
2.
顶级类不需要导入
3.
在时间轴上写代码会自动导入内置类(在包flash.*中的所有类)。
4.
类的修饰符public和internal.默认时候为internal,internal仅对其所在包的其他成员可见。AS3.0可以使用内部类，这个内部类只能被主类或者同一个as文件里面的其他内部类使用。
5.
构造函数的修饰符必须为public.
6.
数据类型:
“基元值”是一个属于下列数据类型之一的值：Boolean、int、Number、String 和 uint。基元值的处理速度通常比复杂值的处理速度快，因为 ActionScript 按照一种尽可能优化内存和提高速度的特殊方式来存储基元值。
“复杂值”是指基元值以外的值。定义复杂值的集合的数据类型包括：Array、Date、Error、Function、RegExp、XML 和 XMLList。许多编程语言都区分基元值及其包装对象。例如，Java 中有一个 int 基元值和一个包装它的java.lang.Integer 类。Java 基元值不是对象，但它们的包装是对象，这使得基元值对于某些运算非常有用，而包装对象则更适合于其它运算。在 ActionScript 3.0 中，出于实用的目的，不对基元值及其包装对象加以区分。所有的值（甚至基元值）都是对象。Flash Player将这些基元类型视为特例 — 它们的行为与对象相似，但是不需要创建对象所涉及的正常开销。这意味着下面的两行代码是等效的：
var someInt:int = 3;
var someInt:int = new int(3);
ActionScript 3.0 中的所有值均是对象，而与它们是基元值还是复杂值无关。
7.
is 运算符是 ActionScript 3.0 中的新增运算符，它可用来测试变量或表达式是否为给定数据类型的成员。在早期的 ActionScript 版本中，此功能由 instanceof 运算符提供。
is 运算符能检查正确的继承层次结构，不但可以用来检查对象是否为特定类的实例，而且还可以检查对象是否是用来实现特定接口的类的实例。下面的示例创建 Sprite 类的一个名为mySprite 的实例，并使用 is 运算符来测试 mySprite 是否为 Sprite 和 DisplayObject 类的实例，以及它是否实现 IEventDispatcher 接口：
var mySprite:Sprite = new Sprite();
trace(mySprite is Sprite); // true
trace(mySprite is DisplayObject); // true
trace(mySprite is IEventDispatcher); // true
is 运算符检查继承层次结构，并正确地报告 mySprite 与 Sprite 和 DisplayObject 类兼容（Sprite 类是 DisplayObject 类的子类） 。is 运算符还检查 mySprite 是否是从实现IEventDispatcher 接口的任意类继承的。由于 Sprite 类是从实现 IEventDispatcher 接口的 EventDispatcher 类继承的，因此 is 运算符会正确地报告 mySprite 也实现该接口。
下面的示例说明与上一个示例相同的测试，但使用的是 instanceof 运算符，而不是 is 运算符。instanceof 运算符正确地识别出 mySprite 是 Sprite 或 DisplayObject 的实例，但是，当它用来测试 mySprite 是否实现 IEventDispatcher 接口时，返回的却是 false。
trace(mySprite instanceof Sprite); // true
trace(mySprite instanceof DisplayObject); // true
trace(mySprite instanceof IEventDispatcher); // false
8.
as 运算符
as 运算符是 ActionScript 3.0 中的新增运算符，也可用来检查表达式是否为给定数据类型的成员。但是，与 is 运算符不同的是，as 运算符不返回布尔值，而是返回表达式的值（代替 true）或 null （代替 false）。下面的示例说明了在简单情况下使用 as 运算符替代 is运算符的结果，例如，检查 Sprite 实例是否为 DisplayObject、IEventDispatcher 和Number 数据类型的成员。
var mySprite:Sprite = new Sprite();
trace(mySprite as Sprite); // [Sprite 对象]
trace(mySprite as DisplayObject); // [Sprite 对象]
trace(mySprite as IEventDispatcher); // [Sprite 对象]
trace(mySprite as Number); // null
在使用 as 运算符时，右侧的操作数必须是数据类型。如果尝试使用表达式（而非数据类型）作为右侧的操作数，将会产生错误。
9.
常量
ActionScript 3.0 支持 const 语句，该语句可用来创建常量。常量是指具有无法改变的固定值的属性。只能为常量赋值一次，而且必须在最接近常量声明的位置赋值。例如，如果将常量声明为类的成员，则只能在声明过程中或者在类构造函数中为常量赋值。下面的代码声明两个常量。第一个常量 MINIMUM 是在声明语句中赋值的，第二个常量MAXIMUM 是在构造函数中赋值的。
class A
{
public const MINIMUM:int = 0;
public const MAXIMUM:int;
public function A()
{
MAXIMUM = 10;
}
}
var a:A = new A();
trace(a.MINIMUM); // 0
trace(a.MAXIMUM); // 10
如果您尝试以其它任何方法向常量赋予初始值，则会出现错误。例如，如果您尝试在类的外部设置 MAXIMUM 的初始值，将会出现运行时错误。
class A
{
public const MINIMUM:int = 0;
public const MAXIMUM:int;
}
var a:A = new A();
a["MAXIMUM"] = 10; // 运行时错误

10.
for..in
for..in 循环用于循环访问对象属性或数组元素。例如，可以使用 for..in 循环来循环访问通用对象的属性（不按任何特定的顺序来保存对象的属性，因此属性可能以看似随机的顺序出现）：
var myObj:Object = {x:20, y:30};
for (var i:String in myObj)
{
trace(i + ": " + myObj[i]);
}
// 输出：
// x: 20
// y: 30
还可以循环访问数组中的元素：
var myArray:Array = ["one", "two", "three"];
for (var i:String in myArray)
{
trace(myArray[i]);
}
// 输出：
// one
// two
// three
11.
for each..in
for each..in 循环用于循环访问集合中的项目，它可以是 XML 或 XMLList 对象中的标签、对象属性保存的值或数组元素。例如，如下面所摘录的代码所示，您可以使用 for
each..in 循环来循环访问通用对象的属性，但是与 for..in 循环不同的是，for each..in循环中的迭代变量包含属性所保存的值，而不包含属性的名称：
var myObj:Object = {x:20, y:30};
for each (var num in myObj)
{
trace(num);
}
// 输出：
// 20
// 30
您可以循环访问 XML 或 XMLList 对象，如下面的示例所示：
var myXML:XML =
Jane
Susan
John
;
for each (var item in myXML.fname)
{
trace(item);
}
/* 输出
Jane
Susan
John
*/
还可以循环访问数组中的元素，如下面的示例所示：
var myArray:Array = ["one", "two", "three"];
for each (var item in myArray)
{
trace(item);
}
// 输出：
// one
// two
// three
如果对象是密封类的实例，则您将无法循环访问该对象的属性。即使对于动态类的实例，也无法循环访问任何固定属性（即，作为类定义的一部分定义的属性）。
12.
嵌套函数
您可以嵌套函数，这意味着函数可以在其它函数内部声明。除非将对嵌套函数的引用传递给外部代码，否则嵌套函数将仅在其父函数内可用。例如，下面的代码在getNameAndVersion() 函数内部声明两个嵌套函数：
function getNameAndVersion():String
{
function getVersion():String
{
return "9";
}
function getProductName():String
{
return "Flash Player";
}
return (getProductName() + " " + getVersion());
}
trace(getNameAndVersion()); // Flash Player 9
在将嵌套函数传递给外部代码时，它们将作为函数闭包传递，这意味着嵌套函数保留在定义该函数时处于作用域内的任何定义。
13.
函数参数的传递:
参数的传递有两种方法：值传递和引用传递。
值传递是将要传递的值作为一副本传递的。
引用传递,传递的是引用对象的内存地址。
在 ActionScript 3.0 中，所有的参数均按引用传递，因为所有的值都存储为对象。但是，属于基元数据类型（包括 Boolean、Number、int、uint 和 String）的对象具有一些特殊运算符，这使它们可以像按值传递一样工作。
function passPrimitives(xParam:int, yParam:int):void
{
xParam++;
yParam++;
trace(xParam, yParam);
}
var xValue:int = 10;
var yValue:int = 15;
trace(xValue, yValue); // 10 15
passPrimitives(xValue, yValue); // 11 16
trace(xValue, yValue); // 10 15
//上面的使用值传递。因为传的数据是属于基元数据类型。
在给个列子
function passByRef(objParam:Object):void
{
objParam.x++;
objParam.y++;
trace(objParam.x, objParam.y);
}
var objVar:Object = {x:10, y:15};
trace(objVar.x, objVar.y); // 10 15
passByRef(objVar); // 11 16
trace(objVar.x, objVar.y); // 11 16
//这个使用的是引用传递。对 objParam 对象的 x 和 y 属性所做的更改将反映在 objVar 对象中。
14.
默认参数值
ActionScript 3.0 中新增了为函数声明“默认参数值”的功能。如果在调用具有默认参数值的函数时省略了具有默认值的参数，那么，将使用在函数定义中为该参数指定的值。所有具有默认值的参数都必须放在参数列表的末尾如：
function defaultValues(x:int, y:int = 3, z:int = 5):void
{
trace(x, y, z);
}
defaultValues(1); // 1 3 5
如果改成：
function defaultValues(y:int = 3, z:int = 5,x:int):void
{
trace(y, z, x);
}
将会出现编译错误。所以所有具有默认值的参数都必须放在参数列表的末尾。
如果某个参数存在默认值，则会有效地使该参数成为“可选参数”。没有默认值的参数被视为“必需的参数”。在用这个例子：
function defaultValues(x:int, y:int = 3, z:int = 5):void
{
trace(x, y, z);
}
defaultValues(1); // 1 3 5
defaultValues中只使用了一个参数x,这个是“必需的参数”.
15
arguments 对象
在将参数传递给某个函数时，可以使用 arguments 对象来访问有关传递给该函数的参数的信息。arguments 对象的一些重要方面包括：
 arguments 对象是一个数组，其中包括传递给函数的所有参数。
 arguments.length 属性报告传递给函数的参数数量。
 arguments.callee 属性提供对函数本身的引用，该引用可用于递归调用函数表达
在 ActionScript 3.0 中，函数调用中所包括的参数的数量可以大于在函数定义中所指定的参数数量，但是，如果参数的数量小于必需参数的数量，在严格模式下将生成编译器错误。您可以使用 arguments 对象的数组样式来访问传递给函数的任何参数，而无需考虑是否在函数定义中定义了该参数。下面的示例使用 arguments 数组及 arguments.length 属性来输出传递给 traceArgArray() 函数的所有参数：
function traceArgArray(x:int):void
{
for (var i:uint = 0; i < arguments.length; i++)
{
trace(arguments[i]);
}
}
traceArgArray(1, 2, 3);
// 输出：
// 1
// 2
// 3
arguments.callee 属性通常用在匿名函数中以创建递归。您可以使用它来提高代码的灵活性。如果递归函数的名称在开发周期内的不同阶段会发生改变，而且您使用的是
arguments.callee（而非函数名），则不必花费精力在函数体内更改递归调用。在下面的函数表达式中，使用 arguments.callee 属性来启用递归：
var factorial:Function = function (x:uint)
{
if(x == 0)
{
return 1;
}
else
{
return (x * arguments.callee(x - 1));
}
}
trace(factorial(5)); // 120
16.
...(rest) 参数
ActionScript 3.0 中引入了一个称为 ...(rest) 参数的新参数声明。此参数可用来指定一个数组参数以接受任意多个以逗号分隔的参数。此参数可以拥有保留字以外的任意名称。此参数声明必须是最后一个指定的参数。使用此参数会使 arguments 对象变得不可用。尽管 ...(rest)参数提供了与 arguments 数组和 arguments.length 属性相同的功能，但是它不提供与arguments.callee 类似的功能。使用 ...(rest) 参数之前，应确保不需要使用arguments.callee。
下面的示例使用 ...(rest) 参数（而非 arguments 对象）来重写 traceArgArray() 函数：
function traceArgArray(... args):void
{
for (var i:uint = 0; i < args.length; i++)
{
trace(args[i]);
}
}
traceArgArray(1, 2, 3);
// 输出：
// 1
// 2
// 3
...(rest) 参数还可与其它参数一起使用，前提是它是最后一个列出的参数。下面的示例修改traceArgArray() 函数，以便它的第一个参数 x 是 int 类型，第二个参数使用 ...(rest) 参数。输出结果将忽略第一个值，因为第一个参数不再属于由 ...(rest) 参数创建的数组。
function traceArgArray(x: int, ... args)
{
for (var i:uint = 0; i < args.length; i++)
{
trace(args[i]);
}
}
traceArgArray(1, 2, 3);
// 输出：
// 2
// 3
17.
ActionScript 3.0 不支持抽象类
18.
必须在声明常量的同时初始化使用 static 和 const 关键字声明的变量
19.
ActionScript 3.0 中不继承静态属性和静态方法，但是在子类的中可以直接使用该属性和该方法，不需要用类名调用。对于实例属性 (property)，无论是使用 function、var 还是使用 const 关键字定义的，只要在基类中未使用 private 属性 (attribute) 声明该属性 (property)，这些属性都可以由子类继承.可以继承使用 var 或 const 关键字声明的属性，但不能对其进行覆盖。覆盖某一属性就表示在子类中重新定义该属性。唯一可覆盖的属性类型是方法，即使用 function 关键字声明的属性。
20.
在子类中不能覆盖使用 var 关键字声明的类成员变量。但是，使用 getter 和 setter函数创建的属性没有此限制。可以对从超类继承的 getter 和 setter 函数使用 override 属性。
21.
接口定义的结构类似于类定义的结构，只是接口只能包含方法但不能包含方法体。接口不能包含变量或常量，但是可以包含 getter 和 setter。要定义接口，请使用 interface 关键字。只能使用 public 和internal 访问控制说明符来修饰接口定义。接口定义中的方法声明不能包含任何访问控制说明符。
22.
在实现接口的类中，实现的方法必须：
使用 public 访问控制标识符。
使用与接口方法相同的名称。
拥有相同数量的参数，每一个参数的数据类型都要与接口方法参数的数据类型相匹配。
使用相同的返回类型。
23.
在 Sprite 或 MovieClip 对象中，使用 graphics 属性创建的绘制内容始终出现在该对象包含的所有子级显示对象的后面。另外，graphics 属性内容不是单独的显示对象，因此，它不会出现在 Sprite 或 MovieClip 对象的子级列表中.
24.
 var img:Loader = new Loader();
         img.load(new URLRequest("img/Banana.jpg"));
  var tempMatrix:Matrix = img.content.transform.matrix;
 //img.content返回对象的根显示目录，比如img返回的是Bitmap
 //继承DisplayObject类的所有类都有transform属性．用来返回一个transform对象．transform对象的matrix属性会返回一个Matrix对象，其中包含影响显示对象的缩放、旋转和平移的值。

     在AS3.0中的几何对象有Point 对象.Rectangle 对象.Matrix 对象,为什么要使用几何对象?使用这些几何对象是很必要的,因为你常常用到的类的属性和这有很大的关系.好了今天先来说说Point对象.

   Point对象实际上就是表示坐标的.他所有的方法都和这个有关系.总结了下Point对象的用法,他有三个作用.先看看他的第一个作用:

1.
确定同一显示对象容器(stage)中两个显示对象的注册点之间的距离：

var FixedSprite:Sprite=new Sprite();
var moveSprite:Sprite=new Sprite();
var size:uint    = 100;
var bgColor:uint = 0xFFCC00;
moveSprite.name="移动的Sprite";
FixedSprite.name="固定的Sprite";
moveSprite.addEventListener(MouseEvent.MOUSE_DOWN, mouseDownHandler);
moveSprite.addEventListener(MouseEvent.MOUSE_UP, mouseUpHandler);
draw(FixedSprite);
draw(moveSprite);
function draw(sprite:Sprite):void {
 var t:TextField=new TextField();
 t.text= String(sprite.name);
 t.selectable=false;
 sprite.graphics.beginFill(bgColor);
 sprite.graphics.drawRect(0, 0, size, size);
 sprite.graphics.endFill();
 sprite.addChild(t);
 addChild(sprite);
}
function mouseDownHandler(event:MouseEvent):void {
 moveSprite.addEventListener(MouseEvent.MOUSE_MOVE, mouseMoveHandler);
 moveSprite.startDrag();
}

function mouseUpHandler(event:MouseEvent):void {
 moveSprite.removeEventListener(MouseEvent.MOUSE_MOVE, mouseMoveHandler);
 moveSprite.stopDrag();
}
function mouseMoveHandler(event:MouseEvent):void {
 var FixedSpritepoint:Point=new Point(FixedSprite.x,FixedSprite.y);
 var moveSpritepoint:Point=new Point(moveSprite.x,moveSprite.y);
 var distance:Number = Point.distance(FixedSpritepoint, moveSpritepoint);
 trace("他们两个原点的距离为:"+distance);
 event.updateAfterEvent();
}
很简单一看就懂，所以我没有写注释。直接复制到时间轴上运行就可以.在这里说一下在时间轴上运行时候,flash会自动导入flash.*和顶极包.这里没有必要导入.

2.

不同的显示容器中的显示对象的坐标可能都不相同。因为显示对象的坐标相对是他的父显示对象而来的。相信大家都明白这个。好了，我们现在的这个例子是求两个不同的显示容器中的显示对象的距离。
var FixedSprite:Sprite=new Sprite();
var ObjectSprite:Sprite=new Sprite();//这个是moveSprite的父显示对象，也就是说moveSprite在这里面
var moveSprite:Sprite=new Sprite();
var size:uint    = 100;
var size_1:uint    = 300;
var bgColor:uint = 0xFFCC00;
var bgColor_1:uint =0xCCFF00;
FixedSprite.name="固定的Sprite";
ObjectSprite.name="ObjectSprite容器";
moveSprite.name="移动的Sprite";
ObjectSprite.x=200;
moveSprite.y=100;
moveSprite.x=100;
moveSprite.addEventListener(MouseEvent.MOUSE_DOWN, mouseDownHandler);
moveSprite.addEventListener(MouseEvent.MOUSE_UP, mouseUpHandler);
draw(FixedSprite,bgColor,size,stage);
draw(ObjectSprite,bgColor_1,size_1,stage);
draw(moveSprite,bgColor,size,ObjectSprite);
function draw(sprite:Sprite,bgColor:uint,size:uint,target:DisplayObjectContainer):void {
 var t:TextField=new TextField();
 t.text= String(sprite.name);
 t.selectable=false;
 sprite.graphics.beginFill(bgColor);
 sprite.graphics.drawRect(0, 0, size, size);
 sprite.graphics.endFill();
 sprite.addChild(t);
 target.addChild(sprite);

}
function mouseDownHandler(event:MouseEvent):void {
 moveSprite.addEventListener(MouseEvent.MOUSE_MOVE, mouseMoveHandler);
 moveSprite.startDrag();
}

function mouseUpHandler(event:MouseEvent):void {
 moveSprite.removeEventListener(MouseEvent.MOUSE_MOVE, mouseMoveHandler);

 var FixedSpritepoint:Point=new Point(FixedSprite.x,FixedSprite.y);
 var ObjectSpritepoint:Point=new Point(ObjectSprite.x,ObjectSprite.y);
 var moveSpritepoint:Point=new Point(moveSprite.x,moveSprite.y);

 moveSpritepoint=ObjectSprite.localToGlobal(moveSpritepoint);//将ObjectSprite中的Piont对象moveSpritepoint转换为相对与舞台的piont对象。
 trace(moveSpritepoint);

 var distance:Number = Point.distance(FixedSpritepoint, moveSpritepoint);
 trace("他们两个原点的距离为:"+distance);
 moveSprite.stopDrag();
}
function mouseMoveHandler(event:MouseEvent):void {

 event.updateAfterEvent();
}
这个例子主要是说DisplayObject类的localToGlobal方法,因为localToGlobal需要一个point对象.

3.

point类还有的作用就是极坐标转换为平面坐标。

var size:uint    = 100;
var bgColor:uint = 0xFFCC00;
var moveSprite:Sprite=new Sprite();
moveSprite.name="看看这个";

function draw(sprite:Sprite,bgColor:uint,size:uint,target:DisplayObjectContainer):void {
 var t:TextField=new TextField();
 t.text= String(sprite.name);
 t.selectable=false;
 sprite.graphics.beginFill(bgColor);
 sprite.graphics.drawRect(0, 0, size, size);
 sprite.graphics.endFill();
 sprite.addChild(t);
 target.addChild(sprite);

}
draw(moveSprite,bgColor,size,stage);

var distance:Number = 200;//极坐标的极轴.
var angle:Number = 2 * Math.PI * (90 / 360);//θ角.
var translatePoint:Point = Point.polar(distance, angle);
moveSprite.x += translatePoint.x;
moveSprite.y += translatePoint.y;

使用polar方法来转换。以一点出发为原点，以原点出发某条射线为极轴，空间某点坐标到原点距离为r，其与原点连线与极轴夹角为θ，θ以极轴出发逆时针为正，这就是极坐标。 极坐标与平面直角坐标的变换一般为： x=r*cosθ y=r*sinθ 此时以X轴正方向为极轴方向

好了,现在说说Rectangle类.

Rectangle对象定义一个矩形区域。嘿嘿，只不过他是看不见的。当定义一个Rectangle对象时候，你要想象，想象现在有个矩形......呵呵。
//我们来做个拖动的例子，让他在这个区域内移动。

var size:uint    = 100;
var size_1:uint    = 300;
var bgColor:uint = 0xFFCC00;
var bgColor_1:uint =0xCCFF00;
var moveSprite:Sprite=new Sprite();
moveSprite.x=20;
moveSprite.y=20;
var FixedSprite:Sprite=new Sprite();
FixedSprite.x=20;
FixedSprite.y=20;

moveSprite.name="拖动条";
FixedSprite.name="拖动区域";
moveSprite.addEventListener(MouseEvent.MOUSE_DOWN, mouseDownHandler);
moveSprite.addEventListener(MouseEvent.MOUSE_UP, mouseUpHandler);
draw(FixedSprite,bgColor_1,size_1,stage);
draw(moveSprite,bgColor,size,stage);
var RectangleObject:Rectangle=new Rectangle(0,0,FixedSprite.width-moveSprite.width,FixedSprite.height-moveSprite.height);
var p:Point=new Point(20,20);
RectangleObject.offsetPoint(p);
function draw(sprite:Sprite,bgColor:uint,size:uint,target:DisplayObjectContainer):void {
 var t:TextField=new TextField();
 t.text= String(sprite.name);
 t.selectable=false;
 sprite.graphics.beginFill(bgColor);
 sprite.graphics.drawRect(0, 0, size, size);
 sprite.graphics.endFill();
 sprite.addChild(t);
 target.addChild(sprite);
}
function mouseDownHandler(event:MouseEvent):void {
 moveSprite.addEventListener(MouseEvent.MOUSE_MOVE, mouseMoveHandler);
 moveSprite.startDrag(false,RectangleObject);
}

function mouseUpHandler(event:MouseEvent):void {
 moveSprite.removeEventListener(MouseEvent.MOUSE_MOVE, mouseMoveHandler);
 moveSprite.stopDrag();
}
function mouseMoveHandler(event:MouseEvent):void {

 event.updateAfterEvent();
}

最后我们说说Matrix类,

Matrix估计是几何类中最复杂的，但是他的功能也是最强大的，运用好Matrix可以大大的节约开发时间．Matrix对象说穿了他就是包含a,b,c,d,tx,ty的六个值的矩形．a是x轴的缩放百分比,相当于xScale，b是y轴的倾斜．c是x的倾斜，d是y轴的缩放百分比,相当于yScale.tx是x坐标位置,ty是y坐标位置.这样看就简单了吧．
var size:uint    = 100;

var bgColor:uint = 0xFFCC00;
var ObjectSprite:Sprite=new Sprite();
var btnSprite:Sprite=new Sprite();

ObjectSprite.x=200;

btnSprite.addEventListener(MouseEvent.CLICK, mouseDownHandler);

draw(ObjectSprite,bgColor,size,stage);
draw(btnSprite,bgColor,size,stage);

function draw(sprite:Sprite,bgColor:uint,size:uint,target:DisplayObjectContainer):void {
 sprite.graphics.beginFill(bgColor);
 sprite.graphics.drawRect(0, 0, size, size);
 sprite.graphics.endFill();
 target.addChild(sprite);

}
var tempMatrix:Matrix = ObjectSprite.transform.matrix;//继承DisplayObject类的所有类都有transform属性．用来返回一个transform对象．transform对象的matrix属性会返回一个Matrix对象，其中包含影响显示对象的缩放、旋转和平移的值。
trace(tempMatrix);//在这里你可以看到Matrix的值.
function mouseDownHandler(e:Event) {
 tempMatrix.scale(0.5,0.5);//更改tempMatrix的a和d的值．
 tempMatrix.translate(5,5);//更改tempMatrix的tx和ty的值．
 ObjectSprite.transform.matrix=tempMatrix;
}

======================================================================

好了,集合类就这些东西了,可以看出,集合类主要是用来辅助其他类的.

         做的时候发现了几个问题,比如AS3.0中的xml文件和sound的id3都不支持中文等等....这些有点郁闷.估计以后升级版本会改.AS3.0比起2.0来说复杂了很多.功能得到了大幅度的加强.比如SoundMixer类,我在这里没有用到它.使用SoundMixer.computeSpectrum() 方法可以显示声音波形图....呵呵.以后做的MP3播放器就更绚了.

显示编程用于处理出现在adobeFlashplay9的舞台上的元素，这个可能是和AS2.0区别最大的地方。在AS3.0中，每个应用程序都有一个由显示对象构成的层次结构。这个结构称为“显示列表”。显示列表包含应用程序中的所有可视元素。
显示对象只能有一个显示对象容器，也就是说这个显示对象不能放在一个以上的显示对象容器中。
如果将在第一个显示对象容器中包含的某一显示对象添加到另一个显示对象容器中，则会从第一个显示对象容器的子级列表中删除该显示对象.

该函数可以遍历显示列表。
function traceDisplayList(container:DisplayObjectContainer,
indentString:String = ""):void
{
var child:DisplayObject;
for (var i:uint=0; i < container.numChildren; i++)
{
child = container.getChildAt(i);
trace(indentString, child, child.name);//主目录。
if (container.getChildAt(i) is DisplayObjectContainer)
{
traceDisplayList(DisplayObjectContainer(child), indentString + "")//显示子目录
}
}
}

处理显示对象的事件：
处理显示对象事件时需要记住的一个重要问题是：从显示列表中删除显示对象时，事件侦听器的存在将会对是否从内存中自动删除显示对象（垃圾回收）产生影响。如果显示对象拥有订阅为其事件的侦听器的对象，即使从显示列表中删除了显示对象，也不会从内存中删除显示对象，因为显示对象仍然拥有到这些侦听器对象的引用。
x 和 y：
一定要记住 x 和 y 属性始终是指显示对象相对于其父显示对象坐标轴的 0,0 坐标的位置。