当前位置:首页 > 网站技术 > 后端技术 > 正文内容

PHP入门基础之面向对象语法

小彬2020-07-20后端技术121

对象是程序中的一种数据结构,用来表现某个事物。相反,任何事物在程序中可以用某个对象来表示。

对象包括变量和函数。对象中的变量叫做属性,对象中的函数叫做方法

对象的属性和方法可以描述表达万事万物

1、面向对象简介

对象 -->归纳,终结(抽象) -->类

类  --> 具体化实现(实例化)  -->对象

面向过程:把所有事物看作一整个运行过程

面向对象:把所有事物看作一个个对象交互运行,由类得到具体的对象,由对象实现具体的工作

    

面向对象三大特性:

封装:把对象的属性和服务结合成一个独立的相同的单位,并尽可能隐蔽对象的内部细节只保留有限的对位接口使之与外部发生联系

继承:子类自动共享父类数据结构和方法的机制,这是类之间的一种关系。在定义和实现一个类的时候,可以在一个已经存在的类的基础之上来进行,把这个已经存在的类所定义的内容作为自己的内容,并加入若干新的内容。

多态:指相同的操作或函数、过程可作用于多种类型的对象上并获得不同的结果。不同的对象,收到同一消息可以产生不同的结果,这种现象称为多态性。

2、类与对象实现

1如何声明类

[]表可以省略,不需要写   

声明类使用关键字class

[修饰符]class 类名
{
    [属性]
    [方法]
}

规则:

类名遵循大写开头的驼峰命名规范

类的开始花括号必须在其声明后自成一行,结束花括号也一样。(不自成一行也行)

类的属性和方法必须添加访问修饰符private[私有]、protected[保护]、public[公共]、var(被视为public,不建议使用)

属性中的变量可以初始化,但是初始化的值必须是常数。这里的常数是指PHP脚本在编译阶段时就可以得到其值,而不依赖于运行时的信息才能求值 

 PHP入门基础之面向对象语法

(目前高版本的PHP支持使用表达式初始化属性,但为了保证代码的正确和规范性,建议还是使用常量对属性进行初始化)

如上图的$var1和$var3是可以实例化输出


2类实例化

$obj = new Dog(); (实例化时,类名后面的括号可加可不加)

<?php 
class Cat
{
 public $name = '彬十二';
 public $sex;
 public function jiao()
 {
     echo 'miaomiao~';
 }
}
$cat1 = new Cat();
var_dump($cat1); //object(Cat)#2 (2) { ["name"]=> string(9) "彬十二" ["sex"]=> NULL }
?>


3属性、方法的调用

可以用  ->(对象运算符)来访问非静态属性

echo $cat1->jiao();
echo $cat1->name;

属性赋值:$cat1 ->sex = 'new'


当一个方法在类定义内部被调用时,有一个可用的伪变量$this。$this代表当前正在使用的对象

class Cat
{
 public $name = '彬十二';
 public $sex;
 public function jiao()
 {
    //  echo 'miaomiao~';
    echo '我叫'.$this->name;
 }
}
$cat1 = new Cat();
var_dump($cat1->jiao()); //我叫彬十二

3、传递赋值、引用赋值

1.基本类型的传递赋值和引用赋值

$a =1;

//传递赋值
$b=$a;
//引用赋值&
$c=&$a;

var_dump($a);
var_dump($b);
var_dump($c); 

//$a=1,$b=1,$c=1;


$a='qq';
var_dump($a);
var_dump($b);
var_dump($c);

//$a='qq',$b=1,$c='qq';
 //变量$a和$c操作的是同一内存空间,$a是什么$c就是什么,反过来也一样
 传递赋值,两个变量各自独立,互不影响


2.复合类型的传递赋值和引用赋值

复合类型的传递赋值

class MyClass
{
 public $name = '猫';
}
$a =new MyClass();//$a存的是对象标识符
$b =$a;   //传递赋值,$a把标识符传给$b
var_dump($a);
var_dump($b);
//$a,$b = '猫'
$a -> name='还是说';
var_dump($a);
var_dump($b);
//$a,$b ='还是说'
$a =123;
//$a 重新赋值 存的是'还是说' $b存的是对象标识符
var_dump($a);
var_dump($b);
//$a=123,$b ='还是说'


复合类型的引用赋值

$b =&$a; //引用赋值,把$a的引用赋值给$b,$a是啥,$b就是啥 

和传递赋值的区别就在 对$a的直接赋值,$b也会随之改变


4、封装

隐藏对象的属性和实现细节,仅对外提供公共的调用,控制在程序中属性的读取和修改的访问级别

访问控制(可见性约束):对属性或方案的访问控制,是通过在前面添加关键字public(公有),protected(受保护),private(私有)来实现的。

    被定义为公有的类成员可以在任何地方被访问

    被定义为受保护的类成员则可以被其自身以及其子类和父类访问

    被定义为私有的类成员则只能被其定义所在的类访问

   PHP入门基础之面向对象语法

 例子:

        <?php
        class MyClass
        {
            public $a='public';
            protected $b='protected';
            private $c='private';
            public function show()
            {
                // 类的内部调用
                // echo $this->a; //public
                // echo $this->b; //protected
                // echo $this->c; //private
            }
        }
        $obj=new MyClass();
        // 类外 以对象的方式调用
        // echo $obj->a; //public
        // echo $obj->b; //Fatal error
        // echo $obj->c; //Fatal error
        $obj->show()
        ?>


5、魔术方法


构造函数:具有构造函数的类会在每次创建新对象时先调用此方法,所以非常适合在使用对象之前做一些初始化工作。

public function __construct([参数])
{
    方法体...
}

例子:
class MyClass
{
    public function __construct($n)
    {
        echo '调用了__construct------'.$n;
    }
}
$obj1 =new MyClass('123'); //调用了__construct------123


析构函数:会在某个对象的所有引用都被删除或者当对象被显式销毁时执行

public function __destruct()
{
    方法体...
}
例子:


class MyClass
{
    public function __destruct()
    {
        echo '对象被销毁了!';
    }
}
$obj =new MyClass();
$obj =null ;//"对象被销毁了!"
unset($obj);//"对象被销毁了!"
exit('结束掉');//"结束掉对象被销毁了!"


6、静态属性、静态方法

static 关键字来定义静态方法和属性

声明类属性或方法为静态,就可以不实例化类而直接访问

静态属性不能通过一个类已实例化的对象来访问(但静态方法可以 $self::$a)

静态属性不可以由对象通过 -> 操作符来访问。

由于静态方法不需要通过对象即可调用,所以伪变量$this在静态方法中不可用。

静态方法访问   ::  或者  self::

内部/外部 类名::属性名  类名::方法名

内部调用 self::属性名  self::方法


例子:

class MyClass{
    public static $a='static';
    public static function fun1(){
        echo '静态方法调用';
        echo MyClass::$a;  //static
        echo self::$a;     //static
        echo '<hr/>';
        MyClass::fun2();  //'this is fun2()'
        self::fun2();   //'this is fun2()'
    }
    public static function fun2(){
        echo 'this is fun2()';
    }
}
echo MyClass::$a; //static
MyClass::fun1();  //静态方法调用staticstatic



非静态方法里面可以使用$this调用静态方法

例子:

public function fun3(){
    echo MyClass::$a;  //static
    echo MyClass::fun2();  //this is fun2()
    $this->fun2();   //this is fun2()
}
$obj=new MyClass();
echo $obj->fun3();

7、const 常量

关键字const可以把在类中始终保持不变的值定位为常量

常量的值是一个定值,调用方式同static

常量一经定义不能修改

例子:

class MyClass{
    public static $a='abc';
    [public] const NUM=123;
}
echo MyClass::$a; //abc
echo MyClass::NUM;//123

8、重载

PHP所提供的“重载”是指动态的“创建”类属性和方法。我们是通过魔术方法来实现的,

当调用当前环境下未定义或不可见的类属性或方法时,重载方法会被调用。

属性重载

在给不可访问属性赋值时,__set($n)会被调用。

读取不可访问属性的值时,__get($n,$v)会被调用。

当对不可访问属性调用isset()或empty()时,__isset($n)会被调用。

当对不可访问属性调用unset()时,__unset($n)会被调用。


<?php 
// 属性的重载
class Person{
  public $name ='小芳';
  protected $age =18;
  
  //__get 使用列子:
  public function __get($n){
     //   echo '触发了不可读取的属性'.$n;
      return $this->age; //此句是方便查看更新后的$v
  }
  
  //__set 使用列子:
  public function __set($n,$v){
      echo '触发了设置属性'.$n.'值为'.$v;
      $this->$n =$v; //此时设置了age为传入的$v,
  }
}
$ren =new Person();
echo $ren->age; //触发了不可读取的属性age
$ren->age =30; //触发了设置属性age值为30
echo '<hr/>';
echo $ren->age //此时输出的是$v
?>
//__inset() 和 __unset()
<?php 
class Person{
    public $name ='小芳';
    protected $age =18;
    public function __isset($n){
        echo '判断一个不可访问的属性是否存在'.$n;
    }
    public function __unset($n){
        echo '销毁一个不可访问的属性'.$n;
    }
}
isset($ren->age);//判断一个不可访问的属性是否存在age
unset($ren->age);//销毁一个不可访问的属性age


方法重载

public function __call ( string $name , array $arguments )
public static function __callStatic ( string $name , array $arguments )

在对象中调用一个不可访问方法时,__call() 会被调用。

在静态上下文中调用一个不可访问方法时,__callStatic() 会被调用。

$name 参数是要调用的方法名称。$arguments 参数是一个枚举数组,包含着要传递给方法 $name 的参数。以逗号分隔


<?php
class MethodTest 
{
    public function __call($name, $arguments) 
    {
        echo $n.'<hr/>';
                var_dump($v);
    }
    /**  PHP 5.3.0之后版本  */
    public static function __callStatic($name, $arguments) 
    {
        echo $n.'<hr/>';
               var_dump($v);
    }
}
$obj = new MethodTest;
$obj->ageList('aaaa');  //ageListarray(1) { [0]=> string(4) "aaaa" }
MethodTest::ageLists('ssss,222','ddd');  // PHP 5.3.0之后版本 ageLists array(2) { [0]=> string(8) "ssss,222" [1]=> string(3) "ddd" }
?>

9、继承

子类继承父类所有公有的和受保护的属性和方法

extends 继承,一个类继承另一个类,不能继承多个

子类,父类,基类2,超类,派生类

派生类,子类是指继承于基类的类

基类,父类,超类是指被继承的类


例子:

<?php
class FatherClass
{
    public $a ='public';
    protected $b='protected';
    private $c= 'private';
    public function func1(){
        echo 'public func1';
    }
    protected function func2(){
        echo 'protected func2';
    }
    private function func3(){
        echo 'private func3';
    }
}
class SonClass extends FatherClass
{
    public function test(){
        $this->func1(); //public func1
        $this->func2(); //protected func2
        $this->func3(); //Fatal error
    }
}
$obj =new SonClass();
$obj->test();
?>


10、重写

继承父类中的方法,子类中定义的与父类同名的方法(说白了就是覆盖)

当一个子类重写其父类中的方法时,PHP不会调用父类中已被重写的方法。是否调用父类的方法取决于子类

关键字 parent:: 访问父类中的被重写的属性和方法


例子:
<?php
class Father{
    public function shuo(){
        echo 'a a o o';
    }
}
class Son extends Father{
    public function shuo(){
        parent::shuo(); //a a o o
        echo 'hello';  //hello
    }
}
$obj=new Son();
$obj->shuo(); 
//a a o ohello
?>



11、final关键字

如果父类中的方法被声明为final,则子类无法重写该方法。如果一个类被声明为final,则不能继承


例子:

<?php
class Father{
    final public function shuo(){
        echo 'a a o o';
    }
}
class Son extends Father{
    public function shuo(){
        echo 'hello';  //Fatal error
    }
}
$obj=new Son();
$obj->shuo();
?>

注:注释Son->shuo()函数。程序输出'a a o o'


12、多态抽象

字面意思是多种状态,接口的多种不同的实现方式即为多态。同一操作作用于不同的对象,可以有不同的解释,产生不同的执行结果

抽象类:抽象类至少要有一个抽象方法,声明关键字abstract

抽象的方法只是声明了其调用方式(参数),不能定义其具体的功能实现

抽象类不能被实例化。有抽象方法就要有抽象类


抽象类例子:

<?php
abstract class MyAbsClass
{
    public $name ='张三';
    public $age;
    public function test(){
        echo 'hello';
    }
    abstract public function func();
}
class ChildClass  extends MyAbsClass
{
    public function func(){
    }
}
abstract class SonClass extends MyAbsClass
{
}
?>


修饰关键字的顺序

类的属性和方法必须添加访问修饰符(private,protected,public)

abstract 和final 必须声明在访问修饰符之前

static 必须声明在访问修饰符之后

13、接口(interface 定义)

可以指定某个类必须实现哪些方法和定义常量,但不需要定义这些方法的具体内容。

即接口里定义的方法都是抽象方法,只有方法名称,没有方法体,不需要加抽象关键字abstract

实现:关键字 implements 一个类可以实现多个接口

接口也可以继承 关键字 extends


例子:

类实现接口

class A implements Ainter

// 定义一个接口
interface MyInterface
{
    public function func();
    public function test();
}

// 在类中实现接口
class MyClass implements MyInterface{
    public function func(){
    }
    public function test(){
        echo 'hello';
    }
}

// 定义抽象类继承自myinterface
abstract class MyAbsClass implements MyInterface{
    abstract function func();
    abstract function test();
}


接口与接口之间实现继承

Ainter extends Binter

interface MyClass 
{
    public function func();
}
interface BitVe extends MyClass
{
    public function test();
}
class MyCass implements BitVe
{
    public function func(){
        
    }
    public function test(){
        
    }
}


一个类可以实现多个接口

class A extends B implements Ainter,Binter,Cinter...

interface MyClass 
{
    public function func();
}
interface BitVe{
    public function test();
}
//也可以继承其他类 完全写法
class MyCass [extends ThreeClass] implements MyClass,BitVe
{
    public function func(){
        
    }
    public function test(){
        
    }
}

14、面向对象程序设计


类型约束

自动加载

对象、类、抽象类、接口


类型运算符

instanceof 用于确定一个PHP变量是否属于某一类class的实例

instanceof 也可以用来确定一个变量是不是继承自某一父类的子类的实例

instanceof 也可以用于确定一个变量是不是实现了某个接口的类的实例

例子:

interface A{
    public function func();
}
abstract class B implements A{
    abstract public function func();
}
class C extends B{
    public function func(){
        echo 'ok';
    }
}
class D extends B{
    public function func(){
        echo '好的';
    }
}
/**
 * B实现了 A
 * C、D继承自B
 * C、D是兄弟
 */
$obj =new C();
var_dump($obj instanceof C); //true
var_dump($obj instanceof D); //false 判断是否属于某个类的实例
var_dump($obj instanceof B); //true  判断是否属于某个子类的实例
var_dump($obj instanceof A); //true  判断是否属于实现了某个接口的类的实例



类型约束

PHP5 可以使用类型约束。函数的参数可以指定其类型

如果一个类或接口指定了类型约束,则其所有的子类或实现也都如此

类型约束不能用于标量类型如int 或string

例子:

<?php
class A{
       //要求传输入C的类
    public function test(C $n){
        echo 'ok';
    }
}
class B{
}
class C extends B{
}

class D extends C{
}
$objA = new A();
$objB = new B();
$objC = new C();
$objD = new D();
$objA->test($objC);//'ok'
$objA->test($objB);//Fatal error: B不是C的子类
$objA->test($objD);//'ok' D是C的子类
?>


总结:在类的类型约束中,如果变量是约束类的子类实例化对象,即满足约束条件,如果是父类或者兄弟类则不满足


自动加载

在实际项目中,有可能会有很多类在不同的PHP文件里,自动加载可以帮助我们去加载类 

__autoload()函数也能自动加载类和接口(自php7.2.0起,此功能已被弃用)

spl_autoload_register()函数可以注册任意数量的自动加载器,当使用尚未被定义的类(class) 和接口(interface)时自动去加载。

1、定义函数方法自动加载类

例子:
// 在类A的时候spl_autoload_register调用myloader函数

function myloader($a){
    // var_dump($a); //B
    // 新建一个类目录 myclassfolder 放B.class.php===> "class B{}"
    include 'myclassfolder/'.$a.'.class.php';
}
/**
 * 三个参数:
 * 参数1 :需要注册的自动加载函数
 * 参数2:如果没有找到1,是否抛出错误
 * 参数3:是否把参数1 函数添加到队列之首
 */
 
spl_autoload_register('myloader',true,true);

class A extends B
{
}

myclassfolder/B.class.php

<?php
class B{
  
}

?>

2、类中有静态方法


// spl_autoload_register 第一个参数以数组方式传入

例子:

<?php
class myloader{
    //
    public static function mychild($a){
        // 新建一个类目录 myclassfolder 放B.class.php===> "class B{}"
        include 'myclassfolder/'.$a.'.class.php';
    }
}
spl_autoload_register(['myloader','mychild'],true,true);
class A extends B
{
}

myclassfolder/B.class.php
<?php
class B{
  
}

?>


3、不用静态方法,实例化对象才能调用

例子:

class MyLoader{
    public function mychild($a){
        include 'myclassfolder/'.$a.'.class.php';
    }
    public function init(){
        // spl_autoload_register 第一个参数以数组方式传入
        spl_autoload_register([$this,'mychild'],true,true);
    }
}
//注册spl,并调用init()方法
$obj =new MyLoader();
$obj->init();
class A extends B
{
}

myclassfolder/B.class.php
<?php
class B{
  
}

?>



4、使用自动加载去加载接口


例子:

// 在类A的时候spl_autoload_register调用myloader函数

function myloader($a){

    // var_dump($a); //B
    // 新建一个类目录 myclassfolder 放C.class.php===> "class C{}"
    include 'myclassfolder/'.$a.'.class.php';
}
spl_autoload_register('myloader',true,true);

class A implements C
{
    public function test(){
    }
}

myclassfolder/C.class.php

<?php
interface  C
{
      public function test();
}

?>


对象、类、抽象类、接口


一个类实现多个接口

抽象类可以实现接口,但不可以实例化

类与类之间叫继承 

接口与接口之间叫继承

类与接口之间叫实现

类与对象之间叫实例化

对象抽象得到类

类抽象得到抽象类

抽象类只留下没有实现的方法和常量

 PHP入门基础之面向对象语法

 PHP入门基础之面向对象语法




15、命名空间

 从广义上来说,命名空间是一种封装事务的方法,很多地方都可以见到这种抽象概念

 在PHP中,命名空间用来解决在编写类库或应用程序时创建可重用的代码如类或函数时碰到的两类问题


 1,用户编写的代码与PHP内部的 类/函数/常量 或 第三方类/函数/常量 之间的名字冲突

 2,为很长的标识符名称(通常是为了缓解第一类问题而定义的)创建一个别名(或简短)的名称,提高源代码的可读性


 定义命名空间

 通过关键字namespace来声明。如果一个文件中包含命名空间,它必须在其他所有代码之前声明命名空间。

两种命名空间二选一
   namespace MyProject1;
   /*内容代码*/
   
  namespace MyProject2{
      /*内容代码*/
  };
  例子: 此时都能输出test()
 
 namespace MySapce{
    function test(){
        echo 'test1';
    }
    test(); //test1
  
  }

namespace MySapce2{
    function test(){
        echo 'test2';
    }
    test(); //test2 
}


使用分号定义命名空间,\空间名\ 调用空间下的方法。"\"表示全局命名空间       


 namespace MySapce;
    function test(){
        echo 'test1';
    }
    
namespace MySapce2;
    function test(){
        echo 'test2';
    }
    
test(); //namespace MySapce2 test();

\A\time(); //namespace MySapce test();

echo \time(); //调用全局空间的系统命名的time()


声明单个命名空间 :namespace MyProject;

定义子命名空间:namespace MyProject\Sub\Level;

可以在同一个文件中定义多个命名空间

全局空间:如果没有定义任何命名空间,所有的类与函数的定义都是在全局空间,与PHP引入命名空间概念前一样

在名称前加上前缀\表示该名称是全局空间中的名称,即使该名称位于其他的命名空间中时也是如此。

__NAMESPACE__常量是包含当前命名空间名称的字符串。

在当前命名空间使用,输出的就是当前命名空间


在全局的命名空间,不包括在任何命名空间中的代码,它包含一个空的字符串


例子:

namespace A\B;
class MyClass
{
    public function __construct(){
        echo 'testA\B';
    }
}
    
namespace A;
class MyClass
{
    public function __construct(){
        echo 'testA';
    }
}

$obj =new MyClass(); //testA     非限定名称

$obj =new \A\B\MyClass(); //testA\B  完全限定名称

$obj =new \A\MyClass(); //testA 完全限定名称

$obj =new \B\MyClass(); //testA\B 相对路径 限定名称


使用include引入外部文件不会导致当前页面命名空间的改变

在调用外部文件里的类直接写 限定名称 。

只有实例化外部文件才会导致命名空间的变化($obj= new \A\MyClass();)


命名空间和动态语言特征

动态访问元素

必须使用完全限定名称和限定名称(包括命名空间前缀的类名称);

注意因为在动态的类名称、函数名称或常量名称中,限定名称和完全限定名称没有区别,因此其前导的反斜杠是不必要的。  

例子:

1、
$a ='classname';
$obj =new $a; //等于实例化classname这个类

//如下:
class ClassSqy
{
    public function test(){
        echo 'shuchu';
    }
}
$a ='ClassSqy';
$obj =new $a;
var_dump($obj->test()) //shuchu 


2、
namespace A\B;
function test()
{
    echo 'test function';
}

namespace A;
$a ='\A\B\test';
$a(); //  \A\B\test()


3、
$b="funcname";
$b();//等于调用这个函数的名称

动态访问命名空间的元素

$a='\namespacename\classname';

$obj =new $a; //实例化$a的命名空间并调用

$a='namespacename\classname';
$obj =new $a;

调用函数

$b='namespacename\funcname';
$b();
$b='\namespacename\funcname';
$b();

限定名称和完全限定名称结果是一样的



使用命名空间:别名/导入


允许通过别名引用或导入外部的完全限定名称,是命名空间的一个重要特征

支持三种别名或导入方式:为类名称使用别名、为接口使用别名或为命名空间名称使用别名

PHP5.6开始允许导入函数或常量或者为他们设置别名


通过操作符use来实现


namespace foo;

use My\Full\Classname; //导入

use My\Full\Nsname as MyNS; //别名导入


//导入多个

use My\Full\Classname as Another,My\Full\Nsname;


ALL:
function myLoader($name){
    echo $name;
    exit();
}
spl_autoload_register('myLoader',true,true);


1
// 导入空间 完全限定名称,不要第一个\
use A\B\C\MyClass;
$obj =new MyClass(); //A\B\C\MyClass


2
// 导入多个
use A\B\C\MyClass,C\D\Test;
$obj =new Test(); //C\D\Test
$obj =new MyClass(); //A\B\C\MyClass


3.1
//导入多个 并且取别名 as
use A\B\C\MyClass as T,C\D\E\Test ;
//实例化 导入类
$obj =new T(); //A\B\C\MyClass

3.2
use A\B\C\MyClass,C\D\E\Test as T;
$obj =new T(); //C\D\E\Test


4
use A\B\C\MyClass as T;
//空间方式使用,导入空间
$obj = new T\MyClass();//A\B\C\MyClass\MyClass


5
//按接口方式使用, 导入 接口
class Person implements T
{
}//A\B\C\MyClass

PHP5.6开始允许导入函数或常量或者为他们设置别名


2、导入函数或常量

two.php
namespace A\S\D;
function func(){
    echo 'namespace A\S\D function func()';
}
CONST NUM=123;



one.php
include 'two.php'
//导入函数
use function A\S\D\func;
func();//namespace A\S\D function func()
//导入 常量
use const A\S\D\NUM; 
echo NUM; //123
//设置别名
use function A\S\D\func  as xx;
xx(); //namespace A\S\D function func()

1.函数和常量不能像类,空间一样多个连在一起导入。

2.建议在平时使用时,不管是空间,还是类或者函数,常量,都单个导入。


标签: php
分享给朋友:

相关文章

PHPCMS实现表单提交数据功能

PHPCMS实现表单提交数据功能

PHPCMS实现表单提交数据功能一般的童鞋可能都会遇到明明在后台设置了表单,为啥在前台页面只提交了一次就不能提交了。造成这个原因是因为在phpcms后台表单设置里,默认设置了否的“允许同一IP多次提交...

 PHP入门基础之会话控制基础和实战

PHP入门基础之会话控制基础和实战

1、会话控制基础会话是具有逻辑关联的多个简单交互的集合简单交互模型逻辑关联http是无状态协议每个请求都是单独处理的,协议无法识别当前用户。有状态vs无状态  (跟朋友吃饭【不用二次介绍】...

PHPCMS完成手机端搭建全教程(新手看完即会)

PHPCMS完成手机端搭建全教程(新手看完即会)

注:这篇文章是在我做完一个自适应和一个响应式网站后写的。所以我建议,如果可以的话,最好用@media css做响应式网站,这样就不用考虑手机端的各种问题。因为我当初做的就是自适应,但是没有想到后面的坑...

PHP入门基础之知识汇总

PHP入门基础之知识汇总

PHP官网:https://www.php.net/1、php基础语法:标准风格 <? php 代码段; ?>如果文档中只有PHP代码,结果标记要省略(规范?)短风格 <?代码段;...

PHPCMS里Apache服务器的伪静态和定制404页面

PHPCMS里Apache服务器的伪静态和定制404页面

1、首先网站根目录要有.htaccess文件,我做的网站服务器是Apache,所以这里就先不讲nginx服务器环境下了,听说nginx环境更简单。 2、然后直接在.htaccess文件配置网...

发表评论

访客

◎欢迎参与讨论,请在这里发表您的看法、交流您的观点。

分享:

支付宝

微信