面向对象知识详解,学习笔记

By admin in 4858.com on 2019年6月2日

跟笔者一齐学ruby
By Tiger
注:本课程转发自在玩耍先行者论坛,版权属于小编泰格。
第一篇
第二篇

跟自身联合学ruby 
By Tiger 
注:本学科转发自在戏耍先行者论坛,版权属于小编Tiger。 
第一篇 
第二篇 

ruby语言跟c#的有个别第一出入在于:
一.ruby是动态语言,c#是静态语言–即对象在new出来未来,ruby还足以动态给指标实例增加一些性质或方法(javascript也是这么)
二.ruby中刻意弱化了变量类型那几个定义,默许情况下变量/方法都无需评释具体(再次来到)类型,但事实上在ruby内部,会自动依照变量的值分配项目。(能够经过
“puts 变量.class“查看)
3.ruby相对c#来说,大概有个别雷的地方在于:父类中的private成员,居然是能够在子类中利用的!
…别的地点,等求学深刻了再写出来
最后上一段测试代码,展示了ruby中类的主干用法:

Ruby 是纯面向对象的言语,Ruby 中的1切都以以指标的款型出现。Ruby
中的每种值都是二个对象,尽管是最原始的东西:字符串、数字,以致连 true 和
false 都是指标。类本人也是三个对象,是 Class
类的一个实例。本章将向您解说全数与 Ruby 面向对象相关的基本点功能。

第一篇 自序

第一篇  自序 
从明天起作者快要起来学Ruby了。怎样,没见吧?1个新人写教程。就凭笔者强项的恒心,科学的自学方法,以及作者的探究精神,笔者有信心学通Ruby,而同样是新手的您也足以!由于本学科是菜鸟教莱鸟若有哪些窘迫的地点还请前辈指教!假设没人看,就当作者自愚自乐了。 
====================================================================== 
卷首语 
————————————————————————– 
预备知识 
一、为何要学Ruby? 
不用说分明是支持发挥卡宴M的潜在的力量啦。而Ruby有多广大坏都与作者非亲非故,因为小编学它只为了贰个缘故–CRUISERM! 
二、什么是Ruby?  它是一种纯粹的面向对象编制程序的脚本语言。那就像C语言啦,正是1种计算机听得懂的言语,就好比你对Computer大叫一声“笔者要上网”它是不会让您上网的,必须通过1种语言来报告它,Ruby就是个中之1,当然Ruby也要用打地铁,不是用说的… 
3、学Ruby要预备吗?当然是汉兰达M了,作者还计划了多少个东西:  .台式机–别看不起它,那只是重大,你的一部分疑点与炅感、研商得出的下结论都可记在上边. 
.七个新工程,作者临时把它命名字为Test,它将用研商与执行. 
.另二个新工程,小编有时把它定名称为正式,它的机能是万1你把自带的Ruby改得万象更新,有它能够做参谋。当然中华VM的脚本数据是保留在
Data 文件夹内的 Scripts.rxdata 文件中的,你也能够对此文件进行备份。 
————————————————————————– 
实行基础 
一、关于脚本脚本编辑器:  .GL450M中,进入脚本脚本编辑器的不二等秘书籍是按F1一或在主菜单「工具」菜单中接纳「脚本编辑器」。。 
.脚本编辑器中有的急迅键(多谢carol叁,那不是自己意识的): 
tab:能够跳格、能够活动举办缩进 
ctrl + 鼠标滚轮 : 调度文字的大小 
ctrl + F:查找本页脚本 
ctrl + shift + F:查找全体脚本 
ctrl + H:替换 
ctrl + A:全选 
ctrl + C,ctrl + V:拷贝粘贴 
ctrl + Z,ctrl + Y:撤废与重做 
F三:和ctrl + F配套使用,”查找下3个” 
F四,F5:接纳上三个/下2个脚本 
F6:把以往选的那一行命名叫本脚本名 
ctrl + enter:保存并关闭本窗口 
二、创立程序的步子:  .鲜明程序的目标-举例你的靶子是做三个求三角形面积的主次。 
.明确要动用什么的秘技-作者通晓S=四分之二ah=一半abSinC,求角度太烦,且后者不是单身的测算运算,故吾选前者。 
.创造程序。 
三、编制程序中应养成的好习于旧贯:  .写注释。许多个人觉着写注释是在浪费时间——但别忘了——当你在写代码时,也许你的思路清楚;可是当程序日趋变大,或当您面前遭遇多少个月前写的代码时,注释的效劳就明摆着了。 
在 Ruby 中,# 符号前面包车型大巴1整行文字会料定为注释。当你要写大块的注释时,
也得以用 =begin 和 =end 的中级的全套为注释。 
疏解是蓝色的,不会奉行,不会潜移默化到程序的运作,只作为编写者标识的备忘记录来采用。 
未完成… 
4、编写翻译错误的意见 
当您拼写、语法有不当了,程序就能够停下运作,并报告您相关的音讯,此时再按F1一进来脚本编辑器,就能够看出光标放在了失误的那1行。 
如图: 
行:未伊始化的常量“Persond” 
现实的秘诀本人还从未下结论。未成功… 
————————————————————————– 
Type&Run 
(本来下文是不准备发的,但有一些人说本学科写的多少脱离奥迪Q7M,所以发了下文——不希图发的来由是自家不驾驭carol三的“汉兰达GSS区置顶脚本整理中,如今采访脚本:30,望我们增多”一帖中竟然有学科!而且有一点点与自个儿的大概大同小异,算了,为了保险教程的完整性,作者就把自个儿写的发上来了…绝非抄袭!) 
让大家来出手Ruby: 
试行:标题画面包车型客车片段自定义 
实施指标: 
.学会Ruby的研商情势。 
.学会依照注释来做一些实施。 
.熟知脚本编辑器中有的快速键的选择。 
张开脚本脚本编辑撰写器 
.在剧本脚本编辑器的左侧找到scene_title 
.能够在左边的筐架中看看第壹行: 
#===================================================================== 
# Scene_Title 
#—————————————————————————— 
# 管理标题画面包车型大巴类 
#===================================================================== 
小编们领悟那是注释,它的情趣正是说scene_title这代码是用于拍卖标题画面包车型客车。同理,大家得以任由看看别的的组(组就是看似scene_title的在剧本脚本编辑器的左侧的壹窜1窜的代码),怎么着,它们的用处综上说述吧! 
.既然知道它是用于拍卖标题画面包车型客车,大家就拿它开刀吧! 
旅游一下:读取数据库;生成系统对象;…那个都太深奥了在往下看—— 
s1 = ” 新游戏” 
s2 = ” 继续” 
s3 = ” 退出” 
算是看出了极度熟谙的中国字了,呵!那不是昂CoraM中标题画面包车型大巴选项吗! 
看看它上面的注释——生成命令窗口。果然是题目画面包车型客车选项。 
我们改了它尝试: 
s1 = “新的循环” 
s2 = “旧的记念” 
s三 = “随风而逝” 
按ctrl + enter:保存并关闭本窗口。 
再按F1二运作游戏。果然不负众望了! 
.人的野心总是Infiniti的,笔者还想加多3个有关本游戏!好再试试: 
s1 = “新的轮回” 
s二 = “旧的追忆” 
s三 = “随风而逝” 
s4 = “关于本游戏” 
.贪得无厌总有局地心虚,再看看它上边包车型客车内容再运行游戏吧! 
@command_window = Window_Command.new(192, [s1, s2, s3]) 
@command_window.back_opacity = 160 
@command_window.x = 320 – @command_window.width / 2 
@command_window.y = 288 
有x、y大盖是在说采纳的规模吧!糟了,多了二个精选,框框就决然要变长,假设不去修该层面包车型客车质量选项会现身选项不大概展现出来的地方。管它呢!就算是真正小编也无能为力… 
先是行有个(1九二, [s1, s2, s3])s壹,s1,s叁好象与s1 =
“新的巡回”等中的s一,s1,s叁说的是同2个事物呢?既然作者加了s4,就得把s四也加进去: 
@command_window = Window_Command.new(192, [s1, s2, s3,s4]) 
s四;s三之间学它样也用 , 连接。 
.再运营游戏。果然出现了有关本游戏选项而且规模也能活动调节把多个选用纳入其间。可知大家刚刚的推测是错的,有x、y大盖是在说框框 
的位置? 
由图可见:黑古铜色框中的星星与规模上端的相对地点在修改前后未有变过,而蓝框中规模下端与RPG字符的周旋地点的相对地点发生了转移,也正是说,框框上端的地方是不改变的,当有新的选项时,自动延伸框框的下端。而有x、y大盖是在说选拔的框框的下边包车型客车职分? 
.再试试: 

复制代码 代码如下:

类用于钦赐对象的花样,它结合了数据表示法和措施,把多少整理成二个几乎的包。类中的数据和方法被称为类的成员。

从明日起笔者将要起来学Ruby了。如何,没见吧?2个新妇写教程。就凭自个儿强项的恒心,科学的自学方法,以及我的钻研精神,笔者有信心学通Ruby,而一样是菜鸟的您也得以!由于本学科是新手教莱鸟若有哪些难堪的地点还请前辈指教!如果没人看,就当自家自愚自乐了。

复制代码代码如下:

class People
#跟javascript那类动态语言一样,ruby中的类也从不public,private那类访问调节标记符

Ruby 类定义

当您定义三个类时,您实际是概念了一个数据类型的蓝图。那实则并不曾定义任何的数码,而是定义了类的称谓意味着如何,也正是说,定义了类的指标将由哪些组成,以及在该对象上能实行什么样操作。

类定义以首要字 class 开始,后跟类名称,最终以一个 end
举办分隔表示终止该类定义。比方,我们运用首要字 class 来定义 Box类,如下所示:

class Box code end

依据常规,名称必须以大写字母初阶,假设带有八个单词,种种单词首字母大写,但那边未有分隔符(举个例子:CamelCase)。

卷首语

盘算知识
一、为啥要学Ruby?
决不说料定是支援发挥哈弗M的潜在的力量啦。而Ruby有多居多坏都与笔者非亲非故,因为笔者学它只为了3个原因–宝马7系M!
二、什么是Ruby? 它是一种纯粹的面向对象编制程序的脚本语言。那就如C语言啦,正是一种计算机听得懂的语言,就好比你对Computer大叫一声“作者要上网”它是不会让您上网的,必须经过一种语言来告诉它,Ruby正是中间之壹,当然Ruby也要用打大巴,不是用说的…
3、学Ruby要积谷防饥什么?当然是PRADOM了,小编还预备了多少个东西: .台式机–别看不起它,那可是根本,你的有的难题与炅感、商讨摄取的结论都可记在上边.
.二个新工程,小编暂且把它命名称为Test,它将用切磋与施行.
.另1个新工程,作者一时把它取名字为行业内部,它的效率是万一你把自带的Ruby改得别开生面,有它能够做参照他事他说加以考察。当然ENCOREM的剧本数据是保存在

s壹 = “新的大循环” 
s贰 = “旧的追思” 
s3 = “随风而逝” 
s四 = “关于本游戏” 
s5 = “asd” 
s6 = “sdasd” 
s7 = “weqw” 
@command_window = Window_Command.new(192, [s1, s2, s3,s4,s5,s6,s7]) 

    def initialize(_name) #构造函数,名字是定点:initialize
        @name = _name; #预约:类的私家变量以@发轫
    end

定义 Ruby 对象

类提供了目的的蓝图,所以基本上,对象是依据类举办创办的。大家应用 new
关键字证明类的对象。上面包车型客车话语注解了类 Box 的四个指标:

box1 = Box.new box2 = Box.new

Data 文件夹内的 Scripts.rxdata 文件中的,你也得以对此文件举行备份。

施行基础
1、关于脚本脚本编辑器: 面向对象知识详解,学习笔记。.奔驰G级M中,进入脚本脚本编辑器的格局是按F1壹或在主菜单「工具」菜单中选用「脚本编辑器」。。
.脚本编辑器中部分急速键(多谢carol三,那不是自家发觉的):
tab:能够跳格、能够自行实行缩进
ctrl + 鼠标滚轮 : 调解文字的深浅
ctrl + F:查找本页脚本
ctrl + shift + F:查找全体脚本
ctrl + H:替换
ctrl + A:全选
ctrl + C,ctrl + V:拷贝粘贴
ctrl + Z,ctrl + Y:取消与重做
F三:和ctrl + F配套使用,”查找下2个”
F肆,F五:选拔上三个/下多个本子
F陆:把前几日选的那1行命名叫本脚本名
ctrl + enter:保存并关闭本窗口
2、创立程序的手续: .明确程序的靶子-比如你的靶子是做多少个求三角形面积的顺序。
.明确要采Nash么的主意-笔者清楚S=二分之一ah=3/6abSinC,求角度太烦,且后者不是单身的企图运算,故吾选前者。
.创设程序。
三、编程中应养成的好习贯: .写注释。很几个人感到写注释是在浪费时间——但别忘了——当您在写代码时,只怕你的思路清楚;然则当程序日趋变大,或当您面前遭逢几个月前写的代码时,注释的职能就不言而喻了。
在 Ruby 中,# 符号前边的1整行文字会确定为注释。当您要写大块的解说时,
也能够用 =begin 和 =end 的中间的凡事为注释。
申明是莲灰的,不会施行,不会影响到程序的周转,只看做编写者标记的备忘记录来采取。
未完成…
四、编写翻译错误的观念
当您拼写、语法有不当了,程序就能停下运维,并报告您相关的消息,此时再按F1一进入脚本编辑器,就汇合到光标放在了失误的那一行。
如图:
行:未初步化的常量“Persond”

果然,有标题展现不出了。 
.再看看: 
s一 = “新的循环” 
s二 = “旧的想起” 
s三 = “随风而逝” 
s四 = “关于本游戏” 
@command_window = Window_Command.new(192, [s1, s2, s3,s4,s5]) 
这会出错。 
s1 = “新的大循环” 
s二 = “旧的回想” 
s三 = “随风而逝” 
s四 = “关于本游戏” 
@command_window = Window_Command.new(192, [s1, s2, s3]) 
有关本游戏将不会被展现。 
.今后的关于本游戏还无用处。大家可以参见”新的巡回””旧的追忆””随风而逝”来给它功用。凡是它们有些自个儿都给有关本游戏加上。往下看,注意到有: 
def update 
@command_window.update 
# 按下 C 键时 
if Input.trigger?(Input::C) 
case @command_window.index 
when 0 # 新游戏 
command_new_game 
when 1 # 继续 
command_continue 
when 2 # 退出 
command_shutdown 
end 
end 
end 
when-当…时,那好象类似条件分裂的尺度部分,注释告诉自个儿那是选择新游戏;继续;退出不一致命令的差异。 
那么command_new_game;command_continue;command_shutdown正是动作了。他们会不会是Ruby中早已定义过的事物?借使是那么您为有关本游戏写其它的东西是没用的。那就让关于本游戏和退出共用贰个东西啊: 

    def to_string #类似C#中的做法,这里写二个ToString方法的ruby版
        “My name is #{@name}”
#ruby中方法最终壹行的值,会被当作函数值再次回到
    end

initialize 方法

initialize 方法是三个行业内部的 Ruby
类方法,是类的构造函数,与其余面向对象编程语言中的 constructor
专门的学问原理类似。当您想要在成立对象的同有时间初步化一些类变量,initialize
方法就派上用场了。该方式包括一雨后鞭笋参数,与别的 Ruby
方法一样,使用该方法时,必须在前面放置 def 关键字,如下所示:

class Box def initialize(w,h) @width, @height = w, h end end

具体的不二秘籍本人还尚无下结论。未形成…

Type&Run
(本来下文是不准备发的,但有些人会说本课程写的有一些脱离帕杰罗M,所以发了下文——不策动发的因由是本身不亮堂carol三的“TiggoGSS区置顶脚本整理中,近期收集脚本:30,望大家增加”1帖中居然有学科!而且有点与自身的大致同样,算了,为了保险教程的完整性,小编就把小编写的发上来了…绝非抄袭!)
让大家来入手Ruby:
实践:题目画面包车型地铁某个自定义
奉行目标:
.学会Ruby的商量方法。
.学会依据注释来做一些试验。
.熟练脚本编辑器中有的快速键的利用。
开辟脚本脚本编辑器
.在剧本脚本编辑器的右侧找到scene_title
.能够在右侧的筐架中看出第三行:
#=====================================================================
# Scene_Title
#——————————————————————————
# 管理标题画面包车型大巴类
#=====================================================================
我们精晓那是注释,它的乐趣乃是scene_title那代码是用来拍卖题目画面的。同理,大家得以任由看看其余的组(组正是附近scene_title的在本子脚本编辑器的左边手的一窜壹窜的代码),如何,它们的用途一览无余吧!
.既然知道它是用以拍卖标题画面包车型地铁,大家就拿它开刀吧!
出境游一下:读取数据库;生成系统对象;…那几个都太深奥了在往下看——
s1 = ” 新游戏”
s2 = ” 继续”
s3 = ” 退出”
毕竟见到了相当纯熟的炎黄字了,呵!那不是GL450M中标题画面包车型大巴选项吗!
看望它下边包车型地铁注明——生成命令窗口。果然是标题画面包车型客车选项。
我们改了它尝试:
s1 = “新的巡回”
s二 = “旧的回想”
s三 = “随风而逝”
按ctrl + enter:保存并关闭本窗口。
再按F12周转游戏。果然成功了!
.人的野心总是Infiniti的,作者还想增添三个有关本游戏!好再试试:
s1 = “新的大循环”
s贰 = “旧的回忆”
s3 = “随风而逝”
s4 = “关于本游戏”
.贪得无厌总有部分心虚,再看看它下边的内容再运维游戏吧!
@command_window = Window_Command.new(192, [s1, s2, s3])
@command_window.back_opacity = 160
@command_window.x = 320 – @command_window.width / 2
@command_window.y = 288
有x、y大盖是在说选拔的层面吧!糟了,多了三个挑选,框框就必然要变长,假如不去修该层面包车型大巴天性选项会现出选项不恐怕出示出来的情景。管它吗!就终于真正本人也无能为力…
第1行有个(1玖贰, [s1, s2, s3])s一,s壹,s3好象与s一 =
“新的巡回”等中的s一,s1,s3说的是同三个事物吗?既然本人加了s四,就得把s四也加进去:
@command_window = Window_Command.new(192, [s1, s2, s3,s4])
s四;s3之间学它样也用 , 连接。
.再运转游戏。果然出现了有关本游戏选项而且规模也能自动调整把三个挑选纳入其间。可知大家刚刚的思疑是错的,有x、y大盖是在说框框
的位置?
由图可见:青莲框中的星星与范围上端的相对地点在修改前后未有变过,而蓝框中规模下端与RPG字符的周旋地点的绝对地点发生了调换,也等于说,框框上端的地方是不变的,当有新的选项时,自动延伸框框的下端。而有x、y大盖是在说选取的框框的上面包车型大巴地方?
.再试试:

复制代码 代码如下:

s一 = “新的大循环”
s2 = “旧的想起”
s三 = “随风而逝”
s4 = “关于本游戏”
s5 = “asd”
s6 = “sdasd”
s7 = “weqw”
@command_window = Window_Command.new(192, [s1, s2,
s3,s4,s5,s6,s7])

果然,有标题展现不出了。
.再看看:
s一 = “新的循环”
s2 = “旧的回想”
s三 = “随风而逝”
s四 = “关于本游戏”
@command_window = Window_Command.new(192, [s1, s2, s3,s4,s5])
那会出错。
s1 = “新的轮回”
s二 = “旧的追思”
s三 = “随风而逝”
s四 = “关于本游戏”
@command_window = Window_Command.new(192, [s1, s2, s3])
有关本游戏将不会被出示。
.将来的关于本游戏还无用处。我们得以参见”新的大循环””旧的想起””随风而逝”来给它效益。凡是它们有的笔者都给有关本游戏加上。往下看,注意到有:
def update
@command_window.update
# 按下 C 键时
if Input.trigger?(Input::C)
case @command_window.index
when 0 # 新游戏
command_new_game
when 1 # 继续
command_continue
when 2 # 退出
command_shutdown
end
end
end
when-当…时,那好象类似条件差别的原则部分,注释告诉小编这是采取新游戏;继续;退出差异命令的不一致。
那么command_new_game;command_continue;command_shutdown正是动作了。他们会不会是Ruby中壹度定义过的东西?假设是那么你为关于本游戏写其余的东西是没用的。那就让关于本游戏和退出共用一个事物吧:

复制代码 代码如下:

def update
@command_window.update
# 按下 C 键时
if Input.trigger?(Input::C)
case @command_window.index
when 0 # 新游戏
command_new_game
when 1 # 继续
command_continue
when 2 # 退出
command_shutdown
when 3
command_shutdown
end
end
end

运作之,果然是这么!按了有关本游戏就淡出了。可知command_shutdown是用来调用退出命令的。那它会不会是Ruby中1度定义过的事物?大家再往下看:
.
#————————————————————————–
# 命令:新游戏
#————————————————————————–
.
.
.
.
.
.
.
#————————————————————————–
# 命令:继续
#————————————————————————–
.
.
.
.
.
.
4858.com,.
#————————————————————————–
# 命令:退出
#————————————————————————–
那好象是在分拣研究。它们都以 def
xxxxxxx早先,而xxxxxxx的源委正是眼下分化中各选项所对的内容了。可知那它不是Ruby中早已定义过的事物。那就为大家自定义留下了退路:

复制代码 代码如下:

def update
@command_window.update
# 按下 C 键时
if Input.trigger?(Input::C)
case @command_window.index
when 0 # 新游戏
command_new_game
when 1 # 继续
command_continue
when 2 # 退出
command_shutdown
when 3
abc
end
end
end

复制一下 命令:退出中的内容,并粘贴在剥离后,把粘贴的内容中的 def
command_shutdown改为def abc。运转之效率和前边同样。
好了就自身现在的实力,也只能进行到此了,借使懂一些语法,能够把def

复制代码代码如下:

    def get_name_size
        return @name.length #其一措施中回到的是数字型(即名称的长度)
    end

实例变量

实例变量是类属性,它们在行使类创制对象时就改成对象的性质。每一个对象的性质是单身赋值的,和别的对象之间不共享值。在类的在那之中,是利用
@
运算符访问那一个属性,在类的外部,则是采纳称为访问器方法公共措施开展走访。上边大家以地点定义的类
Box 为实例,把 @width 和 @height 作为类 Box 的实例变量。

class Box def initialize(w,h) # 给实例变量赋值 @width, @height = w, h
end end

asd上边包车型大巴源委改一改。

总结

def update 
@command_window.update 
# 按下 C 键时 
if Input.trigger?(Input::C) 
case @command_window.index 
when 0 # 新游戏 
command_new_game 
when 1 # 继续 
command_continue 
when 2 # 退出 
command_shutdown 
when 3 
command_shutdown 
end 
end 
end 

    def test #类定义的末尾巴部分分,把那个法子标志为私家方法了
        puts “private method(test) in People.”
    end

做客器 & 设置器方法

为了在类的外表使用变量,大家不能够不在访问器方法当中定义那么些变量,accessor
其实一定于 getter。下边包车型客车实例演示了访问器方法的用法:

未完成…

作业
.程序开辟的手续?
.试着使用脚本编辑器中有个别快捷键。
提高题:
试着总计脚本编辑器使用中出现的1部分张冠李戴类型及其观念。

运作之,果然是那样!按了关于本游戏就淡出了。可知command_shutdown是用来调用退出命令的。那它会不会是Ruby中早已定义过的东西?我们再往下看: 

#————————————————————————– 
# 命令:新游戏 
#————————————————————————– 







#————————————————————————– 
# 命令:继续 
#————————————————————————– 







#————————————————————————– 
# 命令:退出 
#————————————————————————– 
那好象是在分拣钻探。它们都是 def
xxxxxxx初始,而xxxxxxx的剧情就是前方区别中各选项所对的从头到尾的经过了。可知那它不是Ruby中1度定义过的东西。那就为我们自定义留下了余地: 

    def show_name
        test #私家方法,可在里头调用
        puts “name = #{@name}”
    end

实例

#!/usr/bin/ruby -w # 定义类 class Box # 构造函数 def initialize(w,h)
@width, @height = w, h end # 访问器方法 def printWidth @width end def
printHeight @height end end # 成立对象 box = Box.new(十, 20) #
使用访问器方法 x = box.printWidth y = box.printHeight puts “Width of the
box is : #{x}” puts “Height of the box is : #{y}”

当上面的代码施行时,它会产生以下结果:

Width of the box is : 10Height of the box is : 20

与用于访问变量值的访问器方法类似,Ruby
提供了壹种在类的表面设置变量值的不二等秘书技,也正是所谓的设置器方法,定义如下:

未完成…

答案

第二篇

复制代码代码如下:

    attr_accessor:name
#概念三个可读写的性质,这里也展现了ruby的二个首要观念:约定重于标准,因为@name在头里早已选择过,这里的属性只需求把@去掉,ruby就能够活动智能的生成类似c#中
set{value = @name},get{return @name}的语句

实例

#!/usr/bin/ruby -w # 定义类 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(拾, 20) # 使用设置器方法 box.setWidth = 30
box.setHeight = 50 # 使用访问器方法 x = box.getWidth y = box.getHeight
puts “Width of the box is : #{x}” puts “Height of the box is : #{y}”

当上边的代码实施时,它会发出以下结果:

Width of the box is : 30Height of the box is : 50

首先章——类,对象和艺术

策画知识
既然如此说Ruby是1种纯粹的面向对象编制程序的脚本语言,那么本人就从指标开首学起。
一、对象是哪些?
玩耍中的任李强西都可以被能够分解为对象。
钱的数量是指标,科长是目的,流氓甲也是象。因为Ruby所能管理的值都是目的,为了便于对象的操作就推荐了类的定义。
二、类是怎么?
对象的类型就称为类。
镇长和流氓甲属于NPC类,钱的数额属于自然数类(注:这里所说的类你可以自个儿定,你也足以说区长和流氓甲属于人类:属于哺乳类:属于…)
有些新鲜的属于那个类的对象叫作类的实体(或实例)。
在平日生活中,大家对总体对象的分类都是有自然档次的。
我们了然:生物〉动物〉哺乳类〉人类
镇长和流氓甲属于人类,它就决然有哺乳类的性质,也就决然有动物的习性。咱们称生物是动物的父类,动物是生物子类,简单察觉子类会承袭父类的性情。当然也会遇上那样的事态:父类的一点品质不得以被某1一定的子类承接——尽管一般鸟类都会飞,但企鹅是小鸟中不会飞的2个子类。
获得自然界这种规律的启示,Ruby就推荐了承接。它大大收缩了程序猿的职业量,我们只需求定义3个父类(或称为超类)的性质,它的子类就会自行接二连三它父类的习性。当然当你相逢像上文谈到的分外企鹅特例还要新扩张或重定义子类和父类之间的界别。传承的乐趣,便是保障被后世的品质但却还要具有本人独有的特征。
引入了类只是有益对象的操作,那么毕竟怎么操作对象啊?那就要用方法了。
3、方法是如何?
办法是有个别类中享有的靶子专项使用的授命。
你只需在某些对象上调用有些方法就足以让那一个目的实施这几个艺术所表示的主意。而那些被操作的对象称为“作用实例”或是“方法的参数”。
举例说你养了重重狗,(狗是2个类,被您养的狗是它的子类)有一个叫旺财(旺财是目的,也是实例),你每一天磨练他们坐下(那是在概念多少个措施),之后每当你发号坐下这一个命令时(那是在调用坐下这些措施)被您养的狗就能坐下。(你就透过措施成功了对指标的操作)。尽管被您养的狗还分狼狗和哈巴狗2类,(狼狗和哈巴狗是被你养的狗的子类),它们会接二连三它父类中定义过的办法。当然一个类中能够定义大多情势(你能够教狗多数东西)。
又举个例子把Ruby看作CD机,CD机所操作的总体育赛事物——CD正是享有的靶子,类是歌曲的风格(如Rubicon&M是1类,Rap是另一类);当然你也得以把艺人当类的分法(如周杰伊(英文名:zhōu jié lún)是壹类,陈小胖是另1类),而调用方法就是按播放按键,结束按键,暂停按键等。
实行基础
在Ruby中创设三个对象并对其开始展览操作的步子如下:
首先得定义类的性质——
1、类的概念
格式:
class 类名
类中定义的情节
end
专注:类名必须以大写字母起先。
设借使三个子类仿佛此写:
class 子类名< 父类名
类中定义的剧情
end
或在概念前边平昔写上:
class 子类名 < 父类名
end
这只是让父类传承父类,不是重定义。为啥那样说呢?
光有三个类还非常,接着再往里面塞方法,以便以往对目的的操作。
2、方法的概念
措施的概念写在“类中定义的内容”这里
格式:
def
形式中定义的内容
end
瞩目:方法必须以小写字母开头。
本来当你相逢像上文聊起的特别企鹅特别的子类时,你还要重定义子类和父类之间的区分那叫称为重载,格式同上。方法的调用如反复定义,则以最后三次为准。
在子类方法中调用父类一样方法的动静下,要选用重要词
super。super将调用被当下形式覆盖的父类中的同名方法。
格式:
super(定义的剧情, … )
若省略括号和参数时,将会把当下格局的参数维持原状地传递给父类中的同名方法。若调用时不想利用参数的话,请使用括号显式地标记,像super()那样。
终极创立3个属于这么些类的对象(实例)——
三、实例的创始
格式:
实例名 =类名.new
实例终于成立好了,以往就该对它进行操作了。
肆、方法的调用
在ruby里,大家由此点 . 来调用2个对象的主意
格式:
已创制的实例名.方法名
若果您要开创1只不时存在的实例,并给其增进方法:
(类名.new).方法名
或:
类名.new.方法名

复制代码 代码如下:

class NPC
def intro
print “我是NPC?”
end
end
class Lioumang<NPC
def talk
print “XX在村落的南部”
end
end
流氓甲=Lioumang.new
流氓甲.talk #显示 我是NPC?
流氓甲.intro #因为流氓甲承继了它的父类的章程,所以展现 XX在村落的南方

说明:
~伍定义多个类——NPC
~1一定义一个NPC的子类——Lioumang
~四为NPC定义二个堪称intro的主意,print ”
“的做用是呈现“”内的东西。(先不要管它怎么运转的)
~⑩为Lioumang定义一个叫做talk的不二等秘书技
开创实例——流氓甲
为流氓甲调用talk的办法
为流氓甲调用intro的主意

复制代码 代码如下:

class NPC
def intro
print “aaa”
end
end
class Lioumang<NPC
def intro
print “bbb”
end
end
流氓甲=Lioumang.new
流氓甲.intro

说明:
体现的是bbb,可知方法的调萌绶锤炊ㄒ澹蛞宰詈笠淮挝肌5绻?三行变为
流氓甲=NPC.new 则展现aaa

复制代码 代码如下:

class NPC
def intro
print “aaa”
end
def talk
print “ccc”
end
end
class NPC
def intro
print “bbb”
end
end
流氓甲=NPC.new
流氓甲.intro
流氓甲.talk

说明:
先出示的是bbb,再彰显ccc,可知类如反复定义,则以保留他们混合的补集,他们的鱼目混珠以最后二回为准。但如果一三行变为
流氓甲=NPC.new 则彰显aaa。

复制代码 代码如下:

class NPC
def talk(a=nil) #nil为空集
p a
end
end
class Lioumang < NPC
def talk(a)
super(5) # 以5作为参数进行调用
super(a) # 以5看作参数进行调用
super # 以伍当作参数实行调用,super(a)的简写
a = 1
super # 以一看作参数实行调用,super(a)的简写
super() # 无参数的调用
end
end
Lioumang.new.talk 5

说明:
~四主意的成效是展现变量a,而a=nil,既体现nil
可知:若省略Super的括号和参数时,将会把当下艺术的参数原封不动地传递给父类中的同名方法。若调用时不想使用参数的话,请使用括号显式地方统一规范明,像super()那样。

def update 
@command_window.update 
# 按下 C 键时 
if Input.trigger?(Input::C) 
case @command_window.index 
when 0 # 新游戏 
command_new_game 
when 1 # 继续 
command_continue 
when 2 # 退出 
command_shutdown 
when 3 
abc 
end 
end 
end 

    private:test #标明test方法是private属性的
    protected:get_name_size
#标明get_name_size只可以在本类或子类定义中应用(大概在子类定义中赋值给子类实例)

实例方法

实例方法的定义与别的方法的概念一样,都是应用 def
关键字,但它们只好通过类实例来使用,如下边实例所示。它们的意义不防止访问实例变量,也能依照你的要求做越来越多其余的天职。

您也许感兴趣的篇章:

  • ruby 学习笔记(二)
    类的着力使用
  • ruby 学习笔记(一) 初识语法
  • 在Ruby on
    Rails中优化ActiveRecord的方法

复制一下 命令:退出中的内容,并粘贴在脱离后,把粘贴的剧情中的 def
command_shutdown改为def abc。运维之成效和后面一样。 
好了就自个儿现在的实力,也不得不进展到此了,如若懂一些语法,能够把def
asd上面的内容改一改。 
————————————————————————– 
总结 
未完成… 
————————————————————————– 
作业 
.程序开发的步调? 
.试着使用脚本编辑器中一些连忙键。 
提高题: 
试着总计脚本编辑器使用中出现的有的谬误类型及其思想。 
未完成… 
————————————————————————————————————————- 
答案 
略 

end
aPeople = People.new(“jimmy”);#创办三个People的实例
puts aPeople.to_string #调用to_string方法
#puts aPeople.get_name_size #将报错,因为该方法受爱慕
#puts aPeople.test #将报错,因为该办法是个人方法
aPeople.show_name
puts aPeople.name
aPeople.name = “杨俊明” #修改姓名
aPeople.show_name
#再定义一个子类
class Man < People    
    def initialize(_name)
        super
        @sex = true
    end    

实例

#!/usr/bin/ruby -w # 定义类 class Box # 构造方法 def initialize(w,h)
@width, @height = w, h end # 实例方法 def getArea @width * @height end
end # 成立对象 box = Box.new(拾, 20) # 调用实例方法 a = box.getArea
puts “Area of the box is : #{a}”

当上边包车型地铁代码实施时,它会生出以下结果:

Area of the box is : 200

第二篇 
先是章——类,对象和艺术 
————————————————————————– 
希图知识 
既然如此说Ruby是一种纯粹的面向对象编制程序的脚本语言,那么小编就从指标开端学起。 
1、对象是怎么着? 
娱乐中的任何事物都可以被可以解释为目的。 
钱的数据是指标,科长是目的,流氓甲也是象。因为Ruby所能管理的值都以目标,为了方便对象的操作就引入了类的定义。 
2、类是何等? 
对象的项目就称为类。 
村长和流氓甲属于NPC类,钱的数额属于自然数类(注:这里所说的类你能够自个儿定,你也得以说科长和流氓甲属于人类:属于哺乳类:属于…) 
有个别独特的属于那几个类的对象叫作类的实体(或实例)。 
在平时生活中,我们对总体对象的分类都以有鲜明档案的次序的。 
咱俩理解:生物〉动物〉哺乳类〉人类 
科长和流氓甲属于全人类,它就决然有哺乳类的习性,也就自然有动物的天性。我们称生物是动物的父类,动物是生物子类,轻便察觉子类会承接父类的品质。当然也会赶过那样的意况:父类的一点质量不得以被某一特定的子类承接——纵然一般鸟类都会飞,但企鹅是小鸟中不会飞的贰个子类。 
得到自然界这种规律的开导,Ruby就引入了承继。它大大收缩了程序猿的专门的学问量,大家只必要定义多个父类(或称为超类)的性格,它的子类就能自行一连它父类的属性。当然当你相逢像上文提起的不胜企鹅特例还要新添或重定义子类和父类之间的区分。承接的乐趣,正是保持被后人的习性但却还要具有和睦独有的特点。 
推荐介绍了类只是有益对象的操作,那么到底怎么操作对象啊?那将在用方法了。 
三、方法是何等? 
主意是有个别类中负有的对象专项使用的吩咐。 
您只需在有个别对象上调用有个别方法就能够让这些目的实施这几个艺术所代表的方法。而以此被操作的目的称为“成效实例”或是“方法的参数”。 
譬如你养了累累狗,(狗是贰个类,被您养的狗是它的子类)有一个叫旺财(旺财是指标,也是实例),你天天锻炼他们坐下(那是在概念1个艺术),之后每当你发号坐下这一个命令时(那是在调用坐下那个艺术)被你养的狗就能够坐下。(你就因此艺术成功了对目的的操作)。假若被你养的狗还分狼狗和哈巴狗二类,(狼狗和哈巴狗是被您养的狗的子类),它们会再而三它父类中定义过的不2诀要。当然3个类中得以定义繁多方法(你能够教狗多数事物)。 
又比如把Ruby看作CD机,CD机所操作的一体育赛事物——CD正是富有的靶子,类是歌曲的风骨(如路虎极光&M是一类,Rap是另壹类);当然你也得以把明星当类的分法(如杰伊 Chou是一类,陈小胖是另①类),而调用方法就是按播放按键,甘休按键,暂停按键等。 
施行基础 
在Ruby中开创八个对象并对其张开操作的手续如下: 
率先得定义类的习性—— 
1、类的定义 
格式: 
class 类名 
类中定义的剧情 
end 
只顾:类名必须以大写字母起始。 
只倘使二个子类就那样写: 
class 子类名< 父类名 
类中定义的源委 
end 
或在概念前面向来写上: 
class 子类名 < 父类名 
end 
那只是让父类承袭父类,不是重定义。为啥这么说吧? 
光有3个类还优秀,接着再往里面塞方法,以便今后对目的的操作。 
二、方法的定义 
艺术的定义写在“类中定义的开始和结果”这里 
格式: 
def 
方法中定义的剧情 
end 
只顾:方法必须以小写字母起先。 
理所必然当您遇到像上文谈到的万分企鹅特别的子类时,你还要重定义子类和父类之间的差别那叫称为重载,格式同上。方法的调用如反复定义,则以最终二回为准。 
在子类方法中调用父类一样方式的气象下,要运用首要词
super。super将调用被眼下艺术覆盖的父类中的同名方法。 
格式: 
super(定义的剧情, … ) 
若省略括号和参数时,将会把近日艺术的参数一点儿也不动地传递给父类中的同名方法。若调用时不想利用参数的话,请使用括号显式地方统一规范注,像super()那样。 
终极创立多少个属于那几个类的对象(实例)—— 
三、实例的创立 
格式: 
实例名 =类名.new 
实例终于创立好了,今后就该对它进行操作了。 
四、方法的调用 
在ruby里,大家通过点 . 来调用多少个对象的格局 
格式: 
已创制的实例名.方法名 
万壹您要开创叁只临时存在的实例,并给其增加方法: 
(类名.new).方法名 
或: 
类名.new.方法名 

    attr_reader:sex #概念只读属性sex

类方法 & 类变量

类变量是在类的享有实例中共享的变量。换句话说,类变量的实例可以被抱有的靶子实例访问。类变量以两个@ 字符作为前缀,类变量必须在类定义中被初步化,如上面实例所示。

类方法使用 def self.methodname() 定义,类措施以 end
分隔符结尾。类形式可利用含有类名称的 classname.methodname
方式调用,如上边实例所示:

复制代码代码如下:

    def call_protected_method
        puts get_name_size #调用父类的受保证措施
    end

实例

#!/usr/bin/ruby -w class Box # 开始化类变量 @@count = 0 def
initialize(w,h) # 给实例变量赋值 @width, @height = w, h @@count += 1end def self.printCount puts “Box count is : #@@count” end end #
创立五个对象 box一 = Box.new(十, 20) box2 = Box.new(30, 100) #
调用类方法来输出盒子计数 Box.printCount

当上边的代码推行时,它会生出以下结果:

Box count is : 2

class NPC 
def intro 
print “我是NPC?” 
end 
end 
class Lioumang<NPC 
def talk 
print “XX在山村的东部” 
end 
end 
流氓甲=Lioumang.new 
流氓甲.talk #显示 我是NPC? 
流氓甲.intro #因为流氓甲继承了它的父类的法子,所以显得 XX在村落的南方 

    def call_protected_method2(man1)
        puts man1.get_name_size
#瞩目这里:这里能够把父类的受保险措施,动态拉长到子类实例
    end

to_s 方法

你定义的别样类都有2个 to_s
实例方法来回到对象的字符串表示格局。上面是一个粗略的实例,依照 width 和
height 表示 Box 对象:

说明: 
~伍定义一个类——NPC 
~1壹定义二个NPC的子类——Lioumang 
~四为NPC定义一个誉为intro的格局,print ”
“的做用是显得“”内的东西。(先不要管它怎么运维的) 
~10为Lioumang定义三个称为talk的主意 
创办实例——流氓甲 
为流氓甲调用talk的艺术 
为流氓甲调用intro的形式 

    def call_private_method #子类能够调用父类的村办方法!!!
那点刚开端很不习贯
        test
    end

实例

#!/usr/bin/ruby -w class Box # 构造器方法 def initialize(w,h) @width,
@height = w, h end # 定义 to_s 方法 def to_s
“(w:#@width,h:#@height)” # 对象的字符串格式 end end # 创建对象 box =
博克斯.new(10, 20) # 自动调用 to_s 方法 puts “String representation of
box is : #{box}”

当下面的代码施行时,它会产生以下结果:

String representation of box is : (w:10,h:20)

二 

    def call_private_method2(man1)
        man1.test
#留神这里:语法检查即便能够经过,不过运转时会提醒私有方法不能够调用,那也是private与protected的分别
    end

访问调节

Ruby 为你提供了多少个级其余实例方法珍重,分别是 public、private 或
protected
。Ruby 不在实例和类变量上利用任何访问调控。

  • Public 方法: Public 方法可被私下对象调用。暗许情状下,方法都以public 的,除了 initialize 方法总是 private 的。
  • Private 方法: Private
    方法不可能从类外部访问或查看。唯有类措施能够访问私有成员。
  • Protected 方法: Protected
    方法只能被类及其子类的靶子调用。访问也不得不在类及其子类内部进行。

上边是二个简短的实例,演示了那三种修饰符的语法:

复制代码代码如下:

    
end
puts “******************************”
aMan = Man.new(“jimmy.yang”);
aMan.show_name
aMan.call_protected_method
puts aMan.sex
aMan.call_private_method
aMan2 = Man.new(“Mike”)
aMan.call_protected_method2(aMan2);
#aMan.call_private_method2(aMan2);
a = “abc”;
#aMan.call_protected_method2(a);
#即便ruby本身对变量没有项目概念,但是这样却非常,即:在调用父类的受保障方法时,其实是重要项目目相配的
puts aMan.class #显示aMan的类名称

实例

#!/usr/bin/ruby -w # 定义类 class Box # 构造器方法 def
initialize(w,h) @width, @height = w, h end # 实例方法私下认可是 public 的
def getArea getWidth * getHeight end # 定义 private 的访问器方法 def
getWidth @width end def getHeight @height end # make them private
private :getWidth, :getHeight # 用于出口面积的实例方法 def printArea
@area = getWidth * getHeight puts “Big box area is : #@area” end #
让实例方法是 protected 的 protected :printArea end # 创建对象 box =
Box.new(10, 20) # 调用实例方法 a = box.getArea puts “Area of the box is
: #{a}” # 尝试调用 protected 的实例方法 box.printArea

当上边的代码实行时,它会发生以下结果。在此地,第1种方式调用成功,不过第二主意会生出1个难点。

Area of the box is : 200test.rb:42: protected method `printArea' called for #<Box:0xb7f11280 @height=20, @width=10> (NoMethodError)

class NPC 
def intro 
print “aaa” 
end 
end 
class Lioumang<NPC 
def intro 
print “bbb” 
end 
end 
流氓甲=Lioumang.new 
流氓甲.intro 

运作结果如下:

类的接轨

承继,是面向对象编制程序中最入眼的定义之一。承袭允许我们依据另一个类定义一个类,那样使得创制和敬重应用程序变得更为轻巧。

三番五次有助于重用代码和神速试行,不幸的是,Ruby 不支持多接二连三,不过 Ruby
协理 mixins。mixin
就好像多一连的三个一定完结,在多三番五次中,只有接口部分是可延续的。

当创造类时,程序猿能够直接钦点新类承袭自有个别已有类的成员,那样就绝不从头编写新的多寡成员和成员函数。这些已有类被称为基类或父类,新类被称呼派生类或子类

Ruby
也提供了子类化的概念,子类化即两次三番,上边包车型大巴实例解释了那么些概念。扩张3个类的语法特别轻巧。只要增加一个< 字符和父类的称呼到类语句中就能够。比方,上面定义了类 BigBox
Box 的子类:

说明: 
展现的是bbb,可见方法的调萌绶锤炊ㄒ澹蛞宰詈笠淮挝肌5绻?三行变为
流氓甲=NPC.new 则显示aaa
三 

复制代码 代码如下:

实例

#!/usr/bin/ruby -w # 定义类 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

复制代码代码如下:

>ruby classDemo.rb
My name is jimmy
private method(test) in People.
name = jimmy
jimmy
private method(test) in People.
name = 杨俊明
******************************
private method(test) in People.
name = jimmy.yang
10
true
private method(test) in People.
4
Man
>Exit code: 0

艺术重载

即便你能够在派生类中增多新的效益,但有的时候你可能想要改造1度在父类中定义的办法的一颦一笑。那时你能够保障方法名称不改变,重载方法的效率就可以,如下边实例所示:

class NPC 
def intro 
print “aaa” 
end 
def talk 
print “ccc” 
end 
end 
class NPC 
def intro 
print “bbb” 
end 
end 
流氓甲=NPC.new 
流氓甲.intro 
流氓甲.talk 

作者:菩提树下的杨过
出处:

实例

#!/usr/bin/ruby -w # 定义类 class Box # 构造器方法 def
initialize(w,h) @width, @height = w, h end # 实例方法 def getArea
@width * @height end end # 定义子类 class BigBox < Box #
退换已有的 getArea 方法 def getArea @area = @width * @height puts “Big
box area is : #@area” end end # 创造对象 box = Big博克斯.new(十, 20) #
使用重载的方式输出面积 box.getArea

如上实例运维输出结果为:

Big box area is : 200

说明: 
先出示的是bbb,再展现ccc,可知类如反复定义,则以保存他们混合的补集,他们的交集以最后贰回为准。但若是一三行变为
流氓甲=NPC.new 则展现aaa。 
四 

你也许感兴趣的稿子:

  • ruby 标准项目总计
  • Ruby字符串、条件、循环、数组、Hash、类基本操作笔记
  • ruby 类常量 解析
  • js
    数组落成二个近似ruby的迭代器
  • 3个简约的Ruby可逆加密解密类
  • Ruby中的Proc类及Proc的类措施Proc.new的使用分析
  • Ruby类实例变量、类实例方法和类变量、类措施的区分
  • Ruby中贯彻把字符串转换为类的二种形式
  • Ruby面向对象编程中类与艺术的底蕴学习

运算符重载

我们意在选取 + 运算符推行八个 博克斯 对象的向量加法,使用 * 运算符来把 Box的 width 和 height 相乘,使用一元运算符 – 对 博克斯 的 width 和 height
求反。下边是贰个含有数学生运动算符定义的 Box 类版本:

class Box def initialize(w,h) # 初始化 width 和 height @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

复制代码代码如下:

结霜对象

神蹟,大家想要防止对象被改换。在 Object 中,freeze
方法可完结那一点,它能管用地把一个目的造成贰个常量。任何对象都可以透过调用
Object.freeze
举行冷冻。冻结对象不能够被改换,也正是说,您不能更改它的实例变量。

您能够行使 Object.frozen?
方法检查1个加以的目的是还是不是曾经被冷冻。若是目的已被冻结,该措施将赶回
true,不然再次回到叁个 false 值。上面包车型地铁实例解释了那么些概念:

class NPC 
def talk(a=nil) #nil为空集 
p a 
end 
end 
class Lioumang < NPC 
def talk(a) 
super(5) # 以5看作参数实行调用 
super(a) # 以5当做参数进行调用 
super # 以伍看成参数举行调用,super(a)的简写 
a = 1 
super # 以一当做参数举行调用,super(a)的简写 
super() # 无参数的调用 
end 
end 
Lioumang.new.talk 5 

实例

#!/usr/bin/ruby -w # 定义类 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 = 博克斯.new(10, 20) # 让我们冻结该目标 box.freeze if(
box.frozen? ) puts “博克斯 object is frozen object” else puts “Box object
is normal object” end # 未来尝试选择设置器方法 box.setWidth = 30
box.setHeight = 50 # 使用访问器方法 x = box.getWidth y = box.getHeight
puts “Width of the box is : #{x}” puts “Height of the box is : #{y}”

当上边的代码推行时,它会产生以下结果:

Box object is frozen objecttest.rb:20:in `setWidth=': can't modify frozen object (TypeError)        from test.rb:39

说明: 
~四措施的功能是展现变量a,而a=nil,既彰显nil 
可知:若省略Super的括号和参数时,将会把当下艺术的参数稳如泰山地传递给父类中的同名方法。若调用时不想使用参数的话,请使用括号显式地方统一标准明,像super()那样。

类常量

您能够在类的里边定义2个常量,通过把1个一贯的数值或字符串值赋给多少个变量来定义的,常量的定义不供给使用
@ 或 @@。根据常规,常量的名目使用大写。

若是常量被定义,您就不能够改动它的值,您能够在类的内部一向访问常量,就像访问变量同样,可是如果你想要在类的表面访问常量,那么您必须运用
classname::constant,如上面实例所示。

实例

#!/usr/bin/ruby -w # 定义类 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(拾, 20) # 调用实例方法 a = box.getArea puts “Area of the box is
: #{a}” puts Box::BOX_COMPANY puts “Box weight is: #{Box::BOXWEIGHT}”

当上边的代码推行时,它会发出以下结果:

Area of the box is : 200TATA IncBox weight is: 10

类常量可被持续,也可像实例方法1致被重载。

行使 allocate 创立对象

唯恐有壹种处境,您想要在不调用对象协会器 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 创制对象 box壹 =
Box.new(十, 20) # 使用 allocate 创造两多少个对象 box二 = Box.allocate #
使用 box一 调用实例方法 a = box一.getArea puts “Area of the box is :
#{a}” # 使用 box二 调用实例方法 a = box二.getArea puts “Area of the box
is : #{a}”

当上边的代码实行时,它会爆发以下结果:

Area of the box is : 200test.rb:14: warning: instance variable @width not initializedtest.rb:14: warning: instance variable @height not initializedtest.rb:14:in `getArea': undefined method `*'    for nil:NilClass (NoMethodError) from test.rb:29

类信息

Ruby的 self 和 Java 的 this
有相似之处,但又大分裂样。Java的办法都以在实例方法中援引,所以this一般都以指向当前指标的。而Ruby的代码逐行实行,所以在不一样的光景文self就有了不相同的意义。让大家来探视上边包车型大巴实例:.

实例

#!/usr/bin/ruby -w class Box # 输出类音信 puts “Class of self =
#{self.class}” puts “Name of self = #{self.name}” end

当上面的代码实施时,它会发生以下结果:

Class of self = ClassName of self = Box

那代表类定义可通过把该类作为当前目的来举行,同一时间也意味元类和父类中的该办法在章程定义试行时期是可用的。

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有