PHP Interface implements use

Mainly for the class name, the methods owned by the class, as well as the parameters of the arguments to do with constraints and specifications to do, it feels like PHP abstract class and a bit similar.

One, the definition and invocation of the interface

2. <?php
4. Interface Face1
6. {
8. const PARAM = ' test ';
10. public function Show ();
12. }
16. Class Test implements Face1
18. {
20. public function Show ()
22. {
24. echo "interface is run<br>";
26. }
28. }
32. $face = new Test ();
34. echo $face->show (); //inerface is run
36. echo Face1::p Aram; //test
38. ?>

Note: The above example should be noted that the method name of the interface is show, inherit the interface class must have show this method, otherwise will be error. That is, the method of the interface is false, the real function is in the inheriting class method, because of this, so I think, interface root PHP abstract class A bit like.

Second, the parameter constraint is relatively strict

2. <?php
4. Interface Face1
6. {
8. public function Show (show $show);
10. }
14. Show Normal
16. Class Test implements Face1
18. {
20. public function Show (show $show)
22. {
24. echo "ASDFASDF";
26. }
28. }
32. Report fatal error
34. Class Test2 implements Face1
36. {
38. public function Show (AAA $aaa)
40. {
42. }
44. }
46. ?>

Explanation: The above example reported fatal error, why will the report fatal error? The reason is that the argument is the AAA $aaa, not the show $show. In the Inherited interface class, when invoking the method of an interface, the parameters to be passed and the parameter names in the interface must be one to. Otherwise you will get an error.

Third, inheritance between interfaces and calling interface pass parameters

2. <?php
4. Interface Face1
6. {
8. public function Show ();
10. }
14. Interface Face2 extends Face1
16. {
18. Public function Show1 (test1 $test,$num);
20. }
24. Class Test implements Face2
26. {
28. public function Show ()
30. {
32. echo "ok<br>";
34. }
38. Public function Show1 (test1 $test,$num)
40. {
42. Var_dump ($test);
44. echo $test 1->aaaa."  $num <br> ";
46. }
48. }
52. Class Test1
54. {
56. public $aaaa ="This is a test";
58. function Fun () {
60. echo ' ===============<br> ';
62. }
64. }
68. $show = new Test1;
70. $show->fun (); //Display ===============
72. Test::show (); //show OK
74. Test::show1 ($show, 6); //object (test1) #1 (1) {["AAAA"]=> string () "This is a test"} 6
76. ?>

Note: The above example can be seen, interface Face2 inherits the interface Face1, class test inherits the interface Face2. I don't know if you found out. Class Test includes two methods, one is show, one show1, and one can not be less, if less one, reported fatal error. The test1 in Show1 (test1 $test, $num) must have the same class test1as the name of the root inheriting classes. If it is not the same, fatal error will also be reported. What if an interface is inherited by more than one class and the class name is different? It's going to be self.

Four, one interface multiple inheritance

2. <?php
4. Interface Comparable {
6. function compare (self $compare);
8. }
12. Class String implements comparable {
14. private $string;
16. function __construct ($string) {
18. $this->string = $string;
20. }
24. function compare (self $compare) {
26. if ($this->string = = $compare->string) {
28. return $this->string." ==". $compare->string.  "<br>";
30. }else{
32. return $this->string."! =". $compare->string.  "<br>";
34. }
36. }
38. }
42. Class Integer implements comparable {
44. private $integer;
46. function __construct ($int) {
48. $this->integer = $int;
50. }
54. function compare (self $compare) {
56. if ($this->integer = = $compare->integer) {
58. return $this->integer." ==". $compare->integer.  "<br>";
60. }else{
62. return $this->integer."! =". $compare->integer.  "<br>";
64. }
66. }
68. }
72. $first _int = new Integer (3);
74. $second _int = new Integer (4);
76. $first _string = new String ("foo");
78. $second _string = new String ("bar");
82. echo $first _int->compare ($second _int); //3!=4
84. echo $first _int->compare ($first _int); //3==3
86. echo $first _string->compare ($second _string); //Foo!=bar
88. echo $first _string->compare ($second _int); //Critical error
90. ?>

Note: As can be seen from the above example, an interface can be inherited by multiple classes, and the class name is different. The same class can be called from one another and cannot be called between different classes. echo $first _string->compare ($second _int); fatal wrong.

PHP interface implements use