05-Classes/06-Instance_and_Class_Variables.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Instance and class variables in Java\r\n",
    "\r\n",
    "With the `findArea` call we've used the dot operator `.` to access a behavior or method from our `Triangle` class. \r\n",
    "\r\n",
    "What about attributes? So far, we have only accessed a triangle's instances values using the this keyword inside it's class. But, we can also access it outside it's class. \r\n",
    "\r\n",
    "\r\n",
    "In our main method we could print out `triangleA`'s, `sideLenThree` with `System.out.printLn(triangleA.sideLenThree);`. We use the dot `.` operator on `triangleA` to access it's instance variable. Or attribute variable, `sideLenThree`. \r\n",
    "\r\n",
    "We could also print out `triangleB`'s base with `System.out.println(triangleB.base);` The rule here is that it is a function if it has parenthesis and an attribute if it does not have parenthesis. `sideLenThree` and `base` are both attributes here. So, we do not add any parenthesis. We are accessing a variable, not calling a function. \r\n",
    "\r\n",
    "Let's save this and run the program. And, see what we get in the output. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "public class InstanceClassVariables {\r\n",
    "\r\n",
    "    public static void main(String[] args) {\r\n",
    "        Triangle triangleA = new Triangle(15, 8, 15, 8, 17);\r\n",
    "        Triangle triangleB = new Triangle(3, 2.598, 3, 3,3);\r\n",
    "\r\n",
    "        double triangleAArea = triangleA.findArea();\r\n",
    "        System.out.println(triangleAArea);\r\n",
    "\r\n",
    "        double triangleBArea = triangleB.findArea();\r\n",
    "        System.out.println(triangleBArea);\r\n",
    "\r\n",
    "        System.out.println(triangleA.sideLenThree);\r\n",
    "        System.out.println(triangleB.base);\r\n",
    "\r\n",
    "    }\r\n",
    "\r\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check the last two values. `17` is the length of `sideLenThree`. And, `3` is the `base` of `triangleB`. \r\n",
    "\r\n",
    "Remember, both `sideLenThree` and `base` are instance variables. Both of these variables hold information about a specific triangle instance. Just like we had static and non-static methods we have static and non-static variables. **Non-static variables** are the instance variables. The `base` of the triangle, the `height` of the triangle, they do not stay static or the same between triangle instances. The values of `base`, `height`, and the rest of our instance variables change depending on the triangle. A **static variable** is something that will not change per instance. They hold the value for the whole class to use. \r\n",
    "\r\n",
    "For example, we might have a static variable that stores how many sides there are to a triangle. This is something that will not change per instance. But, rather if you change it, it should effect every instance. \r\n",
    "\r\n",
    "Similar to how we accessed static behavior, or static methods we access a static variable using the class name. Since it does not change from instance to instance, and belongs to the class rather than a single instance, a static variable is accessed with a dot `.` operator, using the class name. \r\n",
    "\r\n",
    "Let's try adding a static variable to our triangle class. \r\n",
    "\r\n",
    "Inside the triangle class, we'll add a static variable above our instance variables. This static variable will be an `int`, and we will call it `numOfSides`. We will give it the value `3`. \r\n",
    "\r\n",
    "Going back to our main class, we can access the static `numOfSides` variable with the class name `Triangle`, and the dot `.` operator. \r\n",
    "\r\n",
    "We will want to print it out to the console. So, we will write `System.out.println`, and then use the class name triangle to access the static variable, `numOfSides`. \r\n",
    "\r\n",
    "Let's run it. \r\n",
    "\r\n",
    "And we see `3` in our console. We have three sides to a triangle. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "public class InstanceClassVariables {\r\n",
    "\r\n",
    "    public static void main(String[] args) {\r\n",
    "        Triangle triangleA = new Triangle(15, 8, 15, 8, 17);\r\n",
    "        Triangle triangleB = new Triangle(3, 2.598, 3, 3,3);\r\n",
    "\r\n",
    "        double triangleAArea = triangleA.findArea();\r\n",
    "        System.out.println(triangleAArea);\r\n",
    "\r\n",
    "        double triangleBArea = triangleB.findArea();\r\n",
    "        System.out.println(triangleBArea);\r\n",
    "\r\n",
    "        System.out.println(triangleA.sideLenThree);\r\n",
    "        System.out.println(triangleB.base);\r\n",
    "\r\n",
    "        System.out.println(Triangle.numOfSides);\r\n",
    "\r\n",
    "    }\r\n",
    "\r\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, this representation of triangle isn't perfect. Right now we assume the values given to the constructor are valid. None of them are zero or negative. And, they together meet the requirements for a triangle. This is something that you can add on later if you want to. But, we are keeping this as simple as possible for now. \r\n",
    "\r\n",
    "In this notebook, we have introduced a lot of new concepts so let's just review what we have learned."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  Classes vs. instances\r\n",
    "\r\n",
    "\r\n",
    "So what are the big takeaways from this chapter? First, in Java, we can create classes to organise our code. In our previous example, we used a `Triangle` class to organise data related to a triangle as well as how we can calculate things from triangle data. \r\n",
    "\r\n",
    "A **class** contains attributes and behaviour, also called **properties** and **methods**. Every class also contains a **constructor**, which is a specific type of method that allows us to create instances of the class.\r\n",
    "\r\n",
    "Ultimately, a class is just a blueprint, and we have to use the constructor in order to create triangles in our code. Some of these attributes are associated with each individual instance, and we call these **instance variables**. These were the `height`, `base`, and `sideLength` attributes in our example. These attributes are accessed with the instance itself, and we use the dot `.` operator on the instance to access instance variables. \r\n",
    "\r\n",
    "Along with instance variables, each instance has instance functions or **non-static methods**. Similarly, these are accessed using the instance with the dot `.` operator and parentheses. We also have **class variables** and **class methods**. These variables and methods are static and we access them using the class name with the dot `.` operator. To use static class variables and methods, we do not need to create an instance, we can just use the class name. \r\n",
    "\r\n",
    "This new vocabulary can sometimes be overwhelming, but when you are debugging, Googling, and trying to figure out how to fix your code, these words often come up. Understanding these concepts is a big hurdle in Java, and once you get it, everything starts to make more sense!"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Java",
   "name": "java"
  },
  "language_info": {
   "name": "java",
   "version": ""
  },
  "orig_nbformat": 2
 },
 "nbformat": 4,
 "nbformat_minor": 2
}