# 【【面向对象】】
#【实例变量】
=begin
实例变量是类属性，它们在使用类创建对象时就编程对象的属性。每个对象的属性是单独赋值的，和其他对象之间不共享。
在类的内部，使用@运算符访问这些属性，在类的外部，使用访问器方法的公共方法进行访问。
=end
#例子
class Box
#构造函数
def initialize(w,h)
@width,@height = w,h
end
#访问器方法
def printWidth
@width
end
def printHeight
@height
end
end
# 创建对象，初始化盒子的高度与宽度
box = Box.new(10,20)
#使用访问器方法
x = box.printWidth
y = box.printHeight
puts "盒子宽度：#{x}"
puts "盒子高度：#{y}"
=begin
盒子宽度：10
盒子高度：20
=end
# 例子 设置器
class Box
def initialize(w,h)
@width ,@height = w,h
end
def getWidth
@width
end
def getHeight
@height
end
#设置器
def setWidth=(value)
@width = value
end
def setHeight=(value)
@height = value
end
end
#创建对象
box = Box.new(10,20)
#使用设置器方法
box.setWidth = 30
box.setHeight = 50
#使用访问器方法
x = box.getWidth
y = box.getHeight
puts "盒子宽度：#{x}"
puts "盒子高度：#{y}"
=begin
盒子宽度：30
盒子高度：50
=end
# 【实例方法】
class Box
def initialize(w,h)
@width,@height = w,h
end
#实例方法
def getArea
@width * @height
end
end
box = Box.new(10,20)
a = box.getArea()
puts "Area of box is : #{a}" #Area of box is : 200
#【类方法& 类变量】
# =begin
# 类变量是在类的所有实例中共享的变量。换句话说，类变量的实例可以被所有的对象实例访问。类变量以两个 @ 字符（@@）作为前缀，类变量必须在类定义中被初始化，如下面实例所示。
# 类方法使用 def self.methodname() 定义，类方法以 end 分隔符结尾。类方法可使用带有类名称的 classname.methodname 形式调用
# =end
class Box
@@count = 0
def initialize(w,h)
@width,@height = w,h
@@count += 1
end
def self.printCount()
puts "Box count is #@@count"
end
end
#创建两个对象
box1 = Box.new(10,20)
box2 = Box.new(30,100)
#调用类方法输出盒子计数
Box.printCount() #Box count is 2
# 【to_s方法】返回对象的字符串表示形式。
class Box
def initialize(w,h)
@width,@height = w,h
end
def to_s
"(w:#@width,h:#@height)"
end
end
box = Box.new(10,20)
puts "String representation of box is : #{box}" #String representation of box is : (w:10,h:20)
# 【访问控制】
=begin
不在实例和类变量上应用任何访问控制。
三种，public private protected
public: 可被任意对象调用。默认情况下，方法都是public的，处理initialize总是private的。
private：不能被类外部访问或查看。只有类方法可以访问私有成员。
protected：只能被类及子类的对象调用。访问也只能在类及其子类内部进行。
=end
class Box
def initialize(w,h)
@width,@height = w,h
end
#实例方法默认是public的
def getArea
getWidth * getHeight
end
#定义私有的访问器方法
def getWidth
@width
end
def getHeight
@height
end
#make them private
private :getHeight,:getWidth
# 输出面积的实例方法
def printArea
@area = getWidth * getHeight
puts "box area is :#@area"
end
#让实例方法是受保护的
protected :printArea
end
box = Box.new(10,20)
#调用实例方法
a = box.getArea
#puts "area of box is : #{a}"
#尝试调用protected的实例方法
#box.printArea()
=begin
Area of the box is : 200
test.rb:42: protected method `printArea' called for #
<Box:0xb7f11280 @height=20, @width=10> (NoMethodError)
=end
# 【备注】因为此时既不在类的内部也不在子类的内部访问的。
# 【类的继承】
=begin
Ruby 不支持多继承，但是 Ruby 支持 mixins。mixin 就像是多继承的一个特定实现，在多继承中，只有接口部分是可继承的。
当创建类时，程序员可以直接指定新类继承自某个已有类的成员，这样就不用从头编写新的数据成员和成员函数。这个已有类被称为基类或父类，新类被称为派生类或子类。
=end
class Box
#构造期方法
def initialize(w,h)
@width,@height = w,h
end
#实例方法
def getArea
@width * @height
end
end
# 定义子类
class BigBox < Box
#添加一个新的实例方法
def printArea
@area = @width * @height
puts "Big box area is :#@area"
end
end
box = BigBox.new(10,20)
box.printArea() #Big box area is :200
# 【方法重载】
#定义父类
class Box
def initialize(w,h)
@width,@height = w,h
end
#实例方法
def getArea
@width * @height
end
end
#定义子类
class BigBox < Box
# 改变已有的getArea方法
def getArea
@area = @height * @width
puts "Big box area is : #@area"
end
end
box = BigBox.new(10,30)
box.getArea() #Big box area is : 300
# 【运算符重载】
class Box
def initialize(w,h)
@width,@height = w,h
end
def +(other) #定义+ 来执行 向量加法
Box.new(@width + other.width,@height + other.height)
end
def -@ #定义一元运算符 - 来对width height 取反
Box.new(-@width,-@height)
end
def *(scalar) #执行标量乘法
Box.new(@width*scalar,@height*scalar)
end
end
# 【冻结对象】
=begin
有时候，我们想要防止对象被改变。在 Object 中，freeze 方法可实现这点，它能有效地把一个对象变成一个常量。任何对象都可以通过调用 Object.freeze 进行冻结。冻结对象不能被修改，也就是说，您不能改变它的实例变量。
您可以使用 Object.frozen? 方法检查一个给定的对象是否已经被冻结。如果对象已被冻结，该方法将返回 true，否则返回一个 false 值
=end
=begin
class Box
def initialize(w,h)
@width,@height = w,h
end
def getWidth
@width
end
def getHeight
@height
end
def setWidth=(value)
@width = value
end
def setHeight=(value)
@height = value
end
end
box = Box.new(10,20)
box.freeze
if(box.frozen?)
puts "box obj is frozen obj"
else
puts "box obj is normal obj"
end
#尝试使用设置器方法
box.setWidth = 30
box.setHeight = 50
#使用访问器方法
x = box.getWidth
y = box.getHeight
puts "width of box is :#{x}"
puts "height of box is :#{y}"
=end
=begin
Box object is frozen object
test.rb:20:in `setWidth=': can't modify frozen object (TypeError)
from test.rb:39
=end
#【类常量】
class Box
BOX_COMPANY = "TATA Inc"
BOXWEIGHT = 10
def initialize(w,h)
@width,@height = w,h
end
def getArea
@width * @height
end
end
box = Box.new(10,20)
a = box.getArea()
puts "area of box is :#{a}"
puts Box::BOX_COMPANY
puts "Box weight is : #{Box::BOXWEIGHT}"
=begin
area of box is :200
TATA Inc
Box weight is : 10
=end
#【使用 allocate 创建对象】
=begin
可能有一种情况，您想要在不调用对象构造器 initialize 的情况下创建对象，即，使用 new 方法创建对象，在这种情况下，您可以调用 allocate 来创建一个未初始化的对象，如下面实例所示：
实例
#!/usr/bin/ruby -w
# 定义类
class Box
attr_accessor :width, :height
# 构造器方法
def initialize(w,h)
@width, @height = w, h
end
# 实例方法
def getArea
@width * @height
end
end
# 使用 new 创建对象
box1 = Box.new(10, 20)
# 使用 allocate 创建两一个对象
box2 = Box.allocate
# 使用 box1 调用实例方法
a = box1.getArea()
puts "Area of the box is : #{a}"
# 使用 box2 调用实例方法
a = box2.getArea()
puts "Area of the box is : #{a}"
尝试一下 »
当上面的代码执行时，它会产生以下结果：
Area of the box is : 200
test.rb:14: warning: instance variable @width not initialized
test.rb:14: warning: instance variable @height not initialized
test.rb:14:in `getArea': undefined method `*'
for nil:NilClass (NoMethodError) from test.rb:29
=end
#【类信息】
#
=begin
Ruby的 self 和 Java 的 this 有相似之处，但又大不相同。Java的方法都是在实例方法中引用，所以this一般都是指向当前对象的。而Ruby的代码逐行执行，所以在不同的上下文(context)self就有了不同的含义。让我们来看看下面的实例：.
实例
#!/usr/bin/ruby -w
class Box
# 输出类信息
puts "Class of self = #{self.class}"
puts "Name of self = #{self.name}"
end
尝试一下 »
当上面的代码执行时，它会产生以下结果：
Class of self = Class
Name of self = Box
这意味着类定义可通过把该类作为当前对象来执行，同时也意味着元类和父类中的该方法在方法定义执行期间是可用的。
=end
# coding=utf-8
# 【【面向对象】】
#方法、类、模块
=begin
1 方法返回值不需要声明，默认最后一行为返回值。但若有条件判断返回的情况，需要用return声明
2 方法中可使用别名“alias”方法生成的拷贝，即使元方法变化，别名拷贝也不会变化
3 当方法定义在类的外部，默认是private。当方法啊定义在类的内部，默认是public
=end
def show_alias
puts "before alias"
end
alias alias_foo show_alias
def show_alias
puts "after alias"
end
puts show_alias #after alias
puts alias_foo #before alias
#例子 类
class Person
def initialize(age,sex)
@age = age
@sex = sex
end
def age
@age
end
def sex
@sex
end
end
tom = Person.new(20,"boy")
puts tom.age #20
puts tom.sex #boy
# 【【方法、类、模块】】 【类】
class Person
def initialize(age,sex)
@age = age
@sex = sex
end
def age
@age
end
def sex
@sex
end
def say
puts "hello world"
end
#重定义方法
def say
puts "How are you?"
end
end
tom = Person.new(20,'boy')
#特定对象的方法
def tom.bye
puts "Goodbye"
end
puts tom.age #只有一个对应的方法会按照这个方法来，如果有多个重定义的，则按照最新的来。所以此时输出"How are you?"
puts tom.sex
puts tom.say #hello world
puts tom.bye #Goodbye
#重新打开类
class PersonOne
def say
puts "Hi!"
end
end
class PersonOne
def bye
puts "Bye!"
end
end
wxue = PersonOne.new
wxue.say #Hi!
wxue.bye #Bye!
# 更好的属性读写，=号的威力
#可用很多种方法对属性进行读写，但最方便的，对属性直接赋值
class PersonTwo
def age=(age)
@age = age
end
def age
@age
end
end
tom = PersonTwo.new
tom.age=(20)
puts tom.age #20
class PersonThree
def age=(age)
@age = age
end
def age
@age
end
end
wxue = PersonThree.new
wxue.age = 20
print "wxue.age=",wxue.age,"\n"
# 自动生成属性的读写操作attr_*
=begin
方法名 效果 例子 等价的代码
attr_reader 读方法 attr_reader :age def age
@age
end
attr_writer 写方法 attr_writer :price def age = (age)
@age = age
end
attr_accessor 读写方法 attr_accessor :age def age = (age)
@age = age
end
def age
@age
end
attr 读方法和
可选的写方法
（如果第二个参数是true）1.attr :age 1. 参见attr_reader
2.attr :age,true 2. 参见attr_accessor
=end
#例子
class Car
attr_accessor :wheel
end
class Bus < Car
attr_accessor :chaircount
end
bus22 = Bus.new
bus22.wheel = 4
bus22.chaircount = 25
puts bus22.wheel #4
puts bus22.chaircount #25
#【【方法、类、模块】】【模块】
#module没有实例，使用时把module混合到类中来使用
module FirstModule
def say
puts "Hello"
end
end
class ModuleTest
include FirstModule
end
test = ModuleTest.new
puts test.say #"Hello"
# 模块和类可以相互嵌套
module Human
class Boy
def say
puts "cool"
end
end
end
test = Human::Boy.new
test.say #cool
