Ruby Basics Flashcards
What is Ruby
Ruby is a pure object oriented programming language. It was created in 1993 by Yukihiro Matsumoto of Japan. Ruby is a general-purpose, interpreted programming language like PERL and Python.
What is a method?
Ruby methods are very similar to functions in any other programming language. Ruby methods are used to bundle one or more repeatable statements into a single unit.
Method names should begin with a lowercase letter. If you begin a method name with an uppercase letter, Ruby might think that it is a constant and hence can parse the call incorrectly.
Methods should be defined before calling them otherwise Ruby will raise an exception for undefined method invoking.
What are Class Methods?
When a method is defined outside of the class definition, the method is marked as private by default. On the other hand, the methods defined in the class definition are marked as public by default. The default visibility and the private mark of the methods can be changed by public or private of the Module.
Whenever you want to access a method of a class, you first need to instantiate the class. Then, using the object, you can access any member of the class.
Ruby gives you a way to access a method without instantiating a class. Let us see how a class method is declared and accessed:
class Accounts def reading_charge end def Accounts.return_date end end
What is an alias statement?
This gives alias to methods or global variables. Aliases can not be defined within the method body. The aliase of the method keep the current definition of the method, even when methods are overridden.
Making aliases for the numbered global variables ($1, $2,…) is prohibited. Overriding the builtin global variables may cause serious problems.
Syntax:
alias method-name method-name
alias global-variable-name global-variable-name
Why is ruby a pure OO language?
Ruby is pure object-oriented language and everything appears to Ruby, as an object. Every value in Ruby is an object, even the most primitive things: strings, numbers and even true and false. Even a class itself is an object that is an instance of the Class class. This chapter will take you through all the major functionalities related to Object Oriented Ruby.
A class is used to specify the form of an object and it combines data representation and methods for manipulating that data into one neat package. The data and methods within a class are called members of the class.
What is a Class?
When you define a class, you define a blueprint for a data type. This doesn’t actually define any data, but it does define what the class name means, that is, what an object of the class will consist of and what operations can be performed on such an object.
A class definition starts with the keyword class followed by the class name and is delimited with an end. For example we defined the Box class using the keyword class as follows:
class Box
code
end
The name must begin with a capital letter and by convention names that contain more than one word are run together with each word capitalized and no separating characters (CamelCase).
How do you define a ruby object?
A class provides the blueprints for objects, so basically an object is created from a class. We declare objects of a class using new keyword. Following statements declare two objects of class Box:
box1 = Box.new box2 = Box.new
What is the initialize method?
The initialize method is a standard Ruby class method and works almost same way as constructor works in other object oriented programming languages. The initialize method is useful when you want to initialize some class variables at the time of object creation. This method may take a list of parameters and like any other ruby method it would be preceded by def keyword as shown below:
class Box
def initialize(w,h)
@width, @height = w, h
end
end
What is an instance variable?
The instance variables are kind of class attributes and they become properties of objects once we objects are created using the class. Every object’s attributes are assigned individually and share no value with other objects. They are accessed using the @ operator within the class but to access them outside of the class we use public methods which are called accessor methods. If we take above defined class Box then @width and @height are instance variables for the class Box.
class Box
def initialize(w,h)
# assign instance avriables
@width, @height = w, h
end
end
What is the accessor method?
!/usr/bin/ruby -w
To make the variables available from outside the class, they must be defined within accessor methods, these accessor methods are also known as a getter methods. Following example shows the usage of accessor methods:
# define a class
class Box
# constructor method
def initialize(w,h)
@width, @height = w, h
end
# accessor methods
def printWidth
@width
end
def printHeight
@height
end
end
# create an object box = Box.new(10, 20)
# use accessor methods x = box.printWidth() y = box.printHeight()
puts “Width of the box is : #{x}”
puts “Height of the box is : #{y}”
produces:
Width of the box is : 10
Height of the box is : 20
What is the setter method?
!/usr/bin/ruby -w
Similar to accessor methods which are used to access the value of the variables, Ruby provides a way to set the values of those variables from outside of the class using setter methods, which are defined as below:
# define a class
class Box
# constructor method
def initialize(w,h)
@width, @height = w, h
end
# accessor methods
def getWidth
@width
end
def getHeight
@height
end
# setter methods
def setWidth=(value)
@width = value
end
def setHeight=(value)
@height = value
end
end
# create an object box = Box.new(10, 20)
use setter methods
box. setWidth = 30
box. setHeight = 50
# use accessor methods x = box.getWidth() y = box.getHeight()
puts “Width of the box is : #{x}”
puts “Height of the box is : #{y}”
produces:
Width of the box is : 30
Height of the box is : 50
What are instance methods?
!/usr/bin/ruby -w
The instance methods are also defined in the same way as we define any other method using def keyword and they can be used using a class instance only as shown below. Their functionality is not limited to access the instance variables, but also they can do a lot more as per your requirement.
# define a class
class Box
# constructor method
def initialize(w,h)
@width, @height = w, h
end
# instance method
def getArea
@width * @height
end
end
# create an object box = Box.new(10, 20)
# call instance methods
a = box.getArea()
puts "Area of the box is : #{a}"
produces:
Area of the box is : 200
what are class variables?
he class variables is a variable which is shared between all instances of a class. In other words, there is one instance of the variable and it is accessed by object instances. Class variables are prefixed with two @ characters (@@). A class variable must be initialized within the class definition as shown below.
A class method is defined using def self.methodname() which ends with end delimiter and would be called using class name as classname.methodname as shown in the following example:
class Box
# Initialize our class variables
@@count = 0
def initialize(w,h)
# assign instance avriables
@width, @height = w, h
@@count += 1 end
def self.printCount()
puts “Box count is : #@@count”
end
end
# create two object box1 = Box.new(10, 20) box2 = Box.new(30, 100)
# call class method to print box count Box.printCount()
produces:
Box count is : 2
Access control: Public Methods
!/usr/bin/ruby -w
Public methods can be called by anyone. Methods are public by default except for initialize, which is always private.
# define a class
class Box
# constructor method
def initialize(w,h)
@width, @height = w, h
end
# instance method by default it is public
def getArea
getWidth() * getHeight
end
# define private accessor methods
def getWidth
@width
end
def getHeight
@height
end
# make them private
private :getWidth, :getHeight
# instance method to print area
def printArea
@area = getWidth() * getHeight
puts "Big box area is : #@area"
end
# make it protected
protected :printArea
end
# create an object box = Box.new(10, 20)
# call instance methods
a = box.getArea()
puts "Area of the box is : #{a}"
# try to call protected or methods box.printArea()
Access control: Private Methods
!/usr/bin/ruby -w
Private methods cannot be accessed, or even viewed from outside the class. Only the class methods can access private members.
# define a class
class Box
# constructor method
def initialize(w,h)
@width, @height = w, h
end
# instance method by default it is public
def getArea
getWidth() * getHeight
end
# define private accessor methods
def getWidth
@width
end
def getHeight
@height
end
# make them private
private :getWidth, :getHeight
# instance method to print area
def printArea
@area = getWidth() * getHeight
puts "Big box area is : #@area"
end
# make it protected
protected :printArea
end
# create an object box = Box.new(10, 20)
# call instance methods
a = box.getArea()
puts "Area of the box is : #{a}"
# try to call protected or methods box.printArea()
