Method

a)  定义：

　　def 方法名 (参数)              #在ruby中方法的参数可以不加括号

       　　#do something

　　end 

　　注：方法名命名规则：以小写字母或者下划线开始，后边跟数字，字母和下划线，单词之间用下划隔开:

      def hello_world

             puts “Hello world”

　　end

　　方法名后边可以跟=,  ?, !

　　“=”: 表示该对象的参数可选，若调用时，没有参数，则使用默认的

　　“?”: 表示该方法是查询功能的方法

　　“!”: 修改接收对象的方法

b) 方法参数:

　　1.设定方法参数默认值：在定义方法时，可以为一些或全部参数指定默认值。在参数后加下等号和一个值，就可以为该参数指定一个默认值，如：

　　def hello(name="ruby")

             puts("Hello, #{name}")

　　end

　　hello()

　　hello("world") 

　　另外，参数的默认值不一定必须是常量，也可以是任意表达式，还可以是实例变量的引用，还可以是前面定义参数的引用。

       def hello(a=10,b=5,c=a-b)

             puts a,b,c

　　end

　　hello()

　　puts

　　hello(1,2,10)

　　2.可变长度参数列表：Ruby中接受任意数目的参数，要在某个参数前加上一个*号，在方法的代码中，这个参数表示成一个数组，它包含传给这个位置上的0个或多个参数。比如：

        def hello(first,*rest)

              p first

              p rest

　　　end

　　　hello("11","22","33","44","55")       

        注：在ruby1.9中，用*打头的参数要放在带有默认值参数的后面，其后可以再指定普通参数，但是该普通参数要放在&打头的参数之前。

        3.哈希表作为有名参数：如果一个方法的有多于两三个参数时，程序员很难记清楚参数的顺序，这时我们就可以使用哈希对像作为参数,如：

        def sequence(args)

              m=args[:m]

              c=args[:c]

               n=args[:n]

              a=[]

              3.times{|i| a << m*i + c}

              p a                 #=> [10, 15, 20]

　　 end

　　 sequence({:n=>3, :m=>5,:c=>10})        #调用方法，传递哈希对像      

       另外,如果哈希对象是最后一个参数(或后面只有一个用&打头的代码块参数)，Ruby允许省略哈希字面量的大括号。 

　　 sequence(:n=>3, :m=>5,:c=>10)       

       因为Ruby中方法调用可以省略圆括号，所以也可以写成下面这样的形式： 

　　 sequence :n=>3, :m=>5,:c=>10      

       如果省略了圆括号，就必须省略大括号，否遇Ruby认为你传递了一个代码块给这个方法。

       4.代码块参数：在Ruby中每个方法调用都可以紧跟一个代码块，每个关联代码块的方法可以通过yield语句调用代码块中的代码。

　　def hello(n,m,c)

  　　　　i=0

  　　　　while(i<n)

     　　　　yield i*m + c

     　　　　i+=1

 　　　　end

　　end

　　hello(3,2,1){|x| puts x} 

          代码块是匿名的，如果希望明确的来控制一个代码块，可以在方法最后加上一个参数，并用&做这个参数的前缀。这个参数会指向传给方法的代码块，该参数是一个Proc对象，它不使用yield语句调用，而是直接通过Proc的call方法来调用：

           def sequence(n,m,c,&b)

              i=0

              while(i<n)

                　　b.call(i*m+c)

   　　　　　　 i+=1

             end

　　　　end

　　　　sequence(5,2,2){|x|puts x}

　　或

         def sequence(n,m,c,b)

              i=0

              while(i<n)

                b.call(i*m+c)

    　　　　 i+=1

             end

　　　end

　　　p=Proc.new{|x|puts x}

　　   sequence(5,2,2,p)} 

　　注：用&打头的代码块参数必须是最后一个，这是为了与省略了括号的数组与哈希参数区别。

c) 返回值

　　方法代码的最后一个表达式的值会作为方法调用表达式的值返回。在Ruby中可使用return关键字显式返回表达式的值，当然也可以不使用return关键字，隐式返回表达式的值。 

Class

a)  定义

   class name

      def initialize (pram1, pram2, …)

              @pram1 = pram1

              @pram2 = pram2

              …

      end

              …

    end

　　Note: 类名的首字母大写，后面的单词的首字母也大写;

　　Initialize 方法如果不做定义，系统默认有一个initialize 方法，在实例化变量时无需给其参数；若用户自定义initialize方法后，实例化对象时就要按照该方法的格式实例化;

　　Ruby中在实例嵌套类时，需要需要使用”外部类::嵌套类.new”的格式实例化潜逃类。

b) 继承

　　class  SubCalss < SuperClass

　　　　...

　　end

c)访问器方法和属性

　　通俗版：

　　class Test

       　　def initialize(x,y)

              　　@x=x

              　　@y=y

       　　end      

       　　def x; @x;end

       　　def y;@y; end 

       　　def  x=(value)

              　　@x=value

       　　end 

       　　def  y=(value)

              　　@y=value

      　　 end

　　end

 　　改进版:

　　class Test

       　　attr_reader :x, :y

       　　#attr_accessor

       　　#attr_writer

　　end

d) 类方法

　　在ruby中可以使用类名称直接访问的方法，称为类方法。有三种方法可以定义一个类方法；

       1）类名.方法名

       2） self.方法名 #（使用self的目的之一是：DRY, don’t repeat yourself）

       3）class << self

                def 方法名

                     …

                end

                     …

          end

e) 类变量：

　　在Ruby中，还可以定义类变量，类变量需要以”@@”开头，它属于某个类，所以在类的某个实例改变类变量时，将引起实例所属类的类变量发生改变。即一旦类变量发生改变，所有实例调用的类变量都会发生改变。类变量使用之前一定要初始化；

f) 访问控制

　　Public 可以被任何实例化对象调用，没有限制访问访问控制。方法默认是public,initialize除外，默认为private. 另外一个例外是所有在类外定义的”全局”方法，这些方法被定义为Object对象的私有实例方法

　　Protected 只能被定义了该方法类或其子类对象调用。整个家族均可访问。

　　Private 不能对象直接调用，接收者只能是self。 也就是说私有方法只能在当前对象的上下文中被调用。