1. 注意：对象的实例变量只能被该对象的实例方法访问，实例方法外的代码不能对实例变量进行读写（除非反射机制）
错误的写法:
# 这段代码并不会像想象中那样正常工作，实例变量只能在self的上下文中被解析，当initialize调用时，此时self会指向一个Point实例对象。但是@x = 0 @y = 0并不在当前上下文中，当这两句代码执行的时候所属的上下文是Point类本身而不是实例对象，因此initialize方法内的@x和方法外的@x是完全不同的两个变量
class Point
@x = 0
@y = 0
def initialize(x, y)
@x,@y = x,y
end
end
2. 如何访问实例属性
- 实现原理如下
class Point
def initialize(x, y)
@x,@y = x,y
end
# 定义访问器（get）
def x
@x
end
def y
@y
end
# 定义访问器（set）
def x=(value)
@x = value
end
def y=(value)
@y = value
end
end
# 使用访问器访问属性
p = Point.new(1,2)
q = Point.new(p.x*2,p.y*2) #看起来仿佛是访问属性，其实是无参数的方法调用
p.x= 0 #可以写成 p.x = 0
p.y= 2
- 因为这种需求茫茫多，ruby提供了一方法使其自动化，module类定义了attr_reader只读 attr_accessor读写，因此上述代码可以改写为：
# 定义一个可变的
class Point
attr_accessor :x, :y
def initialize(x, y)
@x,@y = x,y
end
end
# 定义一个不可变的
class Point
attr_reader :x, :y
def initialize(x, y)
@x,@y = x,y
end
end
3. 怎么使用+-*／来操作对象
def +(other)
raise TypeError,"must Point" unless other.is_a? Point
Point.new(@x+other.x,@y+other.y)
end
def *(scalar)
Point.new(@x*scalar,@y*scalar)
end
# 使用操作符
p = Point.new(1,2)
m = p + 2
q = p * 2
# 此处注意 如果p*2 是可运行的，但是若2*p则是不行的因为2是integer，他的*方法不知道与Point对象如何一起工作，若想p*2 和2 * p 返回一样的结果则可以定义个coerce 方法
def coerce(other)
[self, other]
end
重写[]，访问数组和hash
def [](index)
case index
when 0, -2: @x # 0 或 -2 返回x
when 1, -1: @y # 1 或 -1 返回y
when :x, "x": @x # :x, "x" 返回x
when :y, "y": @y # :y, "y" 返回y
else nil
end
end
4.如何枚举一个对象
def each
yield @x
yield @y
end
定义了each迭代器则可以混入 Enumerable 模块的一些方法，因为他们都是基于each方法实现的
include Enumerable
p = Point.new(1,2)
p.each{|x| p x} # => 1,2
p.all? {|x| x==0 } # 如果返回为true则返回
5. 如何判断对象的相等性
def ==(other)
if other.is_a? Point
@x == other.x && @y == other.y
else
false
end
end
# 如果我们希望 .eql? 和 == 一样则可以通过如下方式
alias eql? ==
# 如果希望eql？ 更严格检测
def eql?
if other.is_a? Point
@x.eql? other.x && @y.eql? other.y
else
false
end
end
# 注意：对于任何对象的比较方法实现
# == 操作符应该内部用==
# eql？内部用eql？比较
- sql? 方法常用哈希对象，所以不能单独定义它，需要一起定义hash方法来计算对象的哈希码
- 如果两个对象的.eql?返回相等 则hash必须相等, 以point为例实现hash方法
def hash
code = 17
code = 37*code + @x.hash
code = 37*code + @y.hash
end
# 上面的写法 包含了顺序 (0,1) 和 （1,0）能返回不同的hash而简单的累加 则会出现问题，缺点是point作为对象主键会导致效率大大降低
6. 如何对象排序
include Comparable
def <==>(other)
return nil unless other.is_a? Point
@x**2 + @y**2 <==> other.x**2 + other.y**2
end
7. 如何创建可变的类
attr_accessor :x, :y
def add!(other)
@x += other.x
@y += other.y
self
end
还有种便捷的方法创建可变类，即用Struct类创建，Struct是ruby的内核类可用来生成其他类,创建时指明的属性自动具有访问器方法
# 两种创建方式
Struct.new("Point",:x, :y) # Struct::Point
Point = Struct.new(:x , :y) #assigns to Point
# 命名匿名类(若把一个未命名的类对象赋值给一个常量，则常亮名就会成为该类的名称，上面也是一样)
C = Class.new
c = C.new
c.class.to_s # => C
上面方式改写代码如下:
Point = Struct.new(:x, :y)
class Point
def add!(other)
self.x += other.x
self.y += other.y
self
end
include Comparable
def <==>(other)
return nil unless other.is_a?Point
self.x**2+self.y**2 <==> other.x**2+other.y**2
end
end
struct创建的可变类变为不可变
Point = Struct.new(:x, :y)
class Point
undef x= ,y= []=
end
7. 怎么添加类方法
class Point
attr_reader :x, :y
def Point.sum(*points)
x, y = 0, 0
points.each{|point| x+= point.x; y += point.y}
Point.new(x, y)
end
# 可以用self来改写，是一样的
def self.sum(*points)
x, y = 0, 0
points.each{|point| x+= point.x; y += point.y}
Point.new(x, y)
end
end
- self是第一种表示类对象的方式
- 第二种方式，适用于定义多个类方法的时候，代码如下:
# 給point类添加类方法
class << Point
def sum(*points)
x, y = 0, 0
points.each{|point| x+= point.x; y += point.y}
Point.new(x, y)
end
# other class in here
end
# 这种可在类定义中使用
class Point
# instance method in there
class << self
# class method in there
end
end
8. 怎么添加常量
class Point
def initialize(x, y)
@x, @y = x, y
end
ORIGIN = Point.new(0, 0)
end
# 上面的代码常量引用了该类的实例，因此在未定义该类initialize方法前常量无法被定义
# 类外也可以定义常量：
Point::ORIGIN = Point.new(0, 0)
定义外访问常量
Point::ORIGIN
9. 类变量和类实例变量怎么写
# 类变量
class Point
@@n = 0
@@totalX = 0
def initialize(x, y)
@x, @y = x, y
@@n += 1
@@totalX += x
end
end
# 类实例变量
# 类的实例变量不过是类对象的实例变量，所以也可以用 attr_asscessor 创建类的实例变量。
# 类也是一个类的实例对象，类实例变量与类关联，和类变量很相似，区别就是类实例变量无法像类变量一样可以在实例方法中被使用，而且还容易和普通实例变量混淆
class Point
# 写法一
def self.new(x, y)
@n += 1
@totalX += x
super
end
# 写法二
class << self
attr_accessor :n, :totalX
end
end
# 然后可以这种方式访问
Point.n
Point.totalX
10. 方法可见性～(实例变量类变量在效果是私有的，常量是公开的)
public : 默认除了initialize和类外定义的方法(这些方法被定义为Object对象的私有实例方法) 方法都是public
private：只能被这个类(或他的子类)的实例方法调用，能被self隐式调用，不能被一个对象显式调用。m是o一个私有方法，那么只能m调用，而不能self.m() 或者o.m调用
protected：只能被这个类(或他的子类)的内部被调用，可以被显示调用，正式描述如下：当一个被类c所定义的protected方法，只有当o和p都是c的子类（或c本身）时，p中的方法才能调用o上的该方法
# 第一种使用方式
class Point
# public methods in here
protected
# protected methods in here
private
# private methods in here
end
# 第二种 在类末尾 一次性声明所有被保护或者私有方法
class Widget
def met_1
end
def met_2
end
def met_3
end
protected : met_2
private :met_1
end
总结：Point的一个书写
Class Point
# 实例变量
attr_accessor :x, :y
# instance method in there
class << self
# 类实例变量
attr_accessor :count , :totalX
# class method in there
end
end
p = Point.new(1,2)
p.x
p.y
Point.count
Point.totalX
