ODD之PHP基础

基础知识

类的属性和方法

<!-- 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/>";

多久啊发