#!/usr/bin/ruby

class Sample
   def hello
      puts "Hello Ruby!"
   end
end

# 使用上面的类来创建对象
object = Sample. new
object.hello

初始化方法

class Customer
   @@no_of_customers=0
   def initialize(id, name, addr)
      @cust_id=id
      @cust_name=name
      @cust_addr=addr
   end
end

• 一般小写字母、下划线开头：变量（Variable）。
• $开头：全局变量（Global variable）。
• @开头：实例变量（Instance variable）。
• @@开头：类变量（Class variable）类变量被共享在整个继承链中
• 大写字母开头：常数（Constant）。

变量(就是 局部变量)

a=1
b=2
puts "a: #a"
puts "b: #b"

a: #a
b: #b

a=1
b=2
puts "a: #{a}"
puts "b: #{b}"

a: 1
b: 2

变量的生存周期

class Test2
	a=1
	b=2
	def printVar()
		puts "a: #{a}"
		puts "b: #{b}"
	end
end
hellotest = Test2.new
hellotest.printVar()

test.rb:5:in `printVar‘: undefined local variable or method `a‘ for #<Test2:0x00000002cf2248> (NameError)
        from test.rb:10:in `<main>‘

class Test2
	def printVar(a,b)
		puts "a: #{a}"
		puts "b: #{b}"
	end
end
hellotest = Test2.new
hellotest.printVar(1,2)

a: 1
b: 2

变量的传递

class Test2
	def testPass(a,b)
		puts "before add : a: #{a}  b: #{b}"
		addVar(a,b)
		puts "after add : a: #{a}  b: #{b}"
	end
	def addVar(a,b)
		a += 1
		b += 2
	end
end
hellotest = Test2.new
hellotest.testPass(1,2)

before add : a: 1  b: 2
after add : a: 1  b: 2

class Obj1
	def initialize(a)
		@a=a
	end
	def printVal()
		puts "a: #@a"
	end
	def setA(a)
		@a=a
	end
	def getA()
		return @a
	end
end


class Test2
	def testPass()
		testobj = Obj1.new("hello")
		a = testobj.getA()
		puts "before add : a: #{a}"
		addVar(testobj)
		a = testobj.getA()
		puts "after add : a: #{a}"
	end
	def addVar(obj)
		obj.setA(obj.getA() + " world")
	end
end
hellotest = Test2.new
hellotest.testPass()

before add : a: hello
after add : a: hello world

实例变量

实例变量的打印

实例变量的生存周期

class LearnInstanceVar
	@a=1
	def printVar()
		puts "a: #{@a}"
	end
end

test1 = LearnInstanceVar.new
test1.printVar

$ ruby test.rb
a:

class LearnInstanceVar
	def initialize(a)
		@a=a
	end
	def printVar()
		puts "a: #{@a}"
	end
end

test1 = LearnInstanceVar.new("hello")
test1.printVar

$ ruby test.rb
a: hello

类变量

类变量的打印

• 类变量可以在多个实例之间公用，类似java的 static
• 在类的方法体以外声明

#!/usr/bin/ruby

class Customer
  @@no_of_customers=0
  def printCus()
    @@no_of_customers += 1
    puts "Total number of customers : #{@@no_of_customers}"
  end
end

cust1=Customer.new
cust2=Customer.new

cust1.printCus()
cust2.printCus()

• equal? 是比较两个对象是否是同一个对象
• == 是比较两个对象是否相等

a = "Ruby" # 定义一个字符串对象
b = "Ruby" # 虽然和a的内容相同，但是他们是不同的对象
a.equal?(b) # false: a和b指向不同的对象
a == b # true: 他们的内容是相同的

=== 三等号

• 在Range中===用于判断等号右边的对象是否包含于等号左边的Range；
• 正则表达式中用于判断一个字符串是否匹配模式，
• Class定义===来判断一个对象是否为类的实例，
• Symbol定义===来判断等号两边的符号对象是否相同。

(1..10) === 5 # true: 5属于range 1..10
/\d+/ === "123" # true: 字符串匹配这个模式
String === "s" # true: "s" 是一个字符串类的实例
:s === "s" # true 

a = 10
b = 20
c = 30

a, b, c = 10, 20, 30

a, b = b, c

a=1
b=2
c=3
a,b=b,c
puts "a: #{a}"
puts "b: #{b}"
puts "c: #{c}"

$ ruby test.rb
a: 2
b: 3
c: 3

foo = 42
defined? foo    # => "local-variable"
defined? $_     # => "global-variable"
defined? bar    # => nil（未定义）

defined? method_call # 如果方法已经定义，则为 True

defined? puts        # => "method"
defined? puts(bar)   # => nil（在这里 bar 未定义）
defined? unpack      # => nil（在这里未定义）

MR_COUNT = 0        # 定义在主 Object 类上的常量
module Foo
  MR_COUNT = 0
  ::MR_COUNT = 1    # 设置全局计数为 1
  MR_COUNT = 2      # 设置局部计数为 2
end
puts MR_COUNT       # 这是全局常量
puts Foo::MR_COUNT  # 这是 "Foo" 的局部常量