05-Classes/01-Classes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Classes in Java\r\n",
    "\r\n",
    "\r\n",
    "In this topic, we will continue to talk about program design and about how we can make our programs readable to other developers. There are often several software developers working on the same program, so it's essential to write code in a way that's easy to read and understand. \r\n",
    "\r\n",
    "A lot of times, I'll forget about code that I've written six months ago. And if it's written in a way where it's hard to understand, I have to take a significant amount of time to understand it before I can add functionality to it. \r\n",
    "\r\n",
    "We want to prevent that. One way to make our program easier to read and understand is with **classes**. We've seen classes a little bit before because all of our code so far has been contained within the a class. But now we are going to dive a little deeper.\r\n",
    "\r\n",
    "Everything we see, hear and experience in everyday life can be represented in code. We've represented the on-repeat functionality of a music player. The final total that may be on a restaurant receipt and more. How well something is represented is up to us and we decide what to code. \r\n",
    "\r\n",
    "Although we've used functions and other tools to represent these in code, most of the time, classes act as blueprints for these things. A class is a **user-defined blueprint** that has a set of attributes and behaviours that define the item that it is supposed to represent. \r\n",
    "\r\n",
    "For example, let's say we wanted to create a class or blueprint for a triangle. \r\n",
    "\r\n",
    "When we think of a triangle, it has a base, a height, and three sides with various lengths. These are attributes or properties of a triangle, so we can define them as that for our blueprint or class. \r\n",
    "\r\n",
    "```\r\n",
    "double base; double  height;\r\n",
    "\r\n",
    "double sideLenOne; double sideLenTwo; double sideLenThree\r\n",
    "```\r\n",
    "\r\n",
    "Each of these attributes will define a data type and they will act as a variable in the blueprint. The base, height and sides of the triangle will have double values. Every triangle we create will have a base, height, and side lengths. The values may not be the same but every triangle has these attributes and these attributes are really variables that will hold a particular value for a given triangle. \r\n",
    "\r\n",
    "## Methods \r\n",
    "\r\n",
    "A class can also have behaviour. The behaviours are defined as functions that are related to the class. In the debugging topic, we debugged some code that calculated the area of a triangle. We could turn that code into a function called `findArea` and add that as behaviour to our triangle class. The functionality would be the same but it's nice to make it a function so we can reuse it as well as organise it by putting it in our Triangle class. \r\n",
    "\r\n",
    "Another name for a behaviour is a **method**. We could say that `findArea` is a method of the Triangle class. We could also add a behaviour or function to this class that decides if the triangle is an equilateral, isosceles or scalene triangle. An equilateral triangle has equal side lengths. An isosceles triangle has two side lengths that are equal and a scalene triangle has all unique side lengths. With if statements and some comparisons with the side length attributes, we could implement a function called `calculateTriangleType` that returns the type of triangle. \r\n",
    "\r\n",
    "```\r\n",
    "Attributes:  base; height; sideLenOne; sideLenTwo; sideLenThree\r\n",
    "\r\n",
    "Methods: findArea(), calculateTriangleType() \r\n",
    "```\r\n",
    "\r\n",
    "One could argue that the fact the triangle is equilateral, isosceles or scalene, is more of an attribute or property rather than something to be calculated. But this is just one programmatic design. There are a bunch of different ways you could represent a triangle in code, it just depends on what functionality you want and what data you want to store. \r\n",
    "\r\n",
    "For the behaviours we've talked about so far, they have manipulated or used attributes of the class. `findArea` used the triangle's base and height and `calculateTriangleType` used the side lengths of the triangle. \r\n",
    "\r\n",
    "Although functions inside the class or behaviours often use a classes properties, they don't have to. We add the keyword `static` if the function does not use the properties of the class but still relates to the overall theme or idea of the class. We'll dive into the keyword `static` later. \r\n",
    "\r\n",
    "Now that we understand classes conceptually, we can connect these blueprints to the execution of our programs."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Java",
   "name": "java"
  },
  "language_info": {
   "name": "java",
   "version": ""
  },
  "orig_nbformat": 2
 },
 "nbformat": 4,
 "nbformat_minor": 2
}