面向对象的基本概念，面向对象编程，oop，面向对象，面向对象的分析，面向对象的设计，面向对象的编程，什么是类。

类，属性和方法，类，对象，面向对象编程的三大特点。特点，封装性，继承性，多态性。

封装性，也可以称为信息隐藏。

继承性就是派生类（子类）自动继承一个或多个基类（父类）中的属性与方法，并可以重写或添加新的属性或方法。

多态性是指同一个类的不同对象，使用同一个方法可以获得不同的结果，这种技术称为多态性。

类的定义，成员方法，类的实例化，成员变量，类常量，构造方法和析构方法，继承和多态的实现，数据的隐藏，静态变量。

类的定义：

  1. <?php
  2. class SpoObject{			//定义类
  3. 	//…
  4. }
  5. ?>

成员方法：

  1. <?php
  2. 	class SportObject{
  3. 		function beatBasketball()($name,$height,$avoirdupois,$age,$sex){	//声明成员方法
  4. 			echo "姓名：".$name;	//方法实现的功能
  6. 		}
  7. 	}
  8. ?>

类的实例化:

  1. 对象名 -> 成员方法

成员变量

类中的变量，也称为成员变量

关键字 成员变量名

对象名 -> 成员变量

类常量

常量就是不会改变的量，是一个恒值。

定义常量使用关键字const

输出格式：

  1. 类名::常量名

构造方法和析构方法

  1. void __construct([mixed args [,…]])
  2. void __destruct ( void )

示例：

  1. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  2. <html xmlns="http://www.w3.org/1999/xhtml">
  3. <head>
  4. <meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
  5. <title>成员变量</title>
  6. <style type="text/css">
  7. <!--
  8. body,td,th {
  9. 	font-size: 12px;
  10. }
  11. body {
  12. 	margin-left: 10px;
  13. 	margin-top: 10px;
  14. 	margin-right: 10px;
  15. 	margin-bottom: 10px;
  16. }
  17. -->
  18. </style></head>
  19. <body>
  20. <?php
  21. class SportObject{
  22. 	public $name;								//定义成员变量
  23. 	public $height;								//定义成员变量
  24. 	public $avoirdupois;						//定义成员变量
  26. 	public function bootFootBall($name,$height,$avoirdupois){				//声明成员方法
  27. 		$this->name=$name;
  28. 		$this->height=$height;
  29. 		$this->avoirdupois=$avoirdupois;
  30. 		if($this->height<185 and $this->avoirdupois<85){
  31. 			return $this->name."，符合踢足球的要求!";			//方法实现的功能
  32. 		}else{
  33. 			return $this->name."，不符合踢足球的要求!";			//方法实现的功能
  34. 		}
  35. 	}
  36. }
  37. $sport=new SportObject();			//实例化类，并传递参数
  38. echo $sport->bootFootBall('1','185','80');								//执行类中的方法
  39. ?>
  41. </body>
  42. </html>
  1. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  2. <html xmlns="http://www.w3.org/1999/xhtml">
  3. <head>
  4. <meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
  5. <title>成员方法</title>
  6. <style type="text/css">
  7. <!--
  8. body,td,th {
  9. 	font-size: 12px;
  10. }
  11. body {
  12. 	margin-left: 10px;
  13. 	margin-top: 10px;
  14. 	margin-right: 10px;
  15. 	margin-bottom: 10px;
  16. }
  17. -->
  18. </style></head>
  19. <body>
  20. <?php
  21. 	class SportObject{
  22. 		function beatBasketball($name,$height,$avoirdupois,$age,$sex){				//声明成员方法
  23. 			if($height>180 and $avoirdupois<=100){
  24. 				return $name."，符合打篮球的要求!";			//方法实现的功能
  25. 			}else{
  26. 				return $name."，不符合打篮球的要求!";			//方法实现的功能
  27. 			}
  28. 		}
  29. 	}
  30. 	$sport=new SportObject();
  31. 	echo $sport->beatBasketball('1','185','80','20周岁','男');
  32. ?>
  33. </body>
  34. </html>
  1. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  2. <html xmlns="http://www.w3.org/1999/xhtml">
  3. <head>
  4. <meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
  5. <title>常量</title>
  6. <style type="text/css">
  7. <!--
  8. body,td,th {
  9. 	font-size: 12px;
  10. }
  11. body {
  12. 	margin-left: 10px;
  13. 	margin-top: 10px;
  14. 	margin-right: 10px;
  15. 	margin-bottom: 10px;
  16. }
  17. -->
  18. </style></head>
  19. <body>
  20. <?php
  21. class SportObject{
  22. 	const BOOK_TYPE = '计算机图书';
  23. 	public $object_name;						//图书名称
  24. 	function setObjectName($name){				//声明方法setObjectName()
  25. 		$this -> object_name = $name;			//设置成员变量值
  26. 	}
  27. 	function getObjectName(){					//声明方法getObjectName()
  28. 		return $this -> object_name;
  29. 	}
  30. }
  31. $c_book = new SportObject();						//实例化对象
  32. $c_book -> setObjectName("PHP类");				//调用方法setObjectName
  33. echo SportObject::BOOK_TYPE."->";					//输出常量BOOK_TYPE
  34. echo $c_book -> getObjectName();				//调用方法getObjectName
  35. ?>
  36. </body>
  37. </html>
  1. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  2. <html xmlns="http://www.w3.org/1999/xhtml">
  3. <head>
  4. <meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
  5. <title>构造方法</title>
  6. <style type="text/css">
  7. <!--
  8. body,td,th {
  9. 	font-size: 12px;
  10. }
  11. body {
  12. 	margin-left: 10px;
  13. 	margin-top: 10px;
  14. 	margin-right: 10px;
  15. 	margin-bottom: 10px;
  16. }
  17. -->
  18. </style></head>
  19. <body>
  20. <?php
  21. class SportObject{
  22. 	public $name;								//定义成员变量
  23. 	public $height;								//定义成员变量
  24. 	public $avoirdupois;						//定义成员变量
  25. 	public $age;								//定义成员变量
  26. 	public $sex;								//定义成员变量
  27. 	public function __construct($name,$height,$avoirdupois,$age,$sex){				//定义构造方法
  28. 		$this->name=$name;						//为成员变量赋值
  29. 		$this->height=$height;					//为成员变量赋值
  30. 		$this->avoirdupois=$avoirdupois;		//为成员变量赋值
  31. 		$this->age=$age;						//为成员变量赋值
  32. 		$this->sex=$sex;						//为成员变量赋值
  33. 	}
  34. 	public function bootFootBall(){				//声明成员方法
  35. 		if($this->height<185 and $this->avoirdupois<85){
  36. 			return $this->name."，符合踢足球的要求!";			//方法实现的功能
  37. 		}else{
  38. 			return $this->name."，不符合踢足球的要求!";			//方法实现的功能
  39. 		}
  40. 	}
  41. }
  42. $sport=new SportObject('1','185','80','20','男');			//实例化类，并传递参数
  43. echo $sport->bootFootBall();								//执行类中的方法
  45. ?>
  47. </body>
  48. </html>

析构方法，是对象被销毁时被调用的，作用是释放内存。

  1. void __destruct ( void )
  1. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  2. <html xmlns="http://www.w3.org/1999/xhtml">
  3. <head>
  4. <meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
  5. <title>析构方法</title>
  6. </head>
  7. <body>
  8. <?php
  9. class SportObject{
  10. 	public $name;								//定义成员变量
  11. 	public $height;								//定义成员变量
  12. 	public $avoirdupois;						//定义成员变量
  13. 	public $age;								//定义成员变量
  14. 	public $sex;								//定义成员变量
  15. 	public function __construct($name,$height,$avoirdupois,$age,$sex){				//定义构造方法
  16. 		$this->name=$name;						//为成员变量赋值
  17. 		$this->height=$height;					//为成员变量赋值
  18. 		$this->avoirdupois=$avoirdupois;		//为成员变量赋值
  19. 		$this->age=$age;						//为成员变量赋值
  20. 		$this->sex=$sex;						//为成员变量赋值
  21. 	}
  22. 	public function bootFootBall(){				//声明成员方法
  23. 		if($this->height<185 and $this->avoirdupois<85){
  24. 			return $this->name."，符合踢足球的要求!";			//方法实现的功能
  25. 		}else{
  26. 			return $this->name."，不符合踢足球的要求!";			//方法实现的功能
  27. 		}
  28. 	}
  29. 	function __destruct(){
  30. 		echo "<p><b>对象被销毁，调用析构函数。</b></p>";
  31. 	}
  32. }
  33. $sport=new SportObject('1','185','80','20','男');			//实例化类，并传递参数
  34. //unset($sport);	
  36. ?>
  37. </body>
  38. </html>

继承和多态的实现

所有成员变量和方法

构造函数

先调用子类中的方法

去调用父类中的构造方法

  1. class subClass extends superClass{
  2. …
  3. }

多态存在两种形式：覆盖和重载。

  1. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  2. <html xmlns="http://www.w3.org/1999/xhtml">
  3. <head>
  4. <meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
  5. <title>继承的实现</title>
  6. <style type="text/css">
  7. </head>
  8. <body>
  9. <?php
  10. /*  父类  */
  11. class SportObject{
  12. 	public $name;								//定义姓名成员变量
  13. 	public $age;								//定义年龄成员变量
  14. 	public $avoirdupois;						//定义体重成员变量
  15. 	public $sex;								//定义性别成员变量
  16. 	public function __construct($name,$age,$avoirdupois,$sex){				//定义构造方法
  17. 		$this->name=$name;						//为成员变量赋值
  18. 		$this->age=$age;						//为成员变量赋值
  19. 		$this->avoirdupois=$avoirdupois;		//为成员变量赋值
  20. 		$this->sex=$sex;						//为成员变量赋值
  21. 	}
  22. 	function showMe(){							//定义方法
  23. 		echo '这句话不会显示。';
  24. 	}
  25. }
  26. /*  子类BeatBasketBall  */
  27. class BeatBasketBall extends SportObject{				//定义子类，继承父类
  28. 	public $height;										//定义身高成员变量
  29. 	function __construct($name,$height){				//定义构造方法
  30. 		$this -> height = $height;						//为成员变量赋值
  31. 		$this -> name = $name;							//为成员变量赋值
  32. 	}
  33. 	function showMe(){									//定义方法
  34. 		if($this->height>185){
  35. 			return $this->name."，符合打篮球的要求!";			//方法实现的功能
  36. 		}else{
  37. 			return $this->name."，不符合打篮球的要求!";			//方法实现的功能
  38. 		}
  39. 	}
  40. }
  41. /*  子类WeightLifting  */
  42. class WeightLifting extends SportObject{						//继承父类
  43. 	function showMe(){											//定义方法
  44. 		if($this->avoirdupois<85){
  45. 			return $this->name."，符合举重的要求!";				//方法实现的功能
  46. 		}else{
  47. 			return $this->name."，不符合举重的要求!";			//方法实现的功能
  48. 		}
  49. 	}
  50. }
  52. //实例化对象
  53. $beatbasketball = new BeatBasketBall('','190');				//实例化子类
  54. $weightlifting = new WeightLifting('','185','80','20','男');
  55. echo $beatbasketball->showMe()."<br>";							//输出结果
  56. echo $weightlifting->showMe()."<br>";
  57. ?>
  58. </body>
  59. </html>

继承的实现

  1. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  2. <html xmlns="http://www.w3.org/1999/xhtml">
  3. <head>
  4. <meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
  5. <title>继承的实现</title>
  6. <style type="text/css">
  7. </head>
  8. <body>
  9. <?php
  10. /*  父类  */
  11. class SportObject{
  12. 	public $name;								//定义姓名成员变量
  13. 	public $age;								//定义年龄成员变量
  14. 	public $avoirdupois;						//定义体重成员变量
  15. 	public $sex;								//定义性别成员变量
  16. 	public function __construct($name,$age,$avoirdupois,$sex){				//定义构造方法
  17. 		$this->name=$name;						//为成员变量赋值
  18. 		$this->age=$age;						//为成员变量赋值
  19. 		$this->avoirdupois=$avoirdupois;		//为成员变量赋值
  20. 		$this->sex=$sex;						//为成员变量赋值
  21. 	}
  22. 	function showMe(){							//定义方法
  23. 		echo '这句话不会显示。';
  24. 	}
  25. }
  26. /*  子类BeatBasketBall  */
  27. class BeatBasketBall extends SportObject{				//定义子类，继承父类
  28. 	public $height;										//定义身高成员变量
  29. 	function __construct($name,$height){				//定义构造方法
  30. 		$this -> height = $height;						//为成员变量赋值
  31. 		$this -> name = $name;							//为成员变量赋值
  32. 	}
  33. 	function showMe(){									//定义方法
  34. 		if($this->height>185){
  35. 			return $this->name."，符合打篮球的要求!";			//方法实现的功能
  36. 		}else{
  37. 			return $this->name."，不符合打篮球的要求!";			//方法实现的功能
  38. 		}
  39. 	}
  40. }
  41. /*  子类WeightLifting  */
  42. class WeightLifting extends SportObject{						//继承父类
  43. 	function showMe(){											//定义方法
  44. 		if($this->avoirdupois<85){
  45. 			return $this->name."，符合举重的要求!";				//方法实现的功能
  46. 		}else{
  47. 			return $this->name."，不符合举重的要求!";			//方法实现的功能
  48. 		}
  49. 	}
  50. }
  52. //实例化对象
  53. $beatbasketball = new BeatBasketBall('','190');				//实例化子类
  54. $weightlifting = new WeightLifting('','185','80','20','男');
  55. echo $beatbasketball->showMe()."<br>";							//输出结果
  56. echo $weightlifting->showMe()."<br>";
  57. ?>
  58. </body>
  59. </html>

重载:

传递的参数个数不同，调用不同的方法，返回不同的值。

  1. <?php
  2. 	class C{
  3. 		function __call($name,$num){		//调用不存在的方法
  4. 		echo "方法名称：" . $name . "<p>";		//输出方法名
  5. 		echo "参数存在个数：" . count($num) . "<p>";	//输出参数个数
  6. 			if (count($num) == 1){	//根据参数个数调用不同的方法
  7. 				echo $this->list1($a);
  8. 			}
  9. 			if (count($num) == 2){	//根据参数个数调用不同的方法
  10. 				echo $this->list2($a,$b);
  11. 			}
  12. 		}
  13. 		public function list1($a){		//定义方法
  14. 			return "这是list1函数";
  15. 		}
  16. 		public function list2($a,$b){	//定义方法
  17. 			return "这是list2函数";
  18. 		}
  19. 	}
  20. $a = new C;					//类的实例化
  21. $a->listshow(1,2);				//调用方法，传递参数
  22. ?>
  1. 关键字::变量名/常量名/方法名
  1. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  2. <html xmlns="http://www.w3.org/1999/xhtml">
  3. <head>
  4. <meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
  5. <title>伪变量$this</title>
  6. </head>
  7. <body>
  8. <?php
  9. 	class example{
  10. 		function exam(){
  11. 			if(isset($this)){
  12. 				echo '$this的值为：'.get_class($this);
  13. 			}else{
  14. 				echo '$this未定义';
  15. 			}
  16. 		}
  17. 	}
  18. 	$class_name = new example();
  19. 	$class_name->exam();
  20. ?>
  21. </body>
  22. </html>
  1. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  2. <html xmlns="http://www.w3.org/1999/xhtml">
  3. <head>
  4. <meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
  5. <title>“::”操作符</title>
  6. </head>
  7. <body>
  8. <?php
  9. class Book{
  10. 	const NAME = 'computer';							//常量NAME
  11. 	function __construct(){								//构造方法
  12. 		echo '本月图书类冠军为：'.Book::NAME.' ';		//输出默认值
  13. 	}
  14. }
  15. class l_book extends Book{								//Book类的子类
  16. 	const NAME = 'foreign language';					//声明常量
  17. 	function __construct(){								//子类的构造方法
  18. 		parent::__construct();							//调用父类的构造方法
  19. 		echo '本月图书类冠军为：'.self::NAME.' ';		//输出本类中的默认值
  20. 	}
  21. }
  22. $obj = new l_book();									//实例化对象
  23. ?>
  24. </body>
  25. </html>

parent: 可以调用父类中的成员变量，成员方法和常量。

self:可以调用当前类中的静态成员和常量。

类名:可以调用本类中的变量，常量和方法。

数据隐藏

public（公共成员）

private（私有成员）

protected（保护成员）

  1. public, private, protected, static, final

静态变量（方法）

  1. 关键字::静态成员
  1. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  2. <html xmlns="http://www.w3.org/1999/xhtml">
  3. <head>
  4. <meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
  5. <title>private关键字</title>
  6. </head>
  7. <body>
  8. <?php
  9. class Book{
  10. 	private $name = 'computer';							//声明私有变量$name
  11. 	public function setName($name){						//设置私有变量
  12. 		$this -> name = $name;
  13. 	}
  14. 	public function getName(){							//读取私有变量
  15. 		return $this -> name;
  16. 	}
  17. }
  18. class LBook extends Book{								//Book类的子类
  19. }
  20. $lbook = new LBook();									//实例化对象
  21. echo '正确操作私有变量的方法：';
  22. $lbook -> setName("PHP");					//对私有变量进行操作
  23. echo $lbook -> getName();
  24. echo '<br>直接操作私有变量的结果：';					//对私有变量进行操作
  25. echo Book::$name;
  26. ?>
  27. </body>
  28. </html>

private只能在所属类的内部被调和修改，不可以在类外被访问。

protected修饰的类成员，可以在本类和子类中被调用，其他地方不可以被调用。

  1. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  2. <html xmlns="http://www.w3.org/1999/xhtml">
  3. <head>
  4. <meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
  5. <title>protected关键字</title>
  6. </head>
  7. <body>
  8. <?php
  9. class Book{
  10. 	protected $name = 'computer';						//声明保护变量$name
  11. }
  12. class LBook extends Book{								//Book类的子类
  13. 	public function showMe(){
  14. 		echo '对于protected修饰的变量，在子类中是可以直接调用的。如：$name = '.$this -> name;
  15. 	}
  16. }
  17. $lbook = new LBook();									//实例化对象
  18. $lbook -> showMe();
  19. echo '<p>但在其他的地方是不可以调用的，否则：';			//对私有变量进行操作
  20. $lbook -> name = 'history';
  21. ?>
  22. </body>
  23. </html>
  1. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  2. <html xmlns="http://www.w3.org/1999/xhtml">
  3. <head>
  4. <meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
  5. <title>protected关键字</title>
  6. </head>
  7. <body>
  8. <?php
  9. class Book{
  10. 	protected $name = 'computer';						//声明保护变量$name
  11. }
  12. class LBook extends Book{								//Book类的子类
  13. 	public function showMe(){
  14. 		echo '对于protected修饰的变量，在子类中是可以直接调用的。如：$name = '.$this -> name;
  15. 	}
  16. }
  17. $lbook = new LBook();									//实例化对象
  18. $lbook -> showMe();
  19. echo '<p>但在其他的地方是不可以调用的，否则：';			//对私有变量进行操作
  20. $lbook -> name = '会报错，这里就错了';
  21. ?>
  22. </body>
  23. </html>

静态变量：

  1. 关键字::静态成员

self，在类内部调用 静态成员所使用

在静态方法中，只能调用静态变量，不能调用普通变量，而普通方法可以调用静态变量。

对象被销毁后，仍然保存被修改的静态数据。

  1. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  2. <html xmlns="http://www.w3.org/1999/xhtml">
  3. <head>
  4. <meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
  5. <title>静态变量的使用</title>
  6. </head>
  7. <body>
  8. <?php
  9. class Book{										//Book类
  10. 	static $num = 0;							//声明一个静态变量$num，初值为0
  11. 	public function showMe(){					//申明一个方法
  12. 		echo '您是第'.self::$num.'位访客';		//输出静态变量
  13. 		self::$num++;							//将静态变量加1
  14. 	}
  15. }
  16. $book1 = new Book();							//实例化对象$book1
  17. $book1 -> showMe();								//调用showMe()方法
  18. echo "<br>";
  19. $book2 = new Book();							//实例化对象$book2;
  20. $book2 -> showMe();								//再次调用showMe()方法
  21. echo "<br>";
  22. echo '您是第'.Book::$num.'为访客';				//直接使用类名调用静态变量
  23. ?>
  24. </body>
  25. </html>

运行效果是：

您是第0位访客

您是第1位访客

您是第2位访客

对象的高级应用

final关键字，抽象类，接口的使用，克隆对象，对象比较，对象类型检测，魔术方法。

  1. 不可以被继承，不能有子类
  2. final class class_name{
  3. //…
  4. }
  6. final function method_name() 不可以重写和覆盖
  1. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  2. <html xmlns="http://www.w3.org/1999/xhtml">
  3. <head>
  4. <meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
  5. <title>final类</title>
  6. ></head>
  7. <body>
  8. <?php
  9. 	final class SportObject{
  10. 		function  __construct(){
  11. 			echo '不能被继承，不能有子类';
  12. 		}
  13. 	}
  14. 	class MyBook extends SportObject{
  15. 		static function exam(){
  16. 			echo "会报错的";
  17. 		}
  18. 	}
  19. 	MyBook::exam();
  20. ?>
  21. </body>
  22. </html>

抽象类，是不能被实例化的类，只能作为父类来使用:

  1. abstract class AbstractName{
  2. …
  3. }

抽象类，一样有成员变量，成员方法，抽象类至少包含一个抽象方法，抽象方法没有方法体，其功能在子类完成。

  1. abstract function abstractName();
  1. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  2. <html xmlns="http://www.w3.org/1999/xhtml">
  3. <head>
  4. <meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
  5. <title>抽象类</title>
  6. </head>
  7. <body>
  8. <?php
  9. 	abstract class CommodityObject{							//定义抽象类
  10. 		abstract function service($getName,$price,$num);	//定义抽象方法
  11. 	}
  12. 	class MyBook extends CommodityObject{				//定义子类，继承抽象类
  13. 		function service($getName,$price,$num){		//定义方法
  14. 			echo '您购买的商品是'.$getName.'，该商品的价格是：'.$price.' 元。';
  15. 			echo '您购买的数量为：'.$num.' 本。';
  16. 			echo '如发现缺页，请在3日内更换。';
  17. 		}
  18. 	}
  19. 	class MyComputer extends CommodityObject{			//定义子类继承父类
  20. 		function service($getName,$price,$num){			//定义方法
  21. 			echo '您购买的商品是'.$getName.'，该商品的价格是：'.$price.' 元。';
  22. 			echo '您购买的数量为：'.$num.' 台。';
  23. 			echo '如发生非人为质量问题，请在3个月内更换。';
  24. 		}
  25. 	}
  26. 	$book = new MyBook();					//实例化子类
  27. 	$computer = new MyComputer();			//实例化子类
  28. 	$book -> service('PHP',5,3);	//调用方法
  29. 	echo '<p>';
  30. 	$computer -> service('XX本',800,1);		//调用方法
  32. ?>
  33. </body>
  34. </html>

接口

  1. interface InterfaceName{
  2. 	function interfaceName1();
  3. 	function interfaceName2();
  4. 	…
  5. }
  7. class SubClass implements InterfaceName1，InterfaceName2{
  8. 	function interfaceName1(){	//功能实现
  9. }
  10.     function interfaceName2(){	//功能实现
  11. }
  12. 	…
  13. }
  1. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  2. <html xmlns="http://www.w3.org/1999/xhtml">
  3. <head>
  4. <meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
  5. <title>接口</title>
  6. </head>
  7. <body>
  8. <?php
  9. 	interface MPopedom{
  10. 		function popedom();
  11. 	}
  12. 	interface MPurview{
  13. 		function purview();
  14. 	}
  15. 	class Member implements MPurview{
  16. 		function purview(){
  17. 			echo '会员';
  18. 		}
  19. 	}
  20. 	class Manager implements MPurview,MPopedom{
  21. 		function purview(){
  22. 			echo '管理员拥有全部权限。';
  23. 		}
  24. 		function popedom(){
  25. 			echo '管理员还没有的权限';
  26. 		}
  27. 	}
  28. 	$member = new Member();
  29. 	$manager = new Manager();
  30. 	$member -> purview();
  31. 	echo '<p>';
  32. 	$manager -> purview();
  33. 	$manager ->popedom();
  34. ?>
  35. </body>
  36. </html>

克隆对象

  1. $object1 = new ClassName();
  2. $object2 = clone $object1;

__clone()方法,调用__clone()方法，可以克隆出来的对象的一些行为及属性

  1. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  2. <html xmlns="http://www.w3.org/1999/xhtml">
  3. <head>
  4. <meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
  5. <title>对象的引用</title>
  6. </head>
  7. <body>
  8. <?php
  9. class SportObject{									//类SportObject
  10. 	private $object_type = 'book';				//声明私有变量$object_type，并赋初值等于“book”
  11. 	public function setType($type){				//声明成员方法setType，为变量$object_type赋值
  12. 		$this -> object_type = $type;
  13. 	}
  14. 	public function getType(){					//声明成员方法getType，返回变量$object_type的值
  15. 		return $this -> object_type;
  16. 	}
  17. }
  18. $book1 = new SportObject();						//实例化对象$book1
  19. $book2 = $book1;								//使用普通数据类型的方法给对象$book2赋值
  20. $book2 -> setType('computer');					//改变对象$book2的值
  21. echo '对象$book1的值为：'.$book1 -> getType();	//输出对象$book1的值
  22. ?>
  24. </body>
  25. </html>

对象比较

两个等号“”是比较两个对象的内容

3个等号“=”是比较对象的引用地址

对象类型检测

instanceof操作符可以检测当前对象是属于哪个类

  1. ObjectName instanceof ClassName

魔术方法

  1. __construct()、__destruct()和__clone()
  2. __set()和__get()方法
  3. __call()方法
  4. __sleep()和__wakeup()方法
  5. __toString()方法
  6. __autoload()方法

__call()方法包含两个参数，即方法名和方法参数

方法参数是以数组形式存在的

_set()方法包含两个参数，分别表示变量名称和变量值

__get()方法有一个参数，表示要调用的变量名

使用serialize()函数可以实现序列化对象

unserialize()函数可以重新还原一个被serialize()函数序列化的对象

__sleep()方法可以清除对象并返回一个该对象中所有变量的数组

__wakeup()方法则是恢复在序列化中可能丢失的数据库连接及相关工作

__toString()方法将对象转化为字符串

对象的比较

  1. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  2. <html xmlns="http://www.w3.org/1999/xhtml">
  3. <head>
  4. <meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
  5. <title>对象的比较</title>
  6. </head>
  7. <body>
  8. <?php
  9. 	class SportObject{
  10. 		private $name;
  11. 		function __construct($name){
  12. 			$this -> name = $name;
  13. 		}
  14. 	}
  15. 	$book = new SportObject('book');
  16. 	$cloneBook = clone $book;
  17. 	$referBook = $book;
  18. 	if($cloneBook == $book){
  19. 		echo '两个对象的内容相等<br>';
  20. 	}
  21. 	if($referBook === $book){
  22. 		echo '两个对象的引用地址相等<br>';
  23. 	}
  24. ?>
  25. </body>
  26. </html>

对象的比较

  1. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  2. <html xmlns="http://www.w3.org/1999/xhtml">
  3. <head>
  4. <meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
  5. <title>对象的比较</title>
  6. </head>
  7. <body>
  8. <?php
  9. 	class SportObject{
  10. 		private $name;
  11. 		function __construct($name){
  12. 			$this -> name = $name;
  13. 		}
  14. 	}
  15. 	$book = new SportObject('book');
  16. 	$cloneBook = clone $book;
  17. 	$referBook = $book;
  18. 	if($cloneBook == $book){
  19. 		echo '两个对象的内容相等<br>';
  20. 	}
  21. 	if($referBook === $book){
  22. 		echo '两个对象的引用地址相等<br>';
  23. 	}
  24. ?>
  25. </body>
  26. </html>

对象类型检测

instanceof操作符可以检测当前对象是属于哪个类

  1. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  2. <html xmlns="http://www.w3.org/1999/xhtml">
  3. <head>
  4. <meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
  5. <title>对象类型检测</title>
  6. </head>
  7. <body>
  8. <?php
  9. class SportObject{}
  10. class MyBook extends SportObject{
  11. 	private $type;
  12. }
  13. $cBook = new MyBook();
  14. if($cBook instanceof MyBook)
  15. 	echo '对象$cBook属于MyBook类<br>';
  16. if($cBook instanceof SportObject)
  17. 	echo '对象$cBook属于SportObject类<br>';
  18. ?>
  19. </body>
  20. </html>

测试结果：

  1. 对象$cBook属于MyBook类
  3. 对象$cBook属于SportObject类

魔术方法：

__set()和__get()方法

  1. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  2. <html xmlns="http://www.w3.org/1999/xhtml">
  3. <head>
  4. <meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
  5. <title>__set()和__get()方法</title>
  6. </head>
  7. <body>
  8. <?php
  9. class SportObject
  10. {
  11. 	private $type = ' ';
  12. 	public function getType(){
  13. 		return $this -> type;
  14. 	}
  15.     private function __get($name){
  16. 		if(isset($this ->$name)){
  17. 			echo '变量'.$name.'的值为：'.$this -> $name.'<br>';
  18. 		}
  19. 		else{
  20. 			echo '变量'.$name.'未定义，初始化为0<br>';
  21. 			$this -> $name = 0;
  22. 		}
  23.     }
  24.     private function __set($name, $value){
  25. 		if(isset($this -> $name)){
  26. 			$this -> $name = $value;
  27. 			echo '变量'.$name.'赋值为：'.$value.'<br>';
  28. 		}else{
  29. 			$this -> $name = $value;
  30. 			echo '变量'.$name.'被初始化为：'.$value.'<br>';
  31. 		}
  32.     }
  33. }
  34. $MyComputer = new SportObject();
  35. $MyComputer -> type = 'DIY';
  36. $MyComputer -> type;
  37. $MyComputer -> name;
  38. ?>
  39. </body>
  40. </html>

变量type赋值为:DIY

变量type的值为:DIY

变量name未定义，初始化为0

变量name被初始化为：0

__call()方法

  1. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  2. <html xmlns="http://www.w3.org/1999/xhtml">
  3. <head>
  4. <meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
  5. <title>__call()方法</title>
  6. </head>
  7. <body>
  8. <?php
  9. class SportObject
  10. {
  11. 	public function myDream(){
  12. 		echo '调用的方法存在，直接执行此方法。<p>';
  13. 	}
  14.     public function __call($method, $parameter)
  15.     {
  16. 		echo '如果方法不存在，则执行__call()方法。<br>';
  17.         echo '方法名为：'.$method.'<br>';
  18.         echo '参数有：';
  19. 		var_dump($parameter);
  20.     }
  21. }
  22. $MyLife = new SportObject();
  23. $MyLife -> myDream();
  24. $MyLife -> mDream('how','what','why');
  25. ?>
  26. </body>
  27. </html>

__sleep()和__wakeup()方法

__sleep()方法可以清除对象并返回一个包含对象中所有变量的数组。

  1. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  2. <html xmlns="http://www.w3.org/1999/xhtml">
  3. <head>
  4. <meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
  5. <title>__sleep()和__wakeup()方法</title>
  6. </head>
  7. <body>
  8. <?php
  9. class SportObject{
  10. 	private $type = 'DIY';
  11. 	public function getType(){
  12. 		return $this -> type;
  13. 	}
  14. 	public function __sleep(){
  15. 		echo '使用serialize()函数将对象保存起来，可以存放到文本文件、数据库等地方<br>';
  16. 		return $this;
  17. 	}
  18. 	public function __wakeup(){
  19. 		echo '当需要该数据时，使用unserialize()函数对已序列化的字符串进行操作，将其转换回对象<br>';
  20. 	}
  21. }
  22. $myBook = new SportObject();
  23. $i = serialize($myBook);
  24. echo '序列化后的字符串：'.$i.'<br>';
  25. $reBook = unserialize($i);
  26. echo '还原后的成员变量：'.$reBook -> getType();
  27. ?>
  28. </body>
  29. </html>

__toString()方法

  1. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  2. <html xmlns="http://www.w3.org/1999/xhtml">
  3. <head>
  4. <meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
  5. <title>__toString()方法</title>
  6. </head>
  7. <body>
  8. <?php
  9. class SportObject{
  10. 	private $type = 'DIY';
  11. 	public function __toString(){
  12. 		return $this -> type;
  13. 	}
  14. }
  15. $myComputer = new SportObject();
  16. echo '对象$myComputer的值为：';
  17. echo  $myComputer;
  18. ?>
  19. </body>
  20. </html>

__autoload()方法自动实例化需要使用的类

  1. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  2. <html xmlns="http://www.w3.org/1999/xhtml">
  3. <head>
  4. <meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
  5. <title>__autoload()方法自动实例化需要使用的类</title>
  6. </head>
  7. <body>
  8. <?php
  9. 	function __autoload($class_name){
  10. 		$class_path = $class_name.'.class.php';
  11. 		if(file_exists($class_path)){
  12. 			include_once($class_path);
  13. 		}else
  14. 			echo '类路径错误。';
  15. 	}
  16. 	$myBook = new SportObject("江山代有人才出　各领风骚数百年");
  17. 	echo $myBook;
  18. ?>
  19. </body>
  20. </html>
  22. <?php
  23. class SportObject{
  24. 	private $cont;
  25. 	public function __construct($cont){
  26. 		$this -> cont = $cont;
  27. 	}
  28. 	public function __toString(){
  29. 		return $this -> cont;
  30. 	}
  31. }
  32. ?>

中文字符串的截取类

  1. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  2. <html xmlns="http://www.w3.org/1999/xhtml">
  3. <head>
  4. <meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
  5. <title>中文字符串的截取类</title>
  6. </head>
  7. <body>
  8. <?php
  9. class MsubStr{
  10. 	function csubstr($str, $start, $len) { 				//$str指的是字符串,$start指的是字符串的起始位置，$len指的是长度。
  11. 	$strlen = $start + $len; 							//用$strlen存储字符串的总长度（从字符串的起始位置到字符串的总长度）
  12. 	for($i = 0; $i < $strlen; $i ++) { 					//通过for循环语句,循环读取字符串
  13. 		if (ord ( substr ( $str, $i, 1 ) ) > 0xa0) { 	//如果字符串中首个字节的ASCII序数值大于0xa0,则表示为汉字
  14. 			$tmpstr .= substr ( $str, $i, 2 ); 			//每次取出两位字符赋给变量$tmpstr，即等于一个汉字
  15. 			$i ++; 										//变量自加1
  16. 		} else { 										//如果不是汉字，则每次取出一位字符赋给变量$tmpstr
  17. 			$tmpstr .= substr ( $str, $i, 1 );
  18. 		}
  19. 	}
  20. 	return $tmpstr; 									//输出字符串
  21. 	}
  22. }
  23. $mc=new MsubStr();										//类的实例化
  24. ?>
  25. <table width="204" height="195" border="0" cellpadding="0" cellspacing="0" background="images/bg.JPG">
  26.   <tr>
  27.     <td width="25" height="37">&nbsp;</td>
  28.     <td width="157">&nbsp;</td>
  29.     <td width="22">&nbsp;</td>
  30.   </tr>
  31.   <tr>
  32.     <td height="30">&nbsp;</td>
  33.     <td><?php
  34. 			$string="关注！";
  35. 			if(strlen($string)>10){
  36. 				echo substr($string,0,9)."...";
  37. 			}else{
  38. 				echo $string;
  39. 			}
  40. 		?>
  41. 	</td>
  42.     <td>&nbsp;</td>
  43.   </tr>
  44.   <tr>
  45.     <td height="30">&nbsp;</td>
  46.     <td><?php
  47. 			$string="关注";
  48. 			if(strlen($string)>10){
  49. 				echo substr($string,0,9)."...";
  50. 			}else{
  51. 				echo $string;
  52. 			}
  53. 		?></td>
  54.     <td>&nbsp;</td>
  55.   </tr>
  56.   <tr>
  57.     <td height="30">&nbsp;</td>
  58.     <td>
  59. 		<?php
  60. 			$strs="关注";
  61. 			if(strlen($string)>10){
  62. 				echo $mc ->csubstr($strs, "0" , "9")."...";
  63. 			}else{
  64. 				echo $strs;
  65. 			}
  66. 		?>
  67. 	</td>
  68.     <td>&nbsp;</td>
  69.   </tr>
  70.   <tr>
  71.     <td height="30">&nbsp;</td>
  72.     <td><?php
  73. 			$strs="关注";
  74. 			if(strlen($string)>30){
  75. 				echo $mc ->csubstr($strs, "0" , "20")."...";
  76. 			}else{
  77. 				echo $strs;
  78. 			}
  79. 		?>
  80. 	</td>
  81.     <td>&nbsp;</td>
  82.   </tr>
  83.   <tr>
  84.     <td height="38">&nbsp;</td>
  85.     <td>&nbsp;</td>
  86.     <td>&nbsp;</td>
  87.   </tr>
  88. </table>
  89. </body>
  90. </html>
  92. <?php
  93. class MsubStr{
  94. 	function csubstr($str, $start, $len) { //$str指的是字符串,$start指的是字符串的起始位置，$len指的是长度。
  95. 	$strlen = $start + $len; //用$strlen存储字符串的总长度（从字符串的起始位置到字符串的总长度）
  96. 	for($i = 0; $i < $strlen; $i ++) { //通过for循环语句,循环读取字符串
  97. 		if (ord ( substr ( $str, $i, 1 ) ) > 0xa0) { //如果字符串中首个字节的ASCII序数值大于0xa0,则表示为汉字
  98. 			$tmpstr .= substr ( $str, $i, 2 ); //每次取出两位字符赋给变量$tmpstr，即等于一个汉字
  99. 			$i ++; //变量自加1
  100. 		} else { //如果不是汉字，则每次取出一位字符赋给变量$tmpstr
  101. 			$tmpstr .= substr ( $str, $i, 1 );
  102. 		}
  103. 	}
  104. 	return $tmpstr; //输出字符串
  105. }
  106. }
  108. ?>
  1. <?php
  2. class changecode{
  3. 	private $str;
  4. 	private $input;
  5. 	private $output;
  6. 	function __construct($input='',$output='gb2312'){
  7. 		$this->input = $input;
  8. 		$this->output = $output;
  9. 	}
  10. 	protected function chgcode($str){
  11. 		if($this->input != ''){
  12. 			$this->str = iconv($input,$output,$str);
  13. 		}else{
  14. 			$this->str = mb_convert_encoding($str,$output);
  15. 		}
  16. 	}
  17. 	function getStr($str){
  18. 		$this->chgcode($str);
  19. 		return $this->str;
  20. 	}
  21. 	function setInput($input){
  22. 		$this->input = $input;
  23. 	}
  24. 	function setOutput($output){
  25. 		$this->output = $output;
  26. 	}
  27. 	function getInput(){
  28. 		return $this->input;
  29. 	}
  30. 	function getOutput(){
  31. 		return $this->output;
  32. 	}
  33. }
  34. ?>

结言

好了，欢迎在留言区留言，与大家分享你的经验和心得。

感谢你学习今天的内容，如果你觉得这篇文章对你有帮助的话，也欢迎把它分享给更多的朋友，感谢。

感谢！承蒙关照！您真诚的赞赏是我前进的最大动力！

PHP全栈学习笔记8的更多相关文章

  1. PHP全栈学习笔记18

    php基础知识,JavaScript,jQuery,ajax基础知识 linux基础知识,mysql数据库的基础与优化 程序设计,PHP框架基础知识,算法,逻辑思维,高并发 PHP基础知识 引用变量, ...

  2. PHP全栈学习笔记29

    前言 这一章主要讲一讲PHP的背景,优势,PHP的环境搭建,书写和调式简单的PHP代码,如何解决简单的PHP错误等. 目录结构 PHP简介 PHP是面向对象,指令式编程,设计者是 拉斯姆斯·勒多夫 出 ...

  3. PHP全栈学习笔记13

    php与ajax技术 web2.0的到来,ajax逐渐成为主流,什么是ajax,ajax的开发模式,优点,使用技术.(ajax概述,ajax使用的技术,需要注意的 问题,在PHP应用ajax技术的应用 ...

  4. PHP全栈学习笔记12

    php简介,php历史,php后端工程师职业前景,php技术方向,php后端工程师职业体系介绍. php是世界上使用最广泛的web开发语言,是超文本预处理器,是一种通用的开源脚本语言,语法吸收了c语言 ...

  5. PHP全栈学习笔记17

    phpmyadmin教程 管理页进入phpmyadmin 打开C:\wamp\apps\phpmyadmin3.5.1下的配置文件:config.inc 修改密码 创建与修改数据库.数据表 字段类型 ...

  6. PHP全栈学习笔记16

    <?php $fileName = "php大师.test.php"; //补充程序,显示文件名(不包括扩展名) $start = strrpos($fileName, &q ...

  7. PHP全栈学习笔记15

    PHP标记风格 PHP一共支持4种标记风格 <?php echo "这是XML风格的标记"; ?> 脚本风格 <script language="php ...

  8. PHP全栈学习笔记14

    一.搭建PHP开发环境 Apahce服务器 Dreamwear创建站点 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitiona ...

  9. PHP全栈学习笔记11

    连接MySQL mysql_connect(servername,username,password); 面向对象: <?php $servername = "localhost&qu ...

  10. PHP全栈学习笔记10

    php常量,常量是不能被改变的,由英文字母,下划线,和数字组成,但是数字不能作为首字母出现. bool define ( string $name , mixed $value [, bool $ca ...

随机推荐

  1. Java 架构师眼中的 HTTP 协议

    HTTP 协议的内容比较多,本文我们将分六部分来介绍. HTTP 协议的基本内容 什么是 HTTP 协议 首先我们来看协议是什么?协议是指计算机通信网络中两台计算机之间进行通信所必须共同遵守有规则的文 ...

  2. Scrapy 1.4 文档 01 初窥 Scrapy

    初窥 Scrapy Scrapy 是用于抓取网站并提取结构化数据的应用程序框架,其应用非常广泛,如数据挖掘,信息处理或历史存档. 尽管 Scrapy 最初设计用于网络数据采集(web scraping ...

  3. Java 读书笔记 (五) 目标数据类型转换

    数据类型转换必须满足如下规则: 不能对boolean类型进行类型转换 不能把对象类型转换成不相关类的对象  //那不同类的对象可以用同一个名字命名吗?根据作用域原则,可以吧? 把容量大的转换为容量小的 ...

  4. buffer_pool.go

    package nsqd import (     "bytes"     "sync" ) var bp sync.Pool func init() {    ...

  5. BZOJ_4636_蒟蒻的数列_线段树+动态开点

    BZOJ_4636_蒟蒻的数列_线段树+动态开点 Description 蒟蒻DCrusher不仅喜欢玩扑克,还喜欢研究数列 题目描述 DCrusher有一个数列,初始值均为0,他进行N次操作,每次将 ...

  6. BZOJ_3210_花神的浇花集会_切比雪夫距离

    BZOJ_3210_花神的浇花集会_切比雪夫距离 Description 在花老师的指导下,每周4都有一个集会活动,俗称“浇水”活动. 具体浇水活动详情请见BZOJ3153 但这不是重点 花神出了好多 ...

  7. BZOJ_1801_[Ahoi2009]chess 中国象棋_DP

    BZOJ_1801_[Ahoi2009]chess 中国象棋_DP Description 在N行M列的棋盘上,放若干个炮可以是0个,使得没有任何一个炮可以攻击另一个炮. 请问有多少种放置方法,中国像 ...

  8. Java开源生鲜电商平台-通知模块设计与架构(源码可下载）

    Java开源生鲜电商平台-通知模块设计与架构(源码可下载) 说明:对于一个生鲜的B2B平台而言,通知对于我们实际的运营而言来讲分为三种方式:           1. 消息推送:(采用极光推送)   ...

  9. python 防止sql注入字符串拼接的正确用法

    在使用pymysql模块时,在使用字符串拼接的注意事项错误用法1 sql='select * from where id="%d" and name="%s" ...

  10. Java关于static的作用

    概述 只要是有学过Java的都一定知道static,也一定能多多少少说出一些作用和注意事项.如果已经对static了如指掌的请点击关闭按钮,看下去也只是浪费您宝贵时间而已.这篇随笔只是个人的习惯总结. ...