专门做招商的网站,哈尔滨建设网站公司,万能网盘搜索引擎入口,十堰网站建设是什么1.2 面向对象介绍
1.2.1 介绍
面向对象是一个编程思想。编程思想有面向过程和面向对象
面向过程#xff1a;编程思路集中的是过程上
面向对象#xff1a;编程思路集中在参与的对象
以去饭馆吃饭为例#xff1a;
面向过程#xff1a;点菜——做菜——上菜——吃饭—…1.2 面向对象介绍
1.2.1 介绍
面向对象是一个编程思想。编程思想有面向过程和面向对象
面向过程编程思路集中的是过程上
面向对象编程思路集中在参与的对象
以去饭馆吃饭为例
面向过程点菜——做菜——上菜——吃饭——结账——收拾
面向对象服务员厨师客人
1.2.2 面向对象的好处
多人合作方便减少代码冗余灵活性高代码的可重用性发挥到极致可扩展性强
多学一招
OOP面向对象编程Object Oriented Programming面向对象编程
OOA: 面向对象分析(Object-Oriented Analysis,OOA)
OOD: 面向对象设计Object-Oriented DesignOOD
1.3 类和对象
1、对象是具体存在的事物对象是由属性变量和方法函数组成的 2、类是具有相同属性和行为的一组对象的集合
分析做菜动作——厨师对象——厨师类 结论我们在开发的时候先写类通过类创建对象然后调用对象的属性和方法实现功能。 类——对象——调用成员
注意一个类可以创建多个对象 小结
1、对象是由属性和方法组成的
2、类是所有对象的相同属性和方法的集合
3、在开发的时候先写类通过类创建对象通过对象调用方法和属性
4、一个类可以创建多个对象 1.4 在PHP中实现类和对象
1.4.1 创建类
语法
class 类名{//属性//方法//常量
}
类是由属性、方法、常量组成的也可以说
类成员有属性、方法、常量 类名的命名规则
以字母、下划线开头后面跟的是字母、数字、下划线不能用PHP关键字做类名类名不区分大小写变量名区分关键字、类名不区分大小写类名用帕斯卡命名法大驼峰 单词的首字母大写
?php
class Student {
}1.4.2 对象实例化
通过new关键字来实例化对象。
?php
//定义类
class Student {}
//实例化对象
$stu1new Student();
$stu2new Student; //小括号可以省略
var_dump($stu1,$stu2); //object(Student)#1 (0) { } object(Student)#2 (0) { } 1.4.3 对象的比较
注意对象的传递是地址传递
相等结构和保存的值一样就相等 全等指向同一个对象才是全等。
?php
//定义类
class Student {}
//实例化对象
$stu1new Student();
$stu2new Student;
$stu3$stu2; //对象传递的是地址
//var_dump($stu1,$stu2,$stu3); //object(Student)#1 (0) { } object(Student)#2 (0) { } object(Student)#2 (0) { }
//对象比较
var_dump($stu1$stu2); //bool(true) ,比较对象的结构
echo br;
var_dump($stu1$stu2); //bool(false) $stu1和$stu2是否是同一个对象
echo br;
var_dump($stu2$stu3); //bool(true) $stu2和$stu3是同一个对象
1.5 属性
属性本质就是变量
通过-调用对象的成员 对象名-属性名 对象名-方法名()
?php
//定义类
class Student {public $name; //属性public $add地址不详; //属性
}
//实例化对象
$stunew Student();
//print_r($stu); //Student Object ( [name] [add] 地址不详 )
//操作属性
//1、给属性赋值
$stu-nametom;
$stu-add北京;//2、获取属性的值
echo 姓名.$stu-name,br; //姓名tom
echo 地址.$stu-add,br; //地址北京//3、添加属性
$stu-age20;
print_r($stu); //Student Object ( [name] tom [add] 北京 [age] 20 )
echo br;
//4、删除属性
unset($stu-add);
print_r($stu); //Student Object ( [name] tom [age] 20 )
1.6 方法
方法的本质就是函数
?php
class Student {//定义方法public function show() {echo 这是show方法br;}//public可以省略如果省略默认就是publicfunction test() {echo 这是test方法br;}
}
$stunew Student;
$stu-show(); //调用方法
$stu-test();多学一招
1、方法前面public是可以省略的如果省略默认就是public的。
2、属性前面的public不能省略
1.7 访问修饰符
用来控制成员的访问权限
修饰符描述public公有的在类的内部和外部都能访问private私有的只能在类的内部访问protected受保护的在整个继承链上访问
**多学一招**一般来说属性都用私有的通过公有的方法对私有的属性进行赋值和取值。
作用保证数据的合法性
?php
//访问修饰符
class Student {private $name; //私有属性private $sex; //私有属性//通过公有的方法对私有的属性进行赋值public function setInfo($name,$sex) {if($sex!男 $sex!女){echo 性别必须是男或女;exit;}$this-name$name; //$this表示当前对象$this-sex$sex;}//显示信息public function getInfo() {echo 姓名.$this-name,br;echo 性别.$this-sex,br;}
}
//实例化
$stunew Student;
$stu-setInfo(tom,男);
$stu-getInfo();
echo hr;
$stu2new Student;
$stu2-setInfo(berry,女);
$stu2-getInfo();提示$this表示调用当前方法的对象
运行结果 1.8 类和对象在内存中的分布
对象的本质是一个复杂的变量类的本质是一个自定义的复杂数据类型栈区运行速度快体积小保存基本类型堆区运行速度稍慢体积大保存复杂类型实例化的过程就是分配内存空间的过程对象保存在堆区将堆区的地址保存到栈区。
分析如下代码的结构
?php
class Student {public $name;public $sex;public function show() {}
}$stu1new Student;
$stu2new Student;$stu1-show();示意图 1.9 封装
封装就是有选择性的提供数据
通过访问修饰符来实现封装
1.10 构造方法
1.10.1 介绍
构造方法也叫构造函数当实例化对象的时候自动执行。 语法
function __construct(){
}
注意前面是两个下划线例题
?php
class Student {public function __construct() {echo 这是构造方法br;}
}
new Student(); //这是构造方法
new Student(); //这是构造方法注意在其他语言里与类名同名的函数是构造函数在PHP中不允许这种写法。
class Student {//和类名同名的方法是构造方法PHP中不建议使用public function Student() {echo 这是构造方法br;}
}
/*
Deprecated: Methods with the same name as their class will not be constructors in a future version of PHP; Student has a deprecated constructor in F:\wamp\www\6-demo.php on line 2
这是构造方法
*/1.10.2 构造函数作用初始化成员变量
?php
class Student {private $name;private $sex;//构造函数初始化成员变量public function __construct($name,$sex) {$this-name$name;$this-sex$sex;}//显示信息public function show() {echo 姓名{$this-name}br;echo 性别{$this-sex}br;}
}
//实例化
$stunew Student(tom,男);
$stu-show();
//运行结果
/*
姓名tom
性别男
*/注意构造函数可以带参数但不能有return。
.11 析构方法
1.11.1 介绍
当对象销毁的时候自动调用
语法
function __destruct(){
}脚下留心析构函数不可以带参数
例题
?php
class Student {private $name;//构造方法public function __construct($name) {$this-name$name;echo {$name}出生了br;}//析构方法public function __destruct() {echo {$this-name}销毁了br;}
}
//测试
$stu1new Student(tom);
$stu2new Student(berry);
$stu3new Student(ketty);
echo hr;运行结果 1.11.2 计算机的内存管理
计算机内存管理方式先进先出先进后出
先进先出的内存管理方式一般用在业务逻辑中比如秒杀、购票等等 先进后出是计算机的默认内存管理方式 1.11.3 思考题
思考题1
?php
class Student {private $name;//构造方法public function __construct($name) {$this-name$name;echo {$name}出生了br;}//析构方法public function __destruct() {echo {$this-name}销毁了br;}
}
//测试
$stu1new Student(tom);
$stu2new Student(berry);
$stu3new Student(ketty);
unset($stu2);
echo hr;
/*
tom出生了
berry出生了
ketty出生了
berry销毁了ketty销毁了
tom销毁了
*/思考题2
?php
class Student {private $name;//构造方法public function __construct($name) {$this-name$name;echo {$name}出生了br;}//析构方法public function __destruct() {echo {$this-name}销毁了br;}
}
//测试
new Student(tom);
new Student(berry);
new Student(ketty);
/*
tom出生了
tom销毁了
berry出生了
berry销毁了
ketty出生了
ketty销毁了
*/思考题3
?php
class Student {private $name;//构造方法public function __construct($name) {$this-name$name;echo {$name}出生了br;}//析构方法public function __destruct() {echo {$this-name}销毁了br;}
}
//测试
$stunew Student(tom);
$stunew Student(berry);
$stunew Student(ketty);
/*
tom出生了
berry出生了
tom销毁了
ketty出生了
berry销毁了
ketty销毁了
*/
1.12 继承
1.12.1 继承介绍
继承使得代码具有层次结构子类继承了父类的属性和方法实现了代码的可重用性。使用extends关键字实现继承父类和子类是相对的
语法
class 子类 extends 父类{
}例题
?php
//父类
class Person {public function show() {echo 这是人类br;}
}
//子类继承父类
class Student extends Person {
}
//测试
$stunew Student;
$stu-show(); //这是人类执行过程
第一步在Student类中查找show()如果找到就调用找不到就到父类中查找
第二步在Person类中查询show()
1.12.2 子类中调用父类成员
?php
//父类
class Person {public function show() {echo 这是人类br;}
}
//子类
class Student extends Person {public function test() {//方法一/*$personnew Person();$person-show(); //这是人类*///方法二$this-show(); //这是人类}
}
//测试
$stunew Student;
$stu-test();小结
1、方法一通过实例化父类调用父类的成员
2、方法二通过$this关键字调用父类的成员
1.12.3 protected
protected受保护的在整个继承链上使用
例题
//例题一
?php
class A {protected $num10; //在整个继承链上访问
}
class B extends A { public function getNum() {echo $this-num;}
}
//测试
$objnew B(); //整个继承链上有A和B
$obj-getNum(); //10//例题二
?php
class A {public function getNum() {echo $this-num;}
}
class B extends A {protected $num10;
}
//测试
$objnew B(); //整个继承链上有A和B
$obj-getNum(); //10//例题三
?php
class A {public function getNum() {echo $this-num;}
}
class B extends A {protected $num10;
}
//测试
$objnew A(); //整个继承链上只有A
$obj-getNum(); //Notice: Undefined property: A::$num 1.12.4 继承中的构造函数
规则
1、如果子类有构造函数就调用子类的如果子类没有就调用父类的构造函数。2、子类的构造函数调用后默认不再调用父类的构造函数通过类名调用父类的构造函数
类名::__construct()例题
?php
class Person {//父类的构造函数public function __construct() {echo 这是父类br;}
}
class Student extends Person {//子类的构造函数public function __construct() {Person::__construct(); //通过父类的名字调用父类的构造函数parent::__construct(); //parent表示父类的名字echo 这是子类br;}
}
//测试
new Student();注意parent关键字表示父类的名字可以降低程序的耦合性
例题给父类传递参数
?php
class Person {protected $name;protected $sex;//父类的构造函数public function __construct($name,$sex) {$this-name$name;$this-sex$sex;}
}
class Student extends Person {private $score;//子类的构造函数public function __construct($name,$sex,$score) {parent::__construct($name,$sex); //调用父类构造函数并传递参数$this-score$score;}//显示信息public function getInfo() {echo 姓名{$this-name}br;echo 性别{$this-sex}br;echo 成绩{$this-score};}
}
//测试
$stunew Student(tom,男,88);
$stu-getInfo();
/*
姓名tom
性别男
成绩88
*/1.12.5 $this详解
t h i s 表 示 当 前 对 象 的 引 用 也 就 是 是 或 this表示当前对象的引用也就是是或this表示当前对象的引用也就是是或this保存的当前对象的地址
?php
class A {public function __construct() {var_dump($this);}
}
class B extends A {}
new A(); //object(A)#1 (0) { }
echo br;
new B(); //object(B)#1 (0) { } 1.12.6 多重继承
PHP不允许多重继承因为多重继承容易产生二义性 如何实现C继承A和B使用继承链 1.13 多态
多态多种形态。
多态分为两种方法重写和方法重载
1.13.1 方法重写
子类重写了父类的同名的方法
?php
//父类
class Person {public function show() {echo 这是父类br;}
}
//子类
class Student extends Person {//子类重写了父类的同名方法public function show() {echo 这是子类br;}
}
//测试
$stunew Student;
$stu-show(); //这是子类注意事项
子类的方法必须和父类的方法同名参数个数要一致子类修饰的不能比父类更加严格
1.13.2 方法重载
在同一个类中有多个同名的函数通过参数的不同来区分不同的方法称为方法重载
注意PHP不支持方法重载但是PHP可以通过其他方法来模拟方法重载。
1.14 私有属性继承和重写
私有属性可以继承但不能重写。
?php
class A {private $namePHP;public function showA() {//var_dump($this); //object(B)#1 (2) { [name:B:private] string(4) Java [name:A:private] string(3) PHP } echo $this-name,br; //PHP}
}
class B extends A {private $nameJava;public function showB() {//var_dump($this); //object(B)#1 (2) { [name:B:private] string(4) Java [name:A:private] string(3) PHP } echo $this-name,br; //Java}
}
$objnew B();
$obj-showA();
$obj-showB();
/*分析
showA()和showB()中的$this都表示B的对象B中继承了A的私有属性所以B中有两个$name.
在showA()中只能访问A中的$name不能访问B中的$name
在showB()中只能访问B中的$name,不能访问A中的$name
*/练习一
?php
class A {protected $nametom; public function showA() {echo $this-name,br;}
}
class B extends A {public $nameberry;public function showB() {echo $this-name,br;}
}
//测试
$objnew B();
$obj-showA(); //berry
$obj-showB(); //berry/*
分析B中将A的$name重写所以$obj中只有一个$name,($nameberry),不管$this在哪个方法中访问就只能访问这个$name
*/练习二
?php
class A {private $nametom; public function showA() {echo $this-name,br;}
}
class B extends A {public $nameberry;public function showB() {echo $this-name,br;}
}
//测试
$objnew B();
$obj-showA(); //tom
$obj-showB(); //berry
/*
分析
$obj中有两个$name,一个是私有的一个是公有的
在showA()中既能访问私有的$name,也能访问公有的$name,但是私有的比公有的权限高所以输出tom
在showB()中不能访问私有的$name,只能访问公有的$name所以输出berry
*/
1.15 方法修饰符
方法修饰符有static、final、abstract
1.15.1 static【静态的】
static修饰的属性叫静态属性、static修饰的方法叫静态方法静态成员加载类的时候分配空间程序执行完毕后销毁静态成员在内存中就一份。调用语法 类名::属性 类名::方法名()
?php
class Person {public static $add北京; // 修饰符之间没有顺序static public function show() {echo 这是一个静态的方法br;}
}
echo Person::$add,br; //北京
Person::show(); //这是一个静态的方法练习统计在线人数
?php
class Student {private static $num0; //静态变量在内存中就一份public function __construct() {self::$num; //self表示所在类的类名}public function __destruct() {self::$num--;}public function show() {echo 总人数是.self::$num,br;}
}
//测试
$stu1new Student;
$stu2new Student;
$stu3new Student;
$stu2-show(); //总人数是3
unset($stu2);
$stu3-show(); //总人数是2**注意**self表示所在类的类名使用self降低耦合性
静态成员也可以被继承
?php
class Person {public static $add中国;public static function show() {echo 这是人类br;}
}
//继承
class Student extends Person {
}
//测试
echo Student::$add,br; //中国 通过子类名称访问父类的静态成员
Student::show(); //这是人类静态延时绑定
static表示当前对象所属的类
?php
class Person {public static $type人类;public function show1() {//var_dump($this); //object(Student)#1 (0) { } //echo self::$type,br; //人类echo static::$type,br; //学生 延时绑定}
}
class Student extends Person {public static $type学生;public function show2() {//var_dump($this); //object(Student)#1 (0) { } //echo self::$type,br; //学生echo static::$type,br; //学生}
}
//测试
$objnew Student();
$obj-show1();
$obj-show2();小结
1、static在内存中就一份在类加载的时候分配空间
2、如果有多个修饰符修饰符之间是没有顺序的
3、self表示所在类的类名
4、static表示当前对象所属的类
5、static有两个作用第一表示静态的第二表示类名
1.15.2 final【最终的】
final修饰的方法不能被重写
final修饰的类不能被继承 作用
1、如果一个类确定不被继承一个方法确定不会被重写用final修饰可以提高执行效率。
2、如果一个方法不允许被其他类重写可以用final修饰。
1.15.3 abstract【抽象的】
abstract修饰的方法是抽象方法修饰的类是抽象类只有方法的声明没有方法的实现称为抽象方法一个类中只要有一个方法是抽象方法这个类必须是抽象类。抽象类的特点是不能被实例化子类继承了抽象类就必须重新实现父类的所有的抽象方法否则不允许实例化类中没有抽象方法也可以声明成抽象类用来阻止类的实例化
例题
?php
//抽象类
abstract class Person {public abstract function setInfo(); //抽象方法public function getInfo() {echo 获取信息br;}
}
//继承
class Student extends Person {//重写实现父类的抽象方法public function setInfo() {echo 重新实现父类的抽象方法br;}
}
//测试
$stunew Student;
$stu-setInfo(); //重新实现父类的抽象方法
$stu-getInfo(); //获取信息抽象类的作用
1定义命名规范 2、阻止实例化如果一个类中所有的方法都是静态方法这时候没有必要去实例化可以通过abstract来阻止来的实例化。
1.16 类常量
类常量是const常量
?php
class Student {//public const ADD //7.1以后才支持访问修饰符const ADD地址不详;
}
echo Student::ADD;问题define常量和const常量的区别
答const常量可以做类成员define常量不可以做类成员。
问题常量和静态的属性的区别
答相同点都在加载类的时候分配空间
不同点常量的值不可以更改静态属性的值可以更改
1.17 接口interface
1.17.1 接口
如果一个类中所有的方法是都是抽象方法那么这个抽象类可以声明成接口接口是一个特殊的抽象类接口中只能有抽象方法和常量接口中的抽象方法只能是public可以省略默认也是public的通过implements关键字来实现接口不能使用abstract和final来修饰接口中的抽象方法。
?php
//声明接口
interface IPerson {const ADD中国;function fun1();function fun2();
}
//接口实现
class Student implements IPerson {public function fun1() {}public function fun2() {}
}
//访问接口中的常量
echo IPerson::ADD;1.17.2 接口的多重实现
类不允许多重继承但是接口允许多重实现。
?php
interface IPic1 {function fun1();
}
interface IPic2 {function fun2();
}
//接口允许多重实现
class Student implements IPic1,IPic2 {public function fun1() {}public function fun2() {}
}注意
1、在接口的多重实现中如果有同名的方法只要实现一次即可
2、类可以继承的同时实现接口
class Student extends Person implements IPIc1,IPic1{}
1.18 匿名类
这是了解的内容PHP7.0支持
?php
$stunew class {public $nametom;public function __construct() {echo 构造函数br;}
};
echo $stu-name;
/*运行结果
构造函数
tom
*/小结
1、如果类只被实例化一次就可以使用匿名类
2、好处在执行的过程中类不占用空间
1.19 方法绑定
这是了解的内容PHP7.0支持
作用将方法绑定到对象上并调用
语法
闭包-call(对象)将闭包绑定到对象上,并调用在PHP中匿名函数称为闭包
例题
?php
$langen;
//类
class Student{
}
//匿名函数
if($langch){$funfunction(){echo 我是一名学生;};
}else{$funfunction(){echo i am a studnet;};
}
//绑定
$stunew Student;
$fun-call($stu); //i am a studnet
1.20 自动加载类
在项目开发中因为一个文件中只能写一个类并且在执行过程中会有很多的类参与如果一个一个的加载很麻烦所以就需要一个机制实现在PHP执行过程中自动加载需要的类。
1.20.1 类的规则
一个文件中只能放一个类必须文件名和类名同名必须类文件以.class.php结尾不是必须
1.20.2 手动加载类
1、创建Goods.class.php页面
?php
//商品类
abstract class Goods {protected $name;final public function setName($name) {$this-name$name; }public abstract function getName();
}2、创建Book.class.php页面
?php
//图书类
class Book extends Goods {public function getName() {echo 《{$this-name}》br;}
}3、创建Phone.class.php页面
?php
//电话类
class Phone extends Goods {public function getName() {echo $this-name,br;}
}4、在PHP页面上加载类文件
?php
require ./Goods.class.php; //手动加载类文件
require ./Book.class.php; //手动加载类文件
require ./Phone.class.php; //手动加载类文件
//测试
$booknew Book();
$book-setName(面向对象编程);
$phonenew Phone();
$phone-setName(苹果6s);
$book-getName();
$phone-getName();运行结果 1.20.3 自动加载类
当缺少类的时候自动的调用__autoload()函数并且将缺少的类名作为参数传递给__autoload()。
?php
/*
*作用自动加载类
*param $class_name string 缺少的类名
*/
function __autoload($class_name) {require ./{$class_name}.class.php;
}
//测试
$booknew Book();
$book-setName(面向对象编程);
$phonenew Phone();
$phone-setName(苹果6s);
$book-getName();
$phone-getName();注意__autoload()函数在PHP7.2以后就不支持了。
1.20.4 注册加载类
通过spl_autoload_register()注册__autoload()函数
?php
//方法一
/*
//加载类函数
function loadClass($class_name) {require ./{$class_name}.class.php;
}
//注册加载类函数
spl_autoload_register(loadClass);
*///方法二
spl_autoload_register(function($class_name){require ./{$class_name}.class.php;
});//测试
$booknew Book();
$book-setName(面向对象编程);
$phonenew Phone();
$phone-setName(苹果6s);
$book-getName();
$phone-getName();1、spl_autoload_register()可以注册多个自动加载函数
?php
function load1($class) {require ./{$class}.class.php;
}
function load2($class) {require ./{$class}.php;
}
function load3($class) {require ./{$class}.fun.php;
}
spl_autoload_register(load1);
spl_autoload_register(load2);
spl_autoload_register(load3);2、PHP5.1以后就开始支持此函数。
1.20.5 类文件存储不规则的加载方法
将类名和文件地址做一个映射组成一个关联数组。
$maparray(//类名 类文件地址Goods ./aa/Goods.class.php,Book ./bb/Book.class.php,Phone ./cc/Phone.class.php
);代码如下
?php
spl_autoload_register(function($class_name){//类名和文件地址映射成一个关联数组$maparray(Goods ./aa/Goods.class.php,Book ./bb/Book.class.php,Phone ./cc/Phone.class.php);//在映射数组中找到就包含if(isset($map[$class_name]))require $map[$class_name];
});
//测试
$booknew Book();
$book-setName(面向对象编程);
$phonenew Phone();
$phone-setName(苹果6s);
$book-getName();
$phone-getName();在项目中绝大部分都是规则存储的不规则的比较少。
