PHP——面向对象

<body>
<?php
//类调用用::
//对象调用用->
class Dog1//定义类
{
  //成员属性（变量）
  var $name;
  var $age;
  var $pinzhong;
  
  //成员方法
  function Jiao1()
  {
    $this->name;  
    echo "{$this->name}在叫";//this代表当前对象  调用类中的对象用$this    
  }    
        
}

$dog= new Dog1();
$dog->name = "旺财";//->调用变量
$dog->age = "10";
$dog->pinzhong = "哈士奇";

$dog->Jiao1();//调用方法
?>
<br />
<?php
class Dog
{
  //成员属性（变量）
  var $name;
  var $age;
  var $pinzhong;
 //构造函数  每个类都有 
  //1、在类的实例化的时候第一个执行
  //2、写法特殊 和类名一样，没有返回类型public Dog(){}
  function __construct($n,$a,$p)//两个下划线 可以传值 对定义的变量初始化
  {
      $this->name = $n;
      $this->age = $a;
      $this->pinzhong = $p;
      }
      function Jiao()
  {
    $this->name;  
    echo "{$this->name}在叫";//this代表当前对象  调用类中的对象用$this    
  }    
}
  $dog= new Dog("旺财","10","哈士奇");
  $dog->Jiao();
?>
<br  />
<?php
//封装：将类里面的成员保护（private），外界无法直接访问
//public protect private 此类
//封装之后用常用方法调用  缺点：需要写很多方法很麻烦
class Dog2
{

  private $name;
  private $age;
  private $pinzhong;
  
  function setname($n)//方法
  {
      $this->name=$n;
      }
  function setage($a)
  {
      if($a>=1 && $a<=5)
      {
          $this->age=$a;
          }
      }
  function __construct($n,$a,$p)//两个下划线 可以传值 对定义的变量初始化
  {
      $this->name = $n;
      $this->age = $a;
      $this->pinzhong = $p;
  }
  function Jiao()
  {
      
    echo "{$this->name}:{$this->age}在叫";   
  }    
 
}
$dog = new Dog2("汪哥","3","金毛");
$dog->setname("小强");
$dog->setage("6");
$dog->Jiao();

?>
<?php
//封装 set()方法和 get()方法
class Dog3
{

  private $name;
  private $age;
  private $pinzhong;
  
 
  function __set($name,$value)//赋值的时候自动调用
    {
        $this->$name = $value;
        
        }
  function __get($name)//取值的时候自动调用
  {
      return $this->$name;
      
      }
   function __construct($n,$a,$p)//两个下划线 可以传值 对定义的变量初始化
  {
      $this->name = $n;
      $this->age = $a;
      $this->pinzhong = $p;
  }
  function Jiao()
  {
      
    echo "{$this->name}:{$this->age}在叫";   
  }    
    
 
}
$dog = new Dog3("汪哥","3","金毛");
$dog->name="大毛";//赋值的时候调用set()方法
$dog->age="1";
     echo "<br />";
echo $dog->name;//取值的时候调用get()方法
      echo "<br />";
echo $dog->pinzhong;
      echo "<br />";
$dog->Jiao();

//继承
class Hashiqi extends Dog3
{
    
    function Jiao()
    {
        parent::Jiao();//调用父类的方法 parent
        //或Dog::Jiao()  用父类名;  
        echo "	";
        echo "hello";//不写上面是方法重写
    } 
    
}
$dog = new Hashiqi("汪哥","3","金毛");
$dog->name="大毛";//赋值的时候调用set()方法
$dog->age="1";
     echo "<br />";
echo $dog->name;//取值的时候调用get()方法
      echo "<br />";
echo $dog->pinzhong;
      echo "<br />"; 
      echo "<br />";
$dog->Jiao();
//类前面加final不能被继承
//static静态属于类，非静态属于对象 静态变量不用实例化，通过类直接调用 用::调用里面的成员用self  静态方法不能调用非静态的

class HH extends Dog3
{
    public static $height;//静态对象，属于类
    
    static function  Gao()//静态方法 static写前面
    {
        echo "<br />";
        echo "这么高".self::$height;//静态方法调用静态成员 用self
        }
}
    
    
$dog= new HH("二毛","2","藏獒");
HH::$height = 10;
echo "<br />";
echo HH::$height;
HH::Gao();
    
//const 定义常量，常量定义好了，不能修改
const A=9;
?>
<?php
//多态 父类的引用指向子类的实例 必须要有继承 重载
class Ren
{
    var $name;
    var $age;
    
    function eat()
    {
        echo "{$this->name}正在吃饭";
        }
    
    }

class China extends Ren
{
    function eat()
    {
        echo "{$this->name}正在用筷子吃饭";
        }
    
    }
    $ren = new China();
    $ren->name = "张三";
    $ren->eat();
?>
<br />
<?php 
class Ren1
{
    var $name;
    var $age;
    
    function eat()
    {
        echo "{$this->name}正在吃饭";
    }
    function __tostring()
    {
        echo "这是一个人类";
        }
    function __clone()//克隆方法 在克隆的时候会自动执行，目的是将克隆出来的对象进行一些改变
    {
        $this->name = "王五";
        
    }      
}
$ren1 = new Ren1;
$ren1->name="李四";
$rl=clone $ren1;//克隆
     
$rl->eat();


//自动加载类
//第一种 include()函数 同一个目录下
       echo "<br />";
include("Cat.php");//不在同一个目录下,往下找 www/Cat.php 往上找../Cat.php
    
$cat= new Cat("喵喵咪","180","机器猫");
    echo "<br />";
$cat->Jiu();
//第二种 require_once 'Cat.php';
//自动加载类
function __autoload($classname)
{
    require_once $classname.".php";//require_once $classname."_class.php";其他写法 必须要有固定格式
    }
$cat1= new Cat("喵喵","180","机器猫");
    echo "<br />";
$cat1->name = "加菲猫";
$cat1->Jiu();

?>
</body>

在页面Cat中的代码

<body>
<?php
class Cat
{
    var $name;
    var $age;
    var $pinzhong;
    
    function __construct($n,$a,$p)
    {
        $this->name = $n;
        $this->age = $a;
        $this->pinzhong = $p;
        
    }
    
    function Jiu()
    {
        echo "一群叫‘{$this->name}’年龄‘{$this->age}’品种为‘{$this->pinzhong}’的小猫在拯救地球";
    }    
}
$cat= new Cat("喵喵","180","机器猫");

$cat->Jiu();





?>
</body>

结果:

笔记：

面向对象：
一：定义类
class Dog
{
var $name;
var $age;
var $pinzhong;

function Jiao()
{
echo "{$this->name}在叫";
}
}

二：实例化对象
$dog = new Dog();
调用对象的成员：
$dog->name = "旺财";
$dog->Jiao();

三：$this关键字
$this->name;this代表该对象，如果要在成员方法中调用成员变量，一定要使用$this找出该成员变量

四：构造函数：
//构造函数 每个类都有
//1、在类的实例化的时候第一个执行
//2、写法特殊 和类名一样，没有返回类型 java写法：public Dog(){}

function __construct($n,$a,$p)
{
$this->name = $n;
$this->age = $a;
$this->pinzhong = $p;
}
$dog= new Dog("旺财","10","哈士奇");

五：析构函数：销毁对象的时候执行函数 不能有参数（了解）
function __destruct()
{
echo "拜拜";
}


六：封装：
将类里面的成员变量加一个private修饰符变成私有的，目的是为了保护类里面的成员不被外界随意访问，从而确保类的安全性。如果将变量设置为私有，如何去访问：
1.自己写函数get函数set函数，然后来对变量赋值和取值
2.用系统自带的__get()函数和__set()函数来实现类里面的变量赋值取值（两条下划线）
function __set($name,$value)
{
$this->$name = $value;
}
function __get($name)
{
return $this->$name;
}

七：继承
继承一般是单继承：一个儿子只能有一个父亲
子类可以继承父类的所有成员
子类可以对父类的成员方法进行重写：（函数名一样），如果要在子类方法中调用父类的方法，用parent::Jiao();
function Jiao()
{
parent::Jiao();

echo "hello";
}
final关键字可以定义该类为最终类，不可被继承

静态：
关键字：static ，如果成员声明了为静态的，那么该成员是属于该类的，不是属于对象的
如何调用静态的成员：
HaShiQi::$height = 10;
HaShiQi::Gao();
用类名加双冒号调用类的静态成员
八、多态：
条件：必须要继承，父类的引用指向子类实例，重写函数

function __tostring()
{
echo "这是一个人类";
}
tostring方法，在输出对象的时候可以显示该方法中的信息

$r1 = clone $ren;克隆对象
function __clone()
{
$this->name = "李四";
}

在克隆的时候会自动执行，该函数的目的就是将克隆出来的对象进行一些改变

九、在页面上引用类：

1.include来引用
include("../china.php");

2.require_once请求页面
require_once "../China.php";

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/Chenshuai7/p/5157811.html