Programming Ruby(读书笔记)-3章

Classes,Objects,and Variables

everything we manipulate in Ruby is an object.And every object in Ruby was generated either directly or indirectly from a class.所有操作都是对象操作，对象是由类直接或者间接产生。为更生动描述类与对象，先设一个案例场景，一个二手书店，每天员工要统计书的信息，比如拿着扫描器扫描每个书的条形码...现在产生如下的数据在CSV文件中:

tut_classes/stock_stats/data.csv

"Date","ISBN","Price"

"2013-04-12","978-1-9343561-0-4",39.45

"2013-04-13","978-1-9343561-6-6",45.67

"2013-04-14","978-1-9343560-7-4",36.95

，我们定义BookInStock

 

class BookInStock
  def initialize(isbn, price)  //initialize是Ruby的回调，会在调用new的时候调用
    @isbn = isbn    #@开始的是instance variables实例变量
    @price = Float(price) #将入参转换为float类型，如果转换出错就抛出异常
  end
end

b1 = BookInstock.new('isbn1', 1)
p b1
b2 = BookInstock.new('isbn2',2.2)
p b2
b3 = BookInstock.new('isbn3', '1.23')
p b3
produces:
#<BookInStock:0x007fac4910f3e0 @isbn="isbn1", @price=3.0>
#<BookInStock:0x007fac4910f0c0 @isbn="isbn2", @price=3.14>
#<BookInStock:0x007fac4910eda0 @isbn="isbn3", @price=5.67>

注意：上面是使用p而不是puts，如果使用puts则只打印#<BookInStock:0x007fac4910f3e0>，因为puts只是简单的把string内容输出到标准输出，而传入我们定义的类时，它只会把类名称和类的id打印出来。这类似于java的toString方法，需要覆盖，来吧，再敲一遍

 

 

class BookInStock
  def initialize(isbn, price)
    @isbn = isbn
    @price = price
  end

  def to_s
    "ISBN: #{@isbn}, price:#{@price}" #实例变量可被所有类方法使用
  end
end

 -----------Attributes------------------

 

类实例生成后，保存了自己的状态(java里的成员变量的值，在此被描述为内部状态(internal state))，默认情况下这些内部状态其它类不能触碰。为了能与外界进行状态交互，引用了attributes（属性）的概念：These externally visiable facets of an object are called attributes。不过概念不重要。

 

class BookInStock
  ...
  def isbn
    @isbn
  end
  def price
    @price
  end
.....
book = BookInStock.new('ruby', 1.23)
puts "ISBN:#{book.isbn}"
produces:
ISBN:ruby

 Ruby为这种情况提供了便捷方式：

class BookInStock
  attr_reader :isbn, :price         #这里使用的是符号
  ...........
end

符号是方便引用名称，这里“:isbn”表示isbn的名称，而“isbn”则表示isbn的值。 如果有些绕，想想不使用符号，那写成什么？

注意：attr_reader并不是实例变量的声明，它是创建了获取方法，变量本身是没有声明，Ruby解耦实例变量与获取方法，如吧，这个我也有些不明白，原文：

It creates the accessormethods, but the variables themselves don’t need to be declared

—they just pop into existence when yo u use them. Ruby completely decouples instance

variables and accessor methods, as we’ll see in Virtual Attributes, on page 35.

----------Writable Arributes--------

#可修改价格的类
class BookInStock
  attr_reader :isbn, :price

  def initialize(isbn, price)
    @isbn = isbn
    @price = price
  end
  def price=(new_price) #定义了price=方法，setPrice(new_price)也行，只是调用要去掉=
    @price = new_price
  end
end

 同样，Ruby为些提供了attr_accessor，attr_accessor :price会给类创建两个方法price与price=，一个用于获取值，一个用于设置新值。

 

有个问题：可以自定义获取属性的名称吗？比如类中定义的price,希望外界使用book_price

------------Virtual Attributes----------------

class BookInStock
  attr_reader :isbn
  attr_accessor :price
  def initialize(isbn, price)
    @isbn = isbn
    @price = price
  end
  def price_in_cents
    Integer(price*100 + 0.5)       #这里没有使用@price
  end
  def price_in_cents=(cents)      #定义写方法是添加一个=
    @price = cents/100.0
  end
end

 --------Attributes,Instance Variables, and methods---------

 Attribute就是方法，只是它被用于存取实例变量相关的内容。

The external state is exposed through methods we’re calling attributes. And the

other actions your class can perform are just regular methods. It really isn’t a crucially

important distinction, but by calling the external state of an object its attributes, you’re

helping clue people in to how they should view the class you’ve written.

-------------Classes Working with Other Classes-------------------

class CsvReader
  def initialize
    @books_in_stock = []
  end
  
  def read_in_csv_data(csv_file_name)
    CSV.foreach(csv_file_name, headers: true) do |row|
      @books_in_stock << BookInStock.new(row["ISBN"], row["Price"])
    end
  end
end

 headers: true表示解析第一行作为为列的名称。

--------------下面使用一个实例描述多个类之间的交互---------------------

实例代码见附件：stock_stats.rar

-----------访问控制---------------

a good rule of thumb(好的经验法则)：不要提供那些能使类的状态出现不正确的方法。Ruby提供三个保护级别：Public/Protected/Private

Public：默认级别，但是initialize除外

Protected：只有类对象或子类对象可访问

Private：不允许object.privateMethod的调用(explicit receiver)，只允许在当前类对象的上下文内调用。与其java不现的是，同一类型的两个对象A,B，B不能这样使用A.privateMethod。想想java的equals方法。

Ruby的访问级别可以在程序动态修改：

Ruby differs fromotherOOlanguages in another importantw a y .Access control is determined

dynamically, as the program runs, not statically. Y o u will get an access violation only when

the code attempts to execute the restricted method.

两种方式设置级别：(级别应用在方法和模块上)

1、

class Class1
public
  def function1
  end
end

 

2、

class Class2
  def function1
  end
  ....
  public :function1,:function2
  protected :function3
end

 模拟一个转账的示例，使用了访问级别

class Account
  attr_accessor :balance
  
  def initialize(balance)
    @balance = balance
  end
end

class Transaction
  def initialize(account_a, account_b)
    @account_a = account_a
	@account_b = account_b
  end
  
private
  def debit(account, amount)
    account.balance -= amount
  end
  def credit(account, amount)
    account.balance += amount
  end

public
  def transfer(amount)
    debit(@account_a, amount)
	credit(@account_b, amount)
  end
end

account_a = Account.new(100)
account_b = Account.new(50)
trans = Transaction.new(account_a, account_b)
trans.transfer(50)
puts "After transfer, account_a's balance #{account_a.balance},account_b's balance #{account_b.balance}"

 protected级别用于，同种类型的对象互相访问内部状态，比如：

class Account
  attr_reader :cleared_balance  #定义cleared_balance访问方法
  protected :cleared_balance     #控制访问级别

  def greater_balance_than?(other)
    @cleared_balance > other.cleared_balance
  end
end

 ---------3.4变量-------------

Ruby中

person = "Time" #person并不是一个对象，而只是一个引用，即变量不是个对象，只是一个引用。这个与JAVA一样。

person2 = person，再修改person2的内容，person也会被修改，两个引用指向同一个对象。

通过person3 = person.dup，可clone一个新的对象。也可以通过调用person.freeze来阻止被修改。