类：对于某类事物的以种抽象，他包含事物的形态、行为
对象：是类的实例化，人类（亚洲人对象） 狗类（金毛）
成员变量：对象的属性特征
成员函数：对象的某种行为
构造函数：主要用来创建对象时，初始化对象，为对象的成员变量赋初始值，意味着在new对象时用到该函数，该函数需要定义在类中
格式：__(两个下划线)construct(参数)
测试代码：
<?php
/**
*
*/
class site
{
var $name;
var $age;
function __construct($parameter1,$parameter2)//构造函数
{
$this->name=$parameter1;
$this->age=$parameter2;
}
function setName($para)
{
$this->name=$para;
}
function printName()
{
echo $this->name;
}
function setAge($para)
{
$this->age=$para;
}
function printAge()
{
echo $this->age;
}
}
$st1=new site("shayan","cycycd");
$st1->printName();
$st1->printAge();
$st2=new site("tom","bob");
$st2->setName("peter");
$st2->printName();
?>
析构函数：和构造函数相反，当对象使用玩之后，会自动执行析构函数把对象销毁
格式：__destruct(){}
测试代码：
<?php
/**
*
*/
class myclass{
function __construct()
{
print "构造函数\n";
echo "此处调用__construct\n";
$this->name="myclass";
}
function __destruct(){
echo "析构函数\n";
echo "此处调用__destruct\n";
print "销毁".$this->name."\n";
}
}
$obj=new myclass;
echo $obj->name."\n";
?>
析构函数在整段代码执行完成后才会调用，
类的定义：
Class classname{定义类的变量和函数}
继承：在php中可以使用extends继承一个列，不能继承多个（使用其他类中的变量和函数，这个类也叫做父类）
A{}
Class B extends A{},A是B的父类，B是A的子类，B可以使用A中的变量和函数
<?php
/**
*
*/
class site
{
var $name;
var $age;
function __construct($parameter1,$parameter2)//构造函数
{
$this->name=$parameter1;
$this->age=$parameter2;
}
function setName($para)
{
$this->name=$para;
}
function printName()
{
echo $this->name;
}
function setAge($para)
{
$this->age=$para;
}
function printAge()
{
echo $this->age;
}
}
class child_site extends site
{
var $grade;
function setGra($para){
$this->grade=$para;
}
function getGar()
{
echo $this->grade;
}
}
$csite=new child_site("父类是site\n","我是子类\n");
$csite->printName();
$csite->printAge();
$csite->setGra("我是子类方法\n");
$csite->getGar();
?>
方法重写：覆盖，也就是说父类中方法不能满足自身的需要，重新去定义方法
访问控制：对定义的类中属性和方法进行访问控制，通过public/protected/private实现
Public：公有的
Protected：
Private：
创建父类和子类
class myclass
{
var $public =‘public‘;//var默认public
protected $protected =‘protected‘;
private $private=‘private‘;
function printh()
{
echo $this->public."\n";
echo $this->protected."\n";
echo $this->private."\n";
}
}
class myclass2 extends myclass
{//可以对public和protected进行重定义，但private不行
protected $protected=‘protected2‘;
function printh()
{
echo $this->public."\n";
echo $this->protected."\n";
echo $this->private."\n";
}
}
测试用子类访问父类protected
报错
测试用子类访问private
报错
测试子类重写父类方法后调用父类属性
无法对private进行重定义，会报错undefined
对父类方法和成员变量的重写测试
测试代码：
<?php
class MyClass
{
// 声明一个公有的构造函数
public function __construct() { }
// 声明一个公有的方法
public function MyPublic() { echo "public‘s function"."\n";}
// 声明一个受保护的方法
protected function MyProtected() { echo "protected‘s function"."\n"; }
// 声明一个私有的方法
private function MyPrivate() {echo "private‘s function"."\n"; }
// 此方法为公有
public function Foo()
{
$this->MyPublic();
$this->MyProtected();
$this->MyPrivate();
}
}
$myclass = new MyClass;
$myclass->MyPublic(); // 这行能被正常执行
//$myclass->MyProtected(); // 这行会产生一个致命错误
//$myclass->MyPrivate(); // 这行会产生一个致命错误
$myclass->Foo(); // 公有，受保护，私有都可以执行
/**
* Define MyClass2
*/
class MyClass2 extends MyClass
{
// 此方法为公有
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";
}
private function testPrivate() {
echo "Bar::testPrivate\n";
}
}
class Foo extends Bar
{
public function testPublic() {
echo "Foo::testPublic\n";
}
private function testPrivate() {
echo "Foo::testPrivate\n";
}
}
$myFoo = new foo();
$myFoo->test(); // Bar::testPrivate
// Foo::testPublic
?>
原文地址：https://www.cnblogs.com/shayanboy/p/11645024.html