经常说面向对象，到底什么是面向对象呢？

Question

to highnice:不懂你说的，什么是高级点？

Answer 1

我的理解：
面向对象就是封装，多态，继承等等一些特性；
举个例子：
    假设你要实现一个写日志的功能，如果不采用面向对象，
    你可能设计一个函数如下：
    function WriteLog( sFileName, sLogText: string ): Boolean;
但是假设你用面向对象来思考，应当是实现一个类，这个类
叫TFileLog(叫别的名字当然也行），它至少应当有一个方法：
  WriteLog;
在此基础上它应当还有些属性：
  Property FileName: string read FsFileName write FsFilename;
等等。
当你只需要实现一个功能（用一个函数就可以实现）的时候，
还看不出面向对象的好处，但是假设你的任务很复杂，
需要一组函数来实现，而且各个函数之间的参数传递很多，很繁琐，
用传统的，应当是定义一个函数级，然后分别调用，但是
采用面向对象，就可以将这些东西 封装到 某个类当中。
这个类提供一些方法，能够比较方便的给用户使用，至于复杂的操作
则在类的内部实现。并且一些参数，也可以成为的属性。啊，说了这么多，只说到了一点点。
其实，还有继承，多态等内容，Delphi带的源码很多，多看看。

Answer 2

对象就是你口袋里面的钞票，你不会让我知道你到底有多少，但是可以通过两个操作来改变它，1：你给我
2：我给你或者你觉得它不是个秘密，那么当别人问你的时候，你也可以告诉他：我又XXX大元，哈哈哈，开个玩笑哦～～～

Answer 3

这是封装性，再来说说其他，有一天，你碰到一个漂亮MM，然后你们在一起，有了你们的子类那么，这个Baby有些别人没有的特权，
比方说，他能看到你口袋里有多少钱，不经过你，自己直接就可以取，不过，要是你特别扣，连这点权利都不给他的话，这点钱就真的是你的私有变量了（Private）但是，有一天你发现一个Baby太孤单了，于是又领养了一个，
然而，多多少少你总有点偏心，给亲生的多了点，给抱来的少了点，于是，亲生的可以直接从你口袋里拿钱，抱来的就一定要经过你的批准，那么，这就是继承的方法不同，一个是嫡系，另一个则是，呵呵，后娘养的。

Answer 4

to ：Nicrosoft(奈软)　哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈，我眼泪都笑出来了。
不过你这样说又不告诉人家答案。呵呵，过分。

Answer 5

忽然兴头来了，再说几句，刚才那叫继承，随着时间的推移，你发现让不同的Baby用不同的取钱方法，变得越来越不合适，一方面，你自己
要时刻牢记对谁用什么方法，另一方面，不过是取钱这件事，其他的事情也多起来，让你烦不胜
烦了于是，你决定采用另外的一种方法，

Answer 6

我门小组一直接受台湾软体公司的 OOP 培训，我在Smiling 的 UML 小组上有个实作模型--“我尝试实作一个OO系统”，你可以看看传统的 Data Aware 方法与 OO 方法的差异。有公司招人麽，我们小组与老板闹翻了，正在失业，呜呜……

Answer 7

下面是我以前发的，看看有没有用：
以下为“废话”：    从头说起！    汇编语言称为低级语言，其语句与计算机的指令一一对应，而计算机的功能是根据实际的电路来确定的，功能已经不再细分，它很多时候跟人的思维逻辑不一样，因此编程人员需要花精力将自己的思维逻辑分解成计算机的一个个具体指令的代码，这样很麻烦，也很浪费时间。    后来出现了高级语言，高级语言的书写规范比较符合人的思维习惯，人们将自己的逻辑想法用高级语言来表示写成文档，再执行编译程序。    继高级语言后有出现了面向对象的语言。它们的特点是：在高级语言的基础上进一步提升，它们定义的语言书写规范已经不仅仅停留在简单逻辑思维的层次，而是设计了将逻辑思维的流程分类、分组、独立封装等很多新特性的“面向对象”模型。即，将人的思维逻辑流程进行归纳、分类、汇总，是一种结晶。
    它将事物的各种性质归类统一，包装成独立对象，再以对象为单位来对其进行使用。以下可能也是“废话”：
    一个对象（应该叫对象模型），可以包含各种属性（譬如：躯体+会送秋波的眼睛）、方法（伸手不三不四）、触发事件（被打了一嘴巴还想还手，打不过就背地里骂人）等。好了，具有这一系列性质的对象模型被描述完毕了。但是，电脑里找不到他？？！    创建实例是指根据上面的基因描述，在内存里给他们分配空间，一下子可以复制出多个这样的家伙！他们都有“会送秋波的眼睛”，都会“伸手不三不四”、“被打了一嘴巴都想还手，打不过都背地里骂人——妈妈的！”。
    他们的基因被称为鸡肋（“基类”）——食之无味，弃之可惜，简直“阿Q”一个！
    天哪！转基因技术真是太可怕了！有人利用以上基因改造出了新的基因。    而新的基因又出了BUG——还有尾巴！！甚至有不道德的人还在电脑里创建了他的实例。“老Q”居然有了“后人”，只可惜多了条尾巴！而这新兴人类的基因被称为“子类”——“继承”而来的。    唉！真是“屎壳郎下仔”——“一代不如一代”，第三代的基因又被改造了，他们的背上又多了一副肘子，没有接胳膊，暂时悬空。
    悬空肘子又分两种，一种可以即插即用，内置各种驱动程序列表VMT，称作“虚拟”的肘子。另一种没有这个表，使用新部件比较麻烦，称为“动态”的肘子！
    这第四代就兴旺啦！因为新肘子上有新东东啦！称为虫灾“重载”。    普通的有长胳膊的，稍微厉害的有长螃蟹钳子的，有长蚂蚱翅膀的，离奇的还有长螺丝刀加老虎钳的，如此种种。而且，细致的朋友可以发现，“虚拟肘子”动起来要比“动态肘子”快一点点......    如此悲哀！怎能下笔再写！实在不忍，就此打住！    ——“救救孩子们吧！”

Answer 8

enlightenment(阿明)的解释很形象，但没说明“虚基类”、“多态”、“vtable”等概念，希望你在详细一些。
另外，如果一个类里嵌套了多层类，如何用程序表达？比如：
class 家庭
{...
   男人 张斌
   女人 林芳
   家具 ...
   轿车 ...
   .......
}
class 男人
{
   皮肤 .....}
class 皮肤
{
   .....}........类里头一层一层地嵌套了好几层类（真够复杂的），这些内嵌的类，又继承了它们的父类，如果用程序如何表达它们之间的关系(我的头都搞晕了）。在delphi程序里经常可以看到a.b.c.d.e之类的东西，是类的嵌套吗？能不能以家庭这个大类，嵌套了好几层小类为例给我做个说明。我想很多面向对象的初学者都想听的，希望高手们解释的详细一点、形象一点，谢谢了！！

Answer 9

对我而言，面向对象只是说让我们实现某个功能的时候，调用的时候思路明确一点，
如A类实现1功能，B类实现2功能，那在我的类中就声明A，B的对象，然后只要调用A和B相应的方法和属性，就可以达到在类A，B中的它们各自封装的功能了，我们不能去管它，如果你想了解，再看也不迟，
就像label1.Caption :='hello world';
我们是不用去管VCL的实现，只要知道它实现什么就行了。

Answer 10

接上文（称《呐喊》篇吧），    饿补湿稿兽，饿缴的饿湿个傻鸟、老鸟、菜鸟，姿以尾师帝傻、佬、菜--鸟。温匹爱采石稿兽（陕音）。
    下面说点正经的（姑且先就叫《彷徨》篇吧，但要比上一篇要枯燥的多，部分内容为引用，就不注明出处了）：
    （以下内容均为个人观点，文中难免有错，或本人大言不惭、信口开河，敬请指正；如果，您要是觉得还不错，还请多多提携、比如转贴啦、多给我介绍介绍几个XX什么的！“美-女-？！！！唾-！-！-！-！”“ 嗳！我只不过说“朋友”二字啦！嗤！就当我什么都没说！！！又一个不解风情的少年！”）    还是“从头说起”，首先将谈点别的东西和Delphi的一点特性，对（对象）的具体表述的Delphi事例将引用sxyid(kyong)举的例子，不过会在稍后一点。言归正传：    我认为面向对象的出现和发展不仅仅是“调用时明确一点”这样的好处。这样认为可能只是出于对它的感性的认识（我并无意夸大）。    在我所知道的，面向对象的精髓应该归为方法论的一种，就象以前所学习的“结构化分析与设计”是一种方法论一样（还有信息建模方法论等）。（上面有人说面向对象是世界观，我不敢苟同，也没有试过，但我想若是那样会很恐怖！因为它毕竟还不是足够的人性化。）简单点，面向对象应该就是一种设计思路。    她较其它方法论自然有他的特色了，这里仅列出一般方法论相对她的弱处：
    1、多数方法论为信息系统建立了分离的信息和功能的模型，他们各自描述了系统的一部分，而面向对象模型是一体的。
    2、一般方法论论难于将系统分析过渡到程序设计，而面向对象方法论可以做到平滑过渡。    它的主要目的应该是简化和合理化的进行系统分析和程序设计（其实程序设计、包括详细设计很难说是否属于系统分析的行为）。    各种面向对象语言对它的支持是为（用面向对象方法论设计的）程序提供实现，表示该语言有这个能力。各种（用面向对象语言编写的）程序是不是使用了该方法论呢？    事实上现在很多情况就是用（面向对象的程序设计）语言实现（[低级的或其它类别的]方法论的）设计。这样不能说一定不会成功，但成功一般将归功于某个“英雄人物”，如果是大型项目，那么评价只有一句--他很“牛X”，但是这个工程很可能是不稳定或存在难于维护、升级等诸多后遗症。    具体的程序是否在设计上完全应用它，同时在一些细节上是否有必要这样做，很难说。比如某个复杂的功能包含许多部分，但是否将这些部分都归为类的函数呢？譬如存在一个只用一次的特定排序，它几乎和类定义毫不相干，作为类的方法只会带来麻烦...    （个人见解）：用JAVA设计，你必须严格构建类，一点点小功能也必须构建类（或对象模型）；C++给我的感觉是很厉害，不过，可能会“乱”，用小说的语言，若无名师（这个名师应该就是方法论）指点可能会走火入魔，“天才与傻瓜仅一线之差”。    而若使用Delphi，我觉得它本身就充当了1/3个名师了：缘何如此呢？Delphi提供了几个层次的封装（我归纳不全）：1、类封装：同其它面向对象语言相似（后面有细述）；2、单元封装，仔细看看Delphi的单元声明：Unit Xxxxx;interface //对外部单元的接口部分uses //本单元使用到的其它单元名称
     //注：Delphi中的use与C++中的include有所不同，
     //在编译当前单元文件时，
     //仅将（（use包含的）单元的）interface部分添加到当前的编译单元，
     //而没有实际地立刻编译引用单元的implementation部分consttypevar  //单元全局变量声明//此处为分界线--------------------------------------------
implementation //内部实现部分usesconsttype var //单元全局隐含变量声明//etcinitialization //单元构造期后初始化finalization //单元销毁期前预销毁end;
        单元包含interface和implementation两部分，其中Interface部分的为和外部单元交互的接口（包括常量、变量、类型、使用单元等），具体的实现代码和内部使用的常量、变量、类型、使用单元在implementation部分--实现部分，这是在除了类封装的又一层模式化的封装。相比起来，C++的单元（或称文件）封装就显得有点而逊色了。我个人有时侯甚至在用C编写程序的时候都部分套用该形式，直观、简洁（尽管C++的编译器对这样的形式毫无兴趣），当然C的形式，如.h文件等也有它的方便之处。    3、子函数的封装：我使用Delphi也有那么一点点时间了（其实也很短，Delphi出世也没多久嘛）。我越来越觉得在面向对象主流情况下保留（Pascal原有的在函数中包含子函数的）能力是个绝佳的设计。
    按照严格定义来讲，它或许不属于面向对象的格局安排，而我觉得，事实上它省去了许多不必要的麻烦，是面向对象弱点的一个补充。其优点上文已有描述。//主函数
function TXxxx.Xxxx(xxx:Xxx):Xxxx;
//或procedure TXxxx.Xxxx(xxx:Xxx);
const
var
    //子函数----------------------------------
    function TXxxx.Xxxx(xxx:Xxx):Xxxx;
    //或procedure TXxxx.Xxxx(xxx:Xxx);
    begin
      //Implementation
    end;
    //----------------------------------------
begin
  //Implementation
end;（我常常痴呆的、满足的看着那自己写那的“优美”的代码；不骗你，在我写的程序里，注释占到一半，有的还多。）//******************************************************************************
// gene example
//******************************************************************************
    下面是一点实际的关于对象的例子（例子而已，不可能概全，譬如不包括接口的说明，那会使问题变的复杂；再说，我本人也不是专家；另外，这仅是一个局部的简单例子，我也不会详细地描述面向对象分析方法论（也绝对轮不到我来讲），我只是作个简单构建）：
    现在假设以构造一个家庭来分析。应sxyid(kyong)的题目，下面首先说几个引子，不看引子也拉倒：    引子（一）：基因，查查字典或《词霸》，基因的翻译有两个--gene、germ plasm。    我当gene的为抽象的基因，它代表的不是某个简单的实体，而是特定顺序的排列、有着特定规律和性质的组合。germ plasm就是简单的细胞质。    细胞是基因得以实现的载体。细胞由细胞壁、细胞液、细胞核组成，细胞核内是细胞质。细胞质还包括染色体，染色体记录了基因信息。    不管正确予否，暂且这样理解吧！下面可能会有用！
    引子（二）：Delphi中对象和类的基本描述（一）：（本引子可能较晦涩，若不明请参阅相关资料；一个具体的对象是一个具体类的实例）  //下面例程详细代码已经省略，若有兴趣可以自己试试补充完整  TUserClass=class(TCustomControl) //或Tobject或其它派生子类，
  //本例使用TcustomControl,派生类将自动拥有OnClick事件，是为了便于说明
  //Delphi中TObject是所有类的始祖
    procedure ExampleFunction(Sender:TObject);
  private
  //该关键字下的数据和对象方法在在本单元外不能被访问，
  //而C++更为严格，同一单元文件内不同的类亦不可互访，需要使用友元(friend)
    FXxxxx: TuserType;
    Procedure SetXxxxx(const Value: TuserType);
  protected
  //该关键字下的数据和对象方法只能被当前类和子类访问
  public
  //可以被程序代码中的任意部分访问
  //下面为构造函数与析构函数，
  //严格的说应该是构造器(constructor)与析构器(destructor),为什么？
  //因为这两个函数只应用与类而不是对象--它们不属于所设计的对象的具体功能
    constructor Create(Aowner:TComponent);override;
  //override称为重载
    destructor Destroy;override;
  published
  //该关键字作为缺省的关键字，是OOP封装机制的扩充
  //譬如将上面的procedure ExampleFunction(Sender:TObject)写在此处效果相同
  //而该关键字的具体作用是提供一种设计时的可见性，
  //声明的属性一般都是公共元素
    property UserDefine:TuserType read FXxxxx write SetXxxxx;;
  //比如按照如上声明，在Delphi的Object Inspector中将会出现UserDefine属性，
  //又由于由TcustomControl派生，所以该类自动拥有OnClick方法；
  //而这时，下拉Object Inspector的下拉框将会有一个ExampleFunction供选择，
  //因为函数ExampleFunction也缺省的属于published部分的声明
  end;var
  UserClass1: TuserClass;
  //该表达式表示对象(UserClass1)是类(TuserClass)的一个实例的指针（注意是“指针”）；
  //通过指针指向对象是Delphi的对象引用模式
  //初始时指针指向空(nil)，
  //当使用构造器后(如UserClass1:=TuserClass.Create(self);)为对象分配内存空间，
  //该指针则指向实际对象的内存空间的入口处
    引子（三）：Delphi中对象和类的基本描述（二），（关于一些关键字的区别）：//滞后联编和多态，引出了面向对象语言有利于重利用的特质。
//在Pascal中，函数、过程基于静态和初期联编，由编译器或Linker分解方法调用，
//引用函数或过程占用的特定内存位置来代替直接调用
//OOP中允许在运行时确定所调用对象方法的实际地址，称为动态联编或滞后联编
//其引出的优点称为“多态”//基类
TbaseClass=class(TObject)
  //以下为三种配合多态性的基类的函数声明
  // virtual虚拟方法
  Procedure MethodOne(Aparam:integer);virtual;
  // dynamic动态方法
  Procedure MethodTwo(Aparam:string);dynamic;
  // abstract抽象方法
  Function MethodThree(Aparam:string); virtual;abstract;//或dynamic;abstract;
  // 无任何特别声明
  Function MethodFour(Aparam:string);  //注：使用虚拟和动态时，当前类需要有该方法的实现代码（即具体的函数的代码段）
  //而使用抽象(abstract)方法时，当前类若有该方法的实现代码会出现警告
  //而在C++中在含纯虚拟函数的抽象类中，不允许建立该方法的实现代码
  //使用抽象的目的就是为了保持多态的性能
end;//子类一
TsubClass1=class(TBaseClass)
  Procedure MethodOne(Aparam:integer);override;
  Procedure MethodTwo(Aparam:string);override;
  Function MethodThree(Aparam:string);override;
  Function MethodFour(Aparam:string);
end;//子类二
TsubClass2=class(TBaseClass)
  Procedure MethodOne(Aparam:integer); override;virtual;
  Procedure MethodTwo(Aparam:string); override;dynamic;
  Function MethodThree(Aparam:string);override;
  Function MethodFour(Aparam1:integer;Aparam2:string);
end;var
  MyObject,BaseClass1:TbaseClass;
  SubClass1: TsubClass1;
  SubClass2: TsubClass2;    上面内容是多态性的一个表示；    如上情况：子类一重载类方法1、方法2、方法3。而方法四只需使用同名函数即可覆盖（注意是覆盖），而且参数可以不同（见子类二中方法4的声明）。
    请看如下调用：
      MyObject:= BaseClass1; BaseClass1.MethodTwo(Aparam); //将执行基类一的方法一；
      MyObject:= SubClass1; SubClass1.MethodTwo(Aparam); //将执行子类一的方法二；
      MyObject:= SubClass2; SubClass2.MethodThree(Aparam); //将执行子类二的方法三；
接下来说一下Virtual、Dynamic、Abstract的关系：
    
    首先，它们的声明(Abstract需要和Virtual或Dynamic联用)都表示该类及其子类可以拥有多态的特性。
    Virtual与Dynamic的比较。如例子中基类的方法1、方法2的声明。声明了虚拟或动态的方法以后，需要在当前类的对该方法进行代码的实行，即需要有：
procedure TbaseClass. MethodOne(Aparam:integer);
begin
//
end;
procedure TbaseClass. MethodTwo(Aparam:string);
begin
//
end;
两个函数（或过程）。先提及一下Abstract，在基类中不需要实现由Abstract声明的方法，就是说，如果基类中存在以下
procedure TbaseClass. MethodThree(Aparam:string);
begin
//
end;
的函数，编译器将发出警告！Abstract方法只是为了多态的引用方便，在基类中保留该方法的入口。    对于重载的方法将会覆盖原有的方法代码，若要保留原有代码,使用inherited关键字，该关键字的引用方法（引用“引子二”的Create和Destroy方法举例）：
constructor Create(Aowner:TComponent);override;
begin
  inherited Create(AOwner);
  //先执行原有函数代码
  //Your constructor code
end;destructor Destroy;override;
begin
  //Your destructor code
  inherited Destroy;
  //后执行原有函数代码
end;
那么，Virtual与Dynamic的区别是什么？    对于以Virtual声明的方法，编译时会产生一个虚对象方法表(VMT)，就是对象方法的地址数组，这是对多态对象引用的快速方式(VCL中的常用方法)。
其缺点是：该类的每个子类都将有该方法的入口（对没有进行重载的子类也不放过），VMT的入口传遍该类的宗系。后果是，占用大量内存。    对动态的对象方法使用的是唯一数值表示的方法，相应函数的寻找比起虚拟的方法要来得慢，但好处是重载时入口仅在其当前子类传播；对于大的或深的对象层次使用动态的方法将节省大量的内存。如何选取虚拟还是动态的方法，有几个简单原则：
  1、若每个子孙类都可能重载时，使用虚拟的方法(比如VCL的许多方法都使用虚拟方法，虽然VCL层次很深，将占用大量内存，但对于某些方法，指不定哪个子类会重载其方法)；
  2、不用频繁重载，只为子类多态而滞后联编，使用动态方法；
  3、若调用频率高，周期远小于秒的单位，应当考虑虚拟方法(较快);
    引子（四）：类或对象的关联模式：
    1、通用-特定模式（经典模式）：譬如首先定义了一个交通工具的类，在由该类扩展成为具体汽车、轮船的类；这是在原有类的基础上的扩展；
    2、整体-部分模式：譬如一台电脑由主板、CPU、内存等组成，且每个电脑包含的是一个个实际的主板、CPU、内存的对象；
    3、对象间联接模式：还分成“参与者-交易模式”、“地点-交易模式”、“参与者-地点模式”、“交易-交易模式”、“项-行项模式”、“伙伴-伙伴模式”等，就不多赘述了，更何况我又不是专家。    引子（五）：集合类Tcollection、TCollectionItem：这两个类是Delphi中定义的类，他们相互关联，通过扩展可以构造出许多其它的集合类。比如TstatueBar中拥有一个TstatusPanels对象，该类由Tcollection派生，可以拥有不定数目的面板对象，相对应有TstatusPanel从TcollectionItem派生（见ComCtrls.pas）。
一般的，要从集合对象派生集合类需要有几个类的声明，通常是；  //集合项的子类
  TsubObjectItem=class(TCollectionItem);
  //集合容器类
  TOwnerObject=class(TCollection);
  //集合项的子类的类型
  TsubObjectItemClass=class of TsubObjectItem;
  //集合容器通用类的类型
  TCustomOwnerObjectClass=class of TOwnerObject;这里就不具体说明了，若有兴趣，看VCL源代码吧。    记得有人问TsubObjectItem与TsubObjectItemClass如何区分区别，其实很简单，如下的变量声明：
var
  SubObjectItem: TsubObjectItem; // 变量SubObjectItem表示对象
  SubObjectItemClass: TsubObjectItemClass; // 变量SubObjectItemClass表示类>>>>>>>>>>>--------------------------------------------------------------
终于进入正题了，好累啊！你看的也累了吧，那我呢？唉！！！现在我们来构造一个家庭，首先是进行分析：（事先说明：我认为面向对象的方法论还不足以描述客观世界或事物（原因见下文对人的类的抽象部分），以下构造仅仅是假设性的描述，所以不要对例子中描述过多苛求）一个家庭包括：成员、财产、作为家庭这个单位(Unit)的义务及职能等。于是需要描述人的类、财产的类等；    （我认为（纯粹个人见解）面向对象不足以描述复杂的客观世界、事物，譬如人类：一个人拥有神经网络、肌肉组织、血液循环、消化系统循环、骨骼构架等等，每个都可以独立自成体系，而细细追究，则各个系统之间的联系又几乎是归究到其根本的，不能任意拆割的）所以只能构造包含人的简单特性的类。好吧！姑且构造吧！从头开始？从细胞开始！；    看过《梁祝》否？夫子说梁山伯五音不全，心、肝、脾、肺、肾到底少哪样----“情-！啊-！”那，情又在何处？
    “情”在基因里就已经存在，但是虚幻的存在的，需要用虚拟的方法声明，她没有具体的表现、表达方式。而感情又常常不是一种，经常是“百感交集”，所以感情应当是集合类型,于是TemotionItem=(喜、怒、哀、乐等); //枚举感情
Temotion=Set of TemotionItem; //集合类型//基因类-------------------------------------------------------------
TGene=class(Tobject)
protected
  Femotion:Temotion; //包含的感情
  FchromosomeNumber:integer; //染色体数目
  …
  Procedure FexpressEmotion; virtual;abstract; //表达感情，虚拟、抽象
  …
  property Emotion: Temotion read Femotion; //只读情感，改变有其它相关事件改变
…
End;//人类基因（对于基因类型属于通用-特定模式）---------------------------
ThumanGene=class(Tgene);
…
End;//人类细胞------------------------------------------------------------
ThumanCell=class(ThumanGene);
…
End;//心、肝、脾、肺、肾（仅列出心）//人心的类（对于人细胞类属于整体-部分模式）---------------------------
ThumanHeart=class
protected
  FcellCollection:TcellCollection; //细胞集合
  //重载表达感情的方法(悲伤时心痛等)
  Procedure FexpressEmotion; override; virtual; // virtual:保留进一步重载的能力
Published 
  //对于以前的属性，可以通过简单声明来使用
  property Emotion: Temotion;
End;//通用人的类(又是整体-部分模式)--------------------------------------
//我已经无法确定各个属性、方法应该属于哪个关键字下了，索性不写关键字了
TcustomHuman=class
  //心、肝、脾、肺、肾、口、耳、鼻、喉、手、臂、腿、脚等（仅列出心）
  Fheart: ThumanHeart;
  …
  Fsex:Tsex; //性别
  Fold:integer; //年龄
  FbloodType:TbloodType; //血型
  …
  //拥有财产集合对象
  FFamilyStuff:TFamilyStuff;//包括房产、家具、交通工具等对象
  …
  //重载表达感情的方法
  Procedure FexpressEmotion; override; 
End;现在可以创建祝英台的人的对象了：    姓名：祝英台，
    性别：女，
    出生日期：东晋某年某月某日，
    血型：不详，
    …
    佣人：十个仆人一个丫鬟，
    交通工具：两辆马车三匹马,
    …,
    …，
    …，
（以上内容有待核实）；//中间的集合类或后面例子引用的其它类等，从略。//家庭
Tfamily=class
published
  //家庭成员的集合对象
  FfamilyCollection:TfamilyCollection;
  …
  //家庭对象的方法等
  procedure AddChild(Acondition:TCondition); //生儿育女
  …
End;    由于，梁山伯祝英台终未构成家庭，我也懒得去构建其实例了（同时我也写的太累了）。不妥之处，多多包涵。好了，休息休息！
    来点儿让大伙儿高兴的吧！请看下文：    “我都快累死了！”，一方面是写的足够多了；另一方面，期间麻烦事真不少。    （声明，下面一段话均乃事实，绝无虚假）
    昨天下班前没写完，就copy到软盘。回家后发现软盘没带回来，一时冲动就又乘车回公司去取。来回折腾不说，家里那一大片还都停了电（深圳也是会停电的！！！已经两天了！！从未料到！--我已经更加不再迷信什么了！！！）。    先是走廊摸黑看不见，多爬了一层楼；然后是磁盘读不出来--死活读不出来、格式化都格式化不了，只好报废撕去其活动套，居然又读出来了--命不该绝（且又学到一招）；再，就是流着汗水、点着蜡烛在打字（我的笔记本硬撑到12点楞是没来电，疯了！我！12点半听到热烈欢呼声--来电啦！！！赶紧开开空调，好景不长，20分钟后又熄火了！不管了，冲个凉、睡吧）。所以，今天才续完。    还是太枯燥了！最后再讲个小故事结束吧！也算和本篇开头相呼应吧（若是斑竹硬要将此帖转到灌水乐园，我也认了）    是关于我自己的一个小故事，又是一个真实的故事！
    前些天和一老乡（也是老同学、老邻居、老友）一块吃饭，邻桌吃饭的正好是他上司，于是友人过去搭话。
    这时两个小孩玩耍走过，其一伫立，无表情的看着我，我也无表情地看着他……突然间，那小孩几乎跳起似的连声朝我嚷道：“傻B！” “傻B！” “傻B！”……一直不停！
    我一时间竟不知所措，任由他叫嚷，好在周围（或许）没有人在意。在他还没停下的时候，我又好象忽然想到了什么，一直吸引着我，来不及去抱怨那小孩如此没有XX，也来不及对那小孩装出绅士般的微笑以抵挡别的可能的发现的人的目光。
…
    兴许是那小孩累了，或是觉得在对牛弹琴，或是其它什么，总之，那小孩已经停止了叫嚷，远去了。老友回了桌，我还一直在傻傻的想…
忽然，我想到了，我的确是个傻B（后阐明），这时我的心情由烦躁又一下子愉悦起来。继续和老友吃饭、胡聊…
    ……
    ……
    我想到了《皇帝的新装》，有一个孩子在叫嚷“他什么都没有穿啊！”，因为小孩子是无须欺骗你的，因为没有理由（不要学《大话西游》说什么“骗一个人不需要理由”，我唾-！-！）。
    于是我承认了，我是个傻B，为什么不否认呢？因为于我来说，一个有自知之明的傻B要比一个执迷不悟的傻B要强得多，于是我的心情由烦躁又一下子愉悦起来了…… enlightenment(阿明) [email protected]

Answer 11

highnice(highnice):面向对象技术本身是很复杂的东西，博大精深，怎么才能不太复杂就能领会？你教我啊？

Answer 12

To:enlightenment(阿明)　
妙论!!!通透!!!
但要想理解什么是面向对象的话,请参看本世纪最著名的面向对象方法论书,候捷先生主力推荐的
我买了一本,很多看不懂,但知道了什么才是面向对象?????
真正的面向对象是博大精深的,哪有我们想象的那么简单!!!!!!@#$%
看一下微软做的WORD就知道了.!!@!!!

Answer 13

2.16 面向对象编程
关于面向对象编程( O O P )的文献已经有很多了，与其说O O P 是一种编程方法，还不如说它是一种信仰，由此引发了大量关于它的优点和缺点的讨论。我们不是正统的O O P 主义者，也不打算讨论O O P有什么优势；我们只是简单地告诉你面向对象编程的基本原则，这是Object Pascal 语言的基础。
O O P 是使用独立对象(包含数据和代码)作为应用程序模块的范例。虽然O O P 不能使得代码容易编写，但它能使代码易于维护。将数据和代码结合在一起，能使定位和修复错误的工作得到简化，并最大限度地减少了对其他对象的影响，提高了程序的性能。通常，一门面向对象的编程语言至少要实现下列三个O O P 的概念：
• 封装，把相关的数据和代码结合在一起，并隐藏了实现细节。封装的好处是有利于程序的模块化，并把代码和其他代码分开。
• 继承，是指一个新的对象能够从父对象中获取属性和方法，这种概念能用来建立V C L 这样的多层次的对象，首先建立通用对象，然后创建这些通用对象的有专用功能的子对象。
继承的好处是能共享代码。
• 多态性，从字面上说，是指多种形状。调用一个对象变量的方法时，实际被调用的代码与实际在变量中的对象的实例有关。
关于多继承

Answer 14

Object Pascal 不像C + +那样支持多继承，多继承是指一个对象能继承两个不同的对象，并包含有两个父对象的所有数据和代码。
对图2 - 4 继续扩展，用多继承来建立一个candy apple(苹果糖)对象，它继承于a p p l e (苹果)类和其他一个称为candy(糖)的类。虽然这个功能看起来有用，但它包含着许多问题。Object Pascal 提供了两种方法来解决这个问题。第一种方法是在一个类中包含其他的类，你能从D e l p h i 的V C L 中看到这种解决方法。为了创建candy apple ，先使c a n d y 对象称为a p p l e 对象的一个成员。第二种方法是用接口，在2 . 1 8 . 7 节“接口”中将更详细地介绍接口，用了接口你能创建一个既支持candy 接口又支持apple 接口的对象。
在你继续深入了解对象的概念以前，应该先理解下面三个术语：
• 域( f i e l d )，也被称为域定义或实例变量，域是包含在对象中的数据变量。在对象中的一个域就像是在P a s c a l 记录中一个域，在C + +中它被称为数据成员。
• 方法( m e t h o d )，属于一个对象的过程和函数名，在C + +中它被称为成员函数。
• 属性( p r o p e r t y )，属性是外部代码访问对象中的数据和代码的访问器，属性隐藏了一个对象的具体实现的细节。
注意最好不要直接访问对象的域，因为实现对象的细节可能改变。相反用访问器属性来访问
对象，它不受对象细节的影响，属性在本章的2.18.2 节“属性”介绍。
基于对象与面向对象的编程
在某些工具中，你能操纵对象但不能创建对象，Visual Basic 中的ActiveX 控件(以前称为O C X )就是例子。虽然在程序中你能用A c t i v e X 控件，但你不能创建它，也不能派生它。这样的环境被称为基于对象的环境。
D e l p h i 是完全的面向对象的环境，这表示在D e l p h i 中你能用已经存在的组件创建新的对象，这些对象是可视的或不可视的，甚至可以是设计时的窗体。

Answer 15

面向对象？哪个方面的？
开发语言有面向对象；人工智能有面向对象；软件工程有面向对象；组织行为学有面向对象；教育学有面向对象……
面向对象只是一种解决问题的方法论，是事物的抽象化过程（也是研究和解决问题的一种方法总结），而Delphi、C++中的面向对象只不过是其方法的具体应用。
如果你无法了解事物的抽象过程，那么你不可能真正地理解什么是面向对象！给你一个题目：对Delphi、C++进行类结构化？
提示： 1：面向对象开发工具 -> 开发工具软件 -> 应用软件 -> 软件 ……
       2：组织型集成开发环境 -> 代码开发工程 -> 实现工程 ……
程序员关心什么？软件设计/组织人员关心什么？

Answer 16

flyonet(网上飞),　enlightenment(阿明--平均睡眠时间<6h/d的超人):
怎么讲才不傻呢?聪明的你,能给讲清楚吗?

Answer 17

错！按flyonet(网上飞)所说，我也是“一群傻瓜哦”中的一员哎！

Answer 18

enlightenment(阿明--进入准冬眠状态的超人)　
说的真好啊

Answer 19

我亦觉得enlishtenment(阿明--进入准冬眠状态的超人)　
说的对我理解面向对象最有启发。