PHP面向对象（oop）的学习笔记

一.特点：

1.封装

public 公共的（类外可以访问）

private 私有的（类内访问）

私有字段内容的调用

class Computer {
  private $_name = '联想';

          //这个时候我采用一个公共对外的方法来访问私有字段
          //因为私有字段只能在类内访问，而对外的公共方法是类内的。
          //更而公共方法又是公共的，所以类外又可访问。
          public function _run() {
               //字段在类内调用的时候必须是类->字段，而$_name只是一个普通变量而已。
               //字段在类外调用的方法是对象->字段，而类内就必须使用Computer->_name
               //但是在本类中，可以用一个关键字来代替Compouter，那就是$this

               echo $this->_name;
          }
     }
     $computer = new Computer();
     $computer->_run();

如何对私有的字段进行赋值和取值

class Computer {
     private $_name;
     //必须写一个对内的入口，对私有字段进行赋值
     public function setName($_name) {
          //这里的$_name只是一个变量而已，参数而已
          //$this->_name才是类的字段
          $this->_name = $_name;
     }


     //必须写个对外的入口，才可以取到
     public function getName() {
          return $this->_name;
     }

}

如果有十个字段那么就必须要二十个方法才能够赋值和取值，那么有没有更简便的方法呢？PHP内置两个方法(拦截器)专门用于取值与赋值：__set()，__get()

class Computer {
//类的字段(成员)
private $_name;
private $_model;
//所有字段的赋值都在这里进行
private function __set($_key ,$_value) {
$this->$_key = $_value;
}
//所有字段的取值都在这里进行
private function __get($_key) {
return $this->$_key;
}
}
$computer = new Computer();
$computer->_model = 'LX';
echo $computer->_model;

有些使用类里面的方法并不需要对外公开，只是里面运作的一部分，这个时候可以将方法也封装起来。所以__set()和__get()方法私有，还是可以执行，是因为目前程序的指针已经在类内了。而类内可以执行封装的方法。类内执行私有方法，不会出现任何错误。它只需要间接的拦截就可以了。拦截是在内类执行的。

静态类成员

静态的方法和成员字段都保存在数据静态区，不是放在堆中

class Computer {
public static $_count = 0;
}
echo Computer::$_count;

静态的方法不用实例化，直接调用

class Computer {

     public static $_count = 0;

     public static function _run() {
          self::$_count++;
     }

}
Computer::_run();
Computer::_run();
Computer::_run();
Computer::_run();
echo Computer::$_count;

Instanceof关键字
PHP5有一个instanceof关键字，使用这个关键字可以确定一个对象是类的实例、类的子类，还是实现了某个特定接口，并进行相应的操作。
class Computer {
//
}
$computer = new Computer();
echo ($computer instanceof Computer);

2.继承：从父类继承到子类的字段或方法

继承自其他类的类成为子类或派生类，子类所继承的类成为父类或基类。(PHP只支持单继承，PHP不支持方法重载)

class Computer {
private $_name = '联想120';
private function __get($_key) {
return $this->$_key;
}
public function run() {
echo '我是父类';
}
}
class NoteBookComputer extends Computer {
}
$notebookcomputer = new NoteBookComputer();
$notebookcomputer->run();
echo $notebookcomputer->_name;

有些时候，并不是特别需要父类的字段和方法，那么可以通过子类的重写来修改父类的字段和方法。

子类调用父类的字段或方法

为了安全，我们一般将父类的方法用受保护的修饰符来封装了起来，这样，外部就无法调用，只能被继承它的子类所看到。这个时候，就需要通过子类操作来调用父类了

class Computer {
     //私有化，但是无法被子类继承，这个时候就应该用受保护的修饰符来封装
      protected $_name = '联想';
      protected function _run() {
           return '联想在运行！';
     }

}
class NoteComputer extends Computer {
     public function getTop() {
          echo $this->_name;
          echo $this->_run();
     }
}

$notecomputer = new NoteComputer();
$notecomputer->getTop();

当子类已经覆盖了父类的字段和方法，但是我们又要调用父类的字段和方法语法：父类名::方法() 或者parent::方法()即可调用

class NoteBookComputer extends Computer {
public function run() {
echo Computer::run(); //
}
}

final关键字

final如果加在类前面，表示这个类不能被继承；如果加在方法前面，表示不能重写此方法

3.多态：

一个相同的方法，不同的人调用这个方法会有不同的行为

用不同的方法去执行调用同一动作

抽象类

抽象类不能被实例化只能被继承（给子类进行继承）

抽象类里的抽象方法，子类必须重写

//创建一个抽象类,只要在class前面加上abstract就是抽象类了
//抽象类不能够被实例化，就是创建对象
//只要类里面有一个抽象方法，那么这个类就必须是抽象类，类前面必须加上abstract
abstract class Computer {
     public $_name = '联想';
     //在抽象类里创建一个抽象方法
     //抽象方法不能够实现方法体的内容
     abstract public function _run();
     //我在抽象类里能否创建一个普通方法
     public function _run2() {
          echo '我是父类的普通方法';
     }
}
//类不能够实现多继承,只支持单继承。
//抽象类是给子类用来继承的，实现一种规范和资源的共享
class NoteComputer extends Computer {
     //抽象类里的抽象方法，子类必须重写，不然会报错。
     //抽象类里的普通方法不需要重写，子类会直接继承下来
     public function _run() {
          echo '我是子类的方法！';
     }
}
$notecomputer = new NoteComputer();
$notecomputer->_run2();
echo $notecomputer->_name;

接口

<?php
//到底应该用抽象类还是接口呢
//如果你要继承多个类的方法规范，那么就用接口好了。
//如果你要共享一个方法体内容，那么就用抽象类。

//创建一个接口
//接口也不能被实例化
//接口是为了规范实现它的子类，以达到统一的目的。也可以共享数据
interface Computer {
     //成员字段必须是常量
     const NAME = '联想';
     //接口里的所有方法都是抽象方法，不能够写方法体
     //并且接口的抽象方法不需要写abstract
     public function _run();
     public function _run2();
}

interface Computer2 {
     public function _run3();
}

//子类继承接口的说话，叫做实现，接口可以多实现
class NoteComputer implements Computer,computer2 {
     public function _run() {
          echo '我重写了run';
     }
     public function _run2() {
          echo '我重写了run2';
     }
     public function _run3() {

     }
}
$notecomputer = new NoteComputer();
$notecomputer->_run();

//接口::常量
//echo Computer::NAME;
?>

多态

<?php
//什么叫做多态，字面意思，多种形态
//一个动作由不同的人去执行，而产生不同的效果或者结果，即为多态。
//一个人通过不同的状态去执行同一种动作，形成不同的结果，也可以称作为多态。

//园丁           剪              修理花草
//理发师         剪               理发
//总裁           剪               裁员

//人            笔记本             运行            win7开机了
//人            台式机              运行            xp开机了

//创建一个接口，来规范运行的方法
interface Computer {
     public function version(); //这个方法表示采用什么电脑
     public function work(); //这台电脑是怎么运行的
}
//创建一个笔记本类来实现接口
class NoteComputer implements Computer {
     public function version() {
          echo '笔记本';
     }
     public function work() {
          echo '可以便携式运行win7';
     }
}
//创建一个台式机的类来实现接口
class DesktopComputer implements Computer {
     public function version() {
          echo '台式机';
     }
     public function work() {
          echo '在工作站运行XP';
     }
}
//创建一个用户
class Person {
     //创建一个方法来接受电脑（笔记本电脑，也可是台式电脑）
     //怎么接受，将他们的对象传进来就OK啦。
     public function _run($type) {
          echo '这个人的';
          $type->version();
          $type->work();
     }
}
//多态的原理，就是类都写好了，不要去修改他，只要在类外的调用参数的更改
//而最后的结果也会得到更改，那么这个就是多态。

//有一个接口，两个类，一个是笔记本的类，一个是台式机的类

//创建了笔记本
$notecomputer = new NoteComputer();
//创建台式机
$desktopcomputer = new DesktopComputer();
//创建一个人
$person = new Person();
//使用电脑
$person->_run($notecomputer); //这种传递，叫做对象引用的传递
?>

二.关键的oop概念

1.类

2.对象

3.字段

4.属性：一种特殊的方法

5.方法

echo var_dump() 打印对象的地址

栈

堆

构造方法（命名必须和类名相同，当实例化的时就可以直接运行构造方法）

php5中可以运用 __construct()创建构造函数

析构方法

public function __destruct() {}

一般情况都是先执行构造方法，在执行其他的方法

用这张图片来解释下上面5个概念

面向对象的工具

PHP引入了__autoload()内置方法来自动包含类文件。 __autoload()应该被写成单个参数的方法。当PHP引擎遇到试图实例化未知类的操作时，会调用__autoload()方法，并将类名当作字符串参数传递给它。
function __autoload($_className) {
require $_className.'.class.php';
}
$demo = new Computer();

PHP采用了__call()内置方法来屏蔽对象调用方法时产生的错误。当对象调用一个不存在的方法时，会自动调用__call()方法。
private function __call($_methodName,$args) {
echo $_methodName.'方法不存在';
print_r($args);
}
$computer->go('我',1,'知道');

PHP使用__toString()内置方法来打印对象的引用。没有使用__toString()的对象是产生一个错误，当打印对象的时候会自动调用__toString()方法。
class Computer {
private function __toString() {
return '打印对象';
}
}
echo new Computer();

PHP可以在类中定义一个__clone()内置方法来调整对象的克隆行为。当一个对象被克隆的时候自动执行__clone()方法，而复制的对象可以在其方法体内进行调整。
class Computer {
public $_name ;
public function __clone() {
$this->_name = 'ibm';
}
}
$computer1 = new Computer();
$computer1->_name = 'dell';
$computer2 = clone $computer1;
echo $computer2->_name;

二，类函数和对象函数

<?php
class Computer {
     public function _run() {}
     private function _go() {}
     public $_name = 'dell';
     private $_model = 'i7';
}

class NoteComputer extends Computer {

}

interface Person {

}

$computer = new Computer();
$notecomputer = new NoteComputer();

//1.检查类是否存在
echo class_exists('Computer');
//2.获取对象的类名
echo get_class($computer);
//3.获取类中公共的方法
print_r(get_class_methods($computer));
//4.获取类中的字段（公有的）
print_r(get_class_vars('Computer'));
//5.获取子类的父类
echo get_parent_class($notecomputer);
//6.判断接口是否存在
echo interface_exists('Person');
//7.判断对象是否是这个类，$notecomputer的类的父类是Computer
echo is_a($notecomputer,'Computer');
//8.判断对象是否是类的子类。
echo is_subclass_of($notecomputer,'Computer');
//9.判断对象是否有这个方法
echo method_exists($computer,'_run');
?>

以上就是我学习php面向对象所做的一下笔记，有不对的地方希望与我交流，谢谢

PHP面向对象（oop）的学习笔记

猜你喜欢