Tutorioal PHP: OOP-PHP Autoload

Assalamualaikum Semua

      Hallo semua selamat datang kembali. Saya Muhammad Aslam atau panggil saja Mas Lam akan berbagi pengetahuan tentang PHP langsung saja tanpa banyak basa basi lagi yu urang belajar PHP.

Autoload

Banyak pengembang yang membuat aplikasi berorientasi objek
membuat satu file sumber PHP per definisi Class. Salah satu
gangguan terbesar adalah harus menulis daftar panjang yang
diperlukan termasuk pada awal setiap skrip (satu untuk setiap
Class).

Di PHP 5, ini tidak lagi diperlukan. Fungsi
spl_autoload_register () mendaftarkan sejumlah
autoloader, memungkinkan Class dan antarmuka dimuat secara
otomatis jika mereka saat ini tidak didefinisikan. Dengan
mendaftarkan autoloaders, PHP diberikan kesempatan terakhir

untuk memuat Class atau antarmuka sebelum gagal dan error.

Contoh autoload

<?php
spl_autoload_register(function($class_name){
include $class_name . '.php';
});

$obj = new MyClass1();
$obj2 = new MyClass2();
?>

Object Interface

Object Interface memungkinkan Anda membuat kode yang menentukan
METHOD mana yang harus diimplementasikan oleh suatu Class, tanpa harus
menentukan bagaimana method ini diterapkan.

Interface didefinisikan dengan cara yang sama seperti Class, tetapi dengan kata
kunci Interface menggantikan kata kunci Class dan tanpa method apa pun yang
memiliki kontennya ditentukan.

Semua method yang dideklarasikan di Interface harus bersifat public ; ini adalah
sifat interface.

Perhatikan bahwa dimungkinkan untuk mendeklarasikan konstruktor di interface,
apa yang bisa berguna dalam beberapa konteks.

Implements

Untuk mengimplementasikan interface, operator
implement digunakan. Semua method dalam interface
harus diimplementasikan dalam class; error akan
menghasilkan kesalahan fatal. Class dapat di implement
lebih dari satu interface jika diinginkan

contoh 1 interface

<?php 

interface iTemplate
{
 public function setVariable($name,$var);
 public function getHtml($template);
}

class Template implements iTemplate
{
 private $vars = array();

 public function setVariable($name, $var)
 {
  $this->vars[$name] = $var;
 }

 public function getHtml($template)
 {
  foreach ($this->vars as $name => $value) {
   $template = str_replace('{'.$name.'}', $value, $template);
  }
  return $template;
 }
}

class BadTemplate
{
 private $vars = array();

 public function setVariable($name,$var){
  $this->vars[$name] = $var;
 }
}

contoh 2 interface(extendable interface)

<?php

interface a
{
 public function foo();
}

interface b extends a
{
 public function baz(Baz $baz);
}

class c implements b
{
 public function foo()
 {
 }

 public function baz(Baz $baz)
 {
 }
}
//fatal error
class d implements b
{
 public function foo()
 {
 }

 public function baz(Baz $baz)
 {
 }
}

Contoh 3 interface (extendable interface)

<?php

interface a
{
 public function foo();
}

interface b
{
 public function bar();
}

interface c extends a,b
{
 public function baz();
}

class d implements c
{
 public function foo(){}
 public function bar(){}
 public function baz(){}
}

Contoh 4 interface (interface with constant)

<?php

interface a
{
 const b = 'Interface constant';
}

echo a::b;

class b implements a
{
 const b = 'Class constant';
}

Visibility

Visibilitas dari sebuah properti, method atau (pada PHP
7.1.0) sebuah konstanta dapat didefinisikan dengan
mengawali deklarasi dengan kata kunci public, protected
atau private.

Anggota class dideklarasikan public agar dapat diakses di
mana saja. Anggota yang dinyatakan protected hanya
dapat diakses di dalam class itu sendiri dan dengan
mewarisi class induk. Anggota yang dinyatakan sebagai
private hanya dapat diakses oleh class yang
mendefinisikan anggotanya.

Property Visibility

Class property harus didefinisikan sebagai public,
private, atau protected. Jika dideklarasikan
menggunakan var, properti akan didefinisikan
sebagai public.

Contoh 1 property declaration

<?php

class MyClass
{
 public $public = 'Public';
 private $private = 'Private';
 protected $protected = 'Protected';

 function printHello()
 {
  echo $this->public;
  echo $this->private;
  echo $this->protected;
 }
}

$obj = new MyClass();
echo $obj->public;
echo $obj->private;
echo $obj->protected;
$obj->printHello();


class MyClass2 extends MyClass
{
 public $public = 'Public2';
 protected $protected = 'Protected2';

 public function printHello()
 {
  echo $this->public;
  echo $this->protected;
  echo $this->private;
 }
}

$obj2 = new MyClass2();
echo $obj2->public;// Works / Run Smoothly
echo $obj2->protected; // Fatal error
echo $obj2->private;// Undefined
$obj2->printHello();

Method Visibility

class Method dapat didefinisikan sebagai public, private,
atau protected. Method yang dinyatakan tanpa kata kunci
akan didefinisikan sebagai publik.

Contoh 2 Method Declaration

<?php

class MyClass
{
 //Declare construct
 public function __construct(){}
 //Declare public method
 public function MyPublic(){}
 //Declare protected method
 protected function MyProtected(){}
 //Declare private method
 private function MyPrivate(){}

 function Foo()
 {
  $this->MyPublic();
  $this->MyProtected();
  $this->MyPrivate();
 }

}

$myclass = new MyClass();
$myclass->MyPublic(); //Works
$myclass->MyProtected(); //Fatal error
$myclass->MyPrivate(); //Fatal error
$myclass->foo(); //Work


class MyClass2
{
 function Foo2()
 {
  $this->MyPublic();
  $this->MyProtected();
  $this->MyPrivate();
 }
}

$myclass2 = new MyClass2();
$myclass2->MyPublic();
$myclass2->Foo2();

class Bar
{
 public function test()
 {
  $this->testPrivate();
  $this->testPublic();
 }

 public function testPublic()
 {
  echo "Bar::testPublic\n";
 }

 public function testPrivate()
 {
  echo "Bar::testPrivate\n";
 }
}

class Foo extends Bar
{
 public function testPublic()
 {
  echo "Foo::testPublic\n";
 }

 public function testPrivate()
 {
  echo "Foo::testPrivate\n";
 }
}

Visibility Konstanta (constant)

Pada PHP 7.1.0, konstanta class dapat didefinisikan
sebagai public, private, atau protected. Konstanta yang
dideklarasikan tanpa kata kunci didefinisikan sebagai
publik.

Contoh 3 Constant Declaration as of PHP

<?php

class MyClass
{
 public const MY_PUBLIC = 'public';
 protected const MY_PROTECTED = 'protected';
 private const MY_PRIVATE = 'private';

 public function foo()
 {
  echo self::MY_PUBLIC;
  echo self::MY_PROTECTED;
  echo self::MY_PRIVATE;
 }
}

$myClass = new MyClass();
MyClass::MY_PUBLIC;//Works
MyClass::MY_PROTECTED;//Fatal error
MyClass::MY_PRIVATE;//Fatal error

/*
Define new class
*/

class MyClass2 extends MyClass
{
 function foo2()
 {
  echo self::MY_PUBLIC;
  echo self::MY_PROTECTED;
  echo self::MY_PRIVATE; //Fatal error
 }

 $myClass2 = MyClass2();
 echo MyClass2::MY_PUBLIC;//Works
 $myClass2->foo2();// Public and protected is works, but private doesn't works

}

Visibility dari objek lain

Objek dengan tipe yang sama akan memiliki akses satu sama lain,
private dan protected meskipun bukan pada instance yang sama. Ini
karena detail spesifik implementasinya sudah diketahui ketika
berada di dalam objek tersebut.

Contoh 4 Accessing private members of the same object type

<?php
/*
This class is show you how to access private method
*/

class Test
{
 private $foo;

 public function __construct($foo)
 {
  $this->foo = $foo;
 }

 private function bar()
 {
  echo "Accessed the private method";
 }

 public function baz(Test $other)
 {
  // We can change the value of property
  $other->foo = 'hello';
  var_dump($other->foo);

  //We can also access the private method
  $other->bar();
 }
}

 $test = new Test('test');

 $test->baz(new Test('other'));