PHP5 面向对象语言

最新推荐文章于 2024-05-07 16:28:22 发布
最新推荐文章于 2024-05-07 16:28:22 发布
阅读量93 收藏
点赞数
文章标签： php
原文链接：http://www.cnblogs.com/wubenzhimu/archive/2012/11/28/2793414.html
版权

声明一个类（Declaring A Class）

    使用class关键字，提供一个类的名字，然后列出这个类的实例应该具备的方法和属性：

 Class MyClass {

     ...         //方法的列表

   ...        //属性的列表

}

 

new关键字和构造函数（The new Keyword And Constructors）

    类的实例是使用new关键字创建的。

    当你调用 new 的时候 PHP 会分派一个新的对象，并且从你定义的类中拷贝属性和方法，然后如果你有定义对象的构造函数的话，它将被自动调用。构造函数式一个命名为 __construct() 的方法，它在 new 关键字创建一个对象后自动运行。构造函数通常被用来自动地执行许多初始化操作，例如属性初始化。构造函数也接受参数，这种情况下，编写 new语句的时候，你还需要给构造函数的括号内传递函数的参数。

View Code 
<?php    
    class Person
    {
        function __construct($name)
        {
            $this->name = $name;
        }
        private $name;
        
        function getName()
        {
            return $this->name;
        }
    }
    
    $judy = new Person("Judy");
    $joe  = new Person("Joe");
    
    print $judy->getName() . "<br />";
    print $joe->getName();
?>

输出结果：

Judy
Joe

析构函数(Destructors)

    析构函数与构造函数的作用是相反的。它是在对象被注销的时候调用的（例如，没有任何变量引用对象）。

View Code 
<?php
    class MyClass
    {
        function __destruct()
        {
            print "An object of type MyClass is being destroyed\n";
        }
    }
    
    $obj = new MyClass();
    $obj = NULL;
?>

输出结果：

An object of type MyClass is being destroyed

使用 $this 变量访问方法和属性（Accessing Methods And Properties Using The $this Variables）

    在对象的方法执行的时候，PHP会自动定义一个叫 $this 的特殊变量，它表示一个对对象本身的引用。通过使用这个变量和 -> 符号，你可以引用改对象其他的方法和属性。

 

Public, protected 和 private 属性

    OOP 中的一个关键范例就是封装和对象属性（也可以叫做成员变量）的访问和保护。

              　　本类          子类          外部

Public           可以          可以          可以

Protected     可以          可以          不可以

Private         可以          不可以        不可以

 

静态属性（Static Properties）

    类可以声明属性。每一个类的实例（例如：对象）拥有它自己的属性拷贝。

但是一个类也可以包含静态属性。和常规属性不一样的是，这些属性属于类本身而不属于类的任何实例。因此，它们经常被叫做类属性以便和对象或者实例的属性区分开来。你也可以把静态属性认为是存储在类当中的全局变量，而且你可以再任何地方通过类访问它们。

 静态属性使用 static 关键字定义的：

 

Class MyClass

{

        static $myStaticvar;

}

 

要访问一个静态变量时，你必须用属性所在的类的名字来限制它

View Code 
<?php
    class MyClass
    {
        static $myStatic;
    }
    
    MyClass::$myStatic++;
    print MyClass::$myStatic;
?>

 

输出结果：

 1 

如果你想在类里面的方法中访问到静态成员，你还可以通过在成员的名字前面加上特殊的类名 self 来访问它， self 是一个方法所属的类的缩写：

View Code 
<?php
    class MyClass
    {
        static $myStatic = 0;
        
        function myMethod()
        {
            print self::$myStatic;
        }
    }
    
    $obj = new MyClass();
    $obj->myMethod();
?>

 

输出结果：

0 

深度思考：（如果把 static 变成 public， 结果又如何？）

View Code 
<?php
    class MyClass
    {
        static $idCounter = 0;
        public $uniqueId;
        
        function __construct()
        {
            self::$idCounter++;
            $this->uniqueId = self::$idCounter;
        }        
    }
    
    $obj1 = new MyClass();
    print $obj1->uniqueId . "<br />";
    $obj2 = new MyClass();
    print $obj2->uniqueId . "<br />";
?>

 

输出结果：

1

2

 

静态方法（Static Methods）

    与静态属性相似，PHP 支持把方法声明为静态的。也就是说静态方法是类的一部分而且不被限制到任何一个特定的对象实例和类的属性。因此，$this 在这些方法中将不能使用，但是类本身可以通过 self 访问。因为静态方法不能被限制到任何特定的对象，所以你可以不创建对象实例就通过 MyClass::Method() 语法调用它。你还可以再一个对象实例中通过 $this->method() 访问这些静态方法，但是在这些方法中 $this 是没有定义的。为了更加清楚些，你应该使用 self::method() 而不是 $this->method()。

View Code 
<?php
    class MyClass
    {
        static function printHelloWorld()
        {
            print "Hello, World";
            self::printNewLine();
        }
        
        static function printNewLine()
        {
            print "<br />";
        }
    }
    
    MyClass::printHelloWorld();
?>

输出结果：

Hello, World

 

类的常量（Class Constants）

    PHP5 中对类的封装进行了改进，你现在可以在类中定义常量。与静态成员类似，它们属于类本身而不是类的实例。类的常量总是对大小写敏感的。定义它们的语法很直观，而且访问类中的常量跟访问静态成员是类似的。

View Code 
<?php
    class MyClass
    {
        const RED   = "Red";
        const GREEN = "Green";
        const BLUE  = "Blue";
        
        function printBlue()
        {
            print self::BLUE;
        }
    }
    
    print MyClass::RED . "<br />";
    $obj = new MyClass();
    $obj->printBlue();
?>

输出结果：

Red
Blue

 

克隆对象（Cloning Objects）

    在创建一个对象的时候（使用 new 关键字），返回的值是一个指向对象的句柄，或者换言之，是对象的ID号。这跟 PHP4 是不一样的，在 PHP4 中返回的值就是对象的本身。这并不意味着调用方法或访问属性的语法被改变了，只是对象在复制的时候意义被更改了。

 

分析下面的代码;

View Code 
<?php
    class MyClass
    {
        public $var = 1;
    }
    
    $obj1 = new MyClass();
    $obj2 = $obj1;
    $obj2->var = 2;
    print $obj1->var;
?>

输出结果：

2

在 PHP4中， 这个代码会打印出1，因为 $obj2 被赋予了 $obj1 对象的值，因此 $obj2 是 $obj1 的一个拷贝，从而改变 $obj2 的时候 $obj1 不会被改变。但是在 PHP5 中，因为 $obj1 是一个对象句柄（它的id号），所以复制到 $obj2 的是一个句柄。因此，当改变 $obj2 的值得时候，你其实已经改变了 $obj1 指向的同一个对象。因此，运行这个代码片段后，结果是打印出2。

View Code 
<?php
    class MyClass
    {
        public $var = 1;
    }
    
    $obj1 = new MyClass();
    $obj2 = clone $obj1;
    $obj2->var = 2;
    print $obj1->var;
?>

 

输出结果：

1

下面的例子描述一个你可能要执行 __clone() 方法的一个典型的情况。假设你有一个对象，它存储着一个资源，例如一个文件句柄。你需要一个新的对象，而且它不能指向同一个句柄，而是打开一个新的文件从而拥有它自己的一个拷贝：

View Code 
<?php
    class MyFile
    {
        private $file_name;
        private $file_handle = NULL;
        
        function setFileName($file_name)
        {
            $this->file_name = $file_name;
        }
        
        function openFileForReading()
        {
            $this->file_handle = fopen($this->file_name, "r");
        }
        
        function __clone()
        {
            if($this->file_handle)
                $this->file_handle = fopen($this->file_name, "r");
        }
    }
?>

 

多态（Polymorphism）

    多态是 OOP 中最重要的部分了。 OOP 不是把函数和数据简单地集合起来，而是使用类和继承轻松地描述现实生活中的情况。它们还可以通过继承复用代码而轻松升级项目。另外，为了编写健壮的可扩展的代码，你通常需要尽量减少使用流程控制语句（例如 if() 语句）。多态将满足所有这些甚至更多的需求。

分析代码：

View Code 
<?php

    /* 猫的类 */
    class Cat
    {
        function miau(){
            print "miau";
        }
    }
    
    /* 狗的类 */
    class Dog
    {
        function wuff(){
            print "wuff";
        }
    }
    
    function printTheRightSound($obj)
    {
        //php 5 提供了關鍵字 instanceof 用以判斷一個對象是否是某個類或接口的實例
        if($obj instanceof Cat) {
            $obj->miau();
        } else if ($obj instanceof Dog) {
            $obj->wuff();
        } else {
            print "Error:未找到类";
        }
        print "<br />";
    }
    
    printTheRightSound(new Cat());
    printTheRightSound(new Dog());
?>

输出结果：

miau
wuff

可以很容易地看出这个例子是不可扩展的。如果想通过增加另外三种动物的声音来扩展的话，你可能不得不在 printTheRightSound() 函数中增加另外三个 else if 模块以便检查你的对象是其中哪一种新动物的实例，而且接下来还要增加代码来调用每一种发声的方法。

    多态使用继承来解决这个问题。它可以让你继承一个父类，继承所有父类的方法和属性后创建“唯一”关系。

    按照前一个例子，我们将创建一个新的类，名叫 animal。然后所有其它的动物从这个父类继承，从而为每一个特定的动物种类创建“唯一”关系。

View Code 
<?php
    class Animal
    {
        function makeSound()
        {
            print "Error:方法应该在子类实现！";
        }
    }
    
    class Cat extends Animal
    {
        function makeSound()
        {
            print "miau";
        }
    }
    
    class Dog extends Animal
    {
        function makeSound()
        {
            print "wuff";
        }
    }
    
    function printTheRightSound($obj)
    {
        if($obj instanceof Animal) {
            $obj->makeSound();
        } else {
            print "Error:未找到类";
        }
        print "<br />";
    }
    
    printTheRightSound(new Cat());
    printTheRightSound(new Dog());
?>

输出结果：

miau
wuff

这个例子中增加多少种动物类型，都不需要对 printTheRightSound() 函数做任何更改，因为 instanceof Animal 可以检测所有这些类型， 而且 $obj->makeSound() 调用也是如此。

 

Parent:: 和 self( parent:: and self::)

    PHP 支持两个类名的保留字让你在编写 OO 应用的时候可以轻松调用。self:: 指向当前的类，而且它通常用来访问静态成员，方法和常量。 Parent:: 指向父类，而且它经常被用来调用父类的构造函数和方法，它也可以用来访问父类的成员和常量。你应该用 parent:: 而不是父类的具体名字，这是为了让你可以方便地更改你的类的层次，因为你不用固定写入某个父类的名字。

下面的例子同时使用了 parent：： 和 self：： 来访问 Child 类和 Ancestor类：

View Code 
<?php
    class Ancestor
    {
        const NAME = 'Ancestor';
        
        function __construct()
        {
            print "In " . self::NAME . "constructor <br />";
        }
    }
    
    class Child extends Ancestor
    {
        const NAME = 'Child';
        
        function __construct()
        {
            parent::__construct();
            print "In " . self::NAME . "constructor <br />";
        }
    }
    
    $obj = new Child();
?>

输出结果：

In Ancestorconstructor
In Childconstructor

 

instanceof 运算符（ instanceof operator）

    PHP 增加 instanceof 作为更符合使用习惯的运算符，并代替已有的 is_a() 内置函数（不推荐使用）。 instanceof 被当成一个逻辑二元运算符来使用：

View Code 
<?php
    class Rectangle
    {
        public $name = __CLASS__;
    }
    
    class Square extends Rectangle
    {
        public $name = __CLASS__;
    }
    
    class Circle
    {
        public $name = __CLASS__;
    }
    
    function checkIfRectangle($shape)
    {
        if($shape instanceof Rectangle) {
            print $shape->name;
            print " is a rectangle <br />";
        }
    }
    
    checkIfRectangle(new Square());
    checkIfRectangle(new Circle());
?>

输出结果：

Square is a rectangle

检测类是否存在

 

Abstract 方法和类(Abstract Methods And Class)

    抽象方法，只要有一个方法被定义为 abstract，整个类也就需要声明为 abstract。

注意：与其他一些语言不同的是，你不能给抽象的方法定义一个默认的执行体。但是在 PHP 中，一个方法可以是 abstract（没有代码）的，或者可以是完整定义的。

 

接口 （Interfaces）

    类的继承让你可以描述几个类之间的父与子的关系。声明一个接口与声明一个类是类似的，但是它只包含函数原型（没有执行体）和常量。任何一个 “implements” 这个接口的类将自动获得这个接口定义的常量并且作为实现的类需要给接口的函数原型提供函数定义（除非你定义实现接口的类为 abstract）， 接口的函数都是 abstract 的。

    通过下面的语法来实现一个接口：

   

 Class A implements b, c, …

{

 

}

 

 下面的例子定义了名叫 Loggable 的接口，它让其他类来实现并通过 Mylog() 定义需要记录哪些信息的日志。 那些没有实现这个接口的类的对象传递给 Mylog() 函数将会打印出错误的信息：

View Code 
<?php
interface Loggable
{
    function logString();
}

class Person implements Loggable
{
    private  $name, $address, $idNumber, $age;
    function logString() {
        return "class person: name = $this->name, ID = $this->idNumber <br />";
    }
}

class Product implements Loggable
{
    private $name, $price, $expiryDate;
    function logString() {
        return "class Product: name = $this->name, price = $this->price <br />";
    }
}

function MyLog($obj)
{
    if($obj instanceof Loggable) {
        print $obj->logString();
    } else {
        print "Error: object doesn't support Loggable interface <br />";
    }
}

$person = new Person();
$product = new Product();

MyLog($person);
MyLog($product);
?>

输出结果：

class person: name = , ID =
class Product: name = , price =

 

接口的继承（Inheritance of Interfaces）

    接口是可以从别的接口继承来的。继承接口的语法与继承类的语法类似，但是接口可以多重继承：

    interface I1 extends I2, I3, …

  {

   }

与类实现接口类似，一个接口只能继承与自己互相不冲突的接口（也就是说如果I2定义了在I1已经定义的方法或者常量，你将接收到报错信息）。

 

final 方法（final Methods）

    很多时候你需要确保一个方法不能被继承类改写。为此，PHP 支持 final 访问控制符来声明一个方法是不可重写的。

    下面的例子不是一个合法的 PHP 脚本，因为它试图重写一个 final 方法：

View Code 
<?php
class MyBaseClass
{
    final function idGenerator()
    {
        return $this->id++;
    }
    protected $id = 0;
}

class MyConcreteClass extends MyBaseClass
{
    function idGenerator()
    {
        return $this->id += 2;
    }
}

?>

输出结果：
Fatal error: Cannot override final method MyBaseClass::idGenerator() in D:\wamp\www\php5\01\lx16.php on line 17

这个脚本不会执行，因为在 MyBaseClass 中把 idGenerator() 定义为 final， 它不许继承的类重写 idGenerator() 并且修改id 增长的逻辑。

 

final类（final Classes）

    与 final 方法类似，你还可以定义一个类为 final。 这么做将不可以其他类继承此类。

 final class MyBaseClass
{

}

class MyConcreteClass extends MyBaseClass
{

}

 

MyBaseClass 已经被声明为 final， MyConcreteClass 不能继承它。 因此，这个代码的执行失败。

 

__toString()方法（__toString() Method）

考虑下面的代码：

View Code 
<?php
class Person
{
    function __construct($name)
    {
        $this->name = $name;
    }
    private $name;
}

$obj = new Person("小明");
print $obj;
?>

输出结果：
Catchable fatal error: Object of class Person could not be converted to string in D:\wamp\www\php5\01\lx17.php on line 12

程序将运行错误！！

 

PHP 为你提供一个叫__toString() 的函数，你可以用它来返回表示对象的字符串信息，而且一旦定义它，打印命令将调用它并打印出返回的字符串。

View Code 
<?php
class Person
{
    private $name;
    
    function __construct($name)
    {
        $this->name = $name;
    }
    
    function __toString()
    {
        return $this->name;
    }
}

$obj = new Person("小明");
print $obj;
?>

输出结果：

小明 

目前__toString() 只能被 print 和 echo 语言结构调用。

 

异常处理（Exception Handling）

    大多数现代的语言都支持一些各自的很流行的 try/catch/throw 异常处理范例。 try/catch 是一个闭合的语言结构，它们保护被其包含的源代码而且会告诉 PHP，“我正在处理发生在这些代码的异常”。异常或者错误在被检测到的时候“抛出”并且 PHP 事实地去搜索它所调用的堆栈，查看是否存在一个相应的 try/catch 结构可以来处理这个异常。

    这种方法有许多好处。首先，你不用放置 if（） 语句在任何异常有可能出现的地方；因此可以减少很多代码。你可以把整个部分的代码都装入 try/catch 结构并且当一个错误发生时处理错误。另外，在你用 throw 语句检测到一个错误后，可以轻松地传递到代码中需要负责处理异常的地方并继续让程序执行下去，因为 throw 展开了函数调用的堆栈知道它检测到一个合适的 try/catch 块。

    Try/catch 的语法如下：

Try {

       …  // 会抛出一个异常的代码

} catch (FirstExceptionClass $exception) {

    …   // 会处理这个异常的代码

} catch (SecondExceptionClass) {


}

 

Try{ }结构装入的代码可以抛出一个异常，后面可以加上一系列的 catch 语句，每一个 catch 声明哪个异常应该调用并且在 catch 块中异常的对象应该用什么变量名来访问。

View Code 
<?php
class NullHandleException extends Exception
{
    function __construct($message)
    {
        parent::__construct($message);
    }
}
    
function printObject($obj)
{
    if($obj == NULL) {
        throw new NullHandleException("printObject received NULL object");
    }
    print $obj . "<br />";
}

class MyName
{
    function __construct($name)
    {
        $this->name = $name;
    }
    
    function __toString()
    {
        return $this->name;
    }
    private $name;
}
    
try {
    printObject(new MyName("Bill"));
    printObject(NULL);
    printObject(new MyName("jane"));
} catch (NullHandleException $exception) {
    print $exception->getMessage();
    print " in file " . $exception->getFile();
    print " on line " . $exception->getLine() . "<br />";
} catch (Exception $exception) {
    //这里将不会被执行
}

?>

输出结果：

Bill
printObject received NULL object in file D:\wamp\www\php5\01\lx19.php on line 13

 

__autoload()

    当编写面向对象的代码时，人们经常习惯于把每一个类放到它自己的源文件中。这样做的好处是可以很轻松地找到类在哪里，而且这样还可以将包含的代码数量最小化，因为你只需引入实际需要的类。这样做的缺陷在于你不得不经常包含大量的源文件，从而让人头疼，而且经常导致包含的太多的文件和一个头疼的代码维护问题。如果你定义一个 __autoload() 可以解决这个问题，它不需要你包含将要使用的类。如果你顶一个 __autoload() 函数，而且当你访问一个还未存在的类时，它将被调用并且把类的名字作为它的参数。这样做给你一个实时包含类的可能性。 如果你成功地包含了该类，你的源码会继续执行，就像这个类已经定义了一样。如果没有成功包含该类，脚本引擎会产生一个类不存在的严重错误。

MyClass.php

View Code 
<?php
    class MyClass
    {
        function printHelloWorld()
        {
            print "Hello, World <br />";
        }
    }
?>

general.php

View Code 
<?php
    function __autoload($class_name)
    {
        require_once("./$class_name.php");
    }
?>

main.php

View Code 
<?php
require_once "./general.php";

$obj = new MyClass();
$obj->printHelloWorld();
?>

输出结果：

Hello, World

 

转载于:https://www.cnblogs.com/wubenzhimu/archive/2012/11/28/2793414.html

aowang3732
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
PHP面向对象类型约束用法分析
01-03
本文实例讲述了PHP面向对象类型约束。分享给大家供大家参考，具体如下： 什么是类型约束 就是要求某个变量只能使用（接受，存储）某种指定的数据类型；php属于”弱类型语言“，通常不支持类型约束；相应的，强类型...
PHP语言之面向对象编程
低头赶路，敬事如仪
10-15 2402
第3关：面向对象编程与数据库综合运用
PHP语言之面向对象编程之继承
低头赶路，敬事如仪
10-16 3471
第3关：方法继承
php是面向对象还是过程,PHP面向过程和面向对象
weixin_34542865的博客
03-25 2025
php程序编写分为面向过程和面向对象。两者在功能实现上没有区别，但是在代码编写上区别很大，面向过程的代码很乱，不易管理，而面向对象把常用的功能封装为一个类，这样代码清楚多了。下面举个小例子说明一下：php连接数据库：面向过程：$conn = mysql_connect('服务器名称', '数据库登陆名', '密码') or die('连接不成功!');mysql_select_db('库名', $...
PHP面向对象概念
无痕之意的博客
09-12 3101
一、面向对象的概念 1、面向对象实现了软件工程的三个目标：重用性、灵活性和扩展性 2、使其编程的代码更简洁，更易于维护，并且具有更强的可重用性 3、面向对象的特点: 封装：隐藏对象的属性和实现细节 继承：从一个基类得到一个或多个类的机制 多态：根据使用类的上下文来重新定义或改变类的性质或行为 二、类和对象的关系 1、类是用于生成对象的代码模板 2、PHP中使用关键字class...
PHP面向对象简介
CooSheng
04-12 1982
面向对象就是将要处理的问题抽象为对象，然后通过对象的属性和行为来解决对象的实际问题。我们通常所说的面向对象准确的说应该叫面向对象编程（OOP），它是面向对象的一部分。 面向对象主要分为三个部分，如下所示： 面向对象分析（Object Oriented Analysis，OOA）； 面向对象设计（Object Oriented Design，OOD）； 面向对象编程（Object Oriented Programming，OOP）。 本节我们主要介绍的是面向对象编程。 什么是面向对象编程 面向对象
Go - 是面向对象语言吗？
一七令
09-19 1298
前言 这篇文章代表博主正式开始学习和使用Go，以前的工作中主要使用一门动态的、解释型和面向对象的脚步语言。是的，你没猜错！它是 PHP。 Go 是一门编译静态语言，令人疑惑的它究竟是不是面向对象设计的。所以本文就以 OOP 的三大特性进行两门语言的对比，看看 Go 是不是面向对象的。 正文 受 C 家族语言如PHP、Java等影响，得到一个不成文的结论：没有类(class)设计存在的就不是面向对象语言。 其中这是不对的，面向对象是一种编程思想，而非一种语言特有的技能。例如javascript 也能通过原型的
005 面向对象和面向过程语言
qq_48028640的博客
12-09 1449
面向对象和面向过程语言 一 ·定义 面向过程： 当需要实现一个功能的时候，每一个步骤我们都需要自己去做，处理实现功能的每一个细节。 面向对象： 当需要实现一个功能的时候，我们不需要自己去做，可以直接找一个已经具有该功能的东西，来帮我解决问题。 二·区别 面向过程强调的是步骤。 面向对象强调的是对象，这里的对象就是饭店。 三·特点 面向对象是一种更符合我们思考习惯的一种思想，他可以将问题简单化，并将我们从执行者变成了指挥者。在面向对象的语言中，有三大基本特性： 1.面向对象 ①封装性 封装就是把普通的对象进行
C++面向对象
qq_45806136的博客
02-13 3556
*从存储空间的角度考虑：**构造函数是在实例化对象的时候进行调用，如果此时将构造函数定义成虚函数，需要通过访问该对象所在的内存空间才能进行虚函数的调用（因为需要通过指向虚函数表的指针调用虚函数表，虽然虚函数表在编译时就有了，但是没有虚函数的指针，虚函数的指针只有在创建了对象才有），但是此时该对象还未创建，便无法进行虚函数的调用。所以构造函数不能定义成虚函数。**从使用的角度考虑：**虚函数是基类的指针指向派生类的对象时，通过该指针实现对派生类的虚函数的调用，构造函数是在创建对象时自动调用的。
go是面向对象语言吗？
热门推荐
每天进步一点点。。。的博客
05-05 1万+
转载链接：https://segmentfault.com/a/1190000001832282#articleHeader5原文链接：http://spf13.com/post/is-go-object-oriented前言面向对象的含义引入了对象（object)、类（class）、继承（inheritance）、子类（subclass）、虚方法（virtual method）、协程（corou...
R语言面向对象编程
四纪启悟 · 数据科学
03-16 1697
R语言面向对象编程 R的极客理想系列文章，涵盖了R的思想，使用，工具，创新等的一系列要点，以我个人的学习和体验去诠释R的强大。 R语言作为统计学一门语言，一直在小众领域闪耀着光芒。直到大数据的爆发，R语言变成了一门炙手可热的数据分析的利器。随着越来越多的工程背景的人的加入，R语言的社区在迅速扩大成长。现在已不仅仅是统计领域，教育，银行，电商，互联网….都在使用R语言。 要成为有理想的极客
PHP面向对象新手视频教程
07-22
PHP 面向对象 新手视频教程资源目录：【】PHP教程1.1.1新版视频形式介绍【】PHP教程1.1.2BS结构软件类型介绍【】PHP教程1.1.3现在是Web2.0的时代【】PHP教程1.1.4Web开发标准【】PHP教程1.1.5认识脚本语言【】...
PHP面向对象编程快速入门
12-17
【摘 要】面向对象编程（OOP)是我们编程的一项基本技能，PHP4对OOP提供了良 好的支持。如何使用OOP的思想来进行PHP的高级编程，对于提高PHP编程能力和 规划好Web开发构架都是非常有意义的。 面向对象编程（OOP)是...
php面向对象程序设计类
05-03
PHP面向对象程序设计类的定义与用法,结合实例形式分析了php类的定义、实例化、__set()及__get()具体使用技巧
php面向对象全攻略 （七） 继承性
01-20
继承是PHP5 面向对象程序设计的重要特性之 一，它是指建立一个新的派生类，从一个或多个先前定义的类中继承数据和函数，而且可以 重新定义或加进新数据和函数，从而建立了类的层次或等级。说的简单点就是，继承性是...
【Web】CTFSHOW 中期测评刷题记录(1)
uuzeray的博客
05-02 1701
访问./cache/6a992d5529f459a44fee58c733255e86.php，命令执行拿flag。login.php是在./templates下的，而./flag.php与./templates均为web目录。注意到用./template/error.php中存在{{username}}，可以用其cache来写马。这时候重开下靶机再去读./templates/index.php，发现是给了提示的。访问./config/settings.php，命令执行拿到flag。
Web安全研究（九）
至臻求学，胸怀云月
05-05 1116
这段代码事实上实现了一个 webshell 的基本功能，因为它允许通过 URL 参数直接控制和执行服务器端的代码，极其危险。在实际应用开发中，应避免直接使用eval函数，特别是当其包含来自用户输入的数据时。同时，也应该对所有用户输入进行严格的验证和过滤，以减少潜在的安全风险。
PHP 在字符中找出重复次数最多的字符
zzjnlwb的专栏
05-06 271
应该也还有其他很多办法！等我遇到了再更新本篇！我感觉这是最简单的一种办法！
免费的发票查验接口平台 PHP开发示例
最新发布
weixin_49544544的博客
05-07 254
发票识别接口，自主ocr核心技术，无论是增值税发票、火车票、打车票还是财政类票据，仅需一键上传即可快速、精准识别全票面信息，且可进行发票的自动分类，避免了人工录入的误差，提升了发票管理数字化效率与准确率。传统手动录入的方式不仅耗时长，繁琐低效，且容易出现人为错漏的风险，让财务工作者头疼不已。发票识别+发票查验接口可以解决票据信息录入繁琐、易出错等一系列难题，体验发票管理的革命性飞跃。发票查验接口，实时联网查验增值税发票管理系统开具发票的真伪，核验为真还可返回全票面信息，且可进行发票的批量核验。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值