1.1.1. 06.类与对象1


类:类是对象的类型,将现实世界的有统一特征的个体抽象出来的结果。如人类、动物类、商品。 对象:对象是类的实例。有统一特征的抽象结果的实例,单独其中一个个体,如动物类的实例可以是猫,狗。 属性:是对象的一个特征,如猫的毛色,种类。 方法:是对象能够执行的动作。如猫可以走、跑、跳、睡觉。

1.类的定义

类名的定义规则与变量、函数的命名方式相同。以字母或下划线开头,跟任意字母、数字、下划线。最后一堆花括号。

  class demo{
     // 声明属性
    public $var = 'a default value';

    // 声明方法
    public function displayVar() {
        echo $this->var;  // 表示当前对象
    }
  }

  $obj = new demo(); // 实例化对象
  $obj->displayVar(); // 输出 a default value

// -----------------------------------------------------------------------------------------

  class A
  {
      function foo()
      {
          if (isset($this)) {
              echo '$this is defined (';
              echo get_class($this);
              echo ")\n";
          } else {
              echo "\$this is not defined.\n";
          }
      }
  }

  class B
  {
      function bar()
      {
          A::foo();
      }
  }

  $a = new A();
  $a->foo(); // $this is defined (A)

  A::foo();  // $this is not defined.

  $b = new B();
  $b->bar(); //  $this is defined (B)

  B::bar(); // $this is not defined.

2.对象的实例化

通过 new 关键字来实例化一个对象,如果该类有命名空间则需要补全命名空间或者在文件开头用 use 引用。

  use App;
  $obj = new className();

  // 也可以这样做
  $a = 'className';
  $obj = new $a();

对象赋值

  $instance = new SimpleClass();
  $assigned = $instance;
  $reference = &$instance;

  $instance->var = '$assigned will have this value';

  $instance = null; // $instance and $reference become null

  var_dump($instance);  // null
  var_dump($reference); // null
  var_dump($assigned); // object(SimpleClass)#1 (1)

3.类的继承

一个类在声明时使用 extends 关键字来继承另一个类的属性和方法。一个类只能继承一个类,不支持多继承。

<?php
    class ExtendClass extends SimpleClass
    {
        // 重写父类方法
        function displayVar()
        {
            echo "Extending class\n";
            parent::displayVar(); // 调用父类方法
        }
    }

    $extended = new ExtendClass();
    $extended->displayVar();
    // 输出 Extending class
    // a default value
?>

4.::class

自 PHP 5.5 起,关键词 class 也可用于类名的解析。使用 ClassName::class 可以获得类名,如果该类声明了命名空间,则会包括命名空间完整显示。

<?php
    namespace NS {
        class ClassName {
        }

        echo ClassName::class; // NS\ClassName
    }
?>

5.类的属性

类的变量叫类的属性。类的声明由 public 、protected 、 private 开头,然后跟上普通变量名。 在类的成员方法中,可以通过 ->(对象运算符) 来获取,如果是静态方法,则通过 self:: 来获取。

  class demo{
    public $a=1;
    public static $b=2;
    public function foo(){
       echo $this->$a;  // 1
       echo self::$b;  // 2
    }
  }

  $obj = new demo();
  $obj->foo();

6.类常量

在类中始终保持不变的值定义为常量。在定义和使用常量的时候不需要使用 $ 符号

类常量是一个定值。类常量使用 const 定义。访问的时候使用 self:: 访问类常量

接口(interface)中也可以定义常量。更多示例见文档中的接口部分。

  class demo{
    const PI=3.14;
  }

  echo demo::PI; // 3.14

7.类的自动加载

类的自动加载可以不用手动 include 各个类文件。 自动加载不可用于 PHP CLI 模式

  spl_autoload_register(function ($class_name) {
       require_once $class_name . '.php';
  });


  $obj  = new demo1();

8.构造函数和析构函数

构造函数 __construct():当实例化一个对象时,立即执行的函数,非常适合用于初始化对象。

析构函数 __destruct():析构函数在到某个对象的所有引用都被删除或者当对象被显式销毁时执行。

如果子类中定义了构造函数则不会隐式调用其父类的构造函数。要执行父类的构造函数,需要在子类的构造函数中调用parent::__construct()

试图在析构函数(在脚本终止时被调用)中抛出一个异常会导致致命错误。

<?php
      class MyDestructableClass {
         function __construct() {
             print "In constructor\n";
             $this->name = "MyDestructableClass";
         }

         function __destruct() {
             print "Destroying " . $this->name . "\n";
         }
      }

      $obj = new MyDestructableClass();
      // 输出 In constructor
      // Destroying MyDestructableClass


      class P{
        public function __construct(){
          echo "construct";
        }
        public function __destruct(){
          echo "destruct";
        }
      }

      $p = new P();// construct;
      unset($p);//destruct;
?>

9.访问控制(可见性)

对属性和方法的访问控制,可以通过,public(公有),protected(受保护的),private(私有的)三种方式来实现。 public (默认): 任何成员都可以访问。 protected :只能其自身或子类访问。 private : 只能自身访问。

  class A{
    public $name = 'a';
    protected $age = 10;
    private $money = 100;
  }
  class B extends A{
    public function test(){
      echo $this->age;//a
    }
    public function testPrivate(){
      echo $this->money;
    }
  }
  $b = new B();
  echo $b->name;//a
  echo $b->test();//10
  # 不可访问
  echo $b->age;//error;
  #子类不能访问
  echo $b->testPrivate();//error

10.范围解析操作符(::)

范围解析操作符(也可称作 Paamayim Nekudotayim)或者更简单地说是一对冒号,可以用于访问静态成员,类常量。还可以用于覆盖类中的属性和方法。

self,parent 和 static 这三个特殊的关键字是用于在类定义的内部对其属性或方法进行访问的

当一个子类覆盖其父类中的方法时,PHP 不会调用父类中已被覆盖的方法。是否调用父类的方法取决于子类。使用self调用父类,使用$this 调用本类。

class A{
  public $name = 'a';
  protected $age = 10;
  private $money = 100;
}
class B extends A{
  public static $s = 's';
  const PI = 111;
  public function test(){
    echo parent::age;// 10

  }

  public static function testStatic(){
    echo self::$s;
  } 
  public function testConst(){
    echo self::PI;
  }
  public function testPrivate(){
      echo $this->money;
  }
}
# self 和 $this
class ParentClass {
    function test() {
        self::who();    // will output 'parent'
        $this->who();    // will output 'child'
    }

    function who() {
        echo 'parent';
    }
}

class ChildClass extends ParentClass {
    function who() {
        echo 'child';
    }
}

$obj = new ChildClass();
$obj->test();//

11.static 静态关键字

声明类属性或方法为静态,就可以不实例化类而直接访问。静态属性不能通过一个类已实例化的对象来访问(但静态方法可以)

静态属性不可以由对象通过 -> 操作符来访问。静态属性只能被初始化为文字或常量。静态属性不随着对象的销毁而销毁。

class P{
  $a = "world";
  public static function test(){
    echo "hello".self::$a;
  }
}
p::test();
Copyright © Kagami丶 2019 all right reserved,powered by Gitbook该文件修订时间: 2019-10-17 19:28:55

results matching ""

    No results matching ""