PHP OOP面向对象部分方法归总(代码实例子)
//对象名存在栈内存中,数据存在堆内存中
class leyangjun{
var $name; //定义变量
var $age;
var $sex;
function say(){//定义方法
echo '哇咔咔';
}
//调用内部属相 或 方法 都用$this
function runMethods(){
echo '<br>我的名字叫:'.$this->name; //$this->say();
}
}
$man = new leyangjun(); //实例化对象(对象都是互相独立,对象名保存在栈内存中,数据保存在堆内存中)
$man2 = new leyangjun();
$man2->name = 'GG'.'<br>';
$man->name = 'leyangjun'.'<br>';
echo $man->name;
echo $man2->name;
$man->say();
$man->runMethods();
/**
*构造方法与析构方法
*描述:当创建一个对象时,它将自动调用构造函数,也就是使用new这个关键字来实例化的时候自动调用构造方法
*在一个类中只能申明一个构造方法
**/
class NewPerson{
var $name;
var $sex;
var $age;
//定义一个构造方法(这是PHP5中的变化,以前的版本中,构造函数的名称必须与类名相同)
function __construct($name,$sex,$age){
//通过构造方法传来的$name给成员属性$this->name赋初始值
$this->name = $name;
$this->sex = $sex;
$this->age = $age;
}
function say(){
echo "<br>名字:".$this->name.'---性别:'.$this->sex.'---年龄:'.$this->age;
}
/**
*析构函数:在销毁一个类之前执行的一些操作或完成一些功能,如:关闭文件、释放结果集等
*析构函数不能带有任何参数
**/
function __destruct(){
echo "<br>再见".$this->name;
}
}
$NewMan = new NewPerson("菠萝蜜","男",25);
$NewMan->say();
//类的封装
class Encapsulation{
private $name; //认得名字被private封装上了
function __construct($name){
$this->name=$name;
}
public function say(){//前面不写默认是public
echo "<br>名字:".$this->name;
}
public function getName(){
return("<br>获取私有属性:".$this->name);
}
function __destruct(){
echo "<br>林苏:".$this->name;
}
}
$p1 = new Encapsulation("长林军");
$name = $p1->getName();
$p1->say();
echo $name;
/**
*__SET __GET() __isset() __unset()方法
* 一般来说,总是把类的属性定义为private,这更符合现实的逻辑。但是,对属性的读取和赋值操作是非常频繁的,
*因此在PHP5中,预定义了两个函数”__get()”和”__set()”来获取和赋值其属性,以及检查属性的”__isset()”和删除属性的方法”__unset()”。
*/
class Person3{
private $name;
private $sex;
private $addess;
private $myData=3;
//__set()方法来设置私有属性
function __set($property_name,$property_value){
echo "<br><hr>在这直接设置私有属性值的时候,自动调用这个__set()方法为私有属性设置值<br>";
$this->$property_name = $property_value;
}
//__get()方法用来获取私有属性
function __get($property_name){
//echo "在直接获取私有属性值的时候,自动调用了这个__get()方法<br>";
if(isset($this->$property_name)) {
return($this->$property_name);
}else{
return ('没有你要的值!');
}
}
//__isset判断私有成员是否存在
public function __isset($p){
//echo "当在类外部使用isset()函数测定 私有成员 $p时,自动调用<br>";
return isset($this->$p);
}
//__unset 删除私有成员
public function __unset($privateAttribute){
//echo "当在类外部使用unset()函数来删除私有成员时自动调用的<br>";
unset($this->$privateAttribute);
}
}
$p3 = new Person3();
$p3->name='leyangjun';
var_dump($p3->age);
echo '姓名:'.$p3->name.'<br><br>';
if(isset($p3->addess)) {
echo $p3->addess.'<hr/>';
}else{
echo '不存在<hr>';
}
unset($p3->myData);
echo $p3->myData.'<hr>';
//继承
class titalMan{}
class Student extends titalMan{
}
/**
*方法重载
*PHP里面没有方法重载。不能重载也就是在你的项目中不能定义相同方法名的方法
*我们这里所指的重载新的方法所指的是什么呢?其实我们所说的重载新的方法就是子类覆盖父类的已有的方法,
**/
/**
*子类调用父类的方法:一种是使用父类的 "类名::" 来调用父类的方法 className::testFunction();
* 一种是使用 "parent::"的方式来调用父类中的方法 parent::say();
**/
/**
*访问类型
*public(公有的、默认的):公有修饰符,类中的成员将没有访问限制,所有的外部成员都可以访问(读和写)
*private(私有的):私有修改符,被定义为private的成员,对同一类里的所有成员是可见的,没有访问限制;但类的外部是不允许改变和操作,对于该类的子类,也不能访问。
*protected(受保护的):保护成员修饰符,被修饰为protected的成员不能被该类的外部代码访问。但是对于该类的子类有访问权限,可以进行属性、方法的读及写操作,该子类的外部代码包括其的子类都不具有访问其属性和方法的权限。
**/
/**
*final关键字的应用
*这个关键字用来定义类和定义方法,不能使用final定义成员属性,因为final是常亮的意思,在php定义常亮的是define()函数
*使用final关键标记的类不能被继承
**/
final class leyangjunA{}
//class leyangjunB extends leyangjunA{} 不能被继承
//使用final关键标记的方法不能被子类覆盖,是最终版本;
class leyangjunC{
final function say(){}
}
class leyangjunD extends leyangjunC{
//function say(){} 不能重写父类的方法
}
/**
*static 和 const关键字的使用
*static关键字是描述成员属性和成员方法是静态的;
*类的静态变量,非常类似全局变量,能够被所有类的实例共享,类的静态方法也是一样的,类似于全局函数
*
*声明类成员或方法为static,就可以不实例化类而直接访问。不能通过一个对象来访问其中的静态成员(静态方法除外)
*在做项目的时候就是使用类名去访问
*
*const:是一个定义常量的关键字,在php中定义常量使用的是define(),但是在类里面定义常量使用 “const休息成员属性的访问方式”
*和static修饰的成员访问的方式差不多,也是用“类名”,在方法里面使用self关键字。不能使用"$"符号,也不能使用对象来访问。
*/
class StaticPerson{
public static $myCountry='中国';
public static $myStatic='foo';
const constant = '<br>constont value';//定义一个常量
public function staticValue(){
//内部调用静态属性
return '<br>我的'.self::$myStatic;
}
public static function myNeiBu(){
//内部调用静态属性
return '内部静态方法:';
}
public static function say(){
echo self::myNeiBu();
echo '我是中国人';
}
public function showConstant(){
echo self::constant; //使用self::访问常量
}
}
$foo = new StaticPerson();
$foo->showConstant();
//echo $foo::constant; 是不允许的
echo $foo->staticValue().'<br>';
echo StaticPerson::$myCountry; //输出静态属性
StaticPerson::say(); //类名访问静态方法
StaticPerson::$myCountry="<br>美国";
echo StaticPerson::$myCountry.'<hr>';
/**
*__toString()
*在直接输出对象引用时自动调用执行的方法。
*
*/
class TestClass{
public $foo;
public function __construct($foo){
$this->foo = $foo;
}
public function __toString(){
return '__toString方法:'.$this->foo;
}
}
$class = new TestClass('hello world!');
//直接输出$class是会报错的,如果里面加了__toString()方法,直接输出对象的时候,就不会产生错误,而直接调用__toSring()方法(一定要有个return语句)
echo $class.'<hr>';
/**
*克隆对象 --clone 或 __clone
*根据一个对象完全克隆一个一模一样的对象,互不干挠
*/
class PersonOne{
//成员属性
var $name;
var $sex;
var $age;
function __construct($name="",$sex="",$age=""){
$this->name=$name;
$this->sex=$sex;
$this->age=$age;
}
function say(){
echo "我的名字:".$this->name.'性别:'.$this->sex.'年龄:'.$this->age.'<br>';
}
}
$pOne = new PersonOne('leyangjun','男','25');
//使用clone 克隆新对象$pTwo,和$pOne对象具有相同的属性和方法
$pTwo = clone $pOne;
$pOne->say();
$pTwo->say();
class PersonThree{
//成员属性
var $name;
var $sex;
var $age;
function __construct($name="",$sex="",$age=""){
$this->name=$name;
$this->sex=$sex;
$this->age=$age;
}
function say(){
echo "我的名字:".$this->name.'性别:'.$this->sex.'年龄:'.$this->age.'<br>';
}
//对象克隆是自动调用的方法,如果想在克隆后改变对象内容,需要在__clone中重写原本的属性和方法
function __clone(){
//$this指的复本
$this->name = '我是假的'.$this->name;
$this->age = 30;
}
}
$Three1 = new PersonThree('乐杨俊','男',28);
$Three2 = clone $Three1;
$Three1->say();
$Three2->say();
/**
*__call 处理调用报错
*调用内部方法不存在程序就报错停止,使用__call可以提示调用的方法及使用参数不存在,但程序继续执行。
*/
class ErrorClass{
function __call($functionName,$args){
echo "<hr>你所调用的函数:$functionName 参数:";
print_r($args);
echo '不存在<br>';
}
}
$ErrorClass = new ErrorClass();
$ErrorClass->demoTest("one","two","three");
echo '程序调用不出安在的不会退出可以执行到这里<hr>';
/**
*抽象类和抽象方法
*抽象方法:没有定义方法实体,在方法申明的时候没有大括号以及其中的内容,直接加分号结束,前面加一个关键字“abstract” --->abstract function fun1();
*抽象类:里面可以有不是抽象方法和成员属性,但是要有一个抽象的方法,这个类就必须申明为抽象类 使用“abstract”来修饰 --->abstract calss Demo{}
*/
abstract class chouxiang{
abstract function talk();
abstract function talk2();
public function talk3(){
echo '父类非抽象方法talk3<br>';
}
}
//$CX = new chouxiang(); //抽象类不能实例化,只能继承(子类必须把父类中的抽象方法全部都实现)
class TestCx extends chouxiang{
//子类必须把父类中的抽象方法全部都实现
function talk(){
echo '重写父类talk方法<br>';
}
function talk2(){
echo '重写父类talk2方法<br>';
}
}
$TestCx = new TestCx();//子类实现了父类的抽象方法,所以可以实例化
$TestCx->talk();
$TestCx->talk3();
/**
*php接口技术(关键字:interface)
*描述:php语言与大多数编程语言一样不支持多重继承,也就是每个类只能继承一个父类
*解析:接口是一种特殊的抽象类,抽象类又是一种特殊的类,所以接口是一种特殊的类。(接口里面所有的方法必须都是申明为抽象方法,另外接口
* 里面不能申明变量,而且接口里面所有的成员都是public权限的。所以子类实现的时候也一定要使用public权限。)
**/
//定义一个接口One
interface One{
//定义一个常量(接口里面不能定义变量成员)
const constant = 'constant value';
//定义一个抽象方法fun1 --- 接口里面的所有方法都要是public(默认的)
public function fun1();
public function fun2();
}
//注:因为接口是一种特殊的抽象类,里面所有的方法都是抽象方法,所以接口也不能产生实例对象,它也做为一种规范,所有抽象方法需要子类去实现
//使用 extends 关键字让一个接口继承另一个接口
interface Two extends One{
function fun3();
function fun4();
}
//注:定义一个接口的子类去实现接口中的全部抽象方法使用关键字“implements”而不是extends
class JK implements One{
public function fun1(){
echo '<hr>接口方法fun1';
}
public function fun2(){
echo '<br>接口方法fun2<br>';
}
}
$jk = new JK();
$jk->fun1();
$jk->fun2();
/**
*注:前面说过,PHP是单继承,一个类只有一个父类,但是一个类可以实现多个接口,遵循多个规范。
*class JK2 implements 接口一,接口二,......{
//必须把所有接口中的方法都要实现才可以实例化对象。
}
PHP中不仅可以实现多个接口,也可以继承一个类的同时实现多个接口,一定要先继承类再去实现接口;
class JK3 extends 类名一 implements 接口一,接口二,.......{
//所有接口中的方法都要实现才可以实例化对象
//........
}
**/
/**
*多态应用
*解析:所谓多态是指一段程序能后处理多种类型对象的能力,比如:公司不同员工不同职位发放工资,多以同一个发放工资的方法就出现了多种形态。
*对程序来说,多态就是把子类对象赋值给父类引用,能后调用父类的方法,去执行子类覆盖父类的那个方法,但在php里是弱类型的,对象引用都是一样的不分类引用,还是子类引用。
**/
//定义一个形状的接口,里面有两个抽象方法让子类去实现
interface Shape{
function area();
function perimeter();
}
//定义了一个矩形子类实现了形状接口中的周长和面积
class Rect implements Shape{
private $width;
private $height;
function __construct($width,$height){
$this->width = $width;
$this->height = $height;
}
function area(){
return '矩形面积是:'.($this->width*$this->height);
}
function perimeter(){
return '矩形周长是:'.(2*($this->width+$this->height));
}
}
//定义一个圆形子类实现了形状接口中的周长和面积
class Circular implements Shape{
private $radius;
function __construct($radius){
$this->radius = $radius;
}
function area(){
return '圆形面积是:'.(3.14*$this->radius*$this->radius);
}
function perimeter(){
return '圆形面积是:'.(2*3.14*$this->radius);
}
}
//把子类矩形对象赋给形状的一个引用
ECHO '<hr>';
$shape = new Rect(5,10);
echo $shape->area().'<br>';
echo $shape->perimeter().'<br>';
//把子类圆形对象赋给形状的一个引用
$shape = new Circular(10);
echo $shape->area().'<br>';
echo $shape->perimeter().'<br>';
//通过上例我们看到,把 矩形对象 和 圆形对象 分别赋给了变量$shape,调用$shape引用中的面积和周长的方法,出现了不同的结果,这就是一种多态的应用,
//其实在我们PHP这种弱类形的面向对象的语言里面,多态的特性并不是特别的明显,其实就是对象类型变量的变项应用
/**
*把对象串行化(序列化:serialize(),反序列化:unserialize() )
*描述:有时候需要把一个对象在网络上传输,为了方面传输,可以把整个对象转化为二进制串,等到达另一端时,在还原为原来的对象,这个过程叫串行化。
*例子:想把一辆汽车通过轮船运到美国去,因为汽车的体积较大,我们可以把汽车拆成小的部件,然后我们把这些部件通过轮船运到美国去,到美国在重新组装回汽车。
*两种情况必须进行对象穿行化:
* 一:把一个对象在网络中传输的时候要将对象串行化
* 二:把对象写入文件或是数据库的时候用到串行化
*serialize(): 串行化/序列化 一个对象
*unserialize(): 反串化/反序列化 把对象转化的二进制字符串在转化为对象
*/
class PersonMans{
var $name;
function __construct($name=""){
$this->name=$name;
}
function say(){
echo '<br>我的名字:'.$this->name;
}
}
$PersonMans = new PersonMans('leyangjun wa haha');
$p1_string = serialize($PersonMans);//把对象串行化,返回一个字符串
echo '<hr>'.$p1_string.'<br>';
$p2_string = unserialize($p1_string);
$p2_string->say();
/**
*魔术方法__sleep()和__wakeup()
*描述:在对象串行化的时候,会调用一个__sleep()方法来完成一些睡前的事情;而在重新醒来,即由二进制串重新组成一个对象的时候,则会自动调用PHP的另一个函数__wakeup(),做一些对象醒来就要做的动作。
*注:__sleep()函数不接受任何参数
*/
class PersonTwo{
var $name;
function __construct($name="",$age=""){
$this->name=$name;
$this->age=$age;
}
function say(){
echo '<br>我的名字:'.$this->name.' 年龄:'.$this->age;
}
//指定串行化把返回的数组中$name 串行化,忽略没在数组中的属性$age
function __sleep(){
$arr = array("name","age");
return $arr;
}
//重新生成对象是,并重新赋值$age为40
function __wakeup(){
$this->age = 36;
}
}
$pThree = new PersonTwo("乐杨俊",20);
//把对象序列化,返一个字符串,调用了__sleep()方法,忽略没在数组中的属性$age
$pThree_string = serialize($pThree);
echo '<hr>'.$pThree_string;
$pThree_string2 = unserialize($pThree_string); //反序列化形成对象$pThree_string2 重新赋值$age=40
$pThree_string2->say();
/**
*类的自动加载
*/
function __autoload($className){
require_once $className.'.php';
}
//MyClass1类不存在自动调用__autoload()函数,传入参数“MyClass1”
$objs = new MyClass1();
?>
PHP OOP面向对象部分方法归总(代码实例子)的更多相关文章
- OOP面向对象三大特点
OOP面向对象三大特点 (一)封装:将现实中一个事物的属性和功能集中定义在一个对象中.(创建对象) 创建对象的3种方式: 1.直接量方式:(创建一个单独的对象) var obj={ 属性名:值, ...
- Java实现OOP(面向对象编程)
一.对象的综述 面向对象编程(OOP)具有多方面的吸引力.对管理人员,它实现了更快和更廉价的开发与维护过程.对分析与设计人员,建模处理变得更加简单,能生成清晰.易于维护的设计方案.对程序员,对象模型显 ...
- Python OOP面向对象
一.什么是面向对象的程序设计 1.面向过程 程序设计:核心是过程二字,过程指的是解决问题的步骤,即先干什么再干什么......面向过程的设计就好比精心设计好一条流水线,是一种机械式的思维方式. 优点是 ...
- OOP 面向对象 七大原则 (一)
OOP 面向对象 七大原则 (一) 大家众所周知,面向对象有三大特征继承封装多态的同时,还具有这七大原则,三大特征上一篇已经详细说明,这一篇就为大家详解一下七大原则: 单一职责原则,开闭原则,里氏 ...
- OOP面向对象 三大特征 继承封装多态
OOP面向对象 ----三大特征 继承封装多态 面向对象(Object Oriented,OO)是软件开发方法.面向对象的概念和应用已超越了程序设计和软件开发,扩展到如数据库系统.交互式界面.应用结构 ...
- 用C实现OOP面向对象编程(1)
如摘要所说,C语言不支持OOP(面向对象的编程).并这不意味着我们就不能对C进行面向对象的开发,只是过程要复杂许多.原来以C++的许多工作,在C语言中需我们手动去完成. 博主将与大家一起研究一下如下用 ...
- 【Java】步入OOP 面向对象
面向对象编程 OOP Object Oriented Programming 面向对象是一种对现实世界理解和抽象的方法,是计算机编程技术发展到一定阶段后的产物. 面向对象是相对于面向过程来讲的,面向对 ...
- 【blade04】用面向对象的方法写javascript坦克大战
前言 javascript与程序的语言比如C#或者java不一样,他并没有“类”的概念,虽然最新的ECMAScript提出了Class的概念,我们却没有怎么用 就单以C#与Java来说,要到真正理解面 ...
- js面向过程改写成面向对象--通用方法
响亮的标题:一个万能的,保底的.面向过程改写成面向对象的方法 前提朗读:很多刚接触js面向对象的时候都不知道如何能快速的写出一个面向对象的程序,这个是必然的现象,不是每一位学js的一上来就会写面向对象 ...
随机推荐
- 基于pscp批量分发文件
用法: pscp -h 目标ip文件 本地文件路径 远程路径 pscp -h hosts.ip file.txt ~/
- NG2-我们创建一个可复用的服务来调用英雄的数据
<英雄指南>继续前行.接下来,我们准备添加更多的组件. 将来会有更多的组件访问英雄数据,我们不想一遍一遍地复制粘贴同样的代码. 解决方案是,创建一个单一的.可复用的数据服务,然后学着把它注 ...
- 解决“找不到请求的 .Net Framework Data Provider。可能没有安装.”错误
问题: 这几天在装.NET 的开发环境,在装好VS2013和Oracle 11g之后,做了一个测试项目,运行调试没问题 但是涉及到数据库相关操作,如新建数据集.连接数据库等在调试的时候则会出现如下错误 ...
- 开源一款强大的文件服务组件(QJ_FileCenter)(系列三 访问接口与项目集成)
系列文章 1. 开源一款强大的文件服务组件(QJ_FileCenter)(系列一) 2. 开源一款强大的文件服务组件(QJ_FileCenter)(系列二 安装说明) 3. 开源一款强大的文件服务组件 ...
- ANE-调用原生组件横屏定位问题
当我们的应用是横的时候,利用ANE调用原生组件如果处理不当,掉出来的组件会是竖的.那么我么要怎么做才能免去自己手动旋转组件这个破事呢.其实很简单 webView = [[UIWebView alloc ...
- Java NIO Selector选择器
Selector是Java NIO中的一个组件,用于检查一个或多个NIO Channel的状态是否处于可读.可写.如此可以实现单线程管理多个channels,也就是可以管理多个网络链接. 为什么使用S ...
- IOS渠道追踪方式
本文来自网易云社区 作者:马军 IOS,安卓渠道追踪的差异 Google Play国内不可用,国内的安卓 App 分发,都是依托几十个不同的应用市场或发行渠道,如百度.360.腾讯等互联网企业以及小米 ...
- 动态代理(CGLIB实现)
CGLIB(Code Generation Library)是一个开源项目.可以直接对类进行增强,而不需要像JDK的动态代理,需要增强的类必须实现某接口 在使用Spring框架时,因为Spring框架 ...
- httpclient post请求例子(无参数名与带参数名的例子),多线程并发处理
版本:4.1 带参数名的情况 HttpClient httpClient = new DefaultHttpClient(); HttpPost httpPost = new HttpPost(url ...
- tomcat 线程模型
最近看到了内网ATA上的一篇断网故障时Mtop触发tomcat高并发场景下的BUG排查和修复(已被apache采纳),引起了我的好奇,感觉原作者对应底层十分了解,写的很复杂.原来对于tomcat的线程 ...