Learn what classes are and how to create your own in PHP.

Classes and Objects

In the previous exercise, we created a class (a blueprint) for any pet we may want to make. But we didn't make any actual, individual pet objects. Since objects are specific instances of a class, the process of creating them is called _instantiation_.

In PHP, objects are instantiated using the `new` keyword followed by the class name and parentheses.

```php
$very_good_dog = new Pet();
```
We now have our first object, `$very_good_dog`. We interact with an object's properties using the _object operator_ (`->`) followed by the name of the property (without the dollar sign, `$`).

We can use this syntax to assign values to object properties:
```php
$very_good_dog->name = "Lassie";
```

We can also use it to access the existing value of object properties:
```php
echo $very_good_dog->name; # Prints "Lassie"
```



Instantiating

Now you have the knowledge to create your own classes and objects in PHP using OOP! Take some time to review the concepts before moving on:
- Classes are defined using the `class` keyword.
- Functions defined within a class become methods and variables within the class are considered properties.
- There are three levels of visibility for class members:
 - `public` (default) - accessible from outside of the class
 - `protected` - only accessible within the class or its descendants
 - `private` - only accessible within the defining class
- Members can be defined to be `static`.
 - Static members are accessed using the Scope Resolution Operator (`::`).
- Classes are instantiated into objects using the `new` keyword.
 - Members of an object are accessed using the Object Operator (`->`).

Review

Sometimes, we want to change how methods behave for subclasses from the original parent definition. This is called _overriding_ a method. To do this, define a new method within the subclass with the same name as the parent method.

For example, our `Pet` class might have a `type()` method:
```php
class Pet {
  function type() {
    return "pet";
  }
}
```
But in our `Dog` class, we want to update this message:
```php
class Dog extends Pet{
  function whatIsThis() {
    return "dog";
  }
}
```
We can call the parent's definition of the method within the subclass using `parent::` followed by the method name:
```php
class Dog extends Pet{
  function type() {
    return "dog";
  }
  function classify(){
    echo "This " . parent::type() . " is of type " . $this->type();
    // Prints: This pet is of type dog 
  }
}
```

Overriding Methods

In addition to properties, we can define class methods -- essentially functions each object will contain. Methods are frequently used to interact with an object's properties in a defined manner.

Methods are defined with the same syntax we use when declaring functions (except they are defined within the curly brackets of a class).

Given a `Pet` class with `first` and `last` name properties, we could provide a method which returns the two properties combined into a full name:
```php
class Pet {
  public $first, $last;
  function getFullName() {
    return $this->first . " " . $this->last;
  }
}
```

The `$this` variable refers to the current object; when we invoke this method, `$this` refers to the specific object that called the method. 

Methods are accessed in a similar fashion to properties, using the object operator (`->`), but in order to invoke them, use parentheses at the end:
```php
$my_object->classMethod();
```

So, to access the full name of our `Pet`, we can use the following:
```php
$very_good_groundhog = new Pet();
$very_good_groundhog->first = "Punxsutawney";
$very_good_groundhog->last = "Phil";
echo $very_good_groundhog->getFullName(); # Prints "Punxsutawney Phil"
```

Methods

In our PHP programs so far, we've relied on data types built into the language—we've used String, Number and Boolean data types directly and saved data in variables. We've also used Arrays to organize multiple pieces of data within a single structure. 

But sometimes the data types built into the language aren't enough! Just as we can write custom functions and not depend exclusively on PHP's built-in functions, we can write custom data types. 

In order to define our own data types, we'll think of the general qualities our user-defined types should have. We'll create a _class_ —a blueprint defining the related data and functions that should be bundled together inside each instance of this new type. Once the class is defined, we can create specific instances of it—as many as we want! These instances of the class are called objects.

Classes are a blueprint for making objects.

Introduction

The concept of only accessing properties through methods is commonly referred to as using _getters_ and _setters_.

For example:
```php
class Pet {
  private $name;
  function setName($name) {
    $this->name = $name;
  }
  function getName() {
    return $this->name;
  }
}
```
This is the most basic way of using getters and setters in PHP. Initially, it may look like it adds little value over making properties `public` and accessing them directly. But what if we only want to accept a string when setting the name of a `Pet`?

We can add logic to the setter to ensure that the value being passed in is formatted properly:
```php
function setName($name) {
  if (gettype($name) === "string") {
    $this->name = $name;
    return true;
  } else {
    return false;
  }
}
```
We added return values to the setter to provide some feedback as to whether the call to `setName` was successful.

We can also use the getter to format values as they are passed out of the object. In this example, we are capitalizing the first letter of the `Pet` name:
```php
function getName() {
  return ucfirst($this->name);
}
```

Getters and Setters

Instantiating objects is the most common way to use classes and is also the most in-line with OOP principles. Sometimes though, it can be useful to group a set of utility functions and variables together into a single class. Since these don't change for every instance, we don't need to instantiate them. We can use them _statically_.

When a member is intended to be used statically, we add the keyword `static` to its definition. 

Consider this class with a `static` property and a `static` method:
```php
class StringUtils {
  public static $max_number_of_characters = 80;
  public static function uclast($string) {
    $string[strlen($string)-1] = strtoupper($string[strlen($string)-1]);
    return $string;
  }
}
```
Accessing these `static` members is done a little differently than with objects. We need to use the [Scope Resolution Operator](https://www.php.net/manual/en/language.oop5.paamayim-nekudotayim.php) (`::`). This can be thought of as switching briefly into the scope of the class itself. Since we are inside the scope, we access properties with the dollar sign.
For example:
```php
echo StringUtils::$max_number_of_characters; # Prints "80"
```
Methods are accessed by using the method name:
```php
echo StringUtils::uclast("hello world"); # Prints "hello worlD"
```


Static Members

To understand visibility we need to think about how classes will be used in complex programs—in large applications, a class might be used in diverse situations (passed around inside functions and used in code written by numerous developers). When we think about our classes being used in many situations, we'll want to consider restricting access to certain member data. 

Up to this point, we've been using `public` visibility for properties. This is also the default visibility for methods. A `public` visibility means members can be accessed from within the object **or** from outside it. But sometimes we'll want a member to only be accessible from within the object. To do this, we can declare this member `private`. 

Let's look at an example:
```php
class Pet {
  private $healthScore = 0; 
  function exercise(){
    $this->healthScore++;
  }
  function feed(){
    $this->healthScore++;
  }
  function healthCheck(){
    if ($this->healthScore >= 2){
      echo "This is a healthy pet!";
    } else {
      echo "This is an unhealthy pet";
    }
  }
}
```
In the code above, we have the property `healthScore`. This is a number we use to calculate the health of a pet. The `healthScore` property can be manipulated and accessed by member methods, but since we never want the property to be accessed directly outside of the class, we set the property as `private`. If an attempt is made to access the property directly, our code will raise a `Fatal Error`.

Visibility - Private Members

In the previous exercise, we asked you to imagine a class for pets. Let's see how we would actually create a PHP `Pet` class. 

To define a `Pet` class, we use the `class` keyword followed by the class name (typically title cased in PHP) and curly brackets:
```php
class Pet {

}
```
Within the curly brackets, we can add _properties_, which define the data each object of the class will contain.  The syntax is similar to how we define variables:
```php
class Pet {
  public $name, $color;
}
```
Note: The `public` keyword has to do with something called visibility.  We'll discuss this in depth later in the lesson.


What are Classes?

A constructor method is one of several [magic methods](https://www.php.net/manual/en/language.oop5.magic.php) provided by PHP. 
This method is automatically called when an object is instantiated. A constructor method is defined with the special method name `__construct`. 

As an example, if we wanted to initialize the `deserves_love` property assigned to `TRUE` for every instance of the `Pet` class, we could use the following constructor:
```php
class Pet {
  public $deserves_love;
  function __construct() {
    $this->deserves_love = TRUE;
  }
}
$my_dog = new Pet();
if ($my_dog->deserves_love){
  echo "I love you!";
}
// Prints: I love you!
```
Constructors can also have parameters. These correspond to arguments passed in when using the `new` keyword. For example, maybe we want to allow for setting the `name` of the `Pet` on instantiation:
```php
class Pet {
  public $name;
  function __construct($name) {
    $this->name = $name;
  }
} 
$dog = new Pet("Lassie");
echo $dog->name; // Prints: Lassie
```
In  the code above, we instantiate a new Pet object, `$dog` with a `name` property assigned to the value `"Lassie"`. Then we access the property and print it.

Keep in mind that the number of arguments used when instantiating the object must match the number of parameters in the constructor definition otherwise PHP will throw an error.


Constructor Method

Imagine we wanted a `Dog` class in our program. This class would have all the properties of the more general `Pet` class, but it would have a few more properties and methods specific to only dogs. Rather than having to manually duplicate the things the two classes have in common, we can create a new class which **extends** the other. The original class can be thought of as the _parent_ and the new class can be thought of as the _child_ class. In object oriented programming, we call this process _inheritance_ since the child class _inherits_ properties and methods from its parent class. A child class is also referred to as a _subclass_ in PHP.

To define a class that inherits from another, we use the keyword `extends`:
```php
class ChildClass extends ParentClass {

}
```

Let's define a `Dog` class that extends our `Pet` class. Each `Dog` instance will have an additional method called `bark()`:
```php
class Dog extends Pet {
  function bark() {
    return "woof";
  }
}
```
Now, objects of class `Dog` can `bark`, but objects of `Pet` cannot. This makes sense here, because most dogs can bark, but not all pets can.

Inheritance

A class's `private` members can **only** be accessed using methods within that class itself. This isn't usually the desired effect when we have subclasses. For example, the following code will throw a `Fatal Error`, since `healthScore` is private to the `Pet` class and can't be accessed from the `Horse` class:
```php
class Pet {
  private $healthScore = 0; 
}

class Horse extends Pet {
  function brushTeeth() {
    $this->healthScore++; 
  }
}

$my_pet = new Horse();
$my_pet->brushTeeth(); // Error
```
To allow members to be accessed from within child classes, we can set the visibility within the parent class to `protected` rather than `private`. This enables child classes to access these properties and methods internally while still preventing them from being accessed externally:
```php
class Pet {
  protected $healthScore = 0; 
}

class Horse extends Pet {
  function brushTeeth() {
    $this->healthScore++; 
  }
}

$my_pet = new Horse();
$my_pet->brushTeeth(); // Successfully increments healthScore
$my_pet->healthScore; // Error
```
