ruby基础二

参考 张开川的 ruby 语言入门教程

1. 等价语句

单引号里是什么就是什么，会照着输出。

ruby 代码

1. a=5   
2. b="hhhh"  
3. print("a is ",a,"\n")   
4. puts("a is #{a}")   
5. puts('a is #{a}')
6. 输出结果:   
7. a is 5   
8. a is 5  
9. a is #{a}

 2.

ruby 代码

1. #ruby支持缺省参数   
2. def sum(a,b=5)   
3.     a+b   
4.   end  
5.   puts sum(3,6) #输出结果为:9   
6.   puts sum(3)#输出结果为8   
7.      
8. #ruby支持可变参数   
9. def sum(*num)   
10.     numSum = 0   
11.     num.each{|i| numSum += i}   
12.     return numSum   
13.   end  
14.      
15.   puts sum() #输出结果为0   
16.   puts sum(3,6)#输出结果为9   
17.   puts sum(1,2,3,4,5,6,7,8,9)#输出结果为45   
18.      
19.   #ruby中如果一个类里有2个同名方法，总是后面的一个被执行  

 

 

3. ruby中的实例变量，类变量,类方法

实例变量：每个实例独享，变量名用@开头

类变量：所有实例共享，变量名用@@开头，类似java里的static变量，但是在使用前必须要初始化。

 类方法:不需要通过实例对象来调用。类方法定义方式: 类名.方法名，如：

ruby 代码

1. def StudentClass.student_count   
2.      puts "aaa"  
3.    end  

如果在外部调用一个类里的常量，需要用到域作用符号"::"

4.ruby里的单例方法：给具体的某个实例对象添加方法，这个方法只属于这个实例对象的。这样的方法叫单例方法

定义单例方法，首先要生成一个实例对象，其次要在方法名前加上一个对象名和一个点号(.)

如：

ruby 代码

1. class Person   
2.         def talk   
3.             puts "hi!"  
4.           end  
5.         end  
6.            
7.         p1 = Person.new  
8.         p2 = Person.new  
9.            
10.         def p2.talk #定义单例方法p2.talk   
11.             puts "Here is p2."  
12.           end  
13.         def p2.laugh   
14.               puts "ha,ha,ha..."  
15.         end  
16.                
17.         p1.talk    
18.         p2.talk   
19.         p2.laugh   
20.   
21. 输出结果为：   
22. hi!   
23. Here is p2.   
24. ha,ha,ha...  

 5.访问控制

ruby 代码

1. #访问控制   
2. #public , protected, private   
3. #public 方法，可以被定义它的类和其子类访问，可以被类和其子类的实例对象调用   
4. #protected 方法，可以被定义它的类和其子类访问，不能被类和其子类的实例对象调用，但是 可以在类和其子类中制定给实例对象   
5. #private 方法，可以被定义它的类和其子类访问,不能被类和其子类的实例对象调用，私有方法不能指定对象   
6.   
7. class Person   
8.   public   
9.   def talk   
10.       puts "public:talk"  
11.     end  
12.   def speak   
13.       "protected:speak"  
14.     end  
15.   def laugh   
16.        "private:laugh"  
17.      end  
18.   protected :speak  
19.   private :laugh  
20.      
21.   def useLaughTest(another)   
22.         puts another.laugh #这里错误，私有方法不能指定对象   
23.       end  
24.          
25.   def useSpeakTest(another)   
26.       puts another.speak  #这里可以，,protected方法可以指定对象   
27.     end  
28. end  
29.   
30. class Student < Person   
31.   def useLaugh   
32.       puts laugh   
33.     end  
34.   def useSpeak   
35.       puts speak   
36.     end  
37.   end  
38.      
39.   p1 = Person.new  
40.   p1.talk   
41.   #p1.speak 实例对象不能访问protected方法   
42.   #p1.laugh 实例对象不能访问private方法   
43.      
44.   p2 = Student.new  
45.   p2.useLaugh   
46.   p2.useSpeak   
47.     

输出结果为：

public:talk
private:laugh
protected:speak