Flash理论课复习具体内容

02.jpg

题型

1. 单选 20*2=40
2. 程序填空题 4*10=40
3. 编程题 10
4. 简述题 10

书本章节

一、第一章

1.关于flash的基本操作 常用快捷键 shift+椭圆工具 ctrl+enter f5 f6 f7 f9 ctrl+d

shift+拉伸    椭圆变正圆
ctrl+enter  运行flash
f5      普通帧
f6      关键帧
f7      空白关键帧
f9      代码窗口
ctrl+d      复制对象

2.工具栏的使用 形变动画 分离 补间 3种帧 普通帧 空白关键帧 关键帧

a.空白帧：表示当前时间轴面板上的某一个图层没有帧。
b.传统补间：该状态表示在两个关键帧之间成功创建了“传统补间动画”
c.形状补间：浅绿色底纹表明创建的补间为“补间形状”。
d.普通帧：以关键帧开始，以矩形显示的普通帧结束，表明在这两个帧之间持续显示第一个关键帧的内容。
e.添加语句：为了控制动画播放，会在帧上添加脚本语句。添加了脚本语句的帧上会显示“a”标签。
f.注释：选择一个帧，在属性面板的“注释”一项输入文字，即为该帧添加了注释。
g.补间动画：在Flash中，为元件创建补间后，帧的显示为此状态。
h.波形帧：此帧用于表示声音文件。

关于帧

(1)普通帧(F5)：

普通帧在时间轴中用空心矩形表示。普通帧的主要作用是重复显示前一帧的内容而不做改变。

(2)关键帧(F6) ：

关键帧在时间轴上用实心圆点表示。关键帧定义了动画中的关键画面 ，关键帧除了具备重复显示前一帧内容的作用之外，还允许用户对关键帧中的内容进行修改。

(3)空白关键帧(F7) ：

空白关键帧在时间轴上用空心的圆点表示。空白关键帧具备有关键帧的属性，但空白关键帧不会重复显示前一帧的内容，而是在空白关键帧所处的当前帧起不再显示前面帧的内容，将舞台清空，便于用户制作后续的画面内容，用户一旦在空白关键帧中添加了内容，空白关键帧将会自动转变为关键帧。

3.元件的3种 多个帧 1个帧 4个帧热区！

元件分为三种类型：影片剪辑元件、按钮元件和图形元件

1）影片剪辑元件

影片剪辑元件用于创建一类可以被用户重复使用的动画片段。影片剪辑元件有独立的时间轴面板，用户可以直接在影片剪辑元件编辑中制作动画片段，其制作方法与场景中动画的制作方法相同。影片剪辑元件虽然是一个动画片段，制作过程中需要使用**多个帧**来完成，但将影片剪辑元件应用于其他对象时，只占用一个帧的位置，但播放时却同样具有动态效果。

影片剪辑元件中可以使用声音、视频、图形和文字等等各种媒体素材。

2）按钮元件

按钮元件是用户与动画的接口，用户通过按钮元件及动作脚本语句可以轻松实现人机交互的效果。新建一个按钮元件后进入到按钮元件的编辑窗口，按钮元件有四个帧

**弹起：**是按钮的普通显示状态。即用户鼠标还未触发按钮时的显示状态。
**指针经过：**该帧中的内容由用户的鼠标移动经过按钮时触发。
**按下：**用户单击鼠标时按钮的显示状态。
**点击：**该帧定义响应鼠标单击的区域。

按钮元件中经常使用到的媒体素材有声音文件和图形文件等各种类型。

（3）图形元件

一般为矢量图形、位图和文字等对象。**一个帧**

图形元件的编辑窗口与场景的编辑窗口相同。用户如果将交互控制和声音素材放于图形元件中，但却无原有的动态效果。

4.导入外部图片素材 主要图片格式 jpg bmp gif png 导入舞台 哪个是动态图？会变成逐帧动画？

只有gif是逐帧动画 其他都是静态

5.帧频FPS 每秒播放的帧数 图层，常见的图层类型 普通图层 遮罩图层、引导图层——至少不止一层

**遮罩动画至少有2个层 遮罩层和被遮罩层**

帧频 = frequent per second

6.绘制矢量图的方法

矩形、椭圆形工具、钢笔工具

7.元件 重点掌握 元件的优势

1.一次制作、反复使用
2.无论元件加多少个都不会增加文件的容量
3.在as3.0用代码直接当类生成导出，方便创建对象

8.实例和元件的关系 类、对象、属性

实例能直接使用-实例名.属性，进行操作 如：myText.text = "hello";
元件要通过类引用新建为对象，再对对象的属性操作，如： var myTitle:Text = new Text();myTitle.text = "yooooooo";

9.动画的导出 可以导出swf 嵌入网页 导出很多不同类别的文件 测试导出时的3类文件.fla .swf .as这3类文件

导出文件，格式相关的东西需要谨记

10.as3代码的位置 时间轴上、时间轴的帧上、专门的脚本文件

如果是在时间轴上面用F9插入了代码 那个帧上面就会有a符号
如果是在外部链接了as文件，则舞台上会直接关联一个as脚本

//在屏幕上打印出一段文字的代码
package {
    //导入所需的类
    import flash.display.Sprite;
    import flash.text.*;
    //定义类
    public class Main extends Sprite {
        //声明一个文本变量
        public var myText:TextField = new TextField();
        //创建一个与类名称一致的方法
        public function Main() {
            //定义文本内容
            myText.autoSize = TextFieldAutoSize.LEFT;
            myText.text = "HELLO MY FLASH";
            //定义文本的样式
            var myFormat:TextFormat = new TextFormat();
            myFormat.size = 50;
            myFormat.font = "Cooper Black";
            myFormat.color = 0x005588;
            //定义文本位置
            myText.x=50
            myText.y=150
            //应用定义的样式
            myText.setTextFormat(myFormat);
            //在舞台上创建显示对象
            addChild(myText);
        }
    }
}

二、第二章(重点)

1.变量定义的方法
2.变量的命名规则

关于变量

变量指的是在程序中可以发生变化的量，实际上，变量是内存中存储数据的容器，用来存储在程序中需要使用的值。
在 ActionScript 3.0中，变量在使用时需要先定义

变量的三大要素：名称、类型、值

变量的定义

格式： var  变量名：数据类型名；

var：定义变量的关键字

变量名：用户命名的一串有效的标识，规则如下：

1.必须以字母开头，且只能由字母、数字和下划线“_”组成，一般采用 “骆驼命名法”命名形式：首字母小写，组成变量名的其他单词的首字母大写，单词其他字母小写。如myText （严格区分大小）；
2.变量名不易太长，尽量做到以最小长度传达最大信息量的目的。如：userName和myAge等
3.变量名要做到唯一使用；
4.不能使用ActionScript3.0中的关键字作为变量的名称

数据类型名：不同数据类型有特定的类型名， var i: int;

1.在对变量进行声明时，还可以使用赋值运算符“＝”直接为变量赋值。如：
　　　　　　var n:Number;
　　　　　　n=3;
或
　　　　　　var n:Number=3;　　　

2.如果要同时声明多个变量 ， 可以使用逗号运算符（,）来对变量进行分隔，此时可以在同一行代码中为每个变量赋值。如：
       var a:int=5, b:Boolean=true, c:String=”My Word”;　　　

3.在创建数组时，往往需要在声明数组的同时为数组赋值。此时可以使用下面的方法：
var myArray:Array=[”button”,”photo”];
var myArray:Array=new Array(元素1,元素2,……)
var myArray:Array=new Array();
        myArray[0]=1;
        myArray[1]=2;
        ………….

4.在创建类的实例时，需要在变量声明的同时为变量赋值。此时可以使用new运算符来创建类的实例
如：下面的语句创建一个影片剪辑实例：

    var myMC:MovieClip =new MovieClip();

变量的作用域：变量使用的范围，是指代码在运行变量时可以被引用的区域；
分为“全局”和“局部”两种；

1.全局变量是在任何函数或类定义的外部定义的变量，其在函数定义或类定义的外部和内部均可以使用。
2.局部变量是在函数中定义声明的变量，这种在函数块中定义的局部变量只能在函数内部使用，在函数外部不可用。

//示例代码 全局变量与局部变量
>
var myText:String="全局变量";
function myTest() {
    trace(myText);
}
myTest();
trace(myText);
>
function myTest() {
    var myText:String="局部变量";
    trace(myText);
}
myTest();

常量

常量指的是在程序中固定不变的量。
常量可以看作是一种使用const关键字来进行声明的特殊变量，其只能在声明的同时进行赋值，一经赋值其值就不能改变。

当在程序中试图对常量的值进行改变时，编译器就会报错。在编写程序时，如果能够确定一个变量的值不会发生改变，就可以将其定义为常量，以便编译器来对其进行监督。

常量使用const关键字来声明：

public stactic const PI:Number=3.1415927;

Flash Player API定义了一组常量供程序员使用，
这些常量全部使用大写字母，各个单词之间以下划线“_”来连接 。

//常量的示意代码
package flash.events
{
    public class MouseEvent extends Events
    {
        public static const MOUSE_MOVE:String=”mouseMove”;
    }
}

3.数据类型的转换 int sting boolean=true\false

数据类型就是表明一个变量可存储信息的种类。分为：

1.基元型数据类型是值类型数据；
2.基元型数据主要指布尔型、字符串型、整型和数值型等。
3.复杂型数据类型是引用类型数据；
4.复杂型数据包括对象型、数组型、日期型、错误对象、可扩充的标记语言对象等类型。

基元型数据类型比复杂型数据类型处理速度要快一些

1．数值型（Number）数据：用于存储和表示数字，数值型数据是一种双精度浮点数，包括整数、无符号整数和浮点数。数值型数据使用64位双精度格式来存储数据。默认值为NaN。
2．整型（int）数据：一组介于-2147483648和2147483647之间的整数。可以使用数字运算符进行数值处理。整型数据的变量默认值为0。
3．字符串型（String）数据：存储字符对象，字符包括字母、数字和标点符号等。在语句书写过程中，字符串需要使用双引号搭配使用，将字符书写在双引号之内。使用“+”可以将多个字符串进行连接和合并。字符串型数据的变量默认值为null。
4．无符号整型（uint）数据：取值范围为0-4294967295，是一个32位无符号整数。无符号数据类型的变量默认值为0。
5．布尔型（Boolean）数据：只有两个值，即“真（true）”和“假(false)”。布尔类型的变量默认值为 false。
6．Null(空值)和void(未定义)数据类型：
Null数据类型只包含一个值Null，表示空，即没有值
void数据类型只包含一个值undefined，表示一个变量没有定义，该值只能赋予无类型变量（即缺乏类型注释或使用*作为注释的变量）。
7．Object数据类型：是ActionScript中所有类定义的基类。其实例的默认值是null。
8．*（无类型）：无类型变量只有一个值undefined。无类型数据用于用户无法确定变量类型时，便可以使用*来表示当前定义的变量的类型未知。

数据类型的转换

1.隐式转换（自动转换）

由flash player在运行时通过调用内部转换算法自动转换

var a:String = "4";
var b:Number = 5;
trace(a+b+5);
//结果：455
//将变量b和5自动转换为String类型

2.显式转换（强制转换）

通过编写代码指示编译器将一种数据类型转换为另一种类型

var a:String = "4";
var b:Number = 5;
trace(a*b);
//结果：出错！
//改为：trace(int(a)*b);
//结果：20
//将变量a强制转换为int类型

4.运算符 is\as

数据类型检查符用于对数据类型进行检测，其包括is运算符、as运算符、typeof运算符和in运算符。

is---测试变量或表达式是否为给定的数据类型,返回true或false

var mySprite:Sprite=new Sprite();
trace(mySprite is Sprite);-----------true
trace(mySprite is MovieClip);-------false

as---测试变量或表达式是否为给定的数据类型,返回表达式的值

var mySprite:Sprite=new Sprite();
trace(mySprite as Sprite);-----------[Object Sprite]
trace(mySprite as MovieClip);-------null

typeof---测试变量或表达式值的类型，返回数据类型名

var a:Number;
trace(typeof(a)); -----------number

in---判断属性是否为特定对象的一部分

trace("PI" in Math);-----------true

5.程序结构 选择结构 if else if \switch case 循环结构 for in \foreach in 的区别

示例代码

//if选择结构
if(condition1){
    statements1;
}
else if (conditiont2){
    statements2;
}
else if (conditiont3){
    statements3;
}
else {
    statements n;
}

//switch选择结构
switch(expression){
    case Clause1:
        statements1;break;
    case Clause2:
        statements2;break;
           default:
        statements;
}

//while循环结构
while (condition){
    statements;
}

//do while循环结构
do{
    statements;
}while(condition)

//for循环结构
for ([init];[condition];[next]){
    statements;
}

//for in 循环结构
for (variableIterant:String in object){
    statements;
}

//for each in 循环结构
for each(variableIterant in object){
    statements;
}

for in和for each in的区别

for each…in循环用于循环访问集合中的项目，这个集合可以是XML或XMLList对象中的便签、对象的属性值或数组中的元素。
与
**for…in **语句不同，该语句的迭代变量包含属性所包含的值，而不是属性的名称。

var jh:XML=<jhj>;
<mz> 广东 </mz>;
<mz> 医药 </mz>;
<mz> 大学 </mz>;
</jhj>;
>
for each(var i:String in jh.mz){
    trace(i);
}
>
for(var j:String in jh.mz){
    trace(jh.mz[j]);
}
>
输出：
广东
医药
大学
广东
医药
大学
>

6.函数 function my_fun()

ActionScript 3.0中有两类函数：方法和函数闭包

方法：如果将函数定义为类定义的一部分或将函数附加到对象的实例，则该函数就称为方法

函数闭包:以其他的任何方式定义函数，则该函数称为函数闭包。在对象或类之外的位置执行函数，都会创建函数闭包

(1)函数语句
function 函数名(参数1:类型,参数2:类型…) {…………. }
例如：

function hs(cs:Number){
    trace(cs*10);
}
>
hs("hello world");

(2) 函数表达式
var 变量名:Function=function(参数1:类型,参数2:类型…) { …………. };
例如：

var hs:Function=function(shuju:String){
    trace(shuju);
};
>
hs("hello world");

值传递和引用传递的区别

>
//1.按值来传递参数
functin cs(a:int,b:int):void{
    a*=5;
    b*=6;
    trace(a,b);
}
var m:int=5,n:int=6;
cs(m,n);
trace(m,n);
>
//m,n的值没改变
>
>
>
//2.按引用传递参数
function cs(myObj:Object):void{
    myObj.a*=5;
    myObj.b*=6;
    trace(myObj.a, myObj.b);
}
var objA:Object={a:5,b:6};
cs(objA);
trace(objA.a, objA.b);
>
//对象objA的a、b属性值变为25和36
>
>
>
//3. 参数…（rest）
//参数…（rest）可以用来指定一个数组参数，以接受任意个逗号分隔的参数，参数声明必须是最后一个指定的参数
var m:int = 0;
function cs(n:int,...abc)
{
    for (var i:uint=0; i<abc.length; i++) {
        m +=  abc[i];
    }
    trace(m);
}
cs(5,6,7,8,9);
>
//结果为n=5,abc[0]=6,abc[1]=7,abc[2]=8,abc[3]=9
//所以 6+7+8+9 =30
>
//4. 对象argumens
//对象argumens是一个数组，包含传递给函数的所有参数。在程序中，可以使用对象argumens来访问有关传递给函数的参数信息。
var m:int = 0;
function cs(a:int,b:int,c:int){
    for (var i:uint=0; i< arguments.length; i++) {
        m +=  arguments[i];
    }
    trace(m);
}
cs(5,6,7);
>
//结果：18（5、6、7的和）
>

函数的嵌套和递归

function qiantao():String{
    function qiantaoA():String{
        return "这是";
    }
    function qiantaoB():String{
        return "函数的嵌套";
    }
    return qiantaoA()+ qiantaoB();
}
trace(qiantao());

函数的递归调用

function digui(x){
    if(x==0||x==1){
        return 1;
    }
    else{
        return x+digui(x-1);
    }
}
trace(digui(10));

三、第三章(重点)

1.鼠标事件 on over...
2.键盘事件 KEY_UP KEY_DOWN keyCode charCode KeyboardEvent
3.帧频事件 ENTET_FRAME
4.计时器事件 Timer(间隔时间毫秒,循环次数) start() complete
5.事件处理函数 addEventListerner()
6.事件处理一般过程

| 事件 | 事件描述 |
| --- |: ----:|
| MouseEvent.CLICK | 用户在交互对象上按下并释放鼠标主按键时发生 |
| MouseEvent.DOUBLE_CLICK | 用户在交互对象上快速连续按下并释放鼠标主按键两次时发生 |
| MouseEvent.MOUSE_DOWN | 用户在交互对象上按下鼠标主按键时发生 |
| MouseEvent.MOUSE_UP | 用户在交互对象上释放鼠标主按键时发生 |
| MouseEvent.MOUSE_OVER | 用户将鼠标光标移到交互对象上时发生 |
| MouseEvent.MOUSE_OUT | 用户将鼠标光标移出交互对象时发生 |
| MouseEvent.MOUSE_MOVE | 用户在交互对象上移动光标时发生 |
| MouseEvent.MOUSE_WHEEL | 用户在交互对象上转动鼠标滚轮时发生 |
| KeyboardEvent.KEY_DOWN | 用户按下某个键时发生 |
| KeyboardEvent.KEY_UP | 用户释放某个键时发生 |
| ContexMenuEvent.MENU_ITEM_SELECT | 用户在交互对象相关联的上下文菜单选择时发生 |
| Event.ENTER_FRAME | 以帧频触发 |
| TimerEvent.TIMER | Timer对象在每次达到指定时间间隔时发生 |
| TimerEvent.TIMER_COMPLETE | 将Timer实例设置为固定的间隔数，在达到最后依次间隔时触发 |

Flash的事件处理过程

//定义侦听器函数
function  eventResponse(eventObject:EventType):void {
                函数处理的代码
}
//在事件目标上添加某种事件的侦听器
eventTarget.addEventListener(EventType.EVENT_NAME, eventResponse);

使用startDrag()

startDrag()方法可以让用户拖动指定的对象，该对象将一直保持跟随鼠标的可拖动状态，直到使用stopDrag()方法停止拖动或有另外一个对象可拖动为止

使用方法：
对象.startDrag(lockCenter:Boolean,bounds:Rectangle)
lockCenter:Boolean—指定可拖动对象是否锁定在鼠标位置中央，为true时，对象将锁定在鼠标位置中央，否则，对象将锁定在首次单击该对象的位置上

>
Mouse.hide();                           //隐藏鼠标指针
var myCursor:myCur=new myCur();     // 创建myCur类的实例
>
//代码中的stage可以用this代替，代表当前舞台
stage.addChild(myCursor);           //放置自定义鼠标指针实例
stage.addEventListener(MouseEvent.MOUSE_MOVE,moveMycur);//创建事件侦听器
>
function moveMycur(e:MouseEvent):void {
    //使用startDrag()方法拖动指针实例
    myCursor.startDrag(true);
}

使用mouseMove

Mouse.hide();
stage.addEventListener("mouseMove",moveCur);
function moveCur(m:MouseEvent ) {
    vLine.x = mouseX;    //垂直放置的线与鼠标x坐标重合
    hLine.y = mouseY;   //水平放置的线与鼠标y坐标重合
    scope.x = mouseX;    //瞄准器的坐标与鼠标重合
    scope.y = mouseY;
    m.updateAfterEvent();  //不是必需
}
//常量“mouseMove”相当于MouseEvent.MOUSE_MOVE
//updateAfterEvent()用于强制更新显示画面(不必等到下一帧)

元件有4种状态，由4个用来描述响应与鼠标交互的关键帧表示

**Up(弹起)：**光标不在按钮上时按钮的状态
**Over(指针经过)：**光标在按钮上时按钮的状态
**Down(按下)：**光标在按钮上鼠标按键按下时按钮的显示状态
**Hit(点击):**按钮的热区(制作透明按钮，其形状决定了按钮的相应区域)。

与按钮交互行为有关的几个属性：

**mouseEnable：**是否能捕获鼠标事件
**useHandCursor：**手形指针是否显示
**tabEnable：**按Tab键是否可以使按钮依次获得焦点

按钮的4个状态:弹起、指针经过、按下、点击

Paste_Image.png

hitTestState的用法

//1.新建一个名为“响应区域”的影片剪辑元件，在该元件的“元件属性”对话框中单击“高级”按钮，勾选“为ActionScript导出”复选框，在“类”文本框中输入类名“hit_Area”
>
//2.在“正方体1”影片剪辑的时间轴面板中创建一个名称为“动作”的新图层，在其第1帧输入以下代码：
>
stop();
var hit_A:hit_Area=new hit_Area();   //创建hit_Area类的实例
hit_btn.**hitTestState** = hit_A;  //设置按钮实例hit_btn的“点击”帧
hit_btn.addEventListener(MouseEvent.MOUSE_OVER,playMC);  //添加事件侦听器
function playMC(myEvent:MouseEvent){
    play();
}

KeyboardEvent类

在 ActionScript 3.0 中，任何对象都可以通过侦听器的设置来键控加诸于对象的键盘动作，而与键盘相关的动作事件均归属于KeyboardEvent类

键盘事件有两种类型：KeyboardEvent.KEY_DOWN事件和KeyboardEvent.KEY_UP事件

在编写程序时， 通过获取KeyboardEvent类对象的keyCode属性和charCode属性值，可以判断按下的按键是哪个，以便触发对应的动作

keyCode ：按键码，为数值，对应键盘上的按键。
charCode：字符码，该键在当前字符集中的数值。（默认字符集是 UTF-8，它支持 ASCII。）

keyCode值与字符值之间的主要区别：
1.按键码表示键盘上的一个按键（如主键盘区中的数字8和*是同一个按键，具有相同的按键码；而主键盘区中的数字8与小键盘上的 8不是同一个键，因此它们的按键码不同）
2.字符码代表计算机可读取和呈现的特定字符（R 与 r 的字符字符码是不同的）

stage.addEventListener(KeyboardEvent.KEY_DOWN,getCode);
function getCode(me:KeyboardEvent){
    char_txt.text=String(me.charCode);
        key_txt.text=String(me.keyCode);
    in_txt.text=String.fromCharCode(me.charCode);
}

注意：fromCharCode()方法传回参数中Unicode字符码代表的字符所组成的字符串

stage.addEventListener(KeyboardEvent.KEY_DOWN,showKey);
function showKey(me:KeyboardEvent){
    switch (me.keyCode){
        case Keyboard.UP :
            key_txt.text="UP键";
            break;
        case Keyboard.DOWN :
            key_txt.text="DOWN键";
            break;
        case Keyboard.LEFT :
            key_txt.text="LEFT键";
            break;
        case Keyboard.RIGHT :
            key_txt.text="RIGHT键";
            break;
    }
}

ActionScript 3.0中，Timer类在每次达到指定的时间间隔时都会触发计时器事件；
首先用Timer方法创建Timer类的实例，设定产生计时器事件的时间间隔以及在停止前生成事件的次数

Timer类常用的属性：

currentCount:int--计时器从0开始后触发的总次数
delay:Number--计时器事件间的延迟时间，单位毫秒
repeatCount:int--计时器运行总次数，为0则为无限次
running:Boolean--计时器当前状态，正在运行为true

Timer对象在每次达到指定的事件间隔时都会调度TimerEvent对象，该对象的事件类型是timer，用常量TimerEvent.TIMER来定义

当到达最后一次事件间隔时，会触发timerComplete事件，该事件由TimerEvent.TIMER_COMPLETE常量定义

digital.gotoAndStop(11)
charc.stop()

//定义计时器，时间间隔为1000毫秒，重复10次
var delay:uint=1000
var repeat:uint=10
var myTimer:Timer=new Timer (delay,repeat)

//为【START】按钮添加事件侦听器和事件响应函数
btn_S.addEventListener(MouseEvent.CLICK,start_T)

//点击事件侦听器
function start_T(m:MouseEvent ):void{
    myTimer.reset();            //计时器复位
    myTimer.start();                      //开始计时
    charc.gotoAndStop(1);             //“角色”影片剪辑播放头移到开头
    digital.gotoAndStop(11);    //倒计时数字影片剪辑的播放头回到初始位置
}

//定义事件侦听器
myTimer.addEventListener(TimerEvent.TIMER,play_Digital);

//创建事件响应函数，每间隔1秒更改显示数字
function play_Digital(e:TimerEvent ):void{
    digital.gotoAndStop(repeat);
    repeat--;
}

//添加TIME_COMPLETE事件侦听器
myTimer.addEventListener (TimerEvent.TIMER_COMPLETE ,c_Down)
function c_Down(e:TimerEvent ):void{
    charc.play();
    repeat=10;
}

四、第四章

1.对象的添加\移除 addChild removeChild
2.改变对象的外观 width height scaleX scaleY alpha color:RGB
3.对时间轴和舞台的控制 gotoAndPlay gotoAndStop prerFrame nextFrame

具体方法

addChild()方法:可以将一个子实例添加到显示对象容器中；

addChild()的使用方法：
DisplayObjectContainer.addChild(child:DisplayObject)

child:DisplayObject是作为DisplayObjectContainer实例的子对象添加到DisplayObject的实例，子对象被添加到该DisplayObjectContainer实例中的其他所有子对象的上面。
如果添加一个已将其他显示对象容器作为父对象的子对象，则会从其他显示对象容器的子列表中删除该子对象。

addChildAt()方法:将子实例添加到对象容器中，可以指定显示对象添加到容器中的层级；

addChildAt()方法的使用方法：
DisplayObjectContainer.addChildAt(child:DisplayObject,index:int);

 index:int—添加该子对象的索引位置，其值为0代表将显示对象添加到显示列表的最底层（可能被其上层的遮盖）；
 index值大的实例位于上层

addChild()方法是按照对象加入的先后顺序来确定对象在显示列表中的层级位置，先加入的位于下层，后加入的位于上层；

使用addChildAt()方法将一个对象添加到某个已经有对象的索引位置，则该位置及其更高位置上的子对象都将上移一层

清除屏幕上的显示对象用到以下两种方法：

removeChild()方法：必须使用一个要移除的显示对象的引用参数

DisplayObjectContainer.removeChild(child:DisplayObject);
其中child:DisplayObject是要删除的对象名称

removeChildAt()方法：删除显示列表中指定索引位置上的对象

DisplayObjectContainer.removeChildAt(index:int);
其中index:int为需要删除的显示对象的索引号

在ActionScript 3.0中，显示对象容器中的每个子对象列表都在内部缓存为一个数组;
numChildren属性:显示对象容器的这个属性表明容器中的子对象的个数。
在显示对象容器的内部保留的显示对象列表的顺序决定了对象在屏幕上的显示的属性。索引值为0的对象位于列表的最底层，索引值为1的对象位于其上层，依次类推。这些位置编号间是没有空缺的。

setChildIndex()方法：更改显示对象列表中对象的索引号

DisplayObjectContainer.setChildIndex(child:DisplayObject,index:int)

其中child:DisplayObject为要更改索引号的对象实例，index:int为目标索引号

MovieClip对象常用的方法

play()、gotoAndPlay(scene,frame)
stop()、 gotoAndStop(scene,frame)
prevFrame()、nextFrame()

MovieClip对象常用的属性

 currentFrame
 totalFrames
 currentLabel
 currentScene

五、第五章

1.移动 x\y

temp.x +=5;
temp.y +=5;

六、第六章(重点)

1.基本碰撞检查 hitTestObejct hitTestPoint
2.多个对象的碰撞检测 2层循环 陨石那题
3.特殊碰撞的检测
4.什么是碰撞检测？碰撞检测在游戏当做有什么作用？各自的优势是什么？哪些情况下需要使用哪种碰撞检测

1、碰撞检测的概念和方法

游戏中的碰撞检测，简单地说，就是判断两个显示实例是否有在同一时刻，某个部分处在了同一位置上。
碰撞检测就是判断有可能发生碰撞的显示实例，在某一时刻是否有重叠的情况发生。

Flash游戏中物体之间的碰撞检测技术主要有两大类：

• 1.基于包围盒的碰撞检测技术--hitTestObject方法；
• 2.基于像素的碰撞检测技术--hitTestPoint方法

Flash中的DisplayObject类内置的两种碰撞检测方法:

• 1.hitTestObject方法用于判断两个显示对象间是否发生了碰撞，是基于包围盒的碰撞检测技术；
• 2.hitTestPoint方法用于判断某个点与显示对象间是否发生了碰撞，是基于像素的碰撞检测技术。

判断movieclip1与movieclip2碰撞处理的代码如下：

    if(movieclip1.hitTestObject(movieclip2))
    {
        //碰撞后的动作
    }

如果两个影片发生了碰撞则返回true，并执行if语句块的内容。这种碰撞检测方法简单，但其精确度较差。原因如下图所示：从表面上看，很明显应该只有两个正方形碰到了

Paste_Image.png

Paste_Image.png

hitTestPoint方法中有两个Number类型的参数，表示x,y坐标，用于定位点。根据显示实例是否与某点相交，返回true或false。

最基本的形式如下：

objectA.hitTestPoint(x,y,shapeflag);
shapeflag:为true时，将在检测碰撞时判断对象中的可见图形而非仅凭矩形边界来判断
可以在if语句中使用它来判断碰撞为true时要执行的代码，Flash只检查给出的点是否在影片剪辑的矩形边界内。

例如，判断对象sprite是否与点（100,100）发生了碰撞：

    if(sprite.hitTestPoint(100,100)){
        //碰撞后的动作
    }

利用距离来检测碰撞

根据需要设定两个对象之间允许的最小距离，当对象间的距离小于这个距离时，就可以确定这2个对象是发生了碰撞了

计算屏幕上的对象objectA和objectB之间的距离：
>
var dx:Number=objectA.x-objectB.x
var dy:Number=objectA.y-objectB.y
var distance:Number=Math.sqrt(dx*dx+dy*dy)

当屏幕上存在着多个对象时，需要判断它们彼此之间是否发生碰撞；
使用循环的嵌套，实现多个运动对象的碰撞检测

//注意:
//外层循环是i= 0 ;i <numObjects-1;i++
//内层循环是j=i+1;j<numObjects;j++
>
for (var i:uint = 0; i < numObjects - 1; i++){
    var objectA = objects[i];   //从数组中获取实例
    for (var j:uint = i + 1; j < numObjects; j++){
        var objectB = objects[j];     //同上
        if (objectA.hitTestObject(objectB)){
            statements;
          }
    }
}

九、第九章

1.关于音乐的加载 嵌入 Sound() UrlRequest() .play() .stop() .load() SoundChannel() SoundTramsform

创建一个新的Sound，并让其自动加载该声音文件：

var req:URLRequest = new URLRequest("click.mp3");
var s:Sound = new Sound(req);

上面两条语句可以合为以下：

var s:Sound = new Sound(new URLRequest("click.mp3"));
//注意：加载的声音文件要与源文件放在同一目录中

s.load(req);
var channel = s.play(0,int.MAX_VALUE);  //play(startTime:Number=0,loops:int=0)
s.close();

var changeForm = new SoundTramsform()
channel.soundTransform = changeForm;
channel.positon
>
changeForm.volume = 0.5

st=>start: URLRequest类 加载
e=>end:SoundTransform类 控制
op1=>operation: Sound类(URLRequest类)
op2=>operation: SoundChannel = Sound类.play()方法
op3=>operation: SoundTransform类 = SoundChannel类.soundTransform属性
st->op1->op2->op3->e

实验题

实验1：基本没
实验2: 2 (1) (4) 3(1) (3) (4)
实验3：(一)2 (二) 1 2
实验4：(一)2 (二)
实验5：1 3

参考代码

package  {
  import flash.display.MovieClip;

  public class shiyan2 extends MovieClip {

      public function shiyan2() {
          // constructor code
          trace("第一题");


          trace("答案1");
          var a:String = "12.3";
          var b:int = 4;
          trace(a+b);
          //加法int转为了字符串 答案是12.34


          trace("答案2");
          var a:String = "12.3";
          trace("编译无法通过");
          //var b:int =a;
          //trace(a+b);
          //string无法赋值给int类型


          trace("答案3");
          var a:String = "12.3";
          var b:int =int(a);
          trace(a+b);
          //int(a)=12 字符串a+b=12.312


          trace("答案4");
          var a:String = "12.3";
          var b:int =int(a);
          trace(b+10);
          //int(a)=12 a+b=22


          trace("常量的声明和使用");
          const SECONDS:uint=60;
          trace("One minute = ", SECONDS,"seconds.");
          //SECONDS =61;
          //trace("One minute = ", SECONDS,"seconds.");
          trace("编译无法通过");
          //常量const被定义无法修改


          trace("关系运算符及关系表达式的求值");
          var a1:Number = 100.1;
          var b1:Number = 100;
          trace("a>b is ",a1>b1);
          trace("ABC > abc is", "ABC">"abc");
          //变量值的比较和字符串值的比较不一样


          trace("函数及其调用");
          function stuInfo(stu:Object):void{
              stu.name = "bb";
              trace(stu.name);
          }
          var myObj:Object = {name:"aa",age:18,dclass:"dm11"};
          stuInfo(myObj);
          trace(myObj.name);
          //函数内部作用域，执行stuInfo(myObj)时把myObj传入了整个对象进去，并把其中的.name修改成了"bb",则先输出bb。之后trace(myObj.name)输出的是被修改之后的bb


          trace("程序的功能是求10个数中的最大值（顺序、选择、循环结构，简单算法");
          var a2:Array = new Array(10);
          var temp:uint = 0;
          a2 = [12,32,56,48,15,35,78,19,65,68];
          for (var i:uint=0; i<a2.length-1; i++) {
              if (a2[i] > a2[i + 1]) {
                  temp = a2[i];
                  a2[i] = a2[i + 1];
                  a2[i + 1] = temp;
              }
          }
          trace("最大的元素值=",a2[a2.length-1]);
          //冒泡排序法 最大数换到最后一位


          trace("程序的功能是用选择排序法将10个整数降序排序")
          var myArr:Array = new Array();
          myArr = [12,56,32,9,15,23,87,123,26,5,36,19];
          var k:int,temp2:int;
          trace("排序前",myArr);
          for (var j:uint=0;   j<myArr.length     ; j++) {
              k = j;
              for (var i:uint=j+1; i<myArr.length; i++) {
                  if (myArr[k] < myArr[i]) {
                      k=i ;
                  }
              }
              temp2 = myArr[j];
              myArr[j] = myArr[k];
              myArr[k] = temp2;
          }
          trace("排序后",myArr);
          //选择排序法 找最小数字 放在最后一个位置


          trace("程序的功能是显示XML集合中fname节点的内容");
          var myXML:XML = <users>
                <fname>二维动画</fname>
                <fname>平面设计</fname>
                <fname>视频编辑</fname>
                         </users>;
          for each (var i2 in  myXML.fname ){
              trace(i2);
          }
          //foreach遍历myXML


          trace("程序的功能是定义一个数组和一个对象，并分别调用typeInfo函数，分别输出数组中的各个元素、对象中的各个属性");
          function typeInfo(obj2){
              if (obj2 is Array) {
                  //用is判断参数类型
                  trace("数组中的元素包括：");
              }
              else if (obj2 is Object) {
                  trace("对象中的属性包括：");
              }
              for (var i3 in obj2) {
                  //输出参数中的各项内容
                  trace(i3,"=",obj2[i3]);
              }
          }
          //定义一个数组和一个对象，并分别调用函数
          var myArr:Array = [100,200,300];
          var myObj:Object = {name:"王明亮",age:30,height:180};
          typeInfo(myArr);
          typeInfo(myObj);
          //for ( go in All) go 迭代访问变量



          trace("通过类的定义与继承、接口的声明与实现，输出如下信息");
          /*
          //Pet.as中定义了一个宠物类Pet
          package{
              public class Pet{
                  public var master:String = "亨利";//master用于存储主人的消息
                  public var name:String;           //name用于存储宠物的名字
              }
          }
          //IPet.as中声明了一个接口IPet
          package{
              public   interface  IPet{
                  function eat();
                  function sleep();
                  function run();
              }
          }
          //Dog.as中定义了一个继承自Pet类的子类Dog，并实现接口IPet中的各个方法
          package{
              public class Dog  extend Pet implements IPet    {
                  public function Dog(name:String){
                      this.name = name;     //在构造函数中，传递参数为小狗的名字
                  }
                      //实现接口的eat方法
                  public function eat(){
                      trace(  this.master  +"喂" +   this.name   + "吃东西");
                  }
                      //实现接口的sleep方法
                  public function sleep(){
                      trace(this.name + "睡着了");
                  }
                      //实现接口的run方法
                  public function run(){
                      trace(this.name + "欢快地跳着");
                  }
              }
          }
          //inf.fla时间轴第一帧上添加代码：
          var myDog:Dog =   new Dog("旺仔") ;
          myDog.run();
          myDog.eat();
          myDog.sleep();
          */

          trace("编写一个计算从n1到n2累加和的函数mysum(n1:uint,n2:uint)，通过调用该函数，输出从1到100的累加和（正确结果是5050）");

          function mysum(n1:uint,n2:uint){
              if(n2 == n1){
                  return n1;
              }else{
                  return mysum(n1,n2-1)+n2;
              }
          }
          trace(mysum(1,100));
          // 递归


          trace("编写一个计算整数n的阶乘的递归函数fac(n:uint):uint，通过调用该函数，输出5的阶乘（正确结果是120）");
          function fac(n:uint):uint{
              if(n==1){
                  return n;
              }else{
                  return n*fac(n-1);
              }
          }
          trace(fac(5));
          // 递归

      }
  }
}


package  {

  import flash.display.MovieClip;
  import flash.events.KeyboardEvent;
  import flash.events.Event;

  public class sy3 extends MovieClip {


      public function sy3() {

          stop();

          trace("kaishi")

          var frameNumber:Number;
          frame_N();
          //自定义函数，用于获取当前帧
          stage.addEventListener(KeyboardEvent.KEY_DOWN, change_F); //侦听键被按下事件

          function change_F(me:KeyboardEvent):void {

              switch (me) {
                   //判断按下了什么键
                  case Keyboard.RIGHT :
                      if (frameNumber==this.totalFrames) { //是最后一帧？
                          this. gotoAndStop(1);     //是，跳转到第一帧
                      }
                      else {
                          this.nextFrame();        //不是，跳转到下一帧
                      }
                      frame_N();
                      break;
                  case Keyboard.LEFT :
                      if (frameNumber == 1) {  //是第一帧？
                          this.gotoAndStop(this.totalFrames);//到最后一帧
                      }
                      else {
                          this.prevFrame();        //跳转到上一帧
                      }
              }
              frame_N();
          }

          function frame_N():void
          {
              frameNumber = this.currentFrame;           //获取当前帧编号
              j_txt.text   = String(frameNumber);    //在文本框中显示帧编号
          }


      }
  }

}

package  {
  import flash.display.MovieClip;
  import flash.events.Event;

  public class shiyan4 extends MovieClip {
      public function shiyan4() {

          /*
          var ball:MovieCircle= new MovieCircle() ;  //创建一个MoveCircle类的实例ball
          var di:int = 1;                    //控制左右移动方向变量，右为 1，左为 -1
          stage.addChild(ball) ;    //将实例ball添加到舞台
          ball.x = 0;
          ball.y = Math.round(Math.random()*400) ; // 控制小球在窗口的高度（400）范围内出现
          stage.addEventListener(Event.ENTER_FRAME , Move);  //帧频事件
          function Move(e:Event):void{
              if (ball.x>( stage.stageWidth-ball.width)){   //小球右移超出舞台边界时
                  di = -1;
              }
              if (ball.x < 0) {
                  di = 1;
              }
              ball.x +=  5 * di;
          }
          */
          var di:Array = new Array();
          var mcs:Array = new Array();
          for(var i:uint=0; i<5; i++){
              di[i] = new int(1);
              mcs[i] = new MC();
              mcs[i].width = (i+1)*10;
              mcs[i].height = (i+1)*10;mcs[i].x = 0;
              mcs[i].y = 20 + (i+1)*mcs[i].height;
              stage.addChild(mcs[i]);  //将第i个实例添加到舞台
          }
          stage.addEventListener(Event.ENTER_FRAME, Move);    //帧频事件
          function Move(e:Event):void{
              for(i=0;i<5;i++){
                  if(mcs[i].x>(stage.stageWidth-mcs[i].width)) //实例右移超出舞台边界时
                      di[i]= -1;
                  if(mcs[i].x < 0 )
                      di[i]= 1;
                  mcs[i].x += 5*di[i];
              }
          }

      }
  }

}

***

## 教材

范例6-5
范例9-2 架子鼓
范例9-3 音乐的开关
P327 最后一行 改成channel = backSound.play(0,1000000);