分类
其他

2020-02-15-李笑来写作课-摘要

2020-02-15-李笑来写作课-摘要

第一节

改变基础观念,就是两个公式:第一个公式是定义公式,形式是x是什么,不是什么?第二个公式是比较公式,形式是x为什么更好甚至最好?

写作起码应该是对输入处理过的输出. 例子,苏轼的题西林壁就是经过长期思考沉淀,通过他的文字处理技巧,文字,韵律,意境,最后输出的只有28个字却足够震撼。

写作一共三个环节,输入,处理,输出。很多人写不出来的原因是输入不够多,处理也几乎没有。

人们常常把事想反,比如谈恋爱和结婚,再比如考研和出国考试。

思考能力才是核心关键,如果你能精彩的思考,你就一定能够精彩的写作,当然也能精彩的讲解及,只要你能精彩的处理,你就能精彩的输出。

绝大多数人没有清楚的表达自己想法的能力。比如王淼同学机票事件。建议,第一去掉没有证据的陈述,第二个,不喊冤不诉苦,第三个只写去哪儿网最不地道的地方。

千万不要小瞧写作能力,写作其实是在倒逼自己的思考质量,思考能力和所有能力是一样的,都需要通过实践磨练。

千万不要神化写作能力,写作不是什么太过了不起的能力,只是一个自认为受过教育的人必要必须的能力而已。

写作能力,除了思考正确之外,剩下的只不过是遣词造句而已,再加上一点点手段,比如倒叙插叙或者用点通感的修辞,偶尔而已。

一定要把注意力放在自己的思考能力,思考质量,思考习惯上,因为思考质量最终一定会影响生活品质的。

写作的分若干阶段,第一阶段,锻炼思考能力,第二阶段,锻炼表达能力,第三阶段,说出价值观,第四阶段,积累影响力,第五阶段,你居然可以普度众生。

你必须自己选择自己的原则,第一,是不是对的,第二,如果是对的,能不能坚守,第三,如果不对,那对的是什么,能不能坚守。

写作的根本是两条,第一读书,第二多读。

选书其实比读书更重要。参考选书的基本原则,http://xiaolai.co/books/xiaolai-xuexi/27978d191e5c718c49141ff1cd7351ce.html,此外,朋友圈<好文章<好书<学术文献,免费<付费,通俗杂志<精英杂志,中文<英文,百度<Google<学术搜索,都是提高输入质量的方法。

根据价值观来选书,第一扔掉不符合价值观的书,第二践行一本符合价值观的书,第三,找一个你认为对的,绝大多数人并不认同的观点,说服一个算一个。

提高选择标准可以提高提高质量,所以我第一尽量只读非虚构类书籍,第二尽量只读英文书籍。

无论如何你总是得在意你的输入质量,所以你就得有自己的选择标准,并且还要想办法逐步抬高你的标准,所以再也不要向任何人索要书单了,一定要你自己选。

一定要反复梳理自己的价值观,就是第一你认为什么是对的,什么是错的,第二,你认为什么更重要,什么最重要。

不要因为反例动摇自己的价值观,如果动摇,说明不够坚定或者应该修订自己的观念。

建议每天花半个小时回答几个问题,第一,这事儿对吗?第二,什么更重要?第三,什么最重要?第四,什么事绝对不能做第五,什么事一定要做到的。

用价值观来判断自己的选择是否正确,所有写作的出发点都是由价值观决定的,什么样的素材值得收藏,值得收藏,什么样的话值得说,什么样的话不适合说,什么样的东西可以接受,什么样的东西坚决不能接受,什么样的理论值得深入研究,什么样的说法不值一提,什么样的人值得深入交往,什么样的人不可不交不可深交,这些都是你的价值观的折射,最终你会发现你的生活开始逐步变得有序的思考,逐步变得有章有法,你的表达开始变得清清楚楚,甚至轻轻松松,这就是树立价值观的重要性,说出了价值观就行。

没有坚定的价值观,就不可能有坚定的选择。比如我选择做一个长销书作者。

第二节

一个人是否聪明取决于两件事情,第一,脑子里是否有足够多的,必要的,清晰的,准确的概念。第二,那些概念之间是否有足够多的,清晰的必要的,准确的连接。

概念是我们的大脑这个操作系统的核心,所谓的升级我们的操作系统,就是指学习应用新的概念,打磨升级已有的概念。

每个概念有两个部分构成,第一个是内涵,是那些对象的属性,第二个是外延,指的是概念所指的对象。

比如分享,必须是自己的东西。

我会怎么做呢?第一,也许不会做个完整版的笔记会想办法提炼要点,第二,就算我做了完整版的笔记,我也不会把它就那么放出去,第三,若是我做了很多思考,生成了很多补充内容,那我有可能放出去,因为我放出去的是我的东西。第四,若那课程是收费的,我可能也不会把笔记就那么放出去。

再比如法定节假日,不限制个人,所以不过法定节假日可以比别人多活一半时间。

我们所使用的语言元素有名词,动词,形容词和副词。名词是用来指称你能感知到某个人或者事物的词汇。动词是用来描述某个人或事物的行为和动作的。形容词性成分是用来描述我们对某个事物的感知的。副词是用来描述我们对某个人或者事物的感知的感知的。

做几个练习,第一个练习是拿出自己写过的一篇文章,找几根带颜色的笔,把里面的所有名词都圈出来,实物名词用一个颜色抽象名词用另外一个颜色。

第二个练习是再随便拿几篇别人的文章,把那些名词前后的形容词都圈出来。这是一个极为简单却又常常被忽视的原因,这句话在说明作者不仅对这个能够感知的抽象事物有所感知,还有一个以上的感知。

我们重新定义一下写作的目标,写作的目标是沟通。第一,你所表达的东西,的确是处理好的吗?第二你处理好的东西你确实表达正确了吗?第三你表达正确的东西,对方真的具备理解的基础吗?第四,对方虽然能理解,他真的会接受吗?第五,对方会表示理解甚至接受,但他真的会当回事儿了,第六,对方有疑问的地方,你准备好进一步解释了吗?第七,对方产生误解的时候,你有对应的方案吗?第八,对方驳斥你的时候,你有足够的心理准备么?

如果你把写作的目标,讲演的目标,清楚的理解为沟通,那么有效的沟通就是需要做大量的提前的功课的,在多个可能的选项当中选择最有效的那个,这不是很容易的事情,这真的是很难获得的技能,也是很难打磨的技能。

任何进步最大的障碍,其实是一个看不见的东西叫做没有反馈。

总结一个沟通的最重要的原则,要想尽一切办法获得所有真实的反馈。

我给你几条简单的建议,第一,多读心理学方面的原版书籍,第二,多读经济学方面的通俗读物。第三,观察分析拆解揣摩那些公众人物是怎样化解危机的,第四,花时间思考每个真实反馈背后的心理出发点,价值观,给自己一个机会去了解每一类人。

有效沟通的本质是让对方明白他自己之前不明白的道理,了解他自己之前不了解的事实。

我们常常需要把叙事顺序也就是叙事结构重新组织一下,以便读者可以从已知开始走到未知,从简单开始理解复杂,从次要起步到达重要。

所谓的恍然大悟,常常不过是发现原来未知的东西,其实是自己已知的,或者发现复杂的东西,其实是如此简单的。

修辞的目的是为了让对方感受到他们原本感受不到的东西。类比在沟通中给对方在未知和已知之间搭建了一座桥梁,否则对方走不过去。排比或者重复,哪怕是结构上的重复都会令人产生足够深刻的印象。

第三节

写作的一个核心重点是做研究的本领。

读书可以突破时间和空间上的局限。

在真实的世界里,就是信息过窄的。

你要想办法突破局限,你要想办法不给自己设置局限。

信息过载就是没有可能解决的问题。

我们去做调查去做研究,其实核心目标就是为了突破局限。

你必须通过建立完整的知识体系,让自己在一定程度上突破思考质量上的局限。

所谓的完整的知识体系有三个支点,统计概率,历史方法论和逻辑学。

一个调查研究过程当中的方法论,就是收集素材的方法,第一个是卡片的应用,正反面有不同的用处,正面摘抄的是例子或者要点,背面是这个例子可能用到的地方。比如猴子的例子。

好的类比常常是神来之笔,收集类比是学习类比的最重要手段。教育就是眼镜的类比,砖头是科学事实的类比。

第二个值得收藏的东西是理论。你平时要读书,去收集各种各样的理论。比如,28理论,木桶理论,黄金分割理论。当相信一个谣言的人数比例超过61.8%,其实就是0.618的时候,这个谣言的影响力就可能暴增到100%。

几个细节需要注意,第一,每一种理论都是有可能被推翻的,第二种,理论都大体上只适用于某些个领域,第三,理论都有一定的局限,并非真理。

除了理论之外,最重要的是不停的收集思考方式和论证方式。比如复杂二分法,对同一事物用两个维度,两次二分,相互组合就可能出现4种情况。人可以分为聪明愚蠢,勤奋和懒惰。做事分为有用无用,有趣无趣。

另外一个思考模式叫进一步拆解,进一步拆解也是值得收藏的思考模式。写作是输出->写作是输入,处理,然后输出。理想就是看到了终点。->能够实现的理想至少有三个节点构成,起点,路径和终点。

读书要给自己时间和机会反过来重新整理,看看好书的作者是如何论证自己观点的,论证过程当中有哪些素材可以用到其他地方,论证过程是什么样的,思考方式是什么样的,自己是否可以模仿一下自己,是否可以拿来创作其他的东西。

我甚至经常从自己并不喜欢的人身上学到很多宝贵的经验。比如方舟子的文献检索能力。

文献检索能力就是两条第一搜索搜索再搜索,第二付费付费再付费,第三整理整理再整理。

只要你收集整理的足够多,各种奇奇怪怪的好运就出现了。

第四节

公开写作的意思就是字面的意思,你写好的文章要发出去发表给很多人看,这样的时候除了原本就并不容易做到的有效沟通之外,还有另外一个可能更为核心的要点传播。要传播出去才是真正的公开。

最厉害的思考方法是思考什么是最核心的因素?

花越多的时间思考琢磨什么最重要这个问题会让你越来越与众不同,道理也很简单,绝大多数人总是问别人什么最重要,而你是那少数不断问自己这个问题的人。

公开写作最重要的是传播,没有传播就没有效果,所以呢,你要拼命琢磨写的东西人们读过之后会不会转发。

无论写成什么样子,最终你要花很长时间去琢磨如何才能让人们把你的文章转发出去,你要满足他们什么样的心理,他们才会洋洋自得的转发,语重心长的转发,意味深长的转发。

可以做个练习。用一两天时间仔细研究一下你自己的朋友圈,看看你曾经转发过什么文章,如实的记录下来你自己当时的心情,再仔细研究一下你的朋友们转发的文章,多耗费一点时间精力去揣测一下他们转发时的心理,不断把自己想到的东西写在一张纸上,可能是一个词,可能是一句话,暂时不要判断,等第二天再看整张纸上的字句,你一定会有一些心得的,而那些心得就是人们所谓的,只可意会不可言传的东西。

如何判断文章读者会不会转出去,是文章是否会让读者产生一个明显的变化。只有能够产生变化的才叫影响力。

正确的传播信息最有效的是人,因为有一些人甚至可能比超级计算机更能有效的处理思想。

你的作品若是被传播的很广,一定是重要的人起的作用,而不是被机器算法挖掘出来的。

互联网是个神奇的地方,也是个很奇怪的地方,每个人好像都是公开的,可最终绝大多数人其实是封闭的,你连上互联网并没有太大的意义,真正有意义的是很多人连上你。

你的传播力取决于你能影响多少个大的节点,你的假想读者群应该是那些有传播能力的大节点。只有他们被触动了,只有他们被感动了,只有他们被震撼了,他们才有可能转发你的内容,只有他们的转发才有以一抵百的威力。

世界上所有大的节点都是苦心经营的结果,不可能是与生俱来的。

任何苦心经营出来的东西你都不应该轻视它,若那苦心经营出来的是好东西,那么你一定要重视它,苦心经营出来的是坏东西,你更不应该轻视它,因为它的杀伤力巨大。

先做一个真正有实力的人,拿出自己的成绩,这才是最核心的关键,更为关键的是无论成长到什么地步,都别忘了自己依然是个有缺点甚至有缺陷的人。

后搜索引擎时代的策略,首先一定要有一个自己的根据地,可能是微信公众账号,可能是微博,可能是知乎,甚至可能是豆瓣,其次要求助于身边的朋友,若是你开通了微信公众账号,可以告诉你身边的朋友你开了一个微信公众账号,告诉他们想要发表哪方面的文章,你的目的是什么,然后写出你自己真正满意的文章,请他们转发,大不了你拉个群发红包吗?最重要的是学会演讲。

从一开始你就要深入思考,你究竟要影响什么人,你的长期目标究竟是什么?对你来说什么最重要。你究竟想要什么样的影响力,花多长时间都不过分。

应对争议要第一应该信奉弱水三千只取一瓢,第二绝不回应,默默拉黑。

认真研究每个细节是放在哪里都是最重要的技能。微信订阅号的题图,标题,副标题。所以标题很重要。你要花很长时间去考虑标题是否吸引人。题图和logo也很重要,副标题是用来让读者点进来的补充工具,所以一定要想办法在你的文章里放置一些金句。金句都是足够短的,足够精炼的。

创作的终极技巧是情理之中,意料之外。好的作品,好的文章,好的电影,好的剧集提供了一些你原本想不到的东西,关键并不只在于你原本想不到,关键在于说当你知道了之后,竟然发现那确实是情理之中的。

找出那些确实足够重要足够本质,读者却没有想到自己该要的,读者获得之后,知道他们确实足够重要足够本质的东西,只有这样你们才有惊喜的感觉啊。

用户喜欢你是没有用的,得想办法让他们爱你,特别爱你,这才有用。

制造惊喜的本领是这世界上最有价值的技能,所以一切创作的终极目标都是一样的,制造惊喜。

传播沉淀与积累,最终靠社区。

分类
其他

2019-11-12-比特币定投时机分析

比特币定投时机分析

前几天我写了比特币定投的文章,我当时选的是每个月第一天买入1000块钱比特币,然后我就想如果是在其它日期买入收益是怎样呢。然后代码如下:

echo 'simple policy: buy 140 usd on the first day of everymonth:'.PHP_EOL;
$btc = [];
$money = [];
$max = [];
for ($i=0;$i<32;$i++) {
    $btc[$i] = $money[$i] = 0;
}
foreach ($result as $row) {
    $i = ltrim(explode("-", $row[$keys[0]])[2], "0");
    $price = $row[$keys[1]];
    $spend = 140;
    $btc[$i] += $spend/$price;
    $money[$i] += $spend;
}
for ($i = 1; $i < sizeof($btc); $i++) {
    echo 'on '.$i.'st day of month buy '.$btc[$i].' BTC for '.$money[$i].' USD';
    echo '. ROI is '.($last_price*$btc[$i]/$money[$i]).PHP_EOL;
}
echo PHP_EOL;

结果如下:

simple policy: buy 140 usd on different days of everymonth:
on 1st day of month buy 22.171847894906 BTC for 11060 USD. ROI is 18.745575707508
on 2st day of month buy 22.483835796744 BTC for 11060 USD. ROI is 19.009351323391
on 3st day of month buy 22.683132436126 BTC for 11060 USD. ROI is 19.177850144936
on 4st day of month buy 22.873776562158 BTC for 11060 USD. ROI is 19.339033548082
on 5st day of month buy 22.663165006578 BTC for 11060 USD. ROI is 19.160968333188
on 6st day of month buy 22.829619605275 BTC for 11060 USD. ROI is 19.301700278335
on 7st day of month buy 22.895282529045 BTC for 10920 USD. ROI is 19.605385580803
on 8st day of month buy 22.758523723982 BTC for 10920 USD. ROI is 19.488278089274
on 9st day of month buy 22.772445297502 BTC for 10920 USD. ROI is 19.500199227019
on 10st day of month buy 22.693920417488 BTC for 10920 USD. ROI is 19.432957840135
on 11st day of month buy 22.499652101912 BTC for 10920 USD. ROI is 19.266604565037
on 12st day of month buy 22.281754478063 BTC for 10920 USD. ROI is 19.08001735314
on 13st day of month buy 22.068019586461 BTC for 10920 USD. ROI is 18.896994717075
on 14st day of month buy 22.068686013953 BTC for 10920 USD. ROI is 18.897565383452
on 15st day of month buy 22.379413146748 BTC for 10920 USD. ROI is 19.163643132924
on 16st day of month buy 22.212017346347 BTC for 10920 USD. ROI is 19.020300974674
on 17st day of month buy 22.181794017372 BTC for 10920 USD. ROI is 18.994420533262
on 18st day of month buy 21.982156192808 BTC for 10920 USD. ROI is 18.823469311231
on 19st day of month buy 22.179971247115 BTC for 10920 USD. ROI is 18.992859682739
on 20st day of month buy 21.974796783756 BTC for 10920 USD. ROI is 18.817167399388
on 21st day of month buy 21.872727840678 BTC for 10920 USD. ROI is 18.729765071755
on 22st day of month buy 21.729407841843 BTC for 10920 USD. ROI is 18.607039185536
on 23st day of month buy 21.647836522888 BTC for 10920 USD. ROI is 18.537189112343
on 24st day of month buy 21.504258966867 BTC for 10920 USD. ROI is 18.41424267816
on 25st day of month buy 21.636898731196 BTC for 10920 USD. ROI is 18.527823007195
on 26st day of month buy 21.575032925006 BTC for 10920 USD. ROI is 18.474846898118
on 27st day of month buy 21.486862408557 BTC for 10920 USD. ROI is 18.399345887391
on 28st day of month buy 22.420571564532 BTC for 11060 USD. ROI is 18.955863474289
on 29st day of month buy 21.492371373023 BTC for 10360 USD. ROI is 19.398877480778
on 30st day of month buy 20.996120074596 BTC for 10220 USD. ROI is 19.210566469857
on 31st day of month buy 12.562011754005 BTC for 6440 USD. ROI is 18.240021560587

结论是除了31号以外没有太大差别,因为不是每个月都有31号。

我又想到另外一个问题,就是这个简单策略从不同的时候开始对应的收益是多少呢?

for($year = 2013; $year < 2020; $year++){
    $btc = 0;
    $money = 0;
    foreach ($result as $row) {
        if (strtotime($row[$keys[0]]) < strtotime($year.'-01-01')) {
            continue;
        }
        if (explode("-", $row[$keys[0]])[2]=='01') {
            $price = $row[$keys[1]];
            $btc += 140/$price;
            $money += 140;
        }
    }
    echo 'start from '.$year;
    echo ' buy '.$btc.' BTC for '.$money.' USD';
    echo '. ROI is '.($last_price*$btc/$money).PHP_EOL;
}

结果如下:

start from 2013 buy 22.171847894906 BTC for 11060 USD. ROI is 18.745575707508
start from 2014 buy 14.422215949735 BTC for 9940 USD. ROI is 13.567431233189
start from 2015 buy 11.074658072271 BTC for 8260 USD. ROI is 12.537250354511
start from 2016 buy 4.6269273232684 BTC for 6580 USD. ROI is 6.5753489208709
start from 2017 buy 1.399094962316 BTC for 4900 USD. ROI is 2.6699500225044
start from 2018 buy 0.49292426430722 BTC for 3220 USD. ROI is 1.4314505327275
start from 2019 buy 0.26423599874152 BTC for 1540 USD. ROI is 1.6044392685404

结论当然是开始定投的时间越晚,收益越低。

同样如果动态调整买入数量,得到结果是:

on 1st day of month buy 54.68896148375 BTC for 24198.152323714 USD. ROI is 21.133405659588
on 2st day of month buy 48.267456335385 BTC for 21573.03055174 USD. ROI is 20.921618237196
on 3st day of month buy 51.927616303556 BTC for 23261.473649997 USD. ROI is 20.874360617497
on 4st day of month buy 54.068655783724 BTC for 23821.542164162 USD. ROI is 21.224023525604
on 5st day of month buy 56.741726914806 BTC for 24986.400799988 USD. ROI is 21.234931601517
on 6st day of month buy 53.217372045735 BTC for 24506.095243249 USD. ROI is 20.306324724596
on 7st day of month buy 49.480430048546 BTC for 23050.151453025 USD. ROI is 20.072973050566
on 8st day of month buy 43.009364229676 BTC for 21216.65825486 USD. ROI is 18.955622929084
on 9st day of month buy 44.911577713843 BTC for 21182.432421281 USD. ROI is 19.825972595816
on 10st day of month buy 46.503338955097 BTC for 21126.39968875 USD. ROI is 20.583094305775
on 11st day of month buy 49.933543814475 BTC for 22750.574451838 USD. ROI is 20.523529101953
on 12st day of month buy 46.670234156205 BTC for 22531.934998415 USD. ROI is 19.36838946566
on 13st day of month buy 44.246103969017 BTC for 22059.150509462 USD. ROI is 18.755915647944
on 14st day of month buy 45.929917738979 BTC for 22048.423270757 USD. ROI is 19.479156609693
on 15st day of month buy 46.619072138652 BTC for 22018.097956519 USD. ROI is 19.798662171002
on 16st day of month buy 45.994781276714 BTC for 22525.160165509 USD. ROI is 19.093814083309
on 17st day of month buy 44.01241958069 BTC for 22716.862562778 USD. ROI is 18.11669251188
on 18st day of month buy 42.904043520119 BTC for 22212.986120989 USD. ROI is 18.061062625519
on 19st day of month buy 45.26385493709 BTC for 22631.051873757 USD. ROI is 18.702463569818
on 20st day of month buy 45.857495755562 BTC for 22263.487782646 USD. ROI is 19.260570739059
on 21st day of month buy 45.105945523037 BTC for 21563.342732128 USD. ROI is 19.560039371102
on 22st day of month buy 44.572688867049 BTC for 21267.952653427 USD. ROI is 19.597251599066
on 23st day of month buy 43.274217689149 BTC for 20151.421970835 USD. ROI is 20.080547395047
on 24st day of month buy 42.184610969101 BTC for 20127.810971946 USD. ROI is 19.597899330555
on 25st day of month buy 41.603369954415 BTC for 19646.816392842 USD. ROI is 19.801055612622
on 26st day of month buy 43.569844882186 BTC for 20399.918765522 USD. ROI is 19.971449891362
on 27st day of month buy 46.073866974541 BTC for 22240.262415163 USD. ROI is 19.37165724189
on 28st day of month buy 49.860591240701 BTC for 23312.017117417 USD. ROI is 19.999981317215
on 29st day of month buy 48.409926306664 BTC for 21470.517141603 USD. ROI is 21.083559590936
on 30st day of month buy 51.125198054587 BTC for 22318.755862658 USD. ROI is 21.419880376601
on 31st day of month buy 23.662189356623 BTC for 11086.585427419 USD. ROI is 19.957637817137

start from 2013 buy 54.68896148375 BTC for 24198.15 USD. ROI is 21.133405659588
start from 2014 buy 34.138451267446 BTC for 18978.9 USD. ROI is 16.819955805149
start from 2015 buy 13.124232059274 BTC for 11972.62 USD. ROI is 10.250300012662
start from 2016 buy 5.0865272908385 BTC for 9908.83 USD. ROI is 4.800108353695
start from 2017 buy 1.9449513947794 BTC for 8228.12 USD. ROI is 2.2103466625796
start from 2018 buy 1.2345328381095 BTC for 6817.58 USD. ROI is 1.6932623616336
start from 2019 buy 0.22404450624699 BTC for 1383.58 USD. ROI is 1.5141907571945

跟简单策略类似,哪一天买入对结果影响不大,同样买入越晚收益越低。

我就换了一个思路,不是每个月固定时间投,而是每次价格下跌5%,我就买入1000块钱:

echo 'buy when price down policy:'.PHP_EOL;
$btc = 0;
$money = 0;
foreach($result as $i => $row){
    if($i == 0){continue;}
    $yesterday_price = ($result[$i-1][$keys[1]] + $result[$i-1][$keys[4]]) / 2;
    $price = $row[$keys[1]];
    if($price < $yesterday_price*0.95){
        $buy = 140;
        $btc += $buy/$price;
        $money += $buy;
        echo $row[$keys[0]].' '.$row[$keys[1]].' '.$row[$keys[4]].' ';
        echo 'buy '.$buy/$price.' BTC for '.$buy.' USD'.PHP_EOL;
    }
}
echo 'BTC: '.$btc.PHP_EOL;
echo 'Spend money: '.$money.PHP_EOL;
echo 'Final value: '.($btc*$last_price).PHP_EOL;
echo 'Final ROI: '.(($btc*$last_price)/$money).PHP_EOL;
echo PHP_EOL;

结果如下:

BTC: 16.835854779097
Spend money: 7840
Final value: 157429.88937822
Final ROI: 20.080343032936

就是花了7840usd(56000人民币)买了16.835854779097个比特币,价值157429.89usd(1124499.21人民币),收益率20.08倍收益。
可以看到这种方案跟简单定投方案的收益率差不多。

不过这种方案收益率跟起投时间的关系更密切:

echo 'buy when price down policy:'.PHP_EOL;
for($year = 2013; $year < 2020; $year++){
    $btc = 0;
    $money = 0;
    foreach($result as $i => $row){
        if (strtotime($row[$keys[0]]) < strtotime($year.'-01-01')) {
            continue;
        }
        if($i == 0){continue;}
        $yesterday_price = ($result[$i-1][$keys[1]] + $result[$i-1][$keys[4]]) / 2;
        $price = $row[$keys[1]];
        if($price < $yesterday_price*0.95){
            $buy = 140;
            $btc += $buy/$price;
            $money += $buy;
        }
    }
    echo 'start from '.$year;
    echo ' buy '.$btc.' BTC for '.$money.' USD';
    echo '. ROI is '.($last_price*$btc/$money).PHP_EOL;
}

结果是:

start from 2013 buy 16.835854779097 BTC for 7840 USD. ROI is 20.080343032936
start from 2014 buy 7.2568342363667 BTC for 5880 USD. ROI is 11.540427475479
start from 2015 buy 5.5110740890794 BTC for 4900 USD. ROI is 10.51700762599
start from 2016 buy 2.0373331871337 BTC for 4060 USD. ROI is 4.6923245762494
start from 2017 buy 1.2092733133323 BTC for 3640 USD. ROI is 3.106526798747
start from 2018 buy 0.30747030774609 BTC for 2380 USD. ROI is 1.2080314607537
start from 2019 buy 0.070211328288695 BTC for 700 USD. ROI is 0.93791000479273

如果是从2019开始用这种策略投资,收益是负的。因为2019没有几次买入的机会。

前面的几种策略里面我都是只有买入,如果加入买出能否获得更多收益呢?
代码:

echo 'buy when price down policy and sell when price up:'.PHP_EOL;
$max_roi = 0;
for ($buy_ratio = 0.1; $buy_ratio <= 1; $buy_ratio += 0.01) {
    for ($sell_ratio = 0; $sell_ratio <= 0.1; $sell_ratio += 0.01) {
        $btc = 0;
        $init_money = 11060;
        $money = $init_money;
        foreach ($result as $i => $row) {
            if (0 == $i) {
                continue;
            }
            $yesterday_price = ($result[$i - 1][$keys[1]] + $result[$i - 1][$keys[4]]) / 2;
            if (strtotime($row[$keys[0]]) < strtotime('2013-01-01')) {
                continue;
            }
            $price = $row[$keys[1]];
            if ($price < $yesterday_price * 0.95) {
                //best buy ratio is 0.5 for 2013-2019
                $buy = $money * $buy_ratio;
                if ($buy < 10) {
                    continue;
                }
                $money -= $buy;
                $btc += $buy / $price;
            }
            if ($price > $yesterday_price * 1.05) {
                // best sell ratio is 0 for 2013-2019
                $sell = $btc * $sell_ratio;
                if ($sell < 0.01) {
                    continue;
                }
                $btc -= $sell;
                $money += $price * $sell;
            }
        }
        //echo 'BTC: '.$btc.PHP_EOL;
        //echo 'money: '.$money.PHP_EOL;
        //echo 'Final value: '.($btc*$last_price+$money).PHP_EOL;
        echo 'Buy Ratio: '.$buy_ratio.' , sell ratio '.$sell_ratio.' get '.$btc.' BTC with '.$money.' ';
        $roi = ($btc * $last_price + $money) / $init_money;
        $max_roi = $roi > $max_roi ? $roi : $max_roi;
        echo 'Final ROI: '.$roi.PHP_EOL;
        //echo PHP_EOL;
    }
}
echo 'max roi :'.$max_roi.PHP_EOL;

我的策略很简单,就是价格下跌了5%就买入全部金额的一定比例比特币,价格上涨了5%就卖出一定比例比特币。

结果发现买入比例49%,卖出比例0的时候能得到最高的ROI, 93.036942129554。这个比例高于直接起始的时候直接买入比特币的策略,因为有一部分的比特币是降价之后才买的。同时卖出比例为0,说明这个策略里面不能卖出比特币。其实也很好理解,因为比特币总体是上涨的,一旦你卖出,因为价格升高,你后面买回来的比特币就越少。总体收益也就减少了。

同时这种策略跟市场紧密相关,

如果从2013开始买入,最佳买入比例是0.49, 最佳卖出比例是0.

如果从2014开始买入,最佳买入比例是0.13, 最佳卖出比例是0.

如果从2015开始买入,最佳买入比例是0.46, 最佳卖出比例是0.

如果从2016开始买入,最佳买入比例是0.99, 最佳卖出比例是0.

如果从2017开始买入,最佳买入比例是0.56, 最佳卖出比例是0.

如果从2018开始买入,最佳买入比例是0.09, 最佳卖出比例是0.01.

如果从2019开始买入,最佳买入比例是0, 最佳卖出比例是0.

所以这种策略没有太多的价值,因为我们无从判断未来行情走向。同时如果从2019年开始用这种策略,最优选择是不要买。:)

类似,如果记录上一次的卖出价格做为参考点:

如果从2013开始买入,
Buy Ratio: 0.45 , sell ratio 0 get 102.70933163813 BTC with 306.1478853125 Final ROI: 86.865077379783
如果从2014开始买入,
Buy Ratio: 0.16 , sell ratio 0 get 21.895526577296 BTC with 1146.5311163133 Final ROI: 18.615619685547
如果从2015开始买入,
Buy Ratio: 0.61 , sell ratio 0 get 40.768021693446 BTC with 255.8665746 Final ROI: 34.491169763761
如果从2016开始买入,
Buy Ratio: 0.99 , sell ratio 0 get 29.992604158107 BTC with 110.59999999999 Final ROI: 25.367770564549
如果从2017开始买入,
Buy Ratio: 0.92 , sell ratio 0 get 12.312205165812 BTC with 70.783999999999 Final ROI: 10.415968708755
如果从2018开始买入,
Buy Ratio: 0.1 , sell ratio 0 get 1.2671786688341 BTC with 2811.3036061319 Final ROI: 1.3255449010102
如果从2019开始买入,
Buy Ratio: 0.96 , sell ratio 0 get 3.0243124957152 BTC with 17.695999999999 Final ROI: 2.5585577745758

跟上一种策略的结果类似,没有太大价值。

我还不死心,又想到一个策略,就是下跌5%就买1000块,上涨5%就卖掉5%。

echo 'buy when price down policy and sell when price up:'.PHP_EOL;
$btc = 0;
$invest = 0;
$return = 0;
foreach($result as $i => $row){
    if($i == 0){continue;}
    $yesterday_price = ($result[$i-1][$keys[1]] + $result[$i-1][$keys[4]]) / 2;
    $price = $row[$keys[1]];
    if($price < $yesterday_price*0.95){
        $buy = 140;
        $btc += $buy/$price;
        $invest += $buy;
        echo $row[$keys[0]].' '.$row[$keys[1]].' '.$row[$keys[4]].' ';
        echo 'buy '.$buy/$price.' BTC for '.$buy.' USD'.PHP_EOL;
    }
    if($price > $yesterday_price*1.05){
        $sell = $btc * 0.05;
        if($sell == 0){continue;}
        $btc -= $sell;
        $return += $price*$sell;
        echo $row[$keys[0]].' '.$row[$keys[1]].' '.$row[$keys[4]].' ';
        echo 'sell '.$sell.' BTC for '.($price*$sell).' USD'.PHP_EOL;
    }
}
echo 'BTC: '.$btc.PHP_EOL;
echo 'Invest money: '.$invest.PHP_EOL;
echo 'Final value: '.($btc*$last_price+$return).PHP_EOL;
echo 'Final ROI: '.(($btc*$last_price+$return)/$invest).PHP_EOL;
echo PHP_EOL;

结果是

BTC: 3.2084003878113
Invest money: 7840
Final value: 76196.536163102
Final ROI: 9.7189459391712

就是花了7840usd(56000人民币)买了3.2084003878113个比特币,价值76196.53usd(544260.93人民币)加上中间卖出比特币获得了46195.20usd(329965.71人民币),9.72倍收益。

可以看出这种策略的收益率不到每逢价格下跌5%就买入1000块钱的策略的一半,不过这种策略的优势在于,投入的资金小于卖出比特币获得的资金,也就是很多时候你是用你的盈利来投资,所以比较能够承受住价格波动带来的损失。这种策略里面卖出比例为0的时候收益率最高,也就变成了每逢价格下跌5%就买入1000块钱的策略。

综合所有的结果,我的结论是老老实实也定投,各种策略能跑赢定投的不多。定投的日期也无所谓,只要不是每个月31号就行。

分类
其他

2019-10-20-学习java最少必要知识

看了半个月的java, 总结了一份学习java最少必要知识。

github链接在这里

Java是由Sun Microsystems公司于1995年5月推出的一种跨平台的,面向对象的通用编程语言。

随着Java的发展,SUN给Java又分出了三个不同版本:
Java SE:Standard Edition
Java EE:Enterprise Edition
Java ME:Micro Edition
简单来说,Java SE就是标准版,包含标准的JVM和标准库,而Java EE是企业版,它只是在Java SE的基础上加上了大量的API和库,以便方便开发Web应用、数据库、消息服务等,Java EE的应用使用的虚拟机和Java SE完全相同。
Java ME就和Java SE不同,它是一个针对嵌入式设备的“瘦身版”,Java SE的标准库无法在Java ME上使用,Java ME的虚拟机也是“瘦身版”。
毫无疑问,Java SE是整个Java平台的核心,而Java EE是进一步学习Web应用所必须的。我们熟悉的Spring等框架都是Java EE开源生态系统的一部分。不幸的是,Java ME从来没有真正流行起来,反而是Android开发成为了移动平台的标准之一,因此,没有特殊需求,不建议学习Java ME。

JDK:Java Development Kit
JRE:Java Runtime Environment
简单地说,JRE就是运行Java字节码的虚拟机。但是,如果只有Java源码,要编译成Java字节码,就需要JDK,因为JDK除了包含JRE,还提供了编译器、调试器等开发工具。

JSR规范:Java Specification Request
JCP组织:Java Community Process
为了保证Java语言的规范性,SUN公司搞了一个JSR规范,凡是想给Java平台加一个功能,比如说访问数据库的功能,大家要先创建一个JSR规范,定义好接口,这样,各个数据库厂商都按照规范写出Java驱动程序,开发者就不用担心自己写的数据库代码在MySQL上能跑,却不能跑在PostgreSQL上。

Java基础语法
一个 Java程序可以认为是一系列对象的集合,而这些对象通过调用彼此的方法来协同工作。下面简要介绍下类、对象、方法和实例变量的概念。
对象:对象是类的一个实例,有状态和行为。例如,一条狗是一个对象,它的状态有:颜色、名字、品种;行为有:摇尾巴、叫、吃等。
类:类是一个模板,它描述一类对象的行为和状态。
方法:方法就是行为,一个类可以有很多方法。逻辑运算、数据修改以及所有动作都是在方法中完成的。
实例变量:每个对象都有独特的实例变量,对象的状态由这些实例变量的值决定。

大小写敏感:Java是大小写敏感的,这就意味着标识符 Hello 与 hello 是不同的。
类名:对于所有的类来说,类名的首字母应该大写。如果类名由若干单词组成,那么每个单词的首字母应该大写,例如 MyFirstJavaClass 。
方法名:所有的方法名都应该以小写字母开头。如果方法名含有若干单词,则后面的每个单词首字母大写。
源文件名:源文件名必须和类名相同。当保存文件的时候,你应该使用类名作为文件名保存(切记 Java 是大小写敏感的),文件名的后缀为 .java。(如果文件名和类名不相同则会导致编译错误)。
主方法入口:所有的 Java 程序由 public static void main(String []args) 方法开始执行。

Java标识符
所有的标识符都应该以字母(A-Z 或者 a-z),美元符($)、或者下划线()开始 首字符之后可以是字母(A-Z 或者 a-z),美元符($)、下划线()或数字的任何字符组合
关键字不能用作标识符
标识符是大小写敏感的
合法标识符举例:age、$salary、_value、__1_value
非法标识符举例:123abc、-salary

Java修饰符
访问控制修饰符 : default, public , protected, private
非访问控制修饰符 : final, abstract, static, synchronized

Java数组
数组是储存在堆上的对象,可以保存多个同类型变量。

Java枚举
枚举限制变量只能是预先设定好的值。使用枚举可以减少代码中的 bug。

Java 关键字
访问控制:
private 私有的
protected 受保护的
public 公共的
类、方法和变量修饰符:
abstract 声明抽象
class 类
extends 扩充,继承
final 最终值,不可改变的
implements 实现(接口)
interface 接口
native 本地,原生方法(非 Java 实现)
new 新,创建
static 静态
strictfp 严格,精准
synchronized 线程,同步
transient 短暂
volatile 易失
程序控制语句:
break 跳出循环
case 定义一个值以供 switch 选择
continue 继续
default 默认
do 运行
else 否则
for 循环
if 如果
instanceof 实例
return 返回
switch 根据值选择执行
while 循环
错误处理:
assert 断言表达式是否为真
catch 捕捉异常
finally 有没有异常都执行
throw 抛出一个异常对象
throws 声明一个异常可能被抛出
try 捕获异常
包相关:
import 引入
package 包
基本类型:
boolean 布尔型
byte 字节型
char 字符型
double 双精度浮点
float 单精度浮点
int 整型
long 长整型
short 短整型
变量引用:
super 父类,超类
this 本类
void 无返回值
保留关键字:
goto 是关键字,但不能使用
const 是关键字,但不能使用
null 空

Java注释
Java支持单行以及多行注释。注释中的字符将被 Java 编译器忽略。
// 这是单行注释的示例
/* 这个也是单行注释的示例 / / 这是第一个Java程序
*它将打印Hello World
* 这是一个多行注释的示例
*/

Java空行
空白行或者有注释的行,Java 编译器都会忽略掉。

继承
在 Java 中,一个类可以由其他类派生。如果你要创建一个类,而且已经存在一个类具有你所需要的属性或方法,那么你可以将新创建的类继承该类。
利用继承的方法,可以重用已存在类的方法和属性,而不用重写这些代码。被继承的类称为超类(super class),派生类称为子类(subclass)。

接口
在 Java 中,接口可理解为对象间相互通信的协议。接口在继承中扮演着很重要的角色。
接口只定义派生要用到的方法,但是方法的具体实现完全取决于派生类。

Java 对象和类
Java作为一种面向对象语言。支持以下基本概念:
多态,继承,封装,抽象,类,对象,实例,方法,重载
对象:对象是类的一个实例(对象不是找个女朋友),有状态和行为。例如,一条狗是一个对象,它的状态有:颜色、名字、品种;行为有:摇尾巴、叫、吃等。
类:类是一个模板,它描述一类对象的行为和状态。
男孩(boy)、女孩(girl)为类(class),而具体的每个人为该类的对象(object)。

一个类可以包含以下类型变量:
局部变量:在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中,方法结束后,变量就会自动销毁。
成员变量:成员变量是定义在类中,方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
类变量:类变量也声明在类中,方法体之外,但必须声明为static类型。

构造方法
每个类都有构造方法。如果没有显式地为类定义构造方法,Java编译器将会为该类提供一个默认构造方法。
在创建一个对象的时候,至少要调用一个构造方法。构造方法的名称必须与类同名,一个类可以有多个构造方法。

创建对象
对象是根据类创建的。在Java中,使用关键字new来创建一个新的对象。创建对象需要以下三步:
声明:声明一个对象,包括对象名称和对象类型。
实例化:使用关键字new来创建一个对象。
初始化:使用new创建对象时,会调用构造方法初始化对象。

public class Puppy{
   public Puppy(String name){
      //这个构造器仅有一个参数:name
      System.out.println("小狗的名字是 : " + name );
   }
   public static void main(String[] args){
      // 下面的语句将创建一个Puppy对象
      Puppy myPuppy = new Puppy( "tommy" );
   }
}

访问实例变量和方法
通过已创建的对象来访问成员变量和成员方法,如下所示:

/* 实例化对象 */
Object referenceVariable = new Constructor();
/* 访问类中的变量 */
referenceVariable.variableName;
/* 访问类中的方法 */
referenceVariable.methodName();

源文件声明规则
一个源文件中只能有一个public类
一个源文件可以有多个非public类
源文件的名称应该和public类的类名保持一致。例如:源文件中public类的类名是Employee,那么源文件应该命名为Employee.java。
如果一个类定义在某个包中,那么package语句应该在源文件的首行。
如果源文件包含import语句,那么应该放在package语句和类定义之间。如果没有package语句,那么import语句应该在源文件中最前面。
import语句和package语句对源文件中定义的所有类都有效。在同一源文件中,不能给不同的类不同的包声明。

Java包
包主要用来对类和接口进行分类。当开发Java程序时,可能编写成百上千的类,因此很有必要对类和接口进行分类。
Import语句
在Java中,如果给出一个完整的限定名,包括包名、类名,那么Java编译器就可以很容易地定位到源代码或者类。Import语句就是用来提供一个合理的路径,使得编译器可以找到某个类。
例如,下面的命令行将会命令编译器载入java_installation/java/io路径下的所有类
import java.io.*;

Java 基本数据类型
变量就是申请内存来存储值。也就是说,当创建变量的时候,需要在内存中申请空间。
内存管理系统根据变量的类型为变量分配存储空间,分配的空间只能用来储存该类型数据。

Java 的两大数据类型:
内置数据类型
引用数据类型

内置数据类型
Java语言提供了八种基本类型。六种数字类型(四个整数型,两个浮点型),一种字符类型,还有一种布尔型。
byte:
byte 数据类型是8位、有符号的,以二进制补码表示的整数;
最小值是 -128(-2^7);
最大值是 127(2^7-1);
默认值是 0;
byte 类型用在大型数组中节约空间,主要代替整数,因为 byte 变量占用的空间只有 int 类型的四分之一;
例子:byte a = 100,byte b = -50。
short:
short 数据类型是 16 位、有符号的以二进制补码表示的整数
最小值是 -32768(-2^15);
最大值是 32767(2^15 – 1);
Short 数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一;
默认值是 0;
例子:short s = 1000,short r = -20000。
int:
int 数据类型是32位、有符号的以二进制补码表示的整数;
最小值是 -2,147,483,648(-2^31);
最大值是 2,147,483,647(2^31 – 1);
一般地整型变量默认为 int 类型;
默认值是 0 ;
例子:int a = 100000, int b = -200000。
long:
long 数据类型是 64 位、有符号的以二进制补码表示的整数;
最小值是 -9,223,372,036,854,775,808(-2^63);
最大值是 9,223,372,036,854,775,807(2^63 -1);
这种类型主要使用在需要比较大整数的系统上;
默认值是 0L;
例子: long a = 100000L,Long b = -200000L。
“L”理论上不分大小写,但是若写成”l”容易与数字”1″混淆,不容易分辩。所以最好大写。
float:
float 数据类型是单精度、32位、符合IEEE 754标准的浮点数;
float 在储存大型浮点数组的时候可节省内存空间;
默认值是 0.0f;
浮点数不能用来表示精确的值,如货币;
例子:float f1 = 234.5f。
double:
double 数据类型是双精度、64 位、符合IEEE 754标准的浮点数;
浮点数的默认类型为double类型;
double类型同样不能表示精确的值,如货币;
默认值是 0.0d;
例子:double d1 = 123.4。
boolean:
boolean数据类型表示一位的信息;
只有两个取值:true 和 false;
这种类型只作为一种标志来记录 true/false 情况;
默认值是 false;
例子:boolean one = true。
char:
char类型是一个单一的 16 位 Unicode 字符;
最小值是 \u0000(即为0);
最大值是 \uffff(即为65,535);
char 数据类型可以储存任何字符;
例子:char letter = ‘A’;。

类型默认值
byte 0
short 0
int 0
long 0L
float 0.0f
double 0.0d
char ‘u0000’
String (or any object) null
boolean false

引用类型
在Java中,引用类型的变量非常类似于C/C++的指针。引用类型指向一个对象,指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型,比如 Employee、Puppy 等。变量一旦声明后,类型就不能被改变了。
对象、数组都是引用数据类型。
所有引用类型的默认值都是null。
一个引用变量可以用来引用任何与之兼容的类型。
例子:Site site = new Site(“Runoob”)。

Java 常量
常量在程序运行时是不能被修改的。
在 Java 中使用 final 关键字来修饰常量,声明方式和变量类似:
final double PI = 3.1415927;
虽然常量名也可以用小写,但为了便于识别,通常使用大写字母表示常量。
byte、int、long、和short都可以用十进制、16进制以及8进制的方式来表示。
当使用常量的时候,前缀 0 表示 8 进制,而前缀 0x 代表 16 进制, 例如:
int decimal = 100;
int octal = 0144;
int hexa = 0x64;
Java的字符串常量是包含在两个引号之间的字符序列。
“Hello World”
“two\nlines”
“\”This is in quotes\””
字符串常量和字符常量都可以包含任何Unicode字符。例如:
char a = ‘\u0001’;
String a = “\u0001”;
Java语言支持一些特殊的转义字符序列。
\n 换行 (0x0a)
\r 回车 (0x0d)
\f 换页符(0x0c)
\b 退格 (0x08)
\0 空字符 (0x20)
\s 字符串
\t 制表符
\” 双引号
\’ 单引号
\ 反斜杠
\ddd 八进制字符 (ddd)
\uxxxx 16进制Unicode字符 (xxxx)

自动类型转换
整型、实型(常量)、字符型数据可以混合运算。运算中,不同类型的数据先转化为同一类型,然后进行运算。
转换从低级到高级。
byte,short,char—> int —> long—> float —> double

  1. 不能对boolean类型进行类型转换。
  2. 不能把对象类型转换成不相关类的对象。
  3. 在把容量大的类型转换为容量小的类型时必须使用强制类型转换。
  4. 转换过程中可能导致溢出或损失精度,例如:
    int i =128;
    byte b = (byte)i;
    因为 byte 类型是 8 位,最大值为127,所以当 int 强制转换为 byte 类型时,值 128 时候就会导致溢出。
  5. 浮点数到整数的转换是通过舍弃小数得到,而不是四舍五入,例如:
    (int)23.7 == 23;
    (int)-45.89f == -45
    必须满足转换前的数据类型的位数要低于转换后的数据类型,例如: short数据类型的位数为16位,就可以自动转换位数为32的int类型,同样float数据类型的位数为32,可以自动转换为64位的double类型。

强制类型转换

  1. 条件是转换的数据类型必须是兼容的。
  2. 格式:(type)value type是要强制类型转换后的数据类型 实例:
public class TypeConversion{
    public static void main(String[] args){
        int i1 = 123;
        byte b = (byte)i1;//强制类型转换为byte
        System.out.println("int强制类型转换为byte后的值等于"+b);
    }
}

Java 变量类型
在Java语言中,所有的变量在使用前必须声明。声明变量的基本格式如下:
type identifier [ = value][, identifier [= value] …] ;
格式说明:type为Java数据类型。identifier是变量名。可以使用逗号隔开来声明多个同类型变量。
以下列出了一些变量的声明实例。注意有些包含了初始化过程。
int a, b, c; // 声明三个int型整数:a、 b、c
int d = 3, e = 4, f = 5; // 声明三个整数并赋予初值
byte z = 22; // 声明并初始化 z
String s = “runoob”; // 声明并初始化字符串 s
double pi = 3.14159; // 声明了双精度浮点型变量 pi
char x = ‘x’; // 声明变量 x 的值是字符 ‘x’。

Java语言支持的变量类型有:
类变量:独立于方法之外的变量,用 static 修饰。
实例变量:独立于方法之外的变量,不过没有 static 修饰。
局部变量:类的方法中的变量。
public class Variable{
static int allClicks=0; // 类变量
String str=”hello world”; // 实例变量
public void method(){
int i =0; // 局部变量
}
}

Java 局部变量
局部变量声明在方法、构造方法或者语句块中;
局部变量在方法、构造方法、或者语句块被执行的时候创建,当它们执行完成后,变量将会被销毁;
访问修饰符不能用于局部变量;
局部变量只在声明它的方法、构造方法或者语句块中可见;
局部变量是在栈上分配的。
局部变量没有默认值,所以局部变量被声明后,必须经过初始化,才可以使用。

实例变量
实例变量声明在一个类中,但在方法、构造方法和语句块之外;
当一个对象被实例化之后,每个实例变量的值就跟着确定;
实例变量在对象创建的时候创建,在对象被销毁的时候销毁;
实例变量的值应该至少被一个方法、构造方法或者语句块引用,使得外部能够通过这些方式获取实例变量信息;
实例变量可以声明在使用前或者使用后;
访问修饰符可以修饰实例变量;
实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见;
实例变量具有默认值。数值型变量的默认值是0,布尔型变量的默认值是false,引用类型变量的默认值是null。变量的值可以在声明时指定,也可以在构造方法中指定;
实例变量可以直接通过变量名访问。但在静态方法以及其他类中,就应该使用完全限定名:ObejectReference.VariableName。

类变量(静态变量)
类变量也称为静态变量,在类中以 static 关键字声明,但必须在方法之外。
无论一个类创建了多少个对象,类只拥有类变量的一份拷贝。
静态变量除了被声明为常量外很少使用。常量是指声明为public/private,final和static类型的变量。常量初始化后不可改变。
静态变量储存在静态存储区。经常被声明为常量,很少单独使用static声明变量。
静态变量在第一次被访问时创建,在程序结束时销毁。
与实例变量具有相似的可见性。但为了对类的使用者可见,大多数静态变量声明为public类型。
默认值和实例变量相似。数值型变量默认值是0,布尔型默认值是false,引用类型默认值是null。变量的值可以在声明的时候指定,也可以在构造方法中指定。此外,静态变量还可以在静态语句块中初始化。
静态变量可以通过:ClassName.VariableName的方式访问。
类变量被声明为public static final类型时,类变量名称一般建议使用大写字母。如果静态变量不是public和final类型,其命名方式与实例变量以及局部变量的命名方式一致。

import java.io.*;
public class Employee {
    //salary是静态的私有变量
    private static double salary;
    // DEPARTMENT是一个常量
    public static final String DEPARTMENT = "开发人员";
    public static void main(String[] args){
    salary = 10000;
        System.out.println(DEPARTMENT+"平均工资:"+salary);
    }
}

Java 修饰符
访问控制修饰符
Java中,可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。
default (即默认,什么也不写): 在同一包内可见,不使用任何修饰符。使用对象:类、接口、变量、方法。
private : 在同一类内可见。使用对象:变量、方法。 注意:不能修饰类(外部类)
public : 对所有类可见。使用对象:类、接口、变量、方法
protected : 对同一包内的类和所有子类可见。使用对象:变量、方法。 注意:不能修饰类(外部类)。
修饰符 当前类 同一包内 子孙类(同一包) 子孙类(不同包) 其他包
public Y Y Y Y Y
protected Y Y Y Y/N(说明) N
default Y Y Y N N
private Y N N N N

默认访问修饰符-不使用任何关键字
使用默认访问修饰符声明的变量和方法,对同一个包内的类是可见的。接口里的变量都隐式声明为 public static final,而接口里的方法默认情况下访问权限为 public。

私有访问修饰符-private
私有访问修饰符是最严格的访问级别,所以被声明为 private 的方法、变量和构造方法只能被所属类访问,并且类和接口不能声明为 private。
声明为私有访问类型的变量只能通过类中公共的 getter 方法被外部类访问。
Private 访问修饰符的使用主要用来隐藏类的实现细节和保护类的数据。

公有访问修饰符-public
被声明为 public 的类、方法、构造方法和接口能够被任何其他类访问。
如果几个相互访问的 public 类分布在不同的包中,则需要导入相应 public 类所在的包。由于类的继承性,类所有的公有方法和变量都能被其子类继承。

受保护的访问修饰符-protected
protected 需要从以下两个点来分析说明:
子类与基类在同一包中:被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问;
子类与基类不在同一包中:那么在子类中,子类实例可以访问其从基类继承而来的 protected 方法,而不能访问基类实例的protected方法。

访问控制和继承
请注意以下方法继承的规则:
父类中声明为 public 的方法在子类中也必须为 public。
父类中声明为 protected 的方法在子类中要么声明为 protected,要么声明为 public,不能声明为 private。
父类中声明为 private 的方法,不能够被继承。

非访问修饰符
为了实现一些其他的功能,Java 也提供了许多非访问修饰符。
static 修饰符,用来修饰类方法和类变量。
final 修饰符,用来修饰类、方法和变量,final 修饰的类不能够被继承,修饰的方法不能被继承类重新定义,修饰的变量为常量,是不可修改的。
abstract 修饰符,用来创建抽象类和抽象方法。
synchronized 和 volatile 修饰符,主要用于线程的编程。

static 修饰符
静态变量:static 关键字用来声明独立于对象的静态变量,无论一个类实例化多少对象,它的静态变量只有一份拷贝。 静态变量也被称为类变量。局部变量不能被声明为 static 变量。
静态方法:static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据,然后计算这些数据。
对类变量和方法的访问可以直接使用 classname.variablename 和 classname.methodname 的方式访问。

public class InstanceCounter {
   private static int numInstances = 0;
   protected static int getCount() {
      return numInstances;
   }
   private static void addInstance() {
      numInstances++;
   }
   InstanceCounter() {
      InstanceCounter.addInstance();
   }
   public static void main(String[] arguments) {
      System.out.println("Starting with " +
      InstanceCounter.getCount() + " instances");
      for (int i = 0; i < 500; ++i){
         new InstanceCounter();
          }
      System.out.println("Created " +
      InstanceCounter.getCount() + " instances");
   }
}

final 修饰符
final 变量:
final 表示”最后的、最终的”含义,变量一旦赋值后,不能被重新赋值。被 final 修饰的实例变量必须显式指定初始值。
final 修饰符通常和 static 修饰符一起使用来创建类常量。
final 方法:
父类中的 final 方法可以被子类继承,但是不能被子类重写。声明 final 方法的主要目的是防止该方法的内容被修改。
final 类:
final 类不能被继承,没有类能够继承 final 类的任何特性。

abstract 修饰符
抽象类:
抽象类不能用来实例化对象,声明抽象类的唯一目的是为了将来对该类进行扩充。
一个类不能同时被 abstract 和 final 修饰。如果一个类包含抽象方法,那么该类一定要声明为抽象类,否则将出现编译错误。
抽象类可以包含抽象方法和非抽象方法。
抽象方法
抽象方法是一种没有任何实现的方法,该方法的的具体实现由子类提供。
抽象方法不能被声明成 final 和 static。
任何继承抽象类的子类必须实现父类的所有抽象方法,除非该子类也是抽象类。
如果一个类包含若干个抽象方法,那么该类必须声明为抽象类。抽象类可以不包含抽象方法。
抽象方法的声明以分号结尾,例如:public abstract sample();。

synchronized 修饰符
synchronized 关键字声明的方法同一时间只能被一个线程访问。synchronized 修饰符可以应用于四个访问修饰符。

transient 修饰符
序列化的对象包含被 transient 修饰的实例变量时,java 虚拟机(JVM)跳过该特定的变量。
该修饰符包含在定义变量的语句中,用来预处理类和变量的数据类型。
public transient int limit = 55; // 不会持久化
public int b; // 持久化

volatile 修饰符
volatile 修饰的成员变量在每次被线程访问时,都强制从共享内存中重新读取该成员变量的值。而且,当成员变量发生变化时,会强制线程将变化值回写到共享内存。这样在任何时刻,两个不同的线程总是看到某个成员变量的同一个值。
一个 volatile 对象引用可能是 null。

Java 运算符
算术运算符
关系运算符
位运算符
逻辑运算符
赋值运算符
其他运算符

算术运算符
假设整数变量A的值为10,变量B的值为20

  • 加法 – 相加运算符两侧的值 A + B 等于 30
  • 减法 – 左操作数减去右操作数 A – B 等于 -10
  • 乘法 – 相乘操作符两侧的值 A * B等于200
    / 除法 – 左操作数除以右操作数 B / A等于2
    % 取余 – 左操作数除以右操作数的余数 B%A等于0
    ++ 自增: 操作数的值增加1 B++ 或 ++B 等于 21(区别详见下文)
    — 自减: 操作数的值减少1 B– 或 –B 等于 19(区别详见下文)
    自增自减运算符
    1、自增(++)自减(–)运算符是一种特殊的算术运算符,在算术运算符中需要两个操作数来进行运算,而自增自减运算符是一个操作数。
    2、前缀自增自减法(++a,–a): 先进行自增或者自减运算,再进行表达式运算。
    3、后缀自增自减法(a++,a–): 先进行表达式运算,再进行自增或者自减运算。

关系运算符
假设整数变量A的值为10,变量B的值为20
== 检查如果两个操作数的值是否相等,如果相等则条件为真。 (A == B)为假。
!= 检查如果两个操作数的值是否相等,如果值不相等则条件为真。 (A != B) 为真。

〉检查左操作数的值是否大于右操作数的值,如果是那么条件为真。   (A> B)为假。

< 检查左操作数的值是否小于右操作数的值,如果是那么条件为真。 (A = B)为假。
<= 检查左操作数的值是否小于或等于右操作数的值,如果是那么条件为真。 (A <= B)为真。

位运算符
Java定义了位运算符,应用于整数类型(int),长整型(long),短整型(short),字符型(char),和字节型(byte)等类型。
位运算符作用在所有的位上,并且按位运算。假设a = 60,b = 13;它们的二进制格式表示将如下:
A = 0011 1100

B = 0000 1101

A&B = 0000 1100
A | B = 0011 1101
A ^ B = 0011 0001
~A= 1100 0011
假设整数变量 A 的值为 60 和变量 B 的值为 13
& 如果相对应位都是1,则结果为1,否则为0 (A&B),得到12,即0000 1100
| 如果相对应位都是 0,则结果为 0,否则为 1 (A | B)得到61,即 0011 1101
^ 如果相对应位值相同,则结果为0,否则为1 (A ^ B)得到49,即 0011 0001
〜 按位取反运算符翻转操作数的每一位,即0变成1,1变成0。 (〜A)得到-61,即1100 0011
<< 按位左移运算符。左操作数按位左移右操作数指定的位数。 A << 2得到240,即 1111 0000

按位右移运算符。左操作数按位右移右操作数指定的位数。  A >> 2得到15即 1111
按位右移补零操作符。左操作数的值按右操作数指定的位数右移,移动得到的空位以零填充。   A>>>2得到15即0000 1111

逻辑运算符
假设布尔变量A为真,变量B为假
&& 称为逻辑与运算符。当且仅当两个操作数都为真,条件才为真。 (A && B)为假。
| | 称为逻辑或操作符。如果任何两个操作数任何一个为真,条件为真。 (A | | B)为真。
! 称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true,则逻辑非运算符将得到false。 !(A && B)为真。

短路逻辑运算符
当使用与逻辑运算符时,在两个操作数都为true时,结果才为true,但是当得到第一个操作为false时,其结果就必定是false,这时候就不会再判断第二个操作了。
public class LuoJi{
public static void main(String[] args){
int a = 5;//定义一个变量;
boolean b = (a<4)&&(a++<10);
System.out.println(“使用短路逻辑运算符的结果为”+b);
System.out.println(“a的结果为”+a);
}
}

赋值运算符
= 简单的赋值运算符,将右操作数的值赋给左侧操作数 C = A + B将把A + B得到的值赋给C
+= 加和赋值操作符,它把左操作数和右操作数相加赋值给左操作数 C + = A等价于C = C + A
-= 减和赋值操作符,它把左操作数和右操作数相减赋值给左操作数 C – = A等价于C = C – A
*= 乘和赋值操作符,它把左操作数和右操作数相乘赋值给左操作数 C * = A等价于C = C * A
/= 除和赋值操作符,它把左操作数和右操作数相除赋值给左操作数 C / = A,C 与 A 同类型时等价于 C = C / A
%= 取模和赋值操作符,它把左操作数和右操作数取模后赋值给左操作数 C%= A等价于C = C%A
<<= 左移位赋值运算符 C << = 2等价于C = C << 2

= 右移位赋值运算符 C >> = 2等价于C = C >> 2
&= 按位与赋值运算符 C&= 2等价于C = C&2
^= 按位异或赋值操作符 C ^ = 2等价于C = C ^ 2
|= 按位或赋值操作符 C | = 2等价于C = C | 2

条件运算符(?:)
条件运算符也被称为三元运算符。该运算符有3个操作数,并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。
variable x = (expression) ? value if true : value if false

instanceof运算符
该运算符用于操作对象实例,检查该对象是否是一个特定类型(类类型或接口类型)。
instanceof运算符使用格式如下:
( Object reference variable ) instanceof (class/interface type)
如果运算符左侧变量所指的对象,是操作符右侧类或接口(class/interface)的一个对象,那么结果为真。
String name = “James”;
boolean result = name instanceof String; // 由于 name 是 String 类型,所以返回真
如果被比较的对象兼容于右侧类型,该运算符仍然返回true。
class Vehicle {}
public class Car extends Vehicle {
public static void main(String[] args){
Vehicle a = new Car();
boolean result = a instanceof Car;
System.out.println( result);
}
}

Java运算符优先级
下表中具有最高优先级的运算符在的表的最上面,最低优先级的在表的底部。
类别 操作符 关联性
后缀 () [] . (点操作符) 左到右
一元 + + – !〜 从右到左
乘性 * /% 左到右
加性 + – 左到右
移位 >> >>> << 左到右 关系 >> = << = 左到右 相等 == != 左到右 按位与 & 左到右 按位异或 ^ 左到右 按位或 | 左到右 逻辑与 && 左到右 逻辑或 | | 左到右 条件 ?: 从右到左 赋值 = + = – = * = / =%= >> = << =&= ^ = | = 从右到左
逗号 , 左到右

Java 循环结构 – for, while 及 do…while
Java中有三种主要的循环结构:
while 循环
do…while 循环
for 循环

while 循环
while是最基本的循环,它的结构为:
while( 布尔表达式 ) {
//循环内容
}
只要布尔表达式为 true,循环就会一直执行下去。

do…while 循环
对于 while 语句而言,如果不满足条件,则不能进入循环。但有时候我们需要即使不满足条件,也至少执行一次。
do…while 循环和 while 循环相似,不同的是,do…while 循环至少会执行一次。
do {
//代码语句
}while(布尔表达式);

for循环
虽然所有循环结构都可以用 while 或者 do…while表示,但 Java 提供了另一种语句 —— for 循环,使一些循环结构变得更加简单。
for循环执行的次数是在执行前就确定的。语法格式如下:
for(初始化; 布尔表达式; 更新) {
//代码语句
}
最先执行初始化步骤。可以声明一种类型,但可初始化一个或多个循环控制变量,也可以是空语句。
然后,检测布尔表达式的值。如果为 true,循环体被执行。如果为false,循环终止,开始执行循环体后面的语句。
执行一次循环后,更新循环控制变量。
再次检测布尔表达式。循环执行上面的过程。

Java 增强 for 循环
Java5 引入了一种主要用于数组的增强型 for 循环。
Java 增强 for 循环语法格式如下:
for(声明语句 : 表达式)
{
//代码句子
}
声明语句:声明新的局部变量,该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块,其值与此时数组元素的值相等。
表达式:表达式是要访问的数组名,或者是返回值为数组的方法。

public class Test {
   public static void main(String args[]){
      int [] numbers = {10, 20, 30, 40, 50};

      for(int x : numbers ){
         System.out.print( x );
         System.out.print(",");
      }
      System.out.print("\n");
      String [] names ={"James", "Larry", "Tom", "Lacy"};
      for( String name : names ) {
         System.out.print( name );
         System.out.print(",");
      }
   }
}

break 关键字
break 主要用在循环语句或者 switch 语句中,用来跳出整个语句块。
break 跳出最里层的循环,并且继续执行该循环下面的语句。

continue 关键字
continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。
在 for 循环中,continue 语句使程序立即跳转到更新语句。
在 while 或者 do…while 循环中,程序立即跳转到布尔表达式的判断语句。

Java 条件语句 – if…else
一个 if 语句包含一个布尔表达式和一条或多条语句。
语法
if 语句的语法如下:
if(布尔表达式)
{
//如果布尔表达式为true将执行的语句
}
如果布尔表达式的值为 true,则执行 if 语句中的代码块,否则执行 if 语句块后面的代码。

if…else语句
if 语句后面可以跟 else 语句,当 if 语句的布尔表达式值为 false 时,else 语句块会被执行。
语法
if…else 的用法如下:
if(布尔表达式){
//如果布尔表达式的值为true
}else{
//如果布尔表达式的值为false
}

if…else if…else 语句
if 语句后面可以跟 else if…else 语句,这种语句可以检测到多种可能的情况。
使用 if,else if,else 语句的时候,需要注意下面几点:
if 语句至多有 1 个 else 语句,else 语句在所有的 else if 语句之后。
if 语句可以有若干个 else if 语句,它们必须在 else 语句之前。
一旦其中一个 else if 语句检测为 true,其他的 else if 以及 else 语句都将跳过执行。
语法
if…else 语法格式如下:
if(布尔表达式 1){
//如果布尔表达式 1的值为true执行代码
}else if(布尔表达式 2){
//如果布尔表达式 2的值为true执行代码
}else if(布尔表达式 3){
//如果布尔表达式 3的值为true执行代码
}else {
//如果以上布尔表达式都不为true执行代码
}

嵌套的 if…else 语句
使用嵌套的 if…else 语句是合法的。也就是说你可以在另一个 if 或者 else if 语句中使用 if 或者 else if 语句。
语法
嵌套的 if…else 语法格式如下:
if(布尔表达式 1){
////如果布尔表达式 1的值为true执行代码
if(布尔表达式 2){
////如果布尔表达式 2的值为true执行代码
}
}

Java switch case 语句
switch case 语句判断一个变量与一系列值中某个值是否相等,每个值称为一个分支。
语法
switch case 语句语法格式如下:
switch(expression){
case value :
//语句
break; //可选
case value :
//语句
break; //可选
//你可以有任意数量的case语句
default : //可选
//语句
}
switch case 语句有如下规则:
switch 语句中的变量类型可以是: byte、short、int 或者 char。从 Java SE 7 开始,switch 支持字符串 String 类型了,同时 case 标签必须为字符串常量或字面量。
switch 语句可以拥有多个 case 语句。每个 case 后面跟一个要比较的值和冒号。
case 语句中的值的数据类型必须与变量的数据类型相同,而且只能是常量或者字面常量。
当变量的值与 case 语句的值相等时,那么 case 语句之后的语句开始执行,直到 break 语句出现才会跳出 switch 语句。
当遇到 break 语句时,switch 语句终止。程序跳转到 switch 语句后面的语句执行。case 语句不必须要包含 break 语句。如果没有 break 语句出现,程序会继续执行下一条 case 语句,直到出现 break 语句。
switch 语句可以包含一个 default 分支,该分支一般是 switch 语句的最后一个分支(可以在任何位置,但建议在最后一个)。default 在没有 case 语句的值和变量值相等的时候执行。default 分支不需要 break 语句。
switch case 执行时,一定会先进行匹配,匹配成功返回当前 case 的值,再根据是否有 break,判断是否继续输出,或是跳出判断。
如果 case 语句块中没有 break 语句时,JVM 并不会顺序输出每一个 case 对应的返回值,而是继续匹配,匹配不成功则返回默认 case。
如果当前匹配成功的 case 语句块没有 break 语句,则从当前 case 开始,后续所有 case 的值都会输出,如果后续的 case 语句块有 break 语句则会跳出判断。

Java Number & Math 类
Java 语言为每一个内置数据类型提供了对应的包装类。
所有的包装类(Integer、Long、Byte、Double、Float、Short)都是抽象类 Number 的子类。
基本类型 包装类
double Double
float Float
long Long
int Integer
short Short
byte Byte
char Character
boolean Boolean

Java Math 类
Java 的 Math 包含了用于执行基本数学运算的属性和方法,如初等指数、对数、平方根和三角函数。
Math 的方法都被定义为 static 形式,通过 Math 类可以在主函数中直接调用。

public class Test {
    public static void main (String []args)
    {
        System.out.println("90 度的正弦值:" + Math.sin(Math.PI/2));
        System.out.println("0度的余弦值:" + Math.cos(0));
        System.out.println("60度的正切值:" + Math.tan(Math.PI/3));
        System.out.println("1的反正切值: " + Math.atan(1));
        System.out.println("π/2的角度值:" + Math.toDegrees(Math.PI/2));
        System.out.println(Math.PI);
    }
}

Number & Math 类方法
1 xxxValue()
将 Number 对象转换为xxx数据类型的值并返回。
2 compareTo()
将number对象与参数比较。
3 equals()
判断number对象是否与参数相等。
4 valueOf()
返回一个 Number 对象指定的内置数据类型
5 toString()
以字符串形式返回值。
6 parseInt()
将字符串解析为int类型。
7 abs()
返回参数的绝对值。
8 ceil()
返回大于等于( >= )给定参数的的最小整数,类型为双精度浮点型。
9 floor()
返回小于等于(<=)给定参数的最大整数 。
10 rint()
返回与参数最接近的整数。返回类型为double。
11 round()
它表示四舍五入,算法为 Math.floor(x+0.5),即将原来的数字加上 0.5 后再向下取整,所以,Math.round(11.5) 的结果为12,Math.round(-11.5) 的结果为-11。
12 min()
返回两个参数中的最小值。
13 max()
返回两个参数中的最大值。
14 exp()
返回自然数底数e的参数次方。
15 log()
返回参数的自然数底数的对数值。
16 pow()
返回第一个参数的第二个参数次方。
17 sqrt()
求参数的算术平方根。
18 sin()
求指定double类型参数的正弦值。
19 cos()
求指定double类型参数的余弦值。
20 tan()
求指定double类型参数的正切值。
21 asin()
求指定double类型参数的反正弦值。
22 acos()
求指定double类型参数的反余弦值。
23 atan()
求指定double类型参数的反正切值。
24 atan2()
将笛卡尔坐标转换为极坐标,并返回极坐标的角度值。
25 toDegrees()
将参数转化为角度。
26 toRadians()
将角度转换为弧度。
27 random()
返回一个随机数。

Java Character 类
Java语言为内置数据类型char提供了包装类Character类。
Character ch = new Character(‘a’);
下面是Character类的方法:
1 isLetter()是否是一个字母
2 isDigit()是否是一个数字字符
3 isWhitespace()是否是一个空白字符
4 isUpperCase()是否是大写字母
5 isLowerCase()是否是小写字母
6 toUpperCase()指定字母的大写形式
7 toLowerCase()指定字母的小写形式
8 toString()返回字符的字符串形式,字符串的长度仅为1

Java String 类
Java 提供了 String 类来创建和操作字符串。
String greeting = “菜鸟教程”;
String 类有 11 种构造方法,这些方法提供不同的参数来初始化字符串,比如提供一个字符数组参数:

public class StringDemo{
   public static void main(String args[]){
      char[] helloArray = { 'r', 'u', 'n', 'o', 'o', 'b'};
      String helloString = new String(helloArray);
      System.out.println( helloString );
   }
}

字符串长度
String 类的一个访问器方法是 length() 方法,它返回字符串对象包含的字符数。

public class StringDemo {
    public static void main(String args[]) {
        String site = "www.runoob.com";
        int len = site.length();
        System.out.println( "菜鸟教程网址长度 : " + len );
   }
}

连接字符串
String 类提供了连接两个字符串的方法:
string1.concat(string2);
返回 string2 连接 string1 的新字符串。也可以对字符串常量使用 concat() 方法,如

public class StringDemo {
    public static void main(String args[]) {
        String string1 = "菜鸟教程网址:";
        System.out.println("1、" + string1 + "www.runoob.com");
    }
}

创建格式化字符串
我们知道输出格式化数字可以使用 printf() 和 format() 方法。
String 类使用静态方法 format() 返回一个String 对象而不是 PrintStream 对象。
String 类的静态方法 format() 能用来创建可复用的格式化字符串,而不仅仅是用于一次打印输出。

String fs;
fs = String.format("浮点型变量的值为 " +
                   "%f, 整型变量的值为 " +
                   " %d, 字符串变量的值为 " +
                   " %s", floatVar, intVar, stringVar);

String 方法
1 char charAt(int index) 返回指定索引处的 char 值。
2 int compareTo(Object o) 把这个字符串和另一个对象比较。
3 int compareTo(String anotherString) 按字典顺序比较两个字符串。
4 int compareToIgnoreCase(String str) 按字典顺序比较两个字符串,不考虑大小写。
5 String concat(String str) 将指定字符串连接到此字符串的结尾。
6 boolean contentEquals(StringBuffer sb) 当且仅当字符串与指定的StringBuffer有相同顺序的字符时候返回真。
7 static String copyValueOf(char[] data) 返回指定数组中表示该字符序列的 String。
8 static String copyValueOf(char[] data, int offset, int count) 返回指定数组中表示该字符序列的 String。
9 boolean endsWith(String suffix) 测试此字符串是否以指定的后缀结束。
10 boolean equals(Object anObject) 将此字符串与指定的对象比较。
11 boolean equalsIgnoreCase(String anotherString) 将此 String 与另一个 String 比较,不考虑大小写。
12 byte[] getBytes() 使用平台的默认字符集将此 String 编码为 byte 序列,并将结果存储到一个新的 byte 数组中。
13 byte[] getBytes(String charsetName) 使用指定的字符集将此 String 编码为 byte 序列,并将结果存储到一个新的 byte 数组中。
14 void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 将字符从此字符串复制到目标字符数组。
15 int hashCode() 返回此字符串的哈希码。
16 int indexOf(int ch) 返回指定字符在此字符串中第一次出现处的索引。
17 int indexOf(int ch, int fromIndex) 返回在此字符串中第一次出现指定字符处的索引,从指定的索引开始搜索。
18 int indexOf(String str) 返回指定子字符串在此字符串中第一次出现处的索引。
19 int indexOf(String str, int fromIndex) 返回指定子字符串在此字符串中第一次出现处的索引,从指定的索引开始。
20 String intern() 返回字符串对象的规范化表示形式。
21 int lastIndexOf(int ch) 返回指定字符在此字符串中最后一次出现处的索引。
22 int lastIndexOf(int ch, int fromIndex) 返回指定字符在此字符串中最后一次出现处的索引,从指定的索引处开始进行反向搜索。
23 int lastIndexOf(String str) 返回指定子字符串在此字符串中最右边出现处的索引。
24 int lastIndexOf(String str, int fromIndex) 返回指定子字符串在此字符串中最后一次出现处的索引,从指定的索引开始反向搜索。
25 int length() 返回此字符串的长度。
26 boolean matches(String regex) 告知此字符串是否匹配给定的正则表达式。
27 boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len) 测试两个字符串区域是否相等。
28 boolean regionMatches(int toffset, String other, int ooffset, int len) 测试两个字符串区域是否相等。
29 String replace(char oldChar, char newChar) 返回一个新的字符串,它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
30 String replaceAll(String regex, String replacement) 使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
31 String replaceFirst(String regex, String replacement) 使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
32 String[] split(String regex) 根据给定正则表达式的匹配拆分此字符串。
33 String[] split(String regex, int limit) 根据匹配给定的正则表达式来拆分此字符串。
34 boolean startsWith(String prefix) 测试此字符串是否以指定的前缀开始。
35 boolean startsWith(String prefix, int toffset) 测试此字符串从指定索引开始的子字符串是否以指定前缀开始。
36 CharSequence subSequence(int beginIndex, int endIndex) 返回一个新的字符序列,它是此序列的一个子序列。
37 String substring(int beginIndex) 返回一个新的字符串,它是此字符串的一个子字符串。
38 String substring(int beginIndex, int endIndex) 返回一个新字符串,它是此字符串的一个子字符串。
39 char[] toCharArray() 将此字符串转换为一个新的字符数组。
40 String toLowerCase() 使用默认语言环境的规则将此 String 中的所有字符都转换为小写。
41 String toLowerCase(Locale locale) 使用给定 Locale 的规则将此 String 中的所有字符都转换为小写。
42 String toString() 返回此对象本身(它已经是一个字符串!)。
43 String toUpperCase() 使用默认语言环境的规则将此 String 中的所有字符都转换为大写。
44 String toUpperCase(Locale locale) 使用给定 Locale 的规则将此 String 中的所有字符都转换为大写。
45 String trim() 返回字符串的副本,忽略前导空白和尾部空白。
46 static String valueOf(primitive data type x) 返回给定data type类型x参数的字符串表示形式。

Java StringBuffer 和 StringBuilder 类
当对字符串进行修改的时候,需要使用 StringBuffer 和 StringBuilder 类。
由于 StringBuilder 相较于 StringBuffer 有速度优势,所以多数情况下建议使用 StringBuilder 类。然而在应用程序要求线程安全的情况下,则必须使用 StringBuffer 类。

public class Test{
  public static void main(String args[]){
    StringBuffer sBuffer = new StringBuffer("菜鸟教程官网:");
    sBuffer.append("www");
    sBuffer.append(".runoob");
    sBuffer.append(".com");
    System.out.println(sBuffer);
  }
}

StringBuffer 方法
1 public StringBuffer append(String s) 将指定的字符串追加到此字符序列。
2 public StringBuffer reverse() 将此字符序列用其反转形式取代。
3 public delete(int start, int end) 移除此序列的子字符串中的字符。
4 public insert(int offset, int i) 将 int 参数的字符串表示形式插入此序列中。
5 replace(int start, int end, String str) 使用给定 String 中的字符替换此序列的子字符串中的字符。
下面的列表里的方法和 String 类的方法类似:
1 int capacity() 返回当前容量。
2 char charAt(int index) 返回此序列中指定索引处的 char 值。
3 void ensureCapacity(int minimumCapacity) 确保容量至少等于指定的最小值。
4 void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 将字符从此序列复制到目标字符数组 dst。
5 int indexOf(String str) 返回第一次出现的指定子字符串在该字符串中的索引。
6 int indexOf(String str, int fromIndex) 从指定的索引处开始,返回第一次出现的指定子字符串在该字符串中的索引。
7 int lastIndexOf(String str) 返回最右边出现的指定子字符串在此字符串中的索引。
8 int lastIndexOf(String str, int fromIndex) 返回 String 对象中子字符串最后出现的位置。
9 int length() 返回长度(字符数)。
10 void setCharAt(int index, char ch) 将给定索引处的字符设置为 ch。
11 void setLength(int newLength) 设置字符序列的长度。
12 CharSequence subSequence(int start, int end) 返回一个新的字符序列,该字符序列是此序列的子序列。
13 String substring(int start) 返回一个新的 String,它包含此字符序列当前所包含的字符子序列。
14 String substring(int start, int end) 返回一个新的 String,它包含此序列当前所包含的字符子序列。
15 String toString() 返回此序列中数据的字符串表示形式。

Java 数组
Java 语言中提供的数组是用来存储固定大小的同类型元素。
声明数组变量
首先必须声明数组变量,才能在程序中使用数组。下面是声明数组变量的语法:
dataType[] arrayRefVar; // 首选的方法

dataType arrayRefVar[]; // 效果相同,但不是首选方法

创建数组
Java语言使用new操作符来创建数组,语法如下:
arrayRefVar = new dataType[arraySize];
上面的语法语句做了两件事:
一、使用 dataType[arraySize] 创建了一个数组。
二、把新创建的数组的引用赋值给变量 arrayRefVar。
数组变量的声明,和创建数组可以用一条语句完成,如下所示:
dataType[] arrayRefVar = new dataType[arraySize];
另外,你还可以使用如下的方式创建数组。
dataType[] arrayRefVar = {value0, value1, …, valuek};
数组的元素是通过索引访问的。数组索引从 0 开始,所以索引值从 0 到 arrayRefVar.length-1。

处理数组
数组的元素类型和数组的大小都是确定的,所以当处理数组元素时候,我们通常使用基本循环或者 For-Each 循环。

public class TestArray {
   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};
      // 打印所有数组元素
      for (int i = 0; i < myList.length; i++) {
         System.out.println(myList[i] + " ");
      }
      // 计算所有元素的总和
      double total = 0;
      for (int i = 0; i < myList.length; i++) {
         total += myList[i];
      }
      System.out.println("Total is " + total);
      // 查找最大元素
      double max = myList[0];
      for (int i = 1; i < myList.length; i++) {
         if (myList[i] > max) max = myList[i];
      }
      System.out.println("Max is " + max);
      // 打印所有数组元素
      for (double element: myList) {
         System.out.println(element);
      }
   }
}

数组作为函数的参数
数组可以作为参数传递给方法。

public static void printArray(int[] array) {
  for (int i = 0; i < array.length; i++) {
    System.out.print(array[i] + " ");
  }
}
printArray(new int[]{3, 1, 2, 6, 4, 2});

数组作为函数的返回值

public static int[] reverse(int[] list) {
  int[] result = new int[list.length];

  for (int i = 0, j = result.length - 1; i < list.length; i++, j--) {
    result[j] = list[i];
  }
  return result;
}

多维数组
多维数组可以看成是数组的数组,比如二维数组就是一个特殊的一维数组,其每一个元素都是一个一维数组,例如:
String str[][] = new String[3][4];
多维数组的动态初始化(以二维数组为例)

  1. 直接为每一维分配空间,格式如下:
    type[][] typeName = new type[typeLength1][typeLength2];
    type 可以为基本数据类型和复合数据类型,arraylength1 和 arraylength2 必须为正整数,arraylength1 为行数,arraylength2 为列数。例如:
    int a[][] = new int[2][3]; //二维数组 a 可以看成一个两行三列的数组。
  2. 从最高维开始,分别为每一维分配空间,例如:
    String s[][] = new String[2][];
    s[0] = new String[2];
    s[1] = new String[3];
    s[0][0] = new String(“Good”);
    s[0][1] = new String(“Luck”);
    s[1][0] = new String(“to”);
    s[1][1] = new String(“you”);
    s[1][2] = new String(“!”);
    解析:
    s[0]=new String[2] 和 s[1]=new String[3] 是为最高维分配引用空间,也就是为最高维限制其能保存数据的最长的长度,然后再为其每个数组元素单独分配空间 s0=new String(“Good”) 等操作。

Arrays 类
java.util.Arrays 类能方便地操作数组,它提供的所有方法都是静态的。
具有以下功能:
给数组赋值:通过 fill 方法。
对数组排序:通过 sort 方法,按升序。
比较数组:通过 equals 方法比较数组中元素值是否相等。
查找数组元素:通过 binarySearch 方法能对排序好的数组进行二分查找法操作。
1 public static int binarySearch(Object[] a, Object key)
用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中,则返回搜索键的索引;否则返回 (-(插入点) – 1)。
2 public static boolean equals(long[] a, long[] a2)
如果两个指定的 long 型数组彼此相等,则返回 true。如果两个数组包含相同数量的元素,并且两个数组中的所有相应元素对都是相等的,则认为这两个数组是相等的。换句话说,如果两个数组以相同顺序包含相同的元素,则两个数组是相等的。同样的方法适用于所有的其他基本数据类型(Byte,short,Int等)。
3 public static void fill(int[] a, int val)
将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型(Byte,short,Int等)。
4 public static void sort(Object[] a)
对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型(Byte,short,Int等)。

Java 方法
Java方法是语句的集合,它们在一起执行一个功能。
方法是解决一类问题的步骤的有序组合
方法包含于类或对象中
方法在程序中被创建,在其他地方被引用
方法的命名规则
1.方法的名字的第一个单词应以小写字母作为开头,后面的单词则用大写字母开头写,不使用连接符。例如:addPerson。
2.下划线可能出现在 JUnit 测试方法名称中用以分隔名称的逻辑组件。一个典型的模式是:test_,例如 testPop_emptyStack。

方法的定义
一般情况下,定义一个方法包含以下语法:
修饰符 返回值类型 方法名(参数类型 参数名){

方法体

return 返回值;
}
方法包含一个方法头和一个方法体。下面是一个方法的所有部分:
修饰符:修饰符,这是可选的,告诉编译器如何调用该方法。定义了该方法的访问类型。
返回值类型 :方法可能会返回值。returnValueType 是方法返回值的数据类型。有些方法执行所需的操作,但没有返回值。在这种情况下,returnValueType 是关键字void。
方法名:是方法的实际名称。方法名和参数表共同构成方法签名。
参数类型:参数像是一个占位符。当方法被调用时,传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的,方法可以不包含任何参数。
方法体:方法体包含具体的语句,定义该方法的功能。

/** 返回两个整型变量数据的较大值 */
public static int max(int num1, int num2) {
   int result;
   if (num1 > num2)
      result = num1;
   else
      result = num2;
   return result;
}

方法调用
Java 支持两种调用方法的方式,根据方法是否返回值来选择。
当程序调用一个方法时,程序的控制权交给了被调用的方法。当被调用方法的返回语句执行或者到达方法体闭括号时候交还控制权给程序。
当方法返回一个值的时候,方法调用通常被当做一个值。例如:
int larger = max(30, 40);
如果方法返回值是void,方法调用一定是一条语句。例如,方法println返回void。下面的调用是个语句:
System.out.println(“欢迎访问菜鸟教程!”);

通过值传递参数
调用一个方法时候需要提供参数,你必须按照参数列表指定的顺序提供。

方法的重载
上面使用的max方法仅仅适用于int型数据。但如果你想得到两个浮点类型数据的最大值呢?
解决方法是创建另一个有相同名字但参数不同的方法,如下面代码所示:

public static double max(double num1, double num2) {
  if (num1 > num2)
    return num1;
  else
    return num2;
}

Java编译器根据方法签名判断哪个方法应该被调用。
方法重载可以让程序更清晰易读。执行密切相关任务的方法应该使用相同的名字。
重载的方法必须拥有不同的参数列表。你不能仅仅依据修饰符或者返回类型的不同来重载方法。

命令行参数的使用
有时候你希望运行一个程序时候再传递给它消息。这要靠传递命令行参数给main()函数实现。
命令行参数是在执行程序时候紧跟在程序名字后面的信息。
CommandLine.java 文件代码:

public class CommandLine {
   public static void main(String args[]){
      for(int i=0; i<args.length; i++){
         System.out.println("args[" + i + "]: " + args[i]);
      }
   }
}

可变参数
Java支持传递同类型的可变参数给一个方法。
方法的可变参数的声明如下所示:
typeName… parameterName
在方法声明中,在指定参数类型后加一个省略号(…) 。
一个方法中只能指定一个可变参数,它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

finalize() 方法
Java 允许定义这样的方法,它在对象被垃圾收集器析构(回收)之前调用,这个方法叫做 finalize( ),它用来清除回收对象。
例如,你可以使用 finalize() 来确保一个对象打开的文件被关闭了。
在 finalize() 方法里,你必须指定在对象销毁时候要执行的操作。
finalize() 一般格式是:
protected void finalize()
{
// 在这里终结代码
}
关键字 protected 是一个限定符,它确保 finalize() 方法不会被该类以外的代码调用。
当然,Java 的内存回收可以由 JVM 来自动完成。如果你手动使用,则可以使用上面的方法。

public class FinalizationDemo {
  public static void main(String[] args) {
    Cake c1 = new Cake(1);
    Cake c2 = new Cake(2);
    Cake c3 = new Cake(3);
    c2 = c3 = null;
    System.gc(); //调用Java垃圾收集器
  }
}
class Cake extends Object {
  private int id;
  public Cake(int id) {
    this.id = id;
    System.out.println("Cake Object " + id + " is created");
  }
  protected void finalize() throws java.lang.Throwable {
    super.finalize();
    System.out.println("Cake Object " + id + " is disposed");
  }
}

Java 异常处理
异常是程序中的一些错误,但并不是所有的错误都是异常,并且错误有时候是可以避免的。
三种类型的异常:
检查性异常:最具代表的检查性异常是用户错误或问题引起的异常,这是程序员无法预见的。例如要打开一个不存在文件时,一个异常就发生了,这些异常在编译时不能被简单地忽略。
运行时异常: 运行时异常是可能被程序员避免的异常。与检查性异常相反,运行时异常可以在编译时被忽略。
错误: 错误不是异常,而是脱离程序员控制的问题。错误在代码中通常被忽略。例如,当栈溢出时,一个错误就发生了,它们在编译也检查不到的。

Exception 类的层次
所有的异常类是从 java.lang.Exception 类继承的子类。
Exception 类是 Throwable 类的子类。除了Exception类外,Throwable还有一个子类Error 。
异常类有两个主要的子类:IOException 类和 RuntimeException 类。
Java 内置异常类
Java 语言定义了一些异常类在 java.lang 标准包中。
标准运行时异常类的子类是最常见的异常类。由于 java.lang 包是默认加载到所有的 Java 程序的,所以大部分从运行时异常类继承而来的异常都可以直接使用。
Java 根据各个类库也定义了一些其他的异常,下面的表中列出了 Java 的非检查性异常。
ArithmeticException 当出现异常的运算条件时,抛出此异常。例如,一个整数”除以零”时,抛出此类的一个实例。
ArrayIndexOutOfBoundsException 用非法索引访问数组时抛出的异常。如果索引为负或大于等于数组大小,则该索引为非法索引。
ArrayStoreException 试图将错误类型的对象存储到一个对象数组时抛出的异常。
ClassCastException 当试图将对象强制转换为不是实例的子类时,抛出该异常。
IllegalArgumentException 抛出的异常表明向方法传递了一个不合法或不正确的参数。
IllegalMonitorStateException 抛出的异常表明某一线程已经试图等待对象的监视器,或者试图通知其他正在等待对象的监视器而本身没有指定监视器的线程。
IllegalStateException 在非法或不适当的时间调用方法时产生的信号。换句话说,即 Java 环境或 Java 应用程序没有处于请求操作所要求的适当状态下。
IllegalThreadStateException 线程没有处于请求操作所要求的适当状态时抛出的异常。
IndexOutOfBoundsException 指示某排序索引(例如对数组、字符串或向量的排序)超出范围时抛出。
NegativeArraySizeException 如果应用程序试图创建大小为负的数组,则抛出该异常。
NullPointerException 当应用程序试图在需要对象的地方使用 null 时,抛出该异常
NumberFormatException 当应用程序试图将字符串转换成一种数值类型,但该字符串不能转换为适当格式时,抛出该异常。
SecurityException 由安全管理器抛出的异常,指示存在安全侵犯。
StringIndexOutOfBoundsException 此异常由 String 方法抛出,指示索引或者为负,或者超出字符串的大小。
UnsupportedOperationException 当不支持请求的操作时,抛出该异常。
下面的表中列出了 Java 定义在 java.lang 包中的检查性异常类。
ClassNotFoundException 应用程序试图加载类时,找不到相应的类,抛出该异常。
CloneNotSupportedException 当调用 Object 类中的 clone 方法克隆对象,但该对象的类无法实现 Cloneable 接口时,抛出该异常。
IllegalAccessException 拒绝访问一个类的时候,抛出该异常。
InstantiationException 当试图使用 Class 类中的 newInstance 方法创建一个类的实例,而指定的类对象因为是一个接口或是一个抽象类而无法实例化时,抛出该异常。
InterruptedException 一个线程被另一个线程中断,抛出该异常。
NoSuchFieldException 请求的变量不存在
NoSuchMethodException 请求的方法不存在

异常方法
下面的列表是 Throwable 类的主要方法:
1 public String getMessage()
返回关于发生的异常的详细信息。这个消息在Throwable 类的构造函数中初始化了。
2 public Throwable getCause()
返回一个Throwable 对象代表异常原因。
3 public String toString()
使用getMessage()的结果返回类的串级名字。
4 public void printStackTrace()
打印toString()结果和栈层次到System.err,即错误输出流。
5 public StackTraceElement [] getStackTrace()
返回一个包含堆栈层次的数组。下标为0的元素代表栈顶,最后一个元素代表方法调用堆栈的栈底。
6 public Throwable fillInStackTrace()
用当前的调用栈层次填充Throwable 对象栈层次,添加到栈层次任何先前信息中。

捕获异常
使用 try 和 catch 关键字可以捕获异常。try/catch 代码块放在异常可能发生的地方。
try/catch代码块中的代码称为保护代码,使用 try/catch 的语法如下:
try
{
// 程序代码
}catch(ExceptionName e1)
{
//Catch 块
}
Catch 语句包含要捕获异常类型的声明。当保护代码块中发生一个异常时,try 后面的 catch 块就会被检查。
如果发生的异常包含在 catch 块中,异常会被传递到该 catch 块,这和传递一个参数到方法是一样。

多重捕获块
一个 try 代码块后面跟随多个 catch 代码块的情况就叫多重捕获。
多重捕获块的语法如下所示:
try{
// 程序代码
}catch(异常类型1 异常的变量名1){
// 程序代码
}catch(异常类型2 异常的变量名2){
// 程序代码
}catch(异常类型2 异常的变量名2){
// 程序代码
}
可以在 try 语句后面添加任意数量的 catch 块。
如果保护代码中发生异常,异常被抛给第一个 catch 块。
如果抛出异常的数据类型与 ExceptionType1 匹配,它在这里就会被捕获。
如果不匹配,它会被传递给第二个 catch 块。
如此,直到异常被捕获或者通过所有的 catch 块。

throws/throw 关键字:
如果一个方法没有捕获到一个检查性异常,那么该方法必须使用 throws 关键字来声明。throws 关键字放在方法签名的尾部。
也可以使用 throw 关键字抛出一个异常,无论它是新实例化的还是刚捕获到的。
下面方法的声明抛出一个 RemoteException 异常:

import java.io.*;
public class className
{
  public void deposit(double amount) throws RemoteException
  {
    // Method implementation
    throw new RemoteException();
  }
  //Remainder of class definition
}

一个方法可以声明抛出多个异常,多个异常之间用逗号隔开。

finally关键字
finally 关键字用来创建在 try 代码块后面执行的代码块。
无论是否发生异常,finally 代码块中的代码总会被执行。
在 finally 代码块中,可以运行清理类型等收尾善后性质的语句。
finally 代码块出现在 catch 代码块最后,语法如下:
try{
// 程序代码
}catch(异常类型1 异常的变量名1){
// 程序代码
}catch(异常类型2 异常的变量名2){
// 程序代码
}finally{
// 程序代码
}

public class ExcepTest{
  public static void main(String args[]){
    int a[] = new int[2];
    try{
       System.out.println("Access element three :" + a[3]);
    }catch(ArrayIndexOutOfBoundsException e){
       System.out.println("Exception thrown  :" + e);
    }
    finally{
       a[0] = 6;
       System.out.println("First element value: " +a[0]);
       System.out.println("The finally statement is executed");
    }
  }
}

catch 不能独立于 try 存在。
在 try/catch 后面添加 finally 块并非强制性要求的。
try 代码后不能既没 catch 块也没 finally 块。
try, catch, finally 块之间不能添加任何代码。

声明自定义异常
在 Java 中你可以自定义异常。编写自己的异常类时需要记住下面的几点。
所有异常都必须是 Throwable 的子类。
如果希望写一个检查性异常类,则需要继承 Exception 类。
如果你想写一个运行时异常类,那么需要继承 RuntimeException 类。
只继承Exception 类来创建的异常类是检查性异常类。

通用异常
在Java中定义了两种类型的异常和错误。
JVM(Java虚拟机) 异常:由 JVM 抛出的异常或错误。例如:NullPointerException 类,ArrayIndexOutOfBoundsException 类,ClassCastException 类。
程序级异常:由程序或者API程序抛出的异常。例如 IllegalArgumentException 类,IllegalStateException 类。

Java 继承
继承是java面向对象编程技术的一块基石,因为它允许创建分等级层次的类。
继承就是子类继承父类的特征和行为,使得子类对象(实例)具有父类的实例域和方法,或子类从父类继承方法,使得子类具有父类相同的行为。
类的继承格式
在 Java 中通过 extends 关键字可以申明一个类是从另外一个类继承而来的,一般形式如下:
类的继承格式
class 父类 {
}
class 子类 extends 父类 {
}
Java 不支持多继承,但支持多重继承。

继承的特性
子类拥有父类非 private 的属性、方法。
子类可以拥有自己的属性和方法,即子类可以对父类进行扩展。
子类可以用自己的方式实现父类的方法。
Java 的继承是单继承,但是可以多重继承,单继承就是一个子类只能继承一个父类,多重继承就是,例如 A 类继承 B 类,B 类继承 C 类,所以按照关系就是 C 类是 B 类的父类,B 类是 A 类的父类,这是 Java 继承区别于 C++ 继承的一个特性。
提高了类之间的耦合性(继承的缺点,耦合度高就会造成代码之间的联系越紧密,代码独立性越差)。

继承关键字
继承可以使用 extends 和 implements 这两个关键字来实现继承,而且所有的类都是继承于 java.lang.Object,当一个类没有继承的两个关键字,则默认继承object(这个类在 java.lang 包中,所以不需要 import)祖先类。
extends关键字
在 Java 中,类的继承是单一继承,也就是说,一个子类只能拥有一个父类,所以 extends 只能继承一个类。
implements关键字
使用 implements 关键字可以变相的使java具有多继承的特性,使用范围为类继承接口的情况,可以同时继承多个接口(接口跟接口之间采用逗号分隔)。

public interface A {
    public void eat();
    public void sleep();
}
public interface B {
    public void show();
}
public class C implements A,B {
}

super 与 this 关键字
super关键字:我们可以通过super关键字来实现对父类成员的访问,用来引用当前对象的父类。
this关键字:指向自己的引用。

final关键字
final 关键字声明类可以把类定义为不能继承的,即最终类;或者用于修饰方法,该方法不能被子类重写:
声明类:
final class 类名 {//类体}
声明方法:
修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}

构造器
子类是不继承父类的构造器(构造方法或者构造函数)的,它只是调用(隐式或显式)。如果父类的构造器带有参数,则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表。
如果父类构造器没有参数,则在子类的构造器中不需要使用 super 关键字调用父类构造器,系统会自动调用父类的无参构造器。

Java 重写(Override)与重载(Overload)
重写(Override)
重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变,核心重写!
重写的好处在于子类可以根据需要,定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。
重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如: 父类的一个方法申明了一个检查异常 IOException,但是在重写这个方法的时候不能抛出 Exception 异常,因为 Exception 是 IOException 的父类,只能抛出 IOException 的子类异常。
在面向对象原则里,重写意味着可以重写任何现有方法。

方法的重写规则
参数列表必须完全与被重写方法的相同。
返回类型与被重写方法的返回类型可以不相同,但是必须是父类返回值的派生类(java5 及更早版本返回类型要一样,java7 及更高版本可以不同)。
访问权限不能比父类中被重写的方法的访问权限更低。例如:如果父类的一个方法被声明为 public,那么在子类中重写该方法就不能声明为 protected。
父类的成员方法只能被它的子类重写。
声明为 final 的方法不能被重写。
声明为 static 的方法不能被重写,但是能够被再次声明。
子类和父类在同一个包中,那么子类可以重写父类所有方法,除了声明为 private 和 final 的方法。
子类和父类不在同一个包中,那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法。
重写的方法能够抛出任何非强制异常,无论被重写的方法是否抛出异常。但是,重写的方法不能抛出新的强制性异常,或者比被重写方法声明的更广泛的强制性异常,反之则可以。
构造方法不能被重写。
如果不能继承一个方法,则不能重写这个方法。

重载(Overload)
重载(overloading) 是在一个类里面,方法名字相同,而参数不同。返回类型可以相同也可以不同。
每个重载的方法(或者构造函数)都必须有一个独一无二的参数类型列表。
最常用的地方就是构造器的重载。
重载规则:
被重载的方法必须改变参数列表(参数个数或类型不一样);
被重载的方法可以改变返回类型;
被重载的方法可以改变访问修饰符;
被重载的方法可以声明新的或更广的检查异常;
方法能够在同一个类中或者在一个子类中被重载。
无法以返回值类型作为重载函数的区分标准。

重写与重载之间的区别
区别点 重载方法 重写方法
参数列表 必须修改 一定不能修改
返回类型 可以修改 一定不能修改
异常 可以修改 可以减少或删除,一定不能抛出新的或者更广的异常
访问 可以修改 一定不能做更严格的限制(可以降低限制)
方法的重写(Overriding)和重载(Overloading)是java多态性的不同表现,重写是父类与子类之间多态性的一种表现,重载可以理解成多态的具体表现形式。
(1)方法重载是一个类中定义了多个方法名相同,而他们的参数的数量不同或数量相同而类型和次序不同,则称为方法的重载(Overloading)。
(2)方法重写是在子类存在方法与父类的方法的名字相同,而且参数的个数与类型一样,返回值也一样的方法,就称为重写(Overriding)。
(3)方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。

Java 多态
多态是同一个行为具有多个不同表现形式或形态的能力。
多态就是同一个接口,使用不同的实例而执行不同操作。
多态存在的三个必要条件: 继承,重写,父类引用指向子类对象
比如:
Parent p = new Child();
当使用多态方式调用方法时,首先检查父类中是否有该方法,如果没有,则编译错误;如果有,再去调用子类的同名方法。
多态的好处:可以使程序有良好的扩展,并可以对所有类的对象进行通用处理。

public class Test {
    public static void main(String[] args) {
        show(new Cat());  // 以 Cat 对象调用 show 方法
        show(new Dog());  // 以 Dog 对象调用 show 方法
        Animal a = new Cat();  // 向上转型
        a.eat();               // 调用的是 Cat 的 eat
        Cat c = (Cat)a;        // 向下转型
        c.work();        // 调用的是 Cat 的 work
    }
    public static void show(Animal a)  {
        a.eat();
        // 类型判断
        if (a instanceof Cat)  {  // 猫做的事情
            Cat c = (Cat)a;
            c.work();
        } else if (a instanceof Dog) { // 狗做的事情
            Dog c = (Dog)a;
            c.work();
        }
    }
}
abstract class Animal {
    abstract void eat();
}
class Cat extends Animal {
    public void eat() {
        System.out.println("吃鱼");
    }
    public void work() {
        System.out.println("抓老鼠");
    }
}
class Dog extends Animal {
    public void eat() {
        System.out.println("吃骨头");
    }
    public void work() {
        System.out.println("看家");
    }
}

虚函数
虚函数的存在是为了多态。
Java 中其实没有虚函数的概念,它的普通函数就相当于 C++ 的虚函数,动态绑定是Java的默认行为。如果 Java 中不希望某个函数具有虚函数特性,可以加上 final 关键字变成非虚函数。

Java 抽象类
在面向对象的概念中,所有的对象都是通过类来描绘的,但是反过来,并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类。
抽象类除了不能实例化对象之外,类的其它功能依然存在,成员变量、成员方法和构造方法的访问方式和普通类一样。
由于抽象类不能实例化对象,所以抽象类必须被继承,才能被使用。也是因为这个原因,通常在设计阶段决定要不要设计抽象类。
父类包含了子类集合的常见的方法,但是由于父类本身是抽象的,所以不能使用这些方法。
在Java中抽象类表示的是一种继承关系,一个类只能继承一个抽象类,而一个类却可以实现多个接口。

抽象方法
如果你想设计这样一个类,该类包含一个特别的成员方法,该方法的具体实现由它的子类确定,那么你可以在父类中声明该方法为抽象方法。
Abstract 关键字同样可以用来声明抽象方法,抽象方法只包含一个方法名,而没有方法体。
抽象方法没有定义,方法名后面直接跟一个分号,而不是花括号。
声明抽象方法会造成以下两个结果:
如果一个类包含抽象方法,那么该类必须是抽象类。
任何子类必须重写父类的抽象方法,或者声明自身为抽象类。

Java 封装
在面向对象程式设计方法中,封装(英语:Encapsulation)是指一种将抽象性函式接口的实现细节部份包装、隐藏起来的方法。
封装可以被认为是一个保护屏障,防止该类的代码和数据被外部类定义的代码随机访问。
要访问该类的代码和数据,必须通过严格的接口控制。
封装最主要的功能在于我们能修改自己的实现代码,而不用修改那些调用我们代码的程序片段。
适当的封装可以让程式码更容易理解与维护,也加强了程式码的安全性。
封装的优点

  1. 良好的封装能够减少耦合。
  2. 类内部的结构可以自由修改。
  3. 可以对成员变量进行更精确的控制。
  4. 隐藏信息,实现细节。

实现Java封装的步骤

  1. 修改属性的可见性来限制对属性的访问(一般限制为private),例如:
    public class Person {
    private String name;
    private int age;
    }
    这段代码中,将 name 和 age 属性设置为私有的,只能本类才能访问,其他类都访问不了,如此就对信息进行了隐藏。
  2. 对每个值属性提供对外的公共方法访问,也就是创建一对赋取值方法,用于对私有属性的访问,例如:
    public class Person{
    private String name;
    private int age;
    public int getAge(){
    return age;
    }
    public String getName(){
    return name;
    }
    public void setAge(int age){
    this.age = age;
    }
    public void setName(String name){
    this.name = name;
    }
    }
    采用 this 关键字是为了解决实例变量(private String name)和局部变量(setName(String name)中的name变量)之间发生的同名的冲突。

Java 接口
接口(英文:Interface),在JAVA编程语言中是一个抽象类型,是抽象方法的集合,接口通常以interface来声明。一个类通过继承接口的方式,从而来继承接口的抽象方法。
接口并不是类,编写接口的方式和类很相似,但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。
除非实现接口的类是抽象类,否则该类要定义接口中的所有方法。
接口无法被实例化,但是可以被实现。一个实现接口的类,必须实现接口内所描述的所有方法,否则就必须声明为抽象类。另外,在 Java 中,接口类型可用来声明一个变量,他们可以成为一个空指针,或是被绑定在一个以此接口实现的对象。

接口与类相似点:
一个接口可以有多个方法。
接口文件保存在 .java 结尾的文件中,文件名使用接口名。
接口的字节码文件保存在 .class 结尾的文件中。
接口相应的字节码文件必须在与包名称相匹配的目录结构中。
接口与类的区别:
接口不能用于实例化对象。
接口没有构造方法。
接口中所有的方法必须是抽象方法。
接口不能包含成员变量,除了 static 和 final 变量。
接口不是被类继承了,而是要被类实现。
接口支持多继承。
抽象类和接口的区别

  1. 抽象类中的方法可以有方法体,就是能实现方法的具体功能,但是接口中的方法不行。
  2. 抽象类中的成员变量可以是各种类型的,而接口中的成员变量只能是 public static final 类型的。
  3. 一个类只能继承一个抽象类,而一个类却可以实现多个接口。

接口特性
接口中的方法都是公有的。
接口是隐式抽象的,当声明一个接口的时候,不必使用abstract关键字。
接口中每一个方法也是隐式抽象的,声明时同样不需要abstract关键字。接口中的方法会被隐式的指定为 public abstract(只能是 public abstract,其他修饰符都会报错)。
接口中可以含有变量,但是接口中的变量会被隐式的指定为 public static final 变量(并且只能是 public,用 private 修饰会报编译错误)。
接口中的方法是不能在接口中实现的,只能由实现接口的类来实现接口中的方法。

接口的声明
接口的声明语法格式如下:
[可见度] interface 接口名称 [extends 其他的接口名] {
// 声明变量
// 抽象方法
}
Interface关键字用来声明一个接口。下面是接口声明的一个简单例子。

接口的实现
当类实现接口的时候,类要实现接口中所有的方法。否则,类必须声明为抽象的类。
类使用implements关键字实现接口。在类声明中,Implements关键字放在class声明后面。
实现一个接口的语法,可以使用这个公式:
…implements 接口名称[, 其他接口名称, 其他接口名称…, …] …
重写接口中声明的方法时,需要注意以下规则:
类在实现接口的方法时,不能抛出强制性异常,只能在接口中,或者继承接口的抽象类中抛出该强制性异常。
类在重写方法时要保持一致的方法名,并且应该保持相同或者相兼容的返回值类型。
如果实现接口的类是抽象类,那么就没必要实现该接口的方法。
在实现接口的时候,也要注意一些规则:
一个类可以同时实现多个接口。
一个类只能继承一个类,但是能实现多个接口。
一个接口能继承另一个接口,这和类之间的继承比较相似。

接口的继承
一个接口能继承另一个接口,和类之间的继承方式比较相似。接口的继承使用extends关键字,子接口继承父接口的方法。
接口的多继承
在Java中,类的多继承是不合法,但接口允许多继承。
在接口的多继承中extends关键字只需要使用一次,在其后跟着继承接口。 如下所示:
public interface Hockey extends Sports, Event
以上的程序片段是合法定义的子接口,与类不同的是,接口允许多继承,而 Sports及 Event 可能定义或是继承相同的方法

标记接口
最常用的继承接口是没有包含任何方法的接口。
标记接口是没有任何方法和属性的接口.它仅仅表明它的类属于一个特定的类型,供其他代码来测试允许做一些事情。
标记接口作用:简单形象的说就是给某个对象打个标(盖个戳),使对象拥有某个或某些特权。
标记接口主要用于以下两种目的:
建立一个公共的父接口:
正如EventListener接口,这是由几十个其他接口扩展的Java API,你可以使用一个标记接口来建立一组接口的父接口。例如:当一个接口继承了EventListener接口,Java虚拟机(JVM)就知道该接口将要被用于一个事件的代理方案。
向一个类添加数据类型:
这种情况是标记接口最初的目的,实现标记接口的类不需要定义任何接口方法(因为标记接口根本就没有方法),但是该类通过多态性变成一个接口类型。

Java 包(package)
为了更好地组织类,Java 提供了包机制,用于区别类名的命名空间。
包的作用
1、把功能相似或相关的类或接口组织在同一个包中,方便类的查找和使用。
2、如同文件夹一样,包也采用了树形目录的存储方式。同一个包中的类名字是不同的,不同的包中的类的名字是可以相同的,当同时调用两个不同包中相同类名的类时,应该加上包名加以区别。因此,包可以避免名字冲突。
3、包也限定了访问权限,拥有包访问权限的类才能访问某个包中的类。
Java 使用包(package)这种机制是为了防止命名冲突,访问控制,提供搜索和定位类(class)、接口、枚举(enumerations)和注释(annotation)等。
包语句的语法格式为:
package pkg1[.pkg2[.pkg3…]];
例如,一个Something.java 文件它的内容
package net.java.util;
public class Something{

}
那么它的路径应该是 net/java/util/Something.java 这样保存的。 package(包) 的作用是把不同的 java 程序分类保存,更方便的被其他 java 程序调用。
一个包(package)可以定义为一组相互联系的类型(类、接口、枚举和注释),为这些类型提供访问保护和命名空间管理的功能。
以下是一些 Java 中的包:
java.lang-打包基础的类
java.io-包含输入输出功能的函数
由于包创建了新的命名空间(namespace),所以不会跟其他包中的任何名字产生命名冲突。使用包这种机制,更容易实现访问控制,并且让定位相关类更加简单。

创建包
创建包的时候,你需要为这个包取一个合适的名字。之后,如果其他的一个源文件包含了这个包提供的类、接口、枚举或者注释类型的时候,都必须将这个包的声明放在这个源文件的开头。
包声明应该在源文件的第一行,每个源文件只能有一个包声明,这个文件中的每个类型都应用于它。
如果一个源文件中没有使用包声明,那么其中的类,函数,枚举,注释等将被放在一个无名的包(unnamed package)中。

import 关键字
为了能够使用某一个包的成员,我们需要在 Java 程序中明确导入该包。使用 “import” 语句可完成此功能。
在 java 源文件中 import 语句应位于 package 语句之后,所有类的定义之前,可以没有,也可以有多条,其语法格式为:
import package1[.package2…].(classname|*);
如果在一个包中,一个类想要使用本包中的另一个类,那么该包名可以省略。
类文件中可以包含任意数量的 import 声明。import 声明必须在包声明之后,类声明之前。

package 的目录结构
类放在包中会有两种主要的结果:
包名成为类名的一部分,正如我们前面讨论的一样。
包名必须与相应的字节码所在的目录结构相吻合。
通常,一个公司使用它互联网域名的颠倒形式来作为它的包名.例如:互联网域名是 runoob.com,所有的包名都以 com.runoob 开头。包名中的每一个部分对应一个子目录。
例如:有一个 com.runoob.test 的包,这个包包含一个叫做 Runoob.java 的源文件,那么相应的,应该有如下面的一连串子目录:
….\com\runoob\test\Runoob.java
编译的时候,编译器为包中定义的每个类、接口等类型各创建一个不同的输出文件,输出文件的名字就是这个类型的名字,并加上 .class 作为扩展后缀。

Java 泛型
Java 泛型(generics)提供了编译时类型安全检测机制,该机制允许程序员在编译时检测到非法的类型。泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。
泛型方法
你可以写一个泛型方法,该方法在调用时可以接收不同类型的参数。根据传递给泛型方法的参数类型,编译器适当地处理每一个方法调用。
下面是定义泛型方法的规则:
所有泛型方法声明都有一个类型参数声明部分(由尖括号分隔),该类型参数声明部分在方法返回类型之前(在下面例子中的)。
每一个类型参数声明部分包含一个或多个类型参数,参数间用逗号隔开。一个泛型参数,也被称为一个类型变量,是用于指定一个泛型类型名称的标识符。
类型参数能被用来声明返回值类型,并且能作为泛型方法得到的实际参数类型的占位符。
泛型方法体的声明和其他方法一样。注意类型参数只能代表引用型类型,不能是原始类型(像int,double,char的等)。

public class GenericMethodTest {
  // 泛型方法 printArray
  public static <E> void printArray(E[] inputArray) {
    // 输出数组元素
    for (E element : inputArray) {
      System.out.printf("%s ", element);
    }
    System.out.println();
  }
  public static void main(String args[]) {
    // 创建不同类型数组: Integer, Double 和 Character
    Integer[] intArray = {1, 2, 3, 4, 5};
    Double[] doubleArray = {1.1, 2.2, 3.3, 4.4};
    Character[] charArray = {'H', 'E', 'L', 'L', 'O'};

    System.out.println("整型数组元素为:");
    printArray(intArray); // 传递一个整型数组

    System.out.println("\n双精度型数组元素为:");
    printArray(doubleArray); // 传递一个双精度型数组

    System.out.println("\n字符型数组元素为:");
    printArray(charArray); // 传递一个字符型数组
  }
}

有界的类型参数:
可能有时候,你会想限制那些被允许传递到一个类型参数的类型种类范围。例如,一个操作数字的方法可能只希望接受Number或者Number子类的实例。这就是有界类型参数的目的。
要声明一个有界的类型参数,首先列出类型参数的名称,后跟extends关键字,最后紧跟它的上界。
下面的例子演示了”extends”如何使用在一般意义上的意思”extends”(类)或者”implements”(接口)。该例子中的泛型方法返回三个可比较对象的最大值。

public class MaximumTest {
  // 比较三个值并返回最大值
  public static <T extends Comparable<T>> T maximum(T x, T y, T z) {
    T max = x; // 假设x是初始最大值
    if (y.compareTo(max) > 0) {
      max = y; // y 更大
    }
    if (z.compareTo(max) > 0) {
      max = z; // 现在 z 更大
    }
    return max; // 返回最大对象
  }

  public static void main(String args[]) {
    System.out.printf("%d, %d 和 %d 中最大的数为 %d\n\n", 3, 4, 5, maximum(3, 4, 5));

    System.out.printf("%.1f, %.1f 和 %.1f 中最大的数为 %.1f\n\n", 6.6, 8.8, 7.7, maximum(6.6, 8.8, 7.7));

    System.out.printf(
        "%s, %s 和 %s 中最大的数为 %s\n", "pear", "apple", "orange", maximum("pear", "apple", "orange"));
  }
}

泛型类
泛型类的声明和非泛型类的声明类似,除了在类名后面添加了类型参数声明部分。
和泛型方法一样,泛型类的类型参数声明部分也包含一个或多个类型参数,参数间用逗号隔开。一个泛型参数,也被称为一个类型变量,是用于指定一个泛型类型名称的标识符。因为他们接受一个或多个参数,这些类被称为参数化的类或参数化的类型。
如下实例演示了我们如何定义一个泛型类:

public class Box<T> {
  private T t;
  public void add(T t) {
    this.t = t;
  }
  public T get() {
    return t;
  }
  public static void main(String[] args) {
    Box<Integer> integerBox = new Box<Integer>();
    Box<String> stringBox = new Box<String>();
    integerBox.add(new Integer(10));
    stringBox.add(new String("菜鸟教程"));
    System.out.printf("整型值为 :%d\n\n", integerBox.get());
    System.out.printf("字符串为 :%s\n", stringBox.get());
  }
}

类型通配符
1、类型通配符一般是使用?代替具体的类型参数。例如 List 在逻辑上是List,List 等所有List<具体类型实参>的父类。

import java.util.*;
public class GenericTest {
    public static void main(String[] args) {
        List<String> name = new ArrayList<String>();
        List<Integer> age = new ArrayList<Integer>();
        List<Number> number = new ArrayList<Number>();
        name.add("icon");
        age.add(18);
        number.add(314);
        getData(name);
        getData(age);
        getData(number);
   }
   public static void getData(List<?> data) {
      System.out.println("data :" + data.get(0));
   }
}

因为getData()方法的参数是List类型的,所以name,age,number都可以作为这个方法的实参,这就是通配符的作用。
2、类型通配符上限通过形如List来定义,如此定义就是通配符泛型值接受Number及其下层子类类型。

import java.util.*;
public class GenericTest {
    public static void main(String[] args) {
        List<String> name = new ArrayList<String>();
        List<Integer> age = new ArrayList<Integer>();
        List<Number> number = new ArrayList<Number>();
        name.add("icon");
        age.add(18);
        number.add(314);
        //getUperNumber(name);//1
        getUperNumber(age);//2
        getUperNumber(number);//3
   }
   public static void getData(List<?> data) {
      System.out.println("data :" + data.get(0));
   }
   public static void getUperNumber(List<? extends Number> data) {
          System.out.println("data :" + data.get(0));
   }
}

3、类型通配符下限通过形如 List来定义,表示类型只能接受Number及其三层父类类型,如 Object 类型的实例。

Java 序列化
Java 提供了一种对象序列化的机制,该机制中,一个对象可以被表示为一个字节序列,该字节序列包括该对象的数据、有关对象的类型的信息和存储在对象中数据的类型。
将序列化对象写入文件之后,可以从文件中读取出来,并且对它进行反序列化,也就是说,对象的类型信息、对象的数据,还有对象中的数据类型可以用来在内存中新建对象。
整个过程都是 Java 虚拟机(JVM)独立的,也就是说,在一个平台上序列化的对象可以在另一个完全不同的平台上反序列化该对象。
类 ObjectInputStream 和 ObjectOutputStream 是高层次的数据流,它们包含反序列化和序列化对象的方法。
一个类的对象要想序列化成功,必须满足两个条件:
该类必须实现 java.io.Serializable 接口。
该类的所有属性必须是可序列化的。如果有一个属性不是可序列化的,则该属性必须注明是短暂的。
如果你想知道一个 Java 标准类是否是可序列化的,请查看该类的文档。检验一个类的实例是否能序列化十分简单, 只需要查看该类有没有实现 java.io.Serializable接口。

public class Employee implements java.io.Serializable
{
   public String name;
   public String address;
   public transient int SSN;
   public int number;
   public void mailCheck()
   {
      System.out.println("Mailing a check to " + name
                           + " " + address);
   }
}

序列化对象
ObjectOutputStream 类用来序列化一个对象,如下的 SerializeDemo 例子实例化了一个 Employee 对象,并将该对象序列化到一个文件中。
该程序执行后,就创建了一个名为 employee.ser 文件。该程序没有任何输出,但是你可以通过代码研读来理解程序的作用。
注意: 当序列化一个对象到文件时, 按照 Java 的标准约定是给文件一个 .ser 扩展名。
SerializeDemo.java 文件代码:

import java.io.*;
public class SerializeDemo
{
   public static void main(String [] args)
   {
      Employee e = new Employee();
      e.name = "Reyan Ali";
      e.address = "Phokka Kuan, Ambehta Peer";
      e.SSN = 11122333;
      e.number = 101;
      try
      {
         FileOutputStream fileOut =
         new FileOutputStream("/tmp/employee.ser");
         ObjectOutputStream out = new ObjectOutputStream(fileOut);
         out.writeObject(e);
         out.close();
         fileOut.close();
         System.out.printf("Serialized data is saved in /tmp/employee.ser");
      }catch(IOException i)
      {
          i.printStackTrace();
      }
   }
}

反序列化对象
下面的 DeserializeDemo 程序实例了反序列化,/tmp/employee.ser 存储了 Employee 对象。
DeserializeDemo.java 文件代码:
“`
import java.io.*;
public class DeserializeDemo
{
public static void main(String [] args)
{
Employee e = null;
try
{
FileInputStream fileIn = new FileInputStream(“/tmp/employee.ser”);
ObjectInputStream in = new ObjectInputStream(fileIn);
e = (Employee) in.readObject();
in.close();
fileIn.close();
}catch(IOException i)
{
i.printStackTrace();
return;
}catch(ClassNotFoundException c)
{
System.out.println(“Employee class not found”);
c.printStackTrace();
return;
}
System.out.println(“Deserialized Employee…”);
System.out.println(“Name: ” + e.name);
System.out.println(“Address: ” + e.address);
System.out.println(“SSN: ” + e.SSN);
System.out.println(“Number: ” + e.number);
}
}
readObject() 方法中的 try/catch代码块尝试捕获 ClassNotFoundException 异常。对于 JVM 可以反序列化对象,它必须是能够找到字节码的类。如果JVM在反序列化对象的过程中找不到该类,则抛出一个 ClassNotFoundException 异常。
注意,readObject() 方法的返回值被转化成 Employee 引用。
当对象被序列化时,属性 SSN 的值为 111222333,但是因为该属性是短暂的,该值没有被发送到输出流。所以反序列化后 Employee 对象的 SSN 属性为 0。

分类
其他

2019-10-02-双色球数字概率分析

双色球的规则是红色球从数字1到33中选出6个,蓝色球从1到16中选出1个。

假定福彩中心没有作弊,概率完全随机,蓝色球随机没有办法分析,所以每个数字出现概率为1/16。

这里我们来分析一下红色球。红色球的结果可能有C(33,6) = 1107568种(C33)

我们把红色球出现的号码从小到大排列,分别叫做红1到红6.

红1最少值是1,最大值是28.

红1为1的可能性是先选一个1出来,其余的32个球中选出5个来的所有可能性。
C(32,5)/C(33,6) = 201376/1107568 = 18.18%

红1为2的可能性是先排除号码1,然后选一个2出来,其余的31个球中选出5个来的所有可能性。
C(31,5)/C(33,6) = 169911/1107568 = 15.34%

依次类推,
红1为3的概率是
C(30,5)/C(33,6) = 142506/1107568 = 12.86%

继续分析规律。

红2最少值是2,最大值是29.

红2为2的可能性是先选一个1号球当红1,然后选一个2号球当红2,其余31个球中选4个出来的所有可能性。
C(31,4)/C(33,6) = 31465/1107568 = 2.84%

红2为3的可能性是先选一个1号球或者2号球当红1,然后选一个3号球当红2,其余30个球中选4个出来的所有可能性。
C(2,1)C(30,4)/C(33,6) = 227405/1107568 = 4.95%

所以通用的概率公式就是第n个球等于i的可能性除以总的可能性。

C(i-1,n-1)*C(33-i,6-n)/C(33,6)

写成java代码就是:

// LotteryChance.java
// javac LotteryChance.java
// java LotteryChance
public class LotteryChance {

    public static double factorial(int n) {
        double[] f = new double[n+1];
        f[0] = f[1] = 1;
        for (int i = 2; i <= n; i++)
            f[i] = f[i-1] * i;
        return f[n];
    }

    public static double combination(int n, int r){
        if(n == 0 || r == 0 || n == r) return 1;
        return Math.round(factorial(n)/(factorial(r)*factorial(n-r)));
    }

    public static void main(String[] args) {
        double all = 1107568; // combination(33,6);
        double[][] chance = new double[6][28];
        for(int n = 1; n < 7; n++){
            System.out.println("the "+ n +"th number:");
            for(int i = n; i < 34-(6-n); i++) {
                chance[n-1][i-n] = combination((i-1), (n-1))*combination((33-i), (6-n))/all;
                System.out.println("the chance = "+i+" is : "+100*chance[n-1][i-n]+"%.");
            }
        }
    }
}

输出结果是:

the 1th number:
the chance = 1 is : 18.181818181818183%.
the chance = 2 is : 15.340909090909092%.
the chance = 3 is : 12.866568914956012%.
the chance = 4 is : 10.722140762463344%.
the chance = 5 is : 8.87349580341794%.
the chance = 6 is : 7.288942981379021%.
the chance = 7 is : 5.939138725568092%.
the chance = 8 is : 4.796996662958843%.
the chance = 9 is : 3.8375973303670743%.
the chance = 10 is : 3.0380978865406005%.
the chance = 11 is : 2.3776418242491655%.
the chance = 12 is : 1.8372686823743551%.
the chance = 13 is : 1.3998237579995088%.
the chance = 14 is : 1.0498678184996315%.
the chance = 15 is : 0.7735868136313075%.
the chance = 16 is : 0.558701587622611%.
the chance = 17 is : 0.3943775912630195%.
the chance = 18 is : 0.2711345939933259%.
the chance = 19 is : 0.1807563959955506%.
the chance = 20 is : 0.11620054028285397%.
the chance = 21 is : 0.0715080247894486%.
the chance = 22 is : 0.041713014460511684%.
the chance = 23 is : 0.02275255334209728%.
the chance = 24 is : 0.01137627667104864%.
the chance = 25 is : 0.005056122964910506%.
the chance = 26 is : 0.00189604611184144%.
the chance = 27 is : 5.417274605261257E-4%.
the chance = 28 is : 9.028791008768762E-5%.
the 2th number:
the chance = 2 is : 2.840909090909091%.
the chance = 3 is : 4.948680351906158%.
the chance = 4 is : 6.433284457478006%.
the chance = 5 is : 7.394579836181616%.
the chance = 6 is : 7.9227641101945885%.
the chance = 7 is : 8.098825534865579%.
the chance = 8 is : 7.994994438264738%.
the chance = 9 is : 7.675194660734149%.
the chance = 10 is : 7.195494994438264%.
the chance = 11 is : 6.604560622914349%.
the chance = 12 is : 5.944104560622914%.
the chance = 13 is : 5.2493390924981576%.
the chance = 14 is : 4.549427213498404%.
the chance = 15 is : 3.8679340681565373%.
the chance = 16 is : 3.2232783901304476%.
the chance = 17 is : 2.6291839417534635%.
the chance = 18 is : 2.0951309535847913%.
the chance = 19 is : 1.6268075639599553%.
the chance = 20 is : 1.2265612585412362%.
the chance = 21 is : 0.8938503098681074%.
the chance = 22 is : 0.6256952169076753%.
the chance = 23 is : 0.41713014460511677%.
the chance = 24 is : 0.2616543634341187%.
the chance = 25 is : 0.1516836889473152%.
the chance = 26 is : 0.07900192132672666%.
the chance = 27 is : 0.03521228493419817%.
the chance = 28 is : 0.012188867861837828%.
the chance = 29 is : 0.002528061482455253%.
the 3th number:
the chance = 3 is : 0.36656891495601174%.
the chance = 4 is : 0.9897360703812317%.
the chance = 5 is : 1.7746991606835878%.
the chance = 6 is : 2.640921370064863%.
the chance = 7 is : 3.5212284934198173%.
the chance = 8 is : 4.360906057235312%.
the chance = 9 is : 5.116796440489433%.
the chance = 10 is : 5.756395995550612%.
the chance = 11 is : 6.256952169076752%.
the chance = 12 is : 6.604560622914349%.
the chance = 13 is : 6.793262354997616%.
the chance = 14 is : 6.824140820247606%.
the chance = 15 is : 6.704419051471332%.
the chance = 16 is : 6.446556780260895%.
the chance = 17 is : 6.0673475578926075%.
the chance = 18 is : 5.5870158762261095%.
the chance = 19 is : 5.028314288603499%.
the chance = 20 is : 4.415620530748451%.
the chance = 21 is : 3.774034641665342%.
the chance = 22 is : 3.128476084538376%.
the chance = 23 is : 2.502780867630701%.
the chance = 24 is : 1.9187986651835371%.
the chance = 25 is : 1.3954899383152999%.
the chance = 26 is : 0.9480230559207201%.
the chance = 27 is : 0.5868714155699695%.
the chance = 28 is : 0.31691056440778353%.
the chance = 29 is : 0.13651532005258368%.
the chance = 30 is : 0.036656891495601175%.
the 4th number:
the chance = 4 is : 0.036656891495601175%.
the chance = 5 is : 0.13651532005258368%.
the chance = 6 is : 0.31691056440778353%.
the chance = 7 is : 0.5868714155699695%.
the chance = 8 is : 0.9480230559207201%.
the chance = 9 is : 1.3954899383152999%.
the chance = 10 is : 1.9187986651835371%.
the chance = 11 is : 2.502780867630701%.
the chance = 12 is : 3.128476084538376%.
the chance = 13 is : 3.774034641665342%.
the chance = 14 is : 4.415620530748451%.
the chance = 15 is : 5.028314288603499%.
the chance = 16 is : 5.5870158762261095%.
the chance = 17 is : 6.0673475578926075%.
the chance = 18 is : 6.446556780260895%.
the chance = 19 is : 6.704419051471332%.
the chance = 20 is : 6.824140820247606%.
the chance = 21 is : 6.793262354997616%.
the chance = 22 is : 6.604560622914349%.
the chance = 23 is : 6.256952169076752%.
the chance = 24 is : 5.756395995550612%.
the chance = 25 is : 5.116796440489433%.
the chance = 26 is : 4.360906057235312%.
the chance = 27 is : 3.5212284934198173%.
the chance = 28 is : 2.640921370064863%.
the chance = 29 is : 1.7746991606835878%.
the chance = 30 is : 0.9897360703812317%.
the chance = 31 is : 0.36656891495601174%.
the 5th number:
the chance = 5 is : 0.002528061482455253%.
the chance = 6 is : 0.012188867861837828%.
the chance = 7 is : 0.03521228493419817%.
the chance = 8 is : 0.07900192132672666%.
the chance = 9 is : 0.1516836889473152%.
the chance = 10 is : 0.2616543634341187%.
the chance = 11 is : 0.41713014460511677%.
the chance = 12 is : 0.6256952169076753%.
the chance = 13 is : 0.8938503098681074%.
the chance = 14 is : 1.2265612585412362%.
the chance = 15 is : 1.6268075639599553%.
the chance = 16 is : 2.0951309535847913%.
the chance = 17 is : 2.6291839417534635%.
the chance = 18 is : 3.2232783901304476%.
the chance = 19 is : 3.8679340681565373%.
the chance = 20 is : 4.549427213498404%.
the chance = 21 is : 5.2493390924981576%.
the chance = 22 is : 5.944104560622914%.
the chance = 23 is : 6.604560622914349%.
the chance = 24 is : 7.195494994438264%.
the chance = 25 is : 7.675194660734149%.
the chance = 26 is : 7.994994438264738%.
the chance = 27 is : 8.098825534865579%.
the chance = 28 is : 7.9227641101945885%.
the chance = 29 is : 7.394579836181616%.
the chance = 30 is : 6.433284457478006%.
the chance = 31 is : 4.948680351906158%.
the chance = 32 is : 2.840909090909091%.
the 6th number:
the chance = 6 is : 9.028791008768762E-5%.
the chance = 7 is : 5.417274605261257E-4%.
the chance = 8 is : 0.00189604611184144%.
the chance = 9 is : 0.005056122964910506%.
the chance = 10 is : 0.01137627667104864%.
the chance = 11 is : 0.02275255334209728%.
the chance = 12 is : 0.041713014460511684%.
the chance = 13 is : 0.0715080247894486%.
the chance = 14 is : 0.11620054028285397%.
the chance = 15 is : 0.1807563959955506%.
the chance = 16 is : 0.2711345939933259%.
the chance = 17 is : 0.3943775912630195%.
the chance = 18 is : 0.558701587622611%.
the chance = 19 is : 0.7735868136313075%.
the chance = 20 is : 1.0498678184996315%.
the chance = 21 is : 1.3998237579995088%.
the chance = 22 is : 1.8372686823743551%.
the chance = 23 is : 2.3776418242491655%.
the chance = 24 is : 3.0380978865406005%.
the chance = 25 is : 3.8375973303670743%.
the chance = 26 is : 4.796996662958843%.
the chance = 27 is : 5.939138725568092%.
the chance = 28 is : 7.288942981379021%.
the chance = 29 is : 8.87349580341794%.
the chance = 30 is : 10.722140762463344%.
the chance = 31 is : 12.866568914956012%.
the chance = 32 is : 15.340909090909092%.
the chance = 33 is : 18.181818181818183%.

从结果可以看出,
红1最有可能出现的数字是1-4, 最大可能性是1.
红2最有可能出现的数字是6-9, 最大可能性是7.
红3最有可能出现的数字是12-15, 最大可能性是14.
红4最有可能出现的数字是19-22, 最大可能性是20.
红5最有可能出现的数字是25-28, 最大可能性是27.
红6最有可能出现的数字是30-33, 最大可能性是33.

为了验证我的结果对不对,我写了一个程序来模拟双色球开奖,同时统计红1到红六出现的次数。
代码如下:

// Lottery.java
// javac Lottery.java
// java Lottery 100000000
import java.util.Arrays;
public class Lottery {
    public static int mostFrequent(int[] arr) {
        int max = 0;
        int f = 0;
        for(int i = 0; i< arr.length;i++) {
            if(arr[i] > max) {
                max = arr[i];
                f = i+1;
            }
        }
        return f;
    }
    public static void main(String[] args) {

        if(args.length < 1)
        {
            System.out.println("Proper Usage is: java Lottery 1000(or how many you want to try).");
            System.exit(0);
        }
        int n = Integer.parseInt(args[0]);    // choose this many elements
        int[] red = new int[33];
        int[] first = new int[34];
        int[] second = new int[34];
        int[] third = new int[34];
        int[] fourth = new int[34];
        int[] fifth = new int[34];
        int[] sixth = new int[34];
        for (int i = 0; i < 33; i++) {
            red[i] = i+1;
        }
        for(int c = 0; c < n; c++){
            for (int i = 0; i < 6; i++) {
                int r = i + (int)(Math.random()*(33-i));
                int t = red[r];
                red[r] = red[i];
                red[i] = t;
            }
            int[] result = new int[6];
            for (int i = 0; i<6; i++){
                result[i] = red[i];
            }
            Arrays.sort(result);
            first[result[0]-1]++;
            second[result[1]-1]++;
            third[result[2]-1]++;
            fourth[result[3]-1]++;
            fifth[result[4]-1]++;
            sixth[result[5]-1]++;
            if(args.length > 1){
                for (int i = 0; i < 6; i++){
                    System.out.print(result[i] + " ");
                }
                System.out.println();
                System.out.printf("red : %s\n", Arrays.toString(red));
            }
        }
        System.out.printf("first : %s\n", Arrays.toString(first));
        System.out.println(mostFrequent(first));
        System.out.printf("second : %s\n", Arrays.toString(second));
        System.out.println(mostFrequent(second));
        System.out.printf("third : %s\n", Arrays.toString(third));
        System.out.println(mostFrequent(third));
        System.out.printf("fourth : %s\n", Arrays.toString(fourth));
        System.out.println(mostFrequent(fourth));
        System.out.printf("fifth : %s\n", Arrays.toString(fifth));
        System.out.println(mostFrequent(fifth));
        System.out.printf("sixth : %s\n", Arrays.toString(sixth));
        System.out.println(mostFrequent(sixth));
    }
}

我执行java Lottery 100000000就是开奖一亿次, 结果如下:
first : [18181415, 15341925, 12865221, 10724122, 8871170, 7285535, 5942311, 4799328, 3837023, 3036659, 2376066, 1835980, 1400676,
1050389, 773613, 559635, 395151, 271204, 180914, 116457, 71486, 41806, 23020, 11295, 5043, 1939, 532, 85, 0, 0, 0, 0, 0, 0]
1
second : [0, 2840458, 4946818, 6432150, 7396106, 7919007, 8098429, 7991389, 7676025, 7199131, 6605295, 5949171, 5248256, 4550103,
3869756, 3221894, 2628698, 2095361, 1625266, 1227908, 893273, 626626, 417263, 262032, 151108, 78369, 35414, 12189, 2505, 0, 0, 0,
0, 0]
7
third : [0, 0, 365942, 988819, 1774042, 2639593, 3518744, 4361205, 5117636, 5755000, 6255513, 6602839, 6793753, 6830798, 6704630,
6444648, 6068836, 5590065, 5026655, 4413666, 3775953, 3128141, 2504301, 1918079, 1395028, 948685, 587462, 317071, 136088, 36808, 0
, 0, 0, 0]
14
fourth : [0, 0, 0, 36697, 136690, 316144, 586649, 947804, 1394881, 1916290, 2501275, 3128912, 3773469, 4415433, 5028612, 5588366,
6066877, 6445842, 6701330, 6826578, 6790441, 6606725, 6259293, 5757620, 5117888, 4361739, 3521883, 2643699, 1773521, 988768, 36657
4, 0, 0, 0]
20
fifth : [0, 0, 0, 0, 2529, 12318, 35027, 78985, 151410, 262359, 415583, 624312, 894846, 1226446, 1626489, 2094632, 2629957, 322277
7, 3867689, 4549473, 5247548, 5943771, 6600351, 7195273, 7673459, 7997888, 8101801, 7921915, 7397245, 6433408, 4949122, 2843387, 0
, 0]
27
sixth : [0, 0, 0, 0, 0, 87, 553, 1906, 4962, 11356, 22608, 41828, 71612, 115976, 181000, 271124, 394621, 559229, 773541, 1050827,
1401171, 1835353, 2378715, 3035969, 3838368, 4797255, 5937331, 7288578, 8877601, 10721731, 12864228, 15335628, 18186842, 0]
33

可以看到跟我上面的理论分析出来的结果一致。
上面结果里面first后面中括号里就是开奖一亿里面,
红1分别等于1到33的次数,当然红1最小等于1,最大等于28,不可能等于33.
可以看到出现的次数基本上等于我们上面理论分析的概率乘以一亿。
比如红1等于1的概率是18.181818181818183%,乘以一亿,理论出现次数是18181818,
这里的出现开奖结果次数是18181415,基本吻合。

同时出现次数也跟理论预言的一样,
红1出现次数最多的就是1。
红2出现次数最多的就是7。
红3出现次数最多的就是14。
红4出现次数最多的就是20。
红5出现次数最多的就是27。
红6出现次数最多的就是33。

至次,我们得到了双色球各个数字出现的概率。

进一步分析,所以红色球中奖概率最大的号码是什么呢?显然就是1,7,14,20,27,33。这个号码的中奖概率有多大呢?把上面的六个概率相乘,可以得出

18.181818181818183%*8.098825534865579%*6.824140820247606%*6.824140820247606%*8.098825534865579%*18.181818181818183%=1.0097518751278756E-6

所以这个号码的数学期望值是多少呢?
1.0097518751278756E-6*5000000/16=0.31554746097,

也就是0.31元,三毛钱,所以就算彩票没有作弊,你用两块钱买到的预期收益也只有三毛一。这就是彩票是一种智商税这种说法的由来。

分类
其他

2017-06-05-腾讯传读后感

断断续续的看完了从公司图书馆借到的《腾讯传》,下面是几点感受:
1.腾讯的成功有偶然性,马化腾几次想把腾讯卖掉,可是没人接手,他就继续干下去了。最后几次在风险投资的资本支撑下,腾讯才到了今天的高度。
2.腾讯的成功有必然性,作为一个技术出身的产品经理,马化腾给腾讯植入了两种基因,第一是技术上的不断迭代,第二是从用户体验方面出发不断的微创新。
3.中国的互联网与美国的互联网真的有很大区别。以前我认为中国互联网的成功主要是得益于天朝的防火墙,美国的互联网受到限制,所以中国的互联网才能发展起来。看了腾讯传之后,我觉得并不完全是这样的,百度的成功也许是受益于谷歌的自动退出,腾讯的崛起并没有遭遇美国对应的对手,阿里的崛起跟亚马逊或者ebay其实也没有太多的竞争关系。也许最开始的时候,中国是借鉴或者抄袭了美国的一些模式,后来的发展就完全不同了,因为中国的用户是不同的。
4.内部良性竞争的机制也许是腾讯成功的一个关键因素。
分类
其他

2016-10-22-蜀山剑侠传读后感

不知道这个蜀山剑侠传跟仙剑奇侠传有什么关系没有。以前也依稀听过还珠楼主这个人,但是我总以为是一个三流的小说家。这次微信小说,给我推荐了这一套蜀山剑侠传,出于好奇,我就打开看了一下。感觉作者文字很古朴,不像我印象中的现代作家,然后我就去查了一下,这位老先生居然是民国时期的作家,是金庸古龙他们的前辈。引用百度百科(http://baike.baidu.com/view/16555.htm)的说法:
还珠武侠诸著,对郑证因、朱贞木、梁羽生、金庸、古龙等武侠名家均有启迪之功。
还珠楼主代表了民国武侠荒诞怪异的一派,他信奉吕祖的伍柳天仙法脉,融合神话、志怪、剑仙、武侠于一体,进行高度哲理化、艺术化的想象发挥,尤其是各种剑仙神术、奇幻法宝,显示了天纵奇才的大气魄,为中国小说界的千古奇观。对后世武侠作家影响巨大,几乎无人可以企及,如台湾武侠泰斗古龙,就曾说到他受还珠楼主的影响颇深。
再说蜀山剑侠传小说本身,虽然最后没有完本,但是不得不说这是金庸和古龙之外我读的最棒的武侠小说。一般网站上的仙侠小说我很少有能读下去,因为情节种种不合理,人物对话苍白,或者就是网游的脚本。蜀山剑侠传不一样,它的情节非常吸引人步步扣人心弦,我前后读一百多个小时,从来没有感觉读不下去。而且书里面的想象力非常丰富,种种武器场景都是一流的。引用知乎(https://www.zhihu.com/question/20895742)的说法:
《蜀山剑侠传》之于20世纪武侠小说,就如《新华字典》之于中国现代文学。因为尽管本书索然无味,里面的武功、器物、人名都被大量借鉴,故事桥段和场景描述也被大量借鉴,貌似没有哪个武侠小说家没抄过这本书的。
举例:
金庸:神雕&灵猿–抄李英琼的雕和猿;降龙十八掌–抄降龙八掌,乾坤大挪移,屠龙刀,双剑合璧的概念,冰蚕,化尸粉&欧阳锋的蛇毒–抄化骨丹,黑玉断续膏–抄生肌灵玉膏,华山论剑–抄峨眉斗剑,郭靖咬蛇吸血的桥段–乌金鳝王,洪七公师徒以针刺蛇的桥段–凌云凤。
古龙:天一神水
梁羽生:冰魄寒光剑,白发魔女–白发龙女,凌云凤
温瑞安:迷天七圣,小寒山,四大名捕中某段对金蚕及其相关养殖阴谋的描述
卧龙生:不胜枚举
倪匡:不胜枚举
又如幻音铃的概念,绝地收秘籍法宝的桥段等等是大家都抄烂了的。
当然在我看来这部小说也不完美,第一个原因是没有写完, 根据这里(http://www.my285.com/wuxia/hzlz/ssj2/01.htm)的说法:
《蜀山剑侠传》从1930年底至1948年9月陆续问世50集,因“物价高昂,书局成本奇重,读者购买力弱”作者曾拟中辍,鉴于读者要求,才续写《后传》。但《后传》出至第5集,又因国家形势大变,再次中断,致使该书未成完壁。后来香港曾流行《后传》10集本,其后5集实为伪作,故本全集只收前5集。
第二个原因是里面人物刻画不算成功,每个人的性格都好像只有一面,一个性格。第三个原因就是价值观太过单一,正邪不两立,正义的一方总是胜利。
这里一个书评(https://www.zhihu.com/question/20895742)写得很好:
还珠楼主的《蜀山奇侠传》,堪称中国武侠(仙侠)的大百科全书式作品。
从故事角度,本书集中国神话传说之大成,让武侠小说从传统技击和清官侠义中走出来,开创性地完成了从现实江湖到纸上江湖的过渡,为满是糟心事的民国时代提供了一个成人的童话。
从文字角度,写景文字之精炼优美,对仗文字之工整谨严,人物角色之伏线千里,都不可多得,更遑论其融汇三教九流的大境界,在金庸之前,没有人能做得到。
从想象力上,层出不穷的法宝,千奇百怪的仙怪,都可以算是让人眼界大开,如上面哥们所引的九子母雷珠,在原子弹爆炸之前,谁能想到会有这样的奇景?如诸天星辰秘魔七绝乌梭,简直是外星人的飞碟~
从影响力上,则金古梁等几乎所有新派武侠作家都受其影响,这在今天看来简直不可想象。当时蜀山之风靡全国,甚至引起了激烈的讨论,如瞿秋白即写过《吉诃德的时代》,希望唤醒怀揣“济贫自有飞剑在,尔且安心做奴才”梦想的平头百姓。
当然,蜀山离不开它的时代局限性。
局限一:作者采用全知观点,似乎一切都是注定了的,那些大人物们掐指一算,就将前因后果弄明白了,让故事的趣味性减少了很多;
局限二:作者对西方文学创作并不清晰,延续着中国文学传统刻画人物,缺少心理描写,故人物塑造上显得单薄简单了些;
局限三:全书有些类似《水浒》一环套一环的连环套模式,却下笔几万言甚至几十万言,导致篇幅过长而情节又显得拖沓,并不符合今天的阅读习惯,尤其是缺乏代入感;
局限四:全书以峨眉派为正统,所有与峨眉有争执的都是坏的,所有争执都以峨眉胜利告终,让读者读来读去会感到腻烦,甚至产生逆反心理——有很多网络小说写蜀山,都选了峨眉的对立面。
总而言之,推荐有兴趣的朋友一看。
分类
其他

2016-10-12-1984读后感

终于看完了这本非常非常非常著名的讽刺批判共产和极权主义的小说。我原以为这种强烈政治色彩的小说一定不好看,开始读这本小说才知道我错了。小说本身就写得很精彩,情节连贯,扣人心弦,让人忍不住一口气读完。至于对极权主义的批判,那就更不用说了,小说应该就是因为这个出名的。下面我说说自己对书中观点的看法:

1.书中描写的极权主义对生命,人权和自由的践踏令人不寒而栗,我们难免觉得有所夸张。但是仔细一想,如果我们不对极权主义保持警惕,它随时都可能卷土重来,尤其是在中国这种皇权主义历史悠久,近代又有极权主义统治经历的国家。其实中国现在是寡头政治,离极权主义只有一步之遥。即使是现在,兲朝对生命和人权的践踏都饱受国际社会的诟病,前段时间雷洋事件就是一个例子。德国导演Dennis Gansel的一部基于真实事件的电影<浪潮>就讲述了一个班级在短短的几天内就走上了纳粹主义的道路的故事。有兴趣的童鞋可以找来看看。熊培云先生的关于电影的影评“世界离独裁只有五天”(http://view.news.qq.com/a/20090203/000021.htm)里面提到了人们走向被奴役的极权主义道路的原因,人们总是在追求平等。在我看来,集体主义是迈向极权主义的第一步,加入一个集体,你会感觉到一种归属感,感觉自己因为是集体的一部分而变得强大,在这个过程,如果不警惕和反抗集体对个人自由的剥夺,集体就会绑架你犯下无意识的罪行,等到你意识到这一点的时候,你已经不敢退出集体了(因为担心孤立和集体对你自由的剥夺)。你就只能一步一步走向极权主义的深渊。个人感觉,唯一防止极权主义的办法就是在心中把自由放在平等之上的位置,绝不因为追求强大而放弃自由。可惜在中国,我们似乎没有这个传统,我们很少提倡自由,无论是思想自由还是行为自由。只能希望中国不要出来一个强人带领我们走上极权的道路。因为比起书中的描写,我们现在的科技发展大大的加强了那个强人集团监控所有人思想和行动的能力。

2.书中结尾描写了老大哥通过修改历史来修改事实,然后还提出现实只存在记忆里面,如果能够修改所有人的记忆和所有的相关记录,事实就被修改了。这一段其实有点哲学的味道了。虽然我们知道至少在现在我们没有办法修改所有人的记忆,但是不得不承认,如果我们能够修改所有关于一件事的记忆和相关的记录,我们就没有办法证明这件事情确实发生过。举个例子,假如一座山顶有一棵树,然后树枯死了,过一段时间,因为风化,那里已经没有树的痕迹,如果所有有那棵树记忆的人都不在了,我就无法确认那座山顶曾经有棵树这个事实了。其实这个问题归根到底就是问世界是真实的么?什么是真实的?你如果确定它是真实的,而不是像黑客帝国里面一个程序模拟出来的? 当然这个问题跟小说的主旨没有太大关系。

分类
其他

2016-07-28-这可能是迄今为止关于人工智能最难读也最全面的文章

看到好买财富上一篇文章,这是摘要及我的看法:

1.人工智能跟工业革命的机器问题类似,担忧是类似的,结果也必然类似,可以带来社会的发展。
2.最近的发展来自于计算能力的提高,gpu使得多层深度学习系统变得可能。深度学习有多种方式,其中一种是监督学习(supervised learning), 是从带标签的数据中学习, 比如垃圾邮件,非垃圾邮件。另外一种是无监督学习(unsupervised learning), 是将网络暴露在大量样本中来对网络进行训练,但不会告诉它要寻求什么模式. 网络识别相似样本的特征和聚类,从而揭示数据中的隐藏分组、连接和模式。识别相似样本的特征和聚类,从而揭示数据中的隐藏分组、连接和模式。还有一种是强化学习,训练一个网络并且以奖励作为反馈。
3.AlphaGo有两个深度神经网络,其中一个通过大量棋局分析可能的走法,另外一个根据随机采样来评估走法。类似的进展有迁移学习(transfer learning), 多任务学习(multitask learning), 动态记忆网络(dynamic memory network), 长期目标是通用人工智能(Artificial General Intelligence,AGI), 就是完成各种任务的系统。最乐观也要十年才能做出AGI.
4.人工智能会加速计算机相关的自动化趋势,要求工作者更快的学习新技能。
5.随着人工智能的发展,每个人都要终生学习以免被淘汰。
6.自动化可能会造成收入差距扩大,可能需要一个新的再分配系统。
7.人工智能可能不会出现人类会犯的计算和认知错误,但是可能会犯回形针最多化的错误,一旦他能自我复制和升级。
8.回形针最多化的前提是人工智能自己复制升级,但是至少在目前这不太可能,因为第一人工智能获得自己的思想不太现实,第二智能爆发需要时间,第三机器在环境不一定能学习。
9.总的来说,人工智能的威胁被夸大了。
下面是原文:

这可能是迄今为止关于人工智能最难读也最全面的文章

2016-07-13 好买财富

以AlphaGo战胜李世乭为节点,人工智能又一次闯入人们的视野中,甚至于有人将2016年视为“人工智能元年”(当然这可能是第N次某个特定的年份被冠以元年这样的称号)。

1927年的《大都会》或许塑造了影史上最早的人工智能机器人形象——人造玛利亚;1956年,人工智能被确立为一门学科。从最初,人们就始终在关注两个问题:计算机怎样接近智能?接近到什么程度?

技术阻碍发展,发展突破阻碍,如此无限循环……是人工智能发展史的最好写照。伴随着科学家无比热情的同时,是各种“人类式”的担心。AI来自何处,去向何方,“人类终将毁于自己创造的智能之手”这一命题是否成立?

“你执着于耳听为虚,眼见为实,大凡这种人都有大彻大悟的期待,聊可安慰的是,如此就已经离真理不远了”

1. 「机器问题」重现

从最初的屡屡失败,到现在的朝气蓬勃,人工智能会导致大面积失业甚至让人类灭绝吗?或许历史会给我们一些有用的线索。

有些人害怕机器会抢走所有人的工作,而只是有选择地让少数人受益,并最终彻底颠覆社会。然而在历史上,类似的一幕曾出现过。两个世纪前,工业化的浪潮席卷英国,与今天同样的担忧曾引发了激烈的争论。那个时候,人们不说「工业革命」而大谈「机器问题(machinery question)」。

1821年,经济学家 David Ricardo 第一个表达了这种看法,他重点关注「机器对于不同社会阶层的利益的影响」,特别是「劳动阶级怀有的意见,他们认为使用机器通常会不利于他们的利益」。1839年,Thomas Carlyle (苏格兰哲学家,被看作是那个时代最重要的社会评论员)对所谓「机械恶魔(demon of mechanism)」予以了抨击 ,他写道,「机械恶魔」破坏性的能力将会扰乱整个工人团体。

现在,这个「机器问题」卷土重来,虽然它伪装成了另外一副样子——人工智能(AI)技术正突飞猛进,机器得以执行曾经只有人才能胜任的各种任务。科学家,经济学家和哲学家正在热议人工智能技术的潜在影响。这种影响可能是非常深刻的。因为人工智能技术,之前看起来不可能自动化的工作——从放射科到法律工作——现在也同样面临着危机。

2013年, 牛津大学的 Carl Benedikt Frey 和 Michael Osborne 进行了一次调查研究,其结果后来被人们广泛引用,该研究发现美国有 47% 的工作有很高的可能性会在不久后被「计算机资本取代」。

更近的一个报告是:美国美林银行预测,2025 年以前,人工智能的「每年产生的创造性破坏的影响」可能会达到14到33万亿美元,其中包括因人工智能实现了知识工作自动化,导致雇佣成本减少的9万亿美元,制造业和医疗护理开销减少的8万亿美元,以及部署无人驾驶汽车和无人机后因效率提升增加的两万亿美元。智囊机构麦肯锡全球研究院(McKinsey Global Institute)说,人工智能正在促进社会发生转变,这种转变比工业革命「发生的速度快 10 倍,规模大 300 倍,影响几乎大3000倍」。

跟两个世纪前的人们一样,很多人担心机器会让几百万人下岗,引发不平等问题和社会动乱。Martin Ford 曾写过两本关于自动化威胁的畅销书,他担心中产阶级的工作将会消失,经济流动性将(即个人,家庭或团体提高经济水平的难易程度)停止,财阀们会「将自己关在封闭式小区或精英城市里,还可能有自动化军事机器人和无人机在旁保护。」

还有人则担心,人工智能会威胁人类的生存,因为超级智能计算机可能不会认同人类的目标,转而攻击创造它们的人类。很多人表达过这类担忧,比如物理学家史蒂芬·霍金。

更让人惊讶的是,伊隆·马斯克,火箭公司 SpaceX 和 电动汽车制造商 Tesla 的创始人,也有同样的想法。与 Carlyle 相似,马斯克警告人类:「我们正在用人工智能召唤恶魔。」他的特斯拉汽车可以利用最新的人工智能技术实现自动行驶,但马斯克却担心未来的人工智能霸主可能会太过强大,失去人类的控制。

他说:「马可·奥勒留(罗马帝国贤君)当国王挺好的,但如果国王是卡利古拉(罗马帝国早期的典型暴君)情况就不太乐观了。」

有人看到风险,有人洞见机遇。投资者正在不断涌入这个领域,科技巨头们则在不断收购人工智能创业公司,并争先吸引学术界最优秀的研究人才。

根据数据分析公司 Quid 的研究数据,在2015年,人工智能企业的成本创下85亿美元的记录,几乎为2010年的四倍。投资公司 Playfair Capital 的 Nathan Benaich 说,2015 年人工智能企业的投资轮数比上一年多16%,而与此同时科技产业整体投资轮数减少了3%。

Playfair Capital 是一家基金管理机构,该公司在人工智能的投资组合达到 25%。「XX+人工智能」取代了「XX行业的Uber 」,成为创业公司默认的商业模式。谷歌,Facebook,IBM,亚马逊和微软都想方设法在云端建立人工智能服务的生态系统。「这项技术将会用在各行各业中,只要这个行业有任意种类的数据,图像,语言等数据类型都可以。」MetaMind 的创始人 Richard Socher 说,「人工智能将遍地开花。」MetaMind 是一家人工智能创业公司,最近被云计算巨头 Salesforce 收购。

这意味什么?本篇特别报道将会审视这项新科技的崛起,探索它对工作,教育,政策的潜在影响,思考它在道德和监管方面的作用。同时,本文还思考了能从机器问题最初的答案中学到的东西。AI 引发的担忧和热情不相上下,同时带来了很多问题,然而值得记住的是,其中的很多问题我们在以前都曾问过,并已经有了答案。

2. 技术:从无法工作到神经网络

人工智能的繁荣基于传统与现代想法的结合。

人工智能如何从刚开始的傲慢与失望,突然成为科技界最热门的领域呢?人工智能(artificial intelligence)这个术语最早被写在 1956 年的一份研究计划中,该计划声称「如果一个精心挑选的科学家小组花一个夏天一起研究,就能使机器解决各种人类无法解决的问题……」,从而实现重大的进步。

那被证明只是疯狂过度地乐观,人工智能虽然偶有突破,但其承诺的远比其所能提供的多得多。最终,大多研究者都避免使用这个术语,而更喜欢用「专家系统」或「神经网络」。现在「人工智能」的名誉恢复和重新兴起要追溯到 2012 年被称为 ImageNet 挑战赛的在线竞赛。

ImageNet 是一个拥有数百万张图片的在线数据库,所有图片都有人工做的标签。对于任何给定词,例如「气球」或「草莓」,ImageNet 里都能找到上百张对应的图片。

每年的 ImageNet 竞赛鼓励该领域的人在计算机识别和自动标记图片上进行比赛,并衡量他们的进展。这些系统首先使用被正确标记的图片集进行训练,然后挑战标记之前没见过的测试图片。在后续的研讨会上,优胜者会分享并讨论他们的技术。

2010 年获胜的系统可以正确标记 72% 的图片(人类平均有 95% 的准确率)。2012 年,多伦多大学的 Geoff Hinton 带领的团队实现了 85% 的准确率,这要归功于一项叫「深度学习」的新技术。这带来了一种长远快速的改进,在2015 年的 ImageNet 竞赛上,一个深度学习系统以 96% 的准确率第一次超过了人类。

2012 年的成果被认为是一项突破,但 Yoshua Bengio 说,他们依靠的是「结合以前已经有了的东西。」Yoshua Bengio 是蒙特利尔大学的计算机科学家,他与 Hinto 以及另外几个人被称为深度学习的先驱。大体上,这项技术使用了大量的计算和训练数据,对来自人工智能发展初期的一个旧思路进行改进,这个旧思路也就是人工神经网络(ANN)——这是生物学启发的人工神经元(脑细胞)网络。

在生物大脑中,每个神经元都能被其它神经元触发,将输出的信号馈送给另一个神经元,而且此神经元的输出也能继续触发其它神经元。一个简单的 ANN 网络有一个输入神经元层,在这里数据被馈送进网络中;还有一个输出层输出结果,中间可能还会有三两个隐藏层对信息进行处理。(实际中,ANN 网络全部在软件中模拟。)网络中的每一个神经元都有一系列的「权重」和一个「激活函数」控制着输出的信号发射。

训练一个神经网络涉及到对神经元权重的调整,以便一个给定的输入产生期望的输出。ANN 在 20 世纪 90 年代早些时候就已经实现了一些有用的结果,例如识别手写数字。但在完成更为复杂的任务上,ANN 陷入了困境。

在过去的十几年中,新技术的出现和对激活函数的一种简单调整使得训练深度网络变得可行。同时,互联网的兴起产生了数十亿可用于目标训练的文档、图片、视频数据。这所有的一切都需要大量的数字操作能力,而 2009 年左右当几个人工智能研究团体意识到个人计算机和视频游戏机上用于生成精致画面的 GPU 也同样适用于运行深度学习算法之后,计算能力也不再是个问题了。

斯坦福大学由吴恩达带领的一个人工智能团队发现 GPU 能够几百倍地加速深度学习系统。然后,训练一个四层的神经网络突然就变得很快了,由之前需要花费几周的时间变成了不到一天时间。GPU 生产商 NVIDIA 的老总黄仁勋说这是一个令人高兴的对称:GPU 这一游戏工作者用于为游戏玩家构建幻想世界的芯片也能用于帮助计算机通过深度学习理解真实世界。

ImageNet 的结果显示了深度学习的能力。突然间,深度学习就获得了关注——不只是在人工智能界,而是在整个科技产业界内!深度学习系统因此变得更加的强大:20 或 30层的网络变得很常见,微软的研究人员曾建立过 152 层的网络。更深层的网络能进行更高水平的抽象并产生更好的结果,事实证明这些网络擅长解决众多领域的难题。

「让人们激动的是这一领域的一种学习方法:深度学习,能够应用于众多不同的领域,」谷歌机器智能研究部门负责人、如今负责搜索引擎的 John Giannandrea 表示,谷歌正在使用深度学习提升其网页搜索结果的质量、理解智能手机端的口语指令、帮助人们在他们的照片中搜索特定的图片、推荐电子邮件的自动回复、改善网页的翻译服务,并且帮助它们的自动驾驶汽车理解周围环境。

学习如何学习

深度学习有很多不同的方式。最普遍使用的是「监督学习(supervised learning)」,这项技术能使用标记样本集训练系统。例如,过滤垃圾邮件:收集出邮件信息样本的大数据集,每一个都标上「垃圾邮件」或者「非垃圾邮件」。一个深度学习系统能够使用这些数据集进行训练,重复的进行样本训练进而调整神经网络内的权重,提高评定垃圾邮件的准确率。

这一方法的巨大优点是不需要人类专家写出规则列表,也不需要程序员用代码编写这些规则,系统能直接从有标签的数据中进行学习。

使用有标签数据训练系统也被用于图片分类、语音识别、信用卡交易欺诈侦测、垃圾和恶意软件识别以及广告定位,所有这些应用领域中的正确答案都可通过之前的大量案例获得。Facebook 能在你上传一张照片后识别、标记照片里你的朋友和家人,它们近期还发布了一个能够为盲人描述照片中的内容(比如两个人、微笑、太阳眼镜、户外、水等)的系统。有大量的数据可用于监督学习,吴恩达先生说,这一科技的应用已经使现在的金融服务领域、计算安全领域和销售领域的公司将自己重新标记为了人工智能公司。

另一项技术是无监督学习(unsupervised learning),其通过将网络暴露在大量样本中来对网络进行训练,但不会告诉它要寻求什么模式。相反,该网络学习识别相似样本的特征和聚类,从而揭示数据中的隐藏分组、连接和模式。

无监督学习能在你不知道会是什么样的情况下被用于事物搜索:例如,监控网络中反常的通信模式,那可能代表着网络攻击;或检查大量的保险声明以检测新类型的诈骗方式。

一个经典的案例:2011 年当吴恩达在谷歌工作时,他领导的一个名为谷歌大脑(Google Brain)项目中的一个大型的无监督学习系统本是用于在千部无标记 YouTube 视频中发现共同模式。一天,吴恩达的一个博士生给了他一个惊喜。吴恩达回忆说「我记得他把我叫道他的电脑前说,『看这个』」,电脑屏幕上是一个毛茸茸的面孔,从数千的样本中发现的模式。系统发现了猫。

强化学习位于监督学习和无监督学习之间,它涉及到训练一个神经网络与只以奖励作为偶然的反馈的环境进行交互。本质上,训练涉及到调整网络的权重,从而获得能带来更高奖励的搜索策略。DeepMind 是这个领域的专家。2015 年 2 月,它们在 Nature 上发表的一篇论文描述了一个能够学习玩 49 种经典的 Atari 视频游戏的强化学习系统,它只使用屏幕上的像素和游戏分数作为输入,输出则连接到一个虚拟的控制器上。这个系统从头学起玩游戏,最终在其中 29 种游戏中达到或超过了人类水平。

把系统游戏化

电子游戏是人工智能研究的理想训练场,DeepMind 的 Demis Hassabis 说,因为「它们是真实世界的缩影,但更纯净和约束化。」 游戏引擎也可以轻松生成大量训练数据。Hassabis 先生以前从事过电子游戏行业的工作,后来取得了认知神经学的博士学位并创立了 DeepMind。这家公司现位于伦敦国王十字车站附近,相当于谷歌的人工智能研究分部。

今年三月,AlphaGo 于首尔的五轮比赛中打败了世界顶尖围棋选手李世石,作为开发公司的 DeepMind 因此登上头条。AlphaGo 是一个有着独特特性的强化学习系统。它由几个相互连通的模块组成,包括两个深度神经网络,它们各有所长——像人脑中模块一样。

其中一个通过大量的棋局分析训练提出一些可能的走法,另一个网络则负责根据随机采样技术来评估这些走法。这个系统把生物启发的技术与纯机器化的技术结合了起来。人工智能研究者们就哪种技术更优越这个问题已经争论了几十年,而 AlphaGo 却另辟蹊径两者都用。「这是一个复合型系统,因为我们认为解决智能问题只有深度学习是不够的」,Hassabis说。

他和其他研究者们已经开始探寻一种叫做迁移学习(transfer learning)的新技术了。这种技术能让强化学习系统把基础建立在已习得的知识上,而不用每一次都从头开始训练。Hassabis 先生解释道,人类可以毫不费力地做到这一点。Giannandrea 先生回忆起他四岁的女儿已经能辨别出 penny-farthing(一种前轮大后轮小的脚踏车)就是一种自行车,即使她之前从没见过这样的东西。「但计算机无法做到,」他说。

一家最近被 Salesforce 收购的初创公司 MetaMind 也在研发一种相关的技术——多任务学习(multitask learning),这种系统用同样的神经网络架构解决多种不同的问题,在一件事情上获得的经验能用来更好地解决其它事情。

跟 DeepMind 类似,它也在探寻模块化的架构;其中一个被称为「动态记忆网络(dynamic memory network)」的系统能消化一系列陈述,然后回答相关问题,并且推断出其中的逻辑联系(Kermit 是一只青蛙;青蛙是绿色的;所以 Kermit 是绿色的)。MetaMind 还把自然语言网络和图像识别网络融合到一个系统中,它可以回答有关图像的问题(「这里面的汽车是什么颜色的?」)。这种技术可以用到智能客服聊天机器人中,或者用于 Salesforce 的客户呼叫中心。

过去,很多有前景的人工智能技术发展都会逐渐疲软。但深度学习却不同。「这东西真的能起作用,」 MetaMind 的 Richard Socher 说。人们每天都会用到它,虽然他们并未意识到。Hassabis、Socher和其他人的长远目标是开发出「通用人工智能(AGI )」—一种能完成各种各样任务的系统,有了它就不必再为每个特定问题都专门开发出一个系统了。

人工智能多年来的研究方向都集中在解决专业化的特定问题上,Socher先生说,但现在研究人员们「正努力用更先进的乐高积木块拼出不一样的东西」。即使他们中最乐观的人也认为还需至少十年才能做出人类智力水平的 AGI 。但 Hassabis 说,「我们认为我们已经知道实现接近 AGI 的系统所需的几十种关键元素了」。

同时人工智能已经在发挥作用了,而且很快会更有用。例如谷歌的智能回复系统,它通过两个神经网络推荐邮件回复,从研究项目到产品上线只用了四个月(虽然刚开始它因为对每条信息建议回复的有「我爱你」而令人失望)。

「在科研期刊上发表文章刚一个月,就有某个公司正确使用你的系统了,」Socher 说。人工智能公司,不论规模大小都能都能定期发表学术文章;人工智能研究者即使在转行进入公司后也能继续在同行评议期刊上发表研究成果。很多人都是边为公司工作边发表科研文章。「如果你不允许他们发表,他们就不会为你工作了,」Andreessen Horowitz 的 Chris Dixon 解释说。

谷歌,Facebook,微软,IBM,亚马逊,百度以及其他公司都开源了某些深度学习软件。部分原因是这些公司中的研究人员想要发表自己的成果,因为这有利于公司招募更多人才。从更现实的角度来看,这也是因为大型互联网公司不在乎把自己的人工智能软件公之于众,因为他们真正的优势在于能获取大量用于训练的用户数据。

一家投资基金公司 Bloomberg Beta的Shivon Zilis说,这使得他们能在某些方面占尽优势,但初创公司也在寻求打入市场的独特途径。比如无人机初创公司能在人群密集的地方通过模拟数据进行飞行训练。而且很多训练数据都能从网上找到,孵化器公司 Y Combinator 的董事长 Sam Altman 说道。他注意到人类可以用有限的数据进行学习,「这意味着大量训练数据并不是实现智能的必要条件」。像 Numenta 和 Geometric Intelligence 这样的初创公司正在探索低数据依赖性的新智能系统。

在这股人工智能淘金热中,公司们排着队为参与者提供铁锹。出现最为频繁的名字是英伟达,Dixon 先生说;似乎每一家人工智能创业公司都在使用它的 GPU 芯片来训练神经网络。GPU 能力也可从亚马逊和微软的云中租用。

与此同时,IBM 和谷歌则正为更快更高效地运行人工智能软件而设计专门的新芯片。谷歌、微软和 IBM 也正使其语音识别、句子解析和图像分析等人工智能服务免费在线提供,让创业公司可以结合这些开发模块来构建新的人工智能产品和服务。IBM 的 Guru Banavar 说:来自多个行业的 300 多家公司已经使用 IBM 的 Watson 平台开发出了人工智能驱动的应用,其中包括筛选应聘者和挑选葡萄酒。

对大多数人而言,所有这些人工智能领域的进步都将体现为他们每天都在使用的互联网服务的不断进步。搜索引擎将得到更相关的结果;推荐将会更加准确。Hassabis 预测说:几年之内,所有东西都将会嵌入某种程度上的智能。人工智能技术将让计算机接口变成对话式和有预测力的,而不只是简单的菜单和按钮。而且对话式的交互让不能阅读书写和目前不能使用互联网的人也能使用计算机,Bengio 说。

厚积多年,一朝薄发;机器将能够执行之前只有人类才能完成的任务。自动驾驶汽车正快速变得越来越好,到某个点时它们也许能够取代出租车司机,至少在市中心等受控环境中可以做到。送货无人机,不管是地上跑的还是天上飞的,类似地可以与人类送货员竞争。改进后的视觉系统和机器人技术让机器人可以码放超市货架和在仓库中移动物体。而且还给意想不到的突破留下了很多余地,Dixon 说。

其他人却很担心,担忧人工智能技术会增压特定任务中现有的计算机化和自动化;就像 200 年前的蒸汽动力一样,让很多工人成了多余。英国诗人 Robert Southey 宣称 :「蒸汽可怕地加剧着已经正在进行的过程,但太快了。」他担心「这强大之力的发现」已经在「我们知道如何正确使用它」之前到来。许多人对今天的人工智能也这么想。

3. 对工作的影响:自动化与焦虑

更加智能的机器会导致大规模失业吗?

坐在位于旧金山的一间办公室里,Igor Barani 在屏幕上调出几张医学扫描结果。他是 Enlitic 公司的首席执行官,这是一家从对 X 光扫描与 CT 扫描图像分析开始将深度学习应用于医疗业的创业公司。这也是对这项技术的很明显的应用。深度学习因它在图像识别的某些形式上有着超人的实力而闻名;大量的标签化训练数据需要消化,而它有着巨大的潜力,去让医疗变得更加准确和有效。

Barani 博士(曾经是一位肿瘤学家)指着从三个角度拍摄的患者肺部 CT 扫影。随着 Enlitic 的深度学习系统的加入,屏幕上出现了红色闪烁点,比对它们来看是否是血管、无害的成像物体或恶性的肺部肿瘤。最终系统会给出一个重点标注的特征以进一步调查。在与三个放射科专家一起合作的测试中,Enlitic 系统在识别恶性肿瘤上优于人类50%,其假阴性率(没诊断出癌症)为零,相比之下人类则有着7%。Enlitic 的另一个系统,可以用来检查 X 射线扫描来检测腕关节骨折,并有效地超出了人类的表现。

在2013年广为关注的一篇研究中,Carl Benedikt Frey 和 Michael Osborne 核查了702种职业的计算能力,并发现美国47%的工人都面临着工作自动化的风险。尤其是,他们警告说大部分运输业和客运业(例如出租车司机和运货司机)和公关类(例如接待员与保安)「都有可能会被计算机所取代」,还有许多销售业与服务业人员(例如收银员,柜台人员,租赁人员,电话推销员和审计师等)也面临着工作被计算机取代的威胁。

他们总结道:「机器学习近期的发展会占据大量的职业分布,在近期面临风险的职业分布广阔。」后续的研究指出英国有35%的职业可能被取代(英语有许多人从事创业公司,也因此难以被取代),在日本这个比例是49%。

经济学家正在担心「职业两极化」的风险,也就是说中层技术的工作(例如制造业)正在消失,而低等和高等工作在扩张。实际上,工作可以被划分为两种常规职业:第一种即高薪水高技术的职业(建筑师,高级管理),还有低薪水低技术的职业(清洁工,快餐员)。

许多西方国家中层职业薪水的停滞都表现出自动化已经开始产生影响——尽管这与外包的影响很难区分出来,后者也取代了许多发展中国家的底薪国家中日常化的工作(例如制造业和呼叫中心)。圣路易斯联邦储备银行发表的数据显示,在美国,非常规认知型工作以及非常规手工型工作自1980年后逐步增长,而常规化工作则一直维持几乎不变。随着更多工作自动化,这种趋势很可能会延续下去。

在更近的例子中,自动取款机(ATM)可能已经有望通过接替一些日常任务来取代银行出纳员的工作,而 Bessen 指出,事实上美国每个银行支行的出纳员平均数量已经从 1988 年的 20 人降低到了 2004 年的 13 人。

这减少了运营一家支行的成本,让银行可以开设更多支行以响应客户的需求。城市银行支行的数量同期上升了 43%,所以总体上雇员的数量增加了。ATM 并没有摧毁工作,而是改变了银行雇员的工作组合——让他们远离了日常任务,进入到了机器不能做的销售和客服领域。

那么谁是正确的:是认为这一次不同于以往而机器将真正夺走所有工作的悲观者(他们中许多是技术者类型的),还是坚持认为技术终将创造更多工作乐观者(大部分是经济学家和历史学家)?

而事实可能介于两者之间。人工智能不会导致大规模失业,但它会加速与计算机相关的自动化的趋势,像技术改变之前做的那样扰乱劳动力市场,并要求工作者比以往更快地学习新技能。Bessen 预计会有一次「艰难转型」,而不是「尖锐地打破历史」。

尽管人们表达了广泛不同的意见,但几乎所有人都同意这个处方:公司和政府将需要想办法让工作者更容易掌握转换工作所需的新技能。这将在悲观者看法正确的事件中提供更好的防御,同时预防比乐观者所预计的人工智能的更快和更重大的影响。

4. 教育和政策:你会失业还是变得富有?

人工智能将会给教育、福利和地缘政治的政策制定者带来影响。

教育

2011 年 7 月,拥有多个头衔的斯坦福大学教授 Sebastian Thrun 在 YouTube 上发布了一段短视频,宣布他和他的同事 Peter Norvig 正在使他们的「人工智能入门(Introduction to Artificial Intelligence)」课程可以在网上免费观看。

到 10 月份该课程开始的时候,来自 190 个国家的 160,000 人报名参加了该课程。与此同时,另一位斯坦福教授吴恩达也将自己的一门关于机器学习的课程免费发布到了网上,有 100,000 人参加了这个课程。这两个课程都持续 10 周。最后,有 23,000 人完成 Thrun 的课程,13,000 人完成了吴恩达的课程。

这样的在线课程,以及短视频讲座、学生的在线讨论板块和自动为他们的课程成绩评级的系统,变成了众所周知的大规模开放式在线课程(MOOC)。2012 年,Thrun 创立了在线教育创业公司 Udacity,吴恩达也联合创立了另一家在线教育创业公司 Coursera。

就在同一年,哈佛大学和麻省理工学院(MIT)联合组建了 edX——一个非营利性的 MOOC 提供组织,该组织由 MIT 人工智能实验负责人 Anant Agarwal 所领导。一些人认为 MOOC 会取代传统的大学教育。最初围绕 MOOC 的炒作现在差不多也已经偃旗息鼓了(尽管已有数百万学生参加了某种形式的在线课程),但 MOOC 的繁荣说明了在线教育的巨大潜力。

Udacity、Coursera 和 edX 都是从人工智能实验室涌现出来的,这个事实凸显了人工智能研究社区希望对教育系统进行大改的信念。Thrun 说他创立 Udacity 是将其作为「正在进行的人工智能革命的解药」——这场革命将催生对工作者的新型工作技能的需求。

类似地,吴恩达认为:鉴于人工智能研究者的工作对劳动力市场的潜在影响,研究者「在应对和解决我们导致的问题上负有道德上的责任」;他说,Coursera 是他在这方面作出的贡献。此外,人工智能技术在教育方面有很大的发展潜力。根据每一个学生的情况各自调整课程,从而实现最轻松最高效的学习方法「适应性学习(Adaptive Learning)」多年前就应该出现了。但新的机器学习技术可能最终有望帮助实现这一目标。

吴恩达说,适应性学习对大量学生使用同一材料进行学习的情况最有效,因为这样可以收集到大量的数据。在这方面的创业公司有 Geekie、Knewton、Smart Sparrow 和 DreamBox 等,教育行业的巨头也对此很有兴趣:2013 年 McGraw-Hill 买下了适应性学习系统 ALEKS;Pearson 最近宣布扩大了与 Knewton 的合作关系。

「老系统将不得不得到认真的修改」,美国西北大学的 Joel Mokyr 指出,教育系统鼓励专业化,这样学生就能在越来越少的主题上学到越来越多。但随着知识过时的速度越来越快,重要的是要学会再学习(relearn)。

Mokyr 认为当下的教育像粘土——「塑造它,然后烘烤它,就定型了」。未来,随着越来越多任务变得自动化,人类技能显得最有价值的任务会不断变化。「你必须终生学习——很长时间来显然都是这样」,吴恩达说,「你在大学里学到的东西不足以让你继续前进 40 年。」

政策政治

对人工智能和自动化的担忧也导致了对更强大的保护人们免受劳动力市场动乱影响的安全网的呼吁。尤其是一些人工智能评论者认为应该建立一套福利系统,让每个人(不管什么情况)都享有保障基本生存的收入(比如说一年 1 万美元?)类似的想法在工业革命时也由 Thomas Paine 和 John Stuart Mill 等一些人提出过。

其基本思想是:人们做得更多让自己的收入增加时,这个福利不会减少,这样人们就会愿意去做事。这会让人们能自由决定自己希望做什么,活在失业中接受合适的再培训。很多预言会有终极工作破坏的人都认为可以把这个情况用来保持消费型经济和支持非劳动人口。如果大部分工作都被自动化取代了,我们就将需要一种重新分配财富的可选机制。

与改革教育系统相比,保障基本收入似乎更简单、更有吸引力。这个想法在技术行业内享有广泛支持:创业孵化器 Y Combinator 甚至还支持着加利福尼亚州奥克兰市的一项对该想法的研究。其总裁 Sam Altman 认为基本保障收入可以确保「向未来工作的平稳过渡」。

看起来似乎是一个未来乌托邦,但一些怀疑论的观点认为这会导致抑制技术造成的不平等和抱怨,从而让极客能发明无拘束的未来。Altman 先生说,根据他的经验,技术人会支持基本收入保障的想法。

但基本收入保障的前提是要有收入,这就将意味着更高的税收。此外因为人们本身的财富水平和各地的消费水平不一样,公平性方面也难以得到保证。而且还有人认为保障基本收入事实上会抑制人们接受再训练,催生一个不愿意劳动(而不是不能劳动)的「懒人」群体;从而加重纳税人的负担。

芬兰和荷兰等富裕国家计划在明年开始有限地试验基本收入政策,而其它较为贫穷的国家显然从没考虑过这样的事。自动化的发展对地缘政治的影响也将逐渐显现。

MIT 的 David Autor 说,自动化对发展中经济体的影响比对富裕经济体的影响更大,因为发展中经济体有更高比例的体力劳动工作:低工资的工人制造廉价的产品、在客服中心提供廉价的服务、在国内或海外做建筑工作……如果自动化使发达国家能在这些方面自给自足,它们对发展中国家提供的产品和服务的需求就越少——发展中国家将失去在这些方面的比较优势,而与此同时,机器人和人工智能的技术和专利也基本上都掌握在发达国家手里。

自动化可能会让发达国家通过全面工业化断掉贫穷国家的发展机会。经济学家常谈论「过早去工业化」;哈佛大学的 Dani Rodrik 指出第一次世界大战前英国的制造业就业人数达到了峰值的 45%,而巴西、印度和中国的制造业就业人数比例已经度过了峰值,却还没超过 15%。这是因为制造业已经远比过去自动化了。

据花旗银行和牛津大学马丁学院的一份报告指出,中国已经取代美国成为了第一大工业自动化市场。然而对于非洲和南美的其它一些新兴经济体而言,自动化却并不是好消息,它们再也无法通过「农田到工厂」的劳动力转移模式来推动经济增长了,它们必须寻找新的增长模式。乔治·梅森大学经济学家 Tyler Cowen 说:如果没有制造业的工作构成中产阶层,这些国家的「核心经济结构中将出现非常高的收入不平等。」

5.道德:弗兰肯斯坦的回形针

技术专家不相信人工智能会失去控制,但还是会有道德上的忧虑

随着《末日侵袭》这部电影情节的发展,它看起来也没有那么可怕。所谓的「回形针最多化」(paperclip maximiser)是牛津大学哲学家 Nick Bostrom 提出的一个思维实验。这个实验假设一个人工智能能够希望能收集尽可能多的回形针。它会想尽一切办法来收集回形针,并且会通过自我升级来找到收集回形针的新方法,它还会反抗一切阻止它做这件事情的企图。最后它“把整个地球和一部分宇宙空间都变成了一个回形针制造工厂”。

这种明显非常愚蠢的试图想表达一个非常严肃的观点:人工智能不需要人类一样的行为和心理动机。它们可能不会出现人类常会犯的错误和偏差,但是会犯别的错误,例如执着于回形针。它们的目标已开始可能看起来是无害的,但如果人工智能能够自我复制并升级自己的性能就会非常危险了。即使是一个运行在一台不联网的计算机上的「被束缚的超级人工智能」也会竭尽全力地劝说它的主人让他获得自由。先进的人工智能不仅仅是一门新技术,而是一个对人类的威胁,Bostrom 说。

机器能够自己独立运行并不是一个新鲜想法,英国作家玛丽·雪莱在 1818 年就在她的小说《弗兰肯斯坦》中提出过这个想法。但直到 1965 年,人们才提出这种能够不断自我升级的人工智能概念。但最近人们在人工智能方面取得的进展又引起了新的担忧,Bostrom 就是一个人工智能威胁论的知名倡导者,他更喜欢把人工智能叫做「超级智能」,这也是他的新书的书名。

一些人工智能研究者给出了几个理由来证明为什么人们没必要恐惧人工智能,最起码是在当前阶段。第一,吴恩达曾说过智能和感性能力以及意识是不同的。在 IBM 的人工智能道德小组工作的 Farancesca Rossi 也说过,人工智能「总有一天会觉醒并获得自己的思想」的想法并不现实。

第二,所谓的「智能爆发」也是不可能出现的,因为这需要一个人工智能在比它的前一个版本的智能升级更短的时间内升级出新的版本。但是大多数计算问题,即使是比人工智能简单得多的,在规模化的的时候也需要花很长的时间。

第三,即使机器能够从经验和环境中学习,它们也不会总在学习。例如一辆自动驾驶汽车并不是在每次驾驶的时候都在进行训练。相反地,深度学习系统在神经网络中建立一个执行特定任务的计算模型也需要花上好几天时间。这个模型可以被应用到一个执行机器中,例如汽车、无人机、app或者其他的地方。但是这些汽车和无人机并不能在实际工作时学习,相反地,他们在实际工作中得到的数据会被传回后方来改进模型,然后模型又会被再次应用。因此一个单一的系统不会在环境中学到「坏行为」,因为它在环境中并没有学习。

6.结论:机械问题的答案

人工智能未来一瞥

之前看起来非常紧要的、亟待解决的原始的机器问题,最终将自我解决。尽管 David Ricardo 以及其他人都表达过「机器取代人类劳力可能致使人口冗余」这样的恐惧,机械化的总体影响将会是创造史无前例规模的职位。

机器让个人工作者能生产更多产品,降低大量商品的价格,扩大需求并且将需要更多工人。全新的工作职位将被创造出来,对机器进行监督。随着公司变得更大,他们将会需要更多经理、会计和其他职位。而且随着铁路、电信、电气的到来,全新的、前所未有的、我们难以想象的产业将会涌现。

诚然,所有这些都将花费一段时间。当一些工作消失的时候,工业化会造成普遍的劳力市场聚变,其他改变难以知晓,而全新的职位将会出现。工厂内的情况曾经非常糟糕,从显著的工人收入变化上反映出经济的增长需要几十年的时间,这种现象也就是我们所熟知的「恩格斯停顿」。

在人工智能发展缓慢而备受挫折的数年之后,现在很多人却认为它前进过快,这是一件非常讽刺的事。然而,一份冷静的评估表明我们应该欢迎人工智能,而不是害怕人工智能。在 19 世纪 40 年代,John Stuart Mill 写道,「将来我们会看到,机械发明对劳工的最终好处是毋庸置疑的。」未来可能会有一位经济学家同样如此描述人工智能的好处,并不只是对劳工而言,而是对每一个人而言。

分类
其他

2016-07-24-佛教理解的幸福

我把李笑来老师的《把时间当朋友》又看了一遍,写了很多感想,这是其中一段:
这里李笑来老师理解有误,佛教不是逃避,而是更彻底,佛教认为从根本意义上讲,没有什么东西本质上就是快乐的,比如吃北京烤鸭是快乐的,你一连吃上四只试试,或者你每顿饭都吃烤鸭,吃上一年试试,很多时候所谓的快乐只是对痛苦的逃离而已。不管是不是基于比较,所谓的满足感或者成功感如果是基于外部环境的,必然是短暂的,不彻底的。李笑来老师认为应该做那些不是基于比较就能带来快乐和幸福的事,可是我认为如果你一定要做成了什么事才能快乐和幸福,这不是彻底和真正的幸福,因为有经验的人都知道,这种幸福是很短暂的,很有可能你付出了重大代价达到目标之后的感觉是不过如此。不知道是萧伯纳还是王尔德说过”人生有两种悲剧,一种是得不到,另外一种是得到了”,说的就是这个意思。想想你自己身上的例子,你花了三年时间辛辛苦苦准备高考拿到了理想大学的通知书,你高兴了几天? 你辛辛苦苦省吃俭用几个月买下了想要的包包,你能高兴几天? 凡是要通过外部的条件或者做成什么事才能达到的幸福都不是彻底的真正的幸福。真正的幸福是内在的,就是全然的接受你自己,活在当下这一刻,不去期盼未来,也不悔恨过去,全然的意识到当下这一刻的美好与伟大,全然的投入到当下这一刻所作的事。
下面是原文。
——
有趣的是,尽管每个人都说“这世界变化快”,可是最终我们总是发现“没什么变化”。今天的“豪宅、名车、年入百万”是很多男人梦寐以求的东西,甚至是姑娘们选择配偶的条件。翻翻旧报纸吧,六七十年代,姑娘们择偶要求男方要有“四大件”:手表、自行车、缝纫机、沙发;八十年代也要求有“四大件”:电视机、冰箱、录音机、洗衣机;二三十年之间的表面变化反映的是本质上的不变——反映的都是人们“想要拥有未曾拥有的物质或者资源”的强烈愿望。
其实,谁都知道一个道理,“你不可能什么都有”。没有人是傻子。可是,“想要拥有未曾拥有的物质或者资源”的愿望是如此强烈,所以,人们开始转到另外一个方向上去:“我拥有的是不多,但是比你多!这样我就很快乐。”细观很多人所定义的“成功”,归根结底其实只要四个字就可以概括——“高人一等”,即,市井语言中所谓的“牛×”。不能做到比谁都牛,那么最好“一人之下万人之上”,退而求其次也起码应该是比大部分人或者很多人更牛。
用这样的方法定义“成功”,早就注定了尴尬的结局。财富也好,权利也说,地位也罢,用这些东西去定义成功,只不过是说法不同而已。绝大多数人的追求不过如此。要是比谁都牛就是成功的话,这世界上就不会有成功者了——上帝最牛(如果他、她,或者它,真的存在的话)——而且那还不是人,是神。然而,大多数人从来不觉得他们的定义有什么问题。不然怎么会有人甚至连阳具都肯放弃而去做奴才呢?——这种例子古今中外哪儿都有,随手一抓从指缝里都能漏出无穷多。
事实上,被基督教定义为七宗罪之一的“嫉妒”也是这样产生的。嫉妒源自于对自己与他人之间的差异的扭曲理解。大多数人一生无法摆脱由比较而产生的情绪,不管是正面,还是负面的。有人说,幸福是一种比较。更有人戏谑道,对一个男人来讲,幸福就是自己的收入总是比妹夫的收入多20%。有句广告词颇为流行,事实上也同样基于一模一样的心理:没有最好,只有更好。
可是问题在于,比较是相对的,相对是永远没有尽头的。
于是,我们可以轻松想象那些把自己的幸福观建立在与他人比较的结果之上的人来说,幸福快乐永生永世难以获得,就算偶尔产生了幸福快乐的感觉,也必然昙花一现,因为总是有人有比他们更加年轻貌美或者英俊潇洒,收入更高、权利更大,地位身份更尊贵、财富数量更庞大。
有些人看透了这一切,可是却选择了逃避。这些人会认为“万物皆空”,一切都是幻想而已。于是声称自己可以跳出红尘,远离喧嚣。其实,这也只不过是心智力量太弱的表现而已。
另外一些人也看透了这一切,却没有选择逃避。而是坦然地接受。他们运用自己的心智力量去分辨哪些快乐或者幸福是必须建立在比较的基础之上的,而哪些快乐或者幸福是无需比较同样可以获得的。然后,把时间花在寻找甚至制造那些无需比较就可以获得的快乐与幸福——当然,同样要付出很多代价——然后无怨无悔地生活,尽情地欢乐,平静地痛苦。
一位外科大夫感觉到很快乐很幸福,因为他刚刚从死神手里抢回来一个年轻的生命。一位中学老师感觉到很快乐很幸福,因为他刚刚给一群 15 岁左右的孩子讲清楚了感性与理性之间的微妙关系。一位生物所的研究员感觉到很快乐很幸福,因为她觉得最近每天从床上爬起来一路小跑冲进实验室然后观察记录她所培养的菌体实在是太美丽太神奇了。一位母亲感觉到很快乐很幸福,因为她现在坐在孩子的床边,孩子睡梦中的脸庞是那么安静美丽透放着光彩,那么令人爱怜……
生活无法彻底回避比较,但是,事实上无需比较就可以获得的欢乐和幸福也确实太多太多,只不过常常被人们忽略。于是,大量的时间被用来去追求必须通过比较才可以获得的欢乐和幸福,最终获得的只有更多的痛苦。可是时间却不会仅仅因为结果无法承受而倒流,时间的属性决定了我们每个人都不可能真正拥有从头再来的机会。如果仅仅因为这样的结果就开始寄希望于来生来世,就更加可悲了。当然,还有更可悲的:寄希望于下一代,而不顾自己的经验完全是“错误的经验”,只是单纯而又愚蠢地认为自己的经验毕竟是“多年的经验”……
只要能真正理解前面这大约一千字左右的内容,我们就可以运用心智获得解放。从今天开始,把自己要做的事情全都罗列出来之后,仔细分辨:
● 我做完这件事之后所获得的欢乐和幸福是不是一定要建立在比较的基础上才可以获得的?
● 然后标记出并优先实施那些无需比较就可以获得欢乐和幸福的行动方案。时间会一如既往地分分秒秒、岁岁年年地流逝,但,你会惊讶于你生活的变化。每一秒,每一分钟,每一天,每一年,时间的质量由于对幸福的追求和感知的差异竟然会如此不同。

分类
其他

2016-05-19-关于要求北京市检察院立案侦查雷洋被害案的刑事报案书

按:本博客都是本人原创文章,但是本篇除外,是可忍,孰不可忍?!

我早上在微信看到鬼脚七的文章《我叫雨田洋,我是个死人》,了解了事情的经过。然后回复了雨田洋看到了雷洋事件真实经过。然后就在朋友圈转发了,可是没过多久微信的链接就被删除了。简单来说,我了解的真相就是一个路人(雷洋)路过一家按摩店,被一个黑面包车上下来几个自称警察的人,抓到车上, 因为路人要去机场按女儿,所以激烈反抗,并且让周围的人报警,警察来之后居然说前面几个人是便衣警察,拖到车上继续打直到失手把人打死。然后送医院发现无法抢救之后伪造路人嫖娼的证据,阻止路人家属看遗体,封锁信息,再引导舆论说路人嫖娼,说路人因为心脏病发作而死。下面是我看到的鬼脚七的小说和雷洋妻子的报案书。

我知道我的小博客没什么人看,而且很快可能就会有相关部门打电话要求删帖,但是我一定做点什么,因为我跟雷洋一样是一个两岁多孩子的父亲,如果不做什么,也许有一天我会像他一样被不知道什么地方的警察打死然后孩子失去父亲,死者还失去名誉。

下面是鬼脚七的小说和雷洋妻子要求北京市检察院立案侦查雷洋被害案的刑事报案书。

=====================
鬼脚七: 我叫雨田洋,我是个死人

【导读】本故事纯属虚构,如有雷同,实属巧合!

我叫雨田洋

文/鬼脚七

大家好,我叫雨田洋,今年29岁,毕业于人民大学。

先告诉大家一个好消息,上个月底,也就是2016年4月24日,我当爸爸了!

再告诉大家一个坏消息,十几天前,也就是2016年5月7日,我死了。

是的,我已经死了,我现在是个死人。

其实死人也能说话的,而且死人说话比活人说话更值得听。因为活人说话,有可能是唯心的,活人怕死。我是死人,没有什么可以威胁一个死人。

你问我是怎么死的?这就是我今天要告诉你的故事。

1

还是先介绍一下背景吧。

我老家在湖南常德澧县,离岳阳很近,和你们熟悉的鬼脚七老家很近,离洞庭湖不太远。

2005年,我考上了人民大学环境学院,到了北京。这是我们家的一件大事,也是我们村的一件大事,我成了我们村的骄傲。我爸妈特有面子,从那以后,他们见人说话的声音都大了几分。

我喜欢人民大学,学习也很努力,后来接着上了硕士研究生!2012年,我硕士毕业,找了份工作,在中国循环经济协会上班。这不算一个赚钱很多的单位,但这个岗位还算不错,稳定、不忙、专业对口。就这样,我留在了北京,在昌平区租了个房子。

我们村的人都说我有出息,因为我留在了北京!

三年前,也就是2013年5月7日,我结婚了。我有个贤惠的老婆,愿意陪我一起吃苦,一起打拼。我们也算北漂,虽然生活不是那么富裕,但我们过得很幸福!上个月,也就是2016年4月24日,我当爸爸了,我的小公主出生了!

我很开心,真的很开心!

看上去命运很照顾我,一个山区的穷小子,考上名牌大学,上本科研究生,在北京有个稳定的工作,有个贤惠的老婆,又生了个可爱的女儿!

但佛陀说:一切都是无常的。

当我拥有了这一切,我从来没有想到,忽然有一天,我会毫无征兆的失去这一切!或者说,他们毫无征兆的失去了我!

2

事情是这样的。

我做爸爸后,湖南老家的奶奶、小姨和嫂子,决定过来探望我家宝宝。他们买了5月7日的机票,大约晚上23点半到北京。他们为什么买这么晚的机票?因为那时的机票最便宜,机票也是我帮买的。

大约晚上21点左右,我岳父说让我早点去机场,因为去机场坐地铁还挺麻烦的,需要一个多小时。于是我拿了钱包、手机就出门了。出门时,我觉得心慌慌的,也不知道为什么。难道是房里太闷了?

北京的五月,天气不错,不冷也不热。我穿着一件T恤,凉风吹来,心慌的感觉慢慢消失。昌平龙锦三街,是条小街道,此时路上依然有不少人,两旁还有不少商店没有关门,例如吃夜宵的,还有足浴的。

我没有心思看这些,我要赶路去地铁站。

我21时左右出发,大约是在21时04分到达昌平龙锦三街,21时16分,几个男人突然从一辆伊兰特轿车上下来,抓住我就往轿车上拖。我之所以知道这么具体的时间,是刚好街道上有两个摄像头拍下来了。我后来才知道的。

一人抓住我的手腕,反扭着胳膊,我动弹不得。

“你们,你们是谁?要干嘛?!”我大声喊!

“少废话,上车!”

我感觉后腰被重重的击了一下,紧接着又有一只脚踢向我的胯下。

天啊,真疼!我当时就懵了:难道遇到绑匪了?

很快我被拖上了车,戴上了手铐。

“你们凭什么抓人!你们到底是什么人?!这是京城,天子脚下,你们还有王法么?!”

这时又一个耳刮子打过来,我感觉右脸火辣辣。

“你老实点!王法?嫖娼居然还这么嚣张!还跟老子讲王法?!老子就是王法!老实交代你嫖娼的过程!”

“嫖娼?!我没嫖娼,你们搞错了!”

“不老实,给我打。”

一阵拳打脚踢……..我真的懵了,我不知道发生了什么。我无法描述有多疼,也不记得他们都打了我哪些地方。总之我最后只能瘫倒在车里。

过了一会儿,我慢慢缓过来了。我告诉自己,要冷静!这是生死攸关的时刻。

“你就承认了吧,刚才在足浴店,你是不是嫖娼了?花了多少钱?”

“各位,我真没干那事儿。你们要什么我都给你们,我身上带钱了,钱包、手机都给你们吧。就这么点值钱的东西了。”

“那个哈,把我们当土匪了哈,我们可是人民警察!你老实交代。坦白从宽,抗拒从严!知道吗?”

“哥,哥们儿,无论你们是什么人,需要什么你就说,我真没嫖娼,要去飞机场接人。”

“机场就不用去了,老实交代你嫖娼的事情!”

“我真没有……”话还没有说完,又一脚踢了过来。

说时迟,那时快。我用脚踢向对面一人的腹部,快速抓住车把手,一把推开车门,往外跑去!

“救命啊!救命啊!”

我知道机会就在此一搏了。

3

周围很快有人停住了脚步,开始围观。

“救命,救命!打电话报警!”我一边跑一边大声喊,“救命,他们不是警察,帮帮我,不要让他们把我带走!”

跑了不到20米,有三个人快速追了上来,一把把我摁倒在地。一顿拳打脚踢以后,一人用脚踩在我的身上。

有个小伙子过来询问:“怎么回事?”

“我们执行公务,你们没事的退开。”

小伙子一看对方太凶,也就退后了。此时我已经忘了疼痛了,心凉了半截:难道我今天就栽这里了 …….

应该还有机会,我看见有人报警了。周围围了不少人,众目睽睽下,这帮人也不敢再打我了,他们想把我拉走,但周围十多个人都出来阻止!说要等警察来了再说!

“我们就是警察!”

“你说你们是就是啊!没穿警服,没开警车,万一是假的呢?要是真警察也不在乎多等几分钟,让110过来再说!”一个中年人理直气壮的说。

“是你爱多管闲事,对吧!身份证拿过来!”

…….

过了几分钟,110 警车终于过来了。从警车上下来两名警察,跟他们交涉了一下,看了证件,然后跟大家说:“散了吧,这是警察执行公务!”

天啊,这帮土匪真的是警察?!

那帮土匪警察把我抬到轿车上,又是一顿拳打脚踢!

慢慢地,我已经感觉不到疼了,我闭上眼睛,但我什么都能看见,感觉自己好像在看戏一样。

这是要死了么?这是幻觉么?

4

几分钟后,好像来了一辆金杯车,他们把我抬到金杯车上。

有人摸我的鼻子,有人翻我的眼睛看。

“妈的,装死啊!”我感觉胯下又被踢了一脚,但我没有感觉到疼。

“没反应,不会这么不经打吧?”那个人喃喃自语的说,“送医院!”

金杯车往医院开去,我感觉自己已经离开了身体。从上面看着身体瘫倒在车内,周围坐着那几个打我的人,他们一脸严肃,还有两个人猛抽烟。

我飘向上空,越飘越高,下面的声音都传了过来,汽车声,说话声,吵架声,还有小孩的哭声。我家宝宝哭了么?宝宝别哭,爸爸一会儿再回家啊。

我这是怎么了?

我这是怎么了?

难道我真的死了?

我不能死!死了我宝宝怎么办?我赶紧回到身体里面吧!

一念之下,我又回到车里,那个“我”还是瘫倒在车里,周围还坐着那几个人…….

“喂,别他妈抽烟了!我要死了!你们赶紧抢救啊!喂,喂,喂喂喂!!!”

但无论我多么大声喊,他们都听不见。

有个人又蹲下身来,用手摸我的鼻子气息,应该是没有感觉到呼吸了。我试图回到我的身体内,但怎么也回不去。

汽车到了医院,那是昌平中西医结合医院!还好不是武警医院,我想。

“快来帮忙,我们是警察!”

“还带着手铐,怎么抢救!快把手铐打开。”

“这人好像已经死了。能不能救活不知道!”

“赶紧抢救,赶紧抢救,别让他真死了……..”

我就在边上,看着他们把“我”抬了进手术室,心电图,脉搏,电击……..

忙了几十分钟,医生说抢救无效,“我”死了。

是的,我死了!

5

是的,我死了!我雨田洋死了!

这就是我死亡的经历。

他们为什么要打死我,我到死也不知道!不过我知道打我的那些土匪真的是警察。

他们接下来做的一些事情,让我有些吃惊:

他们故意不及时通报我的家属。

后来我家属过来的时候,他们不让家属拍照。

他们去那个足浴店做了一系列的工作,控制了里面的人。

他们让一位卖淫女录了一份口供,说给我”打飞机”了…..

他们抹去了一些摄像头的记录。

他们对外说我嫖娼,说我是心脏病猝死。

他们说20天后才有尸检结果。(什么准备工作需要这么长时间啊!)

……

这是真相么?

6

我已经死了,但我还很清醒。

我很伤心,但我没有眼泪!

我很恨!但我不知道该恨谁!

我飘荡回家,家里有一股悲伤的气息。每个人都很沉重。

我老婆坐在床上,神奇有些呆滞。眼睛红红的,一定哭了很多次了。

我宝宝就躺在妈妈身边,才两个多星期的小公主。她睡得很香,那个样子我不忍心打扰她。

真的希望她就这么一直睡下去,不要醒来,这个世界太痛苦了。

以前社会上发生了那么多事情,安庆陆纯合、浙江钱云会……

从来没有想到会发生在我身上!就像你从来不会想到类似的事情会发生在你身上。

当然,能忽然发生在我身上,也可能会忽然发生在你身上。

接下来会发生什么?

我不知道,但我不会离去,我会一直看着。

7

最后我给大家念一首诗吧:

起初他们追杀共产党人,
我没有说话,
因为我不是共产党人;

接着他们追杀犹太人,
我没有说话,
因为我不是犹太人;

后来他们追杀工会会员,
我没有说话,
因为我不是工会会员;

此后他们追杀天主教徒,
我没有说话,
因为我不是天主教徒;

最后他们奔我而来,
却再也没有人站出来为我说话了。

—–马丁·尼穆勒

【七哥闲谈】

实在看不过去了,才写了这篇文章。如果这件事情对推动社会的未来有一点积极的影响,我能说:我参与了!这就是我写这篇文章的原因!

故事虽然虚构,但真实发生。如果你还不知道发生了什么事,请自己去问周围的朋友。或者在鬼脚七微信后台回复【雨田洋】,查看更真实更残酷的故事。

=====================

吴文萃(雷洋妻子):关于要求北京市检察院立案侦查雷洋被害案的刑事报案书

http://wqw2010.blogspot.jp/2016/05/blog-post_25.html

报案人:吴文萃,女,汉族,1988年5月7日出生,身份证号码略,住北京市昌平区东小口镇,系雷洋(男,汉族,1987年6月7日出生,住北京市昌平区东小口镇,身份证号码略,本案被害人)之妻。

犯罪嫌疑人:北京市公安局昌平分局参加办理雷洋涉嫌“嫖娼”案件的相关警察、辅警。

涉嫌罪名:故意伤害(致人死亡)罪、滥用职权罪、帮助伪造证据罪

报案请求:对涉嫌犯罪的全部办案人员立案侦查,对初查已经构成犯罪的嫌疑人,立即采取刑事强制措施,依法追究刑事责任。

一、案情经过

2016年5月7日晚21时左右,雷洋离家前往北京首都机场,接老家湖南赶来北京看望他刚出生半月的女儿的三位亲戚。

21时04分18秒:雷洋来到龙锦三街,由东向西行走。21时16分50秒:雷洋到达事发足浴店西侧约67米处。(这两个时间点有监控探头证据证实,这个12分钟时间点之内,发生了本案警方所称的“足浴店嫖娼”事件)此后,被五六名无任何警察执法标志、没有穿警服、无警号、无警车的便衣人员拦截、挟持。在伊兰特轿车上要他承认刚才是到洗脚店嫖了娼。雷洋认为遇上绑架勒索,可能是不承认嫖娼,这些人就对雷洋进行“突审”,(警察向家属通报时亲口陈述),进行了暴力殴打。(家属在8日凌晨在中医院太平间、和13日在北京市公安局法医中心尸检前,都看到雷洋身上右额部被重击淤肿、阴部睾丸肿胀、右上臂、腰部、脸部都有严重伤痕,明显系暴力殴打形成),雷洋挣扎逃出小车,在小区内向周边居民大喊“救命,他们不是警察,帮帮我,不让他们把我带走”。随即又被三个人摁倒在地。群众打110报警,十多位群众围观目击并询问情况,阻止不让带走。他们才出示证件说是警察。110警察放行。雷洋又被架进伊兰特轿车5-6分钟。随后来了一辆金杯面包车,两个人随即将雷洋架上面包车。有证人看到此时雷洋已经双手瘫软,不会反抗。根据警察说法,随后雷洋身体就出现异常。当晚22时09分,(警方通报说法)雷洋被送至北京市昌平区中西医结合医院, 警方称抢救无效死亡。而根据医院记录,雷洋到医院时已经死亡。22时55分,医院宣布抢救无效死亡。

从发生抓人到人瘫软抬上金杯车,只有10几分钟。(小区目击证人报警时间21时38分可以证明) 到确认死亡,时间不超过50分钟。

雷洋此期间唯一接触对象,是在昌平公安局这些办案人完全控制之下,排除任何其他因素。而雷洋年轻健康,无任何急症病史,不可能在50分钟内会突然因病死亡。

5月8日凌晨1时01分,报案人拨打雷洋电话,接听者自称是昌平区东小口派出所民警。他们通知我到该派出所,称雷洋出事。我即同从湖南坐飞机已经到北京我家的亲属一起,于凌晨1时30分左右赶到派出所。警方当面告知我们,雷洋在该派出所抓嫖过程中突发心脏病猝死。经过交涉等待,一直到清晨天亮,我的亲属才在医院太平间见到雷洋遗体5-6分钟,全身赤祼,身上盖着白布,不让看下半身,也不让拍照。五六名便衣警察即强行隔离开家属。

事发当夜,昌平公安局故意拖延通知我们家属,控制遗体不告知我们放在哪里,掩盖真相,抓捕足浴店全体人员,获取“雷洋嫖娼”的假证据,让足浴女录制有“打飞机”的口供,向社会播放,进行引导。并组织媒体进行采访,统一口径,杜撰雷洋“嫖娼”、“激烈反抗”、“心脏病发作猝死”的说法,两次通过网媒和有关报纸、电视台,发布《情况通报》和相关采访录像,进行掩盖,以造成既成事实。并于8日下午,向我们家属通报,要求我们接受这一结论。

二、犯罪事实

报案人认为,5月7日晚21时参与经办雷洋案件的所有民警的行为,在没有证据能够证实雷洋有嫖娼行为的情况下,对一个无辜公民进行挟持和暴力殴打伤害,致其在10几分钟内即被打濒临死亡。延误时间没有及时抢救,致被害人雷洋在不到50分钟内即死亡。一个年轻健康的人,因警察滥用职权的执法行为,离开了人世。因滥用职权犯罪导致的故意伤害行为,导致了致人死亡的后果,情节极为恶劣。事后又进行了一系列的掩盖和伪造证据行为。已经构成滥用职权罪、和故意伤害(致人死亡)罪、帮助伪造证据罪。

(一)没有证据可以证明雷洋嫖娼

2016年5月11日,北京市公安局昌平分局发布《情况续报》,称“5月7日20时许,昌平警方针对霍营街道某小区一足疗店存在卖淫嫖娼问题的线索,组织便衣警力前往开展侦查。21时14分,民警发现雷某(男,29岁,家住附近)从该足疗店离开,立即跟进,亮明身份对其盘查。雷某试图逃跑,在激烈反抗中咬伤民警,并将民警所持视频拍摄设备打落摔坏,后被控制带上车。”这段通报明显进行了编造,漏洞百出,污篾无辜的雷洋,从而试图对民警的犯罪事实进行了推托掩盖。

1、雷洋没有嫖娼时间。报案人明知,雷洋是于2016年5月7日晚21时左右,离开家前往北京首都机场接机的。而警方认定当晚21时14分左右雷洋就从足疗店出来。同时,根据昌平警方提供给中央电视台的道路视频监控显示:雷洋出现在监控摄像头3号的时间为21时04分18秒,出现在监控摄像头4号的时间为21时16分50秒,而事发足浴店位于监控探头3和4之间。所以按经办民警的说法,雷洋进入足浴店完成嫖娼的前后时间为十分钟左右。两处监控审查相减的时间,雷洋可能进足浴店也不到10分钟,根本不可能完成选座、选人、端洗脚水、谈价钱、征求服务方式、脱衣、戴套,洗浴,进行性服务“打飞机”、射精、穿衣、再走到大门外往西70米,这一系列的经过。根本不符合常理,雷洋没有嫖娼的时间。

2、雷洋没有嫖娼动机。雷洋当晚九点出发,到北京首都机场接来看他满月的新生女儿的小姨、奶奶和嫂子,从家里出发,坐地铁需要一个多小时,才能赶到北京机场,而飞机预计落地时间是十一点半。是我们催他出门的,时间已经很紧张。在这么短的时间里雷洋如此匆忙忙忙里偷闲挤时间去嫖娼,不符合基本常理。同时,雷洋接其小姨等人来家里,为了照看刚刚出生14天的雷洋的孩子。另外,5月7日还是报案人和雷洋结婚纪念日。在这个特殊的日期、时间节点以及马上与亲人团聚的背景下,雷洋不可能专门去嫖娼一个根本不认识的比他还大的洗脚女。

3、雷洋嫖娼没有任何直接证据。

(1)监控录像审查没有雷洋进、出足浴店的任何证据;
(2)足浴女也没有进行脸相辩认,无法证实接受性服务“打飞机”的人就是雷洋;
(3)阴毛、体液、避孕套,对于一直控制尸体的警方,进行伪造嫁接易如反掌;
(4)足浴女说是“打飞机”手淫,警方说是用了避孕套性交易;
(5)一说雷洋很快承认了嫖娼,又说挣扎逃跑抗拒执法高咬伤民警打碎视频拍摄设备;(6)足浴女在电视上说,“打飞机”他们的规定时间是45分钟,雷洋既然专门绕道去选择性服务,没有任何外来电话催促和干扰的情况下,为什么10分钟内就会主动结束服务付钱走了?除了有利害关系应当回避的昌平公安机关的编造和抓人形成的伪证,能够证明雷洋有嫖娼的证据一份也没有。完全是为了掩盖打人致死而故意编造。

4、雷洋生前向居民区大声呼救,扩大影响,没有想掩盖嫖娼,不符合嫖娼行为人的特征。明显不是有嫖娼情节的惯常表现。如果真做了见不得人的事,他应该会很顺从地随办案民警走,而不会让居住地不远的居民大家都知道,而大声叫救命。只有根本没有违法情节的人,才会有这样的反应。

(二)雷洋尸体外伤严重。
2016年5月8日凌晨五时多,报案人亲属经派出所通知,到昌平中西医院太平间,见到了雷洋的尸体。雷洋全身赤裸,嘴角有血,额头、颈部、手臂、都有明显外伤,明显是暴力殴打才能够形成。在5月13日尸检现场,五位亲属都亲眼见到的全身伤痕,致命处是睾丸异常肿大,额部有重伤淤痕,右手脱皮,腿上有淤青和血痕。明显是外力伤害致死。待法医检验结论出来,一定会进一步证实这一结论。

(三)公安执法整个过程严重违反法律规定。

1、经办民警盘问和车上“突审”严重违法。

根据警方自己公布的通报,经办民警当时是着便衣,在盘问时雷洋大声呼喊“救命”,“他们不是警察”,这些都有目击证人证实,根据常识和雷洋的智力水平,如果雷洋被抓时经办民警出示有效证件,雷洋不会大声呼救、让人报警。这说明,经办民警在抓捕雷洋时没有穿警服,未戴警号,根本未出示工作证件和法律文书,这显然违反治安行政执法的法定程序,根本不是依法执行职务,而是违法办案,非法抓人。

2、经办民警利用职权暴力殴打雷洋。

从雷洋的尸体表面即可看出,雷洋浑身是伤,尤其是睾丸肿大特别严重。现场很多目击证人证明当时经办民警和雷洋发生了肢体冲突,昌平分局在通报和接受新闻受访时,都承认经办民警与雷洋发生了激烈对抗。在一个普通治安行政案件中,五个经办民警约束一个人会有多大难度?为什么要采取如此暴力?

(四)雷洋没有心脏病史,可以排除猝死。

2016年5月8日,东小口派出所在告知报案人雷洋死因时,称“心脏病猝死,这是医生的初步诊断。”然而,事实上雷洋根本没有心脏病,雷洋家族也没有心脏病史。也不可能一个年青健康的平时一直好好的青年人,到警察手里没有其他原因十几分钟内坐在车内就会急病死亡。经办民警在没有任何证据,也没有进行司法鉴定的情况下,以一句“心脏病猝死”,明显是在掩盖搪塞。

(五)经办民警的行为符合刑事立案追诉标准。

本案中,昌平公安局经办民警,严重违法办案,无端怀疑无辜公民,进行挟持和暴力殴打,进行刑讯逼供,车上“突审”,导致雷洋最终被直接殴打致死。根据《刑法》第二百三十四条,各被控告嫌疑人已经涉嫌故意伤害(致死)罪;根据《刑法》第三百九十七条,各被控告嫌疑人已经涉嫌滥用职权罪;根据《刑法》第三百零七条第二款、第三款,该局相关领导和没有参加直接行动的警察,组织伪造证据,掩盖执法中打死人的事实,供公开播放,误导社会,故意陷害雷洋,进行虚假事实通报,掩盖本单位涉案人员的犯罪行为,已经涉嫌帮助伪造证据罪,并应当依法从重处罚。

三、立案管辖

(一)该案属于检察机关管辖

《刑事诉讼法》第十八条规定:国家工作人员的渎职犯罪,国家机关工作人员利用职权实施的非法拘禁、刑讯逼供、报复陷害、非法搜查的侵犯公民人身权利的犯罪以及侵犯公民民主权利的犯罪,由人民检察院立案侦查。对于国家机关工作人员利用职权实施的其他重大的犯罪案件,需要由人民检察院直接受理的时候,经省级以上人民检察院决定,可以由人民检察院立案侦查。”最高人民检察院《关于人民检察院直接受理立案侦查案件范围的规定》: “国家机关工作人员利用职权实施的其他重大的犯罪案件,需要由人民检察院直接受理的时候,经省级以上人民检察院决定,可以由人民检察院立案侦查。”

(二)该案应由北京市人民检察院管辖

根据《人民检察院直接受理立案侦查职务犯罪案件管辖规定》第二条:“人民检察院对直接受理的渎职侵权等职务犯罪案件,实行分级立案侦查。……省、自治区、直辖市人民检察院立案侦查在本省、自治区、直辖市有重大影响的职务犯罪案件;……”根据《人民检察院刑事诉讼规则》第十三条:“人民检察院对直接受理的案件实行分级立案侦查的制度。……省、自治区、直辖市人民检察院立案侦查全省(自治区、直辖市)性的重大犯罪案件;……”
本案中,雷洋非正常死亡案件,在北京市甚至在全国都造成了极为恶劣的影响,已经成为全国和国际上都关注的案件。因此应由北京市人民检察院立案管辖。

同时,由于本案已经有充分的证据可以判断经办民警涉嫌故意伤害(致死)罪,可以判处无期徒刑以上罪刑,根据《刑事诉讼法》的规定,亦应由北京市人民检察院决定立案侦查。
综上所述,报案人认为,各犯罪嫌疑人,身为国家机关工作人员,人民警察,在履行职务过程中,违反法律规定,滥用职权,并利用职权故意伤害致人死亡,其行为已触犯《刑法》第二百三十四条、第三百九十七条、第三百零七条第二款之规定,涉嫌故意伤害(致死)罪、滥用职权罪、帮助伪造证据罪,应依法追究刑事责任。

现根据《刑事诉讼法》第十八条、第一百零七之规定,请求贵院立即受理报案,迅速保全和调取相关证据,核实证人证言,审查相关事实和证据,并对此案立案侦查,立即对相关涉案嫌疑人依法采取刑事强制措施。查清全案,依法追究相关嫌疑人的刑事责任。

此致
北京市人民检察院

报案人:吴文萃(雷洋妻子)
2016年5月16 日

抄报:最高人民检察院
附件:略

分类
其他

2016-03-03-工业规模与人口-读后感

2016-03-03-工业规模与人口-读后感

好文章,以前我认为计划生育错误主要是四个原因: 一,不人道,生孩子跟吃饭喝水拉屎一样是人的基本权力,任何组织和个人都无权干涉; 二,人口老龄化会影响整个社会经济的发展,看看日本就知道了; 三,人口是资源而不是负担,除了智障和残疾人,绝大部分人对社会的贡献都大于或等于社会给他的回报; 四,在现代社会想让人口增加比想让人口减少困难得多,现在日本,俄罗斯,欧盟,新加坡,韩国等发达国家都面临鼓励生育的难题,因为现代社会娱乐设施更多,社会福利增强,避孕技术的进步,人们的生育意愿都在下降。现在这篇文章又提供了一个新的视角,人口规模会影响到工业水平。

以下是原文:
—-
欧洲已死,死在第四次工业革命前夕
2016-03-03NE0罗辑思维

达沃斯论坛又开了,议题是“掌控第四次工业革命”,但在我看来,此议题选在欧洲开真是一种莫大的讽刺。如果说有哪个地方是绝逼不可能引领第四次工业革命的,我绝对先投欧洲一票。

当前全世界第一大工业国是哪个?是美国吗?是德国吗?是日本吗?是俄罗斯吗?不,不用到处找了,答案是你脚下站着的这个国家,中国。

我知道,国内很多人对欧洲,或者说德国制造崇拜得五体投地,一会儿说百年传承,一会儿说精密无比。我也承认,在目前某些领域,那些经过长时间积累的欧洲产品确实比我们的要好用不少。但如果只看到这些,那么,我只能说,那些盲目崇拜的国人连工业化最本质的东西都没搞懂。

工业化是什么?本质上,工业化是用机器造机器,那问题来了,那些制造机器的机器,是谁来设计的?又是谁来建造的?甚至最终是谁来操作的?

1
大历史的尺度

当你以一个更大的时间尺度,十年,二十年,甚至五十年的时间去看待整个工业化时代,你就会明白,决定一个工业化社会未来的最终还是人,是工业化人口。

不管是在美苏,还是德日,或者任何的工业社会里,工业人口数量不仅直接决定了工业经济的规模,也决定了工业体系的复杂程度,或者说先进程度。

因为现代工业的发展趋势是分工越来越细,产品越来越复杂,基本配件越来越多。要保证工业的正常运转,把工艺锁在图书馆里,指望用到的时候再去查是不行的。就算查到了还有个熟能生巧的问题,更不可能有进步——没有人能基于不懂的知识进行二次开发。

所以在工业的核心部分里,平均每个基本配件要至少对应一个专职人员来储备并改进生产工艺。

随着工业化的发展,核心产业所占用的工业人口和工业技术的复杂性,以及基本配件数量在同比例增长。但是核心产业并不能自己构成一个完整的社会,还需要消费品工业、建筑业、交通运输、商业、服务业、行政、军事、社会保障等第三产业,以及采矿、农业等初级产业部门的劳动力来配合。这些人配齐了,整个工业体系才能顺畅地运转,同时每个社会成员才能拥有相对轻松而丰富的生活。

再加上这些劳动力抚养的子女和老人,大致可以估算出一个独立工业体系所需的人口大约是基本配件数量的10倍,最少也不能少于5倍。

19世纪中后期,工业体系只有蒸汽机这一种动力,当时最复杂的工业品无非是铁甲舰,一条铁甲舰有几十万种零部件,所以当时的一个工业国需要近百万人来满足核心产业,最小的工业国比利时也有 400 万人口。

20世纪初第二次工业革命后增加了电器和化工两个大门类,工业体系的基本零部件种类也随之翻了几倍,已经要近千万核心产业劳动力才能维持工业体系完整了。此时列强中已经不再包括比利时之流,人口最少的法国是 4000 万人,而且法国的工业体系也不完备,被 6000 多万人的德国打上门来,就必须在英美的支持下打第一次世界大战。

到“二战”期间,基本部件增加到几百万种,对应的是 6500 万人的德国可以发动战争,法国则在开战后一个月出局。但德国也必须放弃研制生产诸如战略轰炸机、航空母舰和原子弹这样的超级武器,人口规模差不多的日本能造航母却造不出像样的坦克。海上地面两边都行的只有人口上亿的美国一家。苏联在海军技术上缺乏储备,不过造坦克、大炮、火箭炮总能压德国一头。

等到世界进入核时代,一套完整工业体系需要由上千万种工业基本配件构成,这决定了只有人口上亿的工业国,也就是美苏才有资格成为世界一极,其他工业国只能做附庸。这段时间尽管英法同为安理会常任理事国,拥有战略核武器,但也只能面对江河日下的命运。

到了冷战中后期,工业配件数量进一步增加到 3000 万种以上,美苏各 2 亿左右的人口被各种工业部门完全占满,很难再往更复杂的工业社会发展了。但是美苏双方都绝不甘心维持这种两极世界的局面,都希望继续扩大工业力量,研制更多的新式武器,拉长产业链,继续提高自己的工业复杂程度,在技术上压倒对方,即把更多的工业人口纳入自己的冷战对抗体系。

在这种情况下,美国把民用产业向国外转移,同时用金融手段继续占有这些工厂的产品,养活本土人口,集中力量和苏联搞军备竞赛。这相当于在不引进移民、不增加农业和社会福利压力的前提下,增加了本国工业人口。

通过这种方式,日本、德国还有20世纪80年代的中国都为美国贡献了冷战所需的工业劳动力,增加了美国一方的工业复杂度,促进了美国的高技术升级。

而苏联一方的人口只有自己的 2 亿多加上东欧几千万,要和美国控制下的全球体系竞争,只能延续二战前那种更适合于进行战备的科技产业体系,通过自上而下的方式在应用技术方面获得高效率,从而使自己的工业体系丧失了自我升级的能力。

另一方面,人口缺乏也使苏联不得不把有限的人口都集中到军事工业和重工业上,到苏联解体的时候,苏联总人口只有 2.8 亿,却有 7000 万产业工人,平均 4 个苏联人就有1个产业工人,其中绝大多数都在军事和重工业部门。这直接导致了苏联民用工业的长期萎缩,最终崩溃。

2
江河日下的帝国们

从上面的角度来看,欧洲最终走向一体化进程不是因为欧盟想,而是如果不统合欧洲这二十几个国家的工业人口和制造能力形成一个数亿人口规模的实体,欧洲根本撑不下去。

但按照目前欧盟的出生率和人口规模,第三次工业革命,也就是它的极限了,第四次工业革命对整个产业链条复杂程度的要求和产业工人数目的要求,都是欧盟承担不起的。

不信?看代表一个国家高端工业体系的战斗机。

目前能够达到第四代战斗机标准的只有两个国家,中国,美国。俄国那个由Su27拍扁而成的 T50 不算。欧洲呢,根本没有任何一个国家能够独立承担得起第四代战斗机的研发,三代半的台风战机,是整个欧洲的力量加起来所能达到的顶峰了,第四代战斗机 F-35,只能是联合美国一起开发。但是即使是欧美联合上一堆傀儡国家例如日韩,整个开发过程都已疲态尽显。

F-35 的开发过程遇到一大堆问题,其中一个非常大的障碍是飞控软件的设计,现代飞机几乎就是一个飞行电脑,几乎一切功能都要通过计算机软硬件完成。

“摩尔定律”不单只对硬件适用,对软件技术发展一样适用,因为芯片的容量差不多每 18~24 个月会增加一倍,带来的运算能力也会支持软件的大小跟着增加一倍。2002年服役的 F-22 的机载计算机软件包括 400 万行源代码,眼下刚刚投入试生产的F-35的软件则有 1900 万行。

软件是人写出来的,当初编写 F-22 的软件时美国人还使用了专门军用的 Ada 高级语言,可是源代码翻了几倍之后,就再也凑不出那么多懂 Ada 的程序员了,只好改为民用的 C 语言,不过连 C 语言的军方程序员都凑不出那么多,战斗机的软件又不能随便外包出去,F-35 的软件开发进度只好一拖再拖,成本也随着人吃马喂节节攀升。

当初美国人提出研发这种轻型四代战机是因为 F-22 价格过于昂贵,需要一种廉价飞机弥补其数量不足。在当时的计划中,这种战机的各项性能差不多相当于 F-22 的一半,造价只有其 1/3 。不过到现在,F-35 还没正式大批量生产,造价就已经快超过了 F-22 。

集美欧之力,造一款第四代战机尚且举步维艰,你还觉得欧盟能独力引发第四次工业革命的几率有多大?

工业革命是一个由量变积累到质变的过程。每次工业革命之后,新的技术手段会让制造精度大幅度提高。一旦机器的精度提高,接下来带来的变化就是可以制造更复杂产品的机器。而越是复杂的产品,包含的零件也就越多,这些零件都需要有人制造出来,所以一个工业体系有多少种零件基本上就需要多少工人、技术人员掌握制造工艺。

说到底,一个国家要维持工业体系持续升级,必须要有足够的工业人口。每当一种更复杂的机器出现,只有招募到足够的工人和技术人员,产业升级才能进行下去。在一次又一次产业升级中只有人口足够多的国家才能甩掉所有对手。

反之,如果产业链已经拉长到把人口基数用光了,那就只能拆旧的补新的。每个国家都会把用来保命的军事工业留在手里,拆出去的工业首先是能赚钱、能滚动发展的民用工业,等民用工业拆得差不多了,机床、工业设备制造行业也会追着民用工业这个大客户而去,只留下军事工业。

虽然军事工业往往代表着一个国家最高的技术水平,但军工造出的枪炮都不能再用来造别的机器,一旦本国没有了民用工业,军事工业也不能把军用先进技术转移到其他产业。再也没办法实现用机器造机器,用老式机器造更先进的机器这种工业化循环。只要别人的工业化循环一运转起来,积累出新一代技术,那些昔日的帝国很快就什么也不是了。

在可预见的将来的将来,整个欧洲会像一个多米诺骨牌阵,一个又一个国家倒下,从希腊,意大利,西班牙,爱尔兰这些猪国(PIIGS),再到英法,最后是德国。如果说有什么是人力不可抗拒的客观历史规律,这就是。

3
后 记

如果很快有第四次工业革命,那么我个人猜想很有可能会是以核聚变、人工智能、量子计算这三大标志性事物宣告一个时代的来临。

而其中最基础的一定是对于能源来源方式的革命。在聚变能这个领域,目前能够确定拥有集反场箍缩磁约束、超导托卡马克、非超导托卡马克这三种装置的国家,只有一个,那就是中国。另一个,可能是美国。

至于欧洲,欧洲建造的巨型强子对撞机里面的核心部件,你猜是 made in 哪个国家?

本文由作者 NE0 授权罗辑思维发布,选自微信公众号“港股那些事”。

这篇文章的视角,既正大,又新奇。
1.分工产生效能。这是经济学大厦的第一块基石。
2.互联网给我们看到了很多“逆分工”的假象,但最终的结局一定是更细密的人类分工。
3.国家的竞争力,不是有多少人口,而是有多少参与到分工协作中的人口。
4.国家的竞争力,不仅取决于本国有多少人口,而且取决于能把多少国际人口卷入到自己的分工体系中。

分类
其他

2016-01-25-30岁生日感想

2016-01-25-30岁生日感想

今天是公历2016年1月25号,农历2015年腊月十六. 我出生的时间是在30年前的1986年1月25号农历1985年腊月十六. 也就是说不管是按公历还是按农历, 今天是我整三十岁的生日.

回顾三十年的经历, 我好像没有太多的亮点. 小学之前的经历已经没有太多印象了, 只有一些记忆残片, 上学, 放学, 奥数, 几个漂亮女生, 其中一个我一直暗恋到我遇到现在的妻子. 初中前两年也没什么印象了, 依稀记得把一个姓盛的同学手弄脱臼了, 然后姓袁的班主任没收了我从同学那里借来的武侠小说, 然后有一张学习标兵的头像挂在了学校的光荣榜上面. 初三去实验中学, 寄宿在三姑姑家, 整天上自习, 除了学习好像也没有什么有趣的事情. 再就是高中了, 在学校住宿, 星期六去大姑姑家蹭饭, 洗澡, 把衣服带过去洗, 然后就是一个姓田的同学偷看了我的日记, 再然后就是高考. 然后上了武汉大学, 大学四年似乎也没有太多的亮点, 似乎参加了一些社团, 但是不记得是做什么的, 印象最深刻的是图书馆, 然后就是追过一个女孩, 可惜没有成功, 后来她跟我说似乎是因为什么误会, 再就是自习, 看书, 樱花, 学会了游泳, 然后在一次游泳的时候亲眼看到一个同学淹死在了游泳池里面, 当时我还在旁边参与了把他拉上岸. 然后我开始思考人生的问题, 一直持续到我保研以及去新加坡留学. 新加坡留学的最大的收获是遇到了我的太太. 在遇到她以前我一直怀疑我会不会找女朋友, 更无法想像我会结婚生子, 甚至我一直有一种感觉我活不到三十岁. 然后我遇见了她, 一切变得实际起来, 登记, 钻戒, 求婚, 结婚, 生孩子. 然后我的宝贝儿子已经两岁半了…

面向未来, 我想说, “四十岁, 你等着, 我来了!”.
面对自己, 我想说, “龚成, 为了儿子, 为了妻子, 为了父母, 加油!”

每次回想过往的经历的时候, 我都有一种不真实的感觉. 仿佛这一切回忆都只是假象, 甚至看到以前的照片, 我都会怀疑这只是一个导演做出来的. 就像黑客帝国里面一样, 所有的一切都是假的, 我的父母, 我的妻子, 我的记忆, 一切的一切都是大脑的想像. 一切的一切都不太对劲, 幸好最终我在佛陀的教导中找到了关于人生的思考的所有答案. 我之前已经写过不少文章阐述我的理解, 这里就不重复了. 总而言之, 我已经形成了对世界的看法: 从最高层次讲, 所有的现象都是基本粒子的运动形成的假象(物理学上尚未证实的弦论说, 佛学上讲的凡所有相皆是虚妄, 两种并不完全相同); 次一级的层次上讲, 说世界上的种种物质和现象都是短暂的, 注定是要消亡的, (物理学上的热力学第二定律, 佛学上的成住坏空说); 最低的层次上讲, 整个人类的物质生活正在变得极为丰富, 整个世界变成越来越小, 越来越相互依存, 我们每个人也必须顺应潮流, 溶入到整个人类的洪流中. 相对应的, 我认为正确的生活态度应该是努力体验修行证悟最高层次的真理, 同时在理智上要认清第二层次的真理从而在第三个层次上面努力生活, 但是不为生活所累. 简单的说, 就是明知道我们所做的一切都是镜中花水中月, 还是要努力的去做, 但是我们的目的不是事情所要达到的结果, 而是在做事的过程修行, 最终能够体会到世界最高层次的真理. 做事的过程中要不悲过去, 非贪未来, 心系当下, 由此安详.

分类
其他

2016-01-19-外汇文章读后感

2016-01-19-外汇文章读后感
早上看了这篇文章
http://mp.weixin.qq.com/s?__biz=MjM5NjE4ODM4MA==&mid=403325410&idx=3&sn=d61bbf3a70115d5fcea8915d67c6f3d7&scene=5&srcid=0119hKoHTEkijGb5WrMKM6JJ#rd
这是我看到的关于外汇储备和汇率最靠谱的一篇文章. 看完之后有几个感想:
1. 无奈, 因为我把这篇文章分享出去也没有什么用. 原因是a. 有兴趣看这篇文章的人不多, b. 有兴趣的人有耐心看完这么长文字的人不多, c. 有耐心看完这篇文章然后能够理解其中意思的人不对, d. 能理解意思的人也什么都做不了. 所以我分享出去只是尽人事罢了.
2. 我想到这篇对谁最有用, 当然是对央行的行长, 外汇储备局的人有用. 但是他们不太可能会看到这篇文章, 即使看到了也不会轻易改变现在的外汇制度, 因为他们就是文章中所说的既得利益者. 有句古话说”肉食者鄙”, 以前我的理解是当政的人很愚蠢. 今天我忽然觉得其实这句话有三层意思, 第一层就是字面上, 有些肉食者就是裙带关系或者巴结权贵上位的, 对于自己的本职工作确实不善长; 第二层意思就是当政者由于屁股决定脑袋只能从自己的角度看问题, 然后产生的认知; 第三层就是当政者其实是明白自己执行的政策是不利于人民长远的利益, 但是由于现行的政策对自己有利, 就昧着良心假作不知继续执行.

以下是原文:
—-
终于有人把人民币暴涨暴跌这件事情给说清楚了!

2016-01-18 好买财富
导读
最近人民币汇率的大跌引人瞩目,离岸人民币曾一度跌破6.7。前一两年人们还在抱怨外储太多、呼吁人民币升值,现在开始担心外储不够、人民币贬值了,为何反转如此之快?到底什么决定着人民币汇率?看看徐昌生老师的文章,详细描述了人民币汇率的决定机制,写于2011年,那时人民币还处于升值压力中。时移势易,人民币汇率变动不居。归根到底,是中国的发展状态和货币数量决定着人民币汇率。

自从国家外汇管理局(以下简称外管局)在其网站上强势声称巨额外汇不是老百姓的血汗钱,并且无法均分给国内老百姓以增加福利以来,对于外管局观点的质疑就源源不断。许多百姓总觉得外管局是在强词夺理,但囿于汇率知识的缺陷无法给予迎头痛击。目前,美债危机再次波及全球,中国作为拥有万亿美债和3万亿巨额外汇的国家,外汇的安全问题再一次拨动了国人的神经。

巨额外汇到底是不是中国老百姓的血汗钱?中国的天量外汇是不是可以发给百姓以改善民生?中国作为一个穷国为什么反而要去购买富国的政府债券?政府的外汇储备为什么又是以美元为主而无法多元化?要弄清这些问题,就必须对汇率知识进行全面透彻地了解,而这一点恰恰为普通百姓所欠缺。

其实,岂止是普通百姓,即便是像外管局这样的专业机构,他们对汇率知识也是似懂非懂,否则不会前后几任局长都说出一些不着边际的外行话(前国家外汇局长吴晓灵女士也阐述过与外管局网站类似的观点)。当然,作为国家的外汇管理专业机构,说他们不懂汇率知识可能是低估了他们的智商,也许他们是想通过混淆是非而浑水摸鱼。不过,笔者不想以小人之心来推测一家政府机构的君子之腹,宁愿相信他们是因为汇率知识的缺乏而身陷迷茫。

鉴于外管局对汇率问题的认识已经误入歧途,鉴于大众对汇率知识的一知半解似是而非,鉴于一些御用经济学家不懂装懂口若悬河或者故意糊弄百姓误导大众,笔者不才,愿意试着用最浅显的语言把汇率的知识系统地讲述一遍,坚信各位读者即便没有任何经济学知识,也能使您对汇率问题重新认识,使您对上述疑问拨云见日。更希望国家外管局的领导能够谦虚谨慎不耻下问,认真通读此篇长文,使自己对汇率问题的认识更上层楼,从而增加自己的知识和减少对大众的误导,更为国家未来制订正确的汇率政策打下良好的理论基础。

一、为什么需要对外贸易?

有一个故事不得不反复提起,虽然故事的内容早已老得掉牙了无新意,但对于没有经济学知识的老百姓来说,学习它对理解汇率原理至关重要。

说是人类尚处在以物易物的蒙昧时代,某甲制造了两柄犀利的斧头,某乙射死了两只肥壮的野羊,甲只需其中的一柄便足够自己砍伐树木,另一柄只是闲置;乙一时半会也吃不了两只羊,另一只放长了时间就会腐烂变质。于是,两人便自发地将多余的东西进行交换,尽管斧头还是斧头,野羊仍是野羊,他们的数量与质量并未发生任何变化,但是双方的境况却因为交换而得到了改善,因为双方都用自己多余的物质换回了对自己有用的财富。

这个故事告诉我们,平等自愿的交换使各种资源更加合理有效地得到分配,能使交换的双方增长财富。从这个故事推广开去,要想使一国一地的百姓更加富有,就必须通过合理的政策来促进更加广泛的交换,交换越多,百姓致富的步伐就越快。当然,人类早已进入了使用货币的文明时代,但是交换本质并未发生任何改变,货币只是充当了交换的媒介而已。

对外贸易与国内百姓之间的交换并无本质上的不同,同样是以他之长补我之短,以己之有换己之无,使各类资源在世界范围内得到更加有效的配置与使用,当然也能促进交换双方的财富增长,这就是为什么各国政要都把捍卫贸易自由作为口号吊在嘴上的原因。但对外贸易与国内又有不同,因为各自的产品在计价时使用的货币并不一样,美国人用的是美元,中国人用的是人民币,用多少元人民币的中国产品才能换回一美元的美国产品,这是一个难题,于是汇率的问题应运而生。

二、汇率是由什么决定的?

假如甲国什么资源产品都有,而乙国资源产品匮乏,此时甲国的钞票就更值钱,因为乙国迫切需要甲国的产品资源,它情愿用更多的产品来换取甲国的钞票以购买甲国的资源,否则甲国就不会与你交换。

但是,这种情况也不是一成不变的,假如乙国原先迫切需要甲国的石油资源,后来他们在自己的境内发现了一座贮量丰富的大油田,那么乙国对甲国的石油资源需求就会下降,此时乙国的钞票相对于甲国的钞票自然就会升值。因为乙国缺油的窘迫已经得到了缓解,原先换1吨甲国汽油愿意拿出10吨粮食,现在可能只愿意拿出5吨粮食。

以中美两国而言,人民币对美元的汇率其实是由中国对美国(或者说世界市场,因为美元是世界通用货币)各类资源产品和美国(或者世界市场)对中国各类资源产品的供需决定的,就象一国之内的物价是由供需双方决定一样。人民币汇率就是人民币在世界市场上的价格。

改革开放初期的中国,彼时中国缺少制造技术,小车、电脑、制造设备和大飞机皆不能造,而中国又急需这些东西以支持现代化建设,于是人民币在国际贸易中就非常不值钱,因为,一方面我们迫切需要美元在美国乃至世界市场购买先进的设备与技术,另一方面外方拿到了大把的人民币却在中国市场上没有什么他们需要的东西可采购。就象现在海地的货币不值钱道理一样,因为你即使拥有海地的货币,但因为其已遭受严重地震,你根本买不到你需要的东西。

但是,随着中国改革开放的不断深入,中国除了大飞机之外,不仅自己能够制造电脑、小车和各类制造设备,而且能够利用这些设备和中国劳动力的优势,生产出更多鞋子袜子领带打火机等诸多轻工产品,这样,一方面我们并不需要更多的美元去美国购买工业产品,因而对美元的需求就下降了;另一方面美国人拿到人民币后却可以在中国买到价廉物美的轻工产品,因而他们对人民币的需求上升了,这一降一升,意味着对美元的需求减少对人民币的需求增加,人民币理所当然地越来越值钱了。也就是说,随着中国经济的发展,人民币对美元的升值是势所必然。

三、汇率升降有没有客观标准?

现在的问题是人民币该升到多少才合适?有的专家说,汇率问题是主权问题,升不升应当由我们国家自行决定;有的专家说,人民币已经在近几年间升了很多,不能再升了;有的专家学者干脆说,人民币不仅不应当升值,还应当贬值,因为贬值意味着我们的产品价格便宜,更有利于抢占世界市场。

如此众说纷纭,老百姓一头雾水。但是,从前文所叙的平等自愿的交换能够促进双方财富的增长这一基本原理出发,我们仍然可以对这个貌似高深莫测的问题找到清晰明了的答案。

任何一方交换的目的从主观上说都不是为了他人,而是为了自己,虽然客观上也有助于他人。对外贸易,如果我们仅仅是把东西卖了出去这还不够,我们还必须把卖东西换回的美元再到美国市场上买回我们需要的东西,这样,交换才算完成。如果只卖不买,那意味着我们的东西倒是给了别人,但别人的东西却没有给我们,这样的交换也许是促进了美国人的财富增长,但却没有使我们自己的财富得到相应的增加。

现代社会已经进入了专业分工的时代,要真正彻底地完成两国之间的交换,既要依赖出口公司也要依赖进口公司。如果出口公司只管把产品卖到国外去,而进口公司却不愿意用出口公司换回的美元来完成进口,则意味着交换并没有完成。有一条标准可以衡量汇率是否正确,那就是出口公司换回来的美元能够毫无障碍地卖给进口公司,进口公司愿意收购这些美元并全部用于进口,此时就意味着交换的彻底完成,也就意味着我们的财富得到了增加,因而这样的汇率就是正确的。

举一个例子可能有助于大家对上面一段话的理解。假定中国某客车厂出口一批高档客车给美国,美国人愿意出100万美元购买,超过了这个价格美国人就宁愿自己制造或者到他国购买。此时,客车厂要不要做这桩生意既取决于制造成本,也取决于汇率。假如客车的生产成本既定是600万人民币,能不能卖的关键就看这100万美元拿回国内可以换成多少人民币。中国是一个外汇管制的国家,客车厂拿到这100万之后,必定会到国有商业银行按照国家规定的比例去兑换人民币,因为按照政府规定的比例兑换人民币比直接与进口企业兑换更加合算。如果按照1美元兑换6.5元的人民币计算,则这批客车可以赚50万元人民币,这单生意当然可以做;假如国家将其更改为1美元只能兑换5元人民币,则这单生意就不能做,一定要做就意味着要亏损100万元人民币。通过这个事例我们可以看出,人民币的汇率越低(也就是1美元能够兑换更多的人民币),比如说1美元可以兑换100元人民币,则出口企业的生意将毫无疑义地兴隆无比。

但是,问题到此并没有完结,人民币不值钱固然有利于我们出口,可攒美元并不是我们的目的,我们的目的是要用这些美元从美国或者世界市场上买回我们国内需要的东西,此时要靠进口企业担纲大任。进口就需要美元,那么进口企业该用什么样的价格向银行购买美元呢?当然是要按照银行从出口企业购买美元的价格执行,并且要加上手续费,否则银行岂不赔本?可是,此时进口企业根本就没有积极性,因为按照6.5元人民币才能兑换1美元的价格来购买美元,进口企业觉得除了少数诸如大飞机之类的高精尖产品之外,其他几乎无论买什么回到国内都不合算。

有两个现象可以作为辅证。一是中国的外汇储备在什么时候会大把用上呢?一般都是某某领导带队去一趟美国或者欧洲,结果回来时往往就签订了大手笔的订单。一般人也许会奇怪,怎么中国的企业家都成了小孩子,该不该进口,难道还要日理万机的国家领导人把关吗?其奥妙就在于,中国的企业用现行的汇率去购买国外的产品大部分都不合算,只有国有企业在政治任务当前的情况下,才心甘情愿或者无可奈何地去充当冤大头!二是中国人出国旅游往往舍不得花钱。旅游者在出国之前往往会兑换很多美元,可是到了美国买一瓶矿泉水也要思量再三,因为我们这些美元是用人民币换来的,当我们使用它时,我们必定会将其换算成人民币而计算成本,可是,这样一计算,我们发现美国的许多产品都比中国贵很多,喝多了矿泉水也意味着不划算,所以他们又把美元带回来重新换成人民币。也就是说,在现行汇率制度下,我们大部分中国人是用不起美元的。

讲完上述例子,读者诸君应当明白这样一个道理,假定汇率正确的话,银行的金库里账号上就不会有太多的美元堆积,因为它们从出口企业处买来的美元早已被需要进口的企业或者出国旅游者买走了,可事实是我们的国家已经堆积3万亿庞大无比的巨额美元,您能说这样的汇率是正确的吗?

四、出口企业是在赚谁的钱?

那么,目前到底应该以多少人民币去兑换1美元才算合理呢?其实,除了市场,任何专家学者都无法解答这个问题。因为市场总是在不断变化的,一个国家对外国资源产品的需求及外国对该国资源产品的需求都是动态的,什么统筹一揽子物品价格来综合计算,什么采用固定的比价紧盯美元的策略,以及将汇率一劳永逸地固定在某个数值上,都可能离真实的汇率差之千里。

正因为市场是处于永恒的变化之中,几乎所有的市场经济国家对汇率都不进行强制干预,也不进行大量的外汇储存,而是让百姓根据自身的需要自由保存与兑换,这样的汇率才能真正反映市场的需求,才能使出口与进口达成平衡,此时的汇率才是正确的真实的,才能真正地促进交换双方的财富增长。也正因为这个原因,汇率是否自由浮动,就成为国际上通行的衡量一个国家是否是市场经济国家的重要标准。

当然,汇率自由浮动,将给出口企业带来风险,比如三个月前是1美元兑换6.5元人民币,于是企业接了一单1000万美元的生意,可是三个月完成加工制作之后,汇率变成了1美元只能兑换5元钱,意味着收入将从6500万元人民币降到5000万元人民币,那么这桩订单完全有可能会从盈利变为血本无归。所以,对于出口企业而言,他们希望人民币汇率起码是稳定,最好是贬值,无论如何也不要升值。

回到前面客车的例子,出口一批高档客车到美国,我们的生产成本是600万元,美国人只愿意出100万美元购买,如果按照现行的汇率客车厂可以赚回50万元人民币。但如果国家放开汇率管制,按照市场需求美元在中国并没有那么值钱,人民币势必升值,假定升值到1美元兑换5元人民币,则客车厂在真实的市场价格下,每生产一批客车,实际上亏损100万元,这单生意其实是不应该做的;但如果政府强制人民币继续贬值,比如贬到1美元兑换10元人民币,则每批客车可以赚到400万元,这对客车厂来说简直就是天上掉钞票。

需要提请读者诸君注意的是,不管美元兑换多少人民币,即便是1美元兑换10元人民币,客车厂能够大发横财,美国人对这批客车也只付了100万美元,我们国家只能凭着这100万美元从美国市场上拿回100万美元的商品。既然美国人没有多付钱,但客车厂却赚得盆满钵满,这钱是从哪里来的?

这钱其实与美国人一点关系都没有,这是客车厂把100万美元交给商业银行按固定的汇率标准兑换来的。中国像客车厂一样的出口企业何止千万,他们因为在现行的汇率标准下有钱可赚,必定会拼命地加大生产出口国外以换取美元,再将这些美元从国内商业银行里兑换出人民币,有钱可赚企业当然会乐此不疲。

问题是,商业银行兑换美元的钱又是从哪来的,按道理应当是来自进口企业对美元的购买,这样一个国家的进出口就平衡了。可前面已经讲过,按照现在的汇率标准,进口企业根本就没有进口的积极性,美元只进不出或者多进少出,商业银行再多的钱也经不起出口企业的兑付,它们就只好把美元卖给央行,因为这个兑付标准是央行制订的。央行本没有足够多的钱来支付,因为央行并不是盈利单位,它除了各商业银行存在那里的存款准备金之外,并没有其他的资金来源,但这并不妨碍央行能够付出钱来,因为央行有印钞的权利。随着出口企业美元的不断流入,央行就开动印钞机按照美元数额的6.5倍印刷人民币向出口企业支付,然后这些人民币再通过出口企业的生产采购环节全部流入了国内市场。

你想想,中国现在的外汇储备已经超过了3万亿美元,那么央行为此多印了多少人民币投放市场呢?心算一下你就能得出已经投放了近20万亿的人民币。其实,还不止这个数,因为以前很长的一段时间里,外汇价格是1美元兑换8元多人民币。一方面是许多东西都运了国外,一方面是国内的钞票在不断印刷,东西少了钱却多了,你现在明白了,为什么我们在国内总是感觉到人民币在不断贬值吗?

五、人民币不升值会有什么后果?

人民币不升值,就意味着出口企业能够生产兴旺,企业有利润,工人不下岗,这对出口企业当然是好事一桩,这也是出口企业言之凿凿反对人民币升值的理由。可是,政府决策不能仅仅考虑出口企业的利益,更多的是要考虑全社会的利益。我们还是来看看人民币不升值会给我们的社会带来怎样的灾难性后果?

一是中国的财富将会源源不断地流向美国,而同等的财富却换来更少的美元,因为汇率偏低意味着我们换回等值的美元需要用更多的东西,说白了我们是在送东西给别人;二是贸易摩擦会越来越多,因为政府不让人民币升值,就只能靠印刷人民币来兑付美元,相当于动用全国的力量给出口企业补贴成本,损害了其他国家与中国出口企业生产能力类同企业的利益,这不符合WTO的规则;三是产业结构将会更加畸形,因为出口企业产品低价贱卖也能赚钱,原本是不应该投产的企业会因为出口换汇带来利润而拼命地加大投资,中央反复提出的所谓减少出口增加消费为目标的经济结构调整终将化成泡影;四是随着世界金融危机的不断缓解,国外的消费能力已逐步恢复,出口增多则美元储备还会继续增多,为了兑换美元只好大量发行人民币,国内通货膨胀自然是卷土重来愈演愈烈。

有的人看到这里,或许还心存侥幸,人民币不升值毕竟使我们中国的外汇储备坐上了世界第一把交椅,这说明我们中国现在有钱了,再也不像从前那样积贫积弱了。然而,天量的外汇并不意味着我们已经财富在手牢不可破,它同样面临着不断缩水贬值的可能。

当我们刻意用偏低的汇率来换取外汇时,攒钱的过程中我们用更多的东西换来更少的美元,这意味着在做生意的时候就已经吃亏了一次;当我们用外汇储备来购买美国的各种基金股票时,基金股票价格大跌(如黑石基金)又让我们损失了一次;当我们用外汇储备来购买各类债券时,因为这些公司(如房地美、雷曼)的破产或亏损我们又损失了一次;当我们用1/3外汇储备来购买美国政府债券而自以为高枕无忧坐收红利时,美国政府正在深陷债务危机,其信用等级被中介机构下调,这些债券在出卖转让时价格又将下降,这意味着中国人的外汇又将大幅度地缩水。以上几个方面的损失动辄都是天文数字,有兴趣的读者可以上网查查相关资料。

更令人尴尬的是,现在我们已经陷入了一种进退维谷的两难处境,因为我们的积攒的美元实在太多,为了保值我们用它来买了许多美国公司的基金股票和美国政府的债券,现在我们是买什么,什么就一路高涨,我们想卖什么,什么就一泻千里。表面上看我们的确是拥有天量的外汇储备,但如果有一天我们真的需要把这些基金股票债券变成现金的时候,这些金融产品的价格无疑会大幅下跌,其损失恐怕难以估量。

最需要说明的是,中国是个穷国,最多也只能算是个发展中国家,这3万亿的外汇储备意味着中国人已经送出了超过20万亿人民币的财富给美国,而我们却没有从美国人那里拿回相应的财富,美国人只给了我们一张3万亿的借条,甚至连借条也谈不上,因为美国人并不因此给我们利息,而且美元是美国这个主权国家有权不断印刷使之不断贬值的。

当然,这并不能去责怪美国人黑心,美国人支付了美元就意味着他们愿意与我们交换,问题是我们的汇率制度使中国人无法去使用这笔钱,这样的制度不应该改革吗?

六、解剖几个迷惑大众的典型问题

看了上述讲解,也许有人不免满腹狐疑,既然中国现行的汇率制度对美国人有利,为什么美国人反而喋喋不休地要求中国人民币升值呢?难道美国政府是活雷锋!

从整体上说,人民币不升值固然有利于美国人的利益,但是同样也会损害另一部分美国人的利益。他们是谁?他们就是与中国出口企业生产同类产品的美国企业。如果人民币升值,中国的产品远渡重洋去美国就没有了竞争力,但由于人民币汇率低估或者说中国人以国内通货膨胀为代价支持了这些产品,使他们有绝对的竞争优势而能够轻而易举地打败美国产品,从而使美国的同类企业减产倒闭和工人降薪失业,这就是为什么东西便宜卖给别人,反而会遭到别人反对的真实原因。大家要注意的是,这前后两个别人是有区别的,前面一个别人是美国的消费者,他们希望中国人的产品越便宜越好,他们并不反对甚至是支持人民币不升值;后面一个别人是美国的同类企业和隶属于这些企业的产业工人,他们因为工厂倒闭或减产,使自己的收入不断减少,他们当然会呼吁美国政府要对中国的汇率政策予以干预,他们是中国不正确汇率政策的受害者。美国的政体众所周知,官员们不可能不要这一部分选票而置这些人的利益于不顾,而且这些人受到的伤害正在发生,因此他们的反对比一般消费者的支持更加坚定强烈。所以说,正确的汇率利人利己,错误的汇率害己害人!

再看一则流传甚广的反对人民币升值的笑话:2010年,一美国人到中国旅游,用10万美元兑换到68万人民币。在中国吃喝玩乐了一年,花了18万人民币。2011年,他要回去了,到银行去,因为人民币兑美元升值到1比5,这位美国人用剩下的50万人民币换回了10万美元。来时10万美元,回去还是10万,潇洒一年,毫发未损,高高兴兴地回家了。

不懂汇率的人看了这个故事,立即对人民币升值深恶痛绝嗤之以鼻。这个笑话从逻辑上来说并非杜撰,故事完全有可能在现实中发生,这也是国外热钱不断涌入中国的原因。但是,造成这样啼笑皆非的结果,是应当怪美国人乘隙而入,还是应当反思我们汇率制度的颟顸僵化。人性总是自私的,中国人外国人并无区别,当我们人民币不升值而导致经济结构混乱和国内通货膨胀不断加剧时,外国人断定这种荒唐制度不可能长久维持,因此将热钱引入中国而大赚一把。面对热钱的不断涌入,我们现在用的是两招笨拙的方法,一是堵住不让进,但是中国的金融市场正在不断开放,地方政府的招商引资仍是如火如荼,堵是堵不住的;二是坚持不升值,但这样做只会导致中国的外汇储备越来越多,通货膨胀更加一发不可收拾。说穿了,在现行的汇率制度下,如果我们不想热钱涌入而使外国人大发横财,我们就必须面对经济结构严重混乱和通货膨胀肆虐横行的苦果。不要怪美国人太狡猾,实在是中国人太无知!

再顺便为读者解答两个热点问题:一是为什么我们的外汇储备总是以美元为主,而无法多元化,比如多储备一些欧元、英镑或者瑞士法郎等?二是为什么人民币很难国际化?

先解答第一个问题。前文已经说过,由于人民币被低估,出口企业赚取美元再回国兑换人民币非常合算,所以出口企业非常愿意用美元结算。同样,与出口企业作贸易的外国企业也愿意用美元结算,因为他们要赚人民币更是难于登天,而中国的产品用美元购买他们觉得非常便宜,买卖双方如此情投意合,流入中国的美元自然是越来越多。更何况对企业来说,美元是世界通行货币,用美元买卖方便无碍,所以即便是与欧洲国家做生意,他们也是用美元或者换算成美元来计价与结算的。至于第二个问题,本质上与第一个问题异曲同工,既然出口企业以及与出口企业做生意的外国企业,都觉得用美元结算比用人民币结算更便宜,谁还会用人民币来结算呢?即使是央行采取非常行动,白送或者白借一些人民币给其他国家,当这些从天而降的人民币用完之后,买卖双方还是要回归美元结算,除非,央行不断地将人民币白送下去。因此,汇率制度不改,人民币国际化就永远无望。

还要告诉大家一个令人丧气的消息,那就是中国这几年所谓引进和利用外资不断增长的成绩其实都是假的,至少成绩是没有像舆论宣传中那么巨大。表面上看我们是引进了不少外资,每年在数字上都有增长,但这些外资根本就没有得到利用,因为,这些引进的外资与我们做出口贸易的得到外汇并无本质区别,这些外资引进之后并没有被进口企业所购买,用以进口外国的产品以支持国内建设,而是躺在了外管局的专门账户上,再经由央行印刷人民币来兑换。说白了,外资是引进了,但没有被真正利用,只是外管局账户上多了几个数字或者库房里多堆了一些花花绿绿的美元纸张。

严格地说,中国在近阶段根本就不需要再提供特别的优惠政策来引进外资,自己的外汇都达到了3万亿,已经到了不知道怎么用不知道放哪里的程度,地方政府还在不遗余力地为引进所谓外商投资而在税收、土地、环保等方面提供空前优惠,真是一个天大的笑话。

七、外管局的观点为什么是错误的?

如果大家认真地阅读了前面的系统阐述,那么相信大家都能对巨额外汇是不是老百姓的血汗钱已经心中有数。

从表面上看,出口企业用外汇换取人民币,商业银行都是支付了人民币的,商行没有不劳而获;而商业银行再拿外汇到央行来兑换人民币,央行也是支付了真金白银的,央行也不是巧取豪夺,这正是央行说巨额外汇不是老百姓的血汗钱的直接理由。可是,通过学习前面知识,我们已经明白,央行所支付的钞票是毫无节制地开动印钞机印出来的,本质上就是通过全国人民的通货膨胀来兑换外汇,这外汇不是老百姓的血汗钱又是什么呢?

外管局为自己申辩说,这是央行对全社会的负债,意思是当中国人要用手中的人民币来购买外汇时,央行还是要把多印的钞票收回,而把手中的外汇还给老百姓的,正所谓欠债还钱。这理由看似成立,但问题是只要汇率制度不改,这一天就永远也不会到来。再退一步说,就算负债之说能够成立,笔者想问,这笔债的债权人是谁?归还期又是哪一天?世上哪有这么好的债务,既无明确的债主,又没有确定的还款日期!难怪外管局对欠上这样的债务锲而不舍绝不放弃。

那么,外管局说巨额外汇不可用来分发给百姓,或者用来作为养老基金改善民生时将会导致通货膨胀,这个理由又是否成立呢?

从表面上看,这个理由是成立的,因为美元是无法在中国流通的,当外管局把天量的外汇无偿分给百姓时,百姓势必要拿这些美元到银行兑换,银行无法将这些外汇卖给进口企业就只好再卖给央行,而央行无力支付就只能再一次开动印钞机,这样国内的通货膨胀当然是雪上加霜。乍听之下,央行的解释非常有理,但如果我们更改一下思考问题的角度,说央行杞人忧天一点也不为过。

美元在国内的确是不能流通,的确是不能用于百姓的购物或者投保,但是,美元却是可以在美国乃至世界各地能够买到东西的货币,有人想购买或出售,必定会有人会出售与购买,市场的流通便能解决任何企业与个人的兑付问题。只要中国政府放弃固定的汇率政策,或者说央行不要用高于市场价格的汇率扰乱市场,中国的百姓分到了美元自会以合适的价格卖给了正在准备进口的企业,进口企业自然乐意用比现行汇率更低的价格(即等值的人民币兑换更多的美元)来换取自己需要的外汇,然后再用换得的外汇购进中国市场急需的商品。如是此,外汇就完全可以用来促进内需和保障民生,也绝不会带来新的通货膨胀。

可以预料的是,百姓分得美元后,美元在国内的价格一时会陷入混乱,有人贱卖,有人贵买,但经过一段时间之后,美元在中国的阶段性均衡价格必定会产生,这样一来,固定的汇率政策必定土崩瓦解,外汇的兑换就只能由买卖双方或者说由市场来确定了,届时企业出口或进口是否值得就有了真正的市场标杆。

八、未来汇率制度改革路在何方?

中国的许多问题,原本只属于经济策略,完全可以充分地讨论争议,然后寻找最佳之策。但是经济政策一旦沾上政治,说白了就是某个领导人针对某一现象发表了意见,整个中国的舆论立马会千人一面众口一词,无数的下级会主动自觉地为上级的论点寻找支撑的论据。

曾几何时,中央领导关于人民币升值问题的强硬态度一经发出,各类媒体便立即行动起来,各路专家纷纷义正词严地谴责美国的霸权主义行径,找一些似是而非的理由混淆视听。有的节目主持人其实自己也没有完全明白汇率的原理,就迫不及待地开始声情并茂的爱国表演。

经济界常有一些令人啼笑皆非的事情,比如,凯恩斯说经济萧条时,政府可以雇一批人白天去挖沟,再雇另一批人晚上去填沟,如此反复循环,然后给他们发工资,这样就可以拉动消费。拿这样的理论去诓骗一个在田间除草的老农,一定会被老农笑掉大牙,因为在他眼里这是浪费,是傻子行为,如真想照顾百姓,直接发钱就是,何必浪费力气挖沟。然而,就是这样一些违背常识的理论,却深得世界各地政府官员的赞赏,也被中国政府各级官员奉为圭臬,其背后的根源不是官员们不懂常识,不知道政府花钱的浪费巨大与效率低下,而是这一理论为官员们干预经济从中谋利找到了理由与借口。

汇率的问题大概也不例外。天量的外汇聚集于央行掌控于外管局,这对于这些部门是不是一件利益巨大的事情,相信读者朋友心中自有分寸。可以看见的事实是,央行的所谓专家学者,没有一个不是反对人民币升值的,意见高度一致,态度斩钉截铁,这其中显然是屁股决定脑袋的原理在起作用。这些专家学者提出的一些貌似逻辑严谨振振有词的问题,只要广大读者认真理解了本文前面的文字,一定可以在其严丝合缝的逻辑当中找到不堪一击的软肋,有兴趣的读者可以自行去分析评判。

最让老百姓担心的是,如果让人民币升值(至于是缓慢升值还是一步到位那是方法问题),出口企业岂不倒下一大片?倘使人民币缓慢升值(比如就像某些专家建议升值2%),企业就无利可图,那说明,这家企业其实早就应该倒闭,它此前所以还能盈利,并不是美国人给了他们利润,而是全国人民通过通货膨胀养活了他们。至于工人们,倘使政府真心要帮助他们,简单易行的办法是把钞票直接发给他们,让他们趁早转行,把青春年华用到国家更需要的行业里,国家何必为此苦苦支撑起一座座亏损的工厂,何必把大量的财富白白送给外国人呢?

倘使汇率最终上升至市场认可的真实汇率,则广大企业都会依据真实汇率调整自己的生产行为,该出口的就出口,该进口的就进口,中国的有限的资源秉赋就不会被低价贱卖,就能得到了合理高效的使用与分配,中国的产业结构才可能得到实质性调整,中国经济才可能从此凤凰涅槃浴火重生。

其实,现阶段即使缓慢升值也是权宜之计,因为,正确的汇率最终来自于市场调节,要想提高效率,使中国经济彻底摆脱出口依赖转靠内需促进,唯一的出路是取消外汇管制,破除固定汇率制度,让各种外币与人民币自由兑换,让进口企业的创汇与出口企业的购汇自由选择平等竞争,市场自会找到一条正确的汇率之途。

对汇率问题的错误认识并以讹传讹,一些所谓的经济学家扮演了摇旗呐喊推波助澜的角色,历史终将会证明他们不唯实只唯上的错误,并将他们钉在学术良知的耻辱柱上。在此,笔者愿意从良知出发,从常识出发,系统地为大家讲述汇率知识,期望读者诸君能够明察秋毫明辨是非,也期望就教于各位专家学者大方之家,更期望有一天能够名正言顺理直气壮地走上国家外管局的讲台。

倘使大家觉得阅读本文后对汇率知识有了更加系统更加彻底的了解,倘使大家觉得本文条理清楚逻辑顺畅,倘使大家觉得采用文中观点制订汇率政策有助于中国经济的产业调整与健康发展,有助于减少中国人的财富和中国人的血汗不被莫名其妙地白送他人,那么,请互相转发,请留言支持,请呐喊声援!

附:本文刚刚落笔之际,网上又传消息,中国7月份外贸顺差314亿,创30个月来的新高。当看到媒体以欣喜的态度向国人报告时,笔者心中默算,中国大陆仅七月份一个月又减少了2000亿元以上(314亿美元按1比6.5元人民币计算)的财富,而央行又将投放2000亿元以上的人民币到国内市场,物少钱多,如此下去,通货膨胀何时才是尽头?明明是血汗财富廉价送人,明明是以国内物价上涨支撑商品廉价出口,不以为忧反以为喜,实在叫人忧思愤懑欲哭无泪……

分类
其他

2016-01-18-滚蛋吧肿瘤君-观后感

2016-01-18-滚蛋吧肿瘤君-观后感
下班之后在手机上看了<滚蛋吧肿瘤君>, 感觉挺不错的.
感觉这部电影至少有以下几个好处:
1. 就电影本身,节奏连贯,情节也很合理.
2. 能够引起一部分普通人对癌症患者的关怀.
3. 能够引起一部分人对死亡的思考.
人生其实只有两件大事: 出生和死亡. 但是大部分人生活的态度就好像他们永远不会死一样, 从来不去考虑死亡的问题. 事实就像电影里面演的, 死亡常常会不期而至. 如果不去思考死亡的问题, 当死亡降临的时候, 你就会感到愤怒, 无助, 绝望以及无尽的痛苦. 相反 如果你认真的思考过死亡, 并且能够坦然的面对和接受死亡随时可能降临这件事, 当死亡来临时, 你就可以很坦然, 就像进入睡眠一样安详.

分类
其他

2015-12-04-对演员的看法

2015-12-04-对演员的看法

看到朋友圈一篇写基努里维斯(黑客帝国里面演neo的男主角)的文章
http://mp.weixin.qq.com/s?__biz=MjM5OTcxMDQwNQ==&mid=400670594&idx=1&sn=14f74cde13ce8ac669c119798ae8888a&scene=1&srcid=1202BH4uS0KQdUGxTqYtTgqM#rd

这是我的看法:

难道他有什么新片要上映? 不知道为什么看到这种把一个演员吹的高大上的文章时,我的第一反应总是: 真的假的,是不是为了宣传新片? 可能是传统观念的影响,也可能是中国演艺圈给我的印象,我总认为演员不是一个值得人尊重的职业,从传统的角度讲,有句老话叫婊子无情戏子无义,从现实的角度讲,至少中国演艺圈的演员大部分都只能算戏子(如果说婊子说的太重的话)。还有一点,演员的职业就是要表演伪装成要求的角色,这种职业会让演员或多或少的养成伪装和做作的习惯,可能到最后别说外人,连他自己都不知道自己什么样。我之前看到一篇吹捧林志颖的文章,叫什么梦想家林志颖,初一看,你会说,哇,真牛,什么台湾赛车手冠军之类一堆的光环; 仔细考究一下,原来不过是一个业余赛车手的非正式比赛的冠军,其他的光环也是一样经不起推敲。当然这可能不是林志颖本人或者团队写的文章,但是他的粉丝们在他们的有意或者无意的误导下形成这样的印象,他们肯定有欺骗的嫌疑。他们这样做可能是为了名利,这也是我讨厌演员的另外一个原因,演员更注重名利,不仅仅是因为他们要耍大牌,更是因为演艺圈的规则就是名气越大,你就越可能得到更多的机会。正是因为这个原因,演员明里要不择手段的吹捧炒作潜规则来获得更大的名气,暗里就去吸毒嫖娼出轨来堕落的放纵自己。。。

以下是原文
——
他是好莱坞最穷的巨星,50岁依然孤身一人只为逝去的妻子孩子…

2015-12-02 妈妈天天看 牛奶母婴精选
你曾经喜欢的电影里,有他的身影。你却永远也不知道,他的一生是这样的坎坷。如果可以,他说希望拿一切来换取他最重视的那个人。。。

说到好莱坞的帅哥,你最先想到谁?

是年轻时美到没朋友的小李子?

还是碟中谍里面的硬汉汤姆克鲁斯?

或者是这位胸大诱人的美国队长?

无论是上面哪一位,他们都坐拥千万粉丝,身价不菲,过着忙碌却富裕的生活。

今天我们来说说这位最穷的好莱坞巨星,基努里维斯。

在很多人眼里,他是世界级的演员,他应当有着光鲜亮丽的人生,但如果有真人秀般的比惨大赛,我相信他能得到冠军。

基努里维斯的妈妈是英国人,父亲是夏威夷华侨,因此基努也有八分之一的中国血统,难怪他的脸庞相对其他好莱坞男星,更有一丝东方韵味。

基努的爸爸在他幼年时期便离开了他,因为贩卖毒品而进入监狱。

而基努的妈妈是一名脱衣舞娘,在酒吧里和基努的爸爸认识,两人在一起后生下了两个孩子:基努和他妹妹。

后来,妈妈带着两个孩子改嫁,母亲之后不停离婚结婚,再离婚再结婚,先后又嫁了三个丈夫。基努的童年是在动荡和不安中度过的,那时的他,和妹妹相依为命。

16岁那年,基努拍了一支可口可乐广告,正式踏入演艺圈。随后的几年里,他得到的都是不温不火的小角色,而他一直苦于无法寻求角色突破。

直到1991年,他出演了一部电影——《我自己的爱达荷》,片中他演一名富家子弟,却沦落街头当男妓。该片成为很多人心目中最经典的90年代同志电影。

在拍戏之余,他收获另一位挚友—— 瑞凡·菲尼克斯,瑞凡也是该片的另一位男主角。

由于家庭极度贫困,童年的瑞凡也过得非常艰难,也许是在彼此身上看到了太多对方的影子,两个人迅速成为好友。瑞凡也凭借该片成为史上最年轻的威尼斯影帝。

那时的基努和他几乎无话不谈,记者断定瑞凡将是世纪末的好莱坞巨星。

然而2年后的一天晚上,约翰尼德普举办万圣节派对,瑞凡被邀请来参加。派对结束后的半夜,瑞凡被发现倒在人行道,已经死亡,死因是吸食毒品过量。原来在拍《我自己的爱达荷》时,瑞凡和基努在配合角色需要的同时,都沾上了毒品。瑞凡死后,基努痛不欲生,当即发誓永远不沾毒品,一直遵守诺言至今。

一年后,基努主演的《生死时速》上映了。当年这部电影获得了巨大的成功,票房高达一亿二千一百万美元,那一年,有人形容他:天神在你眉宇之间。基努的事业达到了巅峰期。

基努至今唯一承认的女友叫珍妮弗塞姆,1999年,她怀孕了。而8个月后,孩子腹死胎中。这对基努和女友的打击都是相当沉重的,但这并未组织基努对她的爱,那时候他们已经准备结婚。

然而没多久,女友塞姆在一次严重的车祸里丧生,在拍戏的基努立即请假赶回来。警方在塞姆的车上发现了很多抗抑郁的药物,大家纷纷猜测是孩子的死对她打击太大,女友得了抑郁症。

在葬礼上,基努没有顾忌太多,和女方的亲友一起抬灵柩。那时他并未和女友完婚,一般情况下,为了避免不吉利,是不需要抬的,但基努一点也不顾及这些。

塞姆的家人很感动,在讣告中称基努为「the love of her life」(她生命中的爱)

随后,失去了挚友和挚爱的基努再次受到沉重打击——从小相依为命的妹妹得了白血病。话说这真的不是韩剧吗?我写着写着都要哭了啊!!!基努用拍戏的片酬送妹妹到全世界最顶级的医院,而医生告诉基努,妹妹的情况很不乐观。当时正在拍《黑客帝国》的他决定退出演艺圈,专心照顾陪伴妹妹。

连续4年内,孩子腹死胎中、女友车祸去世、妹妹得了白血病,基努的心境几近崩溃。然而此时他的事业迎来了第二个巅峰,1999年的《黑客帝国》找到了他。2003年,第2、3部续集连环推出。这三部戏让基努里维斯成为了真正的好莱坞巨星。

当时票房几亿美元的这位好莱坞巨星被拍到在街头一个人走着,记者连续拍他几天他都浑然不知,鞋子开口了,他居然用胶带绑着出门。

《太阳报》笑话他:一个赚钱那么多的大明星,怎么是这副穷酸样?(当时那张照片找不到了,但基努真的是十年如一日穿的很朴素,现在被记者拍到依然是这样)

拍《地狱神探》时,片场人员说在拍戏空挡,除非要和导演讨论,其他时间他都是一个人默默的看着地上发呆。后来,他决定将拍摄《黑客帝国》收入的70%捐献给了治疗白血病的医院,或许是失去的太多了,他帮助别人不要再失去更珍贵的东西。

就这样一位高票房高片酬的男星,39岁的时候才买了第一套房子,在此之前他经常睡朋友家地板,也在一家汽车旅店住了九年。

作为一位好莱坞巨星,他的身边从来不跟保镖,身上不穿大牌衣服不用大牌钱包。47岁生日那天,他衣衫褴褛地坐在马路边吃自己的蛋糕,蛋糕上还插着一根生日蜡烛,有粉丝走过来聊天,他便把蛋糕和他们同分共享。

拍《魔鬼代言人》时导演抱怨另一位主演片酬太高,电影经费紧张,基努主动拿出100万美元给剧组。

一年前,基努受邀去出席《Daughter of God》的派对,派对在纽约的夜店举行。基努私下很不修边幅,导致工作人员都没认出他。他一个人冒雨傻等了20分钟,最后夜店老板发现了他,后来店员告诉记者:基努当时很狼狈的样子,但为人非常随和,没有发脾气。

在采访节目里,主持人问他对自己的事业如何看待,他沉默了一会后回答:“宁愿拿现在的一切去换取还没出世的女儿和她妈妈的生命。”

曾经和基努在一个剧组的场地记者说:基努是他遇到过最不耍大牌的巨星,他对所有人都是彬彬有礼的,甚至在休息空挡分担他们的工作。

曾有位美国女网友发帖说,当她的车子抛锚,搁在路边时,基努主动停下车,帮她打电话叫拖车,然后送她回家。整个过程,他没有任何的企图,只是为了帮人而帮人。

基努说过,他这辈子的凡事已了,把所有的都已看淡。在美国,有人坐地铁碰到过他,一般好莱坞巨星谁会挤地铁,只有他会。

也有人拍到他乐善好施的画面,由于是抓拍,因此画质不清楚。ps:基努这可不是炒作,在接拍《黑客帝国》以后,他就基本上不接商业大片了,更不需要进行炒作人气。

照片里,他把腰弯的很低表示尊重

他是好莱坞亿万票房的巨星,曾经失去了挚友,失去了孩子,失去了挚爱,家庭也支离破碎,但对于现在,他是一个知足常乐的人。他没有任何偶像包袱,他愿意席地而坐与流浪汉分享啤酒。

也有网友拍到他在地铁给人让座。
图一:基努问背着大包的女人需要座位吗?
图二:基努让开座位站了起来。
其实基努不知道这些都被网友录了下来发到网上

基努爸爸是夏威夷华侨,在夏威夷语里,基努的意思是“吹过山头的清风”。
许多年前你曾是个不知何为愁滋味的微笑少年。

如今的基努已经51岁,依然未婚。在娱乐圈,长得帅的人千千万万,演技好的人万万千千,但有几个人像他这样乐善好施、淡泊名利?

愿你的内心永远纯真。

分类
其他

2015-05-27-天龙八部-男人的幸福

2015-05-27-天龙八部-男人的幸福

天龙八部感想
原文:
——–
萧峰哈哈大笑,说道,”是了,萧某不再是孤孤单单,给人轻蔑鄙视的胡虏贱种,这世上至少有一个人…至少有一个人…”一时不知如何说才是。
阿朱接道,”有一个人,敬重你,钦佩你,感激你,愿意生生世世,永永远远,陪在你身边,和你一起抵受患难屈辱,艰难困苦。”说得诚挚无比。
——–
感想: 金庸真是大家, 洞悉人性, 任何一个男子如果有一个能够敬重他钦佩他, 那么人生就幸福了.

2016-05-24补记: 其实如果怎么怎么样,那么人生就幸福了是一种幻觉。因为这个如果总是达不到的,真正的幸福是不依赖任何外在条件的。按照我现在的理解,真正的幸福就是安住于当下。

分类
其他

2015-03-30-关于爱国

关于爱国,我一直是认同卢梭的观点,”爱国主义是流氓的最后庇护所”。我的理解是爱国是分辨一个人头脑是否清楚的试金石。如果你说你爱你的孩子,你的父母,你的亲人,很好理解; 如果你说你爱土地,爱钱,爱金银财宝,也很好理解; 如果你说你爱中国的历史,爱中国的文化,爱所有的中国人,也能理解; 但是你说爱国,那是什么意思吗呢?这个国家是你的么,皇帝或者皇后陛下? 你甚至不了解这个国家,就像一个段子里面说的,一旦你开始了解这个国家,你就走上了犯罪的道路。以前南方周末上有篇文章叫”爱国不等于爱朝廷”,我觉得很值得一看。如果你坚持要爱国,也请想清楚,不要被忽悠成爱朝廷或者更糟糕的爱党了。当然这篇文章里面的爱国显然是指的爱中国人,这虽然有些简单粗暴,因为中国人里面也有坏蛋,但是就像文章所说的这是一种本能,爱就爱吧。。。

下面是原文:

爱国也是常识

2015-03-30同人于野罗辑思维

可能是为了暗示他们也会跟普通人聊天,或者出租车司机是他们唯一有机会与之聊天的普通人,中国文化人都喜欢引用出租车司机的话。与一般人写文章都是称赞出租车司机的口才和见识不同,《南方周末》上梁文道的文章《爱国不忘爱己》,描写了一个“逻辑奇怪”的出租车司机:

那位司机从沿途不断的收费站开始骂起,最后数到公费开销的浪费与贪官派人截访无告民众的可恶,这社会几乎没有一件事能令他满意,自己则处处受到不公的待遇。但奇怪的是,话锋一转,他居然盼望政府早日武力解决台湾问题,还说要是美国胆敢介入,就要迎头痛击,让他们知道谁才是世界第一强国。

你自己都自身难保,为什么还这样爱国?梁文道说,“西方的自由主义传统一直不大明白平民百姓的爱国热情究竟是怎么回事”。爱国似乎是一种非理性的愚蠢行为。但梁文道有一个比西方的自由主义传统更好的理论。他举了二战时期日本的例子,认为爱国其实是为了获得一点尊严。“融入大我的崇高可以消弭个人生活上那微不足道的缺陷。”然后梁文道表示自己“同情地理解这种尊严的追求”,但仍然希望他们最好还是能先去追求自己的生活再说。

这个理论不能解释为什么那些在生活中很有尊严的人也爱国。实际上,有统计表明(Super Freakonomics),最爱国的那些人,也就是那些参加革命的人,那些选举的时候出来排队投票的人,和那些参加恐怖组织的人一样,并非来自社会底层。大多数黑社会成员出身于贫寒家庭。大多数罪犯出身于社会底层。但大多数最爱国的人出身于社会中层。他们往往受过平均程度以上的教育。他们不缺尊严。实际上,美国的爱国者比例绝对不比中国少。

一个不走运的出租车司机不见得是最爱国的人,但他也爱国,而且原因跟别人没有什么区别,爱国是人的一种本能。现在我来分析一下爱国心理学。

爱国心理起源于“认同感”心理。美国德克萨斯州曾经一度被公路上开车者从车中乱扔出来的垃圾所困扰。政府想了各种办法,比如说罚款,后来又在电视里播放教育人们爱护环境的公益广告,但是都不好使。德州的人都很有牛仔精神,认为跟警察对着干很酷,而且可能还认为女人才担心环境。最后起作用的公益广告,它的广告词是这样的:“真正的德克萨斯人不开车扔东西”。(此故事来自 Made to Stick 一书。)

也就是说这个广告跟论坛上“中国人必看”,“是中国人就顶”这种标题党一样,利用了德州人以自己是德州人为荣的这个心理,人们就是这样不讲理地以自己的身份认同为荣。

爱国思想的本质其实就是民族优越感,英文文言文叫做族群中心主义,ethnocentrism。那么为什么会有这种莫名其妙的认同感?这种认同感是非理性的么?这个心理学家可能不好解释的问题,可以用计算机模拟的方法解释。

Brookings Institute 的 RossHammond 和密西根大学的 Robert Axelrod 在2006年做的这个模拟实验,现在已经成了学术界的经典。实验用计算机模拟一个世界上有这么多人,这些人每天随机地交往。交往的规则是如果双方都合作,那么双方都受益,但每个人都有可能通过欺骗对方来使自己得到更多好处,也就是说他们每天的交往都面临“囚徒困境”。如果每个人都没有任何信息来判断对方是否值得信任,那么显然这个社会的一切交往都只能靠运气。

有意思的部分是这样的。程序完全随机地把全体人员分为四组,然后给每组人“刷”上一身颜色。设定其中每个人都可以给自己选择一个策略,利用这个策略来判断自己到底是选择合作还是欺骗一个人。同时,每个人都可以借鉴学习别人的成功策略,这样好的策略可以流传开来。可供选择的信任策略包括:

1.完全随机地决定合作还是欺骗

2.与跟自己颜色相同的人合作,欺骗跟自己颜色不同的人

3.与跟自己颜色不同的人合作,欺骗跟自己颜色相同的人

实验结果是这个本来随机的颜色划分的确把人分成了不同的族群。一开始可能是几个同一颜色又恰好采用第二条策略的人偶然凑在了一起,他们这个小组因为总是互相合作而受益了。然后其他人会学习这个策略并加入这个小组,这样小组就会越来越壮大。只有这第二个策略会导致这种正反馈。最终,哪怕是那些采取“民族虚无主义”,也就是第一个策略的人,也混得不行了。

这个实验相对于真实世界显然是特别简化的,但它说明了一个重要事实:民族优越感其实就是一个促进合作的机制。如果你在淘宝买东西,一家店主表示自己很爱中国,另一家店主表示自己不爱中国,而你恰好是个中国人,请问你更信任哪家店呢?

多年进化的结果,这种合作与欺骗的爱国算计很可能已经进入人的潜意识,成为感情的一部分,甚至变成了一种原始的冲动。当我看到中国队跟别国比赛,我本能地就支持中国队。这跟崇高可能没什么关系,就好像看到美女产生的原始冲动一样。

现在回到那个被梁文道“同情”的出租车司机。在这里,文人“奇怪”他的原因可能不是他希望打台湾,而是因为他在国家对不起他的情况下还爱国。但科学事实是爱国是一种原始冲动,跟国家对不对得起自己没关系,这就好比说爱不爱美女跟自己想不想要孩子没关系一样。

正如美女令我们产生的原始冲动有可能导致犯罪,爱国这种原始冲动也有可能导致军国主义和种族歧视。但是你不能说爱国很奇怪,正如你不能说喜欢美女很奇怪。

在这个连同性恋都理直气壮的时代,爱国有什么不能光明正大的呢?

非常感谢大家创作或推荐好文供大家分享学习,有关稿费支付及知识产权事宜请发邮件至dushuren@luojilab.com。

政治和商业,所有超越个体的事,都需要一个基础能力——

为他人重新定义一个“我们”。

我们是中国人。

我们是劳苦大众。

我们是某品牌的用户群。

等等。

这些概念都不是天生的。

和“国家”一样,它们都是“想象的共同体”。