OOP--Object Oriented Programming 面向对象--->达到软件工程的三个目标：重用性、灵活性、扩展性；特点:封装、继承、多态
类是具有相同属性和相同行为或功能的对象
对象是类的具体化，类是对象的抽象化，先有类，通过类得到对象，使用对象
类由成员属性(对个体描述)和成员方法(行为、功能)组成
修饰符 public 公共的
class Parson /*[修饰符] class 类名 类名：首字母大写的驼峰命名法*/
{
/*必加修饰符[成员属性]成员变量*/
public $name;
//默认值要求 标量可以 数组 null可以 常量可以
/*修饰符可选建议加上[成员方法]成员函数 首字母小写的驼峰命名法*/
public function say()
{
echo '功能处理代码';
}
public function shui()
{
echo '功能处理函数';
}
}
$p = new Parson;
$p -> say();/*访问成员方法*/
echo $p -> name;/*访问成员属性，没有$*/
class Phone
{
public $size;
public $color;
public function init($size, $color)
{
// $p = new Phone;
// $p -> size = $size;
$this -> size = $size;/*====this 代表当前对象 伪变量 在类里用自己的成员属性用this===*/
$this -> color = $color;
}
}
echo '<pre>';
$p = new Phone;
$p -> init('8G','red');
var_dump($p->color);
$p1 = new Phone;
$p1 -> init('32G','blue');
var_dump($p1->size);====================================================================
构造函数(方法) //在new的同时自动调用构造方法，给成员属性初始化，初始化可以给默认值，要传值
class Person
{
public $name;
public $age;
public $sex;
public function __construct($name='xx',$age=18,$sex='男')
{
$this -> name = $name;
$this -> age = $age;
$this -> sex = $sex;
}
}
$p1 = new Person('zs','18','nan');
$p2 = new Person('ls','19','nv');
var_dump($p1);
var_dump($p2);析构方法 当一个对象自动销毁时调用，关闭目录、关闭数据库连接、资源回收等，
栈：后放先出 队列：先进先出
class Person
{
public $name;
public $age;
public $sex;
//初始化成员属性
public function __construct($name,$age,$sex)
{
echo $this -> name = $name.'str<br />';
echo $this -> age = $age.'str<br />';
echo $this -> sex = $sex.'str<br />';
}
public function __destruct()
{
echo $this -> name.'end<br />';
echo $this -> age.'end<br />';
echo $this -> sex.'end<br />';
}
}
$p1 = new Person('zs','18','nan');
$p2 = new Person('ls','19','nv');
链式操作 在方法中返回$this
//this 链式操作 连贯操作 return 讲值返回函数调用处
class Person
{
public $name;
public function say()
{
echo '说<br />';
return $this;
}
public function eat()
{
echo '吃<br />';
return $this;
}
}
$p1 = new Person;
$p1 -> say() -> eat();
对象本身就是引用类型 "=" 相当于 "&" 相对于起别名
class A{}
$a = new A;
var_dump($a);
$c = $a;
var_dump($c);
//$a 和 $c是一个
$d = new A();
var_dump($d);
如果是2个== 同一个类实例化出来的属性和属性值相等就相等
如果是3个=== 只同一个对象才相等
==================================================================
封装： public 公共的； protected 受保护的；private 私有的；
在本类中 Y Y Y
在子类中 Y Y N
在类外边 Y N N
Fatal error: Uncaught Error: Cannot access private property Person::$age in D:\XAMPP\htdocs\1121.php:18
Stack trace:
#0 {main}
thrown in D:\XAMPP\htdocs\1121.php on line 18 这个错误可能是封装的属性是私有的private，所以报错
class Person
{
public $name;
private $age;
public $tz;
public function __construct($name,$age,$tz)
{
$this -> name = $name;
$this -> age = $age;
$this -> tz = $tz;
}
public function setAge($age)
{
if($age > 10 && $age < 80) {
$this -> age = $age;
}else{
echo '给个合理值';
}
}
public function getAge()
{
if($this -> age > 30){
return '18';
}else{
return $this -> age;
}
$this -> age = $age;
}
}
echo '<pre>';
$p = new Person('gz',9,120);
echo $p -> setAge(110);
echo $p -> getAge();魔术方法——__set($proName,$proVal) __get($proName) __isset($key) __unset()
class Person
{
private $name;
private $age;
private $sex;
private $tz;
//魔术方法 自动设置
public function __set($key, $val)
{
$this -> $key = $val;
}
//获取
public function __get($key)
{
return $this -> $key ;
}
}
$p = new Person;
//在类的外部 对私有属性 赋值 自动调用 __set方法
$p -> name = 'gz';
$p -> age = 34;
$p -> sex = '男';
$p -> tz = 60;
print_r($p);
echo '<br />';
$p1 = new Person;
$p1 -> name = 'gz';
$p1 -> age = 34;
$p1 -> sex = '男';
$p1 -> tz = 60;
print_r($p1);
echo '<hr>';
//在类的外部 获取私有属性的值 自动调用 __get方法
echo $p -> age;
//__isset($key)对不可访问属性调用isset() 或empty() 时 __isset()会被调用
//__unset($key)当对不可访问属性调用unset()时__unset()会被调用
===================================================================
继承：重复代码的提取 单继承，一个子类只能有一个父类，支持多层继承 extends
子类中定义与父类重名的成员属性会覆盖；
子类中权限只能扩大不能缩小 public > protected > private
//父类
class Person
{
public $name;
// public $age = 20;
// private $age = 20;
protected $age = 20;
public $sex;
public function say()
{
echo 'say...<br />';
}
}
//extends继承 扩展 子类 衍生类
class Js extends Person
{
public function speak()
{
echo $this -> age;
}
}
$p1 = new Js;
print_r($p1);
echo '<br />';
$p1 -> speak();继承重构 parent::__construct($name....);
class A
{
public $name;
public $age;
public function __construct($name,$age)
{
$this -> name = $name;
$this -> age = $age;
}
}
class B extends A
{
public $sex;
public function __construct($name,$age,$sex)
{
//parent代表父类，扩展父类时，如果重构构造方法，建议第一行代码↓↓↓↓↓↓↓↓
parent::__construct($name,$age);//继承A的成员属性，重写
// 或者A::__construct($name,$age);//继承A的成员属性，重写
$this -> sex = $sex;
}
}
$obj = new('a','1','woman')
var_dump($obj);final（最终版本）只能修饰类和成员方法 不能被继承 不能被重写
static静态 只能修饰成员属性和成员方法 只初始化一次 在多个对象之间共享 内存单独存储， 效率高
class A
{
//静态成员熟悉 类属性
static $name = 'aa';
//静态成员方法 类方法 成员方法没有$this， 默认就是静态成员方法，不能并存
static function test()
{
return 'aaa';
}
public function say()
{
//2种方法都可以 在本类中可以用sele::$成员属性 访问外部用 类名::$成员属性
return A::$name;
//return self::$name;
//三种类内部访问方法 类外不能用self
return self::test();
//return A::test();
//return 对象->test();
}
}
$a = new A;
echo $a -> say();const 类常量 注意大写 const NAME = 'aa'; echo A::NAME;
魔术方法
__toString() 把一个对象当字符串输出时，输出一个对象时，自动调用，必须返回一个字符串
Class A
{
public function __toString(){
return 'string';
}
}
$a = new A;
echo $a;__invoke() 把一个类当做函数调用时，自动调用
Class A
{
public function __invoke(){
echo '对象不能当函数使用';
}
}
$a = new A;
$a();__call() 当调用不存在的方法时自动调用
__callStatic() 当调用不存在的静态的的方法时自动调用，要求使用static修饰方法
<?php
Class A
{
//2个参数 1个：不存在的方法名 2个：实参 数组
public function __call($funcname, $args){
echo '当调用不存在的方法自动调用';
}
}
$a = new A;
$a -> say(1,2);
?>__sleep() 在serialize串行化时自动调用该方法
__wakeup() 在反串行化时自动调用 ，要求，类必须在
<?php
Class A
{
public function __sleep(){
return array('name','age');
}
//反串行化自动调用，要求，类必须在
public function __wakeup(){
$this -> name = 'aa';//可以修改成员属性
}
}
$a = new A;
var_dump(serialize($a));//串行化产生一个可存储的值的表示 对象---string
$obj = unserialize('O:1:"A":2:{s:4:"name";s:2:"aa";s:3:"age";i:18;}');//反串行化
var_dump($obj);
?>__clone(); 使用clone关键字时自动调用
<?php
class A{
public function __clone()
{
echo 'clone<br />';
}
}
$a = new A;
//$b = $a;取别名
$b = clone $a;
var_dump($a);
var_dump($b);
?>对象 instanceof 类
问某个对象是否由某个类实例化出来的 返回布尔值
class A{}
class B extends A{}
$b = new B;
var_dump($b instanceof A);
var_dump($b instanceof B);
//结果都是true类型约束 !is_int 例 ：function add(int $num1，$num2)//必须是int
类名约束 修饰 例 function test(A $obj) //要必须由A类实例化出来的对象
class C
{
public function say(array $arr)
{
foreach ($arr as $k => $v){
echo $v;
}
}
}
$obj = new C;
$obj -> say([1,2,3,4]);变量函数也叫(回调函数） 把一个函数名赋给一个变量，使用变量()调用，第三个参数 callable函数名
echo jsq(1,2,'he');
function he($a, $b)
{
return $a + $b;
}
function jsq($num1, $num2, $func)
{
return $func($num1, $num2); //he(1,2)
}