Ruby类（二）

类

Ruby是一种面向对象语言

定义类

#!/usr/bin/ruby
# -*- coding : utf-8 -*-
class Customer
    
end

类中的变量

Ruby 提供了四种类型的变量：

• 局部变量：局部变量是在方法中定义的变量。局部变量在方法外是不可用的。在后续的章节中，您将看到有关方法的更多细节。局部变量以小写字母或 _ 开始。
• 实例变量：实例变量可以跨任何特定的实例或对象中的方法使用。这意味着，实例变量可以从对象到对象的改变。实例变量在变量名之前放置符号（@）。
• 类变量：类变量可以跨不同的对象使用。类变量属于类，且是类的一个属性。类变量在变量名之前放置符号（@@）。
• 全局变量：类变量不能跨类使用。如果您想要有一个可以跨类使用的变量，您需要定义全局变量。全局变量总是以美元符号（$）开始。

new

class Customer
    @@no_of_customer = 0;

    def initialize(id, name, addr)
        @id = id;
        @name = name;
        @addr = addr;
    end

    def buy
        puts "buy somethings"
    end

    def id
        return @id
    end

    def setId(id)
        @id = id
    end
end

cust = Customer.new(12, "zhao", "beijng")
puts cust.id
cust.setId(13)
puts cust.id
cust.buy

类的实例变量只能通过方法来访问。因为生成的实例变量都private的，类似java的私有变量。如果每次都需要手写getter和setter比较麻烦，可以通过元编程的特性来自动生成getter 和setter
attr_accessor 、attr_reader 和attr_writer

class Customer
    @@no_of_customer = 0
    attr_accessor:id
    attr_reader:addr
    attr_writer:name
    def print
        puts "id is #@id"
    end
    
    def buy
        #声明一个实例变量不一定得在initialize方法中，
        @things = ["shoes", "backpack"]
        puts @things
    end
end

c = Customer.new
#没有赋值之前打印， id = nil
c.print
c.id = 12
c.print
puts c.id
c.buy

类变量也是私有的，只能通过方法来进行访问，但是类变量的的声明只能在类中声明(如果在方法中声明，并没有语法错误)，而不能在initialize或者方法中声明，因为在构造函数中声明和初始化，在生成多个对象的时候会被覆盖。在使用类变量之前，必须先声明，否则程序运行错误

在访问实例变量、类变量 和全局变脸的时候，都必须加上他们的前缀， @、 @@、 $

自定义方法来创建 Ruby 对象

您可以给方法 new 传递参数，这些参数可用于初始化类变量。
当您想要声明带参数的 new 方法时，您需要在创建类的同时声明方法 initialize。
initialize 方法是一种特殊类型的方法，将在调用带参数的类的 new 方法时执行。
下面的实例创建了 initialize 方法：

class Customer
    @@no_of_customer = 0;

    def initialize(id, name, addr)
        @_id = id;
        @_name = name;
        @_addr = addr;
    end
end

#当重写initialize方法之后，不能直接掉new方法，
#cust = Customer.new;

cust = "ad";
puts cust;

cust = Customer.new(12, "zhao", "beijng");
puts cust;

Ruby 类中的成员函数

在 Ruby 中，函数被称为方法。类中的每个方法是以关键字 def 开始，后跟方法名。
方法名总是以小写字母开头。在 Ruby 中，您可以使用关键字 end 来结束一个方法。
下面的实例定义了一个 Ruby 方法：

def buy
        puts "buy somethings"
    end

如果没有参数可以选择不加括号， 也可以加括号：def buy()， 如果写return 默认返回nil。

• 类方法

class Demo
    @@b=2
    def initialize
        @a=1
    end
    
    def print
        puts @a
        puts @@b
    end
    
    def Demo.test   #类方法
        puts @a     #返回nil
        @a = 5
        puts @a
        puts @@b
    end
    
    def Demo.test1  #类方法
        puts @a  
    end
end    

demo = Demo.new
demo.print  
Demo.test
Demo.test1
demo.print  

查看上面代码和运行的结果，会发现类方法有如下特点：

1）类方法的定义和引用都需要前面加类名

2）类方法可以访问类变量

3）类方法中引用的 @a 并不是类的实例变量，而是另外一个命名空间的

Ruby 常量

常量以大写字母开头。定义在类或模块内的常量可以从类或模块的内部访问，定义在类或模块外的常量可以被全局访问。
常量不能定义在方法内。引用一个未初始化的常量会产生错误。对已经初始化的常量赋值会产生警告。

只要第一个字母为大写，就表明这就是常亮

Ruby 伪变量

它们是特殊的变量，有着局部变量的外观，但行为却像常量。您不能给这些变量赋任何值。

self: 当前方法的接收器对象。
true: 代表 true 的值。
false: 代表 false 的值。
nil: 代表 undefined 的值。
FILE: 当前源文件的名称。
LINE: 当前行在源文件中的编号。

继承

• 构造方法
  子类的构造方法如果没用重写，则会直接复用父类的构造方法，如果子类重写了构造方法，在new子类的时候调用子类的构造方法，但是父类的构造方法时候是会调用取决于你在子类中是否手动调用父类的构造方法，

class Box
    def initialize(width, height)
        @width = width
        @height = height
        puts "Box initialize"
    end

    def area
        a = @width * @height
        puts "area is #{a}"
    end

    def width 
        puts @width
    end

    def self.classMethod 
        puts "class Method"
    end
end

class CircelBox < Box
    # def initialize
    #     super(10,10)
    #     puts "CircelBox initialize"
    # end
end