PHP：类-属性-访问控制-静态Static-类常量-类的自动加载-构造函数和析构函数

最新推荐文章于 2021-03-20 04:56:11 发布

xiongxiaolin123

最新推荐文章于 2021-03-20 04:56:11 发布

阅读量550

点赞数

分类专栏： PHP

本文链接：https://blog.csdn.net/xiongxiaolin123/article/details/97304951

版权

PHP 专栏收录该内容

39 篇文章 0 订阅

订阅专栏

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <meta http-equiv="X-UA-Compatible" content="ie=edge">
  <title>类-属性-访问控制-静态Static-类常量-类的自动加载-构造函数和析构函数</title>
</head>
<body>
<?php

  date_default_timezone_set("Asia/Shanghai");
  #类-属性-访问控制-静态Static-类常量-类的自动加载-构造函数和析构函数
  
  #NOTE: 如果直接使用 var 声明属性，而没有用 public，protected 或 private 之一，PHP 5 会将其视为 public
  
  #TIPS：方法内访问属性使用：$this->属性名；方法内访问静态属性和方法使用：self::属性名(或静态方法名)

  function demo() {
    class A {
      public $name = 'xxl';
      public static $age = '25';
      
      function echoMessage() {
        echo $this->name;
        echo '<br>';
        echo self::$age;
      }
    }
    (new A())->echoMessage();
  }
  // demo();

  /**
   * 访问控制-属性声明
   * tips: 
   *  1. 关键词 public：被定义为公有的类成员可以在任何地方被访问
   *  2. 关键词 protected：被定义为受保护的类成员则可以被其自身以及其子类和父类访问
   *  3. 关键词 private：被定义为私有的类成员则只能被其定义所在的类访问
   *  4. final关键词：使用final的类不能被继承
   *  5. 继承的子类重新定义的方法覆盖父类方法，覆盖方法的访问控制范围小于父类方法
   */
  function demo2() {

    class MyClass {
      public $public = 'Public';
      protected $protected = 'Protected';
      private $private = 'Private';

      function printHello () {
        echo $this->public;
        echo $this->protected;
        echo $this->private;
      }
    }

    $obj = new MyClass();
    echo $obj->public;
    // echo $obj->protected;   //致命错误Fatal error: Cannot access protected property MyClass::$protected
    // echo $obj->private;   //致命错误Fatal error: Cannot access private property MyClass::$private

    echo '<br><hr>';

    class MyClass2 extends MyClass {
      protected $protected = 'Protected2';

      function printHello () {
        echo $this->public;       //Public
        echo $this->protected;    //Protected2
        echo $this->private;    //未定义
      }
    }

    $obj2 = new MyClass2();
    echo $obj2->public;
    // echo $obj2->protected;    //致命错误
    echo $obj2->private;    //Notice: 未定义private，因为属性是私有的，无法被继承
    $obj2->printHello();
  }
  // demo2();

  /**
   * 访问控制-方法声明
   * tips: 作用和属性声明相同
   */
  function demo3() {

    class MyClass {
      // 声明一个公有的构造函数
      public function __construct () {}
      
      // 声明一个公有的方法
      public function MyPublic () {
        echo '公有的方法<br>';
      }

      // 声明一个受保护的方法
      protected function MyProtected () {
        echo '受保护的方法<br>';
      }

      // 声明一个私有的方法
      private function MyPrivate () {
        echo '私有的方法<br>';
      }

      // 默认为公有方法
      function Foo () {
        $this->MyPublic();
        $this->MyProtected();
        $this->MyPrivate();
      }
    }

    $myclass = new MyClass();
    $myclass->MyPublic();
    // $myclass->MyProtected();    //致命错误Fatal error: Call to protected method MyClass::MyProtected()
    // $myclass->MyPrivate();    //致命错误Fatal error: Call to private method MyClass::MyPrivate()
    $myclass->Foo();

    class MyClass2 extends Myclass {
      function Foo2() {
        $this->MyPublic();
        $this->MyProtected();
        $this->MyPrivate();   //致命错误Fatal error: Call to private method MyClass::MyPrivate()
      }
    }

    $myclass2 = new MyClass2();
    $myclass2->MyPublic();
    $myclass2->Foo2();

    class Bar {
      public function testPublic () {
        echo 'Foo:testPrivate<br>';
      }
    }

  }
  // demo3();

  /**
   * 访问同一个对象类型的私有成员 
   */
  function demo4() {
    class Test {
      private $foo;

      public function __construct ($foo) {
        $this->foo = $foo;
      }

      public function getfoo() {
        echo $this->foo;
        echo '<br>';
      }

      private function bar () {
        echo 'Accessed the private method.';
      }

      public function baz (Test $other) {
        $other->foo = 'hello';
        var_dump($other->foo);
        echo '<br>';
        $other->bar();
      }
    }

    $test = new Test('test');
    $test2 = new Test('other');
    $test->baz($test2);
    echo '<br>';
    $test->getfoo();
    $test2->getfoo();
  }
  // demo4();

  /**
   * 静态属性和方法
   * tips: 
   *  1. 由于静态方法不需要通过对象即可调用，所以伪变量 $this  在静态方法中不可用
   *  2. 声明类属性或方法为静态，就可以不实例化类而直接访问。静态属性不能通过一个类已实例化的对象来访问（但静态方法可以）
   */
  function demo5() {
    
    class Foo {
      public static $my_static = 'foo';

      public function staticValue () {
        return self::$my_static;
      }
    }

    class Bar extends Foo {
      public function fooStatic () {
        return parent::$my_static;
      }
    }

    echo Foo::$my_static.'<br>';

    $foo = new Foo();
    echo $foo->staticValue().'<br>';
    // echo $foo->my_static;     //错误Strict Standards: Accessing static property Foo::$my_static as non static
    echo '<br><hr>';

    echo $foo::$my_static.'<br>';
    $classname = 'Foo';
    echo $classname::$my_static.'<br>';
    echo '<br><hr>';

    echo Bar::$my_static.'<br>';
    $bar = new Bar();
    echo $bar->fooStatic().'<br>';

  }
  // demo5();

  /**
   * 类常量
   */
  function demo6() {
    class MyClass {
      const AB = 'abcdef';

      function showConstant () {
        echo self::AB.'<br>';
      }
    }

    $myclass = new MyClass();
    $myclass->showConstant();

    echo MyClass::AB.'<br>';
  }
  // demo6();

  /**
   * 类的自动加载
   * 魔术函数__autoload
   * tips: 可以使用spl_autoload_register()注册给定的函数作为 __autoload 的实现;或使用spl_autoload
   */
  function demo7() {

    function __autoload($class_name) {
      echo '类名: '.$class_name.'<br>';
      require_once 'test/'.$class_name.'.php';
    }

    $obj1 = new MyClass1();
  }
  // demo7();

  /**
   * 构造函数和析构函数
   */
  function demo8() {
    class  MyDestructableClass  {
      function  __construct () {
          print  "In constructor <br>" ;
           $this -> name  =  "MyDestructableClass" ;
      }

      function echoMes() {
        echo '测试信息<br>';
      }
   
      function  __destruct () {
          print  "Destroying "  .  $this -> name  .  "\n" ;
      }
   }
   
    $obj  = new  MyDestructableClass ();
    $obj->echoMes();
  }
  demo8();


?>
</body>
</html>

xiongxiaolin123

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
PHP：类-属性-访问控制-静态Static-类常量-类的自动加载-构造函数和析构函数

<!DOCTYPE html><html lang="en"><head> <meta charset="UTF-8"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <meta http-equiv="X-UA-Comp...
复制链接

扫一扫