关于类的：女娲造人 - 达人(yitu)

2005/10/13 | 关于类的：女娲造人
类别(flash As) | 评论(0) | 阅读(308) | 发表于 16:52: /*前言:相信大家都听说过女娲造人的故事，不过细节可能不会太清楚，我现在略述如下，您可要仔细听哦，这和我们今天要聊的主题有莫大的关系呀。

女娲是一个人身龙尾的女神。盘古开天辟地以后，也就在天地间到处游历。她虽然是神，可是也会寂寞的，望着平静的水面里自己美丽的倒影不胜唏嘘。于是她便决定按照自己的形貌来捏泥人。女娲心灵手巧，不一会儿就捏好了好多的泥人。这些泥人几乎和她一样，只不过她给他们做了与两手相配的双腿，来代替龙的尾巴。女娲朝着那些小泥人吹口气，那些小泥人便被灌注了活力，“活”了起来，变成了一群能直立行走、能言会语、聪明灵巧的小东西，女娲称他们为“人”。女娲在其中一些人身上注入了阳气——自然界一种好斗的雄性要素，于是他们就成了男人；而在另外一些人身上，她又注入了阴气——自然界一种柔顺的雌性素，于是她们便成了女人。女娲想让人们遍布广阔的大地，但她累了，做得也太慢了。于是，她想出一条捷径。她把一根绳子放进河底的淤泥里转动着，直到绳的下端整个儿裹上一层土。接着，她提起绳子向地面上一挥，凡是有泥点降落的地方，那些泥点就变成了一个个小人。女娲就这样创造了布满大地的人们。

这个故事可谓是蕴涵了极深刻的程序语法规则，大家看完我下面的分析后，一定会相信故事的作者没准是远古时代的程序员呢!

<代码看起来很长，是我加了详细的注释的缘故>

1、类:如果女娲属于一个类的话，可以称之为"神"。代码表示为:
--神.as开始--

[code]
*/
class 神{
//class :定义'类'的关键字,描述一组具有共性的对象的特征
static var 类别:String="神";
//static:定义'类变量'或'类方法'的关键字,它描述一组类的整体属性或方法。在这里表示，所有的神的都可称为"神"。
static var 所属:Object =神;
//表示神归谁管啦，中国远古的神好象没有什么附属关系哦。
public var 善恶:String;
//public :定义'公开'属性或方法的关键字，它描述类的可以供外部对象访问的属性或方法。
private var __姓名:String;
//private定义'私有‘属性或方法的关键字,它描述类的需要封装的属性或方法,表现为它定义的变量或方法只可以被类或子类内部的方法访问(调用).
//下面会详细说明用private的理由的.
private var __形体:String;
//在变量名字前加"__"仅标志它是具有获取/设置方法的属性.
private var __性别:String;
public function set 姓名(n:String):Void{
//set:动作脚本 2.0中隐式设置类相关属性的关键字.下面会详细说明
__姓名=n;//类内部的方法可以访问私有属性'__姓名'
}
public function get 姓名():String{
//get:动作脚本 2.0中隐式获取类相关属性的关键字.下面会详细说明
var n:String="伟大的神"+__姓名;//类内部的方法可以访问私有属性'__姓名'
return n;
}
public function set 形体(x:String):Void{
__形体="神奇的"+x;
}
public function get 形体():String{
return __形体;
}
public function set 性别(n:String):Void{
if(n=="男"||n=="女"){
__性别=n;
}
}
public function get 性别():String{
return __性别;
}
function 神(sh:String,n:String,x:String,s:String){
/*构造函数,是连接类和实例的纽带,它接受外部设置的参数,对即将生成的实例进行初始化.它的表现就是名称与包含它的类的名称相同.其实我真的认为...它可以比喻为'子宫'的.. sh:善恶,n:姓名,x:形体,s:性别   */
善恶=sh;//为善恶属性直接赋值。
姓名=n;//调用'set 姓名'方法为'__姓名'属性赋值。
形体=x;//调用'set 形体'方法为'__形体'属性赋值。
性别=s;
//调用'set 性别'方法为'__性别'属性赋值，在赋值之前会先判断s是否为'男'或'女'。//对赋值进行必要的控制，是隐式设置属性的一个优势。
}
public function 寂寞():Void{
trace("\"自己好孤单啊，有个人陪陪我多好啊!\"");
}
public function 创造(o:String):Object {    //o:创造的目标
if(o=="人"){
var 泥人=捏泥人();
var 气=["阳","阴"];
var r=Math.floor(Math.random()*2);//得到一个随即数字,或0或1
var 随即气= 气[r];
var 人=吹口气(泥人,随即气);//类内部的方法可以调用'私有'方法'吹口气'命名(人,"人");//女娲称他们为'人'...
return 人;
}        //if ... 当然神还具备其它的创造本领，这里略~
}
public function 捏泥人():Object {
trace("捏泥人...");
var 泥人=new Object();
泥人.形体="人身人腿";//据上面神话所述，女娲是'人身蛇尾'...
trace("一个泥人制作完毕!");
return 泥人;
}
public function 命名(o:Object,n:String){
//o:待命名的对象,n:名称
o.类别=n;
trace("一个人诞生了!");
}
private function 吹口气(o:Object,s:String):Object{
//o:泥人,s:气     //这个方法确实是神私有的方法啦，我一直都不理解的，如果能吹口气吹出银子来...
    trace("吹口气...");    //--泥人具有了以下本领--
o.直立行走=function(){
trace("打架摔交中...");
}
trace("泥人学会直立行走!");
o.能言会语=function(){
trace("谈情说爱中...");
}
trace("泥人学会语言!");
o.聪明灵巧=function(){
trace("坑蒙拐骗中...");
}
trace("泥人学会思考!");    //呵呵
if(s=="阴"){    //如果注入的是阴气
o.性别="女";
}else if(s=="阳"){
o.性别="男";
}    //else if 又阴又阳 then 人妖~~
trace("泥人性别是"+o.性别+"!");
trace("泥人具备了灵魂!");
return o;
}

}

/*--神.as结束--

到这里我们的"造神运动"就告一阶段了，该看看我们的神的威力啦！

--女娲造人.fla开始--*/

//在第一桢上写代码:
var 女娲=new 神("善","女娲","人身蛇尾","女"); //new:生成实例的关键字，它先创建一个初始时匿名的新对象，再用构造函数设置新对象的特性， //最后返回新对象的内存地址。在这里新诞生的'神'的内存地址赋给了'女娲'变量。
trace(女娲.姓名+"是一位"+女娲.形体+女娲.性别+神.类别); //调用女娲的'get 姓名'方法,返回'伟大的神女娲'。对返回的属性值进行必要的控制，是隐式获取属性的一个优势。 //比如，你的老板叫张三，却常被称为'张总'，这也是经过必要的控制之后得到的结果。 //'张三'这个名字只有他的自己人才使用哦！所以说生活中有很多事情也可用'私有属性'来解释的~
trace("她是"+女娲.善恶+神.类别); //直接返回女娲的善恶属性值。
trace("一天,她觉得"); 女娲.寂寞();
trace("于是,她开始"); 女娲.创造("人");

/*--女娲造人.fla结束--

现在测试一下吧，看看会产生什么惊天动地的大事吧!

--测试影片开始--
伟大的神女娲是一位神奇的人身蛇尾女神
她是善神
一天,她觉得
"自己好孤单啊，有个人陪陪多好啊!"
于是,她开始
捏泥人...
一个泥人制作完毕!
吹口气...
泥人学会直立行走!
泥人学会语言!
泥人学会思考!
泥人性别是男!
泥人具备了灵魂!
一个人诞生了!
--测试影片结束--

--女娲造人.fla 开始--

*/
var 女娲:神=new 神("善","女娲","人身蛇尾","女");
trace(女娲.姓名+"是一位"+女娲.形体+女娲.性别+神.类别);
trace("她是"+女娲.善恶+神.类别);
trace("一天,她觉得");
女娲.寂寞();
trace("于是,她开始");
var 原始人:Object=女娲.创造("人"); //将创造出来的"人"赋值给变量'原始人',以后就可以通过'原始人'访问他的属性与方法。
trace("----原始人开始展示自己的才能----");
trace("原始人是"+原始人.性别+原始人.类别);
trace("原始人的形体是"+原始人.形体);
trace("原始人会直立行走，现在他(她)在:");
原始人.直立行走();
trace("原始人能言会语，现在他(她)在:");
原始人.能言会语();
trace("原始人聪明灵巧，现在他(她)在:");
原始人.聪明灵巧()

/*
--女娲造人.fla 结束--

我们人的表现如何呢?现在测试一下:

--女娲造人.fla 测试开始--

伟大的神女娲是一位神奇的人身蛇尾女神
她是善神
一天,她觉得
"我好孤单啊，有个人陪陪我多好啊!"
于是,她开始
捏泥人...
一个泥人制作完毕!
吹口气...
泥人学会直立行走!
泥人学会语言!
泥人学会思考!
泥人性别是女!
泥人具备了灵魂!
一个人诞生了!
----原始人开始展示自己的才能----
原始人是女人
原始人的形体是人身人腿
原始人会直立行走，现在他(她)在:
打架摔交中...
原始人能言会语，现在他(她)在:
谈情说爱中...
原始人聪明灵巧，现在他(她)在:
坑蒙拐骗中...

--女娲造人.fla 测试结束--

看到测试结果，你的感受如何呢？这个这个嘛，还是'人之初，性本恶'吧？

废话少说，言归正传。话说女娲想让人们遍布广阔的大地，但象她这样一个一个捏制下去希望实在渺茫啊。而且我们也看到了，其实每个泥人的样子虽然各不相同，但灵魂却是相似的，都是女娲的一口气使然。如果每个人都需要从女娲那里来那么一口，不把女娲累死也得元气大伤吧!那么女娲该怎么办呢?传说里说女娲拿了根绳子甩啊甩的就造出了很多人，看来得从这根'绳'子着手了.

这根绳子如此不一般，我认为是女娲把造人的模版倾注其中的结果。传说里又说，女娲是'按照自己的行貌'造的人，可以肯定'人'一定是从神那里继承了不少的特性吧。

--人.as开始--*/

class 人 extends 神 { //extends:定义类与类之间继承关系的关键字,子类对父类的特性可以保留或扬弃。
static var 类别:String = "人";
static var 所属:Object = 神;   //看到没，人是归神所管的哦
static var 气:Array = ["阳", "阴"];
static function 设置性别():String {
    var 随即气 = 人.气[Math.floor(Math.random()*2)];
if (随即气 == "阴") {
return "女";
} else if (随即气 == "阳") {
return "男";
}
}
public function set 形体(x:String):Void {
//毕竟人和神的形体有很大的不同，神的形体千变万化，   //人的形体却大体是相似的，所以子类重写了父类的 'set 形体()'方法.   //x:形体的状况,如是怎样的身材等等

if (x == undefined) {
x = "平常";
}     //如果没有提供'形体'的详细描述,那么用默认值'平常'。     __
形体 = x+"人体";
}
public function get 形体():String{
//这个方法有点奇怪,本来应该直接继承就可以了，但却不得不再写一遍,原因不明。或者set 与 get 要配对出现?
return __形体;
}
function 人(x) {
//人的诞生无法和神相比啦，重写构造函数   //x:形体   //与神相比，人的构造函数只有'形体'一项参数,因为人的善恶跟后来的成长过程有关，   //性别由自然规则来定，姓名是后来由别人给命名的...只有身体是与天俱来的   //善恶=undefined 这里写出来，是提醒大家善恶现在其实是undefined的    //姓名=undefined
形体 = x;
性别 = 人.设置性别();     //调用类方法来初始化性别
trace("人诞生了!");
}   //下面的是继承来的方法
public function 寂寞():Void {
//寂寞者，人神皆然。不过'人'对'神'的寂寞有所拓展
super.寂寞();     //super:指向父类对象的关键字,因为'人'与神的寂寞有相同的地方，所以这里先调用'神'的‘寂寞’方法。
trace("哪怕是陪我聊聊天也行哦!");     //神会把'寂寞'转化为'创造',人却把'寂寞'转化为'有聊'~~
}
public function 创造(o:Object):Object {   //人是没有神那么伟大的创造力...重写'创造'方法
if (o == "火") {
var o = new Object();
o.名称 = "火";
o.烤 = function(oo:Object) {
trace(oo+"烤熟了!");
};
trace("发明钻木取火！");
return o;
}     //其他的创造能力...略   }   //public function 捏泥人()... 人和神的 ‘捏泥人’没啥区别，完全继承之
public function 吹口气(o:Object) {
//由私有方法成为公有方法   //唉,一般来说子类对父类的功能都是有所拓展或增强的,唯独由神到人有点特别呀，   //拓展的只是些皮毛无聊的小功能，象这‘吹口气’的大本领就没继承来!要是吹口气吹出银子来...
if (o == undefined) {
//如果无东西可吹
trace("哎,这觉睡得好长啊");       //等于是打个哈欠吧
} else if (o == " 蜡烛") {
trace("蜡烛灭了");       //吹吹蜡烛~
} else if (o == this) {     //this:表示对象自身的关键字。     //如果吹的对象是自己
trace("哪里哪里，我也是略懂一二...你有什么要请教的?");       //唉，我也难免吹吹自己的~
} else if (o instanceof 人.所属) {     //如果吹的对象是人类的主宰的话
trace("爹亲娘亲没有"+o.姓名+"亲!");       //得 ,这又是在拍了~
}
}   //下面是人自己的方法
public function 直立行走() {
trace("打架摔交中...");
}
public function 能言会语() {
trace("谈情说爱中...");
}
public function 聪明灵巧() {
trace("坑蒙拐骗中...");
}
}
/*
[/code]
//--人.as结束--

现在"造人运动"也告一段落了，让我们看看收效如何吧:

--女娲造人.fla--
(在原代码后附加)
[code]
*/
var 远古人=new 人("美丽的"); 远古人.姓名="远古人"; //为实例自己的姓名属性赋值
远古人.打猎=function(o:String):Void{
trace("射杀一只"+o+"!");
}
//为实例定义自己的方法
trace("----远古人开始展示自己的才能----");
trace(远古人.名字+"是"+远古人.性别+人.类别);
trace(远古人.名字+"的形体是"+远古人.形体);
远古人.寂寞();
trace("远古人会直立行走，现在他(她)在:");
远古人.直立行走();
trace("远古人能言会语，现在他(她)在:");
远古人.能言会语();
trace("远古人聪明灵巧，现在他(她)在:");
远古人.聪明灵巧();
远古人.捏泥人();
远古人.吹口气();
远古人.吹口气("蜡烛");
远古人.吹口气(远古人);
远古人.吹口气(女娲);
远古人.打猎("鹿");
/*
[/code]
--女娲造人.fla 结束--

如果你想要看看这位远古人的表现如何，不妨自己测试。到此为止，我们的故事就快讲完了。女娲现在造人就非常简单了，只需要"new 人()"就可以了，再不用捏个泥人吹口气了。如果精神充沛的话就"new 人('健康的')"，如果体力不支的话就"new 人('软弱的')"。如果你了解Action 1.0语法的继承机制的话，一定知道类中的实例方法是写在类的"prototype"(即原型)上的，这样可以实现由类创建的实例共享相同的方法。在我们刚才创建的类中，由"public"或"private"关键字修饰的方法其实也是写在"prototype"上的。所以说，现在女娲不再需要在每个"人"身上都定义一遍"方法"，也就是对每个人都"吹口气"了。

*/; 0

http://yitu.5d.cn/

评论Comments