php 面向对象中接口 与多态性的用法

php教程 面向对象中接口 与多态性的用法
，接口的方法名是show，继承接口的类中必须有show这个方法，要不然就会报错。也就是说接口的方法是假的，真正起作用的是在继承的类中的方法，就是因为这一点，所以我觉得，接口根php的抽象类有点像。

<?php
interface face1
{
 const param = 'test';
 public function show();
}

class test implements face1
{
 public function show()
 {
 echo "interface is run<br>";
 }
}

$face = new test();
echo $face->show();         //inerface is run
echo face1::param;           //test
?>

接口间的继承和调用接口传递参数

<?php
interface face1
{
 public function show();
}

interface face2 extends face1
{
 public function show1(test1 $test,$num);
}

class test implements face2
{
 public function show()
 {
 echo "ok<br>";
 }

 public function show1(test1 $test,$num)
 {
 var_dump($test);
 echo $test1->aaaa."$num<br>";
 }
}

class test1
{
 public $aaaa="this is a test";
 function fun(){
 echo ' ===============<br>';
 }
}

$show = new test1;
$show->fun();            //显示===============
test::show();             //显示ok
test::show1($show,6);     //object(test1)#1 (1) { ["aaaa"]=>  string(14) "this is a test" } 6
?>

/* 接口技术
 *
 * 接口是一种特殊的抽象类,抽象类又是一种特殊的类
 *
 * 接口和抽象类是一样的作用
 *
 * 因为在PHP是单继承的，如果使用抽象类，子类实现抽象类就不能再去继承其他的类了
 *
 * 如果既想实现一些规范，又想继承其他类。就要使用接口。
 *
 *   接口和抽象类的对比
 *
 *    1.作用相同，都不能创建对象，都需要子类去实现
 *
 *    2.接口的声明和抽象类不一样
 *
 *    3.接口被实现方式不一样
 *
 *    4.接口中的所有方法必须是抽象方法,只能声明抽象方法(不用使用abstract修饰)
 *
 *    5.接口中的成员属性，只能声明常量，不能声明变量
 *
 *    6.接口中的成员访问权限，都必须是public,抽象类中最低的权限protected
 *
 *     声明接口： interface 接口名{ };
 *   
 *    7.使用一个类去实现接口，不是使用extends,而是使用implements关键字
 * 
 *   如果子类是重写父接口中抽象方法，则使用implements(实现),类--接口，抽象类--接口 使用implements，接口--接口 使用extends(继承)
 *
 *     可以使用抽象类去实现接口中的部分方法
 *    如果想让子类可以创建对象，则必须实现接口中的所有方法
 *    可以定义一个接口去继承另一个接口
 *    一个类可以去实现多个接口(按多个规范开发子类),使用逗号分隔多个接口名称
 *    一个类可以在继承一个类的同时，去实现一个或多个接口
 *
 *   使用implements的两个目的：
 *
 *    1.可以实现多个接口，而extends词只能继承一个父类
 * 
 * 2.没有使用extends词，可以去继承一个类，所以两个可以同时使用
 *
 * 多态：多态是面向对象的三大特性之一
 *
 * “多态”是面向对象设计的重要特性，它展现了动态绑定（dynamic binding）的功能，也称为“同名异式”（Polymorphism）。多态的功能可让软件在开发和维护时，达到充分的延伸性（extension）。事实上，多态最直接的定义就是让具有继承关系的不同类对象，可以对相同名称的成员函数调用，产生不同的反应效果。
 *
 *
 *
 *
 *
 */
 //声明接口
 interface Demo{
  
  const HOST="localhost";

  const USER="admin";

  function fun1();//声明方法不用加abstract，默认就是。权限是public
  function fun2();
 }
 
 //接口的继承
 interface Demo2 extends Demo {
  function fun3();
  function fun4();
 }

 interface Demo3{
  function fun5();
  function fun6();
 }

 interface Demo4{
  function fun7();
 }

echo Demo::HOST;//可以访问接口中的常量

class Hello{
 function fun8(){

 }
}

//子类必须实现接口中的所有方法
class UTest extends Hello implements Demo2,Demo3,Demo4 { //实现多个接口
 
 function fun1(){

 }

 function fun2(){

 }

 function fun3(){

 }

 function fun4(){

 }

 function fun5(){

 }

 function fun6(){

 }

 function fun7(){

 }

}

/*-------------------多态---------------*/

interface Test{

 function fun1();

 function fun2();
}

class One implements Test{
 function fun1(){
  echo "aaaaaaaaa";
 }

 function fun2(){
  echo "bbbbbbbbbbbb";
 }
}

class Two implements Test{
 
 function fun1(){
  echo "11111111";
 }

 function fun2(){
  echo "2222222222";
 }
}

//同一个接口，实现同一个方法，不同对象，输出不同。这就是多态的表现与应用

$test=new One;
$test->fun1();//输出一行 a
$test->fun2();//输出一行 b

$test=new Two;
$test->fun1();//输出一行 1
$test->fun2();//输出一行 2

?>

<?php
/*--------------多态的一个应用实例 模拟USB设备的使用------------------*/

//一个USB的接口
interface USB{
 function mount();//装载USB的方法
 function work();//USB工作的方法
 function unmount();//卸载USB的方法
}

//定义一个USB设备 U盘
class Upan implements USB{//实现USB接口
 function mount(){
  echo " U盘 装载成功<br/>";
 }

 function work(){
  echo "U盘 开始工作<br/>";
 }

 function unmount(){
  echo "U盘 卸载成功<br/>";
 }
}

//定义一个USB设备 USB鼠标
class Umouse implements USB{//实现USB接口
 function mount(){
  echo " USB键盘 装载成功<br/>";
 }

 function work(){
  echo "USB键盘 开始工作<br/>";
 }

 function unmount(){
  echo "USB键盘 卸载成功<br/>";
 }
}

//定义一个电脑类
class Computer{
 //使用USB设备的方法
 function useUSB ($usb){//$usb参数表示 使用哪种USB设备
  $usb->mount();//调用设备的 装载方法
  $usb->work();//调用设备的 工作方法
  $usb->unmount();//调用设备的卸载方法
 }
 
}

//定义一个电脑的使用者的类
class PcUser{
 //安装USB的方法
 function install(){
  
  //首先拿来一台电脑
  $pc=new Computer;
 
  //拿来一些USB设备
  $up=new Upan;//拿来一个U盘
  $um=new Umouse;//拿来一个USB鼠标

  //把USB设备插入电脑,  使用电脑中使用USB设备的方法 来调用 要插入的设备
  $pc->useUSB($up);//插入U盘
  $pc->useUSB($um);//插入USB鼠标
 }

}

//实例化一个电脑用户
$user=new PcUser;

$user->install();//安装设备

/*-------------输出内容--------------
U盘 装载成功
U盘 开始工作
U盘 卸载成功
USB键盘 装载成功
USB键盘 开始工作
USB键盘 卸载成功

从上面的例子中可以看出，一个接口可以被多个类继承，并且类名不一样。同一个类之间可以相互调用，不同类之间不能调用。echo $first_string->compare($second_int);报fatal错误的。

 

php教程 递增／递减运算符

只操作变量的一种运算

递增／递减运算符不影响布尔值。递减 NULL 值也没有效果，但是递增 NULL 的结果是 1。

 
例子  　　　 名称  　　 效果
 ++$a  　　前加  　　$a 的值加一，然后返回 $a。
 $a++  　　后加  　　返回 $a，然后将 $a 的值加一。
 --$a  　　 前减  　　 $a 的值减一， 然后返回 $a。
 $a--  　　 后减  　　 返回 $a，然后将 $a 的值减一。

<?php

$a=1;
echo "前加";     //$a 的值加一，然后返回 $a
echo  ++$a;   //显示值  2   

$a=1;
echo "后加";     //返回 $a，然后将 $a 的值加一
echo  $a++;   //显示值   1   

$a=2;
echo "前减";     //$a 的值减一， 然后返回 $a
echo  --$a;   //显示值  1   

$a=2;
echo "前减";     //$返回 $a，然后将 $a 的值减一
echo  $a--;   //显示值  2   
?>

<?php
echo "<h3>Postincrement</h3>";
$a = 5;
echo "Should be 5: " . $a++ . "<br />n";
echo "Should be 6: " . $a . "<br />n";

echo "<h3>Preincrement</h3>";
$a = 5;
echo "Should be 6: " . ++$a . "<br />n";
echo "Should be 6: " . $a . "<br />n";

echo "<h3>Postdecrement</h3>";
$a = 5;
echo "Should be 5: " . $a-- . "<br />n";
echo "Should be 4: " . $a . "<br />n";

echo "<h3>Predecrement</h3>";
$a = 5;
echo "Should be 4: " . --$a . "<br />n";
echo "Should be 4: " . $a . "<br />n";
?>

<?php教程
/*
 * 封装性：面向对象三大特性之一
 *
 * 1.就是把对象的成员(属性,方法)结合成一个独立的相同单位，并尽可能隐藏对象的内部细节
 *   访问权限修饰符  public protected private
 *   private：私有的，用这个关键字修饰的成员，只能在对象内部访问(只有用$this访问)
 * 
 *  属性可以封装:
 *    只要一个变量，需要在多个方法使用，就将这个变量声明为成员属性，可以直接在这个对象中的所有方法中使用
 *
 *    成员属性，相当于这个对象中的全局变量
 *
 *    成员属性都会在方法中使用，成员属性值的变化其实就是在改变方法的执行行为，也就是改变了对象的功能
 *
 *    成员属性的值如果不正常，方法执行的功能叶就不正常
 *    
 *    作用：不需要在对象外部改变或读取它的值
 *     1.封装
 *      再提供一个公有的方法(经过方法对对象成员属性进行赋值和取值就可以控制)
 *
 *
 *  方法也可以封装
 *
 *   作用：
 *    1.使用private修饰使其只能在内部使用
 *
 *    2.一个类中有100个方法，封装了95个(为另外5个服务的方法),只有5个方法可以使用
 *
 *   100个成员属性，都让取值，不可以改值;或者只可改值，不可获取值//此种情况下使用以下方法比较方便
 *   和封装有关的魔术方法：
 *
 *  __set();//是直接设置[私有的]成员属性值时，自动调用的方法
 *  __get();//是直接获取[私有的]成员属性值时，自动调用的方法
 *  __isset();//是直接使用isset()查看对象中私有属性是否存在时，自动调用这个方法
 *  __unset();//是直接使用unset()删除对象中私有属性时，自动调用的方法
 *
 *
 *
 *
 *
 *
 *
 */
class Person{

  //x封装成员属性，不需要在对象外部改变
  private $name;
  private $age;
  private $sex;

  private __unset($proName){
   unset($this->$proName);
  
  }

  //是直接查看对象中私有属性是否存在时，自动调用这个方法
  //__isset($proName)的使用,$proName代表属性名
  private function __isset($proName){
   return isset($this->$proName);//isset()返回是否存在
  }

  function __construct($name,$age,$sex){
   $this->name=$name;
   $this->age=$age;
   $this->sex=$sex;

  }

  
  //当获取私有的成员属性时，自动调用此方法
  private function __get($proName)
  {
   //控制所获取的值
   if($proName=="age"){
    if($this-age>40)
     return $this->age-10;
   }
   return $this->$proName;
  }

  //当设置私有的成员属性时，自动调用此方法
  private function __set($proName,$proValue){
   //$proName表示成员属性名，$proValue表示成员属性值
   //控制设置范围
   if($proName=="age"){
    if($proValue > 100 || $proValue<0)
     return;
   }
   $this->$proName=$proValue;

   
  }

  //提供公有方法来设置成员属性的值
  function setAge($age){
   //控制年龄范围，增加安全性
   if($age > 100 || $age < 0 )
    return;
   $this->age=$age;
  }
  
  //提供公有方法来获取成员属性的值
  function getAge(){
   //控制获取年龄的范围
   if($this->age < 30)
    return $this->age;
   else if($this->age<40)
    return $this->age-5;
   else if($this->age<50)
    return $this->age;
   else
    return $this->age-15;
提供公有方法来  }

  function say(){
   echo "我的名字：{$this->name}，我的年龄：{$this->age}，我的姓别：{$this->sex}<br>";

   //访问封装过的 run()方法
   $this-run();
  }

  private function run(){
   echo '111111111111<br>'

  }

  function eat(){

  }

  //析构方法
  function __destruct(){

  }
 }

$p1=new Person("zhangsan",25,"男");
$p2=new Person;
$p3=new Person;
//$p1->age=-50;//因为年龄在外部随意访问，所以成员属性药封装，才有安全性。
$p1->setAge(30);//通过方法来设置成员属性德值
$p1->getAge();//通过方法来获取成员属性德值

//通过添加家魔术方法__set($proName,$proValue) __get($proName)，就可以直接调用成员属性了

$p1->say();//可以调用
$p1->run();//私有的方法不能直接调用

//删除$p1里面的name
unset($p1->name);

//判断name是否存在
if(isset($p1->name)){

 echo "存在<br>";
}else{
 echo "没有这个成员 <br>";
}

来的成员:
var $name;                  //声明人的姓名
var $sex;                            //声明人的性别
var $age;                            //声明人的年龄
function run(){…….}
改成封装的形式：
private $name;                            //把人的姓名使用private关键字进行封装
private $sex;                                     //把人的性别使用private关键字进行封装
private $age;                                     //把人的年龄使用private关键字进行封装
private function run(){……}             //把人的走路方法使用private关键字进行封装
注意：只要是成员属性前面有其它的关键字就要去掉原有的关键字“var”。
通过private就可以把人的成员（成员属性和成员方法）封装上了。封装上的成员就不能被类外面直接访问了，只有对象内部自己可以访问；下面的代码会产生错误：
class Person
{
//下面是人的成员属性
private $name; //人的名子，被private封装上了
private $sex; //人的性别, 被private封装上了
private $age; //人的年龄, 被private封装上了
//这个人可以说话的方法
function say()
{
echo "我的名子叫：".$this->name." 性别：".$this->sex." 我的年龄是：".$this->age."<br>";
}
//这个人可以走路的方法, 被private封装上了
private function run()
{
echo "这个人在走路";
}
}
//实例化一个人的实例对象
$p1=new Person();
//试图去给私有的属性赋值，结果会发生错误
$p1->name="张三";
$p1->sex="男";
$p1->age=20;
//试图去打印私有的属性，结果会发生错误
echo $p1->name.”<br>”;
echo $p1->sex.”<br>”;
echo $p1->age.”<br>”
//试图去打印私有的成员方法，结果会发生错误
$p1->run();
输出结果为：
Fatal error: Cannot access private property Person::$name
Fatal error: Cannot access private property Person::$sex
Fatal error: Cannot access private property Person::$age
Fatal error: Cannot access private property Person::$name
Fatal error: Call to private method Person::run() from context ''
从上面的实例可以看到，私有的成员是不能被外部访问的，因为私有成员只能在本对象内部自己访问，比如，$p1这个对象自己想把他的私有属性说出去，在say()这个方法里面访问了私有属性，这样是可以。（没有加任何访问控制，默认的是public的，任何地方都可以访问）

 

继承
通常需要这样一些类，这些类与其它现有的类拥有相同变量和函数。实际上，定义一个通用类用于所有的项目，并且不断丰富这个类以适应每个具体项目将是一个不错的练习。为了使这一点变得更加容易，类可以从其它的类中扩展出来。扩展或派生出来的类拥有其基类（这称为“继承”，只不过没人死）的所有变量和函数，并包含所有派生类中定义的部分。类中的元素不可能减少，就是说，不可以注销任何存在的函数或者变量。一个扩充类总是依赖一个单独的基类，也就是说，不支持多继承。使用关键字“extends”来扩展一个类。

<?php教程
class test {

    public function __construct() {
    }

    public function name() {
        $this->xname('John');
    }

    private function showName($name) {
        echo 'my name in test is '.$name;
    }
}

class extendTest extends test {

    public function __construct() {
        parent::__construct();
    }

    private function showName($name) {
        echo 'my name in extendTest is '.$name;
    }
}

$test = new extendTest();
$test->name();
?>

上述示例定义了名为 Named_Cart 的类，该类拥有 Cart 类的所有变量和函数，加上附加的变量 $owner 和一个附加函数 set_owner()。现在，以正常的方式创建了一个有名字的购物车，并且可以设置并取得该购物车的主人。而正常的购物车类的函数依旧可以在有名字的购物车类中使用：

<?php
$ncart = new Named_Cart;    // 新建一个有名字的购物车
$ncart->set_owner("kris");  // 给该购物车命名
print $ncart->owner;        // 输出该购物车主人的名字
$ncart->add_item("10", 1);  // （从购物车类中继承来的功能）
?>
这个也可以叫做“父－子”关系。创建一个类，父类，并使用 extends 来创建一个基于父类的新类：子类。甚至可以使用这个新的子类来创建另外一个基于这个子类的类。

Note:

类只有在定义后才可以使用！如果需要类 Named_Cart 继承类 Cart，必须首先定义 Cart 类。如果需要创建另一个基于 Named_Cart 类的 Yellow_named_cart 类，必须首先定义 Named_Cart 类。简捷的说：类定义的顺序是非常重要的。

 

 

class Person{
 protected $name;//protected保护的权限,在子类可以访问，外部不能访问
 protected $age;
 protected $sex;

 function __construct($name,$age,$sex){
  $this->name=$name;//当使用this时，就算name没有声明，也会再次声明一个
  $this->age=$age;
  $this->sex=$sex;

  echo "###############";
 }

 public function say(){
  echo "我的名字：{$this->name}，我的年龄{$this->age}：，我的性别：{$this->sex}<br/>";
 }

 protected function eat(){

  echo "wwwwwwwwwwwwwwwwwwwww<br>";

 }

 function run(){

 }
 protected $name;//protected保护的权限,在子类可以访问，外部不能访问
 protected $age;
 protected $sex;
}

//继承
class Student extends Person{
 var $school;

 function __construct($name,$age,$sex,$school){
  parent::__construct();//调用父类的构造方法
  $this->school=$school;
 }

 //重载say()方法,进行扩展
 protected function say(){//父类使用public,子类的权限不能低于父类,可以喝父类的权限相同
  //Person::say();//调用父类的say()方法
  parent::say();//调用父类say()方法，parent代表父类名,当父类名变化时也能够调用。

  echo "我所在的学校{$this->school}<br/>";
 }

 function study(){
  echo "{$this->name}在学习<br/>";
 }

}

$s=new Student("zhangsan",23,"男");
$s->say();
$s->study();

 *  1.面向对象的三大特性之一
 *  
 *  2.开放性、可扩充性
 *  
 *  3.增加代码的重用性
 *  
 *  4.提高了软件的可维护性
 *
 *  5.继承就是用子类去“扩展”父类
 *
 *  C++ 属于多继承，同一个类可以有多个父类
 *
 *  PHP和JAVA属于单继承，同一个类只能有一个父类
 *
 *  不管是多继承或者单继承，都可以有多个子类
 * 
 * 只要你在设计两个类时，有可以共享的成员，就将可以共享的内容单独作为一个基类使用
 *
 * 一、类继承的应用
 *  
 *  1.声明一个子类,使用extends关键字去继承(扩展)一个父类
 *
 *  2.子类可以从父类中继承所有的内容，包括成员属性方法，构造方法......，在子类中都可以使用
 *
 * 二、访问类型控制
 *  
 *  虽然子类可以从父类中继承所有内容，但私有的private成员，只能在本类中使用，子类中也不能使用
 *
 *  封装时，既可以让自己类的内部可以访问,也让子类可以用，但类的外部不能使用，只要将权限设置为protected
 *
 *
 *
 * 三、子类中重载父类的方法
 *
 *  1.子类可以声明可以声明和父类相同的方法名，即子类覆盖了父类同名的方法
 *
 *  2.子类的方法对父类方法的扩展
 *
 *  3.在子类中调用父类中被覆盖的方法
 *   使用   父类名::方法名()  parent::方法名()
 *  
 *  4.在子类中编写构造方法，如果父类中也有构造方法，一定要去调用一次父类中被覆盖的构造方法
 *
 * 注意：子类中重载的方法，不能低于父类中访问权限(子类可以放大权限，但不能缩小权限)

基本知识

<?php教程
echo "1 , php.ini中把display_errors=On才显示错误位置<br>";
echo "2 ,习惯使用echo和print打印<br>";
echo "wamp安装完后不能使用是因为安装过iis，是apache无法启动监听，停止iis就可以了";
phpinfo();//每行语句使用分号";"结束

/*
php.ini中把display_errors=On才显示错误位置
习惯使用echo和print打印
*/

/*
多行注释
*/

//单行注释
#单行注释
?>

简单变量和简单数组知识
1 ,htm和php混编
2， 一个语句以 ";" （分号结束）
3，如何定义一个变量，和变量使用

php数据运算类型
四种标量变量
boolean
integer
float，double
string
两种复合类型
array
object

<?php
echo "<br>";
echo "如何定义一个变量，和变量使用<br>";

$a=9;
echo "$a";
echo "<br>";
$b1=true;$b2=FALSE;
$f=1.26;
$s="字符串类型";
echo "int".$a."boolean".$b1."float".$f."string".$s ;

$arr=array(1,2,3,4,5);
$arr2=array("id"=>100,"title"=>"this is new" );
$arr3=array(array(1,2,3,4),array(5,6));
echo "<br>";
echo $arr;
print_r( $arr2);
echo "<br>";
echo $arr3[0][3].$arr3[1][1];
echo $arr2['id'];

?>

stdClass类是PHP的一个内部保留类，初始时没有成员变量也没成员方法，所有的魔术方法都被设置为NULL，可以使用其传递变量参数，但是没有可以调用的方法。stdClass类可以被继承，只是这样做没有什么意义。

该类是PHP的保留类，并不是所有类的基类。

view sourceprint?1 <?php 

2 class foo {} 

3 $bar = new foo(); 

4 echo $bar instanceof stdClass?'yes':'no'; 

5 //output：no

另外一个例子：

view sourceprint?01 <?php 

02 // CTest does not derive from stdClass 

03 class CTest { 

04     public $property1; 

05 } 

06 $t = new CTest; 

07 var_dump($t instanceof stdClass);            // false 

08 var_dump(is_subclass_of($t, 'stdClass'));    // false 

09 echo get_class($t) . "n";                   // 'CTest' 

10 echo get_parent_class($t) . "n";            // false (no parent) 

11 ?>

任何用(object)强制转换都会得到一个stdClass的实例。

参考：