在flashmx2004专业版中编程
    打开你的flash,用Ctrl+N就可以打开New document对话框。flash2004现在不仅可以编辑Flash文件(*.fla)，而且还能编辑ActionScript文件(*.as),Flash javascript文件(*.jsfl),Flash工程文件(*.flp)文件。
screen.width-430)this.width=screen.width-430 align=center border=0> 
让我们来建立第一个flash 应用程序了,给大家对在flash mx 2004专业版有一个大概的了解.
1.建立一个ActionScript文件(ActionScript File),名为FirstClass.,然后你就可以看到.as的编辑框了,键入如下代码:

class FirstClass                                        //(1)
{
        private var myData:Number=10;                  //(2)   
        public  function traceMyData():Void            //(3)
        {
                trace(myData=+myData);
        }
}

然后选择好路径,我这里是存在G:/tutorial下面,存成FirstClass.as.
这是我们在flash mx 2004中定义的第一个类.为了给大家一个感性的认识, 简单地介绍一下这个类的结构. 第(1)行是类头, 由class关键字定义一个类, 注意存成.as文件的时候,文件名应与类名一样.类头下面的全是类体了.第(2)行是类的数据成员myData的定义,接触过AS1.0的读者请注意:其中private是访问限定字,Number表示数据类型为数字.这与AS1.0有不同之处.第(3)行定义了一个成员函数,traceMyData用来打印myData的值,接触过AS1.0的读者请注意:其中public是访问限定字,Void为返回数据类型,这里的Void表示没有返回值.
2.用Ctrl+N建立一个flash文档(Flash document),取名为myFirst2004Program.
3.用F9打开ActionScript编辑面板, 在专业版里面, 没有普通编辑模式,只存在专家模式了.
4.点击Action面板右上角的按钮screen.width-430)this.width=screen.width-430 align=center border=0>,选择Preferences定义Action面板的参数和选项(Ctrl+U).如图所示即为Preferences面板.

screen.width-430)this.width=screen.width-430 align=center border=0>

其中有一个重要的设置就是AS类的路径设置.
5.选择Preferences面板中的ActionScript标签,然后再点选Language里面的ActionScript 2.0 Settings..,就会弹出ActionScript Setting对话框.如下图所示:
screen.width-430)this.width=screen.width-430 align=center border=0>
默认的有一个$(LocalData)/Classes表示你的flashMX2004安装路径下面的内建类的路径.还有一个.号,表示当前工作路径.假如读者是一个java爱好者,配置过java的SDK,那对这个应该不会陌生了,这与java的classpath设定完全是一个道理.
6.选择classpath下面的screen.width-430)this.width=screen.width-430 align=center border=0>号, 你就可以增加一个类路径了.选择刚才存放的G:/tutorial,你就成功地添加了一个类路径,不管你的fla文件存在哪儿, 它都能导入到你刚才定义的FirstClass类. 当然,假如你把myFirst2004Program.fla也存在G:/tutorial下面,那就大可不必定义类路径. 因为通过当前工作路径.就可以导入FirstClass类了.
7.在myFirst2004Program.fla文件的第一帧,编写如下代码:

var myInstance:FirstClass=new FirstClass();        //(1)
myInstance.traceMyData();                          //(2)

其中第(1)行, 新建FirstClass类的一个对象,名为myFirstClass.第二行调用myFirstClass的traceMyData成员函数.
8.用Ctrl+Enter,测试一下.output窗口就会出现myData=10.是不是很新奇呢?

AS2.0面向对象编程基础(二) 对象和类(Object & Class)
什么是对象呢? 世界上所有的特定的物体都是对象,包括可见的和不可见的,形象的和抽象的.你楼下的停的那辆自行车是一个对象, 大街上的一个漂亮mm是一个对象, 天上的一朵云是一个对象,我做的一道数学题也是一个对象.每个对象都有自己的属性和方法.自行车有型号,高度等属性, 也有骑动的方法;mm有姓名, 身高, 体重的属性,有走路,挥手, 跳舞,抛媚眼等方法....
那什么是类呢?先来想想这个,街上的人多的是，有一些mm,有一些王子，还有一群恐龙和一堆青蛙．每一个mm、王子、恐龙、青蛙都是一个对象，他们有什么共性呢？ 他们都是人！(有人要提出非议：恐龙和青蛙不是人.AOL:faint.....)。他们属于人类,不管他们长得好看还是难看， 他们都有鼻子有眼，会说话， 最重要的是会制造生产工具(上哲学课?)。类是所有有相同共性的对象的总称,当然对象的数量可以为无限。 人类是所有会制造劳动工具的生物的总称,所以人是一个类， 而每一个具体的人是一个对象。还有一种说法更形象点儿， 类是建立对象的模型，对象是类的实例。 想像一下现在你要用你的双手来做一个人的泥像。最好的方法就是用一个模具， 用一次就可以造出一个人泥像来。每一个泥像等同于一个对象， 而这个模具等同于一个类了.
    下面我们来设计一个Person类.
class Person
{
        //constructor
        public function Person(n:String,a:Number,tel:Number)
        {
                name=n;
                age=a;
                telNum=tel;
        }
       
        //methods
        public function getName():String
        {
                return name;
        }
       
        public function getAge():Number
        {
                return age;
        }
       
        public function getTelNum():Number
        {
                return telNum;
        }
       
        public function saySomeThing():Void
        {
                trace(I am a Person named +name);
                trace(I am +age+ years old);
                trace(My telephone number is +telNum);
                trace(==================================);
        }
       
        //properties
        private var name:String;
        private var age,telNum:Number;
}
在AS2.0声明类的一般形式为:

        class ClassName
        {
          // 类体
        }
在类体定义数据成员(由于其经常表示类的属性, 所以一般称为属性)和成员函数(由于其经常表示类的方法,所以一般称为方法).一般情况下，属性是声明为私有类型，用关键字private来定义。这样的话，只有类的成员才能访问到该属性。有其它面向对象语言如c++,c#,java等开发经验的读者请注意，这里的privte其实相当于这些语言的protected,另外这个private也通过ASSetPropFlag函数来模拟的，有一些bug.这些将在以后的篇章中再详谈.而类的方法，则一般声明为公有类型，用关键字public来定义。该类的所有对象都能使用该方法。

这个Person类有如下属性,分别表示一个人的姓名,年龄,还有联系电话.
       
        private var name:String;
        private var age,telNum:Number;
这个类的方法为:
        public function getName():String
        public function getAge():Number
        public function getTelNum():Number
        public function saySomeThing():Void
创建对象
把上面的类存成Person.as之后，新建一个aolWaterflier.fla文件就可以创建该类的对象了。 创建对象要用到关键字new
方法如下:
var waterfliererson=new Person(waterfiler,19,13576092805);
var aolerson=new Person(AOL,22,13987654321);
其中waterflier和aol是两个变量, 它的类型是Person.
Person类在用new关键字创建一个对象的时候,你可以把这个对象看做是一把勺子,一个变量可以看做是一只手,而你要使得你的变量按照用户希望的方式来随时控制或访问这个对象.你可以握住这个勺子的柄来实现.对象也有一个这样的柄,而且每次建立一个对象的时候会产生不同的柄,这个柄就叫做句柄,它是对象的一个引用.而你把这个引用赋值给变量waterflier,aol.那么这两个变量,就拥有了对两个不同的Person类的对象的引用.那么你就可以使用该对象的属性和方法了.
aol.saySomeThing();
trace(waterflier.getName()+ +waterflier.getAge()+ +waterflier.getTelNum());
构造函数
注意到类体有一开始有一个名为Person的函数。它就是该类的构造函数，它是一个特殊的成员函数。构造函数的作用是在创建该类的对象初始化对象中的字段。构造aol对象的时候,把AOL赋给n,22赋给a,13987654321赋给tel.然后通过n,a,tel初始化name,age,telNum.
注意:在声明构造函数时, 不能有返回值.在AS2.0中，不像其它的面向对象的语言中，构造函数可以重载。假如你定义了两个或者两个以上名为Person的构造函数时，编译就会提示出错。
Note:
1.创建对象的时候,一定要指明对象的数据类型,这里为Person类. 假如你没有定义数据类型的话,private所声明的属性就可以访问. 如:
var waterflier=new Person(waterfiler,19,13576092805);
trace(waterflier.name+ +waterflier.age+ +waterflier.telNum);
这样封装就失去了实际意义了.
2.命名的一些约定:
(1)类名一般为名词(Person)或者形容词加名词(FirstClass),表达要精准.每个词的首个字母要大写.
(2)变量名一般也为名词(name,age)或者形容词加名词,一般第一个词的首个字母小写,接着的首个字母要大写(telNum).
(3)函数名一般为动宾结构,一般第一个词的首个字母小写,接着的首个字母要大写(getName,getAge,getTelNum,saySomeThing).

静态属性和静态方法(Static Property & Static Method)
上一节讲了,创建一个对象就会使该对象初始化一些具体的属性值。Person类举了两个实例， 一个是waterflier，还有一个aol.在创建waterflier对象和aol对象的时候，分别初始化了他们的属性。那么有时候，我的Person类的各个对象有一个所有对象都能访问的属性， 比如说某公司招人,这个公司已经招人的总数totalPersonnels则为这样的一个例子。 当然你可以这样实现：
class Person
{
    //other properties and methods omitted...
public function getTotalPersonnels():Number
{
        return totalPersonnels;
}

public function incrementEmploy()
{
        totalPersonnels++;
}

private var totalPersonnels:Number=0;
}

但是公司每招一个人都得调用所有的Person类的对象中的incrementEmploy()方法， 这样假如对象建了很多， 就会很麻烦。
在AS2.0中引进了静态属性.则可以这样实现：
class Person
{
    //other properties and methods omitted...
public function getTotalPersonnels():Number
{
        return totalPersonnels;
}

public function incrementEmploy()
{
        totalPersonnels++;
}

private static var totalPersonnels:Number=0;
}
静态属性的值由所有实例共享,它是属于类的性性，而不是某个具体的实例的属性.静态属性只能由类来访问.你可以把private改成public试试。在一个fla文件用使用
trace(Person.totalPersonnels);
没有任何错误，但是你建立了一个rei实例的话，用rei的属性来访问就会出错。
var reierson=new Person();
trace(rei.totalPersonnels);
这时编译器就会报错:Static members can only be accessed directly through classes.
但是你可以通过getTotalPersonnels方法来访问静态属性。
trace(rei.getTotalPersonnels()):
下面来看看静态方法,静态方法和静态属性一样是属于类的，而不是属于某个具体对象的。
class Person
{
    //other properties and methods omitted...
public static function getTotalPersonnels():Number
{
        return totalPersonnels;
}

public static  function incrementEmploy()
{
        totalPersonnels++;
}

private static var totalPersonnels:Number=0;
}

这时你就可以用Person类访问这些方法了，而用其实例rei的方法一样会报刚才的错.
trace(Person.getTotalPersonnels());//this is the right access .
有一点要注意，静态方法只能访问静态属性。你把totalPeronnels属性的static去掉，然后再用Person.getTotalPersonels()方法访问，就会报错:
Instance variables can not be accessed in static functions.
这是为什么呢？前面已经说得很清楚了， static所定义的属性是属于类的,而未加static的一般属性是属于具体的实例的.不能用类的方法去访问具体的一个对象的属性.

获取和设置方法(get/set method)
一般的情况下，对象的属性都是设为私有的，它除了对象自身的方法从外部无法访问。那么我们编写代码的时候怎么才能访问到这些属性呢？当然只有通过公有方法来实现了。好的面向对象编辑习惯要求程序员给对象客户提供有效的对私有属性进行操作的公有获取方法和设置方法。这两个方法分别称为get方法和set方法。
下面我们以Person类来说明获取和设置方法。
class Person
{
        //get method
        public function getName():String
        {
                return n;
        }
       
        //set method
        public function setName(newName:String):Void
        {
                n=newName;     
        }   

        //private property
        private var n:String;

        //others omitted...
}
这时你可以新建类的对象，使用它的getName()和setName()方法来获取和设置其私有属性。
var pengerson=new Person();
peng.setName(peng);
trace(peng.getName());
以上是传统的get/set方法，然而传统的方法不是很简洁，获取和设置用了两个函数。其实在AS2.0中有get和set关键字可以实现，获取和设置共用同一个函数名。　把上面的代码写成这样：
class Person
{
        //get method
        public function get name():String
        {
                return n;
        }
       
        //set method
        public function set name(newName:String):Void
        {
                n=newName;     
        }   
        //private property
        private var n:String;
        //others omitted...
}

这样你就可以使用下面的简单方法来实现获取和设置对象的属性了。　
var pengerson=new Person();
peng.name=peng;
trace(peng.name);
而很多时候名字一旦定下来了，是不能改变的，这就是只读属性，不能写。我们可以只使用get方法,而不用set方法来实现。让我们用一个构造函数来重新定义这个Person类吧。

class Person
{
        //consturctor
        public function Person(newName:String)
        {
                n=newName;
        }

        //get method
        public function get name():String
        {
                return n;
        }

        //private property
        private var n:String;

        //others omitted...
}

使用方法：
var pengerson=new Person(peng);
trace(peng.name);

类似的只写属性，那就可以只使用set，而不用get来实现.大家可以自己试试。

动态类(dynamic class)
一般的我们定义的类, 不能在外部定义基于这个类的对象的方法和属性了. 在AS2.0面向对象编程基础(二)里面我们介绍了一个Person类. 我想为这个类加一个属性:性别(sex).
在一个fla文件里, 你试试这样编写:
var leierson=new Person();
lei.sex=male;
测试一下就会报错: There is no property with the name 'sex'.
现在我们可以用dynamic关键字,加在class的前面重新定义那个Person类.
dynamic class Person
{
        //constuctor
        public function Person(n:String,a:Number,tel:Number)
        {
                name=n;
                age=a;
                telNum=tel;
        }
       
        //properties
        private var name:String=;
        private var age,telNum:Number;
       
        //others methods and properties defined external
}
在这个类里面我们只定义了一个构造函数,三个属性:姓名、年龄和电话。新建一个fla文件。我们可以在外部定义获取这些属性的函数，并且有一个介绍自己的函数。而且可以定义他的性别这个属性。下面是代码：
Person.prototype.getName=function():String
{
        return this.name;
}

Person.prototype.getAge=function():Number
{
        return this.age;
}

Person.prototype.getTelNum=function():Number
{
        return this.telNum;
}

Person.prototype.saySomeThing=function():Void
{
        trace(I am a Person named +this.getName());
        trace(I am +this.getAge()+ years old);
        trace(My telephone number is +this.getTelNum());
        trace(==================================);
}
var leierson=new Person(lei,20,1381234567);
lei.saySomeThing();
lei.sex=male;
trace(And I am a  +lei.sex);
注意上面有一个this关键字， 它表示对对象自身的引用,lei对象的this就是指自身， 自身的姓名属性就可以用this.name表示。
在output窗口不但不会报错， 而且还会输出：
I am a Person named lei
I am 20 years old
My telephone number is 1381234567
==================================
And I am a  male
实际上我们最熟悉不过的MovieClip类就是一个动态类， 我们可以随时给MovieClip类定义的对象添加属性，给MovieClip添加方法供具体的对象使用。你可以定义一个MoiveClip.prototype.drawTriangle()方法，那么每个MovieClip对象都可以使用这个方法来画三角形了。
MovieClip.prototype.drawTriangle=function():Void
{
        beginFill (0x0000FF, 50);
    lineStyle (5, 0xFF00FF, 100);
    moveTo (200, 200);
    lineTo (300, 300);
    lineTo (100, 300);
    lineTo (200, 200);
    endFill();
}
_root.createEmptyMovieClip(myMovieClip,1);
myMovieClip.drawTriangle();

这时你可就可以看到一个三角形了.
screen.width-430)this.width=screen.width-430 align=center border=0>

AS2.0面向对象编程基础(六) 继承(一)(inherit)
在说这个之前， 我要郑重地向大家说：It is important!没有继承的语言根本不能称之为一种面向对象的语言， 继承是面象对象最重要的特性。我们把Person类简写成只有一个方法和一个属性的类如下：
/////////////////  Person.as  ///////////////
class Person
{
        //constructor
        public function Person(n:String)
        {
                newName=n;
        }
       
        //method
        public function get name()
        {
                return newName;
        }
       
        //property
        private var newName:String;
}
我们已经定义了一个类型，这时我们有需要定义另一些比较特殊的类型。比如说程序员就是一种特殊的能写程序的人类，而美工就是一种特殊的能做设计的人类。(不好意思，我常年蹲工作室，接触最多的人就是这两种)。程序员有善长的编程语言的特殊属性，写代码的特殊方法；美工有善长的设计软件的特殊属性，设计的特殊方法，这些都是Person类所没有的。我们可以重新定义这两个类，像下下面这样：
//////////////////  CodeMan.as  ///////////////////
class CodeMan
{
        //constructor
        public function CodeMan(n:String,l:String)
        {
                newName=n;
                skilledLanuage=l;
        }
       
        //methods
        public function get name()
    {
            return newName;
    }
        public function writeCode():Void
        {
                trace(I am using  +skilledLanuage+ lanuage to write codes);
        }
       
        //properties
        private var newName:String;
        private var skilledLanuage:String;
}
/////////////////////  Designer.as  ////////////////////
class Designer
{
        //rewrite constructor
        public function Designer(n:String,s:String)
        {
                newName=n;
                skilledSoftWare=s;
        }
       
        //methods
        public function get name()
    {
          return newName;
    }

        public function Design():Void
        {
                trace(I am using  +skilledSoftWare+ to design a web.);
        }

学习oop的话建议学下as3.0
如果说AS2.0只是外表接近OOP标准语言，内在还是乱糟糟的AS1.0脚本语言，那么AS3.0不论是从OOP设计级别，还是从编译器级别（如，对弱引用—— week reference—— 的支持）来评估的都是标准、正宗、强大的语言。

对这个编码一直都晕着，怎么也学不会