浅入PHP-面向对象

一.什么是面向对象

 1.面向对象是一种编程思想，将程序中的数据和操作封装在对象中，通过对象之间的交互来实现程序的功能。

2.面向对象的编程主要关注对象的行为和状态，通过定义 类 来创建对象，并且通过调用对象的方法来实现操作。

3.特点是：封装、继承、多态。

4.编写一个类型的方式：

   

class 类型名称{
  属性；
  方法；
}

5.创建对象的方式：

      变量 = new 类型名称() ;

6.调用对象的属性或者方法：

       变量名-> 属性名/方法名()；

7.封装-举例：

           

<?php
class Animal {
        # 属性
        var $nmae;
        var $food;
  
        # 方法
        function eat(){
            echo '喂' . $this->name . '吃' . $this->food.'<br/>';
        }
  
    }

$dog = new Animal();//创建对象

//调用对象
$dog->name = '莱福' ;
$dog->food = '骨头' ;
$dog->eat() ;


    ?>

8.构造函数

    指的是在创建一个对象时自动调用的特殊方法。主要作用是对对象的属性进行初始化和执行一些必要的操作。在构造函数中，this的作用是区分函数中的参数和类中的属性。

    使用方法是运用  __construct 来进行定义。

    语法格式：

void __construct([参数1、参数2、参数3、......]) {

         $this->属性1 = 参数1 ;

         $this->属性2 = 参数2 ;

         $this->属性3 = 参数3 ;

          ......

} 

 

9.继承

      指的是使用关键字 extends 来继承一个类，一个类可以从另一个类继承属性和方法。目的是为了减少代码的重复编写。

     如：

 //定义一个父类

class Animal{

    public function makeSound(){

        echo "Animal makes sound" ;

   }

}

//定义一个子类，继承自父类

class Dog extends Animal{

   public function makeSound(){

    echo "Dog barks" ;

   }

}

 10.多态

    指的是子类重写父类的方法。当子类对象调用该方法时，会执行子类中的方法，而不是父类中的方法。

  

<?php
// 定义一个父类
class Animal {
    public function makeSound() {
        echo "Animal makes sound";
    }
}

// 定义一个子类，继承自父类
class Dog extends Animal {
    public function makeSound() {
        echo "Dog barks";
    }
}

// 定义另一个子类，继承自父类
class Cat extends Animal {
    public function makeSound() {
        echo "Cat meows";
    }
}

// 创建对象并调用方法
$animal1 = new Animal();
$animal1->makeSound(); // 输出：Animal makes sound

$animal2 = new Dog();
$animal2->makeSound(); // 输出：Dog barks

$animal3 = new Cat();
$animal3->makeSound(); // 输出：Cat meows
?>

   运行测试可得：

 11.演示：

 (1).

<?php 
    # 编写一个类型，其中有属性和函数
    class Animal{      
        //编写一个类型
        # 注意点一: 在类型中编写属性 和 在外部定变量有一定的区别
        # 需要在变量名之前加上var关键字
        var $name; // 在类型的外部编写的变量就叫变量,在类型的内部编写的变量叫属性!!!
    
        var $food;
        //编写了两个属性

        function eat(){ 
            # 注意点二: 在函数的内部调用属性, 需要加上$this
            # $this是指代当前对象, $this->变量名,就是表示调用自己的属性。
            echo '喂' . $this->name . '吃' . $this->food. '<br/>';
        }
    }
        //编写了一个类型中的方法

    # 类型一般不会直接使用,而是创建出对象以后去使用对象
    $dog = new Animal(); // new对象时,()中的参数就是传入构造方法的；创建一个对象
    # 注意点三: 为对象的属性(内部的变量)进行赋值, 而且属性不需要加$符号
    $dog->name = '来福';
    $dog->food = '狗粮';
     //给对象的属性传参
    $dog->eat(); //调用方法
 
    # 类型被创建以后可以不断地复用
    $cat = new Animal(); //创建对象
    $cat->name = 'Tom';
    $cat->food = '鱼干';
    //给对象属性传参
    $cat->eat();//调用方法
?>

   (2).

 <?php 

    class Animal{
        var $name; 
        var $food;
        //创建类型及其属性

        // 构造函数
        function __construct(){
            // 构造函数不需要手动调用  变量名->__construct(); // 不需要 !!!
            // 构造函数在new对象的时候，会自动被调用。
            echo '你创建了Aniaml类型的对象哦~<br/>';
        }

        function eat(){
            echo '喂' . $this->name . '吃' . $this->food. '<br/>';
        }
    }
        //编写了类型中的方法
    
    $dog = new Animal(); 
    $cat = new Animal();
    //创建对象

?>

    (3).

<?php 

    class Animal{
        var $name; 
        var $food;

        // 构造函数：构造函数是可以设置参数的
        // 构造函数最大的作用就是属性赋值
        function __construct($param1, $param2){
            echo $param1 . ' ' . $param2 . '<br/>';

        }

        function eat(){
            echo '喂' . $this->name . '吃' . $this->food. '<br/>';
        }
    }
        //方法


    $dog = new Animal('来福', '狗粮'); // new对象时,()中的参数就是传入构造方法的
    $cat = new Animal('凯特', '鱼干');
    //创建了两个对象
    $cat->eat();

?>

 

    *上面测试结果中，最后一行为是什么是“喂吃”呢？缺少了主体。这是因为构造函数 __construct()的括号中的写的并不是属性，而是$param1 和 $param2 ，如果改成$name 和 $food，则就给属性赋值了

      改写后：

   

<?php 

    class Animal{
        var $name; 
        var $food;

        // 构造函数：构造函数是可以设置参数的
        // 构造函数最大的作用就是属性赋值
        function __construct($name, $food){
            //this最大的作用就是区分函数中的参数和类中的属性
            $this->name = $name ;
            $this->food = $food ;
            
        }
        //编写了构造函数并且给属性赋值了

        function eat(){
            echo '喂' . $this->name . '吃' . $this->food. '<br/>';
        }
    }

    $dog = new Animal('来福', '狗粮'); 

    $cat = new Animal('凯特', '鱼干');
    //创建对象
    $cat->eat();
    //调用方法，会安方法里写的步骤执行程序
?>

*这样就成功运用构造函数给属性赋值了，省去了后续给属性赋值的编写步骤了。

(4).

<?php 
    class Animal{
        var $name;
        var $food;
        //创建类型及其属性

        function __construct($name, $food){
            $this->name = $name;
            $this->food = $food;
        }
        //运用构造函数，给属性赋值

        function eat(){
            echo '喂' . $this->name . '吃' . $this->food. '<br/>';
        }
    }
        //编写类型的方法
    
    // 继承
    // 有时候我们会想更精确的描述一种类型
    // 但是这个新的类型有很多属性 和 函数 都与之前的某一个类型相同
    // 为了提高代码的复用性,减少代码冗余,可以使用extends关键字直接将之前类型中的属性和函数继承过来使用。
    // extends关键字之前的类型称之为子类
    // extends关键字之后的类型称之为父类
    class Dog extends Animal{

    }
    //运用继承，新的子类 Dog 继承了父类 Animal中的属性和方法等所有内容
    $dog = new Dog('旺财','骨头');//创建对象
    echo $dog->name; 

?>

(5).

<?php 
    class Animal{
        var $name;
        var $food;
        //创建类型及属性
        function __construct($name, $food){
            $this->name = $name;
            $this->food = $food;
        }
        //运用构造函数，并给属性赋值

        function eat(){
            echo '喂' . $this->name . '吃' . $this->food. '<br/>';
        }
    }
        //创建方法
    
    class Dog extends Animal{
        // new子类对象时,  如果子类没有编写构造函数,会自动调用父类的构造函数
        function __construct($param1, $param2){
        // 在子类的构造函数中可以使用parent::__construct()手动调用父类的构造函数
            parent::__construct($param1, $param2);
        }
    }
        //创建子类继承父类，子类中调用父类的构造函数，

    $dog = new Dog('旺财','骨头');//创建对象

    echo $dog->name;
    echo '<br/>' ;
    $dog->eat();

?>

 

(6).

<?php 
    class Animal{
        var $name;
        var $food;

        function __construct($name, $food){
            $this->name = $name;
            $this->food = $food;
        }

        function eat(){
            echo '喂' . $this->name . '吃' . $this->food. '<br/>';
        }
    }

    class Dog extends Animal{
        var $add; 
       //创建子类继承父类，并且新增了一个属性
        function __construct($param1, $param2,$param3){
 
            parent::__construct($param1, $param2);//调用父类中的构造函数
            $this->add = $param3;
        }

        function run(){
            echo '带着' . $this->name . '去' . $this->add . '遛弯<br/>';
        }
        //子类中又新写了一个方法
    }

    $dog = new Dog('大黄','骨头','湖边公园');

    $dog->eat();
    $dog->run();
    //调用方法
?>

 (7).

<?php 
    class Animal{
        var $name;
        var $food;
        function __construct($name, $food){
            $this->name = $name;
            $this->food = $food;
        }
        function eat(){
            echo '喂' . $this->name . '吃' . $this->food. '<br/>';
        }
    }
    
    class Dog extends Animal{
        var $add;


        function __construct($param1, $param2,$param3){
 
            parent::__construct($param1, $param2);
            $this->add = $param3;
        }

        function run(){
            // 可以在子类的方法中调用父类的方法
            parent::eat();
            echo '带着' . $this->name . '去' . $this->add . '遛弯<br/>';
        }
    }

    $dog = new Dog('大黄','骨头','湖边公园');
    $dog->run();

?>

 

二.练习

1. 写一个人类Person:

类中的属性: 姓名. 性别. 年龄. 身高. 体重. 出生年月

类中的方法:

    (1). 一个人类的自我描述方法: 输出该人类的所有相关属性

   测试:

生成一个Person对象p, 该对象的姓名"王二麻子", 性别"男", 年龄"17", 身高"176.5", 体重"73.5", 出生年月"1997/9/23",最后调用该对象的自我描述方法

<?php
  class  Person{
    var $name ;
    var $gender ;
    var $age ;
    var $height ;
    var $weight ;
    var $born ;

    function __construct($name,$gender,$age,$height,$weight,$born){
        $this->name = $name ;
        $this->gender = $gender ;
        $this->age = $age ;
        $this->height = $height ;
        $this->weight = $weight ;
        $this->born = $born ;

    }

    function jiesao(){
        echo '我叫' . $this->name . '，性别为' . $this->gender . '，今年' . $this->age. '，我的身高是' . $this->height. '，体重是' . $this->weight. '，出生年月是' . $this->born. '。' ;

    }

  }

  $p = new Person('王二麻子','男','17','176.5','73.5','1997.9.23') ;
  $p->jiesao() ;
?>

2. 写一个狗类Dog:

    类中的属性: 姓名, 性别, 颜色, 品种, 体重, 肩高, 价钱

     类中的方法:

     (1). 一个狗类的介绍方法: 输出狗类的所有信息

   测试:

生成一个Dog对象b, 该对象的姓名"阿八", 性别"母", 颜色"棕红", 品种"泰迪", 体重"5.2"斤, 肩高"26", 价钱"2000"

生成一个Dog对象t, 该对象的姓名"兔子", 性别"母", 颜色"银灰", 品种"泰迪", 体重"3.1"斤, 肩高"22", 价钱"5000"

<?php
  class  Dog{
    var $name ;
    var $gender ;
    var $colour ;
    var $breed ;
    var $weight ;
    var $height ;
    var $price ;

    function __construct($name,$gender,$colour,$breed,$weight,$height,$price){
        $this->name = $name ;
        $this->gender = $gender ;
        $this->colour = $colour ;
        $this->breed = $breed ;
        $this->weight = $weight ;
        $this->height = $height ;
        $this->price = $price ;

    }

    function jiesao(){
        echo '它叫' . $this->name . '，性别为' . $this->gender . '，颜色是' . $this->colour. '，品种是' . $this->breed. '，体重是' . $this->weight. '，肩高是' . $this->height. '，价钱为' .$this->price . '。' . '<br/>';

    }

  }

  $b = new Dog('阿八','母','棕红','泰迪','5.2','26','2000') ;
  $b->jiesao() ;

  $t = new Dog('兔子','母','银灰','泰迪','3.1','22','5000') ;
  $t->jiesao() ;
?>

3. 写一个方形类Square:

     类中的属性: 长, 宽

      类中的方法:

          (1). 显示方向信息的方法:显示长和宽, 并且显示面积

     测试:

            生成一个方向对象s, 长为6,宽为5, 显示长和宽, 并且显示面积

<?php
  class Square{
   var $long ;
   var $wide ;

    function __construct($long,$wide){
        $this->long = $long ;
        $this->wide = $wide ;

    }

    function qiumianji(){
        echo '这是一个方形，它的长是' . $this->long .'，宽是' . $this->wide . '，面积是' . $this->long * $this->wide .'。' . '<br/>';

    }

  }

  $s = new Square('6','5') ;
  $s->qiumianji() ;
?>