php面向对象精要

Posted 2020-10-25 ghostwu

1、静态属性与方法

每一个类的实例拥有自己的属性和方法，每一个类也可以包含静态属性，静态属性不属于类的任何实例，可以把静态属性理解成存储在类中的全局变量，可以在任何地方通过类名引用静态属性。

 1 <?php
 2 class MyClass {
 3     static $a = 0;    
 4     function getValue(){
 5         return self::$a;
 6     }
 7 }
 8 
 9 $obj = new MyClass();
10 echo $obj->getValue() . PHP_EOL;
11 
12 echo MyClass::$a . PHP_EOL;
13 ?>

 2，静态属性的应用-----把一个唯一的id传递到类的所有实例中

<?php
    class MyClass {
        static $count = 0;
        public $unique_id;
        function __construct(){
            self::$count++;
            $this->unique_id = self::$count;
        }
    }
    
    $obj1 = new MyClass();
    echo $obj1->unique_id . PHP_EOL;
    $obj2 = new MyClass();
    echo $obj2->unique_id . PHP_EOL;
?>

3，静态方法

 1 <?php
 2     class HelloWorld {
 3         static function sayHello(){
 4             print "Hello World";
 5             self::printNewLine();
 6         }
 7 
 8         static function printNewLine(){
 9             echo PHP_EOL;
10         }
11     }    
12     HelloWorld::sayHello();
13     HelloWorld::sayHello();
14 ?>

4，类的常量

>全局常量用 define函数定义

>类的常量与静态成员类似，他们属于类本身，而不是类的实例

>类的常量对大小写敏感

<?php
    class MyColorEnumClass {
        const RED = "red";
        const GREEN = "green";
        const BLUE = "blue";

        static function printColor(){
            print self::RED . PHP_EOL;
            print self::GREEN . PHP_EOL;
            print self::BLUE . PHP_EOL;
        }
    }        
    
    MyColorEnumClass::printColor();
?>

 5，对象克隆

在php5中，对象赋值，其实是引用 ， 如果需要拷贝对象，用克隆关键字clone

<?php
    class MyClass {
        public $var = 1;
    }

    $obj1 = new MyClass();
    //$obj2 = $obj1;
    $obj2 = clone $obj1;
    $obj2->var = 2;
    //使用$obj2 = $obj1, 下面输出2
    //使用$obj2 = clone $obj1, 下面输出1
    echo $obj1->var . PHP_EOL;

?>

6，多态

下面这个实例，如果想要再增加一种动物，那么需要改动2处，需要增加动物类和方法，而且需要在printTheRightSound方法中增加一个elseif分支，这种设计对于代码维护和分离非常不友好

<?php
    class Cat{
        function miao(){
            echo "cat";
        }
    }

    class Dog{
        function wang(){
            echo "dog";
        }
    }

    function printTheRightSound( $obj ){
        if( $obj instanceof Cat ) {
            $obj->miao();
        }else if ( $obj instanceof Dog ) {
            $obj->wang();
        }else {
            echo "传递了错误的对象类型";
        }
        echo PHP_EOL;
    }

    printTheRightSound( new Cat() );
    printTheRightSound( new Dog() );
?>

我们可以用继承的优势，改造上面的缺点

 1 <?php
 2     abstract class Animal {
 3         abstract function makeSound();
 4     }
 5     class Cat extends Animal{
 6         function makeSound(){
 7             echo "cat";
 8         }
 9     }
10     class Dog extends Animal{
11         function makeSound(){
12             echo "dog";
13         }
14     }
15     class Chicken extends Animal {
16         function makeSound(){
17             echo "chicken";
18         }
19     }
20 
21     function printTheRightSound( $obj ){
22         if( $obj instanceof Animal ) {
23             $obj->makeSound();
24         }else {
25             echo "传递了错误的对象类型";
26         }
27         echo PHP_EOL;
28     }
29 
30     printTheRightSound( new Cat() );
31     printTheRightSound( new Dog() );
32     printTheRightSound( new Chicken() );
33 ?>

这样改造之后，printTheRightSound就不需要改动，只需要添加对应的动物类和方法即可