PHP面向对象

1.访问修饰符

1）public：可以用来修饰属性和方法，表示此属性或者方法可以在类的内部、类的派生类和类的外部使用
2）protected：可以用来修饰属性和方法，表示此属性或者方法可以在类的内部和类的派生类中使用
3）private：可以用来修饰属性和方法，表示只能在类的内部使用
4）internal：同一个程序集的对象可以访问
5）protected internal：3和4的并集，符合任意一条都可以访问

2.类的成员

类的成员分别有 属性、方法、类常量

3.定义类成员的属性

1）必须使用3p（public protected private）修饰符进行修饰
2）可以用static修饰为静态，静态属性不会随对象实例销毁
3）可以没有初始值
4）初始值不能为资源型和对象型
5）初始值不能为变量或函数调用
6）成员属性不能重复定义

4.定义类成员的方法

1）必须使用3p（public protected private）进行修饰
2）可以没有形参、返回值与程序体

5.魔术方法的作用

1）_construct（）类的构造函数，当一个类被实例化的时候自动调试
2）_destruct（）类的析构函数，脚本执行结束的时候、销毁对象的时候、重新定义对象的时候
3）_get（）读取不可访问或不存在属性时被调用
4）_set（）当给不可访问或不存在属性赋值时被调用
5）_sleep（）使用serialize时被调用（不需要保存大对象的所有数据时很有用）
6）_wakeup（）当使用unserialize时被调用，可用于做些对象的初始化操作
7）_toString（）当一个类被转化成字符串时被调用
8）_clone（）进行对象clone时被调用，用来调整对象的克隆行为
9）_call（）调用非public或不存在的方法时被调用

6.面向对象编程

6.1类的成员
类与对象：
类是抽象的，是泛指，是某一类事物的统称。
对象是具体的，是特指，是某一个具体事物的“特称”。
属性：属性本质就是变量
方法：方法的本质是函数
6.1-1属性（变量）
下面的类定义了属性

class Person
{
    // 变量在类的内部叫做属性，在类的外部叫做变量
    public $name = "yhb";
    public $age;
    public $weight;
    public $height;
    public $gender;
}

类中的属性为什么可以不设置初始值，而是等到创建对象之后再为属性赋值

/**
 * 以class开头
 * 类名首字母大写
 */

class Person
{
    // 变量在类的内部叫做属性，在类的外部叫做变量
    public $name = "yhb";
    public $age;
    public $weight;
    public $height;
    public $gender;
}
/*对象实例化
使用运算符 new 创建类的对象
 */
$p1 = new Person();
// 为对象中的属性赋值
$p1->name='刘建金';
$p1->age=100;
$p1->weight=170;
$p1->height=120;
$p1->gender='男';
echo '<pre>';
print_r($p1);
echo '</pre>';
$p2 = new Person();
$p2->name='李建';
$p2->age=18;
$p2->weight=250;
$p2->height=120;
$p2->gender='男';
echo '<pre>';
print_r($p2);
echo '</pre>';

6.1-2方法（函数）
类中的方法可以使用类中的属性，但是要使用 $this 引用

<?php
/**
 * 以class开头
 * 类名首字母大写
 */

class Person
{
    // 变量在类的内部叫做属性，在类的外部叫做变量
    public $name = "yhb";
    public $age;
    public $weight;
    public $height;
    public $gender;
    // 函数再类的内部叫做方法，再类的外部叫做函数
    public function speak()
    {
        echo "大家好，我叫".$this->name."，是一个新人类，我的身高是".$this->height."，
        体重是".$this->weight."，我是".$this->gender;
    }
}
/*对象实例化
使用运算符 new 创建类的对象
 */
$p1 = new Person();
// 为对象中的属性赋值
$p1->name = '刘金';
$p1->age = 100;
$p1->weight = 170;
$p1->height = 120;
$p1->gender = '男';
// 调用对象中的方法
$p1->speak();
echo '<pre>';
print_r($p1);
echo '</pre>';

6.1-3类常量
和变量相对，变量一经赋值后，时可以变化的，但是常量一经赋值后是不可变化的
说明：在类中的方法中访问类常量，需要使用self：：常量名称的方法访问
在类的外部可以通过 对象名称：：常量名称 或者类名：：常量名称的访问常量

<?php
class School{
  public $students=100;
  public $name;
  public $tech=100;//受保护的技术资料
  const ADDRESS='金银路1号';
  // 定义构造方法，为 students 和 name 属性赋值
  public function __construct($students,$name)
  {
    $this->name=$name;
    $this->students=$students;
  }
  // 自定义方法，负责介绍学校
  public function introduce(){
    echo '学校简介：名称：'.$this->name.',
    本校有'.$this->students.'名学生,本校地址为:'.self::ADDRESS;
  }
}
$school=new School(10000,'河北软件职业技术学院');
$school->introduce();

6.2静态属性
静态属性，静态方法，静态类
属性按性质又可分为：实例属性，静态属性。
方法按性质又可分为：实例方法，静态方法，魔术方法。
实例属性和实例方法统称为实例成员；
静态属性和静态方法统称为静态成员。
6.2-1静态属性
静态属性：第一在类中使用static修饰，
第二在类中使用self：：属性名称的方式访问静态属性，
第三在类的外部使用 对象：：属性名称 或者类型：：属性名称 的方式访问
6.2-2静态方法
在类中使用static修饰，
静态方法不能访问非静态的属性和方法，反之则可以，
在类的外部使用 对象：：属性名称 或者类型：：属性名称 的方式访问
6.3单例模式
下面是普通的类，可以创建多个实例，但是单例模式一个类只能够创建一个实例，因为有的时候，创建多个实例是对资源的浪费
第一、定义将构造方法定义为private，这样在类的外部就无法通过new 的方式创建类的对象
第二、定义公共的静态的方法，提供给调用者，调用者通过此方法获取类的对象
第三、在静态公共方法中，判断是否已经创建过类的对象了
第四、添加一个禁止克隆的方法

<?php
class A
{
    private static $obj = null;
    public $name;
    public $age;
    /**
     * 通过将构造函数设置为private，禁止用户在类的外部通过构造函数创建类的对象
     */
    private function __construct()
    {
    }
    // 禁止克隆
    private function __clone()
    {
    }
    /**
     * 提供一个自定义方法，让用户调用此方法创建类的对象
     * 但是因为方法是我们自己定义的，所以在用户调用此方法创建对象时，
     * 我们可以保证只能够创建一个
     */
    public static function getObj()
    {
        if (self::$obj == null) {
            self::$obj = new A();
        }
        return self::$obj;
    }
}
$a1 = A::getObj();
$a2 = A::getObj();
$a3 = A::getObj();

var_dump($a1);
echo '<br>';
var_dump($a2);
echo '<br>';
var_dump($a3);

构造函数 − 主要用来在创建对象时初始化对象， 即为对象成员变量赋初始值，总与new运算符一起使用在创建对象的语句中。构造函数是一种特殊的方法。主要用来在创建对象时初始化对象， 即为对象成员变量赋初始值，在创建对象的语句中与 new 运算符一起使用。
析构函数 − 析构函数(destructor) 与构造函数相反，当对象结束其生命周期时（例如对象所在的函数已调用完毕），系统自动执行析构函数。析构函数往往用来做"清理善后" 的工作（例如在建立对象时用new开辟了一片内存空间，应在退出前在析构函数中用delete释放）。

7.面向对象三大特征

7.1封装
封装可以最大限度的保护类的内部细节
也就是说尽量不让类的调用者知道类的内部都有哪些属性，哪些方法
目的：使类更加安全

class Book{
  private $name;
  private $author;
  private $price;

  /**
   * 通过构造方法为私有属性赋值
   */
  public function __construct($name,$author,$price)
  {
    $this->name=$name;
    $this->author=$author;
    $this->price=$price;
  }
}
$p1=new Book("庆余年",'猫腻','20');

步骤：
a.将属性设置为private
b.通过构造方法为private属性赋值
c.通过公共方法获取私有属性的值
7.2继承
自己没有，别人，可以拿来，就是继承
子类与父类的属性与方法
子类继承父类的所有内容，但父类中的private部分不能直接访问
子类中新增加的属性和方法是对父类的扩展
子类中定义的与父类同名的属性是对父类属性的覆盖，同名的方法也是对父类方法的覆盖

class Book{
  private $name;
  private $author;
  private $price;

  /**
   * 通过构造方法为私有属性赋值
   */
  public function __construct($name,$author,$price)
  {
    $this->name=$name;
    $this->author=$author;
    $this->price=$price;
  }
}
$p1=new Book("庆余年",'猫腻','20');

概念解释
父类：被继承的类叫做父类，也叫基类
字类，继承别的类的类叫做字类，也叫派生类
7.3多态
当父类引用指向子类实例的时候，由于子类对父类的方法进行了重写，父类引用在调用该方法的时候表现出的不同，称为多态
多态性是指在父类中定义的属性或行为被子类继承之后，
可以具有不同的数据类型或表现出不同的行为。这使得同一个属性或行为在父类及其各个子类中具有不同的语义。
就是说同一种方法在子类与父类中执行的结果不同。
条件：
a.要有继承
b.父类引用指向子类实例
c.要有重写
d.调重写的方法

class A
{
    public function f1()
    {
        echo 'f1';
    }
}
class B extends A
{
    public function f1()
    {
        echo '字类中的f1';
    }
}
$b1 = new B();
/**
 * 字类中如果又与父类同名的方法，则会覆盖父类中的方法
 */
$b1->f1();

8. PDO 操作数据库

pdo 与 mysqli 一样，也是php的一个扩展，但是其能够连接多个数据库
8.1 增删改
// 执行 CUD
// $sql=“insert into news(title,create_time) values(‘aa’,now())”;
// $sql=“update news set title=‘bb’ where id>=114”;
// $sql=“delete from news where id>=114”;
// $numb=$pdo->exec($sql);
// echo $numb;

8.2 查询
8.2-1 逐行读取
逐行读取需要调用 fetch 方法，每调用一次，读取1行

<?php
$dsn="mysql:host=localhost;dbname=test";
$user="root";
$pwd="root";

$pdo=new PDO($dsn,$user,$pwd);
// 执行查询
$sql="select * from news";
// 查询成功，返回 PDOStatement对象，失败返回false
$res=$pdo->query($sql);
/**
 * fetch 方法参数
 * 1）PDO::FETCH_ASSOC：表示关联数组
 * 2) PDO::FETCH_NUM：返回索引数组
 * 3) PDO::FETCH_OBJ：返回对象
 */
while($row=$res->fetch(PDO::FETCH_OBJ)){
  echo '<pre>';
  print_r($row);
  echo "</pre>";  
}

说明：
fetch 方法参数
PDO::FETCH_ASSOC：表示关联数组
PDO::FETCH_NUM：返回索引数组
PDO::FETCH_OBJ：返回对象
8.2-2 读取所有行

$rows=$res->fetchAll(PDO::FETCH_ASSOC);
echo '<pre>';
print_r($rows);
echo '</pre>';

8.2-3 读取指定列

 // 读取指定列
echo $res->fetchColumn(1);
echo $res->fetchColumn(1);
echo $res->fetchColumn(1);

8.3 预处理
预处理语句是预先将一个sql语句发送到数据库服务器，执行其他sql语句只是修改预处理语句里对应的参数
简单的说，就是将sql语句强制一分为二：第一部分前面相同的命令和结构部分，第二部分为后面可变的数据部分。预处理语句可以减轻服务器的压力
8.3-1 SQL注入
SQL注入就是通过SQL命令插入到web表单提交或输入域名或页面请求的查询字符串中，最终达到欺骗服务器执行而已的SQL命令的目的
8.3-2 增加数据

<?php
$dsn="mysql:host=localhost;dbname=test";
$user="root";
$pwd="root";

$pdo=new PDO($dsn,$user,$pwd);
// 创建预处理语句，使用命名参数
$pre=$pdo->prepare("insert into news(title,create_time) values(:title,:create_time)");
$title='goodbye';
$create_time='2019-01-01';
// 替换占位符
$pre->bindParam(':title',$title);
$pre->bindParam(':create_time',$create_time);

// 创建预处理语句:使用占位符（?）
/*$pre=$pdo->prepare("insert into news(title,create_time) values(?,?)");
$title='hello';
$create_time='2019-01-01';
// 替换占位符
$pre->bindParam(1,$title);
$pre->bindParam(2,$create_time);
*/
$numbs=$pre->execute();
var_dump($numbs);

8.3-3修改数据

<?php
$dsn="mysql:host=localhost;dbname=test";
$user="root";
$pwd="root";

$pdo=new PDO($dsn,$user,$pwd);
// 创建预处理语句，使用命名参数
$sql="update news set title=? where id=?";
$pre=$pdo->prepare($sql);
$title='aljdslfasdf';
$id=118;
// 替换占位符
$pre->bindParam(1,$title);
$pre->bindParam(2,$id);

$numbs=$pre->execute();
var_dump($numbs);

8.3-4 查询

<?php
$dsn="mysql:host=localhost;dbname=test";
$user="root";
$pwd="root";

$pdo=new PDO($dsn,$user,$pwd);
// 创建预处理语句，使用命名参数
$sql="select * from news where id>:id";
$pre=$pdo->prepare($sql);

$id=50;
// 替换占位符
$pre->bindParam(":id",$id);

$pre->execute();
$res=$pre->fetchAll();
var_dump($res);