php 面向对象编程

<?php

class SimpleClass
{
        //define var
        public $var = ‘a default value‘;

        //method define
        public function displyVar()
        {
                echo $this->var;
        }
}

//SimpleClass::displyVar();

$obje1=new SimpleClass();
$obje1->displyVar();


?>

 <?php


class Person
{
    public $city="济南";
    
    //成员方法不能用类名调用 ，要用对象调用 
    public function sayHi($name=‘your name‘)
    {
        echo $name.‘say: hello everyone! I am from ‘.$this->city;
        echo "</br>";
    
    }
    
    
    //static 是静态方法，可以用类名调用 Person::hi()
    static  function hi($name=‘jack‘)
    {
        echo $name.‘say: hello everyone! I am from ‘;
        echo "</br>";
    }

}

$p1 = new Person();
$p1->sayHi();
$p1->city="北京";
$p1->sayHi("cocoa");

Person::hi("tom");
Person::hi();

echo "some city".$p1->city;

class Student extends Person
{
    public $name="姓名";
    
    public function study()
    {
       echo $this->name."good good study!"."</br>";
    }
}

echo "<hr>";

?>

<?php

/**
*    访问权限
    public : 公开的，子类，处部都可以访问，对象等可以访问
    private: 私有的，只有在本类内部访问，子类外部不可访问，对象不可访问
    protected:受保护的，子类可以访问，外部不可访问，对象也不可以访问
*/

class A
{
    public $public = "public var";
    private $private = "private var";
    protected $protected = "pritected var";
    
    function hi()
    {
        echo $this->public."</br>";
        echo $this->private."</br>";
        echo $this->protected."</br>";
    }
}

$a = new A();

$a->hi();

echo "<hr>";

echo $a->public."</br>";    //可访问
//echo $a->protected."</br>";    //不可访问
//echo $a->private."</br>";    //不可访问

echo "<hr>";


class B extends A
{
    //可以对 public 和 protected进行重新定义，但是 private 的不能；
    //protected $protected = "protected2";
    
    function hi2()
    {
         
        echo $this->public."</br>";
        echo $this->private."</br>";
        echo $this->protected."</br>";
    }
}

$b = new B();
$b->hi();
$b->hi2();



?>

<?php

/**
    php抽象类 abstract
    抽象类不能直接被实例化，必须由子类继承去实现；
    抽象类必须至少有一个抽象方法；
    抽象类可以有非抽象方法；
    
    
*/

abstract class A
{
    //强制要求子类实现的方法
    abstract public function method();
    
    abstract protected function method2();
    
    //抽象方法不能声明为private
    //abstract private function method4();
        
    
    public function method3()
    {
        echo "method3 </br>";
    }
    
}

class B extends A
{
    public function method()
    {
        echo "method </br>";
    }
    
    protected function method2()
    {
        echo "method2";
    }


    public function hi()
    {
        $this->method2();
    }
}

$b = new B();
$b->method();
$b->method3();

$b->hi();

?>

<?php

/**

 php 接口
    指定某个类必须实现哪些方法；    
    接口中的方法必须是 public的
    关键字 interface    
    一个类可以实现多少个接口
    接口中的可以定义常量，都是定值，不能修改
*/

interface A
{
    //接口的方法，必须都是public的
    public function methodA();
    public function methodB();
}

interface C
{
    //接口里面声明常量，不可改变
    const varIP = ‘192.168.8.35‘;
    public function methodC();
}


//实现
class B implements A,C
{
    public function methodA()
    {
        echo "implements methodA </br>";
    }
    
    public function methodB()
    {
        echo "implements methodB </br>";        
    }

    public function methodC()
    {
        echo "implements methodC</br>";
    }


}

$b = new B();
$b->methodA();
$b->methodB();
$b->methodC();

//常量访问
echo C::varIP;

?>

<?php


class B
{
    function __construct()
    {
        echo "this is B init method</br>";
    }
}

$b = new B();

class C extends B 
{
    //继承关系的话，会先调用父类的 构造方法，然后执行自己的构造方法；
    //也可以自己手动调用父类的构造方法，关键字 parent::    
    function __construct()
    {
        parent::__construct();
        echo "this is C init method </br>";
    }
}

$c = new C();


?>

<?php


class B
{
    function __construct()
    {
        echo "this is B init method</br>";
    }

    
    function __destruct()
    {
        echo "this is B Class Destroying</br>";
    }
}

//$b = new B();

class C extends B 
{
    //继承关系的话，不会先调用父类的 构造方法，需要自己手动调用 ，然后执行自己的构造方法；
    //手动调用父类的构造方法，关键字 parent::    
    function __construct()
    {
        parent::__construct();
        echo "this is C init method </br>";
    }

    //析构造方法也是，子类不会主动调用父类的析构方法，要手动调用
    function __destruct()
    {
        parent::__destruct();
        echo "this is C Class Destroying</br>";
    }
}

$c = new C();


?>