php基础干货

最新推荐文章于 2024-07-25 20:29:32 发布

weixin_34250709

最新推荐文章于 2024-07-25 20:29:32 发布

阅读量80

点赞数

文章标签： php 数据库

原文链接：https://juejin.im/post/5a438658f265da430f326214

版权

php基础知识总结

php 命名规则

1.类的命名

1.使用大写字母作为词的分割，其他的字母均使用小写。
2.名字的首字母使用大写。
3.不要使用下划线('_')。

2. 类属性命名

1.属性命名应该以字符‘m’为前缀<br 2.前缀‘m’后采用与类命名一致的规则。
3.m’总是在名字的开头起修饰作用，就像以‘r’开头表示引用一样。
如：mValue、mLongString等

3. 方法的命名

方法的作用都是执行一个动作，达到一个目的。所以名称应该说明方法是做什么的。一般名称的前缀都是有第一规律的，如is（判断）、get（得到），set（设置）。
方法的命名第一个单词的首字母小写，其后单词的首字母大写

面向对象的理解

什么是面向对象

面向对象编程（Object Oriented Programming,OOP,面向对象程序设计）是一种计算机编程架构，OOP的一条基本原则是计算机程序是由单个能够起到子程序作用的单元或对象组合而成，OOP达到了软件工程的三个目标：重用性、灵活性和扩展性。为了实现整体运算，每个对象都能够接收信息、处理数据和向其它对象发送信息。

什么是类?

类的概念：类是具有相同属性和服务的一组对象的集合。它为属于该类的所有对象提供了统一的抽象描述，其内部包括属性和服务两个主要部分。在面向对象的编程语言中，类是一个独立的程序单位，它应该有一个类名并包括属性说明和服务说明两个主要部分。

引入例子女娲人身蛇尾，用女娲造人引出类和实例：女娲造人前先思考人的形象然后再造人

所以：人的形象是抽象的，用来说明人的特点；而每一个人都是具体的，且符合人的形象
类：所有对象共同点的一个抽象！
对象:就是根据说明制造出来的具体对象
类有什么? 属性(比如人:身高,体重,姓名)
能干什么? 功能(说话,吃饭)
用变量和函数分别模拟属性和功能

面向对象中，方法即是函数；属性即是变量，只是面相对象中一般说方法和属性

new 类名 (); // 直接产生一个对象并返回该对象
$a = new 类名; // 那么a 对象包含所有的属性
要调用对应的属性值可以 $a -> name (name不用$)；要调用对应的方法 $a -> say()

 

    class Person
    {
        // 1.成员属性 变量
        public $name = '小明';
        protected $age = 18;
        private $money = 100;
        // 2.成员方法 函数 public 可以省略
        // 3.修饰符  public 公有 private私有 protected受保护的
        public function speak($wrods = 'hello')
        {
            return 'i can speack' . $wrods . '我今年' . $this->age . '岁了' . '我的人民币' . $this->money . '元';
        }
    
        function fun()
        {
            return $this->job() . '我的' . $this->addr();
        }
        protected function job()
        {
            return '我的工作比较保密';
        }
        private function addr()
        {
            return '我不会告诉你的';
        }
    }
    // 类的实例化继承
     $p = new Person();
    复制代码

魔术方法

php 独有的,其他编程语言没有的. 封装好的一些具有固定功能的方法
特点:1. php 面向对象所有的魔术犯法__下划线开头
特点:2 php魔术方法在满足某个特定条件下,将会自动调用

构造函数

__construct() , 注意前面是两个下划线；当new对象（产生对象）,根据方法名同名的方法也会当对象被创建的时候也会被自动调用
(构造函数在创建对象的时候被调用)
1.构造函数可以接受参数，能够在创建对象时赋值给对象属性
2.构造函数可以调用类方法或其他函数
3.构造函数可以调用其他类的构造函数

析构函数

__destruct()在对象被销毁的时候调用的函数
如何销毁对象：
1、显式销毁，unset（），直接赋值为null或者其他值
2、执行完最后一行代码时自动销毁（如果之前已经销毁，则不再销毁）

对变量的销毁问题

$a = new People(); //创建一个对象（new People()），并把使用权给变量$a（$a是一个变量名，指向这个对象）
$a = $b = $c ; //3个变量都指向内存中的同一个对象
unset（$a）;//unset，即是销毁对象(object)，但有其他变量$b等仍然指向对象，那么该对象将不能被销毁，但是$a为null不再指向这个对象

this的绑定

当一个对象调用一个它对应类的方法时，该方法执行之前先完成一个绑定，即是用
$this绑定到调用此方法的对象（这样才能在方法内对这个对象的属性进行操纵），因为方法内如果想访问调用者（即是对象）的属性必须用$this；否则则理解为方法内部的一个局部变量

 
    class Person
    {
        public $name;
        // 构造方法(函数) 在类被实例化的时候 在对象被创建的时候
        // 满足一些初始化的操作
        function __construct($name)
        {
            $this->name = $name;
        }
    }
    复制代码

封装

封装的概念：通过修饰符改变属性或者函数的访问权限，达到保护的作用。
光是封装起来是没意义的，还要供外部交互才行；所以通过一个开放的接口（即是一个函数）供外部操纵；内部的操作，不需要外部知道，从而隐藏内部的一些细节。
例子: 洗衣机，你只要点击启动程序的按钮就能洗衣服，不需要知道洗衣机内部怎么运行
权限修饰符：private protected public
private修饰的属性只能在其类里面才能被访问到。
protected 本类和子类能访问

_set _get 魔术方法 (在类外对类内受保护或私有的属性赋值)

__set 当你设置在类外设置类中属性或赋值, 将会被调用;
__get 当你获取受保护或者私有的属性的值的时候,将会被调用

继承

子类继承父类的属性和方法，再进一步拓展自己的属性和方法；父类的属性和方法一般是一个归纳（所有对象都有的），提高代码的重新性

拥有的问题

子类继承父类，子类有父类所有的属性和方法，在子类里面能够操作父类中非private修饰的属性或者方法，但是父类中对于private修饰的属性或者方法子类无法操作（类外的范围限制）

方法的重写

如果子类中出现了与父类重名的方法我们称之为重写

        // 继承
        class Person
        {
            public function a() // job
            {
                echo 'Person/a';
            }
            protected function b()
            {
                echo 'Studnent/b';
            }
            private function c()
            {
                echo 'ddd';
            }
        }
        class Student extends Person
        {
            // 子类重写父类 子类只能比父类宽松 不能比父类严格
            protected function b()
            {
                parent::b();
                echo 'Studnent/b';
            }
        
            // 测试
            public function test()
            {
                $this->b();
            }
            // 方法的重写 // public 宽松重写父类方法子类必须是public
            public function a()
            {
                // 子类方法中调用父类的方法
                parent::a();
                echo '张泽雨';
            }
        
            public function c()
            {
        //        parent::c();// 私有的方法 子类继承的方法不能被调用
            }
        }
        
        // 重写父类的方法
        // 如果子类中出现了与父类重名的方法 我们称之为重写
        
        /*
         * 父类          子类
         * public       public
         * protected    protected   public
         * private      private    protected  public
         * */
        $s = new Student();
        $s->a();
        $s->test();

final 最终如果类不希望被别人继承在类名前加修饰符 final

// 1.如果类中你的某个方法不希望被别人继承后使用, 可以在方法名前加final
// 2.如果整个类都不希望被别人继承使用可以在类名前加 final
// 3. final 不能来修饰成员属性

class A
{
    // const 类中定义常量
     public $name = '张泽';
    public function test()
    {
        echo 'test';
    }
}

class B extends A
{
    public function test()
    {
        echo '子类test';
    }
}

$b = new B();
$b->test();

static 静态变量

static (静态变量) 防止重复初始化
====

    function test()
    {
        static $n = 0; // static (静态变量) 防止重复初始化
        echo $n;
        $n++;
    //    echo $n;
    //    echo;
    }
    // 防止重复初始化
    test();
    test();
    test();
    test();
    test();
    test();

//访问类中的静态属性或者方法 self:: // 访问普通属性或者普通方法$this->

    class A
    {
        public static $count = 0;
    
        public function __construct()
        {
            // 访问类中的静态属性或者方法 self::
            // 访问普通属性或者普通方法$this->
            self::$count++;
        }
    
        public function getCount()
        {
            echo self::$count;
        }
    }
    
    $a = new A();
    $a->getCount();
    $a1 = new A();
    $a1->getCount();
    $a2 = new A();
    $a2->getCount();

单利模式单态模式

一个类只能有一个实例对象存在
为了能让类只能实例化一次前提是让类不能实例化是不能以new 的方式去实例化

class Db {
// 防止重复初始化
    private static $obj = null;
    private function __construct() {
        echo '数据库链接成功';
    }
    public stratic function getInstance () {
        // 通过静态方法来实例化类产生的对象
        if (is_null(self::$obj)) {
        // 如果self:: $obj == null
        // 类内部去实例化
        self:: $obj = new Db ();
        }
        return self::$obj;
    }
}

$db = Db::getInstance();
$db = Db::getInstance();

instanceof 检测当前对象实例是否属于某一个类的类型

// 一个对象一定属于自己的类本身
// 一个对象还属于本类的父类

    class A extends B
    {
    }
    class B
    {
    }
    // 如何比较对象是否属于某个类
    $a = new A();
    $b = new B();
    // $a 对象是否属于 A类
    var_dump($a instanceof A);
    // $b 对象是否属于 B类
    var_dump($b instanceof B);
    // $a 对象是否属于 B类
    var_dump($a instanceof B);
    // $b 对象是否属于 A类
    var_dump($b instanceof A);
    // 一个对象一定属于自己的类本身
    // 一个对象还属于本类的父类
     
    // __toString 快速的获取对象字符串
    // 当我们直接输出一个对象的时候会自动调用
    class C
    {
        // __toString 方法的返回值一定是字符串
        public function __toString()
        {
            // 解释说明类的方法
            return '此类是作为方便大家调用使用的, 用来解释说明此类的作用,编写文档';
        }
    }
    $c = new C();
    // 类外直接输出对象 (会直接调用__toString方法)
    echo $c;

__call 处理错误调用

当试图调用一个类中不存在的方法, 就会报错
如果此时有__call 方法则会自动调用此方法

    class A
    {
        public function test($str)
        {
            echo $str;
        }
    
    // $name     访问不存在的方法名
    // $arguments 调用方法时的参数列表
        public function __call($name, $arguments)
        {
            echo '当类外调用不存在的方法会被自动调用' . $name . '方法不存在';
            foreach ($arguments as $v) {
                echo $v ;
            }
    //   print_r($arguments);
        }
    }
    
    $a = new A ();
    $a->test("hello");
    $a->test1("php", "world", "happy");

__autoload 自动加载类

作用:当new 一个不存在类的时候会自动调用
唯一一个写在类外的魔术方法

    function __autoload($name)
    {
        $name = strtolower($name);
        if (file_exists($name . '.class.php')) {
            include_once $name . '.class.php';
        } else {
            die($name . '.class.php文件不存在');
        }
    }
    // new 一个不存在的类的时候 会自动调用
    $one = new One();
    $two = new Two();
    $four = new Four(); // 不存在
    $one->a();
    $two->a();
    $four->a();

转载于:https://juejin.im/post/5a438658f265da430f326214