PHP-面向对象_学习笔记

首页免费课 PHP-面向对象笔记

PHP-面向对象

                
                逆雪寒
            全栈工程师

                    查看讲师更多课程 
                    逆雪寒讲师的其他课程
                
Beanstalkd-带你玩转消息队列
中级·8460
免费课程
                                
                难度初级
            
                时长 2小时30分
            
                学习人数
            
综合评分9.50
                            55人评价
                        查看评价
                                9.7
                                内容实用
                            
                                9.7
                                简洁易懂
                            
                                9.1
                                逻辑清晰

最热最新

慕函数7722910 00:01

<?php

use PhpOffice\PhpSpreadsheet\Calculation\Engineering\Compare;

/**
* 访问控制
* public 公有
* private 私有只能在类内部使用
* protected
* 类的属性和方法
* this 类的一个实例
* 类常量
* ----继承----
* 当父类的方法是私有的private的时候，子类是不能调用的，内部是可以访问的
* 当父类的方法是受保护的protected的时候，子类是可以访问的
* 当子类的方法与父类的方法相同的时候，子类覆盖父类方法
* 当子类没有构造方法时，直接调用父类的构造方法
* 当子类和父类都有构造方法时，子类调用其本身的构造方法，当想调用父类的构造方法时使用：parent::construct();
* ---final 关键字---
* final class Dad {} 类加上final 关键字后，类不能被继承
* final function Name(){} 父类的方法加上final关键字后，该方法在子类时不能被重写的
* --- 命名空间---
* namespace venter\session
* namespace test
* ---define----
* define 定义常量是全局的
* --- const 定义常量----
* ---自动加载类 autoload 用的少基本都在使用 spl_autoload_register()----
* ---static 关键字---
* 当属性和方法被定义为static的时候，这个属性和方法就属于类的属性和方法，可以直接调用，不需要实例化
* ----对象复制---
* 在php中对象的拷贝是浅拷贝，改变地址
*
* --- 接口---
* 接口是类的模板，类是对象的模板
* interface Person{
* }
*
**/

class Computer{
//属性
public $cpu=5000;
public $mainboard ='huashuo';
private $ht="512";
const ONE =1;
const TWO= self::ONE+1;
const THREE = self::TWO+1;
//构造方法实例化的时候调用
public function __construct()
{

}
function __autoload($name){
require $name.".php";
}

//方法
public function game($gamename){
if($this->hdSize<1024){
echo '内存太小';
return false;
}
return true;

}
public function job($jobName='write code'){
$this->game("ddd");
}
public function hdSize(){
$this->ht;
}
//析构方法
public function __destruct()
{

}
}

// var_dump(Computer::THREE);
// $computer = new Computer();
// $computer->job();

class Person{
public static $hand ="手";
public static $foot = "脚";

static function getCount(){
return self::$foot;
}
}

echo Person::getCount();

class A{
public static function who(){
echo "A类的方法";

}
public static function test(){
//self::who() ; //父类本身的who方法
static::who(); // static 自动判断，是类A还是类B，后期绑定
}
}
class B extends A{
public static function who(){
echo "B类的方法";
}
}
echo B::test(); // 此时输出 “B类的方法”
class Test{
private $abc="";
public $testi;
public function __set($var,$val){
$this->var=$val;
}
public function __get($var){
return $this->var;
}
//调用的方法不存在时，不会报错两个参数，一个方法名，一个参数名
public function __call($func,$var){
var_dump($var) ;
}
//静态方法未定时，调用不会报错 $test::goes("r","d","4");
public static function __callStatic($name, $arguments)
{
var_dump($arguments);
}
public function __toString(){
return $this->test;
}
}

$test = new Test();
$test->abc ='abcsss';
$test->go("q","d","dd"); //已数组的方式传参数 go方法没有定义，不会报错
$test::goes("r","d","4"); // 该方法未定义直接调用，不会报错，
echo $test; //echo 输出对象不会报错，因为定义了 __toString()魔术方法
var_dump($test->abc);

//接口-----------------------------------------------------------

interface Persons{
public function eat();
public function sleep();
}

class Woman implements Persons{
public function eat(){
echo "eat fruit";
}
public function sleep(){
echo 'sleep early';
}
}
class Man implements Persons{
public function eat(){
echo "eat fruit less";
}
public function sleep(){
echo 'stay up';
}
}
class L {
public static function factory(Persons $user){
return $user;
}
}
$result = L::factory(new Man());
$result->eat();
$result->sleep();

//接口继承--------------------------------------------------------------------------

interface ai{
const abc="hhhh";
public function a();
}
interface bi{
public function b();
}
interface ab extends ai,bi{

}

class Test4 implements ab{
public function a(){
echo "aaaaaaaaa";
}
public function b(){
echo "bbbbbbb";
}
}
$dd = new Test4();
$dd->a();
$dd->b();
echo (ai::abc);

// 抽象类abstract、

abstract class ABC {
public function holiday(){
echo "wait";
}
public function sleep(){

}
public function eat(){

}
}
class ABB extends ABC{
public function sleep(){
echo "Yes";
}
public function eat(){
$this->holiday();
echo "No";
}
}
$aaa = new ABB();
$aaa->eat();
$aaa->sleep();

//------单例模式和工厂模式----------
//单例模式确保类只能有一个实例节省空间
class TestAB{
private static $_instance =null;
private function __construct()
{

}
private function __clone(){

}
public static function getInstance(){
if(!(self::$_instance instanceof self)){
self::$_instance =new self();
}
return self::$_instance;
}
}
$nn = TestAB::getInstance();//实例化两次，但是只开辟一次空间两个变量值相同
$nn2 = TestAB::getInstance();
print_r($nn) ;
print_r($nn2) ;
//------- 工厂模式
//
class Memcache{
public function set(){

}
public function get(){

}
public function delete(){

}
}

class Cache{
public static function factory(){
// 文档中多数运用Memcache类时，假如因为当前需要，改为redis ，需要使用工厂模式
return new Memcache();
}
}
//直接把Memcache 替换为redis 即可，其他代码部分不需要更改
$cache = cache::factory();
$cache->set();

查看全部

0 采集收起来源：接口类和抽象类以及设计模式
2022-07-13
weixin_慕莱坞7062197 03:48

在php中继承的特点是只支持单继承，即一个子类只能继承一个父类，去获得父类中的方法。但从php5.4开始有trait概念，一个类可以通过use关键字引入多个trait的方法，用trait解决了单继承的问题。

查看全部

1 采集收起来源：Trait关键字
2020-09-07
weixin_慕莱坞7062197 10:30

类型约束有int,string,array,float,bool等。但类也可以作为类型约束的类型之一，如图test(A $a)指的是$a必须是类A的对象，否则会报错。

查看全部

0 采集收起来源：对象拷贝和类型约束
2020-09-07
weixin_慕莱坞7062197 07:32

浅拷贝：对象赋值$b=$a，2个对象指向同一块内存地址，值发生改变会互相影响。浅拷贝比较省内存。
深拷贝:用clone关键字，会产生一块新的内存存储对象。clone后相当于有两个值相同的不同的对象。若clone的原对象里有对象属性如$a->obj，由于对象复制默认是浅拷贝，则要用到__clone魔术方法定义对象属性为深拷贝。这样$a->obj->sex才不受$b->obj->sex影响。

查看全部

0 采集收起来源：对象拷贝和类型约束
2020-09-07
weixin_慕莱坞7062197 04:06

self::who()和static::who()的区别在于self指的本类，即父类A，而static会根据代码实际情况判断指的是B类。

查看全部

0 采集收起来源：后期静态绑定
2020-09-06
weixin_慕莱坞7062197 13:54

static关键字
当属性和方法加上static关键字后，属性和方法就是类的，可以直接通过类名进行调用，无需实例化。么当给一个属性加上static关键字，那么这个属性变成了类属性，不需要实例化类（获得对象）就可以直接用类名进行调用。如Person::$foot;方法同理如Person::work();

查看全部

0 采集收起来源：类的自动加载
2020-09-06
weixin_慕莱坞7062197 11:55

命名空间+类名 = 类文件路径.
用spl_autoload_register()替换字符串后自动加载类文件

查看全部

0 采集收起来源：类的自动加载
2020-09-06
weixin_慕莱坞7062197 14:15
命名空间和全局空间
1. 在全局空间中引用命名空间的类，用use关键字引入命名空间的类，as起别名。若引入函数则为use function venter\session\iLikeImooc;引入常量则为use const venter\IMOOC;
2.在命名空间中引用全局空间的类，若为namespace venter,即命名空间为venter,如new Test();类默认为venter\Test();找不到会报错，在类前加反斜杠new \Test();则为找到全局空间的Test类。函数和常量会先在命名空间中找，找不到会去全局找。
查看全部

0 采集收起来源：命名空间
2020-09-06
慕前端4482349 01:36

extends

查看全部

0 采集收起来源：类的继承以及final关键字
2020-07-13

RR__

外部想要对私有属性进行读取和修改。

<?php
class Test
{
    private $abc = '';
    public function setAbc($val)    //修改
    {
         $this->abc = $val;        
     }
     
     public function getAbc()     //读取
     {
          return $this->abc;
      }
}

$test = new Test();
$test = setAbc('hahaha');    //hahaha赋给参数$val
var_dump($test->getAbc());     //打印出：string(6)"hahaha"

若有多个私有属性要被外部访问，上述就不行了，所以有了两个魔术方法：__set 和 __get 。如：

<?php
class Test
{
    private $abc = '';
    private $cba = '';
    public function __set($var,$val)    //修改。 __set(属性名，属性值)
    {
         $this->$var = $val;        
     }
     
     public function __get($var)     //读取。  __get(属性名)
     {
          return $this->$var;
      }
}

$test = new Test();
$test->abc = 'hahaha';    //当给私有属性赋值时，会默认自动地调用__set方法，如果类里没有__set方法，就会报错
var_dump($test->abc);     //打印出：string(6)"hahaha"

魔术方法 __isset 用于检测私有属性是否存在。

<?php
class Test
{
    private $abc = 'abc';
    
    public function __isset($var)
    {
        return isset($this->$var)?true:false;
     }
}
$test = new Test();
var_dump(isset($test->abc));    //打印出：bool(true)

魔术方法__unset 删除

<?php
class Test
{
    private $abc = 'aaa';
    
    public function __unset($var)
    {
        unset($this->$var);
     }
}

$test = new Test();
unset($test->abc);

为避免要调用的方法不存在，用魔术方法 __call 当被调用的方法不存在时，__call 会自动被调用。如：

<?php
class Test
{
    public function __call($func,$arguments)     //__call(方法名，参数）
    {
        echo($func . "<br/>");
        print_r($arguments);
     }
}

$test = new Test();
$test->go(1,'ok');     //结果为：go
                        //       Array( [0] =>1 [1] => ok )

当静态方法不存在时，魔术方法__callStatic 会被自动调用。如：

<?php
class Test
{
    public static function __callStatic($method,$arg)    //要加static关键字   __callStatic(方法名，参数)
    {
        echo($method . "<br/>");
        print_r($arg);
     }
}

Test::go(1,'ok');      //结果为：go
                        //       Array( [0] =>1 [1] => ok )

当对象以函数的方式被调用时，魔术方法__invoke会自动被调用。

<?php
class Test
{
     public function __invoke($arg)
     {
         var_dump($arg);    
      }
}

$test = new Test();
$test('go....');  //这就是对象以函数的方式被调用   结果为：string(6)"go...."

当对象被打印时，魔术方法__toString() 会自动被调用。

<?php
class Test
{
     public function __toString()
     {
         return "hello.....";    
      }
}

$test = new Test();
echo($test);     //结果为：hello......

查看全部

0 采集收起来源：魔术方法

2020-07-06

RR__

<?php
class A {    
     public static function who()   
     {        
         echo "AAA";    
      }    
      public static function test()    
      {        
            static::who();      //之后的结果为BBB，若用self::who()，则结果为AAA    
       }                        //因为子类B调用父类的test方法，又调用who方法，子类父类都有who方法，用static是调用子类的who方法，用self是调用父类(也就是self所在类的)who方法
}

//子类
class B extends A {    
    public static function who()    
    {        
         echo "BBB";    
     }
}
B::test();   //因为这里是B，所以父类A和子类B都有who方法我们也要调用子类B的who方法，

查看全部

0 采集收起来源：后期静态绑定

2020-07-06

RR__

imooc.php：

<?php
class Imooc
{
    public function nice()
    {
        echo "imooc nice";
     }
}

main.php：

<?php
function __autoload($className)    //__autoload()是内置函数，实现类的自动加载
{
     require $className . ".php";    
 }
 $imooc = new Imooc();
 var_dump($imooc);   //结果为：object(Imooc)#1(0){}
 
 
 //__autoload()函数将在以后PHP版本里不再使用，所以用spl_autoload_register()函数
<?php
spl_autoload_register(function($className){
     require $className . ".php";
});
$imooc = new Imooc();
var_dump($imooc);      //结果为：object(Imooc)#1(0){}

//还可以：
 <?php
 function test($className){
      require $className . ".php";
}
spl_autoload_register('test');

$imooc = new Imooc();
var_dump($imooc);      //结果为：object(Imooc)#1(0){}

//若在类里：
<?php
class Momo
{
    function haha($className)
    {
         require $className . ".php";
     }
}
spl_autoload_register([new Momo,'haha']);

$imooc = new Imooc();
var_dump($imooc);     //结果为：object(Imooc)#1(0){}

现文件级别如下:

main.php：

<?php
spl_autoload_register(function($className){
     include str_replace("\\","/",$className .".php");    //将\转换为/, (两个\\因为其中一个\是转义字符）将在网页上显示models/Imooc,为了显示出路径
});

$imooc = new models\Imooc();
var_dump($imooc);     //结果为：object(models/Imooc)#2(0){}

Static关键字：

当给属性加上Static关键字，该属性就是类的属性，而不是对象的，不用实例化这个类，就可以通过类名调用。方法也是可以。如：

<?php
class Person
{
    public static $hand = "手";
    public static $foot = "脚";
    
    public static function work()
    {
         return "单纯的工作";
     }
}

echo(Person::$foot);
echo(Person::work());

<?php
class Person
{
    public $a = 1;
    
    public static function work()
    {
         echo ($this->$a);     //有static关键字时不能这样，会报错。$this代表的是对象，self是代表的是类
         return "单纯的工作";
     }
}

echo(Person::work());    //会报错


<?php
class Person
{
    public static $hand = "手";
    public static $foot = "脚";
    
    public static function work()
    {
         echo(self::$hand);      //因为是类的方法和属性，不是对象的，所以用self
         return "单纯的工作";
     }
}
echo(Person::work());   //结果为：手单纯的工作


//子类
class Imooc extends Person
{
    public function play()
    {
        parent::work();     //parent代表类
     }
}
$imooc = new Imooc();
echo($imooc->play());    //结果为：手单纯的工作

查看全部

0 采集收起来源：类的自动加载

2020-07-06

RR__

两个类的类名相同，会出现错误。所以引入了命名空间。

和文件中的目录一样，同一目录不存在相同命名的文件，而不同目录存在相同命名的文件。命名空间借鉴了这种方法。

php：

<?php
namespace venter;   //用namespace关键字，Imooc类和iLikeImooc()函数和IMOOC常量就在venter命名空间下

class Imooc
{
 }

function iLikeImooc(){
    echo "i Like imooc";
}

//曾经用define()定义一个常量，这个不受命名空间影响，所以用const定义常量
const IMOOC = 'nice';

2.php：

<?php
namespace venter\session;   //用\表示session是venter下一级，

class Imooc
{
 }

main.php：

<?php
include '1.php';
include '2.php';

var_dump(new venter\Imooc());
var_dump(new venter\session\Imooc());  //两个同名类就都可打印了

venter\iLikeImooc();    //两个同名函数就可调用了

echo(venter\IMOOC);    //同名常量都可打印出来了

还可以这样：

main.php：

<?php
include '1.php';
include '2.php';

use venter\session\Imooc;
var_dump(new Imooc());    //就不需要这样一大串var_dump(new venter\session\Imooc()); 
use venter\Imooc as Imooc2;     //另一同名类用as取名为Imooc2
var_dump(new Imooc2()); 

use function venter\iLikeImooc;    //函数，use后需要有function ，能加as命名
iLikeImooc();

use const venter\IMOOC;   //常量，use后要有const
var_dump(IMOOC);

当没有使用namespace来指定当前脚本的命名空间时，则当前脚本存在于全局命名空间。命名空间分两个，一个是有被指定，一个没有指定。

3.php：

<?php
class Test1
{
}

function Text2()
{
}

const TEST3 = 'test3';

index.php：

<?php
namespace index;
include '3.php';

var_dump(new \Text1());    //在此脚本文件有命名空间下，会找此命名空间的类，
                //若是var_dump(new Text1())因为Text1是3.php是全局空间的类，就会报错，找不到类。所以Text1前加\

Test2();  //函数和常量在此命名空间下若没有，会自动在全局空间3.php里找，而类不自动去全局空间找，所以要加\
echo(TEST3);

查看全部

0 采集收起来源：命名空间

2020-07-02

RR__

被继承的类叫父类。子类继承父类的属性和方法。通过子类扩展了父类的功能，是之前所学的扩展性。

<?php
class Dad
{
    public function Kungfu()
    {
        echo "降龙十八掌";
     }
}

class Boy extends Dad     //使用 extends 关键字使子类继承父类
{
 }
 
$boy = new Boy();
$boy->Kungfu();    //结果为：降龙十八掌   （子类继承父类的属性和方法）

当父类的方法是私有的（private），子类不能调用，只有父类本身类的内部能用。

当父类的方法是受保护的（protected），只能被父类自己和继承的子类调用，其他类和外部不能调用。

方法名相同时，子类的方法覆盖父类的方法：

<?php
class Dad
{
    public function Kungfu()
    {
        echo "降龙十八掌";
     }
}

class Boy extends Dad
{
     public function Kungfu()  //方法名相同时，子类的方法覆盖父类的方法：
     {
         echo "凌波微步无影掌";
      }    
 }
 
$boy = new Boy();
$boy->Kungfu();    //结果为：凌波微步无影掌

当子类没有构造方法时，会自动调用父类的构造方法。

当子类有自己的构造方法时，就调用自己的构造方法，而不会调用父类的构造方法。若既想调用父类的构造方法也有子类的，用 parent 关键字。如：

<?php
class Dad
{
    public function __construct()
    {
        echo "dad dad...";
     }
     public function Kungfu()
     {
         echo "降龙十八掌";
      }
}

class Boy extends Dad
{
    public function __construct()
    {
        parent::__construct();   //若既想调用父类的构造方法也有子类的，用 parent 关键字。
        echo "boy boy..";
     }
 }
 
$boy = new Boy();
$boy->Kungfu();    //结果为：dad dad...boy boy...降龙十八掌

父类不想被子类继承，用 final 关键字，如：

final class Dad

父类的某个方法不想被子类继承，用 final 关键字，如：

final public function Kongfu()

查看全部

0 采集收起来源：类的继承以及final关键字

2020-07-02

首页上一页1 2 3 4 5 6 7 下一页尾页

0/150

提交

取消

开始学习

课程须知: 学习该课程需要熟悉PHP语法基础，了解PHP的基本使用

老师告诉你能学到什么？: 1 对象的基本概念 2 什么是面向对象思想 3 面向对象的特性和规则 4 如何使用面向对象

微信扫码，参与3人拼团

热搜

最近搜索清空

PHP-面向对象