面向对象的概念php,php面向对象常用概念

类：对于某类事物的以种抽象，他包含事物的形态、行为

对象：是类的实例化，人类(亚洲人对象) 狗类(金毛)

成员变量：对象的属性特征

成员函数：对象的某种行为

构造函数：主要用来创建对象时，初始化对象，为对象的成员变量赋初始值，意味着在new对象时用到该函数，该函数需要定义在类中

格式：__(两个下划线)construct(参数)

测试代码：

/**

*

*/

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(){}

测试代码：

/**

*

*/

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中的变量和函数

/**

*

*/

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

对父类方法和成员变量的重写测试

测试代码：

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