基础知识
类的属性和方法
<!-- test.php -->
<?php
header("content-type:text/html;charset=utf-8");
class Person{
//属性
public $name = "人";
public $age = 20;
public $food = "食物";
//方法
public function eat(){
echo "吃饭";
}
public function eat2(){
//name为局部变量,需要使用this
echo $this->name."吃".$this->food;
}
public function sleep(){
echo "睡觉";
}
}
//对象
//类->对象
$xiaoming = new Person();
//调用对象的属性
echo $xiaoming->name;
echo "<br />";
//调用对象的方法
$xiaoming->eat();
$xiaoming->sleep();
echo "<hr />";
//对象的属性可以重新赋值
$xiaoming->name="小明";
echo $xiaoming->name;
echo $xiaoming->age="18";
echo "<hr />";
//this的使用
$xiaoming->name="小明2";
$xiaoming->food="香蕉";
$xiaoming->eat2();
?>
属性和方法都有protected public private
局部变量和this
static & const的常量
<!-- test2.php -->
<?php
class Position{
public $p1 = "earth";
static public $p2 = "sun";
//定义一个类常量
const PI = 3.1415926;
}
$x = new Position();
echo $x->p1;
echo $x::$p2;
echo Position::$p2;//static优先用类输出
echo "<hr />";
//输出类常量
//用类似静态变量的方法调用
echo $x::PI;
echo Position::PI;
?>
static修饰一个属性时,这个属性不属于某个具体的对象,而是属于这个类
构造方法和析构方法
<?php
header("content-type:text/html;charset=utf-8");
class Human{
public $name;
public $food;
//构造方法
//只要实例化对象就会自动调用
public function __construct(){
echo "这是构造方法<br />";
}
public function eat(){
echo $this->name."吃".$this->food."<br>";
}
//析构方法
//只要销毁对象就会自动调用
public function __destruct(){
echo "这是析构方法<br />";
}
}
$Iroman = new Human();
$Iroman->name = "钢铁侠";
$Iroman->food = "牛排";
$Iroman->eat();
构造方法的传参
对属性的初始化
<?php
header("content-type:text/html;charset=utf-8");
class Human{
public $name;
public $food;
//构造方法
//只要实例化对象就会自动调用
public function __construct($name,$food){
$this->name = $name;
$this->food = $food;
}
public function eat(){
echo $this->name."吃".$this->food."<br>";
}
}
$Suman = new Human("超人","牛肉");
$Suman->eat();
继承
<?php
header("content-type:text/html;charset=utf-8");
class Father{
public function money(){
echo "100000";
}
}
class Son extends Father{
public function useMoney(){
echo "-1000";
}
//方法的重写
public function money(){
echo "50000";
}
}
$s = new Son();
$s->Money();
$s->useMoney();
抽象
<?php
//abstract
//抽象方法A
//抽象方法A不能被实例化
abstract class A{
public function testA(){
echo "AAA";
}
//抽象方法
//抽象方法没有方法体
abstract function testB();
abstract function testC();
}
class B extends A{
function testB(){
}
function testC(){
}
}
$a = new B();
接口
<?php
//接口 interface
//接口本身就是抽象的,方法前不用加abstract
interface testA{
//接口里的方法,本身就是public
function A();
}
interface testB{
function B();
}
//类可以同时实现多个接口
class C implements testA,testB{
public function A(){
}
public function B(){
}
}
$c = new C();
总结
抽象类:相当于一类事物的规范
接口:组成事物的零件的规范
单例模式
非单例模式
<?php
class MySQL{
public $rand;
public function __construct(){
$this->rand = rand(10000,99999);
echo $this->rand."<br />";
}
}
$A = new MySQL();
$B = new MySQL();
$C = new MySQL();
var_dump($A);
echo "<br />";
var_dump($B);
echo "<br />";
var_dump($C);
echo "<br/>";
缺点:分别实例化了3个对象,增加了服务器的压力
<?php
//单例模式
//只用一个对象
//1.类不允许继承,加final
final class MySQL{
public $rand;
//2.修改构造函数为私有化(就不能实例化对象)
private function __construct(){
$this->rand = rand(10000,99999);
echo $this->rand."<br />";
}
//3.本类中定义一个实例
static public $single;
//4.创建实例
static public function getInstance(){
if(is_null(self::$single)){
//self 即 MySQL类
//MySQL::$singel == self::$single
self::$single = new MySQL();
}
return self::$single;
}
}
//5.调用静态方法
$A = MySQL::getInstance();
$B = MySQL::getInstance();
$C = MySQL::getInstance();
var_dump($A);
echo "<br />";
var_dump($B);
echo "<br />";
var_dump($C);
echo "<br/>";
多久啊发