1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##Lesson 1: Classes and objects\n",
    "\n",
    "##### New keywords\n",
    "- `class`\n",
    "- `new`\n",
    "- `->`\n",
    "- `$this`\n",
    "\n",
    "# Introduction\n",
    "\n",
    "Objects are key to understanding object-oriented technology. Look around right now and you'll find many examples of real-world objects: your dog, your desk, your television set, your bicycle.\n",
    "\n",
    "Real-world objects share two characteristics: They all have state and behavior. Dogs have state (name, color, breed, hungry) and behavior (barking, fetching, wagging tail). Bicycles also have state (current gear, current pedal cadence, current speed) and behavior (changing gear, changing pedal cadence, applying brakes). Identifying the state and behavior for real-world objects is a great way to begin thinking in terms of object-oriented programming.\n",
    "\n",
    "Bundling code into individual software objects provides a number of benefits, including:\n",
    "- Modularity: The source code for an object can be written and maintained independently of the source code for other objects. Once created, an object can be easily passed around inside the system.\n",
    "- Information-hiding (encapsulation): By interacting only with an object's methods, the details of its internal implementation remain hidden from the outside world.\n",
    "- Code re-use: If an object already exists (perhaps written by another software developer), you can use that object in your program. This allows specialists to implement/test/debug complex, task-specific objects, which you can then trust to run in your own code.\n",
    "- Pluggability and debugging ease: If a particular object turns out to be problematic, you can simply remove it from your application and plug in a different object as its replacement.\n",
    "\n",
    "## Classes and Objects\n",
    "\n",
    "A class is a source code blueprint for objects. Other analogies are classes provide a factory to create objects with, or are an 'object template'.\n",
    "\n",
    "Objects are instantiated out of classes by using the new keyword. Another way to think about it is that we instantiate (create instances from) a class in order to assign an instance of the class to a variable.\n",
    "\n",
    "## The Class Keyword\n",
    "The `class` keyword takes a code block that represents an object factory. Inside the code block, properties and methods are created.\n",
    "Objects are instantiated out of classes by using the `new` keyword. Here is a completely bare Person class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=> \u001b[34;4mPerson\u001b[39;24m {#243}"
     ]
    },
    {
     "data": {},
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// Defines a \"Person\" class.\n",
    "class Person {\n",
    "}\n",
    "\n",
    "// Creates a \"Person\" object.\n",
    "$person = new Person();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The “class” blueprint can specify:\n",
    "- Name: identifies the class.\n",
    "- Properties (variables): contain the attributes of the class.\n",
    "- Methods (functions): contain the behaviors of the class.\n",
    "\n",
    "We might have a Person class that represents a person. The person might have properties such as a name, a height, a weight, a date of birth, etc. A person might have some ability to walk, which we could represent as a method.\n",
    "We can access properties or methods of the object using the object operator, `->`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi!\n"
     ]
    },
    {
     "data": {},
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=> \u001b[36mnull\u001b[39m"
     ]
    },
    {
     "data": {},
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// Defines a \"Person\" class.\n",
    "class PersonWhoTalks {\n",
    "\n",
    "  // Defines a method.\n",
    "  function sayHi() {\n",
    "    echo 'Hi!';\n",
    "  }\n",
    "}\n",
    "\n",
    "// Creates a \"PersonWhoTalks\" object.\n",
    "$person = new PersonWhoTalks();\n",
    "$person->sayHi();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `$this`\n",
    "Within an object method, `$this` is a reference to the current object. Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Joe Bob\n"
     ]
    },
    {
     "data": {},
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=> \u001b[36mnull\u001b[39m"
     ]
    },
    {
     "data": {},
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class PersonWithName {\n",
    "  // Define a property.\n",
    "  public $name;\n",
    "\n",
    "  // Defines a \"setter\" method.\n",
    "  function setName($name) {\n",
    "    $this->name = $name;\n",
    "  }\n",
    "  \n",
    "  function sayName() {\n",
    "    echo $this->name;\n",
    "  }\n",
    "}\n",
    "\n",
    "$person = new PersonWithName();\n",
    "$person->setName('Joe Bob'); // Sets the name.\n",
    "$person->sayName(); //Joe Bob"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Notes:\n",
    "Objects are always passed by reference, meaning that a function that accepts an object as a parameter modifies the original object passed to it, rather than making a copy of it.\n",
    "\n",
    "## Coding Standards:\n",
    "- Class name: uppercase camels, eg: `MyClass`\n",
    "- Class properties/methods: lowercase camels, eg: `myProperty`\n",
    "- One class per file.\n",
    "- No closing `?>` tag.\n",
    "\n",
    "## Exercises\n",
    "1. Create a “Person” class and instantiate an object of it.\n",
    "2. Add properties for name, age.\n",
    "3. Add methods getName(), getAge().\n",
    "4. Invoke var_dump() on the person object to inspect it.\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "PHP",
   "language": "php",
   "name": "jupyter-php"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}