1024av视频,91极品视频在线观看,精品久久久久久中文字幕2017

導讀網頁的本質就是超級文本標記語言，通過結合使用其他的Web技術（如：腳本語言、公共網關接口、組件等），可以創造出功能強大的網頁。因而，超級文本標記語言是萬維網（Web）編程的基礎，也就是說萬維網是建立...

網頁的本質就是超級文本標記語言，通過結合使用其他的Web技術（如：腳本語言、公共網關接口、組件等），可以創造出功能強大的網頁。因而，超級文本標記語言是萬維網（Web）編程的基礎，也就是說萬維網是建立在超文本基礎之上的。超級文本標記語言之所以稱為超文本標記語言，是因為文本中包含了所謂“超級鏈接”點。

本篇文章給大家帶來的內容是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視頻教程！

以上就是PHP什么是面向對象？PHP面向對象小結的詳細內容，更多請關注php中文網其它相關文章！

網站建設是一個廣義的術語，涵蓋了許多不同的技能和學科中所使用的生產和維護的網站。

溫馨提示：喜歡本站的話，請收藏一下本站！

當前位置:雨林木風下載站 > 網頁設計教程 > 詳細頁面

PHP什么是面向對象？PHP面向對象小結

本類教程下載

系統下載排行