【php】基础学习4

　　这部分主要包括php面向对象的程序设计，具体如下：
 <html xmlns=http://www.w3.org/1999/xhtml>

     <head>

     <meta http-equiv=Content-Type content="text/html;charset=utf-8">

     </head>

     <body>

     <?php

         /*

         * 面向对象程序设计

         */

         /*

         * 类的定义格式：

           class 类名{

             var $temp;//属性

             function 方法名(参数1,参数2...){

                 方法的具体操作

             }

           }

         */

         /*

         * 对象

         * ① 对象的实例化用new关键字：

              $对象名称=new 类型名();

           ② 当类被实例化后，可使用操作符"->"来调用该对象中的成员属性和方法

              $对象名称->属性;

         */

         /*

         * 类成员的访问控制

         * 通过对类的成员添加关键字public、protected、private来实现对类中成员的访问控制。

           如果没有设置这些关键字，php将自动解析为public

           ① public:被public定义的类成员可以再任何地方被访问。

           ② protected:被protected定义的类成员可以再其所在的类的子类和父类中访问。

           ③ private：被private定义的类成员只能在类的内部被访问。

         * 当成员变量使用private关键字修饰时，由于只能在类的内部访问，

           所以只能通过调用成员方法来实现对私有成员变量的访问。

         */

         class blog{

             private $blogName;

             public function setName($blogName){

                 $this->blogName=$blogName;

             }

             public function getName(){

                 return $this->blogName;

             }

         }

         $blog=new blog();

         $blog->setName('Knife');

         echo $blog->getName()."<br/>";

         /*

         * 在类里面定义常量用const关键字，而不是通常的define()函数。

         * const constant="value";

         */

         Class Person{

             const country = "中国"; // 定义常量

             public function myCountry() {

                 echo "我是".self::country."人<br />";//内部访问常量

             }

         }

         echo Person::country."<br />";//中国

         $p1 = new Person();

         $p1 -> myCountry();//我是中国人

         /*

         * 范围解析操作符（::）

         * 可以用于访问静态成员static，类常量constant，还可以用于覆盖类中的属性和方法。

         * ① 当在类定义之外引用到这些项目时，要使用类名。

           ② 自PHP 5.3.0起，可以通过变量来引用类，该变量的值不能是关键字（如 self，parent 和 static）。

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

         */

         //1 在类的外部使用 :: 操作符

         class MyClass {

             const CONST_VALUE = 'A constant value';

         }

         $classname = 'MyClass';

         echo $classname::CONST_VALUE."<br/>"; // 自 PHP 5.3.0 起

         echo MyClass::CONST_VALUE."<br/>";

         //2  在类定义内部使用 ::

         class OtherClass extends MyClass{

             public static $my_static = 'static var';

             public static function doubleColon() {

                 echo parent::CONST_VALUE . "<br/>\n";

                 echo self::$my_static . "<br/>\n";

             }

         }

         $classname = 'OtherClass';

         echo $classname::doubleColon(); // 自 PHP 5.3.0 起

         OtherClass::doubleColon();

         //3 调用父类的方法

         class MyClass1{

             protected function myFunc() {

             echo "MyClass::myFunc()<br/>";

             }

         }

         class OtherClass1 extends MyClass1{

             public function myFunc(){

                 parent::myFunc();// 但还是可以调用父类中被覆盖的方法

                 echo "OtherClass::myFunc()<br/>";

             }

         }

         $class = new OtherClass1();

         $class->myFunc();

         /*

         * 构造方法

         * ① 构造函数可以接受参数，能够在创建对象时将参数赋值给特定的对象字段。

           ② 构造函数可以调用类方法或其他函数。

           ③ 类的构造函数可以调用其他构造函数，包括父类的构造函数

           ④ 也可以调用与实例化对象没有任何关系的类构造函数，只须在__construct前加上类名即可

              className::__construct();

         * 构造方法的命名方式，可统一规定为__construct(注意：是两个下划线)

           如果一个类中没有名称为__construct()的方法时，php5将搜索与类名相同的构造方法

         */

         class human{

             private $name;

             private $work;

             function __construct($name,$work){

                 $this->name=$name;

                 $this->work=$work;

             }

             function introduce(){

                 echo "我叫".$this->name."，我的工作是一名".$this->work."<br/>";

             }

         }

         $man_1=new human('Jim','ITer');

         $man_1->introduce();

         /*

         * 析构方法

         * 析构方法和构造方法的作用是相对的，它在某个对象中的所有引用都被删除或对象被显示销毁时执行，

           析构方法是php5中新添加的内容，之前的版本中没有析构方法

         * 与构造方法的命名规则一样，一个类的析构方法被规定为__destruct(注意：两个下划线)。

           析构方法不能带有任何参数。创建格式如下：

           function __destruct(){

             具体方法内容;

           }

         */

         class human1{

             private $name;

             private $work;

             function __construct($name,$work){

                 $this->name=$name;

                 $this->work=$work;

             }

             function introduce(){

                 echo "我叫".$this->name."，我的工作是一名".$this->work."<br/>";

             }

             function __destruct(){

                 echo "销毁对象".$this->name.'<br/>';

             }

         }

         $man_1=new human1('Knife','ITer');

         $man_1->introduce();

         $man_1=new human1('Fork','Manager');

         $man_1->introduce();    

         /*

         * 静态属性

         * 如果想在同一类的成员方法中访问静态属性，可以通过在改静态属性的名称前加上操作符"self::"来实现

         */

         class sta_num{

             static $num=0;

             function add(){

                 self::$num++;              //直接写$num++报错

                 echo self::$num++."<br/>"; //直接写$num++报错

             }

         }

         $sta=new sta_num();

         $sta->add();

         /*

         * 静态方法

         * 由于静态方法不受任何具体对象的限制，所以不需要建立类实例

         * 它与静态属性的调用方式相同，使用self::来表示调用同一类中的静态方法

         */

         class sta_num2{

             static function show($num){

                 echo "\$num:".$num;

                 echo "<br/>\n";

                 self::add($num);

             }

             static function add($num){

                 echo "\$num+100=".($num+100)."<br/>";

             }

         }

         $num=50;

         sta_num2::show($num);

         /*

         * 对象克隆

         * clone一个对象

         * 通过clone后得到的对象与原对象没有任何关系，它把原来对象的所有信息从内存的位置中复制了一份，

           然后再内存中又开辟一个空间来存储克隆后的对象

         */

         $man_1=new human('Jim','ITer');

         $man_1->introduce();

         $man_2=clone $man_1;

         $man_2->introduce();

         /*

         * _clone方法

         * 可以再对象类中定义一个__clone()(注意：两个下划线)方法来调整对象的克隆行为。

           此方法的代码将在克隆的操作期间来执行。

         * 除了将所有的现有对象成员复制到目标对象之外，还会执行_clone()方法制定的操作。

         */

         class cloneExample{

             public function __clone(){

                 echo "cloneExample对象已被克隆<br/>";

             }

         }

         $ce1=new cloneExample();

         $ce2=$ce1;    //不调用_clone方法，没有任何输出

         $ce3=clone $ce1;//调用_clone()方法

         /*

         * 继承

         * extends

         * 关键字parent::用来表示父类和要调用的父类中的成员方法，语法格式如下：

           parent::父类成员方法(参数1，参数2...)

         * ① 在父类和子类中都定义了构造函数时，子类的对象实例化后将调用子类的构造函数，

              而不会调用父类的构造函数。

         */

         class human3{

             var $name;

             var $height;

             function __construct(){

                 echo "这里是父类的构造方法<br/>";

             }

             function introduce(){

                 echo "我叫".$this->name."&nbsp;&nbsp;我的身高是：".$this->height."<br/>";

             }

         }

         class worker3 extends human3{

             var $company;

             function __construct(){

                 echo "这里是子类的构造方法<br/>";

                 parent::__construct();//如果隐掉这句话，就是注释①的情况

             }

         }

         $man=new worker3();

         /*

         * instanceof关键字

         * php5中instanceof运算符可以检测当前对象是否属于同一类

         */

         class tree{

             function __construct($name){

                 echo $name;

             }

         }

         class dog{

             function __construct($name){

                 echo $name;

             }

         }

         class car{

             function __construct($name){

                 echo $name;

             }

         }

         //检测函数，检测对象是否属于某个类

         class is_class{

             static function check($obj){

                 if($obj instanceof tree){

                     echo "属于tree类<br/>";

                 }else if($obj instanceof dog){

                     echo "属于dog类<br/>";

                 }else{

                     echo "属于其他类<br/>";

                 }

             }

         }

         $obj_1=new tree("松树");

         is_class::check($obj_1);

         $obj_2=new dog("京巴");

         is_class::check($obj_2);

         $obj_3=new car("丰田");

         is_class::check($obj_3);

         /*

         * 多态

         * 多态的重点是父类和接口，而不是他们所衍生出来的子类。

         * 实现多态的方法有两种：

           ① 通过继承实现多态

           ② 通过接口实现多态

         */

         /*

         * 抽象类与接口

         * php中存在一些不能被实例化的特殊类，他们就是抽象类与接口

         * ① 抽象类里至少包含一个由关键字abstract修饰的抽象方法

              抽象类的定义格式语法如下：

              abstract class 抽象类名称{

                 声明数据成员;

                 abstract function 成员方法1(参数1,参数2,...)

                 abstract function 成员方法1(参数1,参数2,...)

                 ...

             }

             当子类要继承方法时，必须包含该类中所有方法，否则在运行时就会出现错误。

         * ② 接口是一组成员方法声明的集合，它只包含一些空的成员方法和常量，

              这些空的成员方法将由实现改接口的类去实现。定义一个几口需要使用interface声明

              定义接口的方式如下：

              interface 接口名称{

                 类常量;

                 function 成员方法1(参数1,参数2,...);

                 function 成员方法2(参数1,参数2,...);

                 ...

              }

            ③ 抽象类与接口的区别：

               1.接口没有数据成员；抽象类有数据成员，且可以实现数据封装；

               2.接口没有构造函数和析构函数；而抽象类可以有

               3.接口中的方法都是public类型的；而抽象类中的方法则可以使用private、protected或public来修饰

               4.接口中不能有实现的方法；而抽象类中可以有自定义的方法

         */

         /*

         * 命名空间

         * ① 定义命名空间可使用关键字namespace

              namespace MyProject;                //file1.php

              const F00=1;

              function foo(){

                 echo "MyProject\function foo()<br/>";

              }

         * ② 注意：命名空间的名称不能使用php关键字，而且namespance语句前不能有任何输出语句。

         * ③ 自定义的命名空间也可以向目录那样出现多级层形式（使用反斜杠"\"进行间隔）

              namespance MyProject\Sub\Level;    //file2.php

              const FOO=1;

              function foo(){

                 echo "MyProject\function foo()<br/>";

              }

         * ④ 同一文件中php还支持定义多个不同的命名空间

              namespance MyProject;

              const FOO=1;

              function foo(){

                 echo "MyProject\function foo()<br/>";

             }

             namespace AnotherProject;

             const FOO=1;

             function foo(){

                 echo "MyProject\function foo()<br/>";

             }

         * ⑤ 定义命名空间后，使用变量、方法或类时，前面要加上空间名称

              include 'file1.php';

              MyProject\foo();

              echo MyProject\FOO;

         * ⑥ 当定义命名空间后，在一个文件中可以出现相同的方法、变量或类，

              主要属于不同的命名空间即可。

              namespace Current;

              include 'file1.php';

              const FOO=2;

              function foo(){

                 echo "MyProject\function foo()<br/>";

              }

              foo();   //调用current命名空间中的foo()函数

              echo FOO;//调用current命名空间中的常量FOO

              \MyProject\foo();

              //开头的反斜线表示'根'全局空间，没有该反斜杠会默认为'Current\MyProject\foo()'

              echo \MyPorject\FOO;

         * ⑥ 除了以上方法，还可以使用use关键字导入命名空间

              include 'file2.php';

              use MyProject\Sub\Level; // 导入命名空间

              Level\foo();

              echo Level\FOO;

         * ⑦ 还可以为命名空间定义一个别名并使用别名作为调用的前缀

              include 'file2.php';

              use MyProject\Sub\Level as ns; // 导入命名空间并定义别名为ns

              ns\foo();

              echo ns\FOO;

         * ⑧ __NAMESPACE__常量（注意：是两对双下划线）

              它总是返回当前命名空间的名称

         * ⑨ namespace关键字

              可以用于明确引用一个当前命名空间或自命名空间中的项目，它等价于类中的self命名空间

              namespace MyProject;

              class foo{

                 public function fun(){

                     echo "namespance test!<br/>";

                 }

              }

              $obj=new namespace\foo;

              echo $obj->fun();

         */

         /*

         * PHP5中的特殊方法

         */

         /*

         * 方法1：__toString()

         * 类内没有声明__toString()方法时，echo类的对象就会报错。

         */

         class product{

             function __toString(){

                 return "this is __toString()方法<br/>";

             }

         }

         $obj=new product();

         echo $obj;

         /*

         * 方法2：__autoload()方法会在第一次引用一个类时调用该方法，

         * 该方法在得到该类的名称后，可以利用这个方法去引入外部的类文件

         * 下面代码运行的前提是，先建一个demo2.php，示例代码如下：

            <?php

                 class demo2{

                     function __construct(){

                         echo "this is demo2's construct!";

                     }

                 }

             ?>

            然后在和demo2.php同级别的目录下新建一个demo1.php，示例代码如下：

         * 注意：使用__autoload()方法时，自动载入的类名应该和该类所在的文件名保持一致，否在会报错。

         */

         function __autoload($class_name){

             include($class_name.".php");

         }

         $obj=new demo2();

         /*

         * 方法3：__get()方法和__set()方法

         * 他们在程序打算获取或设置对象未定义的属性时调用。

         * __set()需要传入两个参数，一个是指定要获取的属性的名称，一个是该属性要设定的值

         */

         class product2{

             var $company="Knife";

             var $array_product=array();

             function __set($key,$value){

                 echo "\$key=$key,\$value=$value<br/>";

                 $this->array_product[$key]=$value;

             }

             function __get($key){

                 echo "\$key=$key,value=".$this->array_product[$key]."<br/>";

             }

         }

         $obj=new product2();

         $obj->company='cannon'; //company存在，所以无输出

         $obj->product_name='fork'; //product_name不存在，调用__set()方法

         $obj->company; //company存在，所以无输出

         $obj->product_name; //product_name不存在，调用_get()方法

         /*

         * 方法4:__call

         * __call方法可以处理类内未定义的方法，让浏览器对用户友好输出

         * __call方法需要传入两个参数，

           第一个参数是方法名称，第二个参数是包含传递给该方法的参数的所有值

         */

         class product3{

             function __call($method,$parameters){

                 echo $method."()方法被调用，该方法所包含信息为：<br/>";

                 print_r($parameters);

             }

         }

         $obj=new product3();

         $obj->undefinedMethod(1,2,3);

     ?>

     </body>

 </html>
巴特西

【php】基础学习4

最新文章

热门文章
