Qo_Tn
第三章学习
3.1 创建字符串
-
String：
- 单引号或双引号 创建。
- 单引号字符串 只能进行最少替换。
- 双引号字符串 对于括起来的字符串能进行更多替换。 例如替换转义字符串和其他特殊字符。
字符串 含义 \a 替换成Bell 声所对应的符号 \nnn nnn表示一个八进制数值，替换成该八进制所对应的字符 \b 退格符，替换成退格键所对应的字符 \xnn xnn 表示一个十六进制数值，替换成该十六进制数所对应的字符 \e 替换Escape键所对应的字符 \cx 替换成Ctrl+X 组合键所对应的字符，其中x可以是任意键对应的字符 \C-x 替换成Ctrl+X 组合键所对应的字符，其中x可以是任意键对应的字符 \n 换行符，替换成一个空行 \M-x 替换成Alt+X 组合键所对应的字符串，其中x可以是任意键对应的字符 \r 回车符，替换成一个回车 \M-\C-x 替换成Ctrl+Alt+X组合键所对应的字符串，其中x可以是任意键对应的字符 \s 空白符，替换成一个空白字符 \t 替换成一个Tab键所对应的字符 \v 替换成一个垂直Tab键所对应的字符 #{expr} 替换成变量或者表达式expr所对应的值
3.2 操作字符串
-
String类 和 Sysbol类
- 这两个类提供了文本功能，通过使用这两个类中的方法可以操作字符串。
- '+' 合并 两个或两个以上 字符串
- '<<' 为已有字符串变量永久性地增加另一个字符串。
- '#{}' 嵌入字符串变量，返回新的字符串
- 拼接字符串还可以使用乘法运算，即一个字符串复制出相应倍数字符串的链接
- 内置 replace 方法可以替换字符串中的内容
- dup、clone 方法 来复制字符串
- dup 只能复制字符串的内容
- clone 除了内容以外，还继承了特殊方法、污染(taint)、冻结(freeze)等信息
- 改变字符串 的 方法
方法 说明 capitalize 将字符串首字母转换为大写 upcase 将字符串中所有的字母转换为大写 downcase 将字符串中所有的字母转换为小写 swapcase 将字符串中大写字母转为小写，小写字母转为大写 strip 去掉字符串中的首尾空格 Lstrip 去掉字符串中左边的空格 Rstrip 去掉字符串中右边的空格 Chop 删除字符串中的最后一个字符 chomp 删除字符串中的最后的换行符 reverse 将字符串中反转过来 - 获取字符和子字符串 用 '[ ]' , '[ ]' 方法的参数是字符的索引，该方法返回一个字符，可以使用ord方法把字符转换为 ASCII 值。为 [ ] 方法添加两个参数，还可以从字符串中获取指定长度的子字符串。
- 当字符串索引: 正左负右，正0负-1 。
- '==' 比较是否相等
- '<=>' 比较字符串的大小 -1 0 1
例如：
puts "-------------------------------------------------------------------------- " #合并字符串 a="合并" b="字符串" c=a+b puts c puts "-------------------------------------------------------------------------- " a<<b # 为已有的字符窜增加另一个字符串 puts a puts b puts "-------------------------------------------------------------------------- " puts "#{a}#{b}" puts "-------------------------------------------------------------------------- " puts "#{a}#{b}"*3 puts "-------------------------------------------------------------------------- " #替换字符串 str="替换的字符串" a=str str.replace("这里用来替换内容") puts str puts a #复制字符串 str="复制字符串的内容" puts str.dup puts str.clone #改变字符串 str="abcdefgWWW，大写" puts str.upcase #获取字符和子字符串 str="abcdefgWWW.help" puts str[2] puts str[7].ord puts str[4,5] puts str[-3] puts str[100] #比较字符串 str="比较字符串,str" itzcn="比较字符串,itzcn" if str==itzcn puts "这两个字符串内容想等" else puts "这两个字符串内容不相等" end #大小 puts 'a'.ord #输出a的ASCII 值 puts 'b'.ord #输出b的ASCII 值 puts 'b'<=>'a' #比较大小，将返回1 if ("a">"b") # 比较大小，将返回false puts "a大于b" else puts "a小于b" end
3.3 Hash对象
- 哈希表时最常用的索引集合之一，用来保存数据
- Hash 类似于 Dictionary
- 可动态 添加实例
Hash对象 常用的方法:
| 方法 | 说明 |
|---|---|
| size() | 返回Hash对象的长度 |
| length() | 返回Hash对象的长度 |
| include?(key) | 判断指定的Hash 对象 是否包含指定的key |
| has_key?(key) | 判断指定的Hash 对象是否包含指定的key |
| delete(key) | 删除Hash 对象中指定key的对应元素 |
| keys() | 返回由Hash 对象中全部key组成的数组 |
| values() | 返回由Hash对象中全部value 组成的数组 |
Hash对象 的迭代器方法:
| 迭代器方法 | 说明 |
|---|---|
| each | 迭代输出Hash对象里面的全部元素(包括key 和 value) |
| each_key | 迭代输出Hash对象里面所有key |
| each_pair | 迭代输出Hash对象里所有key-value对 |
| each_value | 迭代输出Hash对象里所有value |
#Hash 对象
person={ #创建Hash对象
"name"=>"Tom",
"age"=>25,
"sex"=>"男"
}
puts person
persons=Hash.new #创建Hash类实例
persons["name"]="Tom" #添加元素
persons["age"]=25
persons["sexx"]="男"
puts persons
puts persons.size()
puts persons.length()
puts persons.include?("name")
puts persons.has_key?("age")
persons.delete("sexx")
puts persons
puts persons.keys()
puts persons.values()
# Hash 迭代方法
persons.each do |name|
p "1#{name}"
end
p persons.each_key
p persons.each_pair
p persons.each_value
3.4 数组
- 数组事数据对象的集合
- 带有索引的集合，都是动态的，长度可变
- 数组的索引 可以为正数，也可以为负数，正0负-1 原则
- 使用size方法来访问数组的长度
将多个空格的字符串转换为数组，使用%w{...}或者%W{...}表示法，这两种表示法功能大致相同。使用大些W的方法，会对内部转义字符和特殊字符进行替换。
| 方法 | 说明 |
|---|---|
| unshift() | 向数组的头部添加数组元素 |
| push() | 向数组的尾部添加数组元素 |
| << | 向数组的尾部添加一个数组元素 |
| shift | 向数组头部删除数组元素 |
| pop | 向数组的尾部删除数组元素 |
| array[n,m] | 截取从索引n开始，长度为m的元素列表，组成新数组 |
| array[n..m] | 截取从索引n开始, 到索引m的元素列表(包括索引m的数字元素)，组成新数组 |
| array[n...m] | 截取从索引n开始，到索引m的元素列表(不包括索引为m的数组元素), 组成新数组 |
例如：
#数组
food=["大米","小米","黑米","虾米","红米","玉米","粟米"]
p food
food[5]="水果"
p food
food[8]="玉米"
p food
food=Array.new
food[0]="大米"
p food
str=%W{上海\s自来水\s来自\s海上} #使用%W
str2=%w{上海\s自来水\s来自\s海上} #使用%w
p str
p str2
#添加删除
food.unshift("小米")
food.push("黑米")
food<<"玉米"
p food
#food.shift
#food.pop
#p food
a=food[1,2]
b=food[1..2]
c=food[1...2]
p a,b,c
food_1=["大米"]
food_2=["小米","香蕉"]
food_1.concat(food_2)
p food_1
p food_2
3.5 类型转换
-
类型转换
方法 说明 to_s 将获取的对象转换为字符串 to_i 将获取的对象转换为整数 to_f 将获取的对象转换为浮点
class Computer #定义Computer 类
def initialize(name) #定义构造函数
@name=name
end
def to_s #定义to_s方法
"电脑型号: #{@name}"
end
end
computer=Computer.new("方正") #实例化Computer 类
puts computer.to_s # 调用to_s方法
puts computer # 输出car对象
pinpai="诺基亚"
xinghao="5000"
color="紫色"
shangshi_date="2008年5月"
price="410"
sale=0.8
puts "品牌："+pinpai
p "型号："+xinghao
p "颜色："+color
p "上市时间："+shangshi_date
p "市场价格："+price
p "优惠价格："+(price.to_i*sale).to_s
第四章学习
4.1 面向对象
- 对象、类、对象的状态、对象的行为、类的关系、对象的消息
- 封装、继承、多态
4.2 创建类
-
类的定义和使用
- class 声明 end 结束
class Animal # 这里写类的结构 end -
类中的表达式
#类的表达式 class Animal puts "这里定义了一个Animal类" puts "这里在Animal类中打印了两行文本" end -
self 关键字
class Animal puts self puts self.class def put puts self puts self.class end end a = Animal.new a.put -
追加类
- 定义好一个类以后，还可以对其进行追加操作。只要是同名的类，对其进行添加功能。在使用类时，系统会自动将两个或多个同名的类合并使用。
class Animal def put p "这是put方法" end end class Animal def show p "这是show方法" end end a=Animal.new a.put a.show -
嵌套类
- 类中声明另外一个类
- 嵌套类用‘ :: ’来引用
class Animal class Head def put puts "这里Head类里的put方法" end end end h=Animal::Head.new h.put -
特殊类
- 在Ruby 中还允许为某个特定的对象追加一些方法和属性，这些方法和属性封装到一个类中直接追加到对象中。这个类没有特定的类名，所以并不能作为普通的类使用，所以我们称其为特殊类。
class Animal #一个空的Animal类 end a=Animal.new class <<a def put puts "这个是特殊类的put方法" end end a.put
4.3 方法
- 方法是类中执行其行为的成员，类的所有行为都将以方法的形式来进行执行和处理
- 脱离了类，也可以使用方法，不过在没有类的情况下定义的方法我们通常称之为“函数”
方法 如下
def methodName(arg1, arg2, ....argN)
#方法体
end
- 参数可以不用括号来标识，如果省略括号，方法名和参数列表之间需要有空格进行分隔，调用方法时使用的括号也可以省略。
class Animal
def eat(food)
puts "这个动物正在吃"+food
end
end
ani=Animal.new
ani.eat("馒头")
-
参数的默认值
class Dog def eat(food="骨头") puts "小狗正在吃"+food end end dog=Dog.new dog.eat("肉") dog.eat -
方法的返回值
class Dog def GetHobi "肉" end def GetWeight return "12kg" end end dog=Dog.new puts "小狗喜欢吃#{dog.GetHobi}" puts "小狗的体重为#{dog.GetWeight}" -
特殊方法
class Dog # 一个空的Dog类 end dog=Dog.new def dog.show puts "我是一个只有12kg体重的小胖狗" end dog.show -
定义类的方法
- 类方法需要使用 类名 和 点运算符 做为方法名的前缀
class Dog def Dog.show puts "我是一只有12kg体重的小胖狗" end end Dog.show
- 类的方法 不一定要声明在类中，它可以在类的外部单独声明。
- 类的方法 声明在类中，可以使用self关键字来代替类名
4.4 实例变量 和 类变量
-
实例变量
- 实例变量用于在类内部共享数据
- 声明位置 顶部、顶部方法、类、类方法、模块、模块方法
- 实例变量 以@开头
@Name="Tom" class Cat @Color="黄色" def init @weight="3kg" end def show puts "#@Name 是一只 #@Color 的有#@weight 体重的小懒猫" end end cat=Cat.new cat.init cat.show -
类变量
- 位置与实例变量相同
- 类变量需要 以两个“@”开头
@@master="张浩华" class Cat def say puts "我是一只小懒猫，我的主人是#@@master" end end class Dog def say puts "我是一只小笨狗，我的主人是#@@master" end end cat=Cat.new cat.say dog=Dog.new dog.say
4.5 属性
-
属性对类的外部提供了一个访问 类内部实例变量的接口，我们可以通过它来操作类的实例变量
-
属性读取器 和 设置器
class Person def name @name end end p=Person.new puts p.name -
如果要为类的实例变量 追加一个设置器，我们还要为其创建一个设置方法
-
设置实例变量值的属性方法比较特殊，命名时需要以等号“=”为后缀，并且必需设置一个方法参数
class Person def name=(val) @name=val end end p=Person.new p.name="joker" -
属性定义标识符
- 四个标识符: attr 、attr_reader 、 attr_writer 、attr_accessor
- 四个标识符为内建方法
class 类名 attr:attr1,key attr_reader:attr1,attr2 attr_writer:attr1,attr2 attr_accessor:attr1,attr2 end- 这里的 :attr1 是类中实例变量的名称，不过这里要把实例变量名称的前缀at符号“@”换成冒号“:”
- attr 根据布尔型数据key的值，定义一个可读写的属性。如果key的值为false，则设置属性的访问权限为只读
- attr_reader 定义一个或多个只读的属性
- attr_writer 定义一个或多个只写的属性
- attr_accessor 定义一个或多个可以读写的属性
class Dog attr:name,true attr_reader:weight end
4.6 构造方法
-
构造方法是在实例化类时要执行的类的方法，且该方法在创建每一个类的实例的时候都会被调用。
-
构造方法 可以接收 0个或多个参数，这样就可以在初始化类的对象的时候 直接为该对象的实例变量设置初始值。
-
构造方法的名称统一为 initialize ,也就是说当调用类的 new 方法创建类的实例的时候，系统会自动调用 initialize 方法来初始化该对象。
class Car def initialize(brand,color) @brand=brand @color=color end def show puts "这是一辆 #@color 的 #@brand 轿车。" end end car=Car.new("BYD","红色") car.show class Pekingese def initialize(name,color,hobi) @name=name @color=color @hobi=hobi end def sayHello puts "汪汪" puts "我是 #@name" puts "我是 #@hobi" end attr_accessor :name, :color, :weight, :hobi end dog=Pekingese.new("小强","白色","吃肉") puts "这里我们得到一只 #{dog.color} 的小狗，\n让它来给我们打个招呼: \n汪汪 \n我是小强 \n我喜欢吃肉" dog.sayHello
4.7 在方法中使用块
-
Ruby 重用性 => 代码块
-
代码块用 话括号的方式 和 do-end 语句 的方式。
{ #代码块内容 } do #代码块内容 End -
代码块可以作为一个参数传递给方法，然后方法中可以使用yield 关键字调用传入的代码块
def say puts "Hello" yield puts "Bye" end say do puts "What you say?" end -
代码块添加参数，方法体中使用 yield 关键字调用代码块的时候传入参数，在带参数的代码块中需要以 “|arg1,arg2|” 的格式声明参数。
def say name="joker" puts "Hello,I'm"+name yield name end say do |name| puts "Hello,"+name end -
代码块不只能有参数，还可以具有返回值。和一般的方法一样，代码块的返回值也是使用最后一个表达式的值，而且在方法中也可以获取和使用代码块的返回值。
def say puts yield end say do "Hello,Joker" end
4.8 类的继承
-
继承可以共享父类的成员，实现代码的复用。
-
继承可以使子类直接使用父类的方法和变量，等于说一个类的另外一个类开辟了特殊的访问权限。
-
在类的继承中，被继承的类称为基类，也可以称为父类; 继承基类的类称为派生类，也可以称为子类。
-
子类继承父类最大的特点就是实现饿了代码的重用，因为子类可以从父类中获取父类中已有的属性和方法。
-
方法：'<' 后追加一个父类的名称即可
-
子类继承父类的元素
-
super 关键字主动的调用父类的同名方法，如果父类的构造方法中有参数列表，可以使用super关键字追加这个参数列表。
class Bird #这是一个鸟类 end class Chick<Bird #这是一个小鸡类 end class Bird def initialize @wing=2 end end class Chick<Bird def show puts "这只小鸡有 #@wing 只翅膀" end end chick=Chick.new chick.show
4.9 访问作用域
-
访问作用域关键字 private、protected、public
-
private 私有方法，被该方法指定的成员只可以被该类内部访问，成员对类外部是不可见的。
-
protected 保护方法，被该方法指定的成员可以被任何隶属的子类访问。
-
public 公有方法，被该方法指定的成员可以被任何类或对象调用，没有访问权限。(成员声明时默认就是 public、initialize 方法除外)
-
声明类属性一样将方法名作为参数传递给三个作用域 控制方法来指定访问级别
class Bird def fly # 前面没有访问修饰，默认为public end private #定义为私有方法 def eat end protected # 定义为 保护的方法 def run end public # 定义为公有的方法 def jump end end class Bird def fly end def eat end def run end def jump end private(:eat) # 定义为私有方法 protected(:run,:jump) # 定义为保护的方法 end
网友评论