Flash ActionScript2.0面向对象游戏开发
“才不是麻瓜”通过精心收集，向本站投稿了10篇Flash ActionScript2.0面向对象游戏开发，下面小编给大家整理后的Flash ActionScript2.0面向对象游戏开发，欢迎阅读!
篇1：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
篇2：面向对象软件工程开发探讨的论文
面向对象软件工程开发探讨的论文
［摘要］
当前计算机软件的复杂性处于日益增长的趋势，不仅意味着软件技术的飞跃，同时也意味着计算机软件的规模也将随之不断扩大。在这样的背景下，面向对象的软件工程逐渐成为了软件开发过程中的主流技术，在近年来逐渐由面向对象编程向面向对象分析及面向对象设计转移，为计算机软件的发展开辟了新的道路，成为了一种主要的研究方向。
［关键词］面向对象；软件工程；开发
0前言
软件工程的设计在于对工程学的相关理论进行利用，并由此作为立足点来进行软件开发与维护。作为软件工程方法中的一大主流方向，面向对象的方法在近年来得到了较为广泛的应用。在该方法中，对象的主要特征属性在于数据与操作，其中数据对应于对象的内部属性特征，操作对应于对象的外部运动规律，通过利用面向对象的方法，软件开发与维护的便捷性可得到根本提升。本文特针对基于面向对象的软件工程开发进行了相关探究，现总结如下。
1面向对象的分析与设计概述
面向对象的分析过程主要包含以下两个阶段：①对用户需求进行提取与抽象概括；②建立模型。面向对象的设计过程主要是将用户的实际要求进行转换与设计，使其成为一个最优的方案。面向对象的方法在由分析到设计的过程中，所有已知条件处于不断扩充的状态，在对其进行优化与完善后，最终使其成为模型。分析与设计虽属于两个不同的阶段，但两者不仅相互联系、相互影响，甚至可相互产生制约。一方面，分析的准确性可对所建立模型的实际意义产生直接影响，同时也是设计结果的折射；另一方面，设计阶段并非可脱离分析阶段独立运行，反之，在这一阶段中需对分析的结果进行反复的理解，由此对其进行完善。
2面对对象的开发方法研究
2．1Booch方法
Booch这一方法主要分为微观与宏观两个过程，两个过程之间存在一定联合，同时相互区别，笔者在此进行区别概述。微观的过程可概括为以下几个方面：①将类和对象抽象化，在问题中进行类和对象的挖掘，同时确定实现对象功能的行为；②对抽象出来的类的状态及行为进行建立，主要对类图进行利用，由此建立起识别对象与类的关系，对类对象的`边界进行确认，并对相互协同作用的类对象进行辨别；③对算法与数据结构进行优化设计，以实现对象类与对象。与微观过程不同的是，宏观过程对于风险与结构更为侧重。进行宏观软件工程开发时，一些相应的成果及活动随之得以确定，为风险评估工作与修改工作提供了便利条件。在宏观过程中，结构与完整性两个因素得到了重点强调，对概念化和需求的建立提出了新的要求。在概念化的过程中，对于创造性具有较高的要求，且无固定模式与框架，建立核心的需求是该过程中的根本任务。另外，在分析过程中，需对软件开发所需的模型进行提供，并充分对系统的行为引起重视，由此作为立足点，对系统的功能特点进行区分；设计过程中，主要侧重于系统结构的实现。
2．2OMT方法
OMT方法是一种在数据库的关系设计中具有广泛应用范围的方法，且在不断发展的过程中，在面向对象的分析与设计领域中也逐渐得到了应用。在实体与关系模型的基础上，OMT方法又做出了进一步拓展，主要包括类、行为、继承等。该方法的模型主要分为如下三种：①对象的模型。该模型主要对对象静态的结构进行表述，并对其相互之间的作用关系进行表达；②动态的模型。该模型主要对系统动态的变化特点进行描述，如随时间的变化等，状态与活动是其重要概念；③功能的模型。该模型主要将不同的数据值在系统内进行转换，如数据存储、数据流、控制流的概念等。总而言之，OMT方法对于分析数据密集型的信息系统具有重要的意义，同时具有较为广阔的发展前景。
2．3UML方法
UML这一建模语言的特点在于易于表达、思路清晰、功能强大，包含着静态、动态、系统环境模型等。在这一方法中，可通过可视化建模工具所提供的代码来对模型进行转换，使其成为一种编程语言，不仅如此，还可通过对相应的工具与方法进行利用，使其产生逆向转换，使其成为UML。在UML方法中，基于例图、对象图、类图的模型可划分为静态模型；基于状态图、活动图的模型可划分为动态类型。这一方法的优势在于对先前各种建模技术的经验与特点做出了综合与总结，并对其中的有利条件进行了吸收，形成一种标准的建模语言。例如，Web系统、数据的模型等新的思想均在UML技术中得到了充分体现，为其提供了深厚的内在支持。
3面向对象的软件工程开发的特点及优势
经实践研究表明，面向对象进行设计的软件工程在当前的计算机软件工程中具有较强的优势。第一，该方法与人类的思维方式更为贴近；第二，该方法具有较强的稳定性；第三，具有更强的可复用性；第四，在大型产品的开发与维护工作中可提供更为良好的便利条件。该方法的特点主要可概括如下：①对象属于基本元素，不同的基本元素之间可进行组合，形成复杂的软件对象，并由软件对象构成整体的系统；②在对不同的对象类进行划分时，可各自对应的数据与方法；③层次结构可通过子类与父类来进行设定；④不同对象之间可进行相互联系。
4结语
综上所述，面向对象的软件开发工程是一种具有较强先进性的方法，在计算机软件开发工作中具有重要的意义，但仍面临着一定的局限性，需在今后的实践中做出相应的完善。
篇3：面向对象的软件工程开发分析的论文
［摘要］当前计算机软件的复杂性处于日益增长的趋势，不仅意味着软件技术的飞跃，同时也意味着计算机软件的规模也将随之不断扩大。在这样的背景下，面向对象的软件工程逐渐成为了软件开发过程中的主流技术，在近年来逐渐由面向对象编程向面向对象分析及面向对象设计转移，为计算机软件的发展开辟了新的道路，成为了一种主要的研究方向。
［关键词］面向对象；软件工程；开发
0前言
软件工程的设计在于对工程学的相关理论进行利用，并由此作为立足点来进行软件开发与维护。作为软件工程方法中的一大主流方向，面向对象的方法在近年来得到了较为广泛的应用。在该方法中，对象的主要特征属性在于数据与操作，其中数据对应于对象的内部属性特征，操作对应于对象的外部运动规律，通过利用面向对象的方法，软件开发与维护的便捷性可得到根本提升。本文特针对基于面向对象的软件工程开发进行了相关探究，现总结如下。
1面向对象的分析与设计概述
面向对象的分析过程主要包含以下两个阶段：①对用户需求进行提取与抽象概括；②建立模型。面向对象的设计过程主要是将用户的实际要求进行转换与设计，使其成为一个最优的方案。面向对象的方法在由分析到设计的过程中，所有已知条件处于不断扩充的状态，在对其进行优化与完善后，最终使其成为模型。分析与设计虽属于两个不同的阶段，但两者不仅相互联系、相互影响，甚至可相互产生制约。一方面，分析的准确性可对所建立模型的实际意义产生直接影响，同时也是设计结果的折射；另一方面，设计阶段并非可脱离分析阶段独立运行，反之，在这一阶段中需对分析的结果进行反复的理解，由此对其进行完善。
2面对对象的开发方法研究
2．1Booch方法
Booch这一方法主要分为微观与宏观两个过程，两个过程之间存在一定联合，同时相互区别，笔者在此进行区别概述。微观的过程可概括为以下几个方面：①将类和对象抽象化，在问题中进行类和对象的挖掘，同时确定实现对象功能的行为；②对抽象出来的类的状态及行为进行建立，主要对类图进行利用，由此建立起识别对象与类的关系，对类对象的边界进行确认，并对相互协同作用的'类对象进行辨别；③对算法与数据结构进行优化设计，以实现对象类与对象。与微观过程不同的是，宏观过程对于风险与结构更为侧重。进行宏观软件工程开发时，一些相应的成果及活动随之得以确定，为风险评估工作与修改工作提供了便利条件。在宏观过程中，结构与完整性两个因素得到了重点强调，对概念化和需求的建立提出了新的要求。在概念化的过程中，对于创造性具有较高的要求，且无固定模式与框架，建立核心的需求是该过程中的根本任务。另外，在分析过程中，需对软件开发所需的模型进行提供，并充分对系统的行为引起重视，由此作为立足点，对系统的功能特点进行区分；设计过程中，主要侧重于系统结构的实现。
2．2OMT方法
OMT方法是一种在数据库的关系设计中具有广泛应用范围的方法，且在不断发展的过程中，在面向对象的分析与设计领域中也逐渐得到了应用。在实体与关系模型的基础上，OMT方法又做出了进一步拓展，主要包括类、行为、继承等。该方法的模型主要分为如下三种：①对象的模型。该模型主要对对象静态的结构进行表述，并对其相互之间的作用关系进行表达；②动态的模型。该模型主要对系统动态的变化特点进行描述，如随时间的变化等，状态与活动是其重要概念；③功能的模型。该模型主要将不同的数据值在系统内进行转换，如数据存储、数据流、控制流的概念等。总而言之，OMT方法对于分析数据密集型的信息系统具有重要的意义，同时具有较为广阔的发展前景。
2．3UML方法
UML这一建模语言的特点在于易于表达、思路清晰、功能强大，包含着静态、动态、系统环境模型等。在这一方法中，可通过可视化建模工具所提供的代码来对模型进行转换，使其成为一种编程语言，不仅如此，还可通过对相应的工具与方法进行利用，使其产生逆向转换，使其成为UML。在UML方法中，基于例图、对象图、类图的模型可划分为静态模型；基于状态图、活动图的模型可划分为动态类型。这一方法的优势在于对先前各种建模技术的经验与特点做出了综合与总结，并对其中的有利条件进行了吸收，形成一种标准的建模语言。例如，Web系统、数据的模型等新的思想均在UML技术中得到了充分体现，为其提供了深厚的内在支持。
篇4：面向对象的软件工程开发分析的论文
经实践研究表明，面向对象进行设计的软件工程在当前的计算机软件工程中具有较强的优势。第一，该方法与人类的思维方式更为贴近；第二，该方法具有较强的稳定性；第三，具有更强的可复用性；第四，在大型产品的开发与维护工作中可提供更为良好的便利条件。该方法的特点主要可概括如下：①对象属于基本元素，不同的基本元素之间可进行组合，形成复杂的软件对象，并由软件对象构成整体的系统；②在对不同的对象类进行划分时，可各自对应的数据与方法；③层次结构可通过子类与父类来进行设定；④不同对象之间可进行相互联系。
4结语
综上所述，面向对象的软件开发工程是一种具有较强先进性的方法，在计算机软件开发工作中具有重要的意义，但仍面临着一定的局限性，需在今后的实践中做出相应的完善。
篇5：面向对象程序设计课网站开发研讨论文
面向对象程序设计精品课网站开发研讨论文
1 系统开发背景与需求
《面向对象程序设计》是广东石油化工学院高州师范学院计算机专业学生的一门必修课程，也是进一步学习后续专业课程的重要根底课。学生在学习该门课程时，普遍感到教学内容笼统，难以了解，使学生不只在课堂上需求教员的引导，而且还需求课堂教学之外的有效补充。因而，迫切需求创立一个网络平台，引导学生自主学习交流，协助学生了解课程的重点与难点，提高广阔师生互动，完成网课教学统一。而《面向对象程序设计》精品课程网站就是这样一个网络平台。
2 精品课程网站的功用剖析
精品课程网站是一个基于 B/S 形式的对课程资源高效管理与应用的系统，它的用户主要是学生和教员以及管理员。三类用户的运用功用如图 1 所示。
3 网站设计与完成
3.1 主要技术
本网站主要用到 JSP（Java Server Pages）、Struct2、Hibernate、Div+CSS 及 JavaScript 等 技 术。JSP 是 使 用JAVA 编程言语编写类 XML 的 tags 和 scriptlets,一个封装产生动态网页的处置逻辑网页能经过 tags 和 scriptlets 访问存在与效劳端资源的应用逻辑[1].Struct2 是在 JSP Model2根底上完成的一个 MVC 框架，有助于减少运用 MVC 设计模型开发 Web 应用的时间[2].Hibernate 是一个面向 Java环境的对象 / 关系数据库映射工具，能够管理 Java 类到数据库表的映射，并提供数据的查询和获取办法。
摘要
3.2 数据库设计
将网站的数据笼统为下列的 14 张数据表：权限表（编号，权限名）；用户表（编号，用户账号，密码，姓名，所在系，班级，性别，权限 ID）；目录表（编号，目录称号）；父子关系目录表（编号，子目录 ID,父目录 ID）；文章列表（编号，文章标题，文章作者 ID,所属目录 ID,发表时间，文章内容，缩略图地址）；附件表（编号，附件名，所属文章 ID）；日志表（编号，用户 ID, 操作来源，操作，操作地址，操作时间）；外部链接表（编号，链接称号，链接地址）根贴表（编号，发帖用户 ID,帖子主题，帖子内容，发帖时间，引荐标识，置顶标识，被置顶时间）；回帖表（编号，回帖用户 ID,所属跟帖 ID,回帖内容，回帖时间，回帖数量）；作业任务表（编号，教员 ID,作业标题，作业任务，作业发布时间）；学生作业状态表（编号，作业任务 ID,作业学生 ID,作业状态）；学生作业细致表（编号，作业学生ID,学生答案，得分，作业上传时间）；数据库备份记载表（编号，数据库文件称号，备份时间）。
3.3 精品课程网站模块设计与完成
3.3.1 课程管理模块
课程管理模块只允许管理员与教员对其进行各种操作。它包括课程分类管理和课程资源管理两大子功用。课程分类管理子模块是用于添加或删除课程资源类别，包括父类与子类的设置；父类即主导航栏目的设置，子类即父类中的分类列表，这样不只有利于教员或管理员对课程进行自在地设置，也便于学生进行阅读。依据精品课程网站的目的及《面向对象程序设计》课程特征，初步设置了六大课程资源类别：学习指导、教学指南、授课教案、多媒体教学、教学录像、课程源码及实验指导。
其中，为学习指导类设定了最新公告、在线答疑两子类；教学指南类设定了课程引见、教学大纲、考试大纲、教材引见及参考学惯用书五个子类。
3.3.2 作业管理模块
作业模块是在线布置作业、在线提交、修改一体的管理模块。包括教员在线布置、查看、修改作业，学生提交、下载作业以及查看评语与分数等功用。
本系统中，作业录入、修改功用采用了 CKEeditor 和ckfinder 在线文本编辑器，录入的数据为 html 格式，便于设置作业内容的特殊显现效果。经过设置表格 style 属性，使数据显现自动换行，从而完成编辑与显现相分歧。作业提交、下载则应用 jspSmartUpload 组件来完成。经过表单提交做好的作业，后台将获取学生的答复，并在学生作业细致表中写入学生答案，最后将学生作业状态表中的任务状态改为 1,标识该学生此次任务已完成并上交。
3.3.3 论坛交流模块
论坛模块能够让学生与学生、学生与教员之间集中交流互动。学习者经过论坛能够分享学习心得，提出问题，以至交友互动。教员与管理员共同对论坛发表的帖子进行管理，如删除、置顶、引荐等操作。一切的操作都在用户客户端的阅读器中完成，由 JSPWeb 程序处置后，对效劳器的数据库进行操作，再处置成 HTML 文件传到用户客户端阅读器，响应用户的需求。
3.3.4 日志管理模块
日志是调试系统和定位毛病的.重要手腕之一。系统管理员依据日志来评价平安程序的效率，以及肯定惹起平安毁坏及系统功用失效的缘由，为审计和监测提供数据。
本模块的设计请求将一切记载日志的操作提取出来，构成一个独立的模块，用来管理和记载整个系统需求记载的日志。用户登录后，教员和学生能够经过日志管理模块来查询个人一切的操作记载，而管理员既能够查看一切用户一切的操作记载，也能够执行清空操作。
3.3.5 外链管理模块
外链是指从其他网站导入到本人网站的链接。导入链接关于网站优化来说是一个重要的过程。经过外链管理模块，一切用户能够外链，教员能够对个人外链进行添加、删除、修正操作，管理员能够对恣意外链进行各种操作。
本网站除了上述功用模块外，还有网站常见的注册登录模块、用户管理模块及网站信息管理模块。其中注册登录模块请求用户在登录界面中输入合法的用户名、密码及正确的考证码来登录本精品课程网站。
用户管理模块是用于集中对各层次的用户进行有效的辨认和管理，包含个人材料和权限的修正等。网站信息管理模块便于管理员检查网站各类信息和课程资源状态，及时备份数据和处置异常问题。
4 结 语
本文讨论的《面向对象程序设计》精品课程网站是基于 WEB 设计，用户能够不限平台、不限时间地登陆系统获取所需的信息，大大促进了优质教学资源的共享，同时为学习者提供了个性化的学习环境，对学习效率与学习质量都有较大地提高。
篇6：地下工程有限元图形系统的面向对象开发
地下工程有限元图形系统的面向对象开发
应用面向对象技术有效地组织地下结构有限元分析图形系统的复杂数据,提出了有限元后处理图形系统面向对象的数据结构和基本算法,并用VC++完成了该系统的开发.系统可以方便地显示地下结构的应力、位移等物理量的.空间等值线、矢量图、塑性区、开裂区等分布特征,最后还给出了系统的应用实例.
作 者： 作者单位： 刊 名：岩石力学与工程学报 ISTIC EI PKU英文刊名：CHINESE JOURNAL OF ROCK MECHANICS AND ENGINEERING 年，卷(期)： 21(z1) 分类号：O241.82 关键词：面向对象设计 地下工程 有限元后处理 图形系统篇7：php面向对象面试题
面向对象模型
面向对象的概念：
oop(面向对象的编程)它能是其代码更加简洁易于维护并且具有更强的可重性
什么是类：
类是具有相同属性和服务的一组对象的集合比如说人，书，轮船，车都属于类，他为属于该类的对象做了一个统一的抽象描述，在编程的语言中类是一个单独的程序，它应该有一个类名包括属性的说明和服务两个部分。
什么是对象：
对象是系统中描述客观事件的一个实体，他是构成系统的一个基本单位。*数据与代码都被捆绑在一个实体当中*，一个对象由一组属性和对这组属性进行操作的一组行为组成。
从抽象的角度来说，对象是问题域或实现域中某些事物的一个抽象。他反映该事物在系统中保存的信息和发挥的作用：它是一组属性和有权对这些属性进行操作的一个封装体。客观世界是由对象和对象之间的联系组成的。
类和对象的关系：
类与对象的关系就如模具和铸件的关系，类的实力化的结果就是对象，而对对象的抽象就是类，类描述了一组有相同特性(属性)和相同行为的对象。
类与属性和方法
PHP中定义类语法格式：
复制代码代码如下:
class classname [可选属性]{
public $property [=value];… //用public声明一个公共标识 然后给予一个变量 变量也可以赋值
function functionname ( args ){ //类的方法里的成员函数
代码} …
//类的方法(成员函数)
}
生成对象(类的实例化): $对象名=new classname( );
使用对象的属性
在一个类中，可以访问一个特殊指针$this当在该类中通过一个操作设置或访问该变量时,使用$this->name来引用.
对象的生成
定义好类后用一个new来声明，由于对象资料的封装特性，对象是无法由主程序区块直接访问的须通过对象来调用类中所定义的属性和行为函数，间接地达成存取控制类中资料的目的。
对象和类的关系
对象和类的关系:
对象是实际存在的，占有动态资源。
类是对象的蓝图，可能占有静态资源。
对象属性占有动态资源
类(静态)属性实际上是有类名字空间上的“全局变量”
性能考虑:
每个对象要单独占用数据空间
增加的调用层次可能消耗执行时间
方法的参数形式和传递方式
方法的参数可以是基本数据类型、数组和类对象。
基本数据类型：值参传递
数组：值参传递
类对象：引用传递
构造函数
构造函数是在类中起到初始化的作用
构造函数的生成方法与其他函数一样只是其名称必须是__construct.
语法格式：
function __construct(参数){
。。。。。。。。
}
范例：
复制代码代码如下:
class Person{
public $name;
public $sex;
public $age;
function __construct($name,$sex,$age){
echo “我是构造函数
”;
$this->name=$name;
$this->sex=$sex;
$this->age=$age;
}
输出结果：初始化
析构函数
当对象脱离其作用域时(例如对象所在的函数已调用完毕)，系统自动执行析构函数。应在退出前在析构函数中用释放内存。
析构函数__destruct 析构函数没有任何参数
范例：
复制代码代码如下:
class person{
function _ _destruct( )
{ echo “bye bye !”; }
}
$a=new person();
访问类型
public 公共的(公共修饰符) 类内部与类外部都可以访问的
private 私有的(私有修饰符) 只能在类内部访问
protected 受保护的(保护成员修饰符) 子类可以访问 类外部不可以访问
oop的三个重要特性
封装，继承，多态
封装性：封装性就是把对象的属性和行为结合成一个独立的单位。
封装一个类需要两步 第一步是私有化一个类 第二步是用set和get 做出读取赋值的操作
他的好处是：隐藏类的实现细节，可以方便加入逻辑控制性，限制对属性的不合理操作，便于修改增强代码的可维护性。
__get与__set
一般说把类私有话更符合现实的逻辑。
预定义两种函数来进行获取与敷值操作。
__get 获取值通常是域的值
__set 设置值通常是域的值
__call 调用一个对象中不存在的方法时，就会产生错误call()这个方法来处理这种情况。
静态属性和方法
static关键字 来声明静态方法
static静态变量 在类的内部生成一个静态变量 就是能够被所有类的实力化共想 也就是说静态成员则放到了“初始化静态段”，在类第一次被加载的时候放入的，可以让堆内存里面的每个对象所共享
使用方法：self::$静态属性、self::静态方法
static function p(){
echo self::$country;
echo self::PI;//访问常量
//echo $this->name;在静态方法中只能操作静态属性
//self::p();
}
外部调用：类::$静态属性、类::静态方法
const关键字：用来生成常量 常量是唯一的不能改变的 惯例常量为大写
const CONSTANT = 'constant value'; 生成一个常量
echo self::CONSTANT;//类内部访问
echo ClassName::CONSTANT;//类外部访问
继承性
B类的对象拥有A类的全部属性与行为，称作B对A类的继承。
假如一个类从多个类中继承了属性与服务，这称为多继承，通常我们成为继承类为子类被继承类为父类，在PHP中只有单继承，但一个父类可以被多个类继承，但是一个子类只能有一个父类，但是允许关联继承，通过继承可以减化类的定义。
extende声明继承关系
语法格式：class B extends A 此范例指明 B继承了A
类的外部访问对子类是有效的
子类与父类的属性与方法
子类继承父类的所有内容，但父类中的private部分不能直接访问
子类中新增加的属性和方法是对父类的扩展
子类中定义的与父类同名的属性是对父类属性的覆盖，同名的方法也是对父类方法的覆盖
重写的方法
在子类中，使用parent访问父类中的被覆盖的属性和方法
parent::__construce();
parent::$name;
parent::fun();
覆盖父类原有属性
clone克窿对象 语法格式$c=clone $p; $c克窿的对象$p 输出echo $c->name;
对象比较
===两个比较运算符。
==是比较两个对象的内容。
===是比较对象的句柄，即引用地址。
instanceof操作符用于检测对象实力是否属于某一个类的类型 属于返回true 不属于返回false
__clone()如果想在克隆后改变原对象的内容，需要在__clone()中重写原本的属性和方法
function __clone(){
$this->name=“我是一个克隆人”;
}
final表示一个类是最终版本 也就是说它不能在被子类调用
多态性
多态性是指在父类中定义的属性或行为被子类继承之后，可以具有不同的数据类型或表现出不同的行为。这使得同一个属性或行为在父类及其各个子类中具有不同的语义。
就是说同一种方法在子类与父类中执行的结果不同。
复制代码代码如下:
class A {
function info(){
echo “A INFO”;
}
}
class B extends A {
function info(){
echo “B INFO”;
}
}
class C extends A {
function info(){
echo “C INFO”;
}
}
function printinfo($obj){
function printinfo(A $obj){
if($obj instanceof A)
$obj->info();
$obj->info();
}
}
$a=new A(); $b=new B(); $c=new C();
printinfo($a); //输出A INFO
printinfo($b); //输出B INFO
printinfo($c); //输出C INFO
抽象方法和抽象类
抽象方法是作为子类摸版使用的。
复制代码代码如下:
abstract class Person{
public $name;
abstract function getInfo();
}
抽象类不能被实力话，一个抽象类中，必须有一个抽象方法。但是抽象类中可以定义动态函数。
接口
当一个类继承了一个接口之后，它要覆盖接口的所有方法，接口只能声明常量，接口的方法必须定义为共有否则无法继承，接口可以与多个接口间继承
语法：
复制代码代码如下:
interface PCI{
const TYPE=“PCI”;
//public $name; error
function start();
function stop();
}
接口中的方法可以声明为static
复制代码代码如下:
interface A{ function a();}
interface B{ function b();}
interface C extends A{ function c();}
class D implements B,C{
function a(){}
function b(){}
function c(){}
}
类
类的声明:
复制代码代码如下:
权限修饰符 class 类名{ //权限修士符号:public,protected,private 或者省略3者.
//类体; //class 是建类关键字
} //类名必须跟在class 后面,且跟上{}.{}之间放类的成员.
?>
//ps:在class关键字前可以加权限修饰符外,还可以加static,abstract等关键字.一个类,即一对大括号之间的全部内容都要在一段代码段中,不允许将类中的内容分割成对块.
class ConnDB{
//....
?>
//...
};
?>
成员属性:
在类中直接声明的变量称为成员属性/变量.其类型可以为php中的标量类型和复合类型,使用资源类型和空类型是无效的.
此外,成员属性的声明时,必须要有关键字来修饰:有特定意义的关键字:public,protected,private ;不需要特定意义:var.声明成员属性时,没有必要赋初始值.
成员常量:
以const常量修饰,例如:const PI = 3.1415926;
常量的输出不需要实例化,直接由类名+常量名调用即可,格式为: 类名::常量名
ps. 特殊的访问方法:--------“$this” 和 “::”
1) $“this” 存在于每个成员方法当中,它是一个特殊的对象以用方法.成员方法属于那个对象,$this应用就代表那个对象,其作用就是专门完成对象内部成员之间的访问.
2) “::”成为作用域操作符,使用这个操作符可以在不创建对象的情况下调用类中的常量,变量和方法. 其语法格式如下:
关键字::变量名/常量名/方法名
关键字:parent,可以调用父类成员中的成员变量,成员方法和常量;
self,可以调用当前类中的静态成员和常量;
类名,可以调用类中的常量,变量和方法;
成员方法:
在类中声明的函数成为成员方法,在一个类中可以声明多个函数,即对象可以拥有多个成员方法.成员方法的声明和函数的声明相同,唯一特殊之处就是成员方法可以有关键字对它进行修饰,从而控制其访问权限.
类的实例化
创建对象:
$变量名 = new 类名称([参数]); //类的实例化.
访问类成员:
$变量名 ->成员属性 = 值;
构造方法和析构方法
构造方法是对象创建完成后第一个呗对象自动调用的方法.它存在每个类的声明当中,是一个特殊的成员方法,一般用来完成一些初始化操作.如果类中没有构造方法,系统会默认自动生成一个没有参数的构造方法.
格式:
复制代码代码如下:
function _construct(形参列表){
//方法体
};
析构方法则如构造方法相反,它是在对象被销毁前最后一个调用的方法.它将完成一个特定的操作,如关闭文件和释放内存.
格式:
复制代码代码如下:
function _destruct(){
//方法体
};
面向对象特点:封装性,抽象性,多态性.
封装:
将类中的成员属性和方法结合成一个独立的相同单位,并且尽可能的隐藏对象的内容细节.其目的是确保类以外的部分不能随意存取类的内部数据(成员属性和成员方法),从而避免外部错误对内部数据的影响.
类的封装是通过关键字public,private,protected,static和final实现的.各关键字的作用请查看php相关文档.
继承性:
使一个类继承并拥有另一个已存在的类的成员属性和成员方法,其中被继承的类成为父类,继承的类成为子类.通过继承能够提高代码的重用性和可维护性.类的继承用 extends 关键字.
格式:
复制代码代码如下:
class 子类名称 extends 父类名称{
//子类方法体.
}
通过parent::关键字也可以在子类方法中调用父类的成员方法,格式如下:
parent::父类的成员方法(参数);
覆盖父类的方法:
所谓的覆盖父类的方法,也就是使用子类中的方法替换从父类中继承的方法,也叫方法的重写.重写的关键就在与子类中创建与父类中相同的方法,g包括方法名称,参数和返回类型.
多态性:
多态性是指一段程序能够处理多种类型对象的能力.php多态有两种实现方法,即通过继承实现多态和通过接口实现多态.
通过继承实现多态,即通过重写继承的成员方法来达到多态的效果.
复制代码代码如下:
abstract class ParentClass{
abstract function printMessage();
}
class SubClassA extends ParentClass{
function printMessage(){
echo “i am message from class A”;
}
}
class SubClassB extends ParentClass{
function printMessage(){
echo “i am message from class B”;
}
}
function printMSG($object){
if( $object instanceof ParentClass){
$object->printMessage();
}else{
echo “error!”;
}
}
$objectA=new SubClassA();
printMSG($objectA);
$objectB=new SubClassB();
printMSG($objectB);
?>
通过接口实现多态,通过定义接口,与空方法.然后类继承接口.
复制代码代码如下:
interface interfaceInfo{
function printMessage();
}
class ClassA implements interfaceInfo{
function printMessage(){
echo “message form class A”;
}
}
class ClassB implements interfaceInfo{
function printMessage(){
echo “message form class B”;
}
}
function printMSG($object){
if($object instanceof interfaceInfo){
$object ->printMessage();
}else{
echo “error !”;
}
}
$objectA =new ClassA();
printMSG($objectA);
$objectB =new ClassB();
printMSG($objectB);
?>
ps. 抽象类和接口.
抽象类和接口都是不能被实例化的特殊类.他们都是能够配合面向对象多态性一起使用.
抽象类:
抽象类是一种不能实例化的类,只能作为其他类的父类来使用.抽象类使用abstract 关键字来声明,其格式如下:
复制代码代码如下:
abstract class 抽象类名{
abstract function 成员方法(参数);//
}
抽象类和普通类相似,包含成员变量,成员方法.两者区别在于抽象类至少要包含一个抽象方法.抽象方法没有方法体,其功能的实现只能在子类中完成.抽象方法也使用关键字 abstract 来修饰.
接口:
继承特性简化了对象和类的创建,增强了代码的可重用性.但php只支持单继承,如果想实现多重继承,就要使用接口.
接口的声明:通过interface 关键字来实现,接口中声明的方法必须是抽象方法,接口中不能声明变量,只能使用const 关键字声明为常量的成员属性,并且接口中所有成员都必须具备puclic 的访问权限.ainterface 声明接口格式如下:
复制代码代码如下:
inerface 接口名称{
//常量成员;//成员只能是常量.
//抽象方法;
}
由于接口不能实现实例化操作,因此只能借助子类继承接口的形式来实现.实现的格式是:
复制代码代码如下:
Class 子类名 implements 接口名1[,接口名2,接口名3,.....]{
//子类方法体.
}
常用关键字:
1) final:final之意为最终的,最后的.这就以为着通过final 关键字修饰的类和方法都为最终版本.不能被继承,也不能有子类.不能重写,也不能被覆盖.
2) static: 通过static 关键字修饰的成员属性和成员方法称为静态属性和静态方法.静态成员属性和方法不需要被实例化就能直接使用.
静态属性:它属于类本身,而不属于类的任何实例.它相当于存储在类中的全局变量,可以在任何位置通过类来访问.访问格式为:
类名称::$静态属性名称;
如果你要在类内部的成员方法中访问静态属性,那么在静态属性的名称前加上操作符: “self::” 即可.
静态方法:由于其不受任何对象限制,因此可以不通过类的实例化而直接引用类中的静态方法.引用格式如下:
类名称::静态方法名(参数);
如果你要在类内部的成员方法中调用静态方法,那么在静态方法的名称前加上操作符: “self::” 即可.在静态方法中只能调用静态变量,而不能调用普通变量;而普通方法中则可以调用静态变量.
使用静态成员除了不需要实例化外,另一个作用是在对象被销毁后,仍然保留呗修改的静态数据,以便下次调用.
3) clone.对象的克隆可以通过关键字来实现.使用clone对象与原对象没有任何关系,即克隆对象会重新申请一份存储空间来存放原对象内容.格式如下:
$克隆对象 = clone $原克隆对象名称;
克隆成功后,他们的n成员方法,属性以及值完全相等.如果要对副本重新初始化,就要用到 _clone().
魔术方法_clone()可以对克隆后的副本对象重新初始化.它不需要任何参数,其中自动包含$this (副本对象)和 $that (原对象) 对象的引用.
对象的比较:
“==” 表示比较两个对象的内容,“===”表示比较两个对象的引用地址相等.
对象类型的检测: instanceof 操作符可以检测当前对象属于那个对象.
面向对象---常用魔术方法:
以上我们已经了解的常用魔术方法有:_construct(),_destruct(),_clone.下面我们再接着介绍几个常用魔术方法.
_get(),_set();
以上两个方法用于对私有成员精细复制或者获取值的操作.
_set()在程序运行中为私有的成员属性设置值,它不需要任何返回值._set()方法包括两个不可省略的参数:变量名和变量值.这个方法不需要主动调用,可在方法钱加上prive关键字.
_get():在程序运行中,在对象的外部获取私有成员的属性的值.他有一个参数:私有成员属性名称.他返回一个允许对象在外部使用的值.此方法同样不许主动调用.
_isset(),_unset():
isset()函数用于检测变量是否存在.而在面向对象中可以通过isset()函数对公有的成员属性进行检测,但对私有成员属性,此函数则不起作用.因此,_isset()函数正是为了起到此作用而创建.格式如下:
bool _isset(string name);
_unset()则同样为了删除制定的变量和对象的私有成员属性.格式如下:
void _unset(string name);//
_call():
_call()方法的作用是当程序试图调用不存在或不可见的成员方法时,php会先调用_call()方法来存储方法名及其参数(方法名和方法参数).其中方法参数是以数组的形式存在.
_toString()方法:
其作用是当使用echo 或者print输出对象时,将对象转化为字符串.
如果没有_toString()方法,直接输出对象时将会发生致命错误.
输出对象时应注意的是,echo 或print 语句后面直接跟要输出的对象,中间不要加多余的字符,否则_toSting()将不会被执行.
_autoload()方法:
将一个独立的,完整的类保存到一个php页中,并且文件名和类名保持一致,这是每个开发人员都需要养成的良好习惯.这样下次在使用的时候就能够轻松的找到它.但有一种情况:如果要在一个页面中引进很多的类,就需要使用include_once()函数或者require_once()函数一个个地引入.php5中引入_autoload()方法可以自动实例化需要使用的类.当一个类还没实例化时,_autoload()会自动到指定的路径下面自动查找和类名相同的文件.找到则继续执行,否则报错.
复制代码代码如下:
function _autoload($class_name){
$class_path = $class_name.'.class.php';
if(file_exists($class_path)){
include_once($class_path);
}else{
echo '类不存在或者类路径错误';
}
}
$class = new Class(); //将会自动加载.
echo $class; //输出类内容.如自定义了_toString()方法;则会输出_toString()中定义的内容.
?>
[php面向对象面试题]
篇8：笔试题面向对象
操作系统
1请解释下列10个shell命令的用途
top、ps、mv、find、df、cat、chmod、chgrp、grep、wc
2、写出下列服务的用途和默认端口
ftp、ssh、http、telnet、https
面向对象
1、写出php的public、protected、private三种访问控制模式的区别
2、写出下列程序的输出结果
class a{
protected $c;
public function
a(){
$this ->c=10;
}
}
class b extends a
{
public function print_data(){
return
篇9：笔试题面向对象
一、选择题：（每题3分，共20题）
1. 下面关于类的说法错误的一项是（ ）。
A、类属于Java语言中的复合数据类型 中的基本结构单位
C、类是同种对象的集合和抽象
2. 如下所示代码：
public class Test05_01{ }
private float a;
public static void m ( ){ }
D、类就是对象 B、对象是Java语言
如何使成员变量a被方法m( )访问（ ）。
A、将private float a改为public float a
B、将private float a改为static float a
C、将private float a改为protected float a
D、将private float a改为float a
3. 下面关于类的说法有误的一项是（ ）。
A、类就是对象 抽象
C、类属于Java语言中的复合数据类型 中的基本结构单位
D、对象是Java语言
B、类是同种对象的集合和
关于Java面向对象的考试题。
4. 下列哪种类成员修饰符修饰的变量只能在本类中被访问（ ）。
A、protected
B、default
C、private
D、public
5. 下面关于方法的说法不正确的一项是（ ）。
A、类的私有方法不能被其他类直接访问。
B、Java中的构造方法名必须和类名相同。
C、方法体是对方法的实现，包括变量声明和合法语句。
D、如果一个类定义了构造方法，也可以用该类的默认构造方法。
6. 下列程序的运行结果是（ ）。
public class Test05_02 extends x{ }
B、编译错误
D、运行成功，但不输出
int ab{ }
public static void main(String[] args) { }
Test05_02 b = new Test05_02 (); b.ab(); static int a = 10; a++;
System.out.println(a);
A、10 C、11
关于Java面向对象的考试题。
7. 下面关于构造方法的描述有误的一项是（ ）。
A、构造方法必须要有返回类型的声明。
B、构造方法和类中的方法很相似：有访问修饰符、方法名、参数列表、方法体。
C、构造方法当成是一个特殊的方法，这个方法的作用就是用来产生一个类的实例。
D、构造方法的方法名必须和类名完全相同。
8. 下列关于对象的说法错误的一项是（ ）。
A、对象成员是指一个对象所拥有的属性或可以调用的方法。
B、由类生成对象，称为类的实例化过程，一个实例可以是多个对象。
C、在创建类的对象时，需要使用Java的new关键字。
D、在Java中要引用对象的属性和方法，需要使用“.”操作符来实现。
9. 类的方法可以不包含下面哪一项（ ）。
A、方法的参数 C、方法的名称
B、方法的主体 D、方法的`返回值类型
10. 下面关于变量说法错误的一项是（ ）。
A、对于成员变量，我们可以不需要手动的显式初始化，因为系统在创建一个新的对象的时候，会给这些成员变量赋一个初值。
B、对于引用变量，它的默认初值是null而非相应的引用类型对象，也就是说，它并不是指向任何对象的首地址。
关于Java面向对象的考试题。
C、系统会对全局（成员）变量指定默认的值，也会对局部变量赋值。
D、局部变量在使用之前，必须对其进行显式初始化。
11. 下面的各种数据类型的默认初始化值表示错误的一项是（ ）。
A、int是0
B、float 是0.0
C、char 是‘u0000’
D、boolean是false
12. 下面哪一项不是Java的访问控制符（ ）。
A、public
B、private
C、void
D、protected
13. Java语言类间的继承关系和接口间的继承关系分别是（ ）。
A、单继承、不能继承
C、多重继承、单继承
B、多重继承、不能继承
D、单继承、多重继承
14. 如果局部变量和成员变量同名，如何在局部变量作用域内引用成
员变量（ ）。
A、不影响，系统可以自己区分
B、不能引用，必须改名，使它们的名称不相同
C、在成员变量前加this，使用this访问该成员变量
D、在成员变量前加super，使用super访问该成员变量
15. 下列关于内部类说法错误的一项是（ ）。
A、内部类可用private或protected修饰符修饰
B、内部类不能有自己的成员方法和成员变量
C、除static内部类外，不能在类内声明static成员
D、内部类可以作为其他类的成员，而且可访问它所在的类的成员
16. 定义外部类时不能用到的关键字是（ ）。
A、public
B、abstract
C、protected
D、final
17. 下面说法不正确的一项是（ ）。
A、abstract和final能同时修饰一个类
B、抽象类既可以做父类，也可以做子类
C、声明为final类型的方法不能在其子类中重新定义
D、抽象类中可以没有抽象方法，有抽象方法的类一定是抽象类或接口
18. 有一个类B，下面为其构造方法的声明，正确的是（ ）。
A、void b(int x) {} C、B(int x) {}
B、void B(int x) {}
D、b(int x) {}
19. 区分类中重载方法的依据是（ ）。
A、不同的形参名称
B、返回值的类型不同
D、访问权限不同
C、形参列表的类型和顺序
20. 下面说法错误的一项是（ ）。
A、在Java中，为了节省创建对象的时间和空间，对于一些常用的方法，会将它在内存中缓存起来。
B、在JDK中针对各种基本数据类型分别定义相应的引用类型，称之为封装类（Wrapper Classes）。
C、JDK5.0中，引入了自动装箱/拆箱功能，可以让我们方便的在简单类型和对应的封装类型数据之间转换。
篇10：perl面向对象实例
这篇文章主要介绍了perl面向对象实例,本文讲解了一个类只是一个简单的包、对象仅仅只是引用、一个方法就是一个简单的子程序等内容,并给出了一个简单示例,需要的朋友可以参考下
首先让我们来看看有关 Perl 面向对象编程的三个基本定义：
1. 一个“对象”是指一个“有办法知道它是属于哪个类”的简单引用，(对象就是引用变量)
2. 一个“类”是指一个“有办法给属于它的对象提供一些方法”的简单的包。（类就是包）
3. 一个“方法”是指一个“接受一个对象或者类名称作为第一个参数”的简单的子程序。（类的方法就是第一个参数为类名或对象的方法）
一个类只是一个简单的包
和 C++ 不同，Perl 并不为类定义提供任何特殊语法。实际上类只是一个包而已。你可以把一个包当作一个类用，并且把包里的函数当作类的方法来用。不过，有一个特殊的数组，叫做 @ISA，它说明了“当 Perl 在当前包中找不到想要的方法时，应当继续从哪儿去找”。这就是 Perl 实现“继承”的关键。@ISA中的每个元素都是一个别的包的名字。当类找不到方法时，它会从 @ISA 数组中依次寻找（深度优先）。类通过访问 @ISA 来知道哪些类是它的基类。
所有的类都有一个隐含的基类（祖先类）：“UNIVERSAL”。“UNIVERSAL” 类为它的子类提供几个通用的类方法。它提供以下几个方法：isa,can。其中isa用来判断变量是否从某个类继承而来，can后面的参数则是一个方法，判断这个方法是否在这个类或者基类中被定义。另外你可以给UNIVERSAL添加新的方法。一旦给它添加了新的方法，所有的class都可以调用。
给UNIBERSAL添加新方法的例子：
代码如下:
sub UNIVERSAL::log()
{
my($self,$msg)=@_;
print “$self: $msg\n”;
}
这样就可以在每个类中调用这个函数，并且log之前会把类名打印出来。
对象仅仅只是引用
Perl中的构造器只是一个子程序，该子程序返回一个被bless处理的引用，这个经过 bless 处理的引用就是人们所说的“对象”，而 bless 的作用就是用来说明这个对象是隶属于哪个“类”。
最简单的构造器：
代码如下:
package Critter;
sub new { bless {} }
如果你希望用户不仅能够用 “CLASS->new()” 这种形式来调用你的构造函数，还能够以 “$obj->new()” 这样的形式来调用的话，那么就这么做：
代码如下:
sub new {
my $this = shift;
my $class = ref($this) || $this;
my $self = {};
bless $self, $class;
$self->initialize();
return $self;
}
一个方法就是一个简单的子程序
方法把它被调用时的对象或者类名称当作它的第一个参数。有两种不同的调用方法的途径，分别成为“调用类方法”和“调用实例方法”。类方法把类名当作第一个参数。它提供针对类的功能，而不是针对某个具体的对象的功能。构造器通常是一个类方法。大多数类方法简单地忽略第一个参数，因为方法知道自己处在什么类里面，也不关心它是通过什么类来调用的。
Perl 提供了两种不同的形式去调用一个方法。最简单的形式是采用箭头符号：
代码如下:
my $fred = Critter->find(“Fred”);
$fred->display(“Height”, “Weight”);
你可以早就熟悉了引用的 “->” 操作符。事实上，因为上面的 $fred是一个指向了对象的引用，因此你也可以把箭头操作符理解为另外一种形式的解引用，
出现在箭头左边的引用或者类名，将作为第一个参数传递给箭头右边的方法。所以上面的代码就分别相当于这样：
代码如下:
my $fred = Critter::find(“Critter”, “Fred”);
Critter::display($fred, “Height”, “Weight”);
简单示例
1、说明
本程序演示了在Perl中如何进行面向对象编程：演示程序包含两个文件：person.pl 和 person.pm，把 person.pl 和 person.pm 放在当前目录下，运行“perl person.pl”即可以看到结果。person.pm定义了名为person的类。person.pl中创建了person类的实例，并测试了person的成员方法。
2、person.pm的内容
代码如下:
#!/usr/bin/perl -w
package person;
use strict;
sub new {
my $class = shift();
print(“CLASS = $class\n”);
my $self = {};
$self->{“name”} = shift();
$self->{“sex”} = shift();
bless $self, $class;
return $self;
}
sub getName {
my ($self) = @_;
return $self->{“name”};
}
sub setName {
my ($self, $name) = @_;
$self->{“name”} = $name;
}
sub getSex {
my ($self) = @_;
return $self->{“sex”};
}
sub setSex {
my ($self, $sex) = @_;
$self->{“sex”} = $sex;
}
3、person.pl的内容
代码如下:
#!/usr/bin/perl -w
use strict;
use person;
sub main()
{
my $tom = person->new(“Tom”, “male”);
my $kiss = person->new(“Kiss”, “female”);
my @persons = ($tom, $kiss);
for my $p (@persons) {
printf(“NAME: %s\tSEX: %s\n”, $p->getName(), $p->getSex());
}
}
&main();
4、程序运行结果
代码如下:
CLASS = person
CLASS = person
NAME: Tom SEX: male
NAME: Kiss SEX: female
【Flash ActionScript2.0面向对象游戏开发】相关文章：
2.IOS 开发学习总结 objectivec面向对象之――类和对象（下）
4.游戏开发简历表格
10.开发右脑的六个亲子游戏
文档为doc格式
