Classes in PHP

Classes in PHP can be defined with a syntax like:

class MyClass
{
   public $field_var1;
   public $field_var2 = 5;
   ...
   const constant1;
   const constant2;
   ...

   function __construct($arg1, $arg2) {
     //constructor code
   }

   function myFun1() {
     // code
   }
   ...
}

To create instances of a class we use the new operator. To dereference fields, or invoke instance functions we use the arrow -> operator.
```
$arg1 =5;
$arg2 = 6;
$my_class = new MyClass($arg1, $arg2);
echo $my_class->field_var1;
$my_class->myFun1();
```
Typically, you put the code for your class into a file and then use a line like:
```
require("MyClass.php");
//or more likely
require_once("MyClass.php");
```
We mentioned this earlier, but I'll just remind people: The require syntax is similar to include except when it fails it gives a fatal error rather than a warning. Also you cannot use require to include remote files even if allow_url_fopen is enabled.
require_once will not re-include the file if it has already been included.
PHP comes with several built-in classes and interfaces.
Several common data structures are also implemented in the Standard PHP Library (SPL).

Constructors/Destructors

We saw we could set up an initial value of a field variable of a class when we declare it:
```
public $my_variable = 0;
```
You can also have a functions __construct and __destruct to do initialization and clean-up.
```
function __construct($n=0) {
     $this->my_variable = $n;
}
```

Private, Protected, Public

Member variables and member functions can be declared private, protected or public:
```
private $my_field;
protected function myMethod() { /* some code*/}
```
Methods without any declaration are the same as public. It is a good habit though to explicitly state the visibility
private means only visible within the class.
protected is visible within the class or within subclasses.
public means variable or method is visible to anyone. There is an older way to declare public fields:
```
var $my_field;
```
This is less clear than the public syntax so should be avoided.

Static and Const

The static keyword creates one instance of the field or method for the class.
```
class Foo{ static $bob=1;} 
echo "bob: ".Foo::$bob;
```
Within the class use self:: to refer to static members.
The const keyword can be used to define constants for a class:
```
class Goo{ const blob=1;}
```
Notice no dollar sign. Can refer to this using
```
Goo::blob
```
Values of constants cannot be changed.
You can create constants not within a class using define:
```
define("PI", 22/7);
echo PI;
```

Cloning

PHP has a command clone for cloning objects:
```
$my_copy = clone $my_obj;
```
To specify how the copying is done you can write a __clone() method for your class.

Quiz

Which of the following statements is true?

The SQL CREATE DATABASE command is used to create a new database table.
A new row could be inserted into the table FOO (A INT) using the command: INSERT INTO FOO VALUES (55);
BCNF is a PHP interface for connecting to a database.

Inheritance

So far we've described how to make a PHP class, constructors, destructors, and cloning.
We've said unlike the default copy-on-write semantics of array assignment, object assignment in PHP is by reference. Let's now turn to inheritance.
Inheritance in PHP is very similar to Java.
A PHP class can extend one other class.
```
class A{}
class B extends A {}
```

PHP also has a notion of interface:

interface MyInterface
{
    function method1($a, $b);
}

A PHP class can implement multiple interfaces:

class C implements MyInterfaceA, MyInterfaceB {}

If you want to have a class with some but not all of its methods defined. You can use the keyword abstract on those methods which will be overriden in subclasses.

Referring to Parents, Final

Consider:

class A {function foo(){} }
class B extends A {function foo(){} }

Within B, self::foo() refers to the redefinition of foo given in the second line above. (Instance methods can also be called using $this->method())
Within B, parent::foo() refers to class A's version of foo.
To prevent a function from being overridden in a subclass you can use the keyword final.
```
class A {final function foo() {} /* can't override*/ }
```

Namespaces

Like C++, PHP supports a notion of namespace. This is similar to the Java notion of package. It allows one to group together a collection of functions, constants, classes, interfaces under one name.
Namespaces must be declared at the start of the file they are in (only the declare command can occur earlier)
A namespace might be declared with a line like:
```
namespace TheNameOfMyNamespace;
// code for namespace
class A
{
  //code for class A
}
function foo()
{
}
```
This declaration with the same name can be at the top of multiple files if you would like to group the contents of these files into the same namespace.
A sub-namespace of a namespace can be declared using backslashes:
```
namespace TheNameOfMyNamespace\MySubNameSpace;
//code
```
Within one file you can switch what namespace you are defining, but it is not recommended:
```
namespace D {
  // code for D
}
namespace E {
  // code for E
}
```

Using Namespaces

Function or class names without qualifications are assumed to come from the current namespace:
```
namespace N;
function foo()
{
  //some code
}

foo(); //assume N namespace.
```

Before function, interface, class, or constant names we can also give the namespace path (either relative or absolute):

M\foo(); /*in context of above we are in N namespace already, 
          so M\foo() means the foo() in N\M namespace. */
\N\M\foo();
\time(); //time function in the global (default) namespace.

You can import a namespace using the use keyword:

use A\B\C;
//rather that type $a= new A\B\C(); you can type $a= new C();
use D\E\F as G;
//rather than typing D\E\F\goo(); could type G\goo();

Namespace Conventions

When you create a new project you don't want to pollute the global namespace with your variables, functions, and classes.
Doing so prevents your code from inter-operating with other PHP code.
The modern way to create PHP projects is to write your project within a namespace of the format: some_vendor_name\some_project_name.
For example,
```
namespace seekquarry\yioop;
```
Following this convention, the above declaration should be at the top of a file with at most one file level comment at above it.
You can of course declare instead sub-namespaces of the project too such as:
```
namespace seekquarry\yioop\models;
```
After the declaration, you should have a blank line followed by any use declarations you need.

Autoloading

The require and require_once commands read in the file given as their argument regardless of whether the classes, functions, etc. are ever used.
In a web and interpreted environment this can result in slower performance, if there are a lot of files being included in this way.
On the other hand, a use declaration does not load anything into memory -- it is just declares a naming convention to be used for how to refer to classes and functions.
In PHP, we can use the spl_autoload_register($your_autoloader_function); command to register a PHP function to be called whether someone tries to instantiate a class or call a function which is not currently in memory.
Using autoloading, allows us to minimize the number of files we read in before executing code.
The autoloader function typically makes use of the namespace info from use declarations to search the file system to find the definition of the class or function that is being instantiated or used.

PHP Classes, Namespaces, Autoloading

Outline