Update dataTypes.md

Author: shoebxsiddiqui

lessons/dataTypes.md

@@ -62,39 +62,39 @@ These are of `8 types`:
 |double       |0.0d             |8 byte         |
 
 1. **Boolean Data Type** : Variables declared with boolean data type can store only true/false. These are used as flag which checks for a particular conditions. Its size is only 1 bit.
-```
+```java
 boolean a = false;
 ```
 2. **Byte Data Type** : It is 8-bit signed 2's complement integer. Its value-range lies between -128 to 127 (inclusive). Its default value is 0. The byte data type is used to save memory in large arrays where the memory savings is most required. It saves space because a byte is 4 times smaller than an integer. It can also be used in place of "int" data type.
-```
+```java
 byte a = 10;
 byte b = -20;
 ``` 
 3. **Short Data Type** : It is a 16-bit signed 2's complement integer. Its value-range lies between -32,768 to 32,767 (inclusive). Its default value is 0. A short data type is 2 times smaller than an integer.
-```
+```java
 short a = 10000;
 short b = -5000;  
 ```
 4. **Int Data Type** : It is a 32-bit signed 2's complement integer. Its value-range lies between - 2,147,483,648 (-2^31) to 2,147,483,647 (2^31 -1) (inclusive). Its default value is 0. It is generally used as a default data type for integral values.
-```
+```java
 int a = 100000; 
 int b = -200000;
 ```
 5. **Long Data Type** : It is a 64-bit 2's complement integer. Its value-range lies between -9,223,372,036,854,775,808(-2^63) to 9,223,372,036,854,775,807(2^63 -1)(inclusive). Its default value is 0. The long data type is generally used when the integer that we have to store exceeds the range provided by int data type.
-```
+```java
 long a = 100000L;
 long b = -200000L; 
 ```
 6. **Float Data Type** : It is a single-precision 32-bit IEEE 754 floating point.Its value range is unlimited. It is recommended that we should use float (instead of double) if yweou need to save memory in large arrays of floating point numbers. It should never be used for precise values, such as currency. Its default value is 0.0F.
-```
+```java
 float f1 = 234.5f ;
 ```
 7. **Double Data Type** : It is a double-precision 64-bit IEEE 754 floating point. Its value range is unlimited. This is also generally used for decimal values just like float. The double data type also should never be used for precise values, such as currency. Its default value is 0.0d.
-```
+```java
 double d1 = 12.3;
 ```
 8. **Char Data Type** : It is a single 16-bit Unicode character. Its value-range lies between '\u0000' (or 0) to '\uffff' (or 65,535 inclusive). It is used to store characters.
-```
+```java
 char letterA = 'A';
 ``` 
 
@@ -106,30 +106,30 @@ Non-Primitive data types are created by instantiation, i.e, an object is created
 
 This object can have more than one reference variable, and if we make changes on the data of the object through one reference variable the actual object gets changed and this changed objects's data is changed in all the variables that are pointing(or referencing) to this object.
 
-These are of `five types` :
+Let's see some of its types:
 
 1. **Class** : Every class is considered as user-defined data type as a user creates a class. In Java programming, a class is basically a user-defined data type that act as a template for creating objects of identical type. It represents the common properties and actions (functions) of an object.
-```
+```java
 public class GitHub
  { 
    // class body.
  }
  ```
 2. **Object** : An object is any real-world thing that has some properties and actions. In other words, an entity that has state and behavior is known as an object. An Object has three characterstics - State, Behaviour and Identity.
-```
+```java
 Person p = new Person();
 ```
 3. **String** : A String is also a class. It represents a sequence of characters like Shuaib, A123, etc. The simplest way to create a string object is by storing sequence of characters into string type variable.
-```
+```java
 String str = "India";
 ```
 4. **Arrays** : It is an Object which is used to store multiple data of same data type. It can store Primitive as well as Non-Primitive data in it. 
-```
+```java
 int [] numbers;
 Student [] x; // Student is a name of class.
 ```
 5. **Interface** : An interface is declared like a class but the only difference is that it contains only final variables and method declarations. It is a fully abstract class. It is blue print of a class. It is mechanism in Java to achieve abstraction and multiple inheritance. There can only be abstract methods and variables and no method body.
-```
+```java
 interface printnum{
     void print();
 }