fixed

Author: Utkarsh1504

lessons/functions.md

@@ -6,8 +6,6 @@ section: "Learn Java"
 description: "Learn how to use functions and scope"
 ---
 
-## **Introduction to Methods/Functions** 
-
 Whether you a professional programmer or just a beginner it is always better to break your programme into blocks, or functions. It will help you later, first of all in debugging, secondly, it is just better to have an elegant, readable and organized code.
 
 A function is a part of a program that has its own name. This name can be used in the program as a command (this command is called a function call). When a function is called, the commands of which it consists are executed. A function call can return a value (similar to an operation) and therefore can be used in an expression along with operations.
@@ -16,35 +14,35 @@ In java, **Method** is also called as **Behaviour**.
 And **Variables** are also called as **States**. 
 
 
-## **Syntax**
+### **Syntax**
 
-```
+```java
 public static int function() 
 {
    //your function Body here//
 }
 ```
 
-## **Example**
-```
+### **Example**
+
+```java
 public static void function()
 {
     System.out.println("Hello World");
 }
 ```
 The main function which calls the above function is as follows:
 
-```
+```java
 public static void main(String []args)
 {
     //function() called below to print "Hello World"
     function();
 }
 ```
 
-T
-he **output** is as follows
-```
+The **output** is as follows
+```js
 Hello World
 ```
 
@@ -57,7 +55,7 @@ To return a something from a method you need to use "**return**" keyword followe
 
 The below example depicts to return a **Integer(int)** value.
 
-```
+```java
 public static int function()
 {
     int count = 0;
@@ -72,59 +70,18 @@ public static int function()
 Make sure that you return the integer value or else, **Compilation fails**.
 
 
-## **Parameters and Pass-By-Reference**
-Unlike any other language you can also pass some parameters to the methods in java.
-If your method needs some data to compute inside it then you must pass a **reference** of that data in the form of  parameters of your method. Again it can be of any data-type or else you can also pass the reference of any **object**. 
-So, here we use **Pass-by-reference** not **Pass-by-value**.
-
-Before passing the reference you should make your method in such a way that it should be able to take the parameters as shown in the below code.
-
-Suppose in the below example, you need to pass the reference of two integers to a method called as **sum** and your method returns the sum of both the two integers.
-
-```
-public static int sum(int num_1, int num_2)
-{
-    //sum of two numbers.
-    int sum =  num_1 + num_2;
-
-    //return sum of the numbers.
-    return sum;
-}
-```
-```
-public static void main(String []args)
-{
-    int a = 10;
-    int b = 20;
-
-    //Suppose you need to add above two numbers.
+## **Parameters and Pass-By-Value**
 
-    //passing the refernce of 'a' and 'b'.
-    int sum = sum(a, b); 
-
-    System.out.println(sum);
-}
-```
-
-**Execution of a Method**
 
 ## **Scope**
 **Scope** of a variable is the part of the program where the variable is **accessible**. Like C/C++, in Java, all identifiers are lexically (or statically) scoped, i.e.scope of a variable can determined at compile time and independent of function call stack. 
 Java programs are organized in the form of classes. Every class is part of some package. Java scope rules can be covered under following categories.
 
-  **Member Variables**
-
-- Scope of member variable is all over the class. You can use it anywhere but inside the class.
-
-**Local Variables**
-
-- Scope of Local variable is between the methods not outside the method, if you do so compiler throws an exception.
-
-**Block Variables**
-
-- The variables declared inside the block level statements cannot be accessed from outside the block. These blocks includes different types of loops, if else statements, etc. 
+1. **Member Variables** - Scope of member variable is all over the class. You can use it anywhere but inside the class.
+2. **Local Variables** - Scope of Local variable is between the methods not outside the method, if you do so compiler throws an exception.
+3. **Block Variables** - The variables declared inside the block level statements cannot be accessed from outside the block. These blocks includes different types of loops, if else statements, etc. 
 
-```
+```java
 class Scope
 {
     static int c = 10;
@@ -161,17 +118,17 @@ class Scope
 
 
 ## **Shadowing**
+
 Shadowing in Java is the practice of using variables in overlapping scopes with the **same** **name** where the variable in low-level scope overrides the variable of high-level scope. Here the variable at high-level scope is shadowed by the low-level scope variable.
 
 In other words we can also say that it will use the global variable untill it finds local variable i.e it will use the local variable when **overlapping** is met.
 
 You can get it well by refering to the below example
 
-```
+```java
 class shadow
 {
 	static int x = 20;
-	
 	public static void main(String []args)
 	{	
 		//here it preints the global variable
@@ -196,9 +153,7 @@ The output is as follows:
 ## **Overloading**
 
 - In method overloading, we can create methods that have the same name, but the methods differ in type, number and/or sequence of parameters.
-
 - When an overloaded method is invoked, Java uses the type, number and/or sequence of arguments as its guide to determine which version of the overloaded method to actually call.
-   
 - When java encounters a call to an overloaded method, it simplyexecutes the version of the method whose parameters match the arguments used in the call.
 
 **Rules of Overloading**
@@ -209,7 +164,7 @@ The output is as follows:
 
 The below example depicts the concept of method overloading.
 
-```
+```java
 class Adder
 {
     static int add(int a,int b)
@@ -240,14 +195,15 @@ The output is as follows
 
 
 ## **Conclusion**
+
 Hence after refering the above topics, we can conclude that if you need some code to be executed again again then we must use methods to increase the code reusability and increase the performance of the program.
 
 And also seen that how important is, the concept of overloading and the rules for it.
 Shadowing is also a great and unique concept where, whenever the variables overlaps then the latest one is considered.
 
 ## **Some Examples to practice**
-- Write a java program to find the area of different shapes by using the concept of method overloading.
 
+- Write a java program to find the area of different shapes by using the concept of method overloading.
 - Write a suitable java program which depicts the concept of shadowing.