README-en.md edited online with Bitbucket

README-en.md

 ---
 
 
-##Classes and objects in C++
+##Classes and Objects in C++
 
-An *object* is an entity that contains data and procedures to manipulate them. Similar to how each variable has a *type* of data associated to it, each object has a *class* associated that describes the properties of the objects: its data (*attributes*), and the procedures that can be used to manipulate its data (*methods*).
+An *object* is an entity that contains data and procedures to manipulate them. Similar to how each variable has a *type* of data associated to it, each object has a *class* associated to it, which describes the properties of the the objects: its data (*attributes*), and the procedures that can be used to manipulate its data (*methods*).
 
-To define and use an object it is not necessary to know all of the details about the methods of the object, but you must know how to create it and how to interact with it. The necessary  information is available in the class' documentation. Before creating objects of any class we should familiarize ourselves with its documentation. The documentation indicates, among other things, what entity is trying to be represented in the class, and its interface or methods available to manipulate the objects of the class.
+It is not necessary to know all of the details about the methods of the object to define and use an object, but you must know how to create it and how to interact with it. The necessary  information is available in the class' documentation. Before creating objects of any class, we should familiarize ourselves with its documentation. The documentation indicates, among other things, what entity is trying to be represented in the class, and its interface or methods available to manipulate the objects of the class.
 
-Take a look at the documentation for the `Bird` class which can be found in the documentation for this project (`objects-birds/doc/en/html/class_bird.html`).
+Take a look at the documentation of the `Bird` class which can be found in [this link.](http://ada.uprrp.edu/~ranazario/bird-html/class_bird.html).
 
 ###Classes
 
-A class is a template for the creation of objects that establishes its attributes and behavior. If it isn't specified otherwise, the attributes and methods defined in a class will be private. This means that the variables can only be accessed and changed by the methods of the class (*constructors*, *setters*, and *getters*, among others).
+A class is a description of the data and processes of an object. The class’ declaration establishes the attributes that each of the objects of the class will have, and the methods that it can invoke.
+
+If it isn't specified otherwise, the attributes and methods defined in a class will be private. This means that the variables can only be accessed and changed by the methods of the class (*constructors*, *setters*, and *getters*, among others).
 
 The following is the skeleton of the declaration of a class:
 
 ---
 
-```cpp
-
+```
   class ClassName
    {
     // Declarations
       type nameOfPublicMemFunc(type of the parameters);
    };
 ```
-
 ---
 
 You can see the declaration of the `Bird` class in the file `bird.h` included in this laboratory experience's program.
 
 ###Objects
 
-An object is an entity that contains data (as well as a variable), called its `attributes`, and also contain procedures, called `method`, that are used to manipulate them. The objects are "instances" of a class that are created in a similar manner as how variables are defined, with the exception that in some occasions we have to add values for the parameters:
+An object is an entity that contains data (same as a variable), called its `attributes`, and it also contains procedures, called `method`, that are used to manipulate them. The objects are "instances" of a class that are created in a similar manner as how variables are defined:
 
-`ClassName objectName(arguments);`
+`ClassName objectName;`
 
-The creation  of the objects is done by functions called `constructors` that will be explained later. Once we have created an object, we can interact with it using the methods that belong to the class.
+By creating an object we have available the methods of the class that the object belongs to.
 
-###Methods of a class
+###Methods of a Class
 
-The methods of a class determine the actions that we can take on the objects of that class. The methods are similar to functions in the sense that they can receive parameters and return a result. An elementary way to know the methods of a class is reading de class declaration. For example, the following is a section of the declaration of the class `Bird` in the file `bird.h`.
+The methods of a class determine the actions that we can take on the objects of that class. The methods are similar to functions in the sense that they can receive parameters and return a result. An elementary way to know the methods of a class is reading the class declaration. For example, the following is a section of the declaration of the class `Bird` in the file `bird.h`.
 
 ---
 
 
-```cpp
-
+```
 class Bird : public QWidget
 {
-
-//...
-
+.
+.
+.
     Bird(int , EyeBrowType , QString , QString, QWidget *parent = 0) ;
-
+    
     int getSize() const;
     EyeBrowType getEyebrow() const ;
     QString  getFaceColor() const;
     void setEyebrow(EyeBrowType) ;
     void setFaceColor(QString) ;
     void setEyeColor(QString) ;
-
-//...
-
+.
+.
+.
 };
 ```
 
 
 ---
 
-Once the object is created, its methods provide the only way to change its attributes, to obtain information about them, or to compute with them. This is why the set of methods is commonly called *interface*. The methods are the interface between the object’s user and its content.
+Once the object is created, its methods provide the only way to change its attributes, to obtain information about them, or do computations with them. This is why the set of methods is commonly called the *interface*. The methods are the interface between the object’s user and its content.
 
 In general, in each class the prototypes of the methods are defined to construct the objects, and to search, manipulate and store the data. The following is a general format of a method prototype:
 
 
 `TypeReturned ClassName::MethodName(parameters)`
 
-We declare public methods within the class so that objects that are instances of a class have permission to access private variables (these are the setters and getters). It's prefered to use private variables and access them through the setters and getters, instead of declaring them public since the object that is associated to these variables has control over the changes that are made.
+We declare public methods within the class so that objects that are instances of a class have permission to access private variables (these are the setters and getters). It's preferred to use private variables and access them through the setters and getters, instead of declaring them public since the object that is associated to these variables would have control over the changes that are made.
 
 To invoke a method we write the name of the object, followed by a period and then the name of the method:
 
 `objectName.methodName(arguments);`
 
 
-####Constructors
+#### Constructors
+
+The first methods of a class that we should understand are the *constructors*. A class can have multiple constructors. One of the constructors will be invoked automatically each time an object of that class is created. In most cases, the constructors are used to initialize the values for the object’s attributes. To create objects of a class, we must know which are the constructors of the class.
+
 
-The first methods of a class that we should understand are the *constructors*. A class can have multiple constructors. One of the constructors will be invoked automatically each time an object of that class is created. In most of the cases, the constructors are used to initialize the values for the object’s attributes. To create objects of a class, we must know which are the constructors of the class.
 
 In C++, the constructors have the same name as the class. The type returned by these functions is not declared since they do not return any value. Their declaration (included in the definition of the class) is like this:
 
 
 `Bird (int, EyeBrowType, QString, QString, QWidget *parent=0)`
 
-You can see the declarations of the method prototypes in the declaration of the `Bird` class in the project's `bird.h` file. The documentation for the class can be found in the documentation for this project (`objects-birds/doc/en/html/class_bird.html`). The first constructor, `Bird (QWidget *parent=0)`, is a method that can be invoked with one or no argument. If no argument is used, the function's parameter has a value of 0.
+You can see the declarations of the method prototypes in the declaration of the `Bird` class in the project's `bird.h` file. The documentation can be found in [this link.](http://ada.uprrp.edu/~ranazario/bird-html/class_bird.html) The first constructor, `Bird (QWidget *parent=0)`, is a method that can be invoked with one or no argument. If no argument is used, the function's parameter has a value of 0.
 
 A class' constructor that can be invoked without using an argument is the class' *default constructor*; that is, the constructor that is invoked when we create an object using an instruction  like:
 
 `Bird pitirre;`
 
-You can see the implementations of the class `Bird` in the file `bird.cpp`. Notice that the first constructor, `Bird (QWidget *parent=0)`, will assign random values to each of the object's attributes. Later on there is a brief explanation for the `randInt` function.
+You can see the implementations of the class `Bird` in the file `bird.cpp`. Note that the first constructor, `Bird (QWidget *parent=0)`, will assign random values to each of the object's attributes. Later on there is a brief explanation for the `randInt` function.
 
 Have a look at the documentation for the second constructor, `Bird (int, EyeBrowType, QString, QString, QWidget *parent=0)`. This function requires four arguments and has a fifth argument that is optional since it has a default value. One way to use this constructor is creating an object like this:
 
 `Bird guaraguao(200, Bird::UPSET, "blue", "red");`
 
 
-####Setters (mutators)
+#### Setters (mutators)
 
-Classes provide methods to modify the values of the attributes of an object that has been created. These methods are called *setters* or *mutators*. Usually, we declare one setter for each attribute that the class has. The `Bird` class has the following setters:
+Classes provide methods to modify the values of the attributes of an objected that has been created. These methods are called *setters* or *mutators*. Usually, we declare one setter for each attribute that the class has. The `Bird` class has the following setters:
 
-* `void setSize (int)`
-* `void setEyebrow (EyeBrowType)`
-* `void setFaceColor (QString)`
-* `void setEyeColor (QString)`
+* `void setSize (int)` 
+* `void setEyebrow (EyeBrowType)` 
+* `void setFaceColor (QString)` 
+* `void setEyeColor (QString)` 
 
 
 You can see the method's declarations in Figure 1 and in the `Bird` class declaration in `bird.h`, and the implementation of the some of the methods in `bird.cpp`. The code in the following example creates the object `bobo` of the `Bird` class and then changes its size to 333.
 bobo.setSize(333);
 ```
 
-####Getters (accessors)
+#### Getters (accessors)
 
 Classes also provide methods to access (get) the value of the attribute of an object. These methods are called *getters* or *accessors*. We usually declare one getter for each attribute a class has. The `Bird` class has the following getters:
 
-* `int getSize ()`
-* `EyeBrowType getEyebrow ()`
+* `int getSize ()` 
+* `EyeBrowType getEyebrow ()` 
 * `QString  getFaceColor ()`
-* `QString   getEyeColor ()`
+* `QString   getEyeColor ()` 
 
 You can see the declarations of the methods in Figure 1 and  in the `Bird` class declaration in `bird.h`, and the implementations of some of the methods in `bird.cpp`. The code in the following example creates the object `piolin` of the `Bird` class and prints its size:
 
 cout << piolin.getSize();
 ```
 
-####Other functions or methods you will use in this laboratory experience
+#### Other Functions or Methods You will use in this Laboratory Experience
 
 **MainWindow:** The file `mainwindow.h` contains the declaration of a class called `MainWindow`. The objects that are instances of this class will be able to use the overloaded methods
 
 
 that will add to the screen a drawing of an object of the `Bird` class that is received as an argument. The code in the following example creates an object `w` of the `MainWindow` class, creates an object `zumbador` of the `Bird` class and adds it in the position (200,200) on the screen `w` using the first method.
 
-```cpp
-
+```
 MainWindow w;
 Bird zumbador;
 w.addBird(200,200,zumbador);
 
 to generate random numbers in the range [min, max]. The method `randInt` depends on another function to generate random numbers that require a first element or *seed* to be evaluated. In this project, that first element is generated with the function call `srand(time(NULL)) ;`.
 
-
 ---
 
 ---