面向对象编程笔记,温故而知新复习下PHP面向对象

类是把全部相似本性的目的总结到一个类中,类就是一组一致属性和行事的对象的集合。类和目的的涉嫌:类是形似对象的叙述,先有类,再有目的。类是对象的空洞,对象是类的实例。通过class关键字制造类,成员属性是在类中声称的变量,三个类可以包括多少个分子属性,成员属性能够有默许值,也可以没有私自认同值,如若有暗中认同值的话,值不可以是变量、表明式、函数和方法的调用,只好是一个值。在类中扬言的办法,就是成员方法,三个类可以包涵七个分子方法。实例化对象:通过new关键字

■ PHP 的面向对象

面向对象

面向对象在PHP中是以类的山势展示的

  • 类名
    来实例化类,实例化类的结果爆发对象。各个对象都以单身的,分化。在类外部,通过对象引用名->属性,访问或设置成员属性,通过对象引用名->方法,调用成员方法。在类内部,通过$this->属性名,访问成员属性,通过$this->方法,调用成员方法,$this代表当前的对象。

 

面向对象思想

  构造器:new就是二个构造器,功能是:①分红空间;②赋初阶值(幸免不当,简化输入)

  new
Object(Parameters)构造器调用构造函数,传参为了赋初阶值;

  对象的中坚要素是:属性和艺术  
类成员(属性和艺术)。属性最为关键,属性的成团是一个情状,方法是3个情状到另二个境况的大桥

  封装:属性和拍卖属性的点子集合起来。

  把多少及数码的操作方法放在一块儿,作为1个互相依存的全部,即对象。

  面向对象是基于面向过程而言的,面向对象是将功用等通过对象来达成,将作用封装进对象之中,让对象去达成具体的细节;那种考虑是将数据作为第三个人,而艺术大概说是算法作为附带,那是对数据一种优化,操作起来尤其的便利,简化了经过。

 

PHP中的类是单继承的,用关键字extends来兑现持续父类,

php内存分配:php内存分为这几片段:栈空间段:空间小,CPU访问速度快,适合存放代码中一时创办的局地变量(一时半刻数据寄存,用于存储占用空间不变,而且比较小的数据类型的内存段:整形,浮点,布尔),栈是后进先出的协会。堆空间段:用于存储进度运维中动态分配的贰个内存段,堆空间的分寸是不固定的,堆内存的尺寸可以开展动态的伸张或回落。可以用堆来存放数据长度可变,占用内存比较大的多少:字符串,数组,对象,都以储存在堆内存段中。代码段:代码段用于存放一些可执行文件的操作命令的,它是可执行程序在内存中的一段镜像,代码段需求防范在运作时被不合规修改,所以只同意我们读取操作,不容许写入。函数就存储在代码段中。开端化静态段(数据段):用来存放在可执行文件中已起首化的全局变量,相当于储存程序静态分配的变量。在函数中用static关键字申明的静态变量(局地的),保存在早先化静态段中,还有类的静态属性和静态方法也是保存在初阶化静态段中。对象在内存中是如何来分配的:在用new关键字成立对象后,对象的引用保存在栈里,对象保存在堆里,对象的方法保存在代码段里。

重点词:类、对象、属性、方法、继承、访问修饰符、构造方法

www.5929.com,面向对象的三个基本特征

   
封装,就是把客观的东西封装成抽象的类,并且类可以把自个儿的数量和艺术只让可倚重的类照旧目标操作,对不可相信的新闻隐藏。隐藏完毕细节,使得代码模块化。

   
继承,可以应用现有类的富有机能,并在无需再度编辑原来的类的情景下对那个功效拓展伸张。可以增加已存在的代码模块。

   
多态,是允许你将父对象设置成为和一个或更加多的她的子对象相等的技艺,赋值之后,父对象就可以依据当前赋值给它的子对象的表征以不一样的法子运转。父类引用指向子类对象。

 

重在字public protected private 第二个是堂而皇之的
哪个人都可以访问,第2个只可以本类内部和本子类内部访问,第多少个只好类内部使用。

php的构造函数:__construct,通过构造函数来达成目的数据初阶化的办事。在每趟用new创设新对象的时候,首先会自行调用类的构造函数。可以在构造函数的参数中为类的成员属性赋暗中同意值。

 

封装

  访问权限的控制常被喻为是现实落实的隐形。把数量和方法包装进类中,以及现实贯彻的隐藏共同被叫作封装

 

public

protected

default

private

同类

同包

 

子类

 

 

通用性

 

 

 

public:可以被有着其余类访问

protected:自己、子类、及同一个包中类(接受包外的子类访问)

default:同一包中的类可以访问,申明时从没加修饰符,认为是friendly(拒绝一切外包访问)

private:只可以被本身走访和改动

  类的做客控制符唯有三种:public、private、protected

  default是无访问控制符

 

static关键字
表示类的静态成员变量,只和类有关,和实例毫无干系,寻常如若经过实例改变了类的静态成员变量的值,那么其余的实例的静态成员变量也会变动。

php的析构函数:__destruct,析构函数,不可以带有参数,析构函数会在对象的持有引用被删去或显式的销毁在此以前会被调用。通过析构函数释放财富,蕴涵结果集,数据库连接等。给目标引用赋值为
null 可以显式调用析构函数。

面向对象的目标:分工显明、高复用性。

继承extend

   在一个子类被创建的时候,首先会在内存中创造三个父类对象,然后在父类对象外部放上子类独有的属性,两者合起来形成四个子类的对象。所以所谓的接轨使子类拥有父类全部的特性和艺术,然而父类对象中的私有属性和办法,子类是无法访问到的,只是有所,但无法应用。子类不可以持续父类的构造函数,只是显式或隐式调用,可以从子类调用超类的构造函数。

   用new创设子类的靶卯时,若子类没有带参构造函数,将先实施父类的无参,然后再实践自个儿的构造函数。父类定义了有参的构造函数后,可以不定义无参的构造函数,系统也不会提供默许的无参构造函数。那时子类只能够调用父类的有参构造函数。

  Java类是单继承,Java接口可以多三番五次。类可以兑现多个接口,接口可以两次三番(扩大)七个接口

  先继承后兑现接口

类中的变量可用$this来访问,可是静态成员用self::来做客。静态成员的章程是用类来访问完毕的,和实例操作非亲非故,静态成员包蕴静态属性和静态方法。

面向对象的封装性:封装就是把大家的分子属性和分子方法封装起来,封装的意在,不想让类的外围“看到”。使用访问修饰符可以兑现封装。封装的好处在于可以啊不想揭发给类外面的习性和艺术,全体都躲藏起来,把类内部的底细不想让旁人见到,那是就可以对成员开展访问控制。php5中的三种访问控制修饰符:public,暗中认同值,在类的其中和外部(通过对象访问)。protected:受保证的,在类的里边或子类中得以访问,但在类的外部,通过对象不只怕访问。private:私有的,只可以在类的中间开展走访。

 

  组合和后续

  组合是指在新类里面创立原有的类的靶子,重复利用已有类的效果。(“has

  • a”)

   组合和一连都同意在新的类中设置子对象,只是组成是显式的,而后续是隐式的。组合中的全体类和持续中的子类对应,组合中的局地类和后续中的父类对应。

  组合和两次三番的选料规则:

  ①
除非五个类之间是“is –
a”的关联,否则不要任意地利用持续。过多的采取持续会损坏代码的可维护性,当父类修改时,会影响全数继续他的子类,扩张了先后维护的难度和财力。

  ②不要独自为落到实处多态而拔取持续,若是类之间平昔不“is

  • a”关系,可以透过落到实处接口与重组的点子来落成相同的目的。

 

在拜访静态成员属性的时候self::记得加变量符$,方法则不宜。

 php魔术方法:(自动调用)__construct() 
__destruct()  __set()  __get()  __isset()  __unset()     
__set($propertyName,$propertyVal):在类的外部(通过对象引用)对私有的或受保证的或然未定义的分子属性实行赋值
的时候会自行调用。__get($propertyName):在类的表面(通过对象引用)对个体的或受保证的还是未定义的积极分子属性进行读取 的时候会自动调用。

面向对象的思路:尽量将各样“效能”独立包装(分工越细越好),然后“功用”间互动调用。

多态

        

  定义:不一样类的对象对同样新闻做出响应。同一新闻可以依照发送对象的两样而使用种种不一样的作为格局。

  多态存在的八个要求条件:继续、重写、父类引用指向子类对象。

Java中多态的完结形式:接口完毕,继承父类举办方式重写,同一个类中展开艺术重载。

  父类引用指向子类对象,该引用不可能再拜访子类新增的分子。Animal
cat = new Cat()

  直接new3个父类实例(Animal
a = new Animal())的界别?

  答:当父类是接口和抽象类时,无法实例化,只好采纳多态,向上转型。普通类中,可以在子类中重写父类中的方法,那样就可以访问子类中的重写方法。

 

父类中的静态成员,在子类中操作的话使用parent::这种措施,情形和self类似。类中静态的措施里面不或许访问类的一般成员属性的。

 __isset()
:当在类的表面对民用的,受保证的如故未定义的分子属性举办isset()大概empty()调用时,会自动调用__isset()魔术点子。

 

重写和重载

总述:1静态属性用于保存类的共有多少

 __unset()
:当在类的外表对个人的,受有限协助的要么未定义的积极分子属性举办unset()调用时,会自动调用__unset()魔术点子。

☆面向对象的三大特色:封装、继承、多态

   方法重载(overload):

  (1)必须是同一个类

  (2)方法名(也足以叫函数)一样

  (3)参数类型不均等或参数数量或相继差距

  (4)不能够透过再次回到值来判断重载

         2静态方法里面只可以访问静态属性

使用extends关键字贯彻接二连三,PHP是单继承的,继承可以兑现代码的高可重用性,高可扩张性。父类–基类–超类。子类–派生类–扩大类。

 

  方法的重写(override)子类重写了父类的同名方法,两同两小一大规格:

  (1)方法名相同,参数类型相同

  (2)子类再次回到类型是父类再次来到类型的子类。

  (3)子类抛出十分的小于等于父类方法抛出极度,

  (4)子类访问权限大于等于父类方法访问权限。

重载(Overload)

重写(Override)

同一个类中方法之间的关系,水平关系

父类与子类之间,垂直关系

通过不同的方法参数来区分(参数的类型,个数,顺序)

参数列表、返回值类型必须一致,方法体不同

不能通过访问权限、返回值类型和抛出的异常类型来进行重载

子类访问权限大于等于父类的访问权限

父类中被重写的方法不能为private

 

  在重写中,运用的是动态单分配,依照new的品类显然目的,从而分明调用的不二法门

  在重载中,运用的是静态多分担,依据静态类型明确目的,无法依照new的连串显然调用方法。

  多态中,Father f =
new Son()

        
成员变量:编译运维参照左侧;

        
成员函数:编译看右侧,运转看右侧;

        
静态函数:编译运维看左边。

 

         3静态成员不须求实例化对象就可以访问

经过parent::关键字在子类中调用父类中被重写的点子。假诺子类的重大字和父类一样,相当于子类重写了父类的章程。

 

面向对象编程笔记,温故而知新复习下PHP面向对象。构造函数

  用来在对象实例化时开头化对象的积极分子变量。

         4类的内部可以通过self恐怕static关键字访问本人静态变量

父类中的
final 方法不只怕被子类重写。

● 类 与 对象:

特点:

  ①
方法名必须和类名相同,无法有重回值(也不可以为void);

  ②
2个类可以有四个构造函数,没有概念的话,编译器会在源代码编译成字节码文件的进度中会提供1个尚未参数默许的构造方法。若定义后,不会再次创下设暗中同意的构造方法;

  ③构造函数的参数有(0到多个); 

  ④构造函数在对象实例化时会被电动调用,且只运维三遍;普通方法是在程序执行到时才调用且可以被该目的调用数十四回;

  ⑤构造函数的效用是做到目的的早先化

  ⑥构造函数不可以被接续,不可以被遮住,能被重载。

  ⑦子类可以经过super()驷马难追字来体现调用父类的构造函数,父类没有提供无参构造,子类的构造函数中务必显式得调用父类的构造函数。

  ⑧父类和子类都未曾概念构造函数时,编译器都会为父类生成一个暗许的无参构造,给子类也生成1个暗许的无参的构造函数。

  ⑨构造方法会在成员变量之后初叶化。

  ⑩构造方法不可以被static、final、synchronize、abstract、native修饰,但足以被public、private、protect修饰。

 

 

  在继续的时候,父类当然也有构造方法,借使您要成立子类的目标,那么执行的经过首先是调用父类的无参构造方法生成父类的对象,然后再调用子类的无参构造方法来生成子类对象。继承的时候都以知识分子成父类的靶子,然后再生成子类的对象。

  通过动用this关键字带上参数,可以在2个构造函数中调用别的3个构造函数。那是this除了单纯表示”当前目标”(注意是指向对象而不是类的定义)之外的第三个效益。不过注意3点:

  第3点,必须放在第2行。

  第三点,只可以调用四个其他的构造函数。(大概可以如此敞亮,正是因为有了第三点,即使可以调用多个的话,那么就不能放在”第③行”,所以不得不一样意三次调用)

  第2点,只好是构造函数调用构造函数,普通函数不可以调用构造函数。

 

         5可以经过parent关键字访问父类的静态成员

在函数中采纳static关键字申明的变量时静态变量,第3回调用此函数时一定于初步化static变量,当函数执行完后,statice变量没有被放走,而是保持在了静态内存中,当大家重新调用这几个函数的时候,会再度读取静态内存中的值,函数static变量的值在函数数十次调用时,其值不会丢掉,函数内部的static变量仅在函数内部是可知的。同样在类中也得以使用static关键字,用static关键字来定义类的静态属性和静态方法,通过static关键字表明的static成员属性和分子方法是属于类的,在类的其中和表面(脚本文件中)static属性和static方法毫无实例化类的目的就可以访问,通过
类名::属性名 和 类名:: 方法名 来访问。其余,在类的中间可以经过self::
关键字来访问static属性和static方法(推荐用self关键字),self关键字表示定义当前艺术的类,在类的实例中也足以用self关键字来访问static属性,在类的里边不只怕用$this来引用static属性和static方法。在static方法内部,不大概使用$this,在static方法中也决不引用非static内容(即没有用static修饰的品质或艺术)。在类的外表,通过类的实例的引用也足以调用类的static方法。类的static属性,在类的多少个实例间共享,其中三个实例修改了static属性值,在类的具有实例中都将赢得更新。

 

super()和this()

  super()关键字表示超类的情致,当前类是从超类继承而来。

  this指代当前目的。

  唯有在重写(Override)父类的点子中,子类要调用继承自父类的主意,才使用super关键字。

  使用super()或者this()方法是必须放在构造函数的首先行。

  由于this函数指向的构造函数暗中同意有super()方法,所以规定this()和super()不或许而且出现在二个构造函数中。

  因为static方法恐怕语句块没有实例时方可接纳,而此刻不要求结构实例,所以无法用this()和super()。

  

         6可以经过类的称谓在类的外部访问静态成员

www.5929.com 1

Class/Object : 类(Class)和 对象(Object)是面向对象方法的中央概念。

abstract(抽象类)和Interface(接口)

 

 

  抽象类

  用abstract修饰的类表示抽象类,抽象类位于继承树的抽象层,抽象类不只怕被实例化。

  用abstract修饰的法门表示架空方法,抽象方法没有方法体。抽象方法用来描述系统全部怎么着效用,但不提供具体的兑现,把现实贯彻留给继承该类的子类。

特点:

  a.含有抽象方法的类必须评释为抽象类(不管其中是还是不是有其余措施)

  b.抽象类可以从没抽象方法,可以有平凡方法。

  c.抽象类必须被持续,抽象方法必须被重写(若子类依然抽象类,不必要重写)

  d.抽象类无法被实例化(无法直接社团三个此类的对象)

  抽象方法

  a.在类中绝非方法体(抽象方法只需注解,而不需兑现有个别意义);

  b.抽象类中的抽象方法务必被落成

  c.若是多少个子类没有已毕父类中的抽象方法,则子类也改成了一个抽象类;

2 final关键字
适用于不可以被复写的成员,在父类中写的final关键字后,其艺术无法再子类中重写,若是在类前写,那么其无法有子类。

在php脚本文件之中通过define或许const来定义常量。在类内部通过const关键字定义常量属性。常量属性的名号一般用小写。常量的值只能够是值,不可以是表明式或变量。在类内部通过类名或self访问常量属性,在类外部,通过类名来访问,无法透过类的实例的引用来拜访。在类的内部也得以通过static关键字访问const常量。

类 是对一类东西共性的下结论、描述,是虚幻的、概念上的定义;

  接口

  interface
中的方法暗中承认为public abstract
(public、abstract可以大致),变量暗许为public static
final;类中的方法全体都以抽象方法。只有注脚没有落成,在不一样类中有两样的主意完结。

不同点

(1)接口中不得不分包抽象方法和暗中同意方法,不只怕为普通方法提供格局完毕;抽象类中得以涵盖普通方法。

(2)接口里无法定义静态方法(jdk1.8下可以定义static方法),抽象类可以定义静态方法。

(3)接口中只可以定义静态常量,不大概定义普通成员变量;抽象类即可以定义变量又足以定义静态常量。

(4)接口中不带有构造器,抽象类里可以包括构造器,抽象类中的构造器并不是用来创建对象,而是让任何子类调用那些构造器来形成抽象类的开首化操作。

(5)接口里不大概包括初步化块,但抽象类可以分包。

(6)三个类最三只好有三个父类,包含抽象类;但3个类可以直接完结三个接口,通过落实三个接口可以弥补Java单继承的供不应求。

共同点

(1)接口和抽象类都不或然被实例化,都位居继承树的上方,用于被其他类落成的继承。

(2)接口和抽象类都得以分包抽象方法,落成接口和后续抽象类的见惯司空子类都必须完毕那么些主意。

 

抽象类

接口

方法

家常便饭方法、抽象方法

只得有抽象方法和暗许方法

静态方法

可以定义

不可以定义(jdk1.8下可以定义)

暗中同意访问权限

jdk1.8前为protected

jdk1.8后为default

jdk1.8前为public

jdk1.8为public或default

变量

概念变量、静态常量

只能定义静态常量

构造器

可以包罗(不是用来创立对象,而是让任何子类调用,落成开头化操作)

不可以包蕴

开首化块

可以包含

不恐怕包罗

面向对象编程笔记,温故而知新复习下PHP面向对象。继承

不得不有贰个父类,但可以完结多少个接口

接口可以一而再七个接口

实例化

接口和抽象类都不只怕被实例化,都位于继承树的顶端,用于被此外类完毕的存续。

 

 

 

即以final关键字写的类依旧措施 不只怕被旁人改动

通过 is_a() ,instanceof
来检测多个对象引用是不是是3个类,父类或接口的实例。get_class()再次回到当前调用对象引用的类名。get_parent_class()再次回到类或许目标的父类名。is_subclass_of()检测1个对象(引用)是不是是别的3个类的子类。

 

final

  final修饰的,就是最后类,不可以被持续。

  final修饰的方法,就是最终方法,最后方法不可以被重写

  final修饰四个引用变量时,是引导用变量不或许变,引用变量所针对的对象中的内容照旧得以转移的。修饰主干数据类型变量时,内容无法变。

  final成员变量必须在早先化代码块或在构造器中初叶化。

作用:

  final类:假定二个类不须要有子类,类的贯彻细节不容许改变,并且确信这一个类不会再被扩张,那么就筹划成final类。

  final方法:①把办法锁定,幸免其余继承类修改它的意思和贯彻。②相当的慢,编译器在遇见调用final方法时候会转入内嵌机制,大大进步实施成效。

 

 

===================================

对象 是事实上存在的,是此类事物的切实个体。因而也称为实例(instance)。

static

  static修饰的变量称为静态变量,静态变量属于全部类,而有的变量属于方法,只在该格局内有效。static不恐怕修饰局地变量。static方法内部不可以调用非静态方法。

  静态变量只可以在类重点中定义,不只怕在形式中定义。

  static变量只会创立一份,不管创设多少个对象,都共用3个变量。

  类方法指被static修饰的主意,无this指针。其余的就是实例方法。类措施能够调用其余类的static方法

3
parent关键字可用来访问在子类中复写的父类的点子。self关键字可用于访问类自个儿的分子方法,也得以方法本人的静态成员和常量,不能访问类本身的性质,类中的

抽象类不可以平素被实例化,只可以通过子类来两次三番它,并且经过在子类中完成抽象类中的抽象方法使抽象类具体化,在抽象类中只须要定义子类要求的情势,也可以在抽象类中部分落成部分故事情节,把集体的有的先完毕以下。在抽象类中务需求有抽象方法,抽象方法就1个虚幻的盘算,抽象方法没有现实的兑现,通过
abstract
关键字来定义三个华而不实方法,抽象方法没有方法体,只是申明了3个调用方式,不可以定义具体的功效落成,子类在继承的时候必须兑现全体的虚幻方法,子类在促成父类抽象方法的时候,可知性可以和父类相同或然从宽,子类中也得以定义本身的点子。在三个类中,只要有贰个类是望梅止渴方法了,那么这几个类就务须注明为abstract
抽象类。abstract抽象类不能被实例化。

 

类情势和目标方法的界别

  一 、类措施是属于全部类的,而实例方法是属于类的有个别对象的。

  由于类措施是属于全部类的,并不属于类的哪个目的,所以类措施的方法体中不只怕有与类的靶子有关的始末。即类方法体有如下限制:

  (1)
类方法中不可以引用对象变量;

  (2)
类方法中不可以调用类的对象方法;

  (3)
在类格局中不或然采纳super、this关键字。(this代表近期类的目的,由static修饰的章程是类直接调用,不必要制造对象,所以不可能用this

  (4)类格局不大概被遮住。

  ② 、与类措施相比较,对象方法大致一直不什么样范围:

  (1)
对象方法中能够引用对象变量,也能够引用类变量;

  (2)
对象方法中得以调用类方法;

  (3)
对象方法中得以动用super、this关键字。

常量使用const关键字定义,使用常量的时候不必要加$符号

接口就是一套规范或契约,是类和类之间的一种协议,接口也是对外提供服务的一种出口。在接口定义中必须是纯粹的模板,接口定义中不得不定义功效,不可以包括具体的达成内容。通过interface
关键字来定义接口,在接口定义中可以包罗方法,也得以分包属性,接口中的方法必须定义成
public
的,不只怕定义方法体。通过implements关键字来落到实处接口,落成接口的时候必须兑现接口中颇具的措施。三个类可以达成多个接口,多个接口之间拔取逗号分隔,三个接口中的方法是不可以有重名的。二个类可以先三番五次其余3个类,在促成多少个接口。接口也帮衬继承,并且1个接口可以两次三番八个接口,接口间的接续形式和类的接续一样,在接口中还可定义常量,接口常量不大概被子类只怕子接口所掩盖。

(比喻:类 是1个“模子”;对象 是依照那么些“模子”造出来的有血有肉的东西。)

static关键字的效益

  为某一定数据类型或对象分配单一的贮存空间,而与创立对象的个数非亲非故;完结有个别方法或质量与类而不是目的关联在一道。

  静态变量属于类,在内存中唯有三个复制,只要静态变量所在的类被加载,这些静态变量就会被分配空间。

 

 

 继承完成多态,接口达成多态。

 

类修饰符

(1)外部修饰类

   1、protected
private
不可以修饰外部类,是因为表面类位居包中,唯有二种恐怕,包可知和包不可知。

  ② 、final 和
abstract不大概同时修饰外部类,因为此类要么能被延续要么不可以被屡次三番,二者只可以选其一。

  三 、不可以用static修饰,因为类加载后才会加载静态成员变量。所以不能够用static修饰类和接口,因为类还没加载,不能利用static关键字。

(2)内部修饰类

  内部类与成员变量地位一贯,所以可以public、protected、default和private,同时还足以用static修饰,表示嵌套内部类,不用实例化外部类,即可调用。

 

4interface
关键字用于定义接口,接口里面的法门不必要有办法的落到实处。用implements用于表示类完结3个接口,而实现一个接口之后必须提供接口中定义的艺术的求实已毕。

www.5929.com 2

 

静态块和结构块

public class B{
  public static B t1 = new B();
  public static B t2 = new B();

 {
     System.out.println("构造块");   
 }
 static{
     System.out.println("静态块");
 }

 public static void main (String args){
      B t = new B();  
 }           
}

 

上述代码的出口结果是:构造块
构造块 静态块 构造块

(1)静态块:用static扬言,JVM加载类时实施,仅执行一次,按讲明顺序执行。

(2)构造块:类中一直用{}定义,每2次创造对象时进行

  静态域中包罗静态变量、静态块和静态方法,其中必要开端化的是静态变量和静态块。而他们多个的开始化顺序是靠他们的职责决定。

  静态变量只可以在类重点中定义,不能在点子中定义。

  执行的相继优先级:静态域**>main()>构造块>构造方法**

 

5instanceof 是二个二元操作符,是判定左侧变量是不是是左边类的实例

=================================== 

●创建类:

先后初步化顺序

  1.父类静态变量

  2.父类静态代码块

  3.子类静态变量

  4.子类静态代码块

  5.父类非静态变量

  6.父类非静态代码块

  7.父类构造器

  8.子类非静态变量

  9.子类非静态代码块

  10.子类构造器

     
先静态后非静态,先父类后子类。

     
按成员变量的定义顺序举办初阶化。即便变量定义散布于艺术之中。

 

6
可以用extends接口继承接口,当类已毕子接口时,接口定义的点子照旧父接口定义的主意,也必要在类中贯彻。

 魔术点子:__toString():当大家输出多少个目的的时候,__toString()魔术点子会被机关调用,__toString()魔术点子须要回到以字符串。当咱们的靶子被看作函数的措施调用(即,在目标的引用前边加上左右括号(),来调用对象,也得以在调用对象的时候,向目的调用传递参数)的时候,会自动触发
__invoke()
魔术点子的调用。(通过func_get_args()函数可以拿走调用函数时传递给函数的参数)。当调用二个目的的未定义或不足访问(例如:在类外部调用类的
private
方法)的方法的时候,__call()魔术点子会被机关调用,__call()魔术点子有四个参数:第三个是未定义的艺术名,首个是给未定义的函数传递的参数(在__call()内部以数组的花样保留),__call()魔术点子,也等于方法的重载。__callStatic()魔术点子在用静态格局调用多少个不行访问如故不存在的static方法时,会被活动调用,__callStatic()魔术点子一致有八个参数:第四个是未定义的点子名,第1个是给未定义的函数传递的参数(在__callStatic()内部以数组的款型保留)。__clone():暗许情形下,将目标的引用直接赋值给一个变量,是援引的赋值,三个都对准同1个目的。想拿到多少个一律的对象足以因而clone关键字完结。通过clone关键字可以将1个目的的天性和情势完全复制一份赋给另二个对象,clone达成后会拿到多个一样的独门对象,各自占用不一致的内存空间,1个目的的变更不会潜移默化另叁个对象。当我们运用clone关键字的时候,自动会调用(触发)3个魔术点子__clone()。__sleep():种类号对象的时候会自行调用。__wakeup():反连串化对象的时候会活动调用。(系列化多少个目的是指将二个目的转换来字节流的格局,那样就足以将目的保存在文书中。)

 

内部类

   为啥使用其中类:

  每种内部类都能独立地继续二个接口的贯彻,所以无论是外围类是还是不是早已接轨了有个别(接口)的已毕,对于里边类没有任何影响。能丰盛好的缓解多重继承的题材。

把一个类定义在另二个类的其中,在类里面的这么些类就叫做内部类,外面的类叫做外部类。内部类可以被当做外部类的一个成员。内部类分为4种:

类的法子必须有落到实处,接口的办法必须为空。

===================================

class 类名 {

  静态内部类(static inner class)

  被声称为static的中间类,可以不借助于表面类实例而被实例化,而寻常的内部类须要在外表类实例化后才能实例化。静态内部类无法与外部类有雷同的名字,无法访问外部类的常备成员变量,只能访问外部类中的静态成员和静态方法。

7
多态,多态是对于接口说的。接口只是概念了二个接口,可是落成接口的类是丰富多彩的,封装1个函数只怕类来促成传入不一致的参数,调用不一致的类,然后输出不一样的结果

以下是进阶篇的内容:面向对象的设计基准,自动加载类,类型提醒,traits,命名空间,spl的行使,反射的行使,php常用设计方式

 

  成员内部类(member inner class)

  静态内部类去掉static就是成员内部类,成员内部类为非静态内部类,可以随便地引用外部类的品质和章程,无论静态照旧非静态,可是它与实例绑定在协同,不得以定义静态属性和艺术。

  1.外部类是不可以平素运用其中类的成员和艺术的,可先成立内部类的靶子,然后经过内部类的对象来访问其成员变量和办法;

  2.假使外部类和中间类具有相同的成员变量或格局,内部类暗许访问自个儿的积极分子变量或方法,若是要拜访外部类的成员变量,

可以使用 this
关键字,如:Outer.this.name

那就是多态。

 

走访修饰符 $成员属性名 = 属性值;

  局地内部类(local inner class)

  局地内部类是概念在3个代码块内的类,它的职能范围为其所在的代码块。局地内部类像一些变量一样,不能别public、protected、private以及static修饰,只好访问方法中的final类型的有个别变量。

8abstract用以定义抽象类。在空洞方法前边扩充abstract可以安装此措施为架空方法,不要求实际的兑现,抽象类中得以包括普通方法。

 

 

  匿名内部类(anonymous class)

  是这一种没有类名的中间类,不使用首要字class、extends、implements,没有构造函数,必须三番五次其他类或促成贰个接口。好处是代码简洁,难题是易读性下跌。

  匿名内部类不可以有构造函数,不可以定义静态变量、方法,不或者是public、protected、private、static
。只可以创设匿名内部类的二个实例,匿名内部类一定是在new的后面。

 

 

 

 

 

 

 

 

连续抽象类的显要词是extends,继承抽象类的子类要求贯彻抽象类中的抽象方法。抽象类和接口一样都无法直接实例化。

访问修饰符 function 方法名(){

 

 

9有关魔术点子

}

__construct __destruct 分别是类的起先化执行和类结束执行的

}

除去上述1个外,超过四分之一魔术点子是容错处理,就是变量只怕措施不设有的时候调用,恐怕类不得法的办法运用才会调用这么些魔术点子

 

__toString 是类被当做字符的时候调用

 

__invoke   当类被看成方法调用的时候调用

注意:

__call 当对象访问不设有的点子名称时会被调用

① 类名首字母要大写;

__callStatic 当访问对象不设有的静态方法的时候 会被调用

② PHP中开创类时,属性不可以是表明式或函数的再次回到值!

__get 读取不可以访问的品质是被调用

③ 在类中不得不定义属性和方法 ,无法直接调用方法。

__set 在给不能够访问的本性赋值是被调用

(★即 在类中除去定义属性和方法,不能有任何其它的操作语句!)

__isset 当给不可以访问的性质使用isset大概empty的时候 被调用

 

__unset 当给不或者访问的品质使用unset的时候被调用

 

__clone 对象被复制的时候调用

★ $this 关键字:

 

$this 关键字 是用来做客当前类中(对象中)的性质或方法。

(即 用来走访自己的属性或方式。)

 

 

●创造对象(实例):

 

$对象名 = new 类名();

 

 

●访问对象属性:

 

$对象名->属性名;

 

留意:访问对象的性质时,属性名后边不必要加 $ 。

 

 

●假若1个文件,专门用来定义类,则命名规范应为:

 

类名.class.php

 

 

●类的静态属性:

 

例如:

class Human {

public static $leg = 2; //在属性名前边加 static
关键字,定义类的静态属性。

}

 

专注:类的静态属性 属于全类,不属于某二个目的,在内存中仅有一份。

 

 

★构造方法(构造函数):

 

构造方法 __construct
是【PHP魔术方法】之一,它是类的一种相当的不二法门,它的紧要功能是做到对新对象实例的初步化。

 

构造方法(构造函数)有三个本性:

① 构造方法没有重临值;

② 创造新对象(实例)时,系统会自动调用该构造函数来成功目标实例的先河化。

 

一般采纳形式为:

 

class 类名 {

做客修饰符 function __construct(形参列表){

……开首化操作……

}

}

 

实例化对象时:

 

$对象名 = new 类名(实参列表);

 

常用处:

①因此构造方法(构造函数)可以实未来实例化对象时给类(其实也等于构造方法在起成效)传入参数;

②创立类时 属性不只怕是表明式或函数的重临值,但透过构造方法就足以兑现。

例如:

 

class Human {

public $name;

public function __construct($a){

$this->name = $a; //依照“类的参数”改变 Human类的积极分子属性 name 的值。

}

}

 

$zhangSan = new Human(‘张三’);

 

echo $zhangSan->name;// 输出:张三

 

 

★析构方法(析构函数):

 

构造方法 __destruct
也是【PHP魔术方法】之一,它也是类的一种十分的点子,它会在目的(实例)的具备引用都被去除或当对象(实例)被显式销毁时实施。

(即 当对象内部的操作实施完结时 __destruct()
会被电动调用。“析构≈善后”)

 

诚如采纳格局为:

 

class 类名 {

function __destruct(){

 

}

}

 

析构方法(析构函数)有四个特征:

① 析构方法没有重返值,也从没参数;

② 析构方法会自动调用;

③ 析构方法首要用于销毁能源;

④ 析构方法调用顺序是:后创制的指标(实例),先被灭绝;(栈 ——
后进先出)???

⑤ 析构方法在先后停止或对象变成废物对象时被调用。

 

 

■ 面向对象的三大特征:封装、继承、多态

 

● ① 、封装特性:

 

q:什么是包装?

a:封装是把一部分连锁的天性和表现隐藏起来,从而获取敬服和安全。

 

 

q:什么是 外部访问 和 内部访问?

a:

“外部访问”的情趣是 对 属性或格局 的拜会 发生在 类的外部。

(即 访问属性或方法的代码 不是在 成立类 的代码之内,而是在其他地点。)

比如说,在创制类的代码之外 通过 ->
访问对象的天性或艺术。代码如:$对象名->属性名

 

“内部访问”的意味是 对 属性或格局 的拜会 暴发在 类的其中。

(即 访问属性或情势的代码 位于 创造类 的代码之内。)

比如,在类的内部通过 $this->
访问本人的习性或方法。代码如:$this->属性名

 

 

☆大家是通过 访问修饰符 浮现 封装性子 的。

 

★访问修饰符(封装关键字):

 

public (无封装性)表示公开的,本类的目的 内部、外部 和 子类的靶子
都足以访问。

protected (有封装性)表示受保险的,仅有 本类的对象 或 子类的目的内部可以访问。

private (有封装性)表示私有的,只有 本类的靶子 内部可以利用。

 

注意:默认是 public

 

 

★如果大家想从外表访问 对象中的 protected 或 private
属性/方法,我们日常的做法是 在目标内部成立贰个 public
方法,然后通过该措施去做客那几个“被爱戴的”或“私有的”属性/方法。(一般大家都在这么些public方法中添加一些检测权限的设定)

例如:

 

class A{

private $money = 10000; // 私有的属性

 

// 创设1个集体措施,用于重置私有属性的值:

public function resetMoney($rmb){

$this->money = $rmb;

}

 

// 创造二个共用艺术,用于获取个人属性的值:

public function showMoney(){

return $this->money;

}

}

 

$a = new A();

$a->resetMoney(10);

echo ‘我有 ¥’,$a->showMoney(),’.00′; // 输出:我有 ¥10.00

 

 

 

● 二 、继承天性:

 

被三番五次的类称之为:基类 或 父类 。

后续的类称之为:派生类 或 子类 。

 

类的接续通过 extends 关键字 来促成。一般格局如下:

 

//父类

class Parents {

 

}

 

//子类 Children 继承 父类 Parents :

class Children extends Parents {

 

}

 

继承的底细:

① 父类中 public 与 protected 的性质和办法 可以在子类中接纳,而 private
的习性和章程 不可以在子类中应用(不大概访问)。

② 二个子类只好继续三个父类。

③ 子类的靶子实例也会持续父类的构造方法。


假若我们想去调用父类中本来的措施(如:父类的构造方法或已被掩盖的艺术),可以动用以下措施达成:

父类名::方法名();

或:

parent::方法名();

⑤借使实类中的方法和父类中的方法重名,且参数个数相同,则父类中的方法将被重写(或称
方法覆盖)。

只顾:在完毕格局覆盖时,新办法的“访问范围”要超过或等于被覆盖的形式。(public
的“访问范围”比 protected 的大。)

 

 

 

 

/************************************

??????谜 ??????

************************************/

 

class Parents{

public $a = ‘P_a’;

protected $b = ‘P_b’;

private $c = ‘P_c’;

 

public function f(){

echo $this->a,'<br />’;

echo $this->b,'<br />’;

echo $this->c,'<br />’;

}

}

 

class Children extends Parents{

public $a = ‘C_a’;

protected $b = ‘C_b’;

private $c = ‘C_c’;

 

public function f_c(){

echo ‘C~’,$this->a,'<br />’;

echo ‘C~’,$this->b,'<br />’;

echo ‘C~’,$this->c,'<br />’;

}

}

 

$xiaoMing = new Children();

 

var_dump($xiaoMing);

echo ‘<hr />’;

$xiaoMing->f(); // 调用 从父类 继承来的 f() 方法。

/*

输出:

C_a

C_b

P_c   <——居然输出了父类的 private 的性质。

*/

echo ‘<hr />’;

$xiaoMing->f_c();

/*

输出:

C~C_a

C~C_b

C~C_c

*/

 

 

 

● ③ 、多态个性:

 

在 Java 中 多态是指:二个接口,多少个形状。

 

Java 中的多态 是由 三个父类 和 继承它的多少个子类 通过 重写方法
完毕的。(即 继承 + 重写)

 

在 PHP 中 不可以兑现 Java 中的那种多态天性,不过足以通过 动态类名模拟类似的作用,即“伪多态”。

(详细,请看057讲)

 

 

 

★方法重载:

 

q:什么是 方法重载 ?

a:方法重载
就是:函数名相同,通过函数的参数个数恐怕是参数类型分裂,达到调用同1个函数名,但推行不一致函数的效益。

 

(PHP5中 默许不协助像 JAVA 那样的主意重载。)

 

PHP中通过 魔术点子 __call() 模拟Java中的方法重载:

 

魔术点子 __call()
的效果是:当调用多个对象的有些方法,但该格局并不设有时,系统就会自动调用
__call() 。

 

瞩目:系统还会自行传给 __call() 七个参数:

第③个参数是 被调用但不设有的法子名;

其次个参数是 调用那么些不存在的法门时 使用的参数 所组成的数组。

 

例如:

 

function __call($存放方法名的变量,$参数数组){

if($存放方法名的变量 == “方法名”){

$cnt = count($参数数组);

if($cnt == 1){

……如果只有叁个参数时,执行……

}else if($cnt == 2){

……如若有八个参数时,执行……

}

}

}

 

 

 

■ PHP 的 静态变量:

 

★ 无论怎么语言,静态变量 的特征都以:常驻内存!!

 

<?php

 

function f(){

static $a = 0; //静态变量

return $a++;

}

 

echo f(),'<br />’;

echo f(),'<br />’;

echo f(),'<br />’;

echo f(),'<br />’;

echo f(),'<br />’;

echo f(),'<br />’;

echo f(),'<br />’;

echo f(),'<br />’;

echo f(),'<br />’;

echo f(),'<br />’;

 

/* 输出:

0

1

2

3

4

5

6

7

8

9

*/

?>

 

 

■ 静态属性 与 静态方法:

 

★ 静态属性 和 静态方法 位于内存的 静态数据区 不随对象实例放在堆区。

 

村办领悟 {

静态属性 和 静态方法 被定义在成立类的代码中。

静态属性 和 静态方法 从概念之时起 就置身 内存的 静态数据区 且 常驻内存。

具备大家不要求对此类举行实例化,也足以由此类名间接对 静态属性 和
静态方法 进行访问。

 

静态属性 是还是不是首要用来 被八个实例 公用 ??

}

 

● 一 、静态属性:

 

静态属性的相似定义格局为:static 访问修饰符 $静态属性名;

 

静态属性一般有三种访问方式:

① 在类外部:类名::$静态属性名

② 在类内部:self::$静态属性名 或 类名::$静态属性名

 

★注意:即使没有给某些类成立对象(实例),也得以通过类名直接调用它的静态属性。因为静态属性位于内存的
静态数据区 不随对象实例放在堆区。

 

 

● 贰 、静态方法:

 

静态方法的形似定义格局为:static 访问修饰符 function 静态方法名(){……}

 

★注意:静态方法中无法访问非静态属性。

 

静态方法一般也有二种访问格局:

① 在类外部:类名::静态方法名() 或 对象名->静态方法名()

② 在类内部:self::静态方法名() 或 类名::静态方法名()

 

 

★静态属性 和 静态方法
只属于类具有。同3个类在一个页面中,只可以声可瑞康(Beingmate)个次。因而,一个类的静态属性
在内存中唯有一份。我们可以接纳那脾本性,落成PHP的 单例情势 。

 

 

★ self 关键字:

 

用来访问当前类中的内容,类似 $this 关键字,但 $this
须求类被实例化今后才得以动用,self 可以直接访问当前类中的内部成员。

 

self关键字的貌似拔取格局如下:

 

self::类内的成员属性或措施

 

等价于:

 

类名::类内的成员属性或情势

 

提示:self 关键字一般用来访问类中的静态属性、静态方法 或 常量。

 

 

★ final 关键字:

 

当大家愿意 有些类无法被继承 或 某些方法无法被重写(覆盖)时,大家可以使用
final 关键字。

 

final关键字的貌似选拔方式如下:

 

final class 类名 {

final 访问修饰符 function 方法名(){

 

}

}

 

/*

上例只用作示范语法,实际上 类 与 该类中的方法 同时用 final
修饰是毫无意义的。

既然如此无法被三番五次,又何来重写吗。

*/

 

 

★ const 关键字:

 

当大家不愿意某些成员属性被改动时,可以使用 const 关键字 将其定义为常量。

 

诚如定义情势:const 常量名 = 值;

 

注意:

① 常量名 前边没有 $ ;

② 常量名 用大写字母。

 

一般访问格局为:

在类外部访问:类名::常量名  或  接口名::常量名

在类内部访问:self::常量名

 

 

★ instanceof 运算符:

 

instanceof ——效率:判断贰个变量是还是不是某一个类的对象(实例)。

 

例如:var_dump(变量名 instanceof 类名);

 

 

 

☆ PHP的【魔术点子】都是 当某种景况暴发时会 自动触发 的办法。

 

 

★魔术点子 __get() :【注意:要在类的里边宣称才有效!】

当运转的语句,请求了三个脚下条件不可知的性质时(比如:未定义的习性、受保证的天性、私有的天性),将会触发
__get() 魔术点子。

 

当 __get() 被触发时,系统为其传了二个参数,该参数的值为请求的属性名。

 

 

★魔术点子 __set() :【注意:要在类的中间宣称才使得!】

 

当运维的讲话,试图设置四个脚下条件不可知的品质时(比如:未定义的性质、受保险的性质、私有的习性),将会触发
__set() 魔术点子。

 

当 __set() 被触发时,系统为其传了多个参数,分别是:必要安装的属性名 和
属性值。

 

 

★魔术点子 __autoload() :【注意:在类的表面声明。】

 

当试图实例化1个未声明的类时,自动触发 __autoload() 魔术点子。

 

当 __autoload()
被触发时,系统为其传播了二个参数,该参数的值是被实例化的类的类名。

 

 

 

■ 对象克隆:

 

怎么是目的克隆?先看之下代码:

 

$obj = new A();

 

$obj_02 = $obj;

 

上述 语句中 $obj_02 = $obj 是 “引用计数赋值”
。它们传递的是有些数据的地点(指针)。即 它们都以指向同一块内存空间。

 

而目的克隆就差距,对象克隆能确实地‘复制’出第三个目的。一般方式如下:

 

$obj_02 = clone $obj;

 

 

魔术点子 __clone() :【注意:要在类的里边宣称才使得!】

 

当对象被克隆时,自动触发 __clone() 魔术点子。

 

 

 

■ 抽象类:(特点:无法被实例化,只可以被接续的类)

 

★抽象类无法被实例化,只用作后续。

 

创制 抽象类 及 抽象方法 的一般方式如下:

 

abstract class 抽象类名 {

 

abstract function 抽象方法名(); // 没有办法体 “{}” 。

}

 

注意事项:

① 抽象类不可以被实例化;

② 抽象类不必然要包括抽象方法,抽象类也得以分包一般方法;

③ 一旦类中富含了指雁为羹方法,则该类也不或者不申明为抽象类;


若2个类继承了有些抽象类,则它必须重写抽象类的富有抽象方法,且参数必须一律。

 

★抽象类的效劳:

因为
三个类继承了某些抽象类,则它必须重写抽象类的拥有抽象方法,且参数必须一致。

具有
抽象类能够当作贰个模板、一种标准、一套安顿方针。其严厉规定其子类必须联合遵从其评释的始末结构。

 

 

■ 接口:(特点:“组合”)

 

创制 接口 的一般格局如下:

 

interface 接口名{

 

public function 方法名();

}

 

落到实处 接口 的形似格局如下:(“已毕”??★ implements n.[机] 工具)

 

class 类名 implements 接口名1,接口名2,接口名3,……{

 

}

 

注意事项:

① 接口无法平素实例化;

② 接口中的方法都不或者有宗旨 “{}” ;

③ 一个类可以兑现多个接口;

④ 接口中可以有总体性,但不可以不是常量,并且是 public
,访问接口中的常量用:接口名::常量名

⑤ 接口中的方法必须是 public (暗中认同就是 public ,并且默许为 抽象方法)。

⑥ 接口可以一而再接口,但接口不大概继承类。

⑦ 若二个类达成了某些接口,则必须兑现(重写)该接口中的全数办法。

 

接口 与 抽象类 的区别:

2个类 只可以 继承三个 抽象类;

二个类 可以 已毕三个 接口。

 

★接口的效益:

与 抽象类 的机能类似 1个接口 可以当做 一种标准、贰个模板。

与 抽象类 不一样的是,3个类 只可以三番五次自 二个抽象类,但 1个类 可以落成两个接口,即 3个类可以受到两个正规(规定)的约束。

 

诸如此类经过把种种 接口 进行不相同的组合 就足以创建出差其余科班(规定)。

 

接口体现了“高内聚、低耦合”的编程思想。

 

Leave a Comment.