devbox
羊村懒王
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

PHP快速入门_php菜鸟教程

作者：羊村懒王 | 2024-06-16 13:47:24

赞

踩

php菜鸟教程

文章目录

PHP快速入门

注：学习php之前最好快速过一遍前端html(如果你学过java，那你会更加容易理解这篇文章)。

HTML推荐观看教程：狂神说JAVA;

PHP推荐观看教程：黑马程序员28天零基础入门到精通；黑马程序员PHP进阶教程由浅入深掌握面对对象开发;

JAVA推荐观看教程：韩顺平30天学会JAVA;

前期准备：

phpStudy,phpStorm
phpStorm配置解释器
在这里插入图片描述

1）语法快速入门

(在电脑web端中查看这篇文章，下列所有代码块中紫色的为关键字)

一. 标识符号

单个php文件时
<?php


  • 1
  • 2
  • 3
php与html混编时
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>

<?php
	echo "php";
?>//必须要有这个才会被认为php语句

</body>
</html>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

二. 变量声明

php中声明变量以$开始
$a ="我是变量";
echo $a;

  • 1
  • 2
  • 3

三.常量声明

两种定义常量的方式
<?php
define("PI", 3.14 ,false);

/*
define "常量名",常量值。
false为可选参数，如果设置为 TRUE，该常量则大小写不敏感，默认是大小写敏感的。
自 PHP 7.3.0 开始，定义不区分大小写的常量已被弃用。从 PHP 8.0.0 开始，只有 false 是可接受的值，传递 true 将产生一个警告
*/

const PI=3.14;
// const 常量名 = 常量值;

//常量一旦被定义就不能随意取消或更改

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

四.注释

//我是单行注释

/*
我是
多行
注释
*/

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

2）数组

一.普通数组

$list = [];		// 第一种创建空数组方式
$list = ['apple', 'banana', 'orange'];  // 创建一个包含元素的数组

//向数组末尾添加元素
array_push($list, 'apple');
array_push($list, 'banana');
array_push($list, 'orange');

$list = array();  //第二种创建空数组方式
$list = ['apple', 'banana', 'orange'];  // 创建一个包含元素的数组

//向数组末尾添加元素
array_push($list, 'apple');
array_push($list, 'banana');
array_push($list, 'orange');

//遍历数组
foreach($list as =>$key $value)
	echo $key . ": " . $value . "\n";

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

二.关联数组

$student = array(
    "name" => "John Smith",
    "age" => 20,
    "major" => "Computer Science",
    "university" => "ABC University"
);

// 访问关联数组中的值
echo $student["name"];  // 输出：John Smith
echo $student["age"];  // 输出：20

// 修改关联数组中的值
$student["major"] = "Information Technology";

// 添加新的键值对
$student["gpa"] = 3;

// 遍历关联数组
foreach ($student as $key => $value) {
    echo $key . ": " . $value . "\n";

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

3）函数

function sayHello() {
    echo "Hello, world!";
}

// 调用函数
sayHello();  // 输出：Hello, world!
// !!函数不调用是没有返回值的


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

4）PHP文件引入

require '文件名';
require_once '文件名'

include '文件名'
include_once '文件名'
/*区别:
	当使用 require 时，如果包含的文件不存在或发生错误，PHP 会发出一个致命错误（Fatal Error），停止执行脚本。
    当使用 include 时，如果包含的文件不存在或发生错误，PHP 会发出一个警告（Warning），继续执行脚本。   
    require_once和include_once的作用交给小伙伴自己探索吧
*/

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

require
include

5）表单处理

php可以处理多种表单；文件上传，图像上传，登录表单，注册表单等；因为是快速入门这里仅演示一种（来写一个简单的计算器吧）
前端页面
（相信前期看了前端的伙伴这里会比较清楚，注意事项就是红色箭头的两个地方。1.action：提交表单时，发送表单数据到"1.php"处理 2.表单需要在form标签内）
php代码
效果
效果

6) php文件处理

//打开文件
$filename = "example.txt";
$file = fopen($filename, "r");

 //读取文件
// 逐行读取
while (!feof($file)) {
    $line = fgets($file);
    // 处理当前行的内容
}

// 读取整个文件内容
$content = file_get_contents($filename);

//写入文件
$content = "Hello, World!";
$file = fopen($filename, "w");
fwrite($file, $content);
fclose($file);

//关闭文件
fclose($file);

//检查文件是否存在
if (file_exists($filename)) {
    // 文件存在
}

//复制文件
$sourceFile = "source.txt";
$destinationFile = "destination.txt";
copy($sourceFile, $destinationFile);

//移动文件
$sourceFile = "source.txt";
$destinationFile = "destination.txt";
rename($sourceFile, $destinationFile);

//删除文件
$filename = "example.txt";
unlink($filename);

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41

（实现一个留言板）

<!DOCTYPE html>
<html>
<head>
    <title>留言板</title>
</head>
<body>
    <h1>留言板</h1>

    <?php
    // 处理用户提交的留言
    if ($_SERVER["REQUEST_METHOD"] == "POST") {
        $message = $_POST["message"];

        // 将留言保存到文件
        $filename = "messages.txt";
        $file = fopen($filename, "a"); //"a"为追加
        fwrite($file, $message . PHP_EOL);/* PHP_EOL 
        									windows平台相当于    echo "\r\n";
											unix\linux平台相当于    echo "\n";
											mac平台相当于    echo "\r";
										*/
        fclose($file);
    }

    // 显示已保存的留言列表
    $filename = "messages.txt";
    if (file_exists($filename)) {
        $file = fopen($filename, "r");

        echo "<h2>留言列表</h2>";
        echo "<ul>";

        while (!feof($file)) {
            $message = fgets($file);
            if (!empty($message)) {
                echo "<li>" . htmlspecialchars($message) . "</li>";
            }
        }

        echo "</ul>";

        fclose($file);
    } else {
        echo "还没有留言。";
    }
    ?>

    <h2>添加留言</h2>
    <form method="post" action="<?php echo $_SERVER["PHP_SELF"]; ?>">
        <textarea name="message" rows="5" cols="30"></textarea><br>
        <input type="submit" value="提交留言">
    </form>
</body>
</html>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54

效果图

7）会话控制

一.cookie

用法:setcookie(name, value, expire, path, domain, secure, httponly);

    name：cookie 的名称。
    value：cookie 的值。
    expire：cookie 的过期时间，使用 Unix 时间戳表示。如果未设置或设置为 0，则表示会话 cookie，将在浏览器关闭时过期。
    path：cookie 的有效路径。默认为当前路径。
    domain：cookie 的有效域名。默认为空，表示当前域名。
    secure：是否仅通过安全的 HTTPS 连接传输 cookie。默认为 false。
    httponly：是否限制 cookie 仅通过 HTTP 协议访问（无法通过 JavaScript 访问）。默认为 false。
  
$_COOKIE(用于存储客户端发送给服务器的 Cookie 数据。它是一个关联数组)  

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

cookie
cookie

cookie高级（会话周期）

演示如何启动会话、设置和获取会话变量，以及检查和销毁会话。
<?php
//cookie的生命周期为1小时
setcookie('username','john',time()+3600);//time()为格林威治时间，也可以称为时间戳，每秒+1

print_r($_COOKIE);

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

二. session

//启动会话：
session_start();

//设置会话变量：
$_SESSION["username"] = "john";

//获取会话变量：
$username = $_SESSION["username"];

//检查会话变量是否存在：
if (isset($_SESSION["username"])) {
    // 变量存在
}

//销毁会话：
session_destroy();

//检查会话是否过期：
if (isset($_SESSION["LAST_ACTIVITY"]) && (time() - $_SESSION["LAST_ACTIVITY"] > 3600)) {
    // 超过 一小时未活动，销毁会话
    session_unset();
    session_destroy();
}
$_SESSION["LAST_ACTIVITY"] = time(); // 更新最后活动时间戳

//设置会话过期时间：
session_set_cookie_params(3600); // 设置会话过期时间为 一小时

演示如何启动会话、设置和获取会话变量，以及检查和销毁会话。

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29

8）面向对象

一.基本概念

其实我们平常已经听的够多了，人类，鱼类，鸟类…是抽象的，是对一系列事物的概览。比如人类，不同的人都有名字，都有年龄，都有性别；不同的鱼，都生活在水里，都有鳍；不同的鸟，都会飞，都有羽毛…这就是类，对一类事物的描述。
！！面向对象是一种思想，并不是技术，至于具体怎么样去做，才是技术。

二.引入(常用关键字与面对对象简单技术实现)(在电脑web端中查看这篇文章，下列所有代码块中紫色的为关键字)


//class：定义一个类为Person。
class Person {
	//属性
    public $name;
    public $age;
    public $sex;
}
//new：创建一个对象实例。
$Person1 = new Person();
$Person1->name='小明';
$Person1->age=20;
$Person1->sex='男';


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

小结：
类是抽象的，代表一类事物；对象是具体的，是类的实例化；类是对象的模板，对象是类的一个个实例;
类通过class+类名+{}创建类；
类是一种结构不会自动运行；
通过new关键字可以得到一个类的具体对象；
可以创建无限个对象；

我们想让小明会说出自己的名字,会做数学题,实现的这个过程叫方法
//class：定义一个类为Person。
class Person {
	//属性
    public $name;
    public $age;
    public $sex;

	//方法
	public	function spekName(){
	echo "我的名字叫小明";}
	
	public function sum($n){//$n为一个形参，你也可以理解为这里必须要有数才能开始运行；
	$res=0;
	for($i=0;$i<=$n;$i++){
		$res += $i;
		}
        return $res;
    }
}
//new：创建一个对象实例。
$Person1 = new Person();
$Person1->name='小明';
$Person1->age=20;
$Person1->sex='男';

$Person1->spekName();
echo '<br/>';
$res = $Person1->sum(20);
echo $res;


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31

小结：
面对对象里面的方法，你也可以理解为，面对过程中的函数就是面对对象中的方法；
对象过程中函数需要调用才能执行，面对对象中，方法需要创建一个实例，然后调用方法；

三.访问修饰符

//public / protected / private：指定成员（属性和方法）的可见性。

/*
public：公共可见性，可以在任何地方访问。
protected：受保护的可见性，只能在当前类和子类中访问。
private：私有可见性，只能在当前类中访问。
*/

class Person {
	//属性
    private $name; //将名字设为私有
    public $age;
    public $sex;

	//方法
	private	function spekName(){ //将说话设为私有
	echo "我的名字叫小明";}
	
	public function sum($n){
	$res=0;
	for($i=0;$i<=$n;$i++){
		$res += $i;
		}
        return $res;
    }
}
//new：创建一个对象实例。
$Person1 = new Person();
$Person1->name='小明';
$Person1->age=20;
$Person1->sex='男';

$Person1->spekName();
echo '<br/>';
$res = $Person1->sum(20);
echo $res


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37

结果
可以看到名字属性，说话的方法被设为私有之后对象已经访问不到了

四.构造方法

<?php

class Person {
	//属性
    public $name;
    public $age;
    public $sex;

	//方法
	public 	function spekName(){
	echo "我的名字叫小明";
    }

	public function sum($n){//$n为一个形参，你也可以理解为这里必须要有数才能开始运行；
	$res=0;
	for($i=0;$i<=$n;$i++){
		$res += $i;
		}
        return $res;
    }

    //构造方法
    public function __construct($name,$age,$sex){
        echo 'Person被初始化了';
        $this->name = $name;
        $this->age = $age;
        $this->sex = $sex;
    }
}
//new：创建一个对象实例。
$Person1 = new Person('小明', 20, '男');

$Person1->spekName();

$res = $Person1->sum(20);
echo $res;



  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38

面对对象
小结：(构造方法的作用)

(__construct)构造方法允许在创建对象实例时为对象的属性赋初始值；构造方法允许定义自己的构造逻辑；有了构造方法的类在实例化对象后，对象会被自动调用

五.析构方法

<?php


class Person {
	//属性
    public $name;
    public $age;
    public $sex;

	//方法
	public 	function spekName(){
	echo "我的名字叫小明\n";
    }

	public function sum($n){//$n为一个形参，你也可以理解为这里必须要有数才能开始运行；
	$res=0;
	for($i=0;$i<=$n;$i++){
		$res += $i;
		}
        return $res;
    }
    
    //析构方法
    public function __destruct(){
        echo $this->name."这个对象已经被销毁\n";
    }


    //构造方法
    public function __construct($name,$age,$sex){
        echo "Person被初始化了\n";
        $this->name = $name;
        $this->age = $age;
        $this->sex = $sex;
    }
}
//new：创建一个对象实例。
$Person1 = new Person('小明', 20, '男');

$Person1->spekName();

$res = $Person1->sum(20)."\n";
echo $res;



  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45

析构方法
(也可以主动销毁)
主动销毁
小结：
(__deconstruct)析构方法与构造方法一样，会被自动调用；析构方法是用来在对象销毁时主动释放资源；

六.static

<?php


class Person
{
    //属性
    public $name;
    public $age;
    public $sex;

    //静态属性
    public static $count = 0;

    //方法
    public function spekName()
    {
        echo "我的名字叫小明\n";
    }

    public function sum($n)
    {//$n为一个形参，你也可以理解为这里必须要有数才能开始运行；
        $res = 0;
        for ($i = 0; $i <= $n; $i++) {
            $res += $i;
        }
        return $res;
    }

    //析构方法
    public function __destruct()
    {
        echo $this->name . "这个对象已经被销毁\n";
    }


    //构造方法
    public function __construct($name, $age, $sex)
    {
        echo "Person被初始化了\n";
        $this->name = $name;
        $this->age = $age;
        $this->sex = $sex;

        // 每次创建对象时，将count加1
        self::$count++;
    }

 	// 静态方法，用于获取创建的人数
    public static function getCount()
    {
        return self::$count;
    }
}

//new：创建一个对象实例。
$Person1 = new Person('小明', 20, '男');


//$Person1->spekName();
//
//$res = $Person1->sum(20)."\n";
//echo $res;

echo "目前共创建了 " . Person::getCount() . " 个人\n";

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64

count++
(可能有小伙伴这里比较疑惑，我解释下，self关键字用于访问当前类的静态成员（包括静态属性和静态方法）。:: 是范围解析操作符，用于访问类的静态成员。所以，self::$count++ 表示对当前类的静态属性 $count 进行自增操作。在这里 等价于Person:: $count++，其中 Person 是类名。)

小结：
静态属性（Static Properties）：通过使用 static 关键字声明的属性是属于类的，而不是属于类的实例。
静态方法（Static Methods）：通过使用 static 关键字声明的方法是属于类的，而不是属于类的实例。
意义：通过使用静态属性，可以实现数据在类的所有实例之间的共享。这意味着多个对象可以访问和修改相同的数据，从而在不同实例之间传递信息。

9) OOP面对对象高级(封装、继承、多态)

一.封装

<?php

class Person
{
// 公共属性
    public $name;

// 私有属性
    private $age;

// 公共方法
    public function __construct($name, $age)
    {
        $this->name = $name;
        $this->setAge($age);
    }

// 私有方法
    private function setAge($age)
    {
        if ($age >= 0) {
            $this->age = $age;
        }
    }

// 公共方法
    public function getAge()
    {
        return $this->age;
    }
}

// 创建一个对象实例
$person = new Person('小明', 20);

// 访问公共属性
echo $person->name; // 输出：小明

// 无法直接访问私有属性
// echo $person->age; // 报错

// 调用公共方法获取私有属性的值
echo $person->getAge(); // 输出：20


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44

小结：
通过getter 和 setter 方法(getter和setter是大家约定俗成的方法)，实现对数据和代码的保护、隐藏，提高了代码的安全性、可读性、可维护性和可扩展性。

二.继承

<?php
//小学生类
class Pupil{
    public $name;
    public $age;
    public $score;
    public function info(){
        echo $this->name.'|'.$this->age;
    }
    public function test(){
        echo '小学生在考试';
    }
}

//研究生类
class Graduate{
    public $name;
    public $age;
    public $score;
    public function info(){
        echo $this->name.'|'.$this->age;
    }
    public function test(){
        echo '研究生在考试';
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26

不知道大家发现问题没有，两个类都有相同的属性，明明只需要写一遍，但是我们却写了两遍。不管是小学生还是研究生，我们都可以抽象为一个类-----学生。

<?php
//学生类
class Student{
    public $name;
    public $age;
    public $score;
    public function info(){
        echo $this->name.'|'.$this->age;
    }
}
//小学生类继承了父类(Student)的所有属性和方法(通过extends关键字)。
class Pupil extends Student {
    public function test(){
        echo '小学生在考试';
    }
}

//小学生类继承了父类(Student)的所有属性和方法(通过extends关键字)。
class Graduate extends Student {
    public function test(){
        echo '研究生在考试';
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23

实例化对象

<?php
//学生类
class Student{
    public $name;
    public $age;
    public $score;
    public function info(){
        echo $this->name.' | '.$this->age.'岁'."\n";
    }
}

//小学生类，还定义了一个tset方法
class Pupil extends Student {
    public function test(){
        echo '小学生在考试';
    }
}

//研究生类,还定义了一个tset方法
class Graduate extends Student {
    public function test(){
        echo '研究生在考试';
    }
}

//实例化对象
$stu1 = new Pupil();
$stu1->name = '小学生小明';
$stu1->age = 8;
$stu1->info();
$stu1->test();

echo"\n";

$stu2 = new Graduate();
$stu2->name = '研究生小强';
$stu2->age = 20;
$stu2->info();
$stu2->test();


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40

结果
小结：通过extends关键字，子类可以继承父类所有公共属性和方法；用于减轻代码冗余，增加代码复用和增强可读性；

三.多态

class Animal {
    public function makeSound() {
        echo "动物发出了声音。\n";
    }
}

class Cat extends Animal {
    public function makeSound() {
        echo "猫发出了“喵喵”的声音。\n";
    }
}

class Dog extends Animal {
    public function makeSound() {
        echo "狗发出了“汪汪”的声音。\n";
    }
}

$animal = new Animal();
$cat = new Cat();
$dog = new Dog();

$animal->makeSound(); // 输出：动物发出了声音。
$cat->makeSound(); // 输出：猫发出了“喵喵”的声音。
$dog->makeSound(); // 输出：狗发出了“汪汪”的声音。


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26

小结：多态允许使用父类类型的变量或参数来引用或接受子类对象，从而在运行时可以根据实际对象的类型决定调用哪个子类的方法。

四.final关键字

<?php


class Person
{
    //方法
    public function spekName($name)
    {
        echo "我的名字叫" . $name . "\n";
    }

}

//new：创建一个对象实例。
$Person1 = new Person();

$Person1->spekName("小红");


class Animal extends Person
{

}

$Animal = new Animal();
$Animal->spekName("小鱼");


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

正常结果

<?php


final class Person
{

    //方法
    public function spekName($name)
    {
        echo "我的名字叫" . $name . "\n";
    }


}

//new：创建一个对象实例。
$Person1 = new Person();

$Person1->spekName("小红");


class Animal extends Person
{

}

$Animal = new Animal();
$Animal->spekName("小鱼");


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29

在这里插入图片描述
(当我加了final后，报错)
小结：
使用 final 关键字修饰一个类时，表示该类是最终类，不能被其他类继承。

五.抽象类(abstract)

<?php
//定义一个抽象类
abstract class Person
{
    //定义一个抽象方法
    abstract public function spekName();
    
}

//继承抽象方法
class Student extends Person
{
    public function spekName()
    {
        // TODO: Implement spekName() method.
        echo "my Name is aRon";
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

小结：通过abstract定义的抽象类和抽象方法，抽象类和抽象方法必须被实现类继承；作用：抽象类可以用于定义一组相关的类的规范，提供这些类所需的共同属性和方法。它们定义了一个接口，规定了子类应该实现哪些方法和拥有哪些属性。抽象类允许指定方法的签名，即方法名和参数，但不需要提供具体的实现。

六.接口(Interface)

<?php

interface MyInterface
{
    public function method1();

    public function method2($param);
}

class MyClass implements MyInterface
{
    public function method1()
    {
        echo "Method 1 implementation";
    }

    public function method2($param)
    {
        echo "Method 2 implementation with parameter: " . $param;
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

(解释一下，首先，使用 interface 关键字定义了一个名为 MyInterface 的接口。接口中声明了两个方法：method1() 和 method2($ param)。这些方法没有具体的实现代码，只是定义了方法的名称和参数;
接下来，使用 class 关键字定义了一个名为 MyClass 的类，并使用 implements 关键字实现了 MyInterface 接口。通过实现接口，MyClass 类承诺遵循接口定义的契约，并提供相应的方法实现;
在 MyClass 类中，实现了 MyInterface 接口所声明的方法。method1() 方法输出了 “Method 1 implementation” 字符串，而 method2($param) 方法将传入的参数与字符串拼接后输出)

小结：接口是一种协议或契约，定义了一组方法，规范了类的行为。通过接口，我们能够实现多态性、提高代码的灵活性和复用性，并促进代码的模块化和可维护性

10）PHP操纵数据库

<?php

class Database
{
    private $servername;
    private $username;
    private $password;
    private $conn;

    public function __construct($servername, $username, $password)
    {
        $this->servername = $servername;
        $this->username = $username;
        $this->password = $password;
        $this->conn = new mysqli($servername, $username, $password);
        if ($this->conn->connect_error) {
            die("连接失败: " . $this->conn->connect_error);
        }
    }

    public function createDatabase($databaseName)
    {
        $sql = "CREATE DATABASE $databaseName";
        if ($this->conn->query($sql) === TRUE) {
            echo "数据库创建成功";
        } else {
            echo "Error creating database: " . $this->conn->error;
        }
    }

    public function closeConnection()
    {
        $this->conn->close();
    }
}

// 创建 Database 对象并执行操作
$database = new Database("localhost", "username", "password");
$database->createDatabase("myDB");
$database->closeConnection();

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40

(相信大家有了上面面对对象的基础还是比较容易看懂吧)

11）结语

看完的小伙伴都是最棒的！！！当然想要讲完PHP所有的特性仅靠这一篇文章是远远不够的，比如，PHP也有其基本数据类型，PHP作为弱类型语言，变量的类型可以随时在运行时进行隐式转换，而无需显式地进行类型声明或转换操作；PHP会话控制还有很多其他的内容；PHP同其他语言一样，拥有控制流程和组织代码的语句；异常处理、PDO等等…还有很多特性交给小伙伴们自己去探索了，希望这篇文章对你有所帮助。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/羊村懒王/article/detail/726892
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号