[OOL]part 7: 基本概念

纯面向对象语言: Ruby

1.纯面向对象语言：所有的值都是对象

2.class-based: 对象都是类的实例

3.mixin

4.dynamically typed

5.reflection

6.有blocks和closures

7.是scripting language: 写小程序，性能相对差

duck typing: If it walks like a duck and quacks like a duck, then it’s a duck.

     方法中传入的参数不重要，只要参数能处理所有特定的message。

     比如对于a.x = a.x + 1,只需要a有.x和.x=，并且.x的返回值有能处理.+(1)。

     缺点：对象的意义来自于使用它的地方，那么就不能轻易的改变其使用的方式了，如i + i不能轻易换成i * 2

dynamic dispatch: late binding, virtual method call

     A > B时，A.fun使用的是基类B的函数，但是对于函数里所有的self.xx，均调用的是A的

     原理：self对应于当前的对象，即A的实例。通过self找变量，类变量则是通过self.class找到的

               当调用e0.fun(e1..)时:

               1.将ei求值为obji

               2.e0的类为A，如果fun在A中，调用这个方法，否则在基类里寻找

               3.当evaluate fun的时候，self对应的是obj0，所以fun中所有的self.xx都对应的是obj0.xx

一些 术语：

     methods, variables

     对象之间的通信：通过调用方法，也叫作sending a message发消息。调用了e0.m e1，这里e1发送消息m给e0, 参数是e1。e0是receiver

     instance variables: 用@访问。mutable, private

     class variables:用@@访问。private，shared in class

     constructor/method initialize: A.new(…)

     class constant: 大写字母开头, 不能修改，publicly visible

     class method

     getter/setter: attr_reader :y :z（y和z只有getter）, attire_accessor：有setter也有getter

一些 语法：

     语法和Python很像

     换行很重要，缩进不重要

     false 和 nil都是false

     能定义以=结尾的函数

     e1+e2是e1.+e2的语法糖

     puts是Object的函数，所以puts=self.puts

     instance/class variable不需要声明就可以使用，第一次的赋值会创建

     self

     top-level method: 在类之外的函数定义都会被加到Object中去

     top-level expression: 在运行的时候会依次evaluate

类是能动态修改的（加，减函数）

class的class是Class

Array: […] 数组类

     可以传blocks。Array.new(5) {|i| -i}=>[0,-1,-2, -3,-4]

     和python一样，可以有负数下标

     没有Array bound error，只会扩充数组，中间填充nil

     可以替代：triple, stack, queue

     可以理解成key是数字的map

Hash：{‘1’ => 1, ‘2’ => 2} 字典

     key可以是任何东西

Symbol: :xxx

     更快，类似字符串

Range：1..100 一串数字

     比 Array.new(100) {|i| i}更高效

Blocks: {…}，几乎等同闭包

     int.times + block

     [].each / inject(类似fold) / select(类似filter) / any? / all? + block

     不是object，不能作为参数传给函数，不是first-class values. 函数能传入0或者1个block

     使用block: method中使用yield调用闭包。yield+参数，则block传入参数。

                       无法直接将block拿到，作为参数递归的传下去，可以通过{|x| yield x}传。如果传入的不是Block而是Closure就可以直接传了

Proc: lambda {...}

     closure。调用方法是x.call(…)。lambda不是keyword, 而是Object中的一个方法，输入是一个block，输出是Proc

     可以存在数组里，作为参数传递。。。

     [].map {|x| lambda {|y| x >= y}} 将得到一个Proc的数组，数组中的每一项都接受一个参数y，并返回a[i]是否>=y

Inheritance: 子类能extend（加新方法）或者override老方法

     class A < D

     object is_a? 某个类及其子类

     object instance_of? 只是某个类

     super keyword