1.面向对象编程:
1.0 为何要有面向对象编程:
很早之前程序员就发现,随着软件的日趋复杂与庞大,维护往往变成了一个很棘手的问题.因为贯穿整个程序的依赖(dependencies),在一个程序中一个很小的改变就可能引起如同涟漪般扩散的偏差(errors).
而面向对象编程正是为了解决这个问题而诞生的.
1.1 何为面向对象编程:
面向对象编程(Object oriented programming)是一种基于对象的编程范型.在面向对象编程语言中,一切均是对象.
1.2 对象(object)的定义:
对象是指一个具体的事物.它有具体的行为(behaviors),有具体的属性(states).有时可以对应现实世界的事物,例如小狗聪聪,猫咪毛毛等.
1.3 类(class)的定义:
定义:
类相当于一副蓝图,定义了一类事物的抽象特点. 例如,"狗"这个类会包含狗的一切基础特征，即所有“狗”都共有的特征或行为，例如它的孕育、毛皮颜色和吠叫的能力。
作用:
这样创建一类具有相同行为与共通的属性的对象时,先创建一个这样的一个类,再用这个类去定义具体的对象,就可以少写很多代码.
1.4 面向对象编程的三大支柱:
- 封装性(Encapsulation)
限定只有特定的类的对象才能调用特定类的方法,并且隐藏了方法的具体执行步骤.
示例:
/* 一个面向过程的程序会这样写： */
定义莱丝
莱丝.设置音调(5)
莱丝.吸气()
莱丝.吐气()
/* 而当狗的吠叫被封装到类中，任何人都可以简单地使用： */
定义莱丝是狗
莱丝.吠叫()
- 继承(inheritance)
在某些情况下一个类会有子类,子类比父类更加具体.例如,“狗”这个类可能会有它的子类"牧羊犬"和"吉娃娃".子类会继承父类的属性和行为,并且包含它自己的.假设"狗"这个类有一个方法(行为)叫做“吠叫()”和一个属性叫做“毛皮颜色”。它的子类（前例中的牧羊犬和吉娃娃犬）会继承这些成员。
例如:
类牧羊犬:继承狗
定义莱丝是牧羊犬
莱丝.吠叫() /* 注意这里调用的是狗这个类的吠叫方法。*/
- 多态(Polymorphism)
多态(Polymorphism)是一个专业术语,意指"许多形态"("many shapes").更具体来说是同一种操作被用不同方式执行.
例如,狗和鸡都有“叫()”这一方法，但是调用狗的“叫()”，狗会吠叫；调用鸡的“叫()”，鸡则会啼叫。 我们将它体现在伪代码上：
类狗
开始
公有成员:
叫()
开始
吠叫()
结束
结束
类鸡
开始
公有成员:
叫()
开始
啼叫()
结束
结束
定义莱丝是狗
定义鲁斯特是鸡
莱丝.叫()
鲁斯特.叫()
这样同样做出叫这个动作,莱丝与鲁斯特的实际行为会大相径庭.
2. 关于对象(object)
2.1 initialize object:
语法:
Classname.new
示例:
- 不带参数:
--- initialize class called GoodDog ---
class GoodDog
end
--- initialize object ----
sparky=GoodDog.new
- 带参数:
--- initialize class called GoodDog ---
class GoodDog
def initialize(name,color)
@name = name
@color = color
end
end
--- initialize object ----
sparky=GoodDog.new("sparky","white")
2.2 instance variable
2.2.1 作用:
记录对象的属性(keep track of states of object)
2.2.2 定义语法:
- 以"@"符号开头
- 后面跟着表示对象属性的单词,并且使用小写字母
示例:
class GoodDog
def initialize(name,color)
@name = name
@color = color
end
end
sparky = GoodDog.new("sparky","white")
2.2.3 instance variable的存取:
2.2.3.1 如何进行存取:
背景问题1:
如何输出@name的值
以上面代码为例,虽然有了instance variable,但是如果我们想要 输出 sparky 的name,那么应该怎么办?
sparky.name # => NoMethodError: undefined method `name' for #<GoodDog:0x007f91821239d0
@name="Sparky">
上面的错误提示告诉我们我们没有定义一个叫做name 的method,也就是说我们需要定义一个方法来存放@name的值,来方便我们输出.
这似乎是说"object."后面只能跟method,而不能跟variable
解决方案:
class GoodDog
def initialize(name,color)
@name = name
@color = color
end
--- add getter_method ---
def get_name
@name
end
end
sparky = GoodDog.new("sparky","white")
这样我们就可以输出sparky的名字了:
puts sparky.get_name # => sparky
背景问题2:
现在已经有了getter method,
但如何改变name的值?
解决方案:
class GoodDog
def initialize(name,color)
@name = name
@color = color
end
--- add getter_method ---
def get_name
@name
end
--- add setter_method ---
def set_name=(name)
@name = name
end
end
sparky = GoodDog.new("sparky","white")
现在运行下面的代码:
sparky.set_name = "spartacus"
puts sparky.get_name #=> spartacus
就会发现name的值改变了.
2.2.3.2 对上述代码进行重构:
- 重构的原因:
Rubyist习惯使用相同的名称来命名instance variable的getter method 和setter method .
- 重构后的代码:
统一使用name来命名getter method 和setter method.
class GoodDog
def initialize(name)
@name = name
end
def name # This was renamed from "get_name"
@name
end
def name=(n) # This was renamed from "set_name="
@name = n
end
end
sparky = GoodDog.new("Sparky")
puts sparky.speak
puts sparky.name # => "sparky"
sparky.name = "Spartacus"
puts sparky.name # => "Spartacus"
2.2.3.3 对上述代码进行再次重构(attr_*):
- 重构的原因:
上述代码占用的空间太多了,只有一个instance variable还好,若是有多个呢?例如height / weight.这样就太麻烦了.
- 解决方案:
Ruby内置了一套方案来解决上述问题.
attr_accessor method 可以自动的帮助我们产生和上面一样的getter / setter metods.
class GoodDog
attr_accessor :name # using attr_accessor method
def initialize(name)
@name = name
end
end
sparky = GoodDog.new("Sparky")
puts sparky.speak
puts sparky.name # => "Sparky"
sparky.name = "Spartacus"
puts sparky.name # => "Spartacus"
这样写就会简洁/方便很多.
-
含有多个instance variable的写法:
attr_accessor :name, :height, :weight
2.2.3.4 其他两种attr_* method:
-
只想要getter method,而不需要setter method :
attr_reader
只想要setter method ,而不想要 getter method:
attr_writer
2.2.4 在class内部使用getter / setter method:
2.2.4.1在class内部使用getter method 替换 instance variable:
- 原因:
如果我们有一个social_security_numbers(用@ssn表示),我们并不想展示所有的数字,只想展示后四位,那么可以这样写:
"****-****-" + @ssn.split("-").last
如果我们需要多次使用到这行代码,与其多次重复写入,不如写一个method将这行代码封装起来.
另外原本的getter mehod 不能让别人直接调用,所以不如直接使用getter method 来封装这行代码:
def ssn
"****-****-" + @ssn.split("-").last
end
-
示例:
class Account def initialize(name,ssn) @name = name @ssn =ssn end def ssn "****-****-" + @ssn.split("-").last end def ssn_hint "Your ssn is #{ssn}" # using ssn instead of @ssn end end
2.2.4.2在class内部使用setter method:
- 原因:
如实在GoodDog class中有多个instance variable,而我们定义一个方法(change_info)用来同时改变着多变量的值:
def change_info(n,h,w)
@name = n
@height = h
@weight = w
end
为了与上面的在class内部使用getter method保持一致(consistence),从而使用setter_method来进行替换.
- 失败的尝试:
根据上面的思路我们对change_info这个method进行了修改.
class GoodDog
attr_accessor :name, :height, :weight
def initialize(n, h, w)
@name = n
@height = h
@weight = w
end
def speak
"#{name} says arf!"
end
def change_info(n, h, w) # try using setter method
name = n
height = h
weight = w
end
def info
"#{name} weighs #{weight} and is #{height} tall."
end
但是当我们进行检测时,却发现变量的值并没有改变.
sparky = GoodDog.new('Sparky', '12 inches', '10 lbs')
puts sparky.info # => Sparky weighs 10 lbs and is 12 inches tall.
sparky.change_info('Spartacus', '24 inches', '45 lbs')
puts sparky.info # => Spartacus weighs 45 lbs and is 24 inches tall.
-
失败的原因:
在上述代码中Ruby误以为我们是想创建新的变量,分别叫name/height/weight了.
所以就会发现@name等变量并没有改变.
使用self method进行修正:
def change_info(n, h, w) # using self method
self.name = n
self.height = h
self.weight = w
end
- 为了保持一致,统一将调用getter method 的地方加上self.
def info
"#{self.name} weighs #{self.weight} and is #{self.height} tall."
end
- 最终结果是形成一个惯例(convention):
- class 内,用到instance variable的地方使用getter method ;
- class内,除setter method以外,需要改变instance variable值的地方统一使用setter method;
- 在class内使用到getter / setter method 的地方都使用self method
3.关于类(class)
3.1 class variable:
3.1.1 作用:
不知道怎么描述,所以通过下面的代码进行感受.
3.1.2 定义方法:
- 语法:
- 使用"@@"作为开头;
- 紧跟着是能够描述想要记录属性的小写的英文单词.
- 示例:
class GoodDog
@@number_of_dogs = 0
def initialize
@@number_of_dogs += 1
end
end
3.2 类方法(class method):
3.2.1 作用:
3.2.2 定义方法:
- 语法:
- 使用self method;
- 用小写单词命名.
- 示例:
class GoodDog
@@number_of_dogs = 0
def initialize
@@number_of_dogs += 1
end
def self.total_number_of_dogs
@@number_of_dogs
end
end
puts GoodDog.total_number_of_dogs # => 0
dog1 = GoodDog.new
dog2 = GoodDog.new
puts GoodDog.total_number_of_dogs # => 2
3.3 常量(constants):
其实和class并没有什么关系.
3.3.1 为什么要有常量:
有时候我们无论如何都不想要定义的量的值改变,这时就使用常量.
3.3.2 常量的定义方法:
- 语法:
- 使用首字母大写的英语单词;
- Rubyist习惯上将常量的所有字母都大写.
- 示例:
class GoodDog
DOG_YEARS = 7 # constants
attr_accessor :name, :age
def initialize(n, a)
self.name = n
self.age = a * DOG_YEARS
end
end
sparky = GoodDog.new("Sparky", 4)
puts sparky.age
3.4 The to_s method:
这部分其实和class也没有什么关系.
3.4.1 自动调用to_s method的两种情况 :
-
puts method 自动调用to_method.
示例:
---这里输出的结果是:前面是sparky这个对象对应的class(GoodDog),紧跟的一串数字/字母是这个是这个对象的ID编码--- puts sparky # => #<GoodDog:0x007fe542323320>puts sparky 等价于puts sparky.to_s
-
字符串插值(string interpolation)自动调用to_s method:
- 字符串插值(string interpolation)就是将常量或者变量插入字符串中.
示例:
irb :001 > arr = [1, 2, 3] => [1, 2, 3] irb :002 > x = 5 => 5 irb :003 > "The #{arr} array doesn't include #{x}." => The [1, 2, 3] array doesn't include 5.在这里字符串插值自动的调用to_s method,然后将arr 和 x 两个变量转换成了对应的值,然后与字符串结合在了一起.
3.4.2 了解to_s method的自动调用的益处:
虽然当前感觉了解to_s method是无关紧要的,但这却会在日后帮助我们更好的读写oo code.
3.5 进一步了解self method
上面有两处使用了self method:
- 告诉Ruby我们想要调用的是setter method,而不是创建新的变量;
- 使用self method帮助定义class method.
那么self究竟是什么?
3.5.1 self指代object:
代码示例
class GoodDog
# ... rest of code omitted for brevity
def what_is_self
self
end end
sparky = GoodDog.new('Sparky', '12 inches', '10 lbs')
p sparky.what_is_self
# => #<GoodDog:0x007f83ac062b38 @name="Sparky", @height="12 inches",
@weight="10 lbs">
通过上述代码我们可以发现self指代的是object(sparky)
3.5.2 self指代class:
代码示例:
class GoodDog
# ... rest of code omitted for brevity
puts self
end
irb :001 > GoodDog
=> GoodDog
通过上面我们得出self指代的是GoodDog这个class.
3.5.3 如何判断self指代什么:
- self,insideofaninstancemethod,referencestheinstance(object)thatcalledthemethod - the calling object. Therefore, self.weight= is the same as sparky.weight= ,in our example.
- self,outsideofaninstancemethod,referencestheclassandcanbeusedtodefineclass methods. Therefore, def self.name=(n) is the same as def GoodDog.name=(n) ,in our example.
4. 继承(inheritance)
4.0 继承的对象:
继承的东西是superclass中的behavior.
4.1 继承的作用:
通过继承能够实现代码复用,从而达到以下好处:
- 除去写重复代码的麻烦;
- 方便debug.
4.1 继承的两种方式:
- class inheritance
- mixing in module
4.2 class inheritance:
4.2.1 语法:
使用
<符号去标记继承方向.
示例:
class Animal
def speak
"Hello!"
end
end
class GoodDog < Animal # 标记GoodDog从Animal继承behavior
end
class Cat < Animal
end
sparky = GoodDog.new
paws = Cat.new
puts sparky.speak # => Hello!
puts paws.speak # => Hello!
4.2.2 继承behavior的overring
当subclass中有与superclass中想相同的method时,subclass的object调用的就是subclass中的method.
示例:
class Animal
def speak
"Hello!"
end
end
class GoodDog < Animal
attr_accessor :name
def initialize(n)
self.name = n
end
def speak
"#{self.name} says arf!"
end
end
class Cat < Animal
end
sparky = GoodDog.new("Sparky")
paws = Cat.new
puts sparky.speak # => Sparky says arf!
puts paws.speak # => Hello!
4.3 super
4.3.1 作用
在subclass中调用superclass中与instance method同名method.
示例:
class Animal
def speak
"Hello!"
end
end
class GoodDog < Animal
def speak
super + " from GoodDog class"
end
end
sparky = GoodDog.new
sparky.speak # => "Hello! from GoodDog class"
4.3.2调用super的三种状况:
- 不含参数:
class Animal
def speak
"Hello!"
end
end
class GoodDog < Animal
def speak
super + " from GoodDog class"
end
end
sparky = GoodDog.new
sparky.speak # => "Hello! from GoodDog class"
- 含参数,但是不指定:
class Animal
attr_accessor :name
def initialize(name)
@name = name
end
end
class GoodDog < Animal
def initialize(color)
super
@color = color
end
end
---这里因为使用了super 所以初始化object的时候调用了Animal中的initialze method,从而导致bruno多了一个属性--name ---
bruno = GoodDog.new("brown") # => #<GoodDog:0x007fb40b1e6718,@color="brown", @name="brown">
- 指定参数:
class BadDog < Animal
def initialize(age, name)
super(name)
@age = age
end
end
BadDog.new(2, "bear") # => #<BadDog:0x007fb40b2beb68 @age=2,@name="bear">
4.4 Mixing in module
4.4.1 为什么要有mixing in module:
[图片上传失败...(image-614c12-1510277893483)]
已上图为例,如实Cat 与Dog有相同的behavior,这个时候我们就可以将它提取出来,放在Mammal中,通过继承来使用.
那么问题来了,Dog与Fish也有相同的behavior—swim,这个时候显然不能将对应的method提取出来放到Mammal或者是Animal中(因为Cat不可以swim).解决方案就是使用Mixing in module .
4.4.2 mixing in module的思路
就是将两个或者多个无法通过继承来dry up 的code 封装到一个容器中,然后让这些class调用这个容器中的内容.
具体来说是这样.将Fish与Dog都有的behavior(swim)用Swimmable这个module进行封装,然后让Fish与Dog进行调用.
4.4.3 mixing in module 的定义:
示例:
module Swimmable
def swim
"I'm swim."
end
end
解释:
- 使用首字母大写的单词;
- rubyist 习惯上将单词以able作为后缀.
4.4.4 mixing in module 的使用:
module Swimmable
def swim
"I'm swimming!"
end
end
class Animal; end
class Fish < Animal
include Swimmable # mixing in Swimmable module
end
class Mammal < Animal
end
class Cat < Mammal
end
class Dog < Mammal
include Swimmable # mixing in Swimmable module
end
语法:
include modulename
5.其他:
5.1 Method lookup path:
5.1.1 定义:
object在调用方法(method)时,是按照一定顺序进行的,这个顺序就叫method loopup path.
5.1.2 知道method lookup path的作用:
当我们研究一个较大的项目时,可能会困惑于那些方法是哪来的.但是若是知道了method lookup path,便能够较好的理解那些方法是在哪儿,以及是如何组织的.
5.1.3 使用ancestors查询method lookup path:
以下述代码为例,如何才能知道Animal的object的method loopup path呢?
module Walkable
def walk
"I'm walking."
end
end
module Swimmable
def swim
"I'm swimming."
end
end
module Climbable
def climb
"I'm climbing."
end
end
class Animal
include Walkable
def speak
"I'm an animal, and I speak!"
end
end
使用ancestors method :
puts "---Animal method lookup---"
puts Animal.ancestors
结果:
--- Animal method lookup ---
Animal
Walkable
Object
Kernel
BasicObject
5.1.4 method lookup path:
顺序:
- 在初始化对象的类中查找
- 在该对象的module中查找(按照mixing进的module的顺序,进行倒序查找)
- 在该类的父类中查找
示例:
module Walkable
def walk
"I'm walking."
end
end
module Swimmable
def swim
"I'm swimming."
end
end
module Climbable
def climb
"I'm climbing."
end
end
class Animal
include Walkable
def speak
"I'm an animal, and I speak!"
end
end
class GoodDog < Animal
include Swimmable
include Climbable
end
puts "---GoodDog method lookup---"
puts GoodDog.ancestors
输出结果:
---GoodDog method lookup path ---
GoodDog
Climbable
Swimmable
Animal
Walkable
Object
Kernel
BasicObject
5.2 module的另外两种用法:
1.用于namespacing;
2.作为container of methods
5.2.1 用于namespacing:
作用:
- 将同类型的class归类放在一起;
- 区分具有相同名字的class
定义方法:
module Mammal
class Dog
def speak(sound)
p "#{sound}"
end
end
class Cat
def say_name(name)
p "#{name}"
end
end
end
如何使用module中的class初始化对象:
buddy = Mammal::Dog.new
kitty = Mammal::Cat.new
buddy.speak('Arf!') # => "Arf!"
kitty.say_name('kitty') # => "kitty"
5.2.2 作为container of methods (module methods)
定义方法:
module Mammal
...
def self.some_out_of_place_method(num)
num ** 2
end
end
调用方法:
- 法一:
value = Mammal.some_out_of_place_method(4)
- 法二:
value = Mammal::some_out_of_place_method(4)
5.3 私有/公共/?；し椒?private/public/protected):
5.3.1 私有方法(private method)
作用:
有时候我们只想让某个方法在class内部发生作用,而不再外部被调用,这个时候就使用private method.
定义方法:
使用保留字:private
class GoodDog
DOG_YEARS = 7
attr_accessor :name, :age
def initialize(n, a)
self.name = n
self.age = a
end
private # method following "private is pirvate method
def human_years
age * DOG_YEARS
end
end
sparky = GoodDog.new("Sparky", 4)
sparky.human_years
说明:
私有方法(private method)只能在instance method中被调用,且是直接调用不能用self method.
即使是objectname.privatemethod的形式也不行.
5.3.2 ?；し椒?protected method)
作用:
有时候我们想要在instance method中使用self.privatemethod或者objectname.privatemethod,的形式,但是有不想外界调用,这是就使用protected method.
语法:
使用保留字:protected
class Animal
def a_public_method
"Will this work? " + self.a_protected_method
end
protected
def a_protected_method
"Yes, I'm protected!"
end
end
class Student
def initialize(name, grade)
@name = name
@grade = grade
end
def better_grade_than?(other_student)
grade > other_student.grade
end
protected
def grade
@grade
end
end
joe = Student.new("Joe", 90)
bob = Student.new("Bob", 84)
puts "Well done!" if joe.better_grade_than?(bob)
5.4 偶发的方法重写(accidental method overrding)
5.4.1 产生原因:
因为所有自己创建的类都继承自class Object,这就导致当有些method与Object中的method同名时,发生method overring.
示例:
例如:Object的send method可以调用某个方法,但是若被重写了,就会出问题.
class Child
def say_hi
p "Hi from Child."
end
def send
p "send from Child..."
end
end
lad = Child.new
lad.send :say_hi
报错:
ArgumentError: wrong number of arguments (1 for 0)
from (pry):12:in `send'
5.4.2 启示:
要熟知一些常见的Object methods,避免发生重写(overrding),否则会对应用造成灾难性的后果.
