注：学习php之前最好快速过一遍前端html(如果你学过java，那你会更加容易理解这篇文章)。
HTML推荐观看教程：;
PHP推荐观看教程：；;
JAVA推荐观看教程：;
,phpStorm
phpStorm配置解释器
(在电脑web端中查看这篇文章，下列所有代码块中紫色的为关键字)
单个php文件时
<?php
php与html混编时
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<?php
echo "php";
?>//必须要有这个才会被认为php语句
</body>
</html>
php中声明变量以$开始
$a ="我是变量";
echo $a;
两种定义常量的方式
<?php
define("PI", 3.14 ,false);
/*
define "常量名",常量值。
false为可选参数，如果设置为 TRUE，该常量则大小写不敏感，默认是大小写敏感的。
自 PHP 7.3.0 开始，定义不区分大小写的常量已被弃用。从 PHP 8.0.0 开始，只有 false 是可接受的值，传递 true 将产生一个警告
*/
const PI=3.14;
// const 常量名 = 常量值;
//常量一旦被定义就不能随意取消或更改
//我是单行注释
/*
我是
多行
注释
*/
$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";
$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";
function sayHello() {
echo "Hello, world!";
}
// 调用函数
sayHello(); // 输出：Hello, world!
// !!函数不调用是没有返回值的
require '文件名';
require_once '文件名'
include '文件名'
include_once '文件名'
/*区别:
当使用 require 时，如果包含的文件不存在或发生错误，PHP 会发出一个致命错误（Fatal Error），停止执行脚本。
当使用 include 时，如果包含的文件不存在或发生错误，PHP 会发出一个警告（Warning），继续执行脚本。
require_once和include_once的作用交给小伙伴自己探索吧
*/
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);
（实现一个留言板）
<!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>
用法: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 数据。它是一个关联数组)
演示如何启动会话、设置和获取会话变量，以及检查和销毁会话。
<?php
//cookie的生命周期为1小时
setcookie('username','john',time()+3600);//time()为格林威治时间，也可以称为时间戳，每秒+1
print_r($_COOKIE);
//启动会话：
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); // 设置会话过期时间为 一小时
演示如何启动会话、设置和获取会话变量，以及检查和销毁会话。
其实我们平常已经听的够多了，人类，鱼类，鸟类…是抽象的，是对一系列事物的概览。比如人类，不同的人都有名字，都有年龄，都有性别；不同的鱼，都生活在水里，都有鳍；不同的鸟，都会飞，都有羽毛…这就是类，对一类事物的描述。
！！面向对象是一种思想，并不是技术，至于具体怎么样去做，才是技术。
//class：定义一个类为Person。
class Person {
//属性
public $name;
public $age;
public $sex;
}
//new：创建一个对象实例。
$Person1 = new Person();
$Person1->name='小明';
$Person1->age=20;
$Person1->sex='男';
小结：
类是抽象的，代表一类事物；对象是具体的，是类的实例化；类是对象的模板，对象是类的一个个实例;
类通过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;
小结：
面对对象里面的方法，你也可以理解为，面对过程中的函数就是面对对象中的方法；
对象过程中函数需要调用才能执行，面对对象中，方法需要创建一个实例，然后调用方法；
//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
可以看到名字属性，说话的方法被设为私有之后对象已经访问不到了
<?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;
小结：(构造方法的作用)
(__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;
(也可以主动销毁)
小结：
(__deconstruct)析构方法与构造方法一样，会被自动调用；析构方法是用来在对象销毁时主动释放资源；
<?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";
(可能有小伙伴这里比较疑惑，我解释下，self关键字用于访问当前类的静态成员（包括静态属性和静态方法）。:: 是范围解析操作符，用于访问类的静态成员。所以，self::$count++ 表示对当前类的静态属性 $count 进行自增操作。在这里 等价于Person:: $count++，其中 Person 是类名。)
小结：
静态属性（Static Properties）：通过使用 static 关键字声明的属性是属于类的，而不是属于类的实例。
静态方法（Static Methods）：通过使用 static 关键字声明的方法是属于类的，而不是属于类的实例。
意义：通过使用静态属性，可以实现数据在类的所有实例之间的共享。这意味着多个对象可以访问和修改相同的数据，从而在不同实例之间传递信息。
<?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
小结：
通过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 '研究生在考试';
}
}
不知道大家发现问题没有，两个类都有相同的属性，明明只需要写一遍，但是我们却写了两遍。不管是小学生还是研究生，我们都可以抽象为一个类-----学生。
<?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 '研究生在考试';
}
}
实例化对象
<?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();
小结：通过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(); // 输出：狗发出了“汪汪”的声音。
小结：多态允许使用父类类型的变量或参数来引用或接受子类对象，从而在运行时可以根据实际对象的类型决定调用哪个子类的方法。
<?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("小鱼");
<?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("小鱼");
(当我加了final后，报错)
小结：
使用 final 关键字修饰一个类时，表示该类是最终类，不能被其他类继承。
<?php
//定义一个抽象类
abstract class Person
{
//定义一个抽象方法
abstract public function spekName();
}
//继承抽象方法
class Student extends Person
{
public function spekName()
{
// TODO: Implement spekName() method.
echo "my Name is aRon";
}
}
小结：通过abstract定义的抽象类和抽象方法，抽象类和抽象方法必须被实现类继承；作用：抽象类可以用于定义一组相关的类的规范，提供这些类所需的共同属性和方法。它们定义了一个接口，规定了子类应该实现哪些方法和拥有哪些属性。抽象类允许指定方法的签名，即方法名和参数，但不需要提供具体的实现。
<?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;
}
}
(解释一下，首先，使用 interface 关键字定义了一个名为 MyInterface 的接口。接口中声明了两个方法：method1() 和 method2($ param)。这些方法没有具体的实现代码，只是定义了方法的名称和参数;
接下来，使用 class 关键字定义了一个名为 MyClass 的类，并使用 implements 关键字实现了 MyInterface 接口。通过实现接口，MyClass 类承诺遵循接口定义的契约，并提供相应的方法实现;
在 MyClass 类中，实现了 MyInterface 接口所声明的方法。method1() 方法输出了 “Method 1 implementation” 字符串，而 method2($param) 方法将传入的参数与字符串拼接后输出)
小结：接口是一种协议或契约，定义了一组方法，规范了类的行为。通过接口，我们能够实现多态性、提高代码的灵活性和复用性，并促进代码的模块化和可维护性
<?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();
(相信大家有了上面面对对象的基础还是比较容易看懂吧)
看完的小伙伴都是最棒的！！！当然想要讲完PHP所有的特性仅靠这一篇文章是远远不够的，比如，PHP也有其基本数据类型，PHP作为弱类型语言，变量的类型可以随时在运行时进行隐式转换，而无需显式地进行类型声明或转换操作；PHP会话控制还有很多其他的内容；PHP同其他语言一样，拥有控制流程和组织代码的语句；异常处理、PDO等等…还有很多特性交给小伙伴们自己去探索了，希望这篇文章对你有所帮助。
因篇幅问题不能全部显示，请点此查看更多更全内容