本篇文章给大家带来的内容是PHP什么是面向对象？PHP面向对象小结。有一定的参考价值，有需要的朋友可以参考一下，希望对你们有所助。
面向对象特性：
*重用性 （每个模块都可以在项目中重复使用）
*灵活性 （每个模块都很轻松被替换更改的）
*拓展性（在模块上添加新功能是很方便的）
类和对象的关系（类生成对象）
物以类聚：相同特性的对象归为一个类，比如nba球员，都有想到的属性姓名，身高体重，球队号码，方法有跑步，跳跃，运球，投篮。将他们当做一个类，而乔丹，詹姆斯这些就是nba球员的实例，也叫对象；
对象内部高内聚（特定的职能，所有相关的内容都封装在对象内部），对外低耦合（对象的一些可见属性和一些可见方法）
用class 声明一个类，在类里面只能有 成员属性 和 成员方法！！！！不能有其他，在一个脚本中不能有两个同名类,实例化类可以有多个对象
class Computer{
public $text = "用关键字new实例化一个类";
public function output(){
echo $this->text;
}
}
$computer = new Computer();
$computer->output();//外部访问方法
$computer->text();//外部访问属性
$computer2 = new Computer();//可以实例化多个
类的属性和方法
访问控制：
public 公有 都可以访问
private 私有 只有类本身内部可以访问
protected 受保护 继承的子类和类本身内部可以访问，外部访问不了，如: $computer->output();如果output()方法设了protected，则报错。
类里面的方法：
方法里面调用一个属性，需要实例化类才能访问属性，而$this可以理解为是这个类的一个实例
class Computer{
public $text = "用$this调用我";
public function output(){
echo $this->text;
}
}
构造方法（实例化时执行）
构造方法可以传递参数，在实例化时传入
通过构造函数的参数传递，改变里面的属性使得每个实例对象不同
class Computer{
function __construct($arg){
echo "我是构造方法，自动执行";
echo $arg;
}
}
$conputer = new Computer("我是构方法的参数");
析构方法：销毁时执行，不能有参数
程序结束后自动执行，手动释放（当对象的引用全部销毁时）会使析构函数提前执行，不用等到程序结束后才调用
当你 unset 一个引用，只是断开了变量名和变量内容之间的绑定。这并不意味着变量内容被销毁了
//对象引用 在PHP 中引用的意思是：不同的名字访问同一个变量内容.
class A
{
function __destruct()
{
echo '====我是析构函数====';
}
}
$a = new A();
//提前执行析构函数的两个方法 unset($a);$a=null;
echo "====正常执行我是先输出的=====";
//两种对象引种的区别
$a = $b;//这时$a和$b是两个独立的引用，unset($aa)只是删除了$a的引用，还有$b的引用，所以不会执行析构函数。改变其中一个为null,不会影响另外一个变量，也不会执行析构函数；
$c = &$a;//两个的变量使用同个引用，c是a的影子，改变其中一个变量为null，两个都为null,会执行析构函数。但是只是unset($a),$c还在使用引用，只要有引用在不会执行析构函数;
//对象的引用用于访问对象的属性和方法，所以$a $b $c都可以访问对象的属性方法；
//当一个对象的所有引用被删除后，才会触发析构函数
//总结：如果程序大，对象引用尽量使用&，节省内存，清除也方便。设其中一个为Null，其他都为Null；
//变量引用 (默认变量赋值会独立开辟一个内存存放内容)
//PHP 的引用允许你用两个变量来指向同一个内容
$a="AB";
$b =&$a;
echo $a;//这里输出:AB
echo $b;//这里输出:AB
$b="EF";
echo $a;//这里$a的值变为EF 所以输出EF
echo $b;//这里输出EF <?php
$a = 1;
$b = $a;
echo $a;
//在此之前，b都是和a共用内存空间的。
xdebug_debug_zval('b');
$a = 2;//a作出了改变，此时b才会有自己的空间
xdebug_debug_zval('b');
?>
//函数引用
<?php
function test(&$a){
$a=$a+100;
}
$b=1;
echo $b;//输出１ test($b); //这里$b传递给函数的其实是$b的变量内容所处的内存地址，通过在函数里改变$a的值 就可以改变$b的值了 echo "<br>"; echo $b;//输出101
?>//函数的引用返回
<?phpfunction &test(){ static $b=0;//申明一个静态变量 $b=$b+1; echo $b; return $b; }$a=test();//这条语句会输出 $b的值 为１ 相当于$a=$b$a=5; $a=test();//这条语句会输出 $b的值 为2 也是$a=$b$a=&test();//这条语句会输出 $b的值 为3 $a=&$b,所以b会随a变了$a=5; $a=test();//这条语句会输出 $b的值 为6?>
赋值和克隆的区别：
$a=$b（独立引用）和$a=&$b（同一引用）这种赋值方式，指向的是同一个对象，同一块内存空间；
$a=clone $b这种赋值方式，则是指向另一个新的对象，另一个块新的内存空间。
<?phpclass mm {
public $name = 'Peter';
}
$a = new mm();
$b = $a;
$c = &$a;
$d = clone $a;
$b->name = "Anne";
echo $a->name,"\n",$b->name,"\n",$c->name,"\n",$d->name;//输出为：Anne Anne Anne Peter
?>
类常量
内部访问 self::常量名
外部访问不需要实例化：类名::常量名
class Computer{
const yh = 12;
const yh2 = self::yh+1;
}
var_dump (Computer::yh2);
$this 和 self 的区别
一个是对象$this 相当于实例化后，可以说除了静态和const常量，基本上其他都可以使用this联络 ；
self则是类本身 self可以访问本类中的静态属性和静态方法，可以访问父类中的静态属性和静态方法。用self时，可以不用实例化的
类的继承
存在意义：把相同的属性方法抽出来，让子类继承
extends 后只能一个逗号，就是说只能继承一个父类，单继承
class dad{
function eat(){
echo "我是父类的方法，子类可以继承我的方法";
}
}
class boy extends dad{
}
$boy = new boy();$boy->eat();
子类也可以覆盖父类的方法
子类没有构造方法时，会调用父类的构造方法，有则调用自己的，
用关键字 parent:: __construct();可以调用父类的构造方法
用final关键字加在类前面就不会被继承；加到方法面前，此方法就不会被重写
命名空间（解决命名冲突问题)
利用文件系统不用目录的原理
被引入的php文件中加入 namespace 目录\子目录;
使用时调用：new 目录\子目录\类名();如 new com\session\computer();
受命名空间影响的有，类（包括抽象类，traits），接口，函数，常量（const和define都是用来声明常量的（它们的区别不详述），但是在命名空间里，define的作用是全局的，而const则作用于当前空间。）
要注意的是，当前脚本文件的第一个命名空间前面不能有任何代码，下面的写法都是错误的：
//例一
//在脚本前面写了一些逻辑代码
<?php
$path = "/";
class Comment { }
namespace Article;
?>
//例二
//在脚本前面输出了一些字符
<html></html>
<?php
namespace Article;
?>为什么要说第一个命名空间呢？因为同一脚本文件中可以创建多个命名空间。<?php
//创建一个名为'Article'的命名空间namespace Article;
//此Comment属于Article空间的元素class Comment { }
//创建一个名为'MessageBoard'的命名空间namespace MessageBoard;
//此Comment属于MessageBoard空间的元素class Comment { }?>
由于每次调用都要写上路径，很麻烦，所以出现use的用法（use引入必须带类名或者函数名）
在调用时先用use引入，use 目录\子目录\类;还可以起个别名区别 as
use venter\session\computer; use venter\computer as computer2; new computer(); new computer2(); 函数的话记得带上function use function venter\session\computer; computer(); 常量记得带上const use const venter\session\computer; var_dump(computer);
重点：在命名空间里面调用全局的类，函数，常量的区别，
页面a定义了命名空间 namespace venter;引入b页面（全局空间）后，此时想调用b页面的类，必须：
New \venter() 加个\代表全局空间下的
但是调用函数和常量时，就不需要加，因为他会自动寻找，向全局寻找。
类自动加载：
当你实例化一个类时，这个类不存在，就会自动执行我们写的 function __autoload($className){},在这个自动函数的内部去执行我们想要操作的代码，参数就是我们实例化的类名，因此可以根据参数去引入php文件。
__autoload将被淘汰，使用新的函数 spl_autoload_register();参数可以传函数名或者匿名函数
spl_autoload_register(function($a){
echo $a;
}
);
new Computer();
或者
function aaa($a){
echo $a;
}
spl_autoload_register('aaa');
new Computer();
或者类的调用方法
class momo
{
function aaa($a){
echo $a;
}
}
spl_autoload_register([new momo],'aaa');
new Computer();
利用命名空间和自动加载实现项目自动引用
1，文件目录就和命名空间名一样，文件名和类名一样 new models\imooc() 就是在models文件下的imooc.php文件，
2，然后利用spl_autoload_register(function($classname){
include str_replace("\\","/",$classname.".php");
});
这里的作用是models\imooc替换掉models/imooc.php 引入
而imooc.php文件中必须命名 namespace models；
static 静态
存在的价值，为了让对象公用一些数据，做到统一性
当属性和方法被定义为 static 时就变成类的属性和方法，不属于对象的，不需要实例化
外部访问 类名::$aa 内部访问 self::$aa 或者static::$aa; 子类访问父类 parent::$aa;
静态方法不能调用非静态属性
因为 $this代表实例化对象，而这里是类，不知道 $this 代表哪个对象
class person{
public static $aa ="a";
public static function eat(){
echo self::$aa;
echo static::$aa;
}
}
class boy extends person{
public function eat2(){
echo parent::$aa;
}
}
echo(boy::eat2());
后期静态绑定：
class A{
public static function who(){
echo "A类的who方法";
}
public static function test(){
self::who();
// static::who();
}
}
class B extends A{
public static function who(){
echo "B类的who方法";
}
}
B::test();
如果是self::who(); 输出的是A类的who方法，说明调用的是A自身，static::who();会根据上下文作处理，类B调用就使用B里面的who()
魔术方法
__set($var,$val) 设置私有属性，当外部调用设置一个私有属性时会自动执行这个方法，
__get($var)获取私有属性，原理是外部调用一个私有属性时会自动执行这个方法
例子：
class test{
private $abc = "";
private $ccc = "";
public function __set($var,$val){
$this->$var = $val;
}
public function __get($var){
return $this->$var;
}
}
$test = new test();
$test->abc = 'abc';
var_dump($test->abc);
__isset($var)方法，当外部调用isset($test-abc)访问一个不能访问的属性时，就会自动执行 isset()或者empty() 都会触发__isset()方法
__unset($var)，当外部想删除一个私用属性时，会自动执行
以上是属性的重载
__call，__callStatic是属于方法的重载，不是重写
__call($func方法名,$arguments参数)当外部调用一个没有定义的方法时，就会调用
__callStatic($meethod,$arg)当调用一个不存在的静态方法时，会自动执行 注意在function 前也要加入 static 因为是静态方法
__invoke($rag)当实例化一个类后，把这个对象变量当成函数调用时，会自动执行
例如：$test = new test();
$test("go....");
__toString() 当对象被当成string使用时，会执行，比如 echo($test);
__clone方法的一些应用
当一个对象被克隆时，会调用__clone，此时可以在里面执行一些逻辑，比如不想让某些值被克隆，或者初始化一些属性的值
对象拷贝：
浅拷贝：是地址传递（对象是浅拷贝）
深拷贝：复制一份，新开辟一块内存(普通变量是深拷贝)
加clone 使对象成为深拷贝，互不影响；
$a = new A();
$b = clone $a;
__clone()当使用clone时，会自动执行
$a = new A();
$b = clone $a; 在A类中会执行__clone()
例子：
class A{
public $obj = null;
public function __clone(){
$this->obj = clone $this->obj;//开辟了新空间给克隆的对象
}
}
Class B{
public $sex = 0;
}
$a = new A();
$a->obj= new B();
$b = clone $a;
$b->obj->sex = 1;
var_dump($a->obj->sex);
类型约束
class A{
public $obj = null;
public function go(){
echo "googogogogo";
}
}
class B{
public function go(){
echo "bbbbbb";
}
}
Function test(A $a){
$a->go();
}
test(new A());//必须是A的实例
trait 关键字
解决单继承问题 配合use 使用
trait A{
public function a(){
echo "aaaaa";
}
}
trait B{
public function b(){
echo "bbbb";
}
}
Class test{
use A,B;
public function c(){
echo "cccc";
}
}
$test = new test();
$test->a();
$test->b();
$test->c();
接口
可以理解为类的模板 不能直接被实例化
用instanceof 判断某个对象是否实现了某个接口
接口可以继承接口，但是类必须实现接口所有的方法
interface person {
public function eat();
public function sleep();
}
class man implements person{
public function eat(){
echo "chichi吃吃";
}
public function sleep(){
echo "shuishushi";
}
}
$aaa = new man();
$aaa->eat();
//接口继承 两种方法
interface aa {
public function eat();
}
interface bb {
public function sleep();
}
interface person extends aa,bb{
//person就直接继承了两种方法
}
class man implements person{
public function eat(){
echo "chichi";
}
public function sleep(){
echo "shuishuishui";
}
}
//或者 直接实现两种接口
class man implements aa,bb{
public function eat(){
echo "chichi";
}
public function sleep(){
echo "shuishuishui";
}
}
//接口里面可以利用 const 定义一个常量
interface person {
const aa = "bbb";
public function eat();
public function sleep();
}
echo person::aa;
抽象类：
（比如人和动物都会呼吸方法都一样，此时就不需要每个类去实现不同的呼吸方法，吃东西的方法不同，所以在类中各自实现逻辑）抽象类的子类只需要实现抽象方法；
内部有自己的执行方法
abstract class person {
public function holiday(){
echo '我是抽象类自己实现的方法';
}
//抽象方法，以分号结束，无方法体；抽象类中至少要有一个抽象方法
abstract public function eat();
}
class man extends person{
public function eat(){
$this->holiday();//直接调用即可
}
}
$aaa = new man();
$aaa->eat();
单例模式：
让一个类只会被实例化一次，节省内存空间
先把构造函数和克隆函数变成私用属性
class test{
private static $_instance = null;//依靠属性存储实例对象判断是否已经实例过
private function __construct(){
// 私有后将不会被外部实例
}
private function __clone(){
// 私有后将不会被外部克隆
}
public static function getInstance(){
if(!(self::$_instance instanceof self)){
// instanceof判断是否是当前的实例，不是的话就实例化赋值，否则就返回
self::$_instance = new self();
}
return self::$_instance;
}
}
$test1 = test::getInstance();
$test2 = test::getInstance();
$test3 = test::getInstance();
var_dump($test1);
var_dump($test2);
var_dump($test3);
// 输出结果object(test)#1 (0) { } object(test)#1 (0) { } object(test)#1 (0) { }
工厂模式：
就是在多处实例化一个类，当这个类名需要改变时，就会导致大量地方需要更改，使用工厂模式避免这种情况发生
class A{
public function a(){
echo 'aaa';
}
public function c(){
echo 'ccc';
}
public function b(){
echo 'bbb';
}
}
class cashe{
public static function factory(){
return new A();//当业务逻辑变化时，只需要改此处
}
}
$cashe = cashe::factory();
$cashe->a();
面向对象功能汇总
有继承功能，必须有访问的控制，（私有公有属性），static静态关键字来保存一些公用的数据，重写对父类的方法属性重定义，final关键字不允许重写或者继承，访问静态属性的几个方法，接口中的方法是不用具体实现的，在类中才实现，而且必须实现接口中所有的方法，因为有了不同的实现方法逻辑，不同的对象产生不同的表现，这叫多态，存在与接口与类之间的叫抽象类，可以有一部分可以实现，一部分不用实现
/*--------------多态的一个应用实例 模拟USB设备的使用------------------*/
//一个USB的接口
interface USB{
function mount();//装载USB的方法
function work();//USB工作的方法
function unmount();//卸载USB的方法
}
//定义一个USB设备 U盘
class Upan implements USB{//实现USB接口
function mount(){
echo " U盘 装载成功<br/>";
}
function work(){
echo "U盘 开始工作<br/>";
}
function unmount(){
echo "U盘 卸载成功<br/>";
}
}
//定义一个USB设备 USB鼠标
class Umouse implements USB{//实现USB接口
function mount(){
echo " USB键盘 装载成功<br/>";
}
function work(){
echo "USB键盘 开始工作<br/>";
}
function unmount(){
echo "USB键盘 卸载成功<br/>";
}
}
//定义一个电脑类
class Computer{
//使用USB设备的方法
function useUSB ($usb){//$usb参数表示 使用哪种USB设备
$usb->mount();//调用设备的 装载方法
$usb->work();//调用设备的 工作方法
$usb->unmount();//调用设备的卸载方法
}
}
//定义一个电脑的使用者的类
class PcUser{
//
安装
USB的方法
function install(){
//首先拿来一台电脑
$pc=new Computer;
//拿来一些USB设备
$up=new Upan;//拿来一个U盘
$um=new Umouse;//拿来一个USB鼠标
//把USB设备插入电脑, 使用电脑中使用USB设备的方法 来调用 要插入的设备
$pc->useUSB($up);//插入U盘
$pc->useUSB($um);//插入USB鼠标
}
}
//实例化一个电脑用户
$user=new PcUser;
$user->install();//安装设备
/*-------------输出内容--------------
U盘 装载成功
U盘 开始工作
U盘 卸载成功
USB键盘 装载成功
USB键盘 开始工作
USB键盘 卸载成功
-----------------------------------*/
?>
以上就是本篇的全部内容，更多相关教程请访问php编程从入门到精通全套视频教程，php实战视频教程，bootstrap视频教程！
Atas ialah kandungan terperinci PHP什么是面向对象？PHP面向对象小结. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!
Status Semasa PHP: Lihat trend pembangunan webApr 13, 2025 am 12:20 AMPHP tetap penting dalam pembangunan web moden, terutamanya dalam pengurusan kandungan dan platform e-dagang. 1) PHP mempunyai ekosistem yang kaya dan sokongan rangka kerja yang kuat, seperti Laravel dan Symfony. 2) Pengoptimuman prestasi boleh dicapai melalui OPCACHE dan NGINX. 3) Php8.0 memperkenalkan pengkompil JIT untuk meningkatkan prestasi. 4) Aplikasi awan asli dikerahkan melalui Docker dan Kubernet untuk meningkatkan fleksibiliti dan skalabiliti.
PHP vs Bahasa Lain: PerbandinganApr 13, 2025 am 12:19 AMPHP sesuai untuk pembangunan web, terutamanya dalam pembangunan pesat dan memproses kandungan dinamik, tetapi tidak baik pada sains data dan aplikasi peringkat perusahaan. Berbanding dengan Python, PHP mempunyai lebih banyak kelebihan dalam pembangunan web, tetapi tidak sebaik python dalam bidang sains data; Berbanding dengan Java, PHP melakukan lebih buruk dalam aplikasi peringkat perusahaan, tetapi lebih fleksibel dalam pembangunan web; Berbanding dengan JavaScript, PHP lebih ringkas dalam pembangunan back-end, tetapi tidak sebaik JavaScript dalam pembangunan front-end.
PHP vs Python: Ciri dan Fungsi TerasApr 13, 2025 am 12:16 AMPHP dan Python masing -masing mempunyai kelebihan sendiri dan sesuai untuk senario yang berbeza. 1.PHP sesuai untuk pembangunan web dan menyediakan pelayan web terbina dalam dan perpustakaan fungsi yang kaya. 2. Python sesuai untuk sains data dan pembelajaran mesin, dengan sintaks ringkas dan perpustakaan standard yang kuat. Apabila memilih, ia harus diputuskan berdasarkan keperluan projek.
PHP: Bahasa utama untuk pembangunan webApr 13, 2025 am 12:08 AMPHP adalah bahasa skrip yang digunakan secara meluas di sisi pelayan, terutamanya sesuai untuk pembangunan web. 1.PHP boleh membenamkan HTML, memproses permintaan dan respons HTTP, dan menyokong pelbagai pangkalan data. 2.PHP digunakan untuk menjana kandungan web dinamik, data borang proses, pangkalan data akses, dan lain -lain, dengan sokongan komuniti yang kuat dan sumber sumber terbuka. 3. PHP adalah bahasa yang ditafsirkan, dan proses pelaksanaan termasuk analisis leksikal, analisis tatabahasa, penyusunan dan pelaksanaan. 4.Php boleh digabungkan dengan MySQL untuk aplikasi lanjutan seperti sistem pendaftaran pengguna. 5. Apabila debugging php, anda boleh menggunakan fungsi seperti error_reporting () dan var_dump (). 6. Mengoptimumkan kod PHP untuk menggunakan mekanisme caching, mengoptimumkan pertanyaan pangkalan data dan menggunakan fungsi terbina dalam. 7
PHP: asas banyak laman webApr 13, 2025 am 12:07 AMSebab mengapa PHP adalah timbunan teknologi pilihan untuk banyak laman web termasuk kemudahan penggunaannya, sokongan komuniti yang kuat, dan penggunaan yang meluas. 1) Mudah dipelajari dan digunakan, sesuai untuk pemula. 2) Mempunyai komuniti pemaju yang besar dan sumber yang kaya. 3) Digunakan secara meluas dalam platform WordPress, Drupal dan lain -lain. 4) Mengintegrasikan dengan ketat dengan pelayan web untuk memudahkan penggunaan pembangunan.
Di luar gembar -gembur: Menilai peranan PHP hari iniApr 12, 2025 am 12:17 AMPHP kekal sebagai alat yang kuat dan digunakan secara meluas dalam pengaturcaraan moden, terutamanya dalam bidang pembangunan web. 1) PHP mudah digunakan dan diintegrasikan dengan lancar dengan pangkalan data, dan merupakan pilihan pertama bagi banyak pemaju. 2) Ia menyokong penjanaan kandungan dinamik dan pengaturcaraan berorientasikan objek, sesuai untuk membuat dan mengekalkan laman web dengan cepat. 3) Prestasi PHP dapat ditingkatkan dengan caching dan mengoptimumkan pertanyaan pangkalan data, dan komuniti yang luas dan ekosistem yang kaya menjadikannya masih penting dalam timbunan teknologi hari ini.
Apakah rujukan yang lemah dalam PHP dan bilakah mereka berguna?Apr 12, 2025 am 12:13 AMDalam PHP, rujukan lemah dilaksanakan melalui kelas lemah dan tidak akan menghalang pemungut sampah daripada menebus objek. Rujukan lemah sesuai untuk senario seperti sistem caching dan pendengar acara. Harus diingat bahawa ia tidak dapat menjamin kelangsungan hidup objek dan pengumpulan sampah mungkin ditangguhkan.
Terangkan kaedah sihir __invoke dalam PHP.Apr 12, 2025 am 12:07 AMKaedah \ _ \ _ membolehkan objek dipanggil seperti fungsi. 1. Tentukan kaedah \ _ \ _ supaya objek boleh dipanggil. 2. Apabila menggunakan sintaks $ OBJ (...), PHP akan melaksanakan kaedah \ _ \ _ invoke. 3. Sesuai untuk senario seperti pembalakan dan kalkulator, meningkatkan fleksibiliti kod dan kebolehbacaan.
Alat AI Hot
Undresser.AI Undress
Apl berkuasa AI untuk mencipta foto bogel yang realistik
AI Clothes Remover
Alat AI dalam talian untuk mengeluarkan pakaian daripada foto.
Undress AI Tool
Gambar buka pakaian secara percuma
Clothoff.io
Penyingkiran pakaian AI
AI Hentai Generator
Menjana ai hentai secara percuma.
Artikel Panas
Alat panas
mPDF
mPDF ialah perpustakaan PHP yang boleh menjana fail PDF daripada HTML yang dikodkan UTF-8. Pengarang asal, Ian Back, menulis mPDF untuk mengeluarkan fail PDF "dengan cepat" dari tapak webnya dan mengendalikan bahasa yang berbeza. Ia lebih perlahan dan menghasilkan fail yang lebih besar apabila menggunakan fon Unicode daripada skrip asal seperti HTML2FPDF, tetapi menyokong gaya CSS dsb. dan mempunyai banyak peningkatan. Menyokong hampir semua bahasa, termasuk RTL (Arab dan Ibrani) dan CJK (Cina, Jepun dan Korea). Menyokong elemen peringkat blok bersarang (seperti P, DIV),
Versi Mac WebStorm
Alat pembangunan JavaScript yang berguna
VSCode Windows 64-bit Muat Turun
Editor IDE percuma dan berkuasa yang dilancarkan oleh Microsoft
EditPlus versi Cina retak
Saiz kecil, penyerlahan sintaks, tidak menyokong fungsi gesaan kod
MantisBT
Mantis ialah alat pengesan kecacatan berasaskan web yang mudah digunakan yang direka untuk membantu dalam pengesanan kecacatan produk. Ia memerlukan PHP, MySQL dan pelayan web. Lihat perkhidmatan demo dan pengehosan kami.
