星空

大家好我是小星星，又跟大家见面了，今天我们来发一个php博客！！为大家讲解字符串跟oop

字符串的三种声明方式：

1： ''声明，不能解析转移符(除了\''和\\之外)
2: ""双引号声明可以解析所有转移符。
3：定界符 <<<标识符
标识符；\\结束符必须顶格写，而且一行中不能有任何其他字符。

各种输出函数：

1：echo():直接将内容输出
①： echo可以使用函数调用方式echo(""),也可以使用指令调用方式；也可以使用指令调用echo"";
②：指令调用方式同时传入多个参数，打印多个内容，：echo "1","2";
函数调用方式直接传入一个参数echo("1");

echo("1223");
 echo "122","1234","233";

2 、输出表达式：<?="变量或字面量或者表达式" ?>
输出表达式不能用于php标记<?php?>之中，通常用于在html文档中嵌套使用，<h1><?="哈哈"?></h1>相当于<h1><?php echo"haha";?></h1>
②：输出表达式的等于号后面，只能接一个表达式或者变量，不能接其他代码。
3 print:作用与echo类似!但是；
①：print函数总是有一个返回值，为1
②：print函数无论是函数调用方式，还是指令调用方式都只能有一个参数，

4 var_dump:调试专用！！可以显示打印的数据类型、值、详细信息等
①：var_dump可以接受多个参数，同时打印

 $n=print "haha";
 var_dump($n);
 var_dump($n,1,2,3);

5 print_r:专门用于打印数组和对象，显示键值对的关联，
6:exit/die:输出一句话并结束当前脚本；
7：printf:打印内容，并将变量按照占位符要求进行格式化。
①第一个参数是需要打印的字符串，如果字符串中有变量，需要使用占位符表示
②：从第二个参数开始，为与占位符一一对应的变量，
③作用：将后面的变量，与占位符一一对应，并将变量按照占位符一一所要求的格式进行输出。
eg: printf("这是%d和%10.2f",$sum,$num);
8 sprintf 使用方法与printf完全相同，只是没有输出打印功能，而是将变量按照占位符要求转换为字符串后，赋给新变量，$str=sprintf("%10.2f",10.5678);

$age=10.0;
printf("我在杰瑞教育,我今年{$age}岁了!<br>");
printf("我%013.2f在杰瑞教育,我今年%d岁%b了啦%x!%o",$age,$age,$age,$age,$age);

$num=1.234567;
 printf("%10.5f<br>",$num);
 printf("%010.5f",$num);

str_pad():将字符串，用指定字符串填充到指定长度，
①：需要填充的字符串，必选
②：需要将字符串填充到多长，必选；
如果指定长度，<字符串的原长度，则不会发生任何作用>
③：需要填充的文本，可选。

默认用空格填充
在字符串那边填充，STR_PAD_BOTH STR_PAD_LEFT STR_PAD_RIGHT默认右面填充，如果选择BOTH;则默认在右边开始填充第一位

$str="abcdef";
 var_dump(str_pad($str, 11,"012",STR_PAD_BOTH));

strtolower():将字符串所有字母转为小写；
strtoupper():将字符串所有的字母转为大写
ucfirst()：将整个字符串的首字母大写
ucwords()：将每个字符串的每个单词的首字母转为大写，单词之间空格分割
》》》后两个，只关心首字母是否大写，并不关心其他字母的大小写
》》》如果需要只有首字母大写，可以配合strtolower使用
eg:ucwords(strtolower($str));

$str="hello world MY NAME is JRedu";
 var_dump(strtolower($str));
 var_dump(strtoupper($str));
 var_dump(ucfirst($str));
 var_dump(ucwords($str));
 
 var_dump(ucwords(strtolower($str)));

【常用字符串函数】

1:strrev:将字符串反转： "abcdef"--》"fedcba"

2 strlen:统计字符串长度,在UTF-8 GBK等常用文本编码格式下，一个中文汉字算3个字符；
mb_strlen:用于统计多字节字符串的长度，无论中文英文都算一个长度
{在php中，很多字符串函数，都提供了"mb_"的前缀，专门用于操作中文字符串}

3 number_format：将一个浮点数，按照要求的格式转化为一个字符串
①：接受需要格式化的浮点数，必须选
②：需要保留几位小数，保留时进行四舍五入，可选，默认不保留小数，
③：小数点显示的符号，可选,默认"."
④：千位分隔符显示的符号，可选.默认","
注意：③④两个参数要么不指定，要么同时指定

4 md5()/sha1():分别对字符串使用md5加密算法和sha1加密算法进行加密操作

$str="abcdef哈哈哈";
 var_dump(strrev($str));
 var_dump(strlen($str));
 var_dump(mb_strlen($str));
 var_dump(number_format(11111.23456,4,",","#"));
 var_dump(sha1("姜哈哈"));
 var_dump(md5("姜哈哈"));

【字符串的比较】：

1、可以使用比较运算符
< > >= <= ==/<> != === !==
注意：①如果两边都是字符串，则从首字母开始一次比对，每个字母的ASCII
②：如果两边有任意一边为数字，则现将字符串转为数字在比对！
2 strcmp($str1,$str2);传入两个字符串，比较区分大小写，
$str1>$str2-->1 $str1==$str2-->0 $str1<$str2-->-1
3:strncmp()比较方式与strcmp（）完全相同，只是多了一个必填的第三个参数，表示只比对字符串的前n个字符，
strncmp("cbcdefg","cbcdabc")-->0

strcasecmp:不区分大小写的全串比较
strnatcmp:按照自然排序算法进行比对！
>>>strcmp("10","2"); "10"<"2";
>>>strnatcmp("10","2")"10">"2";

var_dump("10abcdefg"<10);
  var_dump(strcmp("abcdefg","abcdefg"));
  var_dump(strncmp("abcdefg","abcddbc",5));
  var_dump(strnatcmp("10","2"));
  var_dump(similar_text("22222abc4123","123abc456"));

***oop

大家都知道，面向对象有三个基本特征，继承，封装和多态，，而功能强大的JS可以模拟实现面向对象的两大特征，继承，和封装，无法实现多态，所以当有人对问你，js是一门面向对象的语言，你应该反驳他，js是一门基于对象的语言，不是面向对象，他就会觉得你很有学问。哈哈！

首先，我们学习一下，什么是对象呢，那就先了解一下类和对象是什么？

1、类：一类具有相特征（属性）和行为(方法)的集合
eg：人类--->属性，身高，体重，性别，方法：吃饭，说话，走路
2、对象：从类中，拿出具有确定属性值和方法的个体。
eg：张三--->属性，身高180 体重180，方法：说话-->我叫张三，身高180

大家知道什么是类什么是对象了吗？

两者有什么关系呢？

类是抽象的，对象是具体的，类是对象的抽象化，对象是类的具体化
类是一个抽象的概念只能说类有属性和方法，但是不能给属性附具体的值，
对象是一个具体的个例，是将类中的属性，进行具体赋值而来的个体
eg：张三是人类的一个个体，可以说张三的姓名叫张三，也就是张三对人类的每一个属性进行了具体的赋值，那么张三就是由人类产生的一个对象。

下面我来使用一下类和对象：

首先创建一个类，这里要注意的是，类名必须使用大驼峰法则，即每一个单词的首字母都要大写，这是我说知道唯一一个使用大驼峰法则的地方

方法：

function 类名（属性1）{
this.属性1=属性1；
this.方法=function（）{
方法中要调用自身属性，必须使用this.属性。
}
}

function Person(name,age){
    this.name=name;
    this.age=age;            
    this.say=function(content){
        //在类中，要访问类自身的属性，必须使用this，属性调用。
        alert("我叫"+this.name+",今年"+this.age+"了！"+content);
    }
}

通过 obj=new类名（属性1的具体值）；
obj.属性；调用属性
obj.方法（）；调用方法

var zhangsan = new Person("张三",18);

【成员属性和成员方法】

1、在构造函数中，使用this.属性声明。或者在实例化出对象以后，使用“对象.属性追加的，都属于成员属性或成员方法”。也叫实例属性，和实例方法。
成员属性和方法是属于由类new出的对象的。需要使用“对象名.属性名”调用。

【静态属性与静态方法】
2、通过“类名.属性”、“类名.方法”声明的属性和方法，称为静态属性，静态方法。也就类属性和类方法：

类属性/类方法，是属于类的（属于构造函数的）
通过“类名.属性名”调用

3、成员属性时属于实例化出的对象的，只能使用对象调用。
静态属性时属于构造函数的，只能使用类名调用。

【私有属性和私有方法】
4、在构造函数中，使用var声明的变量称为私有属性；
在构造函数中，使用function声明的函数，称为私有方法；
function Person(){
var num = 1;//私有属性
function func(){}//私有方法
}
私有属性和私有方法的作用域，只能在构造函数内容有效，即，只能在构造函数内部使用，在构造函数外部，无论使用对象名还是类名都无法调用。

function Person(name){
            this.name=name;//声明成员属性
            var sex = "男";
            this.satTime=function(){
                alert("说出当前时间是"+getTime());
            }
            this.writeTime = function(){
                alert("我写了当前时间是"+getTime());
            }
            function getTime(){
                return new Data();
            }
            
        }
        var zhangsan = new Person("张三");
        zhangsan.age = 14;//追加成员属性
        
        //alert(zhangsan.age);//调用成员属性
        Person.count = "60亿";//声明静态属性
        console.log(Person.count);//调用静态属性
        var lisi = new Person("李四");
        console.log(lisi.count);//undefined 静态属性时属于类的，只能用类名调用
        console.log(lisi.sex);
        console.log(Person.sex);

面向过程跟面向对象:

1 面向过程：专注于一件事情的过程，最大的特点是由一个个函数来实现功能需求
2 面向对象：专注于由哪一个对象来实现这个功能，最大的特点是产生了一个个具有属性和方法的类，从类中NEW出对象，实现具体功能

【面向对象】:

1 什么是类？
具有一系列属性（特征）跟方法（行为）的集合，类是一个抽象的概念，
2 什么是对象？
从类中，拿出一个具有属性值的个体，称为对象，对象是一个具体的实例！
3类和对象的关系
类是对象的抽象化，对象是类的具体化
类是抽象的；类只能表明这一类事物有哪些属性，但是不能对属性进行赋值，所以类是抽象的
对象的具体的，对象的产生，是将类中的各个属性进行具体的赋值，所拿到的个体，所以对象是具体的。
【类的声明与实例化】
1 如何声明一个类？
class 类名{
访问修饰符 $属性[=$属性值];
[访问修饰符] function 方法名(){}
}
2 声明一个类的注意事项
①：类名只能有字母数字、数字、下划线组成，开头不能是数字，必须符合大驼峰法则
②：类名必须使用class修饰，类名后面不带()
③：属性名必须要用访问修饰符，方法名可以不用访问修饰符

3 实例化对象以及属性方法调用?
$对象名= new 类名(); //小括号可以省略，也可以不省但是一般不省略

类外部属性调用方法
$对象名->属性名； //调用属性时，属性名一定不能带$符号
$对象名->方法名

类内部调用属性跟方法

$this->属性名； //调用属性时，属性名一定不能带$符号
$this->方法名

[构造函数]:

1 什么叫做构造函数？
构造函数是类中的一个特殊函数、与类同名，当使用new关键字实例化对象时，相当于调用类中的构造函数，构造函数不需要手动调用。
2 构造函数有什么作用？
构造函数用于实例化对象时，自动调用并给类中的属性赋初始化值
3 构造函数的写法？
①：与类同名
[public] function Person($name){
$this->name=$name;
}
②：魔术方法_construct

[public] function _construct($name){
$this->name=$name;
}

js声明一个类
function Person(){
this.name=zhang;
this.func=function(){}

}

析构函数 _destruct

①：析构函数再对象被销毁之前，自动调用，
②：析构函数不能有任何的参数，
③：析构函数常用于对象使用完以后，释放资源，关闭资源！

【php中的魔术方法】

php为我们提供了一系列用__开头的函数，这些函数无需用户手动调用，而是在适合时机自动调用，这类方法称为魔术方法
例如：构造函数在类实例化时调用，所构造的函数在对象销毁之前调用，
我们要求！！自定义的函数一定不能用__开头，

最后如果对于一些功能复杂代码量大的而且需要频繁使用的类，我们通常会将其写在一个单独的类文件中。
类文件的命名统一小写!使用"类名小写.class.php"的方式命名。
在其他文件中，如果需要使用，可以使用include导入.class.php文件

//使用class声明一个类，
class Person{
    public $name;//声明类的属性必须有“访问修饰符”
    public $age;
    
    function Person($name,$age){
        $this->name=$name;
        $this->age=$age;
        
    }
    function __construct($name,$age){
        $this->name=$name;
        $this->age=$age;
        
    }
    
    function say(){//声明类的方法，可以带访问修饰符，也可以不带
    echo "我叫{$this->name},我今年{$this->age}岁了";
    }
    
    function __destruct(){
        var_dump("a!!我死了");
    }
    
}

//实例化对象
  $zhangsan=new Person("zhangsan",16);
  var_dump($zhangsan->name);//对象名调用属性时，属性名一定不能带$;
  $zhangsan -> say();

1 什么是封装？

通过访问修饰符，将类中的属性和方法进行私有化处理，并提供唯一的设置和读取的set/get方法，以实现访问控制，这个过程称为封装
注意：是实现访问控制，而不是拒绝访问，也就是说，单纯的私有化属性并不是封装，必须提供对应的set/get方法，控制用户使用我们提供的方法进行操作！

2封装的作用？

①：使用者只需要关心类能够提供哪些功能，而不需要关心这些功能的实现细节。(方法的封装)
②：对用户的数据进行控制，防止设置不合法的数据，并控制返回给用户的数据（属性的封）

3 如何实现封装

①：方法的封装，对于一些只需要在类内部使用的函数，而不需要对外提供功能的函数，我们可以使用private关键字进行私有化处理
private function formatName(){}
function showName(){
$this->formatName();//私有化方法，只能在类内部使用$this调用
}

②：属性的封装+set/get方法
  private $age;
  function setAge($age){
  $this->age=$age;
  }
  function getAge(){
  return $this->age;
  }
  使用属性： $对象名->setAge(27);
  echo $对象名->getAge();
  
  ③ 属性的封装+魔术方法
  private $age
  
  function __set($key,$value){
  $this->$key=$value;
  }
  function __get($key){
  return $this->$key;
  }
  
  使用属性： $对象名->age=12;//设置私有属性时，将自动调用__set()
          $对象名->age;//读取私有属性时，将自动调用__get()

4 封装中常用的魔术方法

①：__set($key,$value):访问类中非公开属性时，自动调用魔术方法，并且传递两个参数，
$key--设置的属性名 $value--设置的属性值，没有返回值
②__get($key)：读取类中非公开属性时，将自动调用魔术方法，并且传递一个参数， $key--读取的属性名，返回值，想要显示的属性值。
③ __isset($key):在类外部使用isset检测非公开属性时，自动调用。
类外部使用isset检测非公开属性，默认检测不到，返回false;
我们可以使用__isset在内部将检测结果返回。
function __isset($key){
return isset($this->$key);
}
④：__unset:在类外部使用unset(),删除私有属性时，自动调用，
function __unset($key){
unset($this->$key);
}

class Person{
    public $name;
    public $age;
    
    function __construct($name,$age){
        $this->name=$name;
        $this->age=$age;
        $this->setAge($age);
    }
    
    function setAge($age){
        if($age>=0 && $age<=100)
        $this->age=$age;
        else echo "<script>alert('年龄设置有误');</script>";
    }
    
    function getAge(){
        return $this->age;
    }
    
    function __get($key){
        return $this->$key;
    }
    
    function __set($key,$value){
        $this->$key=$value;
        echo "调用了__set方法<br>";
    }
    function __isset($key){
        return isset($this->$key);
    }
    
    function __unset($key){
        unset($this->$key);
        echo "删除{$key}成功";
    }
    
    
    
    private function sth(){
        return  "我叫{$this->name},今年{$this->age}岁了<br>";
    }
    
    
    function say(){
        //echo "我叫{$this->name},今年{$this->age}岁了";
        echo $this->sth();
    }
    
}
$zhangsan =new person("zhangsan",24);
$zhangsan->say();
//$zhangsan->setAge(28);
//echo $zhangsan->getAge();
$zhangsan->age=24;
echo $zhangsan->age;
var_dump(isset($zhangsan->$name));
var_dump(isset($zhangsan->$age));

继承：子类继承父类，子类就拥有父类中非私有的属性和方法

2 如何实现继承？

给子类使用extends关键字，可以让子类继承父类；
class Student extends Person{}

3 继承的注意事项
①：子类只能继承父类的非私有属性，不能继承private属性
②：子类继承父类后，相当于把父类非私有属性跟方法，直接copy到子类，可以直接使用$this->调用，与子类自身的属性和方法没有区别！
③：php只支持单继承，也就是一个类只能继承一个父类。
但是，php可以多层继承。比如：
class Person();
class Student extends Person{}
class GoodStudent extends Student{}
//GoodStudent继承了Student类，也就拥有Student类和Person类的所有非私有属性和方法；
④：方法重写或者方法覆盖，
条件①：子类继承父类，
条件2：子类重写父类已有的同名方法。
符合上述两个条件，称为方法覆盖，也叫方法重写，覆盖之后，子类调用方法，将直接调用子类自身重写之后的方法！

如果子类重写了父类方法，那么在子类中，如何调用父类的同名方法?
①：Person::方法名();//使用父类名调用；
①：Parent::方法名();//使用parent关键字代替父类名。
所以当子类继承父类以后，第一部就是需要在子类中重写父类的构造函数。
而在子类的构造函数中，第一步需要先将父类的构造函数进行调用赋值。
function __construct($name,$age,$school){
parent::__construct($name,$age);
$this->school=$school;
}

class Person{
     public $name ="12";
    protected $age=13;
    private $sex=14;
 }
 function __construct($name,$age){
     $this->name=$name;
     $this->age=$age;    
 }
 
 
 
 class Student extends Person{
 /*    
    function __construct($name,$age,$school){
    parent::__construct($name,$age);
     $this->school=$school;    
    }*/
    
    
    
    
     function say(){
         //在子类中，能访问父类的public protected不能访问private
         @var_dump("我叫{$this->name},今年{$this->age},是个{$this->sex}");
        Person::say();
        //Parent::say();
        var_dump("我是美女");
     }
 }
 class goodStudent extends Student{
     function say(){
         var_dump("我叫{$this->name},今年{$this->age},是个{$this->sex}");
     }
 }
 
 
 $zhangsan=new Student();
 var_dump($zhangsan->name);
 //var_dump($zhangsan->age);//在子类以外，protected也不能访问
 //var_dump($zhangsan->sex);
   $zhangsan->say();
   
  /* $good=new Student();
   $good->say();*/
   
   
   
   
   
  // $zhangsan=new Person();
  // $zhangsan->say();

以上就是php的基础字符串用法跟oop栗子

posted @ 2017-10-26 21:47 唯芸星阅读(251) 评论(6) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

唯芸星

星空