In this project, you'll utilize your knowledge of Kotlin classes and all of the previously taught concepts in this course to help Codey build a calculator.

The first step in creating Codey's individual calculator is to generate a blueprint.  

In **Calculator.kt**, declare the class, `Calculator`, that accepts a `name` property within its primary constructor. 

**Note**: Running your code will result in the following error: 

```error 
could not find or load main class CalculatorKt
```

This error exists due to the absence of a `main()` function. If you'd like to get rid of this error now, go ahead and also create an empty `main()` function below the class. Otherwise, move on to the next step. 

Within the class body, add an `init` block that will output the owner of the calculator using the `name` property. 

Now, let's give our calculator the ability to make calculations. 

First, declare a member function called, `add()`, which should calculate and return the sum of two Integer values.




Next, implement the `subtract()` function which should calculate and return the difference between two Integer values. 

Another arithmetic function most commonly used on a calculator is multiplication. 

Implement the `multiply()` function which will calculate and return the product between two Integer values. 


The opposite calculation of multiplication is division. Add a member function, `divide()`, which should calculate and return the quotient between two Integer values. 

The member function should return an error message if the user tries to divide by `0`. 



Lastly, create the `power()` function which should calculate and return the first parameter raised to the power of the second.  

Think of how you can implement this within the function body. Give it a shot in the code editor. Move on to the next step for guided instruction.  



Within the body of the `power()` function, declare a new variable, `result`, and assign it the value of `1`. 

To achieve the power calculation, use a looping technique to iterate over each value, from `1` to param1. Within the body of the loop, reassign the value of `result` to be `result` times param2.   

Return `result` from the function.

Now that we've implemented several arithmetic functionalities, let's spring our calculator to action. If you haven't already done so, below the class, declare a `main()` function. 

In it, create a variable name of your choosing that will store an instance of the `Calculator` class. Pass in the name, `"Codey"` in the class call, and run your code. You should see the output statement from the `init` block.

On the following line, call the `add()` function on your instance and pass in two Integer values consecutively. Wrap your code in a `println()` statement to see the output. 



Use the same syntax to call each member function on your instance on a separate line and test their calculations. Make sure to wrap each line of code in a `println()` statement to see the output. 




Excellent work! If you’re up for a challenge, check out these additional tasks:

- To mimic a real-world calculator, we can format our output to also include the original calculation. `12` -> `5 + 7 = 12`.
- Having the code as is without any additional output, we can refactor some of the member functions to utilize a single expression syntax and shorten the lines of code that they span.  
- We can add another member function to the class that you'd like your calculator to perform. 



Sample solution: 

- [**Calculator.kt**](https://github.com/Codecademy/learn-kotlin/blob/main/7-classes/Calculator.kt)

If you make something cool, share it with us!

Codey's Calculator

Become a Data Analyst in just 10 weeks. Register & learn from an ex-Microsoft consultant. [REGISTER NOW](https://www.codecademy.com/bootcamps/data-1)