当前位置：首页 > 实用文档 > 其他范文> 地下工程有限元图形系统的面向对象开发

地下工程有限元图形系统的面向对象开发

时间：2023-08-07 07:49:22 其他范文收藏本文下载本文

地下工程有限元图形系统的面向对象开发（锦集5篇）由网友“多鱼”投稿提供，下面给大家分享地下工程有限元图形系统的面向对象开发，欢迎阅读!

地下工程有限元图形系统的面向对象开发

篇1：地下工程有限元图形系统的面向对象开发

地下工程有限元图形系统的面向对象开发

应用面向对象技术有效地组织地下结构有限元分析图形系统的复杂数据,提出了有限元后处理图形系统面向对象的数据结构和基本算法,并用VC++完成了该系统的开发.系统可以方便地显示地下结构的应力、位移等物理量的.空间等值线、矢量图、塑性区、开裂区等分布特征,最后还给出了系统的应用实例.

作者：作者单位：刊名：岩石力学与工程学报 ISTIC EI PKU英文刊名：CHINESE JOURNAL OF ROCK MECHANICS AND ENGINEERING 年，卷(期)： 21(z1) 分类号：O241.82 关键词：面向对象设计地下工程有限元后处理图形系统

篇2：面向对象软件工程开发探讨的论文

面向对象软件工程开发探讨的论文

［摘要］

当前计算机软件的复杂性处于日益增长的趋势，不仅意味着软件技术的飞跃，同时也意味着计算机软件的规模也将随之不断扩大。在这样的背景下，面向对象的软件工程逐渐成为了软件开发过程中的主流技术，在近年来逐渐由面向对象编程向面向对象分析及面向对象设计转移，为计算机软件的发展开辟了新的道路，成为了一种主要的研究方向。

［关键词］面向对象；软件工程；开发

0前言

软件工程的设计在于对工程学的相关理论进行利用，并由此作为立足点来进行软件开发与维护。作为软件工程方法中的一大主流方向，面向对象的方法在近年来得到了较为广泛的应用。在该方法中，对象的主要特征属性在于数据与操作，其中数据对应于对象的内部属性特征，操作对应于对象的外部运动规律，通过利用面向对象的方法，软件开发与维护的便捷性可得到根本提升。本文特针对基于面向对象的软件工程开发进行了相关探究，现总结如下。

1面向对象的分析与设计概述

面向对象的分析过程主要包含以下两个阶段：①对用户需求进行提取与抽象概括；②建立模型。面向对象的设计过程主要是将用户的实际要求进行转换与设计，使其成为一个最优的方案。面向对象的方法在由分析到设计的过程中，所有已知条件处于不断扩充的状态，在对其进行优化与完善后，最终使其成为模型。分析与设计虽属于两个不同的阶段，但两者不仅相互联系、相互影响，甚至可相互产生制约。一方面，分析的准确性可对所建立模型的实际意义产生直接影响，同时也是设计结果的折射；另一方面，设计阶段并非可脱离分析阶段独立运行，反之，在这一阶段中需对分析的结果进行反复的理解，由此对其进行完善。

2面对对象的开发方法研究

2．1Booch方法

Booch这一方法主要分为微观与宏观两个过程，两个过程之间存在一定联合，同时相互区别，笔者在此进行区别概述。微观的过程可概括为以下几个方面：①将类和对象抽象化，在问题中进行类和对象的挖掘，同时确定实现对象功能的行为；②对抽象出来的类的状态及行为进行建立，主要对类图进行利用，由此建立起识别对象与类的关系，对类对象的`边界进行确认，并对相互协同作用的类对象进行辨别；③对算法与数据结构进行优化设计，以实现对象类与对象。与微观过程不同的是，宏观过程对于风险与结构更为侧重。进行宏观软件工程开发时，一些相应的成果及活动随之得以确定，为风险评估工作与修改工作提供了便利条件。在宏观过程中，结构与完整性两个因素得到了重点强调，对概念化和需求的建立提出了新的要求。在概念化的过程中，对于创造性具有较高的要求，且无固定模式与框架，建立核心的需求是该过程中的根本任务。另外，在分析过程中，需对软件开发所需的模型进行提供，并充分对系统的行为引起重视，由此作为立足点，对系统的功能特点进行区分；设计过程中，主要侧重于系统结构的实现。

2．2OMT方法

OMT方法是一种在数据库的关系设计中具有广泛应用范围的方法，且在不断发展的过程中，在面向对象的分析与设计领域中也逐渐得到了应用。在实体与关系模型的基础上，OMT方法又做出了进一步拓展，主要包括类、行为、继承等。该方法的模型主要分为如下三种：①对象的模型。该模型主要对对象静态的结构进行表述，并对其相互之间的作用关系进行表达；②动态的模型。该模型主要对系统动态的变化特点进行描述，如随时间的变化等，状态与活动是其重要概念；③功能的模型。该模型主要将不同的数据值在系统内进行转换，如数据存储、数据流、控制流的概念等。总而言之，OMT方法对于分析数据密集型的信息系统具有重要的意义，同时具有较为广阔的发展前景。

2．3UML方法

UML这一建模语言的特点在于易于表达、思路清晰、功能强大，包含着静态、动态、系统环境模型等。在这一方法中，可通过可视化建模工具所提供的代码来对模型进行转换，使其成为一种编程语言，不仅如此，还可通过对相应的工具与方法进行利用，使其产生逆向转换，使其成为UML。在UML方法中，基于例图、对象图、类图的模型可划分为静态模型；基于状态图、活动图的模型可划分为动态类型。这一方法的优势在于对先前各种建模技术的经验与特点做出了综合与总结，并对其中的有利条件进行了吸收，形成一种标准的建模语言。例如，Web系统、数据的模型等新的思想均在UML技术中得到了充分体现，为其提供了深厚的内在支持。

3面向对象的软件工程开发的特点及优势

经实践研究表明，面向对象进行设计的软件工程在当前的计算机软件工程中具有较强的优势。第一，该方法与人类的思维方式更为贴近；第二，该方法具有较强的稳定性；第三，具有更强的可复用性；第四，在大型产品的开发与维护工作中可提供更为良好的便利条件。该方法的特点主要可概括如下：①对象属于基本元素，不同的基本元素之间可进行组合，形成复杂的软件对象，并由软件对象构成整体的系统；②在对不同的对象类进行划分时，可各自对应的数据与方法；③层次结构可通过子类与父类来进行设定；④不同对象之间可进行相互联系。

4结语

综上所述，面向对象的软件开发工程是一种具有较强先进性的方法，在计算机软件开发工作中具有重要的意义，但仍面临着一定的局限性，需在今后的实践中做出相应的完善。

篇3：Flash ActionScript2.0面向对象游戏开发

对象

概述:

Flash ActionScript2.0是一种面向对向的编程语言,利用它可以开发出功能强大的应用程序.以早期的ActionScript. 1.0相比,它在结构化编程上具有明显的优势,可以使程序具有更强的可移植性,可重性,和伸缩性.

本文通过一个推箱子游戏的开发过程来逐步讲述如何利用ActionScript2.0 进行开发.

结构分析:

在进行一个项目的开发前,项目规化是必不可少的.我们先来思考一下推箱子游戏包含哪些必要的元素呢?

一个玩家(Player)

至少一个箱子(Box)

和箱子数目一样的目标地(Target)

数目不定的砖块(Brick)

砖块连在一下组成了墙壁(Wall)

一个游戏管理者(Manager)

一些显示游戏信息的控件

我们都需要将这些元素抽象化为对象(Object),各个对象包含有各自特有的属性和方法.比如,玩家具有位置属性(currentPos),它表示玩家当全的位置,玩家还有move方法,它使玩家移到下一个位置.等腰三角形这些问题搞清楚了,我们就要进行具体的实现.

实现过程:

打开Flash,新建“动作脚本文件”,依次建立如下.as文件,注意要把它们放在同一个目录下.源文件如下:

//*********Pos.as*********

//用来表示游戏中物体位置的类

//游戏中所有对象的位置都为此类的实例

//用col,row 两个量确定物体的位置

class Pos {

var col:Number;// 列值

var row:Number;// 行值

//构造函数

function Pos(c, r) {

col = c;

row = r;

}

//判断两个位置是否重合

function equals(t):Boolean {

return (col == t.col && row == t.row);

}

//根据方向值,取得此位置的下一个位置

function getNextPos(d):Pos{

var nextPos:Pos;

nextPos=new Pos(col,row);

switch (d) {

case 0 :

nextPos.col++;

break;

case 1 :

nextPos.row++;

break;

case 2 :

nextPos.col--;

break;

case 3 :

nextPos.row--;

break;

}

return nextPos;

}

//************Wall.as************

//用来构建游戏中的墙壁

class Wall extends MovieClip {

var brickMatrix:Array;//表示墙壁形状的数组

var left:Number;//左偏移量

var top:Number;//上偏移量

var bricks:Array;//用来存放砖块电影剪辑的数组

var _stepSize:Number;//每块砖的偏移量

//构造函数

function Wall {

left = 0;

top = 0;

_stepSize = 40;

}

//设置墙壁形状数组

function setMatrix(b) {

bricks = new Array();

brickMatrix = b;

}

//按照墙壁形状数组修墙

function build():Void {

var index = 0;

for (var i = 0; i

for (var j = 0; j

if (brickMatrix[i][j] == 1) { //数组值为1,画一块砖

bricks[index] = attachMovie(“Brick”, “bricks”+index, this.getNextHighestDepth());

bricks[index]._x = left+j*_stepSize;

bricks[index]._y = top+i*_stepSize;

index++;

}

//*************Target.as*****************

class Target extends MovieClip{

var pos:Pos;

var finished:Boolean;

var left:Number;

var top:Number;

var _stepSize:Number;

function Target(){

finished=false;

left=0;

top=0;

_stepSize=40;

}

function setPos(p){

pos=p;

this._x=left+pos.col*_stepSize;

this._y=top+pos.row*_stepSize;

}

//*************Player.as**************

//游戏中的player

class Player extends MovieClip {

var _stepSize:Number;//步长

var _wall:MovieClip;//墙壁电影剪彩辑

var startPos:Pos;//初始置

var currentPos:Pos;//当前位置

var left:Number;//左边距

var top:Number;//上边距

var dir:Number;//移动方向

var boxes:Array;

var player_path_stack:Array;//玩家移动的路线

var boxes_path_stack:Array;//箱子移动的路线

//构造函数,初始化

function Player() {

_stepSize = 40;

currentPos = null;

left = 0;

top = 0;

dir = 0;

player_path_stack=new Array();

boxes_path_stack=new Array();

boxes = new Array();

}

//设置玩家的起始位置

function setStartPos(p) {

startPos = new Pos(p.col, p.row);

currentPos = startPos;

this._x = currentPos.col*_stepSize+left;

this._y = currentPos.row*_stepSize+top;

}

//为玩家指定一个wall实例

function setWall(w) {

_wall = w;

}

//为玩家指定一个boxes数组,存有所有的箱子实例

function setBoxes(b) {

boxes = b;

}

//通过按键控制玩家

function setKeyHandle() {

this.onKeyDown = function() {

if (Key.isDown(Key.LEFT)) {

dir = 2;//左键

} else if (Key.isDown(Key.RIGHT)) {

dir = 0;//右键

} else if (Key.isDown(Key.UP)) {

dir = 3;//上键

} else if (Key.isDown(Key.DOWN)) {

dir = 1;//下键

}

var nextObject = this.getNextObject(); //取得玩家下一个位置上的物体

if (nextObject == “BOX”) { //玩家下一个位置上是个箱子

var box_pushed = getPushedBox();//取得此位置上的这个箱子

//被推到的箱子存在

if (box_pushed) {

if (box_pushed.getNextObject() == “NOTHING”) {//被推箱子的下个位置没有障碍

boxes_path_stack.push({box:box_pushed,pos:new Pos(box_pushed.pos.col,box_pushed.pos.row)});

box_pushed.move();//被推箱子移一步

this.move();//玩家移一步

}

} else if (nextObject == “NOTHING”) {//玩家的下个位置玩障碍

this.move();

boxes_path_stack.push(null);

}

};

Key.addListener(this); //监听按键输入

}

//取得被推到的箱子

function getPushedBox() {

var nextPos:Pos;

nextPos =currentPos.getNextPos(dir);

for (var i = 0; i

if (boxes[i].pos.equals(nextPos)) {

return boxes[i];

break;

//trace(box_pushed);

}

return null;

}

//取得玩家下个位置上的物块类型( 墙壁, 箱子, 无障碍)

function getNextObject():String {

//var obj:String;

var nextPos:Pos;

nextPos = currentPos.getNextPos(dir);

if (_wall.brickMatrix[nextPos.row][nextPos.col] == 1) {

return “WALL”;

}

for (var i = 0; i

if (boxes[i].pos.equals(nextPos)) {

return “BOX”;

}

return “NOTHING”;

}

//移到下个位置

function move() {

player_path_stack.push(currentPos);

var c=currentPos.getNextPos(dir);

currentPos=c;

this._x = left+this.currentPos.col*_stepSize;

this._y = top+this.currentPos.row*_stepSize;

}

//返回上一步

function reback(){

if(player_path_stack.length>0){

var pre=player_path_stack.pop();

currentPos=pre;

this._x = left+this.currentPos.col*_stepSize;

this._y = top+this.currentPos.row*_stepSize;

}

if(boxes_path_stack.length>0 ){

var bj=boxes_path_stack.pop();

if(obj!=null){

var box=obj.box;

var pos=obj.pos;

box.pos=pos;

box._x=box.left+box.pos.col*box._stepSize;

box._y=box.top+box.pos.row*box._stepSize;

}

class Box extends MovieClip {

var pos:Pos;

var left:Number;

var top:Number;

var _wall:MovieClip;

var player:MovieClip;

var _stepSize:Number;

var _targets:Array;

var finished:Boolean;//此箱子是否到达目标地

function Box() {

left = 0;

top = 0;

finished = false;

_stepSize = 40;

}

//设置目标地

function setTargets(t) {

_targets = new Array();

_targets = t;

}

//设置箱子的起始位置若罔闻

function setStartPos(p) {

pos = new Pos(p.col, p.row);

this._x = pos.col*_stepSize+left;

this._y = pos.row*_stepSize+top;

}

//移到下一个位置

function move() {

var c = pos.getNextPos(player.dir);

pos = c;

this._x = left+pos.col*_stepSize;

this._y = top+pos.row*_stepSize;

gotTarget();

}

//是否到达目标地

function gotTarget() {

for (var i = 0; i<_targets.length; i++) {

if (this.pos.equals(_targets[i].pos)) {

if (this.getDepth()>_targets[i].getDepth()) {

this.swapDepths(_targets[i]);

}

this.finished = true;

return;

}

this.finished = false;

}

//取得一下个位置上物体的类型

function getNextObject():String {

//var obj:String;

var nextPos:Pos;

nextPos = pos.getNextPos(player.dir);

if (_wall.brickMatrix[nextPos.row][nextPos.col] == 1) {

return “WALL”;

}

for (var i = 0; i

if (player.boxes[i].pos.equals(nextPos)) {

return “BOX”;

}

return “NOTHING”;

}

class Matrix{

//用来存放游戏各关中初始界面

static var matrixs:Array;

function Matrix(){

matrixs=new Array();

//0:null

//1:wall

//2:player

//3:box

//4:target

//5:target and box

//1 2 3 4 5 6 7 8 9

matrixs[0]= [[0, 0, 0, 0, 0, 0, 0, 0, 0],//1

[0, 0, 0, 0, 0, 0, 0, 0, 0],//2

[0, 0, 0, 0, 0, 0, 0, 0, 0],//3

[0, 0, 0, 0, 0, 0, 0, 0, 0],//4

[0, 0, 0, 0, 0, 0, 0, 0, 0],//5

[0, 0, 0, 0, 0, 0, 0, 0, 0],//6

[0, 0, 0, 0, 0, 0, 0, 0, 0],//7

[0, 0, 0, 0, 0, 0, 0, 0, 0],//8

[0, 0, 0, 0, 0, 0, 0, 0, 0] //9

];

//1 2 3 4 5 6 7 8 9

matrixs[1]= [[0, 1, 1, 1, 1, 1, 1, 0, 0],//1

[1, 1, 1, 0, 0, 0, 1, 0, 0],//2

[1, 0, 3, 0, 1, 0, 1, 1, 0],//3

[1, 0, 1, 0, 0, 4, 0, 1, 0],//4

[1, 0, 0, 0, 0, 1, 0, 1, 0],//5

[1, 1, 0, 1, 0, 0, 0, 1, 0],//6

[0, 1, 2, 0, 0, 1, 1, 1, 0],//7

[0, 1, 1, 1, 1, 1, 0, 0, 0],//8

[0, 0, 0, 0, 0, 0, 0, 0, 0] //9

];

//1 2 3 4 5 6 7 8 9

matrixs[2]= [[0, 0, 1, 1, 1, 1, 1, 0, 0],//1

[1, 1, 1, 0, 0, 0, 1, 0, 0],//2

[1, 0, 3, 0, 1, 0, 1, 1, 0],//3

[1, 0, 1, 0, 0, 4, 0, 1, 0],//4

[1, 0, 0, 0, 0, 1, 0, 1, 0],//5

[1, 1, 3, 1, 4, 0, 0, 1, 0],//6

[0, 1, 2, 0, 0, 1, 1, 1, 0],//7

[0, 1, 1, 1, 1, 1, 0, 0, 0],//8

[0, 0, 0, 0, 0, 0, 0, 0, 0] //9

];

//1 2 3 4 5 6 7 8 9

matrixs[3]= [[1, 1, 1, 1, 1, 1, 1, 1, 0],//1

[1, 0, 0, 0, 1, 0, 0, 1, 0],//2

[1, 0, 0, 0, 0, 0, 0, 1, 0],//3

[1, 1, 3, 1, 1, 0, 0, 1, 0],//4

[0, 1, 0, 4, 1, 0, 1, 1, 1],//5

[0, 1, 0, 0, 0, 0, 2, 0, 1],//6

[0, 1, 0, 0, 1, 0, 0, 0, 1],//7

[0, 1, 1, 1, 1, 1, 1, 1, 1],//8

[0, 0, 0, 0, 0, 0, 0, 0, 0] //9

];

//1 2 3 4 5 6 7 8 9

matrixs[4]= [[1, 1, 1, 1, 1, 1, 1, 1, 0],//1

[1, 0, 0, 0, 1, 0, 0, 1, 0],//2

[1, 0, 0, 0, 0, 0, 0, 1, 0],//3

[1, 1, 5, 1, 1, 0, 0, 1, 0],//4

[0, 1, 0, 4, 1, 0, 1, 1, 1],//5

[0, 1, 0, 5, 0, 3, 2, 0, 1],//6

[0, 1, 0, 0, 1, 0, 0, 0, 1],//7

[0, 1, 1, 1, 1, 1, 1, 1, 1],//8

[0, 0, 0, 0, 0, 0, 0, 0, 0] //9

];

//1 2 3 4 5 6 7 8 9

matrixs[5]= [[0, 0, 1, 1, 1, 1, 0, 0, 0],//1

[0, 1, 1, 0, 0, 1, 1, 1, 1],//2

[1, 1, 0, 0, 0, 0, 0, 0, 1],//3

[1, 0, 3, 0, 1, 2, 1, 0, 1],//4

[1, 0, 1, 0, 4, 0, 0, 0, 1],//5

[1, 0, 0, 3, 0, 1, 1, 1, 1],//6

[1, 1, 1, 0, 4, 1, 0, 0, 0],//7

[0, 0, 1, 1, 1, 1, 0, 0, 0],//8

[0, 0, 0, 0, 0, 0, 0, 0, 0] //9

];

//1 2 3 4 5 6 7 8 9

matrixs[6]= [[0, 0, 1, 1, 1, 1, 0, 0, 0],//1

[0, 1, 1, 0, 0, 1, 1, 1, 1],//2

[1, 1, 0, 0, 3, 0, 0, 0, 1],//3

[1, 0, 3, 0, 1, 2, 1, 0, 1],//4

[1, 0, 1, 0, 4, 0, 0, 0, 1],//5

[1, 0, 4, 3, 0, 1, 1, 1, 1],//6

[1, 1, 1, 0, 4, 1, 0, 0, 0],//7

[0, 0, 1, 1, 1, 1, 0, 0, 0],//8

[0, 0, 0, 0, 0, 0, 0, 0, 0] //9

];

//1 2 3 4 5 6 7 8 9

matrixs[7]= [[0, 1, 1, 1, 1, 1, 0, 0, 0],//1

[0, 1, 0, 0, 0, 1, 0, 0, 0],//2

[1, 1, 3, 1, 0, 1, 1, 1, 0],//3

[1, 0, 0, 0, 3, 2, 0, 1, 0],//4

[1, 0, 1, 0, 0, 1, 0, 1, 0],//5

[1, 0, 1, 4, 0, 4, 0, 1, 0],//6

[1, 0, 0, 0, 1, 1, 1, 1, 0],//7

[1, 1, 1, 1, 1, 0, 0, 0, 0],//8

[0, 0, 0, 0, 0, 0, 0, 0, 0] //9

];

//1 2 3 4 5 6 7 8 9

matrixs[8]= [[0, 1, 1, 1, 1, 1, 0, 0, 0],//1

[0, 1, 0, 0, 0, 1, 0, 0, 0],//2

[1, 1, 3, 1, 0, 1, 1, 1, 0],//3

[1, 0, 0, 4, 3, 2, 0, 1, 0],//4

[1, 0, 1, 0, 0, 1, 0, 1, 0],//5

[1, 0, 1, 4, 4, 3, 0, 1, 0],//6

[1, 0, 0, 0, 1, 1, 1, 1, 0],//7

[1, 1, 1, 1, 1, 0, 0, 0, 0],//8

[0, 0, 0, 0, 0, 0, 0, 0, 0] //9

];

//1 2 3 4 5 6 7 8 9

matrixs[9]= [[0, 1, 1, 1, 1, 1, 1, 1, 0],//1

[0, 1, 0, 2, 4, 4, 4, 1, 0],//2

[0, 1, 0, 0, 0, 1, 1, 1, 1],//3

[1, 1, 1, 3, 0, 0, 0, 0, 1],//4

[1, 0, 0, 0, 1, 3, 1, 0, 1],//5

[1, 0, 3, 0, 1, 0, 0, 0, 1],//6

[1, 0, 0, 0, 1, 1, 1, 1, 1],//7

[1, 1, 1, 1, 1, 0, 0, 0, 0],//8

[0, 0, 0, 0, 0, 0, 0, 0, 0] //9

];

//1 2 3 4 5 6 7 8 9

matrixs[10]= [[0, 0, 1, 1, 1, 1, 0, 0, 0],//1

[0, 0, 1, 0, 0, 1, 0, 0, 0],//2

[0, 0, 1, 0, 0, 1, 0, 0, 0],//3

[0, 0, 1, 0, 0, 1, 1, 1, 0],//4

[0, 0, 1, 4, 3, 3, 2, 1, 0],//5

[0, 0, 1, 0, 0, 4, 0, 1, 0],//6

[0, 0, 1, 0, 0, 1, 1, 1, 0],//7

[0, 0, 1, 1, 1, 1, 0, 0, 0],//8

[0, 0, 0, 0, 0, 0, 0, 0, 0] //9

];

}

function getMatrix(d){

return matrixs[d];

}

//****************Manager.as*************

//用来管理游戏

//所有的对象都入其中

//MovieClip类的子类

class Manager extends MovieClip {

var wall:MovieClip;

var player:MovieClip;

var boxes:Array;

var targets:Array;

var stageNum:Number;//游戏的当前关数

function Manager() {

_x=50;

_y=50;

}

//游戏初始化

function init(s) {

stageNum = s;

boxes = new Array();

targets = new Array();

var brickMatrixT = new Matrix().getMatrix(stageNum);//根据关数从矩阵类中取得相应的矩阵

//修墙

wall = attachMovie(“Wall”, “wall”, this.getNextHighestDepth());

wall.setMatrix(brickMatrixT);

wall.build();

//创建一个玩家

player = attachMovie(“Player”, “plyaer”, this.getNextHighestDepth());

player.setWall(wall);

player.setKeyHandle();//监听键盘输入

for (var i = 0; i

for (var j = 0; j

if (brickMatrixT[i][j] == 2) {

player.setStartPos(new Pos(j, i));

}

if (brickMatrixT[i][j] == 3) {

var d = this.getNextHighestDepth();

var box = attachMovie(“Box”, “box”+i+j, d);

box.setStartPos(new Pos(j, i));

box.player = player;

box._wall = wall;

boxes.push(box);

}

if (brickMatrixT[i][j] == 4) {

var d = this.getNextHighestDepth();

var t = attachMovie(“Target”, “target”+i+j, d);

t.setPos(new Pos(j, i));

targets.push(t);

}

if (brickMatrixT[i][j] == 5) {

var d = this.getNextHighestDepth();

var box = attachMovie(“Box”, “box”+i+j, d);

box.setStartPos(new Pos(j, i));

box.player = player;

box._wall = wall;

box.finished = true;

boxes.push(box);

var d1 = this.getNextHighestDepth();

var t = attachMovie(“Target”, “target”+i+j, d1);

t.setPos(new Pos(j, i));

targets.push(t);

}

for (var i = 0; i

boxes[i].setTargets(targets);

}

player.setBoxes(boxes);

player.swapDepths(this.getNextHighestDepth());

}

//判断游戏是否结束

function ifWin() {

var win = true;

for (var i = 0; i

win = boxes[i].finished && win;

}

return win;

}

新建“Flash文档”,命名为“push_box”,并将它和以上脚本文件存在同一目录下.以下要做的就是建立要用到的电影剪辑,并将其和相应的脚本文件建立链接.

按“Ctrl+F8”,新建一个电影剪辑,命名为“Player”,在编辑状态下画一个长,宽都为40象素的小人(_stepSize=40),注意,小人的注册点放在左上脚.画完后在电影库中,右击“Player”,选择“为动作脚下本导出”,其它不选.“标识符”,“As 2.0类”都为电影剪辑名“Player”.要注意,大小写不能搞错,否则会出错.

按上述方法依次建立“Box”,“Target”剪辑.

按10建立名为“Brick”的剪辑,不过由于它不需要外部脚本文件,故“As 2.0”中不要添.

按10建立“Wall”剪辑,稍有不同的是,在编辑状态下,第一帧中加“stop()”,第二帧中加入一个“Brick”剪辑.这样做是因为“Wall”在修建时需要用到“Brick”.

按12建立“Manager”剪辑,不同的是需要点中“在第一帧导出”，而且第二帧加入的不是“Brick”,而是“Wall”,“Player”,“Box”,“Target”.

好了,一切就绪,我们可以测试一下了.在主时间轴上第一帧中中入语句:attachMovie(“Manager”,“game1”,_root.getNextHighestDepth()); game1.init(1);就可以运行第一关了.

至于如何建立友好的用户界面,我们只需稍花点力气就搞定了.

示例：

点击这里下载源文件

如果你还有任何不明白之处,可发邮件或QQ给我.xiake1860@ncepubj.edu.cnQQ:4077130

篇4：面向对象的软件工程开发分析的论文

［摘要］当前计算机软件的复杂性处于日益增长的趋势，不仅意味着软件技术的飞跃，同时也意味着计算机软件的规模也将随之不断扩大。在这样的背景下，面向对象的软件工程逐渐成为了软件开发过程中的主流技术，在近年来逐渐由面向对象编程向面向对象分析及面向对象设计转移，为计算机软件的发展开辟了新的道路，成为了一种主要的研究方向。

［关键词］面向对象；软件工程；开发

0前言

1面向对象的分析与设计概述

2面对对象的开发方法研究

2．1Booch方法

Booch这一方法主要分为微观与宏观两个过程，两个过程之间存在一定联合，同时相互区别，笔者在此进行区别概述。微观的过程可概括为以下几个方面：①将类和对象抽象化，在问题中进行类和对象的挖掘，同时确定实现对象功能的行为；②对抽象出来的类的状态及行为进行建立，主要对类图进行利用，由此建立起识别对象与类的关系，对类对象的边界进行确认，并对相互协同作用的'类对象进行辨别；③对算法与数据结构进行优化设计，以实现对象类与对象。与微观过程不同的是，宏观过程对于风险与结构更为侧重。进行宏观软件工程开发时，一些相应的成果及活动随之得以确定，为风险评估工作与修改工作提供了便利条件。在宏观过程中，结构与完整性两个因素得到了重点强调，对概念化和需求的建立提出了新的要求。在概念化的过程中，对于创造性具有较高的要求，且无固定模式与框架，建立核心的需求是该过程中的根本任务。另外，在分析过程中，需对软件开发所需的模型进行提供，并充分对系统的行为引起重视，由此作为立足点，对系统的功能特点进行区分；设计过程中，主要侧重于系统结构的实现。

2．2OMT方法

2．3UML方法