注:学习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等等…还有很多特性交给小伙伴们自己去探索了,希望这篇文章对你有所帮助。
因篇幅问题不能全部显示,请点此查看更多更全内容