p*n
2 楼
富通出售资产遭否决 平安保险险胜一局
http://www.sina.com.cn 2009年02月12日 09:28 新浪财经
视频：富通CEO称平安反对票或令公司破产 媒体来源：东方卫视《早市导航》
香港经济日报指，经过约5小时的会议，欧洲富通集团(Fortis)出售140亿欧元资产
予法国巴黎银行之交易，在中国平安(33.79,-0.11,-0.32%)保险(02318)等股东反对下
遭到否决。
平保发言人盛瑞生对本报表示，投票结果反映出股东的意愿。平保愿意与有关各方
在公司管治原则下，共同维护富通的持续经营，以及富通客户与股东的利益。
平安保险的反对阵营仅以百万票之差险胜。富通的股东会于比利时首都布鲁塞尔时
间早上10时开始，至下午3时15分左右开始投票，出席股东约5,000名。
VEB临阵赞成 无碍结果
会议就出售富通的荷兰资产予荷兰政府议案率先以大比数否决，其后富争议性的出
售资产予比利时政府再转售予法巴的议案，赞成与反对仅相差约百万票，会议主持人亦
迟疑了一会，才宣布议案遭到否决。
这次股东会是在比利时法院裁判下安排进行，不少股东对于比利时政府在未咨询股
东的情况下
http://www.sina.com.cn 2009年02月12日 09:28 新浪财经
视频：富通CEO称平安反对票或令公司破产 媒体来源：东方卫视《早市导航》
香港经济日报指，经过约5小时的会议，欧洲富通集团(Fortis)出售140亿欧元资产
予法国巴黎银行之交易，在中国平安(33.79,-0.11,-0.32%)保险(02318)等股东反对下
遭到否决。
平保发言人盛瑞生对本报表示，投票结果反映出股东的意愿。平保愿意与有关各方
在公司管治原则下，共同维护富通的持续经营，以及富通客户与股东的利益。
平安保险的反对阵营仅以百万票之差险胜。富通的股东会于比利时首都布鲁塞尔时
间早上10时开始，至下午3时15分左右开始投票，出席股东约5,000名。
VEB临阵赞成 无碍结果
会议就出售富通的荷兰资产予荷兰政府议案率先以大比数否决，其后富争议性的出
售资产予比利时政府再转售予法巴的议案，赞成与反对仅相差约百万票，会议主持人亦
迟疑了一会，才宣布议案遭到否决。
这次股东会是在比利时法院裁判下安排进行，不少股东对于比利时政府在未咨询股
东的情况下
p*t
3 楼
心血来潮，把尘封了有两年的第二代20G的硬盘版iPod给充了会电，接上TF10，听德国
美女版维瓦尔第的“四季”，还是很不错的啊，对比了一下PK2，TF10的气势显然要足
了不少啊，不错不错。
美女版维瓦尔第的“四季”，还是很不错的啊，对比了一下PK2，TF10的气势显然要足
了不少啊，不错不错。
s*e
4 楼
H1, 准备在fidelity开个 roth IRA, 有一选项是Country of Tax Residence，不知道
应该US还是China. 麻烦开过的人指点
一下，谢谢。
应该US还是China. 麻烦开过的人指点
一下，谢谢。
P*p
5 楼
[果子店狗血穿越] 来自五代的你 （69）一对故人
上回书说到，果子一行在官道上被守夜人的卫队拦住敲诈，强行要求他们到同福客栈投
宿。多亏了瓜老板的圆滑，双方才没动起手来。
但是这样一来，毕竟憋了一肚子气，一行人各怀心事，终于赶到了渡口。举目一看，不
由得叫起苦来。原来果然如同守夜人说的那样，渡口上一条船也没有。不仅如此，这渡
口是冷冷清清，只有一间客栈。果子叫道：“这里还真是黑店啊，怎么就只有这一家店
？”
瓜老板叹道：“也许是因为夏汛刚过，洪水才退的缘故吧。不管怎么样，咱们是要在这
里打尖了，你看，离这里最近的渡口也要在百里之外，恐怕等咱们到了河对面的关家庄
，这戏也散了。”
众人无奈，只得一齐下马，往这个同福客栈走去。这客栈的门前却是冷冷清清，不见有
什么别的客人。众人走进了大门，也没见有什么人出来招呼。果子眼尖，首先看到大堂
的柜台后面，有一人正趴在那里酣睡。当下咳嗽一声，喊道：“有人么，住店啦。”
那小二抬起头来，睡的正稀里糊涂，果子一行见了这人，却都是一惊。原来此人不是旁
人，正是火柴！
却见那火柴见了众人，也不惊讶，只是打了个哈欠道：“怎么，你们在路上遇到我的兄
弟们啦？是他们让你们到这里来投宿的？”
果子这才明白，原来火柴和那些守夜军人是一伙的，正要发怒，却见玉狐已经跳了过去
，劈手揪住火柴前襟，喝道：“好你个火柴，这些年让我找的好苦！”
“你放手啊，”火柴淡淡说道：“咱俩熟归熟，你再这么揪着我，我一样告你性骚扰。
”玉狐怒道：“少废话，快说，当年你为什么擅自离开小黑屋，导致火云邪神的逃脱？
”“你说反了吧，”火柴依旧是冷冷地：“我却要问你，当年为何要以相亲为名，把我
骗下山去和东风姑娘见面？”
“怎么，见一面还亏了你么？”一个甜美的声音突然响起，只见一个妙龄少女，正分花
抚柳搬地从内堂走出来。但见此女：足下蹑丝履，头上玳瑁光，腰着流纨素，耳垂明月
当。指若削葱根，口如含朱丹，纤纤作细步，精妙世无双。右手拿一账本，左手持一算
盘，看样子是这里的老板娘了。只见火柴的眼神登时就温柔了下来，喃喃说道：“当年
那一面，自是此生无憾。”
果子正在欣赏这位美女，却见玉狐，瓜老板，河马，和卫京四人都是脸色大变，死死盯
着那女子。果子心里好笑，心想莫非这些人没见过美女是怎么的，却听四人几乎是异口
同声道：“东风？你怎么在这里？”果子这才吃了一惊，没想到眼前这位老板娘，就是
早已经如雷贯耳的东风！
只见东风面带微笑，缓缓说道：“诸位今日来到我这里，便是客人，以往的事情都不要
说起。阿柴哥，你先将这些客人们安顿下吧。”说完施了一礼，居然竟自走了。
玉狐等四人根本没有料到会在这里遇到东风，加上她又先发制人，一时间都呆在原地，
面面相觑，做声不得。只听火柴懒洋洋地说道：“我说诸位，先住下再说吧。”瓜老板
低声道：“这里面肯定有蹊跷，咱们先住下来再慢慢查访不迟。”
欲知后事如何，且听下回分解。
(待续）
上回书说到，果子一行在官道上被守夜人的卫队拦住敲诈，强行要求他们到同福客栈投
宿。多亏了瓜老板的圆滑，双方才没动起手来。
但是这样一来，毕竟憋了一肚子气，一行人各怀心事，终于赶到了渡口。举目一看，不
由得叫起苦来。原来果然如同守夜人说的那样，渡口上一条船也没有。不仅如此，这渡
口是冷冷清清，只有一间客栈。果子叫道：“这里还真是黑店啊，怎么就只有这一家店
？”
瓜老板叹道：“也许是因为夏汛刚过，洪水才退的缘故吧。不管怎么样，咱们是要在这
里打尖了，你看，离这里最近的渡口也要在百里之外，恐怕等咱们到了河对面的关家庄
，这戏也散了。”
众人无奈，只得一齐下马，往这个同福客栈走去。这客栈的门前却是冷冷清清，不见有
什么别的客人。众人走进了大门，也没见有什么人出来招呼。果子眼尖，首先看到大堂
的柜台后面，有一人正趴在那里酣睡。当下咳嗽一声，喊道：“有人么，住店啦。”
那小二抬起头来，睡的正稀里糊涂，果子一行见了这人，却都是一惊。原来此人不是旁
人，正是火柴！
却见那火柴见了众人，也不惊讶，只是打了个哈欠道：“怎么，你们在路上遇到我的兄
弟们啦？是他们让你们到这里来投宿的？”
果子这才明白，原来火柴和那些守夜军人是一伙的，正要发怒，却见玉狐已经跳了过去
，劈手揪住火柴前襟，喝道：“好你个火柴，这些年让我找的好苦！”
“你放手啊，”火柴淡淡说道：“咱俩熟归熟，你再这么揪着我，我一样告你性骚扰。
”玉狐怒道：“少废话，快说，当年你为什么擅自离开小黑屋，导致火云邪神的逃脱？
”“你说反了吧，”火柴依旧是冷冷地：“我却要问你，当年为何要以相亲为名，把我
骗下山去和东风姑娘见面？”
“怎么，见一面还亏了你么？”一个甜美的声音突然响起，只见一个妙龄少女，正分花
抚柳搬地从内堂走出来。但见此女：足下蹑丝履，头上玳瑁光，腰着流纨素，耳垂明月
当。指若削葱根，口如含朱丹，纤纤作细步，精妙世无双。右手拿一账本，左手持一算
盘，看样子是这里的老板娘了。只见火柴的眼神登时就温柔了下来，喃喃说道：“当年
那一面，自是此生无憾。”
果子正在欣赏这位美女，却见玉狐，瓜老板，河马，和卫京四人都是脸色大变，死死盯
着那女子。果子心里好笑，心想莫非这些人没见过美女是怎么的，却听四人几乎是异口
同声道：“东风？你怎么在这里？”果子这才吃了一惊，没想到眼前这位老板娘，就是
早已经如雷贯耳的东风！
只见东风面带微笑，缓缓说道：“诸位今日来到我这里，便是客人，以往的事情都不要
说起。阿柴哥，你先将这些客人们安顿下吧。”说完施了一礼，居然竟自走了。
玉狐等四人根本没有料到会在这里遇到东风，加上她又先发制人，一时间都呆在原地，
面面相觑，做声不得。只听火柴懒洋洋地说道：“我说诸位，先住下再说吧。”瓜老板
低声道：“这里面肯定有蹊跷，咱们先住下来再慢慢查访不迟。”
欲知后事如何，且听下回分解。
(待续）
T*e
6 楼
寻梦记
李唐风
昨晚在几个微群里提到梦的话题，我发了个询问贴：“说到梦，突然想到一个问题，请
教大家的经验。谁梦中见过自己在飞的？如果飞着飞着，突然被弄醒了，是啥感觉？恐
高？还是摔下来？我好象是使劲拍翅膀，结果胳膊差点儿被床和被子整折了。”
一个身在美国的中学女同学回帖相当生动：“据说做在天上飞的梦很常见。昨晚我就梦
见在北京家附近天上飞。突然发现一大湖。湖里很多很肥的鱼。于是我从空中俯冲。结
果抓了一只大海龟。揪着脖子弄出湖里。”“我做梦的本事可大了。前天晚上梦见在人
大附中初中班上课。突然钱老师笑嘻嘻地袍到我面前说我很好。我登时受宠若惊。几乎
不敢相信老钱看得起我。”而且梦境非常真切，还说当时回头一看，班里面几个学霸男
生都穿着格格的衣服坐在教室里。“醒了以后，仍旧有受宠若惊之感。”（注：钱老师
是几乎所有中学同学公认的超级教师。如果我说他是中学里的博导儿，其他同学可能会
觉得我有自夸成分，但不会觉得对钱老师有任何夸大其词。）
我觉得她的做梦本事确实很棒。上天不用买飞机票，下水捞鱼不用撒网，上课学习还被
自己最敬重的老师当众夸奖。这种感觉，很爽。
我也深信她所说的这种梦境清晰、真切的感受。有时候，我们在梦中的所作所为、所思
所想，醒来后会觉得荒诞，可是在梦境中却一直毫无疑义，理所当然。而有时，梦中的
思维甚至比醒来时，更具理性。比如平日里有煞费苦心而不得其解的问题，在梦里遇到
了同样的问题或不同场景的相似问题，竟然能不暇思索地迎刃而解，当时醒来后还隐约
记得，很奇怪自己前几日脑筋多次急转弯儿，怎么都没如此转过筋来。所以后来对于《
星际穿越》中，看到主人公从未来回到过去，用未来的经验来提醒过去的自己，我觉得
既神奇又自然。
另一个群里一位正在禅修的大学同学回贴：“梦见自己飞，说明你很有灵性，前世是修
行人，你这个梦告诉你这辈子还在沉沦不醒。”
读之心有所感，赋诗一首：
梦醒之间
庄生已忘形
恋恋化蝶情
梦续前生愿
醒来明夜星
-
李唐风的博客 - http://blog.sina.com.cn/s/articlelist_3893018258_0_1.html
以唐诗风骨持炼现代文字
承中华文化璀璨之传统
鉴当代时事风云之春秋
品人情风土百味之霜露
虽末学而立雄志
以微躯诚结群豪
透视人间
宏观天意
微视尘沙
李唐风
昨晚在几个微群里提到梦的话题，我发了个询问贴：“说到梦，突然想到一个问题，请
教大家的经验。谁梦中见过自己在飞的？如果飞着飞着，突然被弄醒了，是啥感觉？恐
高？还是摔下来？我好象是使劲拍翅膀，结果胳膊差点儿被床和被子整折了。”
一个身在美国的中学女同学回帖相当生动：“据说做在天上飞的梦很常见。昨晚我就梦
见在北京家附近天上飞。突然发现一大湖。湖里很多很肥的鱼。于是我从空中俯冲。结
果抓了一只大海龟。揪着脖子弄出湖里。”“我做梦的本事可大了。前天晚上梦见在人
大附中初中班上课。突然钱老师笑嘻嘻地袍到我面前说我很好。我登时受宠若惊。几乎
不敢相信老钱看得起我。”而且梦境非常真切，还说当时回头一看，班里面几个学霸男
生都穿着格格的衣服坐在教室里。“醒了以后，仍旧有受宠若惊之感。”（注：钱老师
是几乎所有中学同学公认的超级教师。如果我说他是中学里的博导儿，其他同学可能会
觉得我有自夸成分，但不会觉得对钱老师有任何夸大其词。）
我觉得她的做梦本事确实很棒。上天不用买飞机票，下水捞鱼不用撒网，上课学习还被
自己最敬重的老师当众夸奖。这种感觉，很爽。
我也深信她所说的这种梦境清晰、真切的感受。有时候，我们在梦中的所作所为、所思
所想，醒来后会觉得荒诞，可是在梦境中却一直毫无疑义，理所当然。而有时，梦中的
思维甚至比醒来时，更具理性。比如平日里有煞费苦心而不得其解的问题，在梦里遇到
了同样的问题或不同场景的相似问题，竟然能不暇思索地迎刃而解，当时醒来后还隐约
记得，很奇怪自己前几日脑筋多次急转弯儿，怎么都没如此转过筋来。所以后来对于《
星际穿越》中，看到主人公从未来回到过去，用未来的经验来提醒过去的自己，我觉得
既神奇又自然。
另一个群里一位正在禅修的大学同学回贴：“梦见自己飞，说明你很有灵性，前世是修
行人，你这个梦告诉你这辈子还在沉沦不醒。”
读之心有所感，赋诗一首：
梦醒之间
庄生已忘形
恋恋化蝶情
梦续前生愿
醒来明夜星
-
李唐风的博客 - http://blog.sina.com.cn/s/articlelist_3893018258_0_1.html
以唐诗风骨持炼现代文字
承中华文化璀璨之传统
鉴当代时事风云之春秋
品人情风土百味之霜露
虽末学而立雄志
以微躯诚结群豪
透视人间
宏观天意
微视尘沙
a*a
7 楼
原文链接：http://ladder.azurewebsites.net/forum.php?mod=viewthread&tid=121&extra=page%3D1
第一集：Mr.Method
Hi，大家好~~我是Mr.Method，和Mr. Okay是好哥们儿。
在所有面向对象的语言里你都能见到我的身影。不信？你们学编程的时候第一个程序
都是Hello World吧？那就是依靠对我的调用实现的——无论是哪个平台、哪种语言，
你一定调用了在命令行里输出字符串的某个Method。
铁三角
在正式介绍我自己之前，还是先说说我的哥哥和妹妹吧，我们的家庭背景有助于大家
对我有一个更好的了解。我的哥哥（Mr. Class）和小妹（Mr. Field）加上我，我们仨
可是面向对象家庭里绝对的主角、“铁三角”。我们三个之所以称为“铁三角”是因为
我们各司其职、配合的非常默契。Mr.Class，他是个很好的组织者，他能把从现实世界
抽象出来的结果良好地组织在一起（这个叫“封装”）——我（Mr.Method）和我小妹
（Ms. Field）被我哥管着（注：被封装在类里）。小妹负责表示我们这个小组织当前
的状态，而我负责我们这个小组织能干什么。有的时候小妹的状态会决定我能不能做一
些事——比如我想买个什么东西，小妹说：“没钱！”那我就不能执行了。而有的时候
我的行为也会影响到小妹的状态——比如我买了辆新车，那么就会从小妹那里减去一些
钱。女孩子家，怕她受伤受骗什么的，一般情况下我们不会让外人直接接触小妹，所以
，保护小妹的事情也由我来负责。总之呢，你知道我在这个小组织里是个跑腿儿的（表
示这个组织能干什么）、同时还是小妹的保护伞，这就足够了。
我的前身
面向对象编程在软件界算是个划时代的进步，之前那个时代叫“面向过程时代”，现
在仍然有面向过程的程序在编写，但远不像以前那么多了。回退二三十年，面向过程流
行的年代，那时候我还不叫Mr.Method，那时候我叫Mr.Funtion。后来有了面向对象，
Function被类所封装管理，于是我们被称为“类的方法”（methods of class），用来
表示这个类能做些什么事情。因为我们是类的成员，被封装在类里，所以从面向过程年
代过来的老程序员们仍然喜欢叫我们Mr. Member Function（成员函数），每当听到这
个名字，我都感觉好好亲切……好好感动……好好内牛满面。算了……过去的事情了。
因为我表达的是“一个类能干什么”，所以，程序中真正做事的——是我。我之所以
能“做事”，全靠程序员们为我编写的代码逻辑（method body），也就是——算法。
没有算法，我就是个空壳；算法错误，程序就会有bug。如果你想省事，不妨这样记：
Mr.Method==算法，或者算法==Mr.Method。
我的样子
在不同的面向对象语言里，我的样子可能不太一样。就自我感觉而言，我还是认为我
在Java/C#/C++语言里的样子最帅。所以，今天就聊聊我在Java语言里长什么样吧（注
：方法在Java/C#/C++的格式几乎没有区别），谁让你们都想靠学Java找工作、攻学位
呢！
Well，当你在代码里见到我的时候，要么是在定义（define）我，要么是在调用（call
）我。因为定义我时候的样子决定了我被调用时的样子，所以让我们从定义开始。
在观察我的样子之前，请你把我想象成一个“加工厂”。比如，果酱加工厂，你给它
输入水果作为原料，它的内部运转加工，最后把加工好的果酱还给你。当然了，我不负
责加工果酱，我加工的是——数据。
OK，来看我被定义时的样子，从前往后依次是：
1. 返回值类型：直截了当地告诉你我的产品是什么。不过，有的时候我并没有产出，
而是默默地做完某些事情（比如阻挡不速之客访问我小妹的值），这时候为了统一起见
，我也会有一个看上去像是返回值类型的void摆在那里。我之所以说在Java/C#/C++里
长的帅，就是因为这些语言在语法格式上的统一。
2. 名字：我的名字必需符合Java语言的符号命名规范，而且使用用caml格式（注：在C
#里使用Pascal格式，C#的发明人Anders先生将以Pascal语言为蓝本的DELPHI开发环境
的一些特性引入了C#，使其语言格式看上去更优雅；而Java则保留了一些C++中的原始
美）。
3. 参数列表：由一对括号括起来的一组“类型->参数名”对，参数列表中的参数可以
是0个、1个、2个...当参数为0个时，也可以说这个方法没有参数；当参数多于1个时，
“类型->参数”对之间要用逗号分隔。
4. 方法体：由一对花括号包围，方法体里就是对数据的加工逻辑了，也就是真正的算
法。翻过头去看下第1项：如果这个方法有返回值（不是void），那么方法体里必需保
证有return语句返回一个与返回值类型相匹配的值（思考：为什么我用的是“相匹配”
而不是“一样”？）。
另外，有的时候我也喜欢打扮一下自己、在整个定义之前加几个修饰符（modifier）
什么的，最常见的就是public或private与static的组合。换句话说，这四种修饰占到
80%以上的情况——(1)public, (2)private, (3)public static, (4)private static
。具体这四种修饰是什么意思，后面会讲到，现在你不必特别在意。
下面是我被定义时常见的样子，请你们自己把上面说的四个部分找出来吧！
================================================
// 无返回值，无参数
void sayHello() {
// 逻辑
}
// 无返回值，1个参数
void sayHello(String friendName){
// 逻辑
}
// 有返回值，1个参数
double convertDollarToRmb(double dollarValue){
double rmbValue = 0;
// 逻辑
return rmbValue;
}
// 有返回值，2个参数
double add(double input1, double input2)
{
double result = input1+input2;
return result;
}
================================================
知道了我在定义的时候长什么样子，那么有一件事就要记清楚了：我的定义只可能出现
在类体里，也就是类的那层花括号里。换句话说，无论我被定义在类体之外，还是在其
它方法体的内部，编译器都不会让你通过的。我在C#里跟在Java里差不多，但在C++里
有那么一点变化，就是我仍然可以被定义在类体之外，这时候我被称为“全局方法”或
“全局函数”，这体现了C++的一种贴近底层的“原始美”，但跟我们学Java的没什么
关系啦^^。（思考：main方法也是一个方法，你能找出它的四个部分吗？）
说完了我被定义时的样子，再来说说我被调用的时候长什么样子吧——看上去跟被定
义的时候长的差不多，但一定要记住，我只能在方法体里被调用（即方法的调用一定只
能是在其它方法的方法体里出现）。科学点讲，当方法B被方法A调用时，方法B出现在
方法A的方法体里，构成了方法A算法的一部分；这时方法A被称为调用者（caller），
方法B被称为被调者（callee）；如果方法B又去调用了方法C，那么会就形成A-->B-->C
这样一个调用层级，学名叫做调用栈（call stack）。
下面是上面四个方法定义在被调用时的样子：
================================================
void callAllMethods()
{
sayHello();
sayHello("Mr.Okay");
double rmb = convertDollarToRmb(1000000);
double r = add(1.5, 3.7);
add(9.9, 0.1); // 这是可以的，但没意义
}
================================================
仔细看，你会发现几处需要注意的地方：
1. 我在被调用的时候，参数的类型就不用写了，因为那是定义我的时候所用的语法，
不是调用的语法，这里我见过太多初学者写错了。
2. 对于有返回值的方法，你需要搞一个变量来接收这个返回值。当然了，不接收也可
以，但这样做就没什么意义了。以前有过一种这样风格的方法定义，但现代编程格式已
经渐渐把这种方法淘汰了。
3. 就算一个方法没有参数，调用我的时候名字后面的那对括号也不能省略，因为你省
略了，编译器会认为你只是提到了我的名字，而没有“调用”我。（）
我的参数
Well，我知道有很多人纠结于“为什么在调用的时候不用写参数类型呀？” “调用的
时候传进去的参数名字是不是必需要和定义时的一样呀？” 这类问题。只要明白了我
的参数，那么这些问题就都明白了。简单讲，我在被定义的时候，参数列表（就是名字
后圆括号里的“类型->参数名”对）叫“形式参数”；而我在被调用的时候，传给我的
参数是真的要被操作的数据，所以叫“实际参数”。下面我来给大家解释解释。
所谓“形式参数”，就是走走形式嘛~~没什么了不起的。这里说的“走走形式”指的
是这些形式参数要参与到我被定义的算法里，在算法里“走走形式”。比如，有这样一
个方法（用伪码表示）：
================
果酱 果酱机(水果 某个水果，干果 某个干果，调料 主调料， 调料 配料)
{
把某个水果切碎磨细；
把某个干果切成粒；
加入主调料；
加入配料；
混合均匀；
返回果酱；
}
=================
这里大家看到的是，“某个水果”、“某个干果”、“主调料”和“配料”都作为跑龙
套的形式参数参与到了果酱的生产算法中。
下面再看调用，看起来是这样（必需被其它的方法所调用）：
=================
void 做果酱()
{
水果 我的水果=买来一个苹果；
干果 我的干果=上回剩下的一包杏仁；
调料 甜料=家里的砂糖；
调料 酸料=冰箱里的柠檬汁；
果酱 新做的果酱=果酱机（我的水果，我的干果，甜料，酸料）；
吃果酱；
吃果酱；
吃果酱；
吃果酱；
// ...
上医院；
}
==================
现在大家应该明白了吧？当调用果酱机方法做果酱的时候，我必需得投入真材实料才能
做出真的果酱来，也就是让先前定义好的算法得以执行。因为是真材实料嘛，所以叫“
实际参数”，简称“实参”。
因为在方法定义的时候就已经要求了参数的类型，所以在调用的时候你只需要把类型
匹配的实参传进方法就行了，不必再次写参数的类型。
顺带跟大家说一下，大家可能一上Java课的时候就听说过“Java是强类型语言”这句
话，这句话怎么理解呢？
关于强类型
想象一下如果这样调用果酱机方法，
=================
void 做果酱()
{
石头 我的石头=拣来一块石头；
沙子 我的沙子=挖来一袋沙子；
调料 甜料=家里的砂糖；
调料 酸料=冰箱里的柠檬汁；
果酱 新做的果酱=果酱机（我的石头，我的沙子，甜料，酸料）；// 你玩儿我？
？！！
吃果酱；
吃果酱；
吃果酱；
吃果酱；
// ...
上医院；// 死翘翘
}
==================
My god！这做出来的东西能吃吗？
你别说，如果这是个C/C++函数（function），说不定真能把“果酱”给你做出来，也
就是说，函数在执行的时候不会报错，而且能返回给你结果，但如果你想拿这个结果做
点什么事情，那结果是不可预知的。这也就是我们常说的C/C++是类型不安全的（现代C
++要好很多）。但如果果酱机方法是用Java语言写的，因为Java是类型安全的语言，所
以你在做这个调用的时候“果酱 新做的果酱=果酱机（我的石头，我的沙子，甜料，酸
料）；”编译器就不让你通过，因为你给的实参类型与定义时的形参类型不匹配。
说说重载（overload）
问你个问题：在同一个类里定义方法的时候，方法名可以相同吗？答案是：“可以！
”但有个要求——方法名相同的时候参数列表不可以再相同。这种方法名相同、参数列
表不同的情况称为方法的重载。前面定义的两个sayHello方法就构成了重载。
这里有几点需要注意的：
1. 参数列表不同，包括了参数的个数不同、类型不同。比如：void myMethod(String
input1, double input2){...}和void myMethod(double input1, String input2){...
}就构成重载。
2. 只改参数名是不能构成重载的。比如：void myMethod(String input1, double
input2){...}和void myMethod(String arg1, double arg2){...}是不重载的。
3. 只改返回值类型也不能构成重载。比如：void myMethod(String input1, double
input2){...}和double myMethod(String input1, double input2){...}是不重载的。
其实大家应该已经发现了，决定两个方法是否重载的是方法定义四个部分中的方法名加
参数列表部分。所以，这两个部分（方法名+参数列表）又称为“方法签名”（method
signature），也就是这两部分的组合确定了一个方法的唯一性。
说说重写（override）
按理说重写这事儿非常简单，但它却与面向对象最核心的一个概念“多态”搅和在一
起了，所以在有些神话传说里会把重写和多态写的云里雾里、神乎其神。其实别听那套
~~很简单的。
咱们先不理多态的茬，只说重写。它的概念是：如果在父类里定义了一个方法A，在这
个父类的子类里你再次定义了方法A，它的返回值类型、方法名、参数列表与父类中的
方法A完全一致，那么我们就说子类中的方法A就对父类中的方法A进行了重写。这再好
理解不过了——方法定义的前三部分安全一样，只有方法体不一样，当然就是子类方法
把父类方法的算法逻辑给覆盖重写了。看例子：
=================
public class Person
{
public void speak()
{
System.out.println("I'm a person.");
}
}
public class Student extends Person
{
public void speak()
{
System.out.println("I'm a student.");
}
}
public class Teacher extends Person
{
public void speak()
{
System.out.println("I'm a teacher.");
}
}
=================
例子中的Person类是Student类和Teacher类的父类（倒过来说，Student和Teacher是
Person的子类或派生类）。它们都拥有返回值类型、名字、参数列表完全相同的方法
speak，所以，Student类和Teacher类里的speak方法对Person类的speak方法构成了重
写。
切记一句话：重写用的好，是福；用不好，是项目里最大的祸害。
多态（polymorphism）——事情有点儿复杂了
什么是多态呢？它可以算得上是OO的重中之重了，它可以这么定义——当用一个父类
类型的变量引用一个子类类型的实例时，通过父类类型的变量调用一个被重载的方法时
，被执行的总是被子类所重写后的版本。看！多态是以重写为基础的。单看定义是很难
明白的，让我们看个例子。
首先，我们在“重写”例子代码上再加一个类：
=================
public class CseTeacher extends Teacher
{
public void speak()
{
System.out.println("I'm a CSE teacher.");
}
}
=================
这个CseTeacher类对Teacher类的speak做了重写（这是再度重写了）。那么，下面这组
方法调用的输出是什么呢？
public class Program
{
public static void main(String[] args)
{
Person person; // 父类类型变量，请注意，它只是个变量，不是实例
person = new Person(); // 变量与实例的类型一致
person.speak();
person = new Student(); // 父类类型变量引用子类实例
person.speak();
person = new Teacher(); // 父类类型变量引用子类实例
person.speak();
person = new CseTeacher(); // 父类类型变量引用子类实例
person.speak();
Teacher teacher = new CseTeacher(); // 父类类型变量引用子类实例
teacher.speak();
}
}
答案是：
I'm a person.
I'm a student.
I'm a teacher.
I'm a CSE teacher.
I'm a CSE teacher.
===================
多态背后的秘密——绑定（bind）
多态是不是很神奇啊？我来向你透露一点它的秘密吧！不过，在我透露这个秘密之前
，我先说一下版权的事儿：咳咳，本系列原创文章发表在http://ladder.azurewebsites.net，转载的话请注明出处，如果你喜欢，欢迎在我们的论坛注册或加入QQ群277252742共同学习提高。
好了，现在开始说秘密：这个秘密就叫“绑定”。什么是绑定呢？如果你仔细观察，
会发现Java里每个方法都必需通过它的拥有者来调用：比如person.speak()，Double.
valueOf()，this.doSomething()。这种把我和我的拥有者关联起来的行为就叫做绑定
，在Java语言里，我被绑定给谁是在编译器编译代码的时候就确定了的，这种绑定方式
也叫“编译期绑定”或者“早绑定”。比如，当你看到我的定义中有static修饰符的时
候，我就被绑定到定义我的类上，而不是这个类的实例上（Double.valueOf就是个典型
的例子）；当我不被static修饰的时候，我会被绑定给定义我的类的实例上——我总跟
定义我的类的实例直接关联，所以才会产生多态的效果，这是编译器刻意追求的效果。
聪明的你一定会问：“既然有早绑定，那么一定有晚绑定咯？”你说对了！晚绑定指
的是方法与哪个对象想关联不由编译器来确定，而是在程序运行的时候根据程序逻辑确
定，晚绑定也叫运行期绑定。
因为编译期程序还没有执行，所以也叫静态期（static）；程序运行起来之后又叫动
态期（dynamic），所以，这两种绑定又被分别称为“静态绑定”和“动态绑定”。听
好了：一门编程语言采用何种绑定决定了它是静态语言还是动态语言。像C/C++/Java/C
#等语言都是静态语言（因为它们需要做静态绑定，所以编译器要提前知道数据的类型
，所以静态语言往往是强类型的）；而像JavaScript/Python/Perl等脚本语言，则是动
态语言，因为采用了动态绑定，它们的对象非常灵活多变（当然，也非常容易把程序搞
乱）。
public与private
最后说说两个常见的修饰符吧。特简单~~当我被public修饰的时候，你在别的类的方法
里用能通过与我绑定的类或实例调用我；当我被private修饰的时候，在别的类的方法
里你是看不见我的。如果我没被修饰符所修饰，默认就是private啦~~他们怕我出去惹
事，所以默认把我关在屋里
如果以后你有机会学习C#，你还会遇到virtual修饰符和override修饰符，这俩是一对
儿。父类的方法如果用virtual修饰了，子类标记了override的方法才能重写父类的方
法……还是Java简单，方法重写是天生的。
哦，差点忘了abstract，当我被这个修饰符修饰的时候可省事啦！这时候你只需要定
义我的返回值类型、名字和参数列表，方法体完全不用定义——这时候我只是个抽象的
签名，没有任何实际的算法。这时候的我被称为“抽象方法”，包含我的类叫“抽象类
”，因为我没有具体的算法，所以这个类也因为我的拖累而不完整了。抽象类可以用来
声明变量，但不能用来创建实例——你想啊，如果创建了实例，你又用实例去调用一个
没定义完整的方法，不崩溃才怪！所以，干脆不让你用抽象类来创建实例了。如果你从
抽象类派生了子类，并且在子类里实现（注意：这时候不叫重写，因为抽象方法本身没
有实际的算法，你不可以“重”写）了抽象方法，那它就成一个完成的实现类（
concrete class）了。别看抽象类和抽象方法是“不完整”和“未定义算法”的，但就
是因为它们的不完整使得他们在整个OO设计中有着举足轻重的地位……要领悟这一点，
你还有很长的路要走，大概得写五万行代码吧
这让我想起了那位神龙见首不见尾、虚无飘渺的Ms.Interface——这老姐更是抽象到
皮包骨头，女人嘛，瘦即是可爱……要不为什么架构师们爱她爱到发疯呢。她的事儿，
以后再说吧。
第一集：Mr.Method
Hi，大家好~~我是Mr.Method，和Mr. Okay是好哥们儿。
在所有面向对象的语言里你都能见到我的身影。不信？你们学编程的时候第一个程序
都是Hello World吧？那就是依靠对我的调用实现的——无论是哪个平台、哪种语言，
你一定调用了在命令行里输出字符串的某个Method。
铁三角
在正式介绍我自己之前，还是先说说我的哥哥和妹妹吧，我们的家庭背景有助于大家
对我有一个更好的了解。我的哥哥（Mr. Class）和小妹（Mr. Field）加上我，我们仨
可是面向对象家庭里绝对的主角、“铁三角”。我们三个之所以称为“铁三角”是因为
我们各司其职、配合的非常默契。Mr.Class，他是个很好的组织者，他能把从现实世界
抽象出来的结果良好地组织在一起（这个叫“封装”）——我（Mr.Method）和我小妹
（Ms. Field）被我哥管着（注：被封装在类里）。小妹负责表示我们这个小组织当前
的状态，而我负责我们这个小组织能干什么。有的时候小妹的状态会决定我能不能做一
些事——比如我想买个什么东西，小妹说：“没钱！”那我就不能执行了。而有的时候
我的行为也会影响到小妹的状态——比如我买了辆新车，那么就会从小妹那里减去一些
钱。女孩子家，怕她受伤受骗什么的，一般情况下我们不会让外人直接接触小妹，所以
，保护小妹的事情也由我来负责。总之呢，你知道我在这个小组织里是个跑腿儿的（表
示这个组织能干什么）、同时还是小妹的保护伞，这就足够了。
我的前身
面向对象编程在软件界算是个划时代的进步，之前那个时代叫“面向过程时代”，现
在仍然有面向过程的程序在编写，但远不像以前那么多了。回退二三十年，面向过程流
行的年代，那时候我还不叫Mr.Method，那时候我叫Mr.Funtion。后来有了面向对象，
Function被类所封装管理，于是我们被称为“类的方法”（methods of class），用来
表示这个类能做些什么事情。因为我们是类的成员，被封装在类里，所以从面向过程年
代过来的老程序员们仍然喜欢叫我们Mr. Member Function（成员函数），每当听到这
个名字，我都感觉好好亲切……好好感动……好好内牛满面。算了……过去的事情了。
因为我表达的是“一个类能干什么”，所以，程序中真正做事的——是我。我之所以
能“做事”，全靠程序员们为我编写的代码逻辑（method body），也就是——算法。
没有算法，我就是个空壳；算法错误，程序就会有bug。如果你想省事，不妨这样记：
Mr.Method==算法，或者算法==Mr.Method。
我的样子
在不同的面向对象语言里，我的样子可能不太一样。就自我感觉而言，我还是认为我
在Java/C#/C++语言里的样子最帅。所以，今天就聊聊我在Java语言里长什么样吧（注
：方法在Java/C#/C++的格式几乎没有区别），谁让你们都想靠学Java找工作、攻学位
呢！
Well，当你在代码里见到我的时候，要么是在定义（define）我，要么是在调用（call
）我。因为定义我时候的样子决定了我被调用时的样子，所以让我们从定义开始。
在观察我的样子之前，请你把我想象成一个“加工厂”。比如，果酱加工厂，你给它
输入水果作为原料，它的内部运转加工，最后把加工好的果酱还给你。当然了，我不负
责加工果酱，我加工的是——数据。
OK，来看我被定义时的样子，从前往后依次是：
1. 返回值类型：直截了当地告诉你我的产品是什么。不过，有的时候我并没有产出，
而是默默地做完某些事情（比如阻挡不速之客访问我小妹的值），这时候为了统一起见
，我也会有一个看上去像是返回值类型的void摆在那里。我之所以说在Java/C#/C++里
长的帅，就是因为这些语言在语法格式上的统一。
2. 名字：我的名字必需符合Java语言的符号命名规范，而且使用用caml格式（注：在C
#里使用Pascal格式，C#的发明人Anders先生将以Pascal语言为蓝本的DELPHI开发环境
的一些特性引入了C#，使其语言格式看上去更优雅；而Java则保留了一些C++中的原始
美）。
3. 参数列表：由一对括号括起来的一组“类型->参数名”对，参数列表中的参数可以
是0个、1个、2个...当参数为0个时，也可以说这个方法没有参数；当参数多于1个时，
“类型->参数”对之间要用逗号分隔。
4. 方法体：由一对花括号包围，方法体里就是对数据的加工逻辑了，也就是真正的算
法。翻过头去看下第1项：如果这个方法有返回值（不是void），那么方法体里必需保
证有return语句返回一个与返回值类型相匹配的值（思考：为什么我用的是“相匹配”
而不是“一样”？）。
另外，有的时候我也喜欢打扮一下自己、在整个定义之前加几个修饰符（modifier）
什么的，最常见的就是public或private与static的组合。换句话说，这四种修饰占到
80%以上的情况——(1)public, (2)private, (3)public static, (4)private static
。具体这四种修饰是什么意思，后面会讲到，现在你不必特别在意。
下面是我被定义时常见的样子，请你们自己把上面说的四个部分找出来吧！
================================================
// 无返回值，无参数
void sayHello() {
// 逻辑
}
// 无返回值，1个参数
void sayHello(String friendName){
// 逻辑
}
// 有返回值，1个参数
double convertDollarToRmb(double dollarValue){
double rmbValue = 0;
// 逻辑
return rmbValue;
}
// 有返回值，2个参数
double add(double input1, double input2)
{
double result = input1+input2;
return result;
}
================================================
知道了我在定义的时候长什么样子，那么有一件事就要记清楚了：我的定义只可能出现
在类体里，也就是类的那层花括号里。换句话说，无论我被定义在类体之外，还是在其
它方法体的内部，编译器都不会让你通过的。我在C#里跟在Java里差不多，但在C++里
有那么一点变化，就是我仍然可以被定义在类体之外，这时候我被称为“全局方法”或
“全局函数”，这体现了C++的一种贴近底层的“原始美”，但跟我们学Java的没什么
关系啦^^。（思考：main方法也是一个方法，你能找出它的四个部分吗？）
说完了我被定义时的样子，再来说说我被调用的时候长什么样子吧——看上去跟被定
义的时候长的差不多，但一定要记住，我只能在方法体里被调用（即方法的调用一定只
能是在其它方法的方法体里出现）。科学点讲，当方法B被方法A调用时，方法B出现在
方法A的方法体里，构成了方法A算法的一部分；这时方法A被称为调用者（caller），
方法B被称为被调者（callee）；如果方法B又去调用了方法C，那么会就形成A-->B-->C
这样一个调用层级，学名叫做调用栈（call stack）。
下面是上面四个方法定义在被调用时的样子：
================================================
void callAllMethods()
{
sayHello();
sayHello("Mr.Okay");
double rmb = convertDollarToRmb(1000000);
double r = add(1.5, 3.7);
add(9.9, 0.1); // 这是可以的，但没意义
}
================================================
仔细看，你会发现几处需要注意的地方：
1. 我在被调用的时候，参数的类型就不用写了，因为那是定义我的时候所用的语法，
不是调用的语法，这里我见过太多初学者写错了。
2. 对于有返回值的方法，你需要搞一个变量来接收这个返回值。当然了，不接收也可
以，但这样做就没什么意义了。以前有过一种这样风格的方法定义，但现代编程格式已
经渐渐把这种方法淘汰了。
3. 就算一个方法没有参数，调用我的时候名字后面的那对括号也不能省略，因为你省
略了，编译器会认为你只是提到了我的名字，而没有“调用”我。（）
我的参数
Well，我知道有很多人纠结于“为什么在调用的时候不用写参数类型呀？” “调用的
时候传进去的参数名字是不是必需要和定义时的一样呀？” 这类问题。只要明白了我
的参数，那么这些问题就都明白了。简单讲，我在被定义的时候，参数列表（就是名字
后圆括号里的“类型->参数名”对）叫“形式参数”；而我在被调用的时候，传给我的
参数是真的要被操作的数据，所以叫“实际参数”。下面我来给大家解释解释。
所谓“形式参数”，就是走走形式嘛~~没什么了不起的。这里说的“走走形式”指的
是这些形式参数要参与到我被定义的算法里，在算法里“走走形式”。比如，有这样一
个方法（用伪码表示）：
================
果酱 果酱机(水果 某个水果，干果 某个干果，调料 主调料， 调料 配料)
{
把某个水果切碎磨细；
把某个干果切成粒；
加入主调料；
加入配料；
混合均匀；
返回果酱；
}
=================
这里大家看到的是，“某个水果”、“某个干果”、“主调料”和“配料”都作为跑龙
套的形式参数参与到了果酱的生产算法中。
下面再看调用，看起来是这样（必需被其它的方法所调用）：
=================
void 做果酱()
{
水果 我的水果=买来一个苹果；
干果 我的干果=上回剩下的一包杏仁；
调料 甜料=家里的砂糖；
调料 酸料=冰箱里的柠檬汁；
果酱 新做的果酱=果酱机（我的水果，我的干果，甜料，酸料）；
吃果酱；
吃果酱；
吃果酱；
吃果酱；
// ...
上医院；
}
==================
现在大家应该明白了吧？当调用果酱机方法做果酱的时候，我必需得投入真材实料才能
做出真的果酱来，也就是让先前定义好的算法得以执行。因为是真材实料嘛，所以叫“
实际参数”，简称“实参”。
因为在方法定义的时候就已经要求了参数的类型，所以在调用的时候你只需要把类型
匹配的实参传进方法就行了，不必再次写参数的类型。
顺带跟大家说一下，大家可能一上Java课的时候就听说过“Java是强类型语言”这句
话，这句话怎么理解呢？
关于强类型
想象一下如果这样调用果酱机方法，
=================
void 做果酱()
{
石头 我的石头=拣来一块石头；
沙子 我的沙子=挖来一袋沙子；
调料 甜料=家里的砂糖；
调料 酸料=冰箱里的柠檬汁；
果酱 新做的果酱=果酱机（我的石头，我的沙子，甜料，酸料）；// 你玩儿我？
？！！
吃果酱；
吃果酱；
吃果酱；
吃果酱；
// ...
上医院；// 死翘翘
}
==================
My god！这做出来的东西能吃吗？
你别说，如果这是个C/C++函数（function），说不定真能把“果酱”给你做出来，也
就是说，函数在执行的时候不会报错，而且能返回给你结果，但如果你想拿这个结果做
点什么事情，那结果是不可预知的。这也就是我们常说的C/C++是类型不安全的（现代C
++要好很多）。但如果果酱机方法是用Java语言写的，因为Java是类型安全的语言，所
以你在做这个调用的时候“果酱 新做的果酱=果酱机（我的石头，我的沙子，甜料，酸
料）；”编译器就不让你通过，因为你给的实参类型与定义时的形参类型不匹配。
说说重载（overload）
问你个问题：在同一个类里定义方法的时候，方法名可以相同吗？答案是：“可以！
”但有个要求——方法名相同的时候参数列表不可以再相同。这种方法名相同、参数列
表不同的情况称为方法的重载。前面定义的两个sayHello方法就构成了重载。
这里有几点需要注意的：
1. 参数列表不同，包括了参数的个数不同、类型不同。比如：void myMethod(String
input1, double input2){...}和void myMethod(double input1, String input2){...
}就构成重载。
2. 只改参数名是不能构成重载的。比如：void myMethod(String input1, double
input2){...}和void myMethod(String arg1, double arg2){...}是不重载的。
3. 只改返回值类型也不能构成重载。比如：void myMethod(String input1, double
input2){...}和double myMethod(String input1, double input2){...}是不重载的。
其实大家应该已经发现了，决定两个方法是否重载的是方法定义四个部分中的方法名加
参数列表部分。所以，这两个部分（方法名+参数列表）又称为“方法签名”（method
signature），也就是这两部分的组合确定了一个方法的唯一性。
说说重写（override）
按理说重写这事儿非常简单，但它却与面向对象最核心的一个概念“多态”搅和在一
起了，所以在有些神话传说里会把重写和多态写的云里雾里、神乎其神。其实别听那套
~~很简单的。
咱们先不理多态的茬，只说重写。它的概念是：如果在父类里定义了一个方法A，在这
个父类的子类里你再次定义了方法A，它的返回值类型、方法名、参数列表与父类中的
方法A完全一致，那么我们就说子类中的方法A就对父类中的方法A进行了重写。这再好
理解不过了——方法定义的前三部分安全一样，只有方法体不一样，当然就是子类方法
把父类方法的算法逻辑给覆盖重写了。看例子：
=================
public class Person
{
public void speak()
{
System.out.println("I'm a person.");
}
}
public class Student extends Person
{
public void speak()
{
System.out.println("I'm a student.");
}
}
public class Teacher extends Person
{
public void speak()
{
System.out.println("I'm a teacher.");
}
}
=================
例子中的Person类是Student类和Teacher类的父类（倒过来说，Student和Teacher是
Person的子类或派生类）。它们都拥有返回值类型、名字、参数列表完全相同的方法
speak，所以，Student类和Teacher类里的speak方法对Person类的speak方法构成了重
写。
切记一句话：重写用的好，是福；用不好，是项目里最大的祸害。
多态（polymorphism）——事情有点儿复杂了
什么是多态呢？它可以算得上是OO的重中之重了，它可以这么定义——当用一个父类
类型的变量引用一个子类类型的实例时，通过父类类型的变量调用一个被重载的方法时
，被执行的总是被子类所重写后的版本。看！多态是以重写为基础的。单看定义是很难
明白的，让我们看个例子。
首先，我们在“重写”例子代码上再加一个类：
=================
public class CseTeacher extends Teacher
{
public void speak()
{
System.out.println("I'm a CSE teacher.");
}
}
=================
这个CseTeacher类对Teacher类的speak做了重写（这是再度重写了）。那么，下面这组
方法调用的输出是什么呢？
public class Program
{
public static void main(String[] args)
{
Person person; // 父类类型变量，请注意，它只是个变量，不是实例
person = new Person(); // 变量与实例的类型一致
person.speak();
person = new Student(); // 父类类型变量引用子类实例
person.speak();
person = new Teacher(); // 父类类型变量引用子类实例
person.speak();
person = new CseTeacher(); // 父类类型变量引用子类实例
person.speak();
Teacher teacher = new CseTeacher(); // 父类类型变量引用子类实例
teacher.speak();
}
}
答案是：
I'm a person.
I'm a student.
I'm a teacher.
I'm a CSE teacher.
I'm a CSE teacher.
===================
多态背后的秘密——绑定（bind）
多态是不是很神奇啊？我来向你透露一点它的秘密吧！不过，在我透露这个秘密之前
，我先说一下版权的事儿：咳咳，本系列原创文章发表在http://ladder.azurewebsites.net，转载的话请注明出处，如果你喜欢，欢迎在我们的论坛注册或加入QQ群277252742共同学习提高。
好了，现在开始说秘密：这个秘密就叫“绑定”。什么是绑定呢？如果你仔细观察，
会发现Java里每个方法都必需通过它的拥有者来调用：比如person.speak()，Double.
valueOf()，this.doSomething()。这种把我和我的拥有者关联起来的行为就叫做绑定
，在Java语言里，我被绑定给谁是在编译器编译代码的时候就确定了的，这种绑定方式
也叫“编译期绑定”或者“早绑定”。比如，当你看到我的定义中有static修饰符的时
候，我就被绑定到定义我的类上，而不是这个类的实例上（Double.valueOf就是个典型
的例子）；当我不被static修饰的时候，我会被绑定给定义我的类的实例上——我总跟
定义我的类的实例直接关联，所以才会产生多态的效果，这是编译器刻意追求的效果。
聪明的你一定会问：“既然有早绑定，那么一定有晚绑定咯？”你说对了！晚绑定指
的是方法与哪个对象想关联不由编译器来确定，而是在程序运行的时候根据程序逻辑确
定，晚绑定也叫运行期绑定。
因为编译期程序还没有执行，所以也叫静态期（static）；程序运行起来之后又叫动
态期（dynamic），所以，这两种绑定又被分别称为“静态绑定”和“动态绑定”。听
好了：一门编程语言采用何种绑定决定了它是静态语言还是动态语言。像C/C++/Java/C
#等语言都是静态语言（因为它们需要做静态绑定，所以编译器要提前知道数据的类型
，所以静态语言往往是强类型的）；而像JavaScript/Python/Perl等脚本语言，则是动
态语言，因为采用了动态绑定，它们的对象非常灵活多变（当然，也非常容易把程序搞
乱）。
public与private
最后说说两个常见的修饰符吧。特简单~~当我被public修饰的时候，你在别的类的方法
里用能通过与我绑定的类或实例调用我；当我被private修饰的时候，在别的类的方法
里你是看不见我的。如果我没被修饰符所修饰，默认就是private啦~~他们怕我出去惹
事，所以默认把我关在屋里
如果以后你有机会学习C#，你还会遇到virtual修饰符和override修饰符，这俩是一对
儿。父类的方法如果用virtual修饰了，子类标记了override的方法才能重写父类的方
法……还是Java简单，方法重写是天生的。
哦，差点忘了abstract，当我被这个修饰符修饰的时候可省事啦！这时候你只需要定
义我的返回值类型、名字和参数列表，方法体完全不用定义——这时候我只是个抽象的
签名，没有任何实际的算法。这时候的我被称为“抽象方法”，包含我的类叫“抽象类
”，因为我没有具体的算法，所以这个类也因为我的拖累而不完整了。抽象类可以用来
声明变量，但不能用来创建实例——你想啊，如果创建了实例，你又用实例去调用一个
没定义完整的方法，不崩溃才怪！所以，干脆不让你用抽象类来创建实例了。如果你从
抽象类派生了子类，并且在子类里实现（注意：这时候不叫重写，因为抽象方法本身没
有实际的算法，你不可以“重”写）了抽象方法，那它就成一个完成的实现类（
concrete class）了。别看抽象类和抽象方法是“不完整”和“未定义算法”的，但就
是因为它们的不完整使得他们在整个OO设计中有着举足轻重的地位……要领悟这一点，
你还有很长的路要走，大概得写五万行代码吧
这让我想起了那位神龙见首不见尾、虚无飘渺的Ms.Interface——这老姐更是抽象到
皮包骨头，女人嘛，瘦即是可爱……要不为什么架构师们爱她爱到发疯呢。她的事儿，
以后再说吧。
p*n
9 楼
平安台词：要完蛋就一起完蛋，谁也别想跑！
k*n
10 楼
哪个美女版？
【在 p****t 的大作中提到】
: 心血来潮，把尘封了有两年的第二代20G的硬盘版iPod给充了会电，接上TF10，听德国
: 美女版维瓦尔第的“四季”，还是很不错的啊，对比了一下PK2，TF10的气势显然要足
: 了不少啊，不错不错。
【在 p****t 的大作中提到】
: 心血来潮，把尘封了有两年的第二代20G的硬盘版iPod给充了会电，接上TF10，听德国
: 美女版维瓦尔第的“四季”，还是很不错的啊，对比了一下PK2，TF10的气势显然要足
: 了不少啊，不错不错。
s*g
11 楼
US.
【在 s****e 的大作中提到】
: H1, 准备在fidelity开个 roth IRA, 有一选项是Country of Tax Residence，不知道
: 应该US还是China. 麻烦开过的人指点
: 一下，谢谢。
【在 s****e 的大作中提到】
: H1, 准备在fidelity开个 roth IRA, 有一选项是Country of Tax Residence，不知道
: 应该US还是China. 麻烦开过的人指点
: 一下，谢谢。
x*g
12 楼
沙发！谢
【在 P********p 的大作中提到】
: [果子店狗血穿越] 来自五代的你 （69）一对故人
: 上回书说到，果子一行在官道上被守夜人的卫队拦住敲诈，强行要求他们到同福客栈投
: 宿。多亏了瓜老板的圆滑，双方才没动起手来。
: 但是这样一来，毕竟憋了一肚子气，一行人各怀心事，终于赶到了渡口。举目一看，不
: 由得叫起苦来。原来果然如同守夜人说的那样，渡口上一条船也没有。不仅如此，这渡
: 口是冷冷清清，只有一间客栈。果子叫道：“这里还真是黑店啊，怎么就只有这一家店
: ？”
: 瓜老板叹道：“也许是因为夏汛刚过，洪水才退的缘故吧。不管怎么样，咱们是要在这
: 里打尖了，你看，离这里最近的渡口也要在百里之外，恐怕等咱们到了河对面的关家庄
: ，这戏也散了。”
【在 P********p 的大作中提到】
: [果子店狗血穿越] 来自五代的你 （69）一对故人
: 上回书说到，果子一行在官道上被守夜人的卫队拦住敲诈，强行要求他们到同福客栈投
: 宿。多亏了瓜老板的圆滑，双方才没动起手来。
: 但是这样一来，毕竟憋了一肚子气，一行人各怀心事，终于赶到了渡口。举目一看，不
: 由得叫起苦来。原来果然如同守夜人说的那样，渡口上一条船也没有。不仅如此，这渡
: 口是冷冷清清，只有一间客栈。果子叫道：“这里还真是黑店啊，怎么就只有这一家店
: ？”
: 瓜老板叹道：“也许是因为夏汛刚过，洪水才退的缘故吧。不管怎么样，咱们是要在这
: 里打尖了，你看，离这里最近的渡口也要在百里之外，恐怕等咱们到了河对面的关家庄
: ，这戏也散了。”
a*a
13 楼
原文链接：http://ladder.azurewebsites.net/forum.php?mod=viewthread&tid=121&extra=page%3D1
第一集：Mr.Method
Hi，大家好~~我是Mr.Method，和Mr. Okay是好哥们儿。
在所有面向对象的语言里你都能见到我的身影。不信？你们学编程的时候第一个程序
都是Hello World吧？那就是依靠对我的调用实现的——无论是哪个平台、哪种语言，
你一定调用了在命令行里输出字符串的某个Method。
铁三角
在正式介绍我自己之前，还是先说说我的哥哥和妹妹吧，我们的家庭背景有助于大家
对我有一个更好的了解。我的哥哥（Mr. Class）和小妹（Mr. Field）加上我，我们仨
可是面向对象家庭里绝对的主角、“铁三角”。我们三个之所以称为“铁三角”是因为
我们各司其职、配合的非常默契。Mr.Class，他是个很好的组织者，他能把从现实世界
抽象出来的结果良好地组织在一起（这个叫“封装”）——我（Mr.Method）和我小妹
（Ms. Field）被我哥管着（注：被封装在类里）。小妹负责表示我们这个小组织当前
的状态，而我负责我们这个小组织能干什么。有的时候小妹的状态会决定我能不能做一
些事——比如我想买个什么东西，小妹说：“没钱！”那我就不能执行了。而有的时候
我的行为也会影响到小妹的状态——比如我买了辆新车，那么就会从小妹那里减去一些
钱。女孩子家，怕她受伤受骗什么的，一般情况下我们不会让外人直接接触小妹，所以
，保护小妹的事情也由我来负责。总之呢，你知道我在这个小组织里是个跑腿儿的（表
示这个组织能干什么）、同时还是小妹的保护伞，这就足够了。
我的前身
面向对象编程在软件界算是个划时代的进步，之前那个时代叫“面向过程时代”，现
在仍然有面向过程的程序在编写，但远不像以前那么多了。回退二三十年，面向过程流
行的年代，那时候我还不叫Mr.Method，那时候我叫Mr.Funtion。后来有了面向对象，
Function被类所封装管理，于是我们被称为“类的方法”（methods of class），用来
表示这个类能做些什么事情。因为我们是类的成员，被封装在类里，所以从面向过程年
代过来的老程序员们仍然喜欢叫我们Mr. Member Function（成员函数），每当听到这
个名字，我都感觉好好亲切……好好感动……好好内牛满面。算了……过去的事情了。
因为我表达的是“一个类能干什么”，所以，程序中真正做事的——是我。我之所以
能“做事”，全靠程序员们为我编写的代码逻辑（method body），也就是——算法。
没有算法，我就是个空壳；算法错误，程序就会有bug。如果你想省事，不妨这样记：
Mr.Method==算法，或者算法==Mr.Method。
我的样子
在不同的面向对象语言里，我的样子可能不太一样。就自我感觉而言，我还是认为我
在Java/C#/C++语言里的样子最帅。所以，今天就聊聊我在Java语言里长什么样吧（注
：方法在Java/C#/C++的格式几乎没有区别），谁让你们都想靠学Java找工作、攻学位
呢！
Well，当你在代码里见到我的时候，要么是在定义（define）我，要么是在调用（call
）我。因为定义我时候的样子决定了我被调用时的样子，所以让我们从定义开始。
在观察我的样子之前，请你把我想象成一个“加工厂”。比如，果酱加工厂，你给它
输入水果作为原料，它的内部运转加工，最后把加工好的果酱还给你。当然了，我不负
责加工果酱，我加工的是——数据。
OK，来看我被定义时的样子，从前往后依次是：
1. 返回值类型：直截了当地告诉你我的产品是什么。不过，有的时候我并没有产出，
而是默默地做完某些事情（比如阻挡不速之客访问我小妹的值），这时候为了统一起见
，我也会有一个看上去像是返回值类型的void摆在那里。我之所以说在Java/C#/C++里
长的帅，就是因为这些语言在语法格式上的统一。
2. 名字：我的名字必需符合Java语言的符号命名规范，而且使用用caml格式（注：在C
#里使用Pascal格式，C#的发明人Anders先生将以Pascal语言为蓝本的DELPHI开发环境
的一些特性引入了C#，使其语言格式看上去更优雅；而Java则保留了一些C++中的原始
美）。
3. 参数列表：由一对括号括起来的一组“类型->参数名”对，参数列表中的参数可以
是0个、1个、2个...当参数为0个时，也可以说这个方法没有参数；当参数多于1个时，
“类型->参数”对之间要用逗号分隔。
4. 方法体：由一对花括号包围，方法体里就是对数据的加工逻辑了，也就是真正的算
法。翻过头去看下第1项：如果这个方法有返回值（不是void），那么方法体里必需保
证有return语句返回一个与返回值类型相匹配的值（思考：为什么我用的是“相匹配”
而不是“一样”？）。
另外，有的时候我也喜欢打扮一下自己、在整个定义之前加几个修饰符（modifier）
什么的，最常见的就是public或private与static的组合。换句话说，这四种修饰占到
80%以上的情况——(1)public, (2)private, (3)public static, (4)private static
。具体这四种修饰是什么意思，后面会讲到，现在你不必特别在意。
下面是我被定义时常见的样子，请你们自己把上面说的四个部分找出来吧！
================================================
// 无返回值，无参数
void sayHello() {
// 逻辑
}
// 无返回值，1个参数
void sayHello(String friendName){
// 逻辑
}
// 有返回值，1个参数
double convertDollarToRmb(double dollarValue){
double rmbValue = 0;
// 逻辑
return rmbValue;
}
// 有返回值，2个参数
double add(double input1, double input2)
{
double result = input1+input2;
return result;
}
================================================
知道了我在定义的时候长什么样子，那么有一件事就要记清楚了：我的定义只可能出现
在类体里，也就是类的那层花括号里。换句话说，无论我被定义在类体之外，还是在其
它方法体的内部，编译器都不会让你通过的。我在C#里跟在Java里差不多，但在C++里
有那么一点变化，就是我仍然可以被定义在类体之外，这时候我被称为“全局方法”或
“全局函数”，这体现了C++的一种贴近底层的“原始美”，但跟我们学Java的没什么
关系啦^^。（思考：main方法也是一个方法，你能找出它的四个部分吗？）
说完了我被定义时的样子，再来说说我被调用的时候长什么样子吧——看上去跟被定
义的时候长的差不多，但一定要记住，我只能在方法体里被调用（即方法的调用一定只
能是在其它方法的方法体里出现）。科学点讲，当方法B被方法A调用时，方法B出现在
方法A的方法体里，构成了方法A算法的一部分；这时方法A被称为调用者（caller），
方法B被称为被调者（callee）；如果方法B又去调用了方法C，那么会就形成A-->B-->C
这样一个调用层级，学名叫做调用栈（call stack）。
下面是上面四个方法定义在被调用时的样子：
================================================
void callAllMethods()
{
sayHello();
sayHello("Mr.Okay");
double rmb = convertDollarToRmb(1000000);
double r = add(1.5, 3.7);
add(9.9, 0.1); // 这是可以的，但没意义
}
================================================
仔细看，你会发现几处需要注意的地方：
1. 我在被调用的时候，参数的类型就不用写了，因为那是定义我的时候所用的语法，
不是调用的语法，这里我见过太多初学者写错了。
2. 对于有返回值的方法，你需要搞一个变量来接收这个返回值。当然了，不接收也可
以，但这样做就没什么意义了。以前有过一种这样风格的方法定义，但现代编程格式已
经渐渐把这种方法淘汰了。
3. 就算一个方法没有参数，调用我的时候名字后面的那对括号也不能省略，因为你省
略了，编译器会认为你只是提到了我的名字，而没有“调用”我。（）
我的参数
Well，我知道有很多人纠结于“为什么在调用的时候不用写参数类型呀？” “调用的
时候传进去的参数名字是不是必需要和定义时的一样呀？” 这类问题。只要明白了我
的参数，那么这些问题就都明白了。简单讲，我在被定义的时候，参数列表（就是名字
后圆括号里的“类型->参数名”对）叫“形式参数”；而我在被调用的时候，传给我的
参数是真的要被操作的数据，所以叫“实际参数”。下面我来给大家解释解释。
所谓“形式参数”，就是走走形式嘛~~没什么了不起的。这里说的“走走形式”指的
是这些形式参数要参与到我被定义的算法里，在算法里“走走形式”。比如，有这样一
个方法（用伪码表示）：
================
果酱 果酱机(水果 某个水果，干果 某个干果，调料 主调料， 调料 配料)
{
把某个水果切碎磨细；
把某个干果切成粒；
加入主调料；
加入配料；
混合均匀；
返回果酱；
}
=================
这里大家看到的是，“某个水果”、“某个干果”、“主调料”和“配料”都作为跑龙
套的形式参数参与到了果酱的生产算法中。
下面再看调用，看起来是这样（必需被其它的方法所调用）：
=================
void 做果酱()
{
水果 我的水果=买来一个苹果；
干果 我的干果=上回剩下的一包杏仁；
调料 甜料=家里的砂糖；
调料 酸料=冰箱里的柠檬汁；
果酱 新做的果酱=果酱机（我的水果，我的干果，甜料，酸料）；
吃果酱；
吃果酱；
吃果酱；
吃果酱；
// ...
上医院；
}
==================
现在大家应该明白了吧？当调用果酱机方法做果酱的时候，我必需得投入真材实料才能
做出真的果酱来，也就是让先前定义好的算法得以执行。因为是真材实料嘛，所以叫“
实际参数”，简称“实参”。
因为在方法定义的时候就已经要求了参数的类型，所以在调用的时候你只需要把类型
匹配的实参传进方法就行了，不必再次写参数的类型。
顺带跟大家说一下，大家可能一上Java课的时候就听说过“Java是强类型语言”这句
话，这句话怎么理解呢？
关于强类型
想象一下如果这样调用果酱机方法，
=================
void 做果酱()
{
石头 我的石头=拣来一块石头；
沙子 我的沙子=挖来一袋沙子；
调料 甜料=家里的砂糖；
调料 酸料=冰箱里的柠檬汁；
果酱 新做的果酱=果酱机（我的石头，我的沙子，甜料，酸料）；// 你玩儿我？
？！！
吃果酱；
吃果酱；
吃果酱；
吃果酱；
// ...
上医院；// 死翘翘
}
==================
My god！这做出来的东西能吃吗？
你别说，如果这是个C/C++函数（function），说不定真能把“果酱”给你做出来，也
就是说，函数在执行的时候不会报错，而且能返回给你结果，但如果你想拿这个结果做
点什么事情，那结果是不可预知的。这也就是我们常说的C/C++是类型不安全的（现代C
++要好很多）。但如果果酱机方法是用Java语言写的，因为Java是类型安全的语言，所
以你在做这个调用的时候“果酱 新做的果酱=果酱机（我的石头，我的沙子，甜料，酸
料）；”编译器就不让你通过，因为你给的实参类型与定义时的形参类型不匹配。
说说重载（overload）
问你个问题：在同一个类里定义方法的时候，方法名可以相同吗？答案是：“可以！
”但有个要求——方法名相同的时候参数列表不可以再相同。这种方法名相同、参数列
表不同的情况称为方法的重载。前面定义的两个sayHello方法就构成了重载。
这里有几点需要注意的：
1. 参数列表不同，包括了参数的个数不同、类型不同。比如：void myMethod(String
input1, double input2){...}和void myMethod(double input1, String input2){...
}就构成重载。
2. 只改参数名是不能构成重载的。比如：void myMethod(String input1, double
input2){...}和void myMethod(String arg1, double arg2){...}是不重载的。
3. 只改返回值类型也不能构成重载。比如：void myMethod(String input1, double
input2){...}和double myMethod(String input1, double input2){...}是不重载的。
其实大家应该已经发现了，决定两个方法是否重载的是方法定义四个部分中的方法名加
参数列表部分。所以，这两个部分（方法名+参数列表）又称为“方法签名”（method
signature），也就是这两部分的组合确定了一个方法的唯一性。
说说重写（override）
按理说重写这事儿非常简单，但它却与面向对象最核心的一个概念“多态”搅和在一
起了，所以在有些神话传说里会把重写和多态写的云里雾里、神乎其神。其实别听那套
~~很简单的。
咱们先不理多态的茬，只说重写。它的概念是：如果在父类里定义了一个方法A，在这
个父类的子类里你再次定义了方法A，它的返回值类型、方法名、参数列表与父类中的
方法A完全一致，那么我们就说子类中的方法A就对父类中的方法A进行了重写。这再好
理解不过了——方法定义的前三部分安全一样，只有方法体不一样，当然就是子类方法
把父类方法的算法逻辑给覆盖重写了。看例子：
=================
public class Person
{
public void speak()
{
System.out.println("I'm a person.");
}
}
public class Student extends Person
{
public void speak()
{
System.out.println("I'm a student.");
}
}
public class Teacher extends Person
{
public void speak()
{
System.out.println("I'm a teacher.");
}
}
=================
例子中的Person类是Student类和Teacher类的父类（倒过来说，Student和Teacher是
Person的子类或派生类）。它们都拥有返回值类型、名字、参数列表完全相同的方法
speak，所以，Student类和Teacher类里的speak方法对Person类的speak方法构成了重
写。
切记一句话：重写用的好，是福；用不好，是项目里最大的祸害。
多态（polymorphism）——事情有点儿复杂了
什么是多态呢？它可以算得上是OO的重中之重了，它可以这么定义——当用一个父类
类型的变量引用一个子类类型的实例时，通过父类类型的变量调用一个被重载的方法时
，被执行的总是被子类所重写后的版本。看！多态是以重写为基础的。单看定义是很难
明白的，让我们看个例子。
首先，我们在“重写”例子代码上再加一个类：
=================
public class CseTeacher extends Teacher
{
public void speak()
{
System.out.println("I'm a CSE teacher.");
}
}
=================
这个CseTeacher类对Teacher类的speak做了重写（这是再度重写了）。那么，下面这组
方法调用的输出是什么呢？
public class Program
{
public static void main(String[] args)
{
Person person; // 父类类型变量，请注意，它只是个变量，不是实例
person = new Person(); // 变量与实例的类型一致
person.speak();
person = new Student(); // 父类类型变量引用子类实例
person.speak();
person = new Teacher(); // 父类类型变量引用子类实例
person.speak();
person = new CseTeacher(); // 父类类型变量引用子类实例
person.speak();
Teacher teacher = new CseTeacher(); // 父类类型变量引用子类实例
teacher.speak();
}
}
答案是：
I'm a person.
I'm a student.
I'm a teacher.
I'm a CSE teacher.
I'm a CSE teacher.
===================
多态背后的秘密——绑定（bind）
多态是不是很神奇啊？我来向你透露一点它的秘密吧！不过，在我透露这个秘密之前
，我先说一下版权的事儿：咳咳，本系列原创文章发表在http://ladder.azurewebsites.net，转载的话请注明出处，如果你喜欢，欢迎在我们的论坛注册或加入QQ群277252742共同学习提高。
好了，现在开始说秘密：这个秘密就叫“绑定”。什么是绑定呢？如果你仔细观察，
会发现Java里每个方法都必需通过它的拥有者来调用：比如person.speak()，Double.
valueOf()，this.doSomething()。这种把我和我的拥有者关联起来的行为就叫做绑定
，在Java语言里，我被绑定给谁是在编译器编译代码的时候就确定了的，这种绑定方式
也叫“编译期绑定”或者“早绑定”。比如，当你看到我的定义中有static修饰符的时
候，我就被绑定到定义我的类上，而不是这个类的实例上（Double.valueOf就是个典型
的例子）；当我不被static修饰的时候，我会被绑定给定义我的类的实例上——我总跟
定义我的类的实例直接关联，所以才会产生多态的效果，这是编译器刻意追求的效果。
聪明的你一定会问：“既然有早绑定，那么一定有晚绑定咯？”你说对了！晚绑定指
的是方法与哪个对象想关联不由编译器来确定，而是在程序运行的时候根据程序逻辑确
定，晚绑定也叫运行期绑定。
因为编译期程序还没有执行，所以也叫静态期（static）；程序运行起来之后又叫动
态期（dynamic），所以，这两种绑定又被分别称为“静态绑定”和“动态绑定”。听
好了：一门编程语言采用何种绑定决定了它是静态语言还是动态语言。像C/C++/Java/C
#等语言都是静态语言（因为它们需要做静态绑定，所以编译器要提前知道数据的类型
，所以静态语言往往是强类型的）；而像JavaScript/Python/Perl等脚本语言，则是动
态语言，因为采用了动态绑定，它们的对象非常灵活多变（当然，也非常容易把程序搞
乱）。
public与private
最后说说两个常见的修饰符吧。特简单~~当我被public修饰的时候，你在别的类的方法
里用能通过与我绑定的类或实例调用我；当我被private修饰的时候，在别的类的方法
里你是看不见我的。如果我没被修饰符所修饰，默认就是private啦~~他们怕我出去惹
事，所以默认把我关在屋里
如果以后你有机会学习C#，你还会遇到virtual修饰符和override修饰符，这俩是一对
儿。父类的方法如果用virtual修饰了，子类标记了override的方法才能重写父类的方
法……还是Java简单，方法重写是天生的。
哦，差点忘了abstract，当我被这个修饰符修饰的时候可省事啦！这时候你只需要定
义我的返回值类型、名字和参数列表，方法体完全不用定义——这时候我只是个抽象的
签名，没有任何实际的算法。这时候的我被称为“抽象方法”，包含我的类叫“抽象类
”，因为我没有具体的算法，所以这个类也因为我的拖累而不完整了。抽象类可以用来
声明变量，但不能用来创建实例——你想啊，如果创建了实例，你又用实例去调用一个
没定义完整的方法，不崩溃才怪！所以，干脆不让你用抽象类来创建实例了。如果你从
抽象类派生了子类，并且在子类里实现（注意：这时候不叫重写，因为抽象方法本身没
有实际的算法，你不可以“重”写）了抽象方法，那它就成一个完成的实现类（
concrete class）了。别看抽象类和抽象方法是“不完整”和“未定义算法”的，但就
是因为它们的不完整使得他们在整个OO设计中有着举足轻重的地位……要领悟这一点，
你还有很长的路要走，大概得写五万行代码吧
这让我想起了那位神龙见首不见尾、虚无飘渺的Ms.Interface——这老姐更是抽象到
皮包骨头，女人嘛，瘦即是可爱……要不为什么架构师们爱她爱到发疯呢。她的事儿，
以后再说吧。
第一集：Mr.Method
Hi，大家好~~我是Mr.Method，和Mr. Okay是好哥们儿。
在所有面向对象的语言里你都能见到我的身影。不信？你们学编程的时候第一个程序
都是Hello World吧？那就是依靠对我的调用实现的——无论是哪个平台、哪种语言，
你一定调用了在命令行里输出字符串的某个Method。
铁三角
在正式介绍我自己之前，还是先说说我的哥哥和妹妹吧，我们的家庭背景有助于大家
对我有一个更好的了解。我的哥哥（Mr. Class）和小妹（Mr. Field）加上我，我们仨
可是面向对象家庭里绝对的主角、“铁三角”。我们三个之所以称为“铁三角”是因为
我们各司其职、配合的非常默契。Mr.Class，他是个很好的组织者，他能把从现实世界
抽象出来的结果良好地组织在一起（这个叫“封装”）——我（Mr.Method）和我小妹
（Ms. Field）被我哥管着（注：被封装在类里）。小妹负责表示我们这个小组织当前
的状态，而我负责我们这个小组织能干什么。有的时候小妹的状态会决定我能不能做一
些事——比如我想买个什么东西，小妹说：“没钱！”那我就不能执行了。而有的时候
我的行为也会影响到小妹的状态——比如我买了辆新车，那么就会从小妹那里减去一些
钱。女孩子家，怕她受伤受骗什么的，一般情况下我们不会让外人直接接触小妹，所以
，保护小妹的事情也由我来负责。总之呢，你知道我在这个小组织里是个跑腿儿的（表
示这个组织能干什么）、同时还是小妹的保护伞，这就足够了。
我的前身
面向对象编程在软件界算是个划时代的进步，之前那个时代叫“面向过程时代”，现
在仍然有面向过程的程序在编写，但远不像以前那么多了。回退二三十年，面向过程流
行的年代，那时候我还不叫Mr.Method，那时候我叫Mr.Funtion。后来有了面向对象，
Function被类所封装管理，于是我们被称为“类的方法”（methods of class），用来
表示这个类能做些什么事情。因为我们是类的成员，被封装在类里，所以从面向过程年
代过来的老程序员们仍然喜欢叫我们Mr. Member Function（成员函数），每当听到这
个名字，我都感觉好好亲切……好好感动……好好内牛满面。算了……过去的事情了。
因为我表达的是“一个类能干什么”，所以，程序中真正做事的——是我。我之所以
能“做事”，全靠程序员们为我编写的代码逻辑（method body），也就是——算法。
没有算法，我就是个空壳；算法错误，程序就会有bug。如果你想省事，不妨这样记：
Mr.Method==算法，或者算法==Mr.Method。
我的样子
在不同的面向对象语言里，我的样子可能不太一样。就自我感觉而言，我还是认为我
在Java/C#/C++语言里的样子最帅。所以，今天就聊聊我在Java语言里长什么样吧（注
：方法在Java/C#/C++的格式几乎没有区别），谁让你们都想靠学Java找工作、攻学位
呢！
Well，当你在代码里见到我的时候，要么是在定义（define）我，要么是在调用（call
）我。因为定义我时候的样子决定了我被调用时的样子，所以让我们从定义开始。
在观察我的样子之前，请你把我想象成一个“加工厂”。比如，果酱加工厂，你给它
输入水果作为原料，它的内部运转加工，最后把加工好的果酱还给你。当然了，我不负
责加工果酱，我加工的是——数据。
OK，来看我被定义时的样子，从前往后依次是：
1. 返回值类型：直截了当地告诉你我的产品是什么。不过，有的时候我并没有产出，
而是默默地做完某些事情（比如阻挡不速之客访问我小妹的值），这时候为了统一起见
，我也会有一个看上去像是返回值类型的void摆在那里。我之所以说在Java/C#/C++里
长的帅，就是因为这些语言在语法格式上的统一。
2. 名字：我的名字必需符合Java语言的符号命名规范，而且使用用caml格式（注：在C
#里使用Pascal格式，C#的发明人Anders先生将以Pascal语言为蓝本的DELPHI开发环境
的一些特性引入了C#，使其语言格式看上去更优雅；而Java则保留了一些C++中的原始
美）。
3. 参数列表：由一对括号括起来的一组“类型->参数名”对，参数列表中的参数可以
是0个、1个、2个...当参数为0个时，也可以说这个方法没有参数；当参数多于1个时，
“类型->参数”对之间要用逗号分隔。
4. 方法体：由一对花括号包围，方法体里就是对数据的加工逻辑了，也就是真正的算
法。翻过头去看下第1项：如果这个方法有返回值（不是void），那么方法体里必需保
证有return语句返回一个与返回值类型相匹配的值（思考：为什么我用的是“相匹配”
而不是“一样”？）。
另外，有的时候我也喜欢打扮一下自己、在整个定义之前加几个修饰符（modifier）
什么的，最常见的就是public或private与static的组合。换句话说，这四种修饰占到
80%以上的情况——(1)public, (2)private, (3)public static, (4)private static
。具体这四种修饰是什么意思，后面会讲到，现在你不必特别在意。
下面是我被定义时常见的样子，请你们自己把上面说的四个部分找出来吧！
================================================
// 无返回值，无参数
void sayHello() {
// 逻辑
}
// 无返回值，1个参数
void sayHello(String friendName){
// 逻辑
}
// 有返回值，1个参数
double convertDollarToRmb(double dollarValue){
double rmbValue = 0;
// 逻辑
return rmbValue;
}
// 有返回值，2个参数
double add(double input1, double input2)
{
double result = input1+input2;
return result;
}
================================================
知道了我在定义的时候长什么样子，那么有一件事就要记清楚了：我的定义只可能出现
在类体里，也就是类的那层花括号里。换句话说，无论我被定义在类体之外，还是在其
它方法体的内部，编译器都不会让你通过的。我在C#里跟在Java里差不多，但在C++里
有那么一点变化，就是我仍然可以被定义在类体之外，这时候我被称为“全局方法”或
“全局函数”，这体现了C++的一种贴近底层的“原始美”，但跟我们学Java的没什么
关系啦^^。（思考：main方法也是一个方法，你能找出它的四个部分吗？）
说完了我被定义时的样子，再来说说我被调用的时候长什么样子吧——看上去跟被定
义的时候长的差不多，但一定要记住，我只能在方法体里被调用（即方法的调用一定只
能是在其它方法的方法体里出现）。科学点讲，当方法B被方法A调用时，方法B出现在
方法A的方法体里，构成了方法A算法的一部分；这时方法A被称为调用者（caller），
方法B被称为被调者（callee）；如果方法B又去调用了方法C，那么会就形成A-->B-->C
这样一个调用层级，学名叫做调用栈（call stack）。
下面是上面四个方法定义在被调用时的样子：
================================================
void callAllMethods()
{
sayHello();
sayHello("Mr.Okay");
double rmb = convertDollarToRmb(1000000);
double r = add(1.5, 3.7);
add(9.9, 0.1); // 这是可以的，但没意义
}
================================================
仔细看，你会发现几处需要注意的地方：
1. 我在被调用的时候，参数的类型就不用写了，因为那是定义我的时候所用的语法，
不是调用的语法，这里我见过太多初学者写错了。
2. 对于有返回值的方法，你需要搞一个变量来接收这个返回值。当然了，不接收也可
以，但这样做就没什么意义了。以前有过一种这样风格的方法定义，但现代编程格式已
经渐渐把这种方法淘汰了。
3. 就算一个方法没有参数，调用我的时候名字后面的那对括号也不能省略，因为你省
略了，编译器会认为你只是提到了我的名字，而没有“调用”我。（）
我的参数
Well，我知道有很多人纠结于“为什么在调用的时候不用写参数类型呀？” “调用的
时候传进去的参数名字是不是必需要和定义时的一样呀？” 这类问题。只要明白了我
的参数，那么这些问题就都明白了。简单讲，我在被定义的时候，参数列表（就是名字
后圆括号里的“类型->参数名”对）叫“形式参数”；而我在被调用的时候，传给我的
参数是真的要被操作的数据，所以叫“实际参数”。下面我来给大家解释解释。
所谓“形式参数”，就是走走形式嘛~~没什么了不起的。这里说的“走走形式”指的
是这些形式参数要参与到我被定义的算法里，在算法里“走走形式”。比如，有这样一
个方法（用伪码表示）：
================
果酱 果酱机(水果 某个水果，干果 某个干果，调料 主调料， 调料 配料)
{
把某个水果切碎磨细；
把某个干果切成粒；
加入主调料；
加入配料；
混合均匀；
返回果酱；
}
=================
这里大家看到的是，“某个水果”、“某个干果”、“主调料”和“配料”都作为跑龙
套的形式参数参与到了果酱的生产算法中。
下面再看调用，看起来是这样（必需被其它的方法所调用）：
=================
void 做果酱()
{
水果 我的水果=买来一个苹果；
干果 我的干果=上回剩下的一包杏仁；
调料 甜料=家里的砂糖；
调料 酸料=冰箱里的柠檬汁；
果酱 新做的果酱=果酱机（我的水果，我的干果，甜料，酸料）；
吃果酱；
吃果酱；
吃果酱；
吃果酱；
// ...
上医院；
}
==================
现在大家应该明白了吧？当调用果酱机方法做果酱的时候，我必需得投入真材实料才能
做出真的果酱来，也就是让先前定义好的算法得以执行。因为是真材实料嘛，所以叫“
实际参数”，简称“实参”。
因为在方法定义的时候就已经要求了参数的类型，所以在调用的时候你只需要把类型
匹配的实参传进方法就行了，不必再次写参数的类型。
顺带跟大家说一下，大家可能一上Java课的时候就听说过“Java是强类型语言”这句
话，这句话怎么理解呢？
关于强类型
想象一下如果这样调用果酱机方法，
=================
void 做果酱()
{
石头 我的石头=拣来一块石头；
沙子 我的沙子=挖来一袋沙子；
调料 甜料=家里的砂糖；
调料 酸料=冰箱里的柠檬汁；
果酱 新做的果酱=果酱机（我的石头，我的沙子，甜料，酸料）；// 你玩儿我？
？！！
吃果酱；
吃果酱；
吃果酱；
吃果酱；
// ...
上医院；// 死翘翘
}
==================
My god！这做出来的东西能吃吗？
你别说，如果这是个C/C++函数（function），说不定真能把“果酱”给你做出来，也
就是说，函数在执行的时候不会报错，而且能返回给你结果，但如果你想拿这个结果做
点什么事情，那结果是不可预知的。这也就是我们常说的C/C++是类型不安全的（现代C
++要好很多）。但如果果酱机方法是用Java语言写的，因为Java是类型安全的语言，所
以你在做这个调用的时候“果酱 新做的果酱=果酱机（我的石头，我的沙子，甜料，酸
料）；”编译器就不让你通过，因为你给的实参类型与定义时的形参类型不匹配。
说说重载（overload）
问你个问题：在同一个类里定义方法的时候，方法名可以相同吗？答案是：“可以！
”但有个要求——方法名相同的时候参数列表不可以再相同。这种方法名相同、参数列
表不同的情况称为方法的重载。前面定义的两个sayHello方法就构成了重载。
这里有几点需要注意的：
1. 参数列表不同，包括了参数的个数不同、类型不同。比如：void myMethod(String
input1, double input2){...}和void myMethod(double input1, String input2){...
}就构成重载。
2. 只改参数名是不能构成重载的。比如：void myMethod(String input1, double
input2){...}和void myMethod(String arg1, double arg2){...}是不重载的。
3. 只改返回值类型也不能构成重载。比如：void myMethod(String input1, double
input2){...}和double myMethod(String input1, double input2){...}是不重载的。
其实大家应该已经发现了，决定两个方法是否重载的是方法定义四个部分中的方法名加
参数列表部分。所以，这两个部分（方法名+参数列表）又称为“方法签名”（method
signature），也就是这两部分的组合确定了一个方法的唯一性。
说说重写（override）
按理说重写这事儿非常简单，但它却与面向对象最核心的一个概念“多态”搅和在一
起了，所以在有些神话传说里会把重写和多态写的云里雾里、神乎其神。其实别听那套
~~很简单的。
咱们先不理多态的茬，只说重写。它的概念是：如果在父类里定义了一个方法A，在这
个父类的子类里你再次定义了方法A，它的返回值类型、方法名、参数列表与父类中的
方法A完全一致，那么我们就说子类中的方法A就对父类中的方法A进行了重写。这再好
理解不过了——方法定义的前三部分安全一样，只有方法体不一样，当然就是子类方法
把父类方法的算法逻辑给覆盖重写了。看例子：
=================
public class Person
{
public void speak()
{
System.out.println("I'm a person.");
}
}
public class Student extends Person
{
public void speak()
{
System.out.println("I'm a student.");
}
}
public class Teacher extends Person
{
public void speak()
{
System.out.println("I'm a teacher.");
}
}
=================
例子中的Person类是Student类和Teacher类的父类（倒过来说，Student和Teacher是
Person的子类或派生类）。它们都拥有返回值类型、名字、参数列表完全相同的方法
speak，所以，Student类和Teacher类里的speak方法对Person类的speak方法构成了重
写。
切记一句话：重写用的好，是福；用不好，是项目里最大的祸害。
多态（polymorphism）——事情有点儿复杂了
什么是多态呢？它可以算得上是OO的重中之重了，它可以这么定义——当用一个父类
类型的变量引用一个子类类型的实例时，通过父类类型的变量调用一个被重载的方法时
，被执行的总是被子类所重写后的版本。看！多态是以重写为基础的。单看定义是很难
明白的，让我们看个例子。
首先，我们在“重写”例子代码上再加一个类：
=================
public class CseTeacher extends Teacher
{
public void speak()
{
System.out.println("I'm a CSE teacher.");
}
}
=================
这个CseTeacher类对Teacher类的speak做了重写（这是再度重写了）。那么，下面这组
方法调用的输出是什么呢？
public class Program
{
public static void main(String[] args)
{
Person person; // 父类类型变量，请注意，它只是个变量，不是实例
person = new Person(); // 变量与实例的类型一致
person.speak();
person = new Student(); // 父类类型变量引用子类实例
person.speak();
person = new Teacher(); // 父类类型变量引用子类实例
person.speak();
person = new CseTeacher(); // 父类类型变量引用子类实例
person.speak();
Teacher teacher = new CseTeacher(); // 父类类型变量引用子类实例
teacher.speak();
}
}
答案是：
I'm a person.
I'm a student.
I'm a teacher.
I'm a CSE teacher.
I'm a CSE teacher.
===================
多态背后的秘密——绑定（bind）
多态是不是很神奇啊？我来向你透露一点它的秘密吧！不过，在我透露这个秘密之前
，我先说一下版权的事儿：咳咳，本系列原创文章发表在http://ladder.azurewebsites.net，转载的话请注明出处，如果你喜欢，欢迎在我们的论坛注册或加入QQ群277252742共同学习提高。
好了，现在开始说秘密：这个秘密就叫“绑定”。什么是绑定呢？如果你仔细观察，
会发现Java里每个方法都必需通过它的拥有者来调用：比如person.speak()，Double.
valueOf()，this.doSomething()。这种把我和我的拥有者关联起来的行为就叫做绑定
，在Java语言里，我被绑定给谁是在编译器编译代码的时候就确定了的，这种绑定方式
也叫“编译期绑定”或者“早绑定”。比如，当你看到我的定义中有static修饰符的时
候，我就被绑定到定义我的类上，而不是这个类的实例上（Double.valueOf就是个典型
的例子）；当我不被static修饰的时候，我会被绑定给定义我的类的实例上——我总跟
定义我的类的实例直接关联，所以才会产生多态的效果，这是编译器刻意追求的效果。
聪明的你一定会问：“既然有早绑定，那么一定有晚绑定咯？”你说对了！晚绑定指
的是方法与哪个对象想关联不由编译器来确定，而是在程序运行的时候根据程序逻辑确
定，晚绑定也叫运行期绑定。
因为编译期程序还没有执行，所以也叫静态期（static）；程序运行起来之后又叫动
态期（dynamic），所以，这两种绑定又被分别称为“静态绑定”和“动态绑定”。听
好了：一门编程语言采用何种绑定决定了它是静态语言还是动态语言。像C/C++/Java/C
#等语言都是静态语言（因为它们需要做静态绑定，所以编译器要提前知道数据的类型
，所以静态语言往往是强类型的）；而像JavaScript/Python/Perl等脚本语言，则是动
态语言，因为采用了动态绑定，它们的对象非常灵活多变（当然，也非常容易把程序搞
乱）。
public与private
最后说说两个常见的修饰符吧。特简单~~当我被public修饰的时候，你在别的类的方法
里用能通过与我绑定的类或实例调用我；当我被private修饰的时候，在别的类的方法
里你是看不见我的。如果我没被修饰符所修饰，默认就是private啦~~他们怕我出去惹
事，所以默认把我关在屋里
如果以后你有机会学习C#，你还会遇到virtual修饰符和override修饰符，这俩是一对
儿。父类的方法如果用virtual修饰了，子类标记了override的方法才能重写父类的方
法……还是Java简单，方法重写是天生的。
哦，差点忘了abstract，当我被这个修饰符修饰的时候可省事啦！这时候你只需要定
义我的返回值类型、名字和参数列表，方法体完全不用定义——这时候我只是个抽象的
签名，没有任何实际的算法。这时候的我被称为“抽象方法”，包含我的类叫“抽象类
”，因为我没有具体的算法，所以这个类也因为我的拖累而不完整了。抽象类可以用来
声明变量，但不能用来创建实例——你想啊，如果创建了实例，你又用实例去调用一个
没定义完整的方法，不崩溃才怪！所以，干脆不让你用抽象类来创建实例了。如果你从
抽象类派生了子类，并且在子类里实现（注意：这时候不叫重写，因为抽象方法本身没
有实际的算法，你不可以“重”写）了抽象方法，那它就成一个完成的实现类（
concrete class）了。别看抽象类和抽象方法是“不完整”和“未定义算法”的，但就
是因为它们的不完整使得他们在整个OO设计中有着举足轻重的地位……要领悟这一点，
你还有很长的路要走，大概得写五万行代码吧
这让我想起了那位神龙见首不见尾、虚无飘渺的Ms.Interface——这老姐更是抽象到
皮包骨头，女人嘛，瘦即是可爱……要不为什么架构师们爱她爱到发疯呢。她的事儿，
以后再说吧。
E*r
14 楼
哈哈
p*t
15 楼
Janine Jansen
当年在iTunes花十几块钱买的。。。
【在 k*****n 的大作中提到】
: 哪个美女版？
当年在iTunes花十几块钱买的。。。
【在 k*****n 的大作中提到】
: 哪个美女版？
s*g
16 楼
But wait for the next reply, I am not 100% sure.
【在 s*****g 的大作中提到】
: US.
【在 s*****g 的大作中提到】
: US.
l*k
17 楼
东风太帅啦
【在 P********p 的大作中提到】
: [果子店狗血穿越] 来自五代的你 （69）一对故人
: 上回书说到，果子一行在官道上被守夜人的卫队拦住敲诈，强行要求他们到同福客栈投
: 宿。多亏了瓜老板的圆滑，双方才没动起手来。
: 但是这样一来，毕竟憋了一肚子气，一行人各怀心事，终于赶到了渡口。举目一看，不
: 由得叫起苦来。原来果然如同守夜人说的那样，渡口上一条船也没有。不仅如此，这渡
: 口是冷冷清清，只有一间客栈。果子叫道：“这里还真是黑店啊，怎么就只有这一家店
: ？”
: 瓜老板叹道：“也许是因为夏汛刚过，洪水才退的缘故吧。不管怎么样，咱们是要在这
: 里打尖了，你看，离这里最近的渡口也要在百里之外，恐怕等咱们到了河对面的关家庄
: ，这戏也散了。”
【在 P********p 的大作中提到】
: [果子店狗血穿越] 来自五代的你 （69）一对故人
: 上回书说到，果子一行在官道上被守夜人的卫队拦住敲诈，强行要求他们到同福客栈投
: 宿。多亏了瓜老板的圆滑，双方才没动起手来。
: 但是这样一来，毕竟憋了一肚子气，一行人各怀心事，终于赶到了渡口。举目一看，不
: 由得叫起苦来。原来果然如同守夜人说的那样，渡口上一条船也没有。不仅如此，这渡
: 口是冷冷清清，只有一间客栈。果子叫道：“这里还真是黑店啊，怎么就只有这一家店
: ？”
: 瓜老板叹道：“也许是因为夏汛刚过，洪水才退的缘故吧。不管怎么样，咱们是要在这
: 里打尖了，你看，离这里最近的渡口也要在百里之外，恐怕等咱们到了河对面的关家庄
: ，这戏也散了。”
H*r
18 楼
太罗嗦。。
另外中文看不太懂
另外中文看不太懂
k*n
19 楼
this one?
http://www.verycd.com/topics/2787410/
【在 p****t 的大作中提到】
: Janine Jansen
: 当年在iTunes花十几块钱买的。。。
http://www.verycd.com/topics/2787410/
【在 p****t 的大作中提到】
: Janine Jansen
: 当年在iTunes花十几块钱买的。。。
y*e
20 楼
当然是US，你又不给中国交税
x*g
21 楼
哈哈 就是帐本和算盘不够酷～～
【在 l******k 的大作中提到】
: 东风太帅啦
【在 l******k 的大作中提到】
: 东风太帅啦
a*a
22 楼
哪天您看懂中文了，也许就不感觉啰嗦了:)
加油学中文，然后再学Java。您肯定没问题！
【在 H**r 的大作中提到】
: 太罗嗦。。
: 另外中文看不太懂
加油学中文，然后再学Java。您肯定没问题！
【在 H**r 的大作中提到】
: 太罗嗦。。
: 另外中文看不太懂
p*t
23 楼
nod nod
【在 k*****n 的大作中提到】
: this one?
: http://www.verycd.com/topics/2787410/
【在 k*****n 的大作中提到】
: this one?
: http://www.verycd.com/topics/2787410/
m*a
24 楼
US for tax purpose unless you state to IRS that you have no intention to
establish US based business ( which means study, work, trades) and stay US less than 183 days each calender year. In that case, China.
establish US based business ( which means study, work, trades) and stay US less than 183 days each calender year. In that case, China.
b*n
25 楼
lol，东风好酷啊～～
导演，这面相有暗示神马么～～
导演，这面相有暗示神马么～～
a*i
26 楼
技术文章写得太装了，写给未成年人看的？
【在 a****a 的大作中提到】
: 哪天您看懂中文了，也许就不感觉啰嗦了:)
: 加油学中文，然后再学Java。您肯定没问题！
【在 a****a 的大作中提到】
: 哪天您看懂中文了，也许就不感觉啰嗦了:)
: 加油学中文，然后再学Java。您肯定没问题！
k*n
27 楼
封面很是香艳啊
不过比不上昨晚那谁谁贴的
【在 p****t 的大作中提到】
: nod nod
不过比不上昨晚那谁谁贴的
【在 p****t 的大作中提到】
: nod nod
P*p
28 楼
bow
【在 x*****g 的大作中提到】
: 沙发！谢
【在 x*****g 的大作中提到】
: 沙发！谢
a*a
29 楼
成年人看到的是成年的内容；未成年人看到的是未成年人的内容；装的人看到的是装的
内容。请君自便:)
【在 a****i 的大作中提到】
: 技术文章写得太装了，写给未成年人看的？
内容。请君自便:)
【在 a****i 的大作中提到】
: 技术文章写得太装了，写给未成年人看的？
p*t
30 楼
哈哈，当时我不知道啊，随MP3还附送了更多的照片儿了，妈的，害得我在同事前出了
丑。。。
【在 k*****n 的大作中提到】
: 封面很是香艳啊
: 不过比不上昨晚那谁谁贴的
丑。。。
【在 k*****n 的大作中提到】
: 封面很是香艳啊
: 不过比不上昨晚那谁谁贴的
P*p
31 楼
尔等已经疑神疑鬼了。。。
【在 b********n 的大作中提到】
: lol，东风好酷啊～～
: 导演，这面相有暗示神马么～～
【在 b********n 的大作中提到】
: lol，东风好酷啊～～
: 导演，这面相有暗示神马么～～
c*m
32 楼
原来一半的 Java就这样啊 。。！！！
看之前很清晰。。看了一点之后 一头雾水。。
这就是害人的老师类型。。
【在 a****a 的大作中提到】
: 原文链接：http://ladder.azurewebsites.net/forum.php?mod=viewthread&tid=121&extra=page%3D1
: 第一集：Mr.Method
: Hi，大家好~~我是Mr.Method，和Mr. Okay是好哥们儿。
: 在所有面向对象的语言里你都能见到我的身影。不信？你们学编程的时候第一个程序
: 都是Hello World吧？那就是依靠对我的调用实现的——无论是哪个平台、哪种语言，
: 你一定调用了在命令行里输出字符串的某个Method。
: 铁三角
: 在正式介绍我自己之前，还是先说说我的哥哥和妹妹吧，我们的家庭背景有助于大家
: 对我有一个更好的了解。我的哥哥（Mr. Class）和小妹（Mr. Field）加上我，我们仨
: 可是面向对象家庭里绝对的主角、“铁三角”。我们三个之所以称为“铁三角”是因为
看之前很清晰。。看了一点之后 一头雾水。。
这就是害人的老师类型。。
【在 a****a 的大作中提到】
: 原文链接：http://ladder.azurewebsites.net/forum.php?mod=viewthread&tid=121&extra=page%3D1
: 第一集：Mr.Method
: Hi，大家好~~我是Mr.Method，和Mr. Okay是好哥们儿。
: 在所有面向对象的语言里你都能见到我的身影。不信？你们学编程的时候第一个程序
: 都是Hello World吧？那就是依靠对我的调用实现的——无论是哪个平台、哪种语言，
: 你一定调用了在命令行里输出字符串的某个Method。
: 铁三角
: 在正式介绍我自己之前，还是先说说我的哥哥和妹妹吧，我们的家庭背景有助于大家
: 对我有一个更好的了解。我的哥哥（Mr. Class）和小妹（Mr. Field）加上我，我们仨
: 可是面向对象家庭里绝对的主角、“铁三角”。我们三个之所以称为“铁三角”是因为
k*n
33 楼
还有更香艳的？
【在 p****t 的大作中提到】
: 哈哈，当时我不知道啊，随MP3还附送了更多的照片儿了，妈的，害得我在同事前出了
: 丑。。。
【在 p****t 的大作中提到】
: 哈哈，当时我不知道啊，随MP3还附送了更多的照片儿了，妈的，害得我在同事前出了
: 丑。。。
a*3
34 楼
好看！
算盘账本，赞东风～～～
哈哈哈，等看火柴瓜板火拼啊～
【在 P********p 的大作中提到】
: [果子店狗血穿越] 来自五代的你 （69）一对故人
: 上回书说到，果子一行在官道上被守夜人的卫队拦住敲诈，强行要求他们到同福客栈投
: 宿。多亏了瓜老板的圆滑，双方才没动起手来。
: 但是这样一来，毕竟憋了一肚子气，一行人各怀心事，终于赶到了渡口。举目一看，不
: 由得叫起苦来。原来果然如同守夜人说的那样，渡口上一条船也没有。不仅如此，这渡
: 口是冷冷清清，只有一间客栈。果子叫道：“这里还真是黑店啊，怎么就只有这一家店
: ？”
: 瓜老板叹道：“也许是因为夏汛刚过，洪水才退的缘故吧。不管怎么样，咱们是要在这
: 里打尖了，你看，离这里最近的渡口也要在百里之外，恐怕等咱们到了河对面的关家庄
: ，这戏也散了。”
算盘账本，赞东风～～～
哈哈哈，等看火柴瓜板火拼啊～
【在 P********p 的大作中提到】
: [果子店狗血穿越] 来自五代的你 （69）一对故人
: 上回书说到，果子一行在官道上被守夜人的卫队拦住敲诈，强行要求他们到同福客栈投
: 宿。多亏了瓜老板的圆滑，双方才没动起手来。
: 但是这样一来，毕竟憋了一肚子气，一行人各怀心事，终于赶到了渡口。举目一看，不
: 由得叫起苦来。原来果然如同守夜人说的那样，渡口上一条船也没有。不仅如此，这渡
: 口是冷冷清清，只有一间客栈。果子叫道：“这里还真是黑店啊，怎么就只有这一家店
: ？”
: 瓜老板叹道：“也许是因为夏汛刚过，洪水才退的缘故吧。不管怎么样，咱们是要在这
: 里打尖了，你看，离这里最近的渡口也要在百里之外，恐怕等咱们到了河对面的关家庄
: ，这戏也散了。”
a*a
35 楼
哎呀哎呀，Sorry啦！哪里一头雾水了？我可以帮你解释解释。我群里的朋友看了之后
怎么都说理解了呢？
【在 c****m 的大作中提到】
: 原来一半的 Java就这样啊 。。！！！
: 看之前很清晰。。看了一点之后 一头雾水。。
: 这就是害人的老师类型。。
怎么都说理解了呢？
【在 c****m 的大作中提到】
: 原来一半的 Java就这样啊 。。！！！
: 看之前很清晰。。看了一点之后 一头雾水。。
: 这就是害人的老师类型。。
p*t
36 楼
我印象中不老少，就是老美看了吹口哨那种。
【在 k*****n 的大作中提到】
: 还有更香艳的？
【在 k*****n 的大作中提到】
: 还有更香艳的？
h*i
37 楼
你这是要让我一挑四的节奏啊？
不过有女神雅典娜在，小强我永远不会倒下，哈哈哈
【在 P********p 的大作中提到】
: [果子店狗血穿越] 来自五代的你 （69）一对故人
: 上回书说到，果子一行在官道上被守夜人的卫队拦住敲诈，强行要求他们到同福客栈投
: 宿。多亏了瓜老板的圆滑，双方才没动起手来。
: 但是这样一来，毕竟憋了一肚子气，一行人各怀心事，终于赶到了渡口。举目一看，不
: 由得叫起苦来。原来果然如同守夜人说的那样，渡口上一条船也没有。不仅如此，这渡
: 口是冷冷清清，只有一间客栈。果子叫道：“这里还真是黑店啊，怎么就只有这一家店
: ？”
: 瓜老板叹道：“也许是因为夏汛刚过，洪水才退的缘故吧。不管怎么样，咱们是要在这
: 里打尖了，你看，离这里最近的渡口也要在百里之外，恐怕等咱们到了河对面的关家庄
: ，这戏也散了。”
不过有女神雅典娜在，小强我永远不会倒下，哈哈哈
【在 P********p 的大作中提到】
: [果子店狗血穿越] 来自五代的你 （69）一对故人
: 上回书说到，果子一行在官道上被守夜人的卫队拦住敲诈，强行要求他们到同福客栈投
: 宿。多亏了瓜老板的圆滑，双方才没动起手来。
: 但是这样一来，毕竟憋了一肚子气，一行人各怀心事，终于赶到了渡口。举目一看，不
: 由得叫起苦来。原来果然如同守夜人说的那样，渡口上一条船也没有。不仅如此，这渡
: 口是冷冷清清，只有一间客栈。果子叫道：“这里还真是黑店啊，怎么就只有这一家店
: ？”
: 瓜老板叹道：“也许是因为夏汛刚过，洪水才退的缘故吧。不管怎么样，咱们是要在这
: 里打尖了，你看，离这里最近的渡口也要在百里之外，恐怕等咱们到了河对面的关家庄
: ，这戏也散了。”
d*e
38 楼
我也看得晕晕乎乎的，得把中文翻译成英文才能跟code对照上。学编程不不应该看中文
翻译的书
【在 c****m 的大作中提到】
: 原来一半的 Java就这样啊 。。！！！
: 看之前很清晰。。看了一点之后 一头雾水。。
: 这就是害人的老师类型。。
翻译的书
【在 c****m 的大作中提到】
: 原来一半的 Java就这样啊 。。！！！
: 看之前很清晰。。看了一点之后 一头雾水。。
: 这就是害人的老师类型。。
d*0
39 楼
哈哈哈。。 小女子，卖艺不卖身的气节都到哪里去了！！
P*p
40 楼
。。毛
【在 h*****i 的大作中提到】
: 你这是要让我一挑四的节奏啊？
: 不过有女神雅典娜在，小强我永远不会倒下，哈哈哈
【在 h*****i 的大作中提到】
: 你这是要让我一挑四的节奏啊？
: 不过有女神雅典娜在，小强我永远不会倒下，哈哈哈
E*1
41 楼
我也觉得不错，支持楼主 。
【在 a****a 的大作中提到】
: 哎呀哎呀，Sorry啦！哪里一头雾水了？我可以帮你解释解释。我群里的朋友看了之后
: 怎么都说理解了呢？
【在 a****a 的大作中提到】
: 哎呀哎呀，Sorry啦！哪里一头雾水了？我可以帮你解释解释。我群里的朋友看了之后
: 怎么都说理解了呢？
l*e
42 楼
是了提琴就喜欢上TF10，楼主你的那个IPOD没用的话卖给我当配件吧。
h*i
43 楼
唉，你们想象力太丰富鸟
【在 P********p 的大作中提到】
: 。。毛
【在 P********p 的大作中提到】
: 。。毛
w*f
44 楼
对我很有用，多谢！
p*t
45 楼
听了两天了，后来基本听的是流行的小曲儿，且不是无损的。坏了，我现在觉得这么听起
来TF10在老iPOD上的表现要比团五还好呢。。。你们谁手头还有老“爱跑儿”的（04年
05年的Classic), 也听听吧。
【在 p****t 的大作中提到】
: 心血来潮，把尘封了有两年的第二代20G的硬盘版iPod给充了会电，接上TF10，听德国
: 美女版维瓦尔第的“四季”，还是很不错的啊，对比了一下PK2，TF10的气势显然要足
: 了不少啊，不错不错。
来TF10在老iPOD上的表现要比团五还好呢。。。你们谁手头还有老“爱跑儿”的（04年
05年的Classic), 也听听吧。
【在 p****t 的大作中提到】
: 心血来潮，把尘封了有两年的第二代20G的硬盘版iPod给充了会电，接上TF10，听德国
: 美女版维瓦尔第的“四季”，还是很不错的啊，对比了一下PK2，TF10的气势显然要足
: 了不少啊，不错不错。
h*i
46 楼
写美女
抄张飞李逵才会出事故
抄红楼孔雀西厢怎么会挨揍
抄张飞李逵才会出事故
抄红楼孔雀西厢怎么会挨揍
s*g
47 楼
Mark
p*t
48 楼
哈哈，正在听啊，终于把电充满了。。。手头有仨“爱跑儿”， 等我过两天再去试试
第一代的iPod Mini,也是硬盘版的。iTouch原来试过，很差，和M6SL/SP比。。。
【在 l*******e 的大作中提到】
: 是了提琴就喜欢上TF10，楼主你的那个IPOD没用的话卖给我当配件吧。
第一代的iPod Mini,也是硬盘版的。iTouch原来试过，很差，和M6SL/SP比。。。
【在 l*******e 的大作中提到】
: 是了提琴就喜欢上TF10，楼主你的那个IPOD没用的话卖给我当配件吧。
P*p
49 楼
nod, 要的就是抄书的乐子，不过尔雅老师是否觉得自己是唯一慧眼之人呢？
【在 h*****i 的大作中提到】
: 写美女
: 抄张飞李逵才会出事故
: 抄红楼孔雀西厢怎么会挨揍
【在 h*****i 的大作中提到】
: 写美女
: 抄张飞李逵才会出事故
: 抄红楼孔雀西厢怎么会挨揍
L*i
50 楼
方法定义的前三部分"安"全一样: “完”全一样
L*k
51 楼
名媛要哭了。ipod touch嘎不济。
【在 p****t 的大作中提到】
: 哈哈，正在听啊，终于把电充满了。。。手头有仨“爱跑儿”， 等我过两天再去试试
: 第一代的iPod Mini,也是硬盘版的。iTouch原来试过，很差，和M6SL/SP比。。。
【在 p****t 的大作中提到】
: 哈哈，正在听啊，终于把电充满了。。。手头有仨“爱跑儿”， 等我过两天再去试试
: 第一代的iPod Mini,也是硬盘版的。iTouch原来试过，很差，和M6SL/SP比。。。
l*k
52 楼
哈哈，小余跟你有同样的爱好
不过他赞捧的美女太多了
一人一诗加n文的，那点墨水早就被挤干，不抄没办法呀，哈哈
不过他赞捧的美女太多了
一人一诗加n文的，那点墨水早就被挤干，不抄没办法呀，哈哈
a*a
53 楼
谢谢您指出笔误，我已经更正了。没想到您阅读的这么仔细。
【在 L*********i 的大作中提到】
: 方法定义的前三部分"安"全一样: “完”全一样
【在 L*********i 的大作中提到】
: 方法定义的前三部分"安"全一样: “完”全一样
p*t
54 楼
是不继啊，声音完全没有厚度。。。
【在 L*****k 的大作中提到】
: 名媛要哭了。ipod touch嘎不济。
【在 L*****k 的大作中提到】
: 名媛要哭了。ipod touch嘎不济。
j*x
55 楼
7，
一辉的粉丝对 型屎 表示很不屑
【在 h*****i 的大作中提到】
: 你这是要让我一挑四的节奏啊？
: 不过有女神雅典娜在，小强我永远不会倒下，哈哈哈
一辉的粉丝对 型屎 表示很不屑
【在 h*****i 的大作中提到】
: 你这是要让我一挑四的节奏啊？
: 不过有女神雅典娜在，小强我永远不会倒下，哈哈哈
h*n
56 楼
有没有续集，讲通另外一半啊?
i*d
57 楼
我的耳机输出坏了。
听起
【在 p****t 的大作中提到】
: 听了两天了，后来基本听的是流行的小曲儿，且不是无损的。坏了，我现在觉得这么听起
: 来TF10在老iPOD上的表现要比团五还好呢。。。你们谁手头还有老“爱跑儿”的（04年
: 05年的Classic), 也听听吧。
听起
【在 p****t 的大作中提到】
: 听了两天了，后来基本听的是流行的小曲儿，且不是无损的。坏了，我现在觉得这么听起
: 来TF10在老iPOD上的表现要比团五还好呢。。。你们谁手头还有老“爱跑儿”的（04年
: 05年的Classic), 也听听吧。
a*n
58 楼
mark
n*l
59 楼
mark
A*3
60 楼
good one.
s*8
61 楼
我的ipod坏了有几个月了，郁闷。
s*8
62 楼
我的ipod坏了有几个月了，郁闷。
l*e
63 楼
拿来给我试着修吧，我已经修好几个了。
【在 s*******8 的大作中提到】
: 我的ipod坏了有几个月了，郁闷。
【在 s*******8 的大作中提到】
: 我的ipod坏了有几个月了，郁闷。
相关阅读
求sprint Samsung 手机请教一个Wifi的问题Verizon iphone 怎么tether？内存，是2x32GB快，还是4x16GB快版主干活了NETGEAR 无线路由器的大deal为了国家安全，一定要手机完全国产deep learning最近有一些进展史低价：1MORE Stylish 真无线耳机，音质可与$150+耳机一战怎样才能扩大guest wifi的覆盖范苹果新的ARM macbook pro怎么样前后端分离为什么最近几年才开始流行微信是个整合平台习派特工爆料，为什么孟晚舟案件与香港国安法同时发生华为在英国“出局”日期有可能更为提前DNX 野牛肉干的大deal美国对华为瞅啥？从微信胜诉恐惧看海外华人的焦虑美国怎么能买到mate 40 Pro?Amazon Show 跟国内老人 video call