객체 지향 PHP란 무엇입니까? PHP 객체지향 요약

이 기사에서는 PHP의 객체지향이 무엇인지 소개합니다. PHP 객체지향 요약. 도움이 필요한 친구들이 참고할 수 있기를 바랍니다.

객체 지향 기능:

* 재사용성(각 모듈은 프로젝트에서 재사용 가능)

* 유연성(각 모듈은 쉽게 교체 및 변경 가능)

* 확장성(모듈 내에서 매우 편리합니다. 새로운 기능 추가)

클래스와 개체의 관계(클래스 생성 개체)

깃털새가 함께 모입니다. 동일한 특성을 가진 개체는 NBA 플레이어와 같이 하나의 클래스로 그룹화되며 모두 다음과 같은 속성을 갖습니다. 이름, 키, 몸무게, 팀 번호 등을 염두에 두고, 방법에는 달리기, 점프, 드리블, 슈팅 등이 포함됩니다. 이들을 클래스로 취급하며 Jordan과 James는 객체라고도 불리는 NBA 선수의 사례입니다.

객체는 높은 내부 응집력(특정 기능, 모든 관련 콘텐츠가 객체 내부에 캡슐화됨)과 외부 낮은 결합(객체 일부)을 갖습니다. 보이는 속성과 일부 보이는 메소드)

클래스를 선언하려면 클래스를 사용하세요. 클래스에는 멤버 속성과 멤버 메소드만 있을 수 있습니다! ! ! ! 하나의 스크립트에 동일한 이름을 가진 두 개의 클래스가 있을 수 없습니다. 인스턴스화된 클래스는 여러 개체를 가질 수 있습니다. 클래스 자체만 내부적으로 접근 가능

protected 보호 상속의 하위 클래스와 클래스 자체는 내부적으로 접근할 수 있지만 다음과 같이 외부에서는 접근할 수 없습니다: $computer->output(); 보호하려면 오류가 보고됩니다.

클래스의 메서드:

메서드에서 속성을 호출하고 속성에 액세스하려면 클래스를 인스턴스화해야 하며 $this는 이 클래스의 인스턴스로 이해될 수 있습니다

class Computer{
    public $text = "用关键字new实例化一个类";
    public function output(){
    echo $this->text;
    }
}
$computer = new Computer();

$computer->output();//外部访问方法
$computer->text();//外部访问属性
$computer2 = new Computer();//可以实例化多个

구성 메서드

( 생성자는 인스턴스화 중에 전달되는 매개변수를 전달할 수 있습니다.

생성자의 매개변수를 전달하고 내부 속성을 변경하여 각 인스턴스 객체를 다르게 만듭니다.

class Computer{    
    public $text = "用$this调用我";   
    public function output(){    
         echo $this->text;
    }
}

소멸자 메서드: 파괴될 때 실행됩니다. 매개변수 없음

프로그램 종료 후 자동으로 실행됩니다. 수동 해제(객체에 대한 모든 참조가 소멸될 때)를 사용하면 프로그램이 끝날 때까지 기다리지 않고 소멸자가 미리 실행됩니다.

참조를 설정 해제하면 변수 이름과 변수 내용 간의 바인딩만 끊어집니다. 이는 변수 내용이 파괴된다는 의미는 아닙니다

class Computer{
   function __construct($arg){
       echo "我是构造方法，自动执行";　　　　
       echo $arg;
   } 
} 
$conputer = new Computer("我是构方法的参数");

할당과 복제의 차이점:

$a=$b(독립 참조) 및 $a=&$b(동일 참조) 이 할당 방법은 It을 가리킵니다. 동일한 객체이고 동일한 메모리 공간입니다.

$a=clone $b의 할당 방법은 또 다른 새로운 객체와 또 다른 새로운 메모리 공간을 가리킵니다.

//对象引用  在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(&#39;b&#39;);
$a = 2;//a作出了改变，此时b才会有自己的空间
xdebug_debug_zval(&#39;b&#39;);
?>


//函数引用
<?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?>

클래스 상수

내부 액세스 self::constant name

외부 액세스에는 인스턴스화가 필요하지 않습니다. 클래스 이름::constant name

<?phpclass mm {

    public $name = &#39;Peter&#39;;

}
$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
?>

$this와 self의 차이점

하나는 객체가 $this는 동일합니다. 인스턴스화 후에는 static 및 const 상수를 제외하고 기본적으로 다른 모든 항목에 연결할 수 있습니다.

self는 클래스 자체이며 이 클래스의 정적 속성 및 메서드에 액세스할 수 있습니다. 상위 클래스의 정적 속성에 액세스합니다. self를 사용할 때 인스턴스화된

클래스를 상속할 필요가 없습니다. 존재 의미는 동일한 속성 메서드를 추출하고 하위 클래스가

extends를 상속하도록 하는 것입니다. 하나의 상위 클래스만 상속될 수 있습니다. , 단일 상속

class Computer{    
    const yh = 12;    
    const yh2 = self::yh+1;
} 
var_dump (Computer::yh2);

하위 클래스는 상위 클래스의 메서드도 재정의할 수 있습니다.

하위 클래스에 생성자가 없으면 상위 클래스의 생성자를 호출합니다. 자체 호출합니다.

parent:: __construct(); 키워드를 사용할 수 있습니다. 상위 클래스의 생성자 메서드를 호출하세요. 클래스 앞에 final 키워드를 추가하면 상속되지 않습니다.

네임스페이스

(네이밍 충돌 문제 해결)

파일 시스템 활용 디렉토리를 사용하지 않는 원칙

가져온 PHP 파일에 네임스페이스 디렉토리 하위 디렉토리를 추가하세요.

사용 시 다음을 호출하세요. 새 디렉토리 하위 디렉토리 클래스 이름(); 예: new comsessioncomputer();

네임스페이스의 영향을 받는 클래스는 클래스(추상 클래스, 특성 포함), 인터페이스, 함수, 상수(const 및 정의는 모두 상수를 선언하는 데 사용됩니다(그 차이점은 그렇지 않음). 상세) 그러나 네임스페이스에서는 정의가 전역 효과를 갖는 반면 const는 현재 공간에 작용합니다. )

현재 스크립트 파일의 첫 번째 네임스페이스 앞에는 코드가 있을 수 없습니다. 메서드가 잘못되었습니다:

class dad{     
     function eat(){         
          echo "我是父类的方法，子类可以继承我的方法";
     }
}
class boy extends dad{
} 
$boy = new boy();$boy->eat();

호출할 때마다 경로를 작성해야 하므로 매우 번거로워서 사용이 나타납니다. 사용법(사용 소개에는 클래스 이름이나 함수 이름이 있어야 합니다)

호출 시 먼저 사용을 사용하여 소개하고, 디렉토리 하위 디렉토리 클래스를 사용하여 별칭을 사용하여

//例一
//在脚本前面写了一些逻辑代码
 

<?php

$path = "/";

class Comment { }

namespace Article;

?>

 

//例二
//在脚本前面输出了一些字符

<html></html>
<?php

namespace Article;

?>为什么要说第一个命名空间呢？因为同一脚本文件中可以创建多个命名空间。<?php
//创建一个名为&#39;Article&#39;的命名空间namespace Article;
//此Comment属于Article空间的元素class Comment { }
//创建一个名为&#39;MessageBoard&#39;的命名空间namespace MessageBoard;
//此Comment属于MessageBoard空间的元素class Comment { }?>

핵심 사항: 네임스페이스에서 전역 클래스 및 함수 호출, 상수 간의 차이점,
페이지 a는 페이지 b(전역 공간)를 도입한 후 네임스페이스 네임스페이스를 정의합니다. , 페이지 b의 클래스를 호출하려면 다음을 수행해야 합니다.
새 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视频教程！

위 내용은 객체 지향 PHP란 무엇입니까? PHP 객체지향 요약의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!