浅入PHP-面向对象

一.什么是面向对象

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

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

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

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

   

1. class 类型名称{
2. 属性；
3. 方法；
4. }

5.创建对象的方式：

      变量 = new 类型名称() ;

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

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

7.封装-举例：

           

1. <?php
2. class Animal {
3. # 属性
4. var $nmae;
5. var $food;
7. # 方法
8. function eat(){
9. echo '喂' . $this->name . '吃' . $this->food.'
   ';
10. }
12. }
14. $dog = new Animal();//创建对象
16. //调用对象
17. $dog->name = '莱福' ;
18. $dog->food = '骨头' ;
19. $dog->eat() ;
22. ?>

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.多态

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

  

1. <?php
2. // 定义一个父类
3. class Animal {
4. public function makeSound() {
5. echo "Animal makes sound";
6. }
7. }
9. // 定义一个子类，继承自父类
10. class Dog extends Animal {
11. public function makeSound() {
12. echo "Dog barks";
13. }
14. }
16. // 定义另一个子类，继承自父类
17. class Cat extends Animal {
18. public function makeSound() {
19. echo "Cat meows";
20. }
21. }
23. // 创建对象并调用方法
24. $animal1 = new Animal();
25. $animal1->makeSound(); // 输出：Animal makes sound
27. $animal2 = new Dog();
28. $animal2->makeSound(); // 输出：Dog barks
30. $animal3 = new Cat();
31. $animal3->makeSound(); // 输出：Cat meows
32. ?>

   运行测试可得：

 11.演示：

 (1).

1. <?php
2. # 编写一个类型，其中有属性和函数
3. class Animal{
4. //编写一个类型
5. # 注意点一: 在类型中编写属性 和 在外部定变量有一定的区别
6. # 需要在变量名之前加上var关键字
7. var $name; // 在类型的外部编写的变量就叫变量,在类型的内部编写的变量叫属性!!!
9. var $food;
10. //编写了两个属性
12. function eat(){
13. # 注意点二: 在函数的内部调用属性, 需要加上$this
14. # $this是指代当前对象, $this->变量名,就是表示调用自己的属性。
15. echo '喂' . $this->name . '吃' . $this->food. '
    ';
16. }
17. }
18. //编写了一个类型中的方法
20. # 类型一般不会直接使用,而是创建出对象以后去使用对象
21. $dog = new Animal(); // new对象时,()中的参数就是传入构造方法的；创建一个对象
22. # 注意点三: 为对象的属性(内部的变量)进行赋值, 而且属性不需要加$符号
23. $dog->name = '来福';
24. $dog->food = '狗粮';
25. //给对象的属性传参
26. $dog->eat(); //调用方法
28. # 类型被创建以后可以不断地复用
29. $cat = new Animal(); //创建对象
30. $cat->name = 'Tom';
31. $cat->food = '鱼干';
32. //给对象属性传参
33. $cat->eat();//调用方法
34. ?>

   (2).

1. <?php
3. class Animal{
4. var $name;
5. var $food;
6. //创建类型及其属性
8. // 构造函数
9. function __construct(){
10. // 构造函数不需要手动调用 变量名->__construct(); // 不需要 !!!
11. // 构造函数在new对象的时候，会自动被调用。
12. echo '你创建了Aniaml类型的对象哦~
    ';
13. }
15. function eat(){
16. echo '喂' . $this->name . '吃' . $this->food. '
    ';
17. }
18. }
19. //编写了类型中的方法
21. $dog = new Animal();
22. $cat = new Animal();
23. //创建对象
25. ?>

    (3).

1. <?php
3. class Animal{
4. var $name;
5. var $food;
7. // 构造函数：构造函数是可以设置参数的
8. // 构造函数最大的作用就是属性赋值
9. function __construct($param1, $param2){
10. echo $param1 . ' ' . $param2 . '
    ';
12. }
14. function eat(){
15. echo '喂' . $this->name . '吃' . $this->food. '
    ';
16. }
17. }
18. //方法
21. $dog = new Animal('来福', '狗粮'); // new对象时,()中的参数就是传入构造方法的
22. $cat = new Animal('凯特', '鱼干');
23. //创建了两个对象
24. $cat->eat();
26. ?>

 

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

      改写后：

   

1. <?php
3. class Animal{
4. var $name;
5. var $food;
7. // 构造函数：构造函数是可以设置参数的
8. // 构造函数最大的作用就是属性赋值
9. function __construct($name, $food){
10. //this最大的作用就是区分函数中的参数和类中的属性
11. $this->name = $name ;
12. $this->food = $food ;
14. }
15. //编写了构造函数并且给属性赋值了
17. function eat(){
18. echo '喂' . $this->name . '吃' . $this->food. '
    ';
19. }
20. }
22. $dog = new Animal('来福', '狗粮');
24. $cat = new Animal('凯特', '鱼干');
25. //创建对象
26. $cat->eat();
27. //调用方法，会安方法里写的步骤执行程序
28. ?>

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

(4).

1. <?php
2. class Animal{
3. var $name;
4. var $food;
5. //创建类型及其属性
7. function __construct($name, $food){
8. $this->name = $name;
9. $this->food = $food;
10. }
11. //运用构造函数，给属性赋值
13. function eat(){
14. echo '喂' . $this->name . '吃' . $this->food. '
    ';
15. }
16. }
17. //编写类型的方法
19. // 继承
20. // 有时候我们会想更精确的描述一种类型
21. // 但是这个新的类型有很多属性 和 函数 都与之前的某一个类型相同
22. // 为了提高代码的复用性,减少代码冗余,可以使用extends关键字直接将之前类型中的属性和函数继承过来使用。
23. // extends关键字之前的类型称之为子类
24. // extends关键字之后的类型称之为父类
25. class Dog extends Animal{
27. }
28. //运用继承，新的子类 Dog 继承了父类 Animal中的属性和方法等所有内容
29. $dog = new Dog('旺财','骨头');//创建对象
30. echo $dog->name;
32. ?>

(5).

1. <?php
2. class Animal{
3. var $name;
4. var $food;
5. //创建类型及属性
6. function __construct($name, $food){
7. $this->name = $name;
8. $this->food = $food;
9. }
10. //运用构造函数，并给属性赋值
12. function eat(){
13. echo '喂' . $this->name . '吃' . $this->food. '
    ';
14. }
15. }
16. //创建方法
18. class Dog extends Animal{
19. // new子类对象时, 如果子类没有编写构造函数,会自动调用父类的构造函数
20. function __construct($param1, $param2){
21. // 在子类的构造函数中可以使用parent::__construct()手动调用父类的构造函数
22. parent::__construct($param1, $param2);
23. }
24. }
25. //创建子类继承父类，子类中调用父类的构造函数，
27. $dog = new Dog('旺财','骨头');//创建对象
29. echo $dog->name;
30. echo '
    ' ;
31. $dog->eat();
33. ?>

 

(6).

1. <?php
2. class Animal{
3. var $name;
4. var $food;
6. function __construct($name, $food){
7. $this->name = $name;
8. $this->food = $food;
9. }
11. function eat(){
12. echo '喂' . $this->name . '吃' . $this->food. '
    ';
13. }
14. }
16. class Dog extends Animal{
17. var $add;
18. //创建子类继承父类，并且新增了一个属性
19. function __construct($param1, $param2,$param3){
21. parent::__construct($param1, $param2);//调用父类中的构造函数
22. $this->add = $param3;
23. }
25. function run(){
26. echo '带着' . $this->name . '去' . $this->add . '遛弯
    ';
27. }
28. //子类中又新写了一个方法
29. }
31. $dog = new Dog('大黄','骨头','湖边公园');
33. $dog->eat();
34. $dog->run();
35. //调用方法
36. ?>

 (7).

1. <?php
2. class Animal{
3. var $name;
4. var $food;
5. function __construct($name, $food){
6. $this->name = $name;
7. $this->food = $food;
8. }
9. function eat(){
10. echo '喂' . $this->name . '吃' . $this->food. '
    ';
11. }
12. }
14. class Dog extends Animal{
15. var $add;
18. function __construct($param1, $param2,$param3){
20. parent::__construct($param1, $param2);
21. $this->add = $param3;
22. }
24. function run(){
25. // 可以在子类的方法中调用父类的方法
26. parent::eat();
27. echo '带着' . $this->name . '去' . $this->add . '遛弯
    ';
28. }
29. }
31. $dog = new Dog('大黄','骨头','湖边公园');
32. $dog->run();
34. ?>

 

二.练习

1. 写一个人类Person:

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

类中的方法:

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

   测试:

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

1. <?php
2. class Person{
3. var $name ;
4. var $gender ;
5. var $age ;
6. var $height ;
7. var $weight ;
8. var $born ;
10. function __construct($name,$gender,$age,$height,$weight,$born){
11. $this->name = $name ;
12. $this->gender = $gender ;
13. $this->age = $age ;
14. $this->height = $height ;
15. $this->weight = $weight ;
16. $this->born = $born ;
18. }
20. function jiesao(){
21. echo '我叫' . $this->name . '，性别为' . $this->gender . '，今年' . $this->age. '，我的身高是' . $this->height. '，体重是' . $this->weight. '，出生年月是' . $this->born. '。' ;
23. }
25. }
27. $p = new Person('王二麻子','男','17','176.5','73.5','1997.9.23') ;
28. $p->jiesao() ;
29. ?>

2. 写一个狗类Dog:

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

     类中的方法:

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

   测试:

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

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

1. <?php
2. class Dog{
3. var $name ;
4. var $gender ;
5. var $colour ;
6. var $breed ;
7. var $weight ;
8. var $height ;
9. var $price ;
11. function __construct($name,$gender,$colour,$breed,$weight,$height,$price){
12. $this->name = $name ;
13. $this->gender = $gender ;
14. $this->colour = $colour ;
15. $this->breed = $breed ;
16. $this->weight = $weight ;
17. $this->height = $height ;
18. $this->price = $price ;
20. }
22. function jiesao(){
23. echo '它叫' . $this->name . '，性别为' . $this->gender . '，颜色是' . $this->colour. '，品种是' . $this->breed. '，体重是' . $this->weight. '，肩高是' . $this->height. '，价钱为' .$this->price . '。' . '
    ';
25. }
27. }
29. $b = new Dog('阿八','母','棕红','泰迪','5.2','26','2000') ;
30. $b->jiesao() ;
32. $t = new Dog('兔子','母','银灰','泰迪','3.1','22','5000') ;
33. $t->jiesao() ;
34. ?>

3. 写一个方形类Square:

     类中的属性: 长, 宽

      类中的方法:

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

     测试:

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

1. <?php
2. class Square{
3. var $long ;
4. var $wide ;
6. function __construct($long,$wide){
7. $this->long = $long ;
8. $this->wide = $wide ;
10. }
12. function qiumianji(){
13. echo '这是一个方形，它的长是' . $this->long .'，宽是' . $this->wide . '，面积是' . $this->long * $this->wide .'。' . '
    ';
15. }
17. }
19. $s = new Square('6','5') ;
20. $s->qiumianji() ;
21. ?>