php面向对象笔记

php 对象 笔记

/*

以下是兄弟连面向对象笔记

*/

php要创建对象

1，声明类

class Peo{
  var $name;
  function say(){
   $this->name;
  }
}

2,实例化

$p1=new Peo();

3，调用：

$p1->name;
$p1->say();

魔术方法：(一般有__的都是魔术方法)

class Peo{
  function __construct(){
    //只要类new成功了之后这里的代码不管调不调用都会被执行
    作用是为代码初始化。
  }
}

—————————————–

面向对象的特性：封装、继承、多态。
1，封装：就是不能让外部随意访问和修改对象内部的变量。
不让外部随意访问对象的属性和方法在前面加上私用修饰private

class Peo{
  private function say(){
    //这里代码外部不能访问了。
  }

  function run(){
     $this->say();//只能用内部的$this才能访问
  }

}

*提示以后学习别人代码只需要学习对外提供接口的代码即可，不需要去看那些私有代码

__get和__set取值和赋值
获取私有变量__get，new完成之后自动调用。

  class Peo{
    private $name1;
    private $name2;
    private $name3;

   //一个类中有很多私有属性要一一为它们添加取值和设置的方法代码会很臃肿
   //所以为了优化代码可以使用__get和__set
 
    public function __set($key,$value){
      $this->$key=$value;
    }  
 
    public function __get($key){
      return $this->$key;
    }
 
 }
 
 
 $p1=new Peo();
 $p1->name1='小李';
 $p1->name2='张三';
 $p1->name3='王5';
 
 echo $p1->name1;
 echo $p1->name2;
 echo $p1->name3;

new完之后

__set()设置私有属性，new完成之后自动调用。
__isset() //判断某私有属性是否存在
__unset() //删除私有属性

2，继承
将公共的属性和方法封装成一个父类，其他的类继承父类称为子类。
如果一个子类继承了一个父类就不能在继承其他父类，一个父类可以被多个子类继承。
子类继承父类使用extends

classs Peo{
  var $name;
  function say(){}
}

class Student extends Peo{
  var $schoolmun;
}

为了保证父类的封装性，既要让子类能继承又不让外界访问修改使用protected

classs Peo{
  protected $name;
  function say(){}
}

class Student extends Peo{
  var $schoolmun;
  function getit(){
    $this->name; //外部调用geiti()就能调用到父类的$name
  }
}

子类中的方法和父类同名的情况下，子类要在继承父类部分代码情况下添加修改使用parent::
*子类中的方法和父类同名的情况下，如果父类方法修饰符为protected，子类中的修饰符只能是protected或者public。（子类开放的权限必须等于或大于父类权限。）

private最保守 protected比较保守 public完全开放

*在之类中无论如何都要去调用一次父类的__construct(),因为如果父类属性有变化了也要保证子类也能被同步修改。40，58:00
————————————————————–

面向对象中类常用修饰符
final只能修饰类和方法
final修饰类不能被子元素覆盖；
final修饰方法，子元素的方法不能和父元素中的方法出现重名字。（不能被覆盖）

静态修饰符static 只能修饰属性和方法，被修饰的对象内存中共享。
调用static修饰的属性和方法不需要new
调用例子：

在类外界调用 echo Pen::$name; echo Pen::say();
在类内部中调用 self::$name; self::say();

*非静态方法可以访问静态属性，静态方法不能非静态属性，但静态方法可以访问静态属性。

const类中声明常量
在类外界调用 echo Pen::$name;
在类内部中调用 self::$name;
常用的魔术方法
__construct //只要类new成功了之后这里的代码不管调不调用都会被执行
作用是：为代码初始化。

__call($value1,$value2) //如果使用此魔术，当一个对象不存在某些方法如果被调用了3次，此魔术也会被自动调用3此并保证不报错。
作用是：处理一些不存在的方法时又偏偏被调用出错时起到的回调作用。

__toString() //如果使用此魔术，echo $p1就会自动调用到此魔术。
作用是：快速遍历对象的属性或者方法。
__clone //，$p2=clone $p1了之后一个克隆创建成功就会自动执行此魔术，里面的$this就是指克隆体对象。
作用是：一个克隆创建成功就会自动执行此魔术，可以为克隆体初始化一些属性。

__autoload //此魔术不在类中使用，在一个页面中使用到哪个类此魔术就会自动获取到类的名称。（有一个小问题，文件的取名要跟类名一样）

3,抽象、接口、多态

抽象介绍和作用

定义抽象类和抽象方法需要修饰符abstract，抽象类不能被实例化。
有抽象方法的类，叫抽象类。
抽象方法就是函数没有主体。
abstract class Peo{ //抽象类
abstract function run(); //抽象方法
}
要使用抽象类就必须让子类继承抽象类，那么子类中就不能出现抽象方法将其父类的抽象方法覆盖即可。
class Child extends Peo{
function run(){ return ‘调用’; } //重载覆盖父类的抽象方法
}
把类写成抽象的作用：如果你需要调用某一个功能要继续完成自己工作，但是这个功能还没完成你不可能要等他完成了这功能才去调用吧，所以可以预先把功能先调用出来，
但前提是你自己要写一个抽象方法和一个抽象类，抽象方法的命名要规范好等功能完成了之后在写 一个子类去继承抽象的父类，而且子类的方法要覆盖抽象父类的抽象方法，
这样就可以达到，不必去等待其他人的代码，可以先完成自己的工作了。
$p1=new Child();
$p1->run();

接口介绍和作用（待学习）

接口是一种特殊抽象类，也不能被实例化，只能被子类继承才能被调用。

多态（待学习）

———————–李炎恢笔记——————————-

---------私有-------------
class Peo{
 private $age;
 protected $name;
 public function run(){}
}

修饰符protected既能保护自己不让对外访问，也能让继承的子类继承自己的属性和方法
修饰符private不仅能保护自己，也不让子类继承，保护性是最好的

不加修饰符默认是public

class Peo{
 function __destruct(){
   echo '析构方法是在所用方法执行完成后才执行的。一般用于清理内存。';
 }
}

__get和__set取值和赋值

class Peo{
 private $name1;
 private $name2;
 private $name3;
 private $name4;
 
 //一个类中有很多私有属性要一一为它们添加取值和设置的方法代码会很臃肿
 //所以为了优化代码可以使用__get和__set

 public function__set($key,$value){
   $this->$key=$value;
 }

 public function __get($key){
   return $this->$key;
 }
 
}

$p1=new Peo();
$p1->name1='小李'; //设置值
echo $p1->name1;

常用声明

class Peo{
  const NAME='电脑';
}
 //不需要new直接就可以使用
 echo Peo::NAME;

静态修饰 static

class Peo{
   public static $count=0; //静态属性
 
  public static function run(){
    self::$count++;
  }
 
  public function _add(){
     //如果有static静态修饰符的 属性就用self调用而不是用$this->
     self::$count++;
  }
}

$p1 = new Peo; //实例化1
$p1->_add(); // count=1
$p2 = new Peo; //实例化2
$p2->_add(); //count=2
echo Peo::$count //可以直接输出不需要new

Peo::run(); //可以直接执行方法 不需要new
instanceof 查看某个实例对象是否属于这个类
echo $p1 instanceof Peo //$p1实例是否属于Peo类

—————–继承———————

修饰符protected既能保护自己不让对外访问，也能让继承的子类继承自己的属性和方法
修饰符private不仅能保护自己，也不让子类继承，保护性是最好的
<?php
 class Pa{
   protected $name='车子'; //protected可以不让对外访问，又能让子类继承到 
   protected function run(){
      return $this->name.'在跑';
   }
 }
 
 
 class Son extends Pa{ 
    var $name='男人'; //子类也可以覆盖父类的属性和方法
    function getrun(){
      return $this->run();
    }
 }
 
 $p1=new Son;
 echo $p1->getrun();
 
?>

parent::属性或者方法，子类重新调用被覆盖的父类的属性或者方法

 class Son extends Pa{ 
  var $name='男人'; //子类也可以覆盖父类的属性和方法
   function run(){
    return parent::run();
   }
 }

修饰符final不希望被继承就加上

final class Pa{ //这个类不能被继承
 final public $name; //此属性不能被继承
 final function run(){} //此方法不能被子类覆盖，否则报错
}

class Son extends Pa{
 function run(){} //父类此方法有final不能覆盖，否则报错
}

———-多态—————

1,抽象类和方法 （抽象类是为了给子类做规范）

//抽象类最好至少有一个抽象方法，不然定义一个抽象类就没意义了
abstract class Pa{ //定义了一个抽象类，此类不需要new，是给子类继承的
 public $name='名字'; //可以有普通属性
 abstract function run(); //定义了一个抽象方法不能用{}号，子类必须继承并重写否则会报错。
 
 public function run2(){ echo '我是抽象类中的方法'; } //抽象类中可以添加普通方法
}


class Son extends Pa{ 
 public function run(){ //子类要覆盖父类中的含有abstract修饰符的方法
 
 }
}
$p1=new Son;
echo $p1->name;
echo "<br>";
echo $p1->run2();

2，接口 (为了实现规范子类，以达到统一目的)

interface Pa{ //定义一个接口
 const NAME='必须常量'; //接口里面的所有属性必须是常量
 
 //接口里面的所有方法默认都是抽象方法，也就是要继承的子类必须要覆盖接口里面的方法
 public function run1(); //默认方法都是加了abstract
 public function run2();
}


interface Pa2{ //定义一个接口
 const NAME2='必须常量2'; //接口里面的所有属性必须是常量
 
 //接口里面的所有方法默认都是抽象方法，也就是要继承的子类必须要覆盖接口里面的方法
 public function run3(); //默认方法都是加了abstract
}


class Son implements Pa,Pa2{ //子类继承接口用implements,可以多继承接口
 public function run1(){ //子类必须重新接口方法
 }
 
 public function run2(){ //子类必须重新接口方法
 }
 
 public function run3(){ //子类必须重新接口方法
 }
}