PHP study notes: Basics of object-oriented programming

PHP study notes: Basics of object-oriented programming, specific code examples are required

Introduction:
Object-Oriented Programming (OOP for short) is a A programming way of thinking that solves complex programming problems by breaking the problem into multiple objects and defining the interactions between the objects. As a powerful programming language, PHP also supports object-oriented programming. This article will introduce the basic concepts and common syntax of object-oriented programming in PHP, and provide specific code examples.

1. Classes and Objects
   In object-oriented programming, a class is the template of an object, describing the properties (member variables) and behavior (member functions) of the object. An object is an instance of a class, created by instantiating the class. The following is a simple example of class definition and object creation:

class Person {
    // 成员变量
    public $name;
    public $age;

    // 构造函数
    public function __construct($name, $age) {
        $this->name = $name;
        $this->age = $age;
    }

    // 成员函数
    public function sayHello() {
        echo "Hello, my name is " . $this->name . " and I am " . $this->age . " years old.";
    }
}

// 创建一个Person对象
$person = new Person("Alice", 25);
$person->sayHello();  // 输出：Hello, my name is Alice and I am 25 years old.

In the above example, we defined a Person class, which contains two member variables $name and $age and a constructor function and a sayHello() member function. Instantiate the Person class through the new keyword to create a Person object, and call the object's member function sayHello() to output the object's information.

2. Encapsulation, inheritance and polymorphism
   Encapsulation, inheritance and polymorphism are the three core features of object-oriented programming. They solve the problems of code reuse and expansion respectively.

2.1 Encapsulation
Encapsulation refers to encapsulating data and methods in a class, and controlling the access rights of data and methods through access control characters (public, protected, private). The following is an example of encapsulation:

class Car {
    private $color;
    protected $price;

    public function __construct($color, $price) {
        $this->color = $color;
        $this->price = $price;
    }

    public function getColor() {
        return $this->color;
    }

    public function setColor($color) {
        $this->color = $color;
    }

    protected function getPrice() {
        return $this->price;
    }
}

$car = new Car("red", 50000);
echo $car->getColor();  // 输出：red
$car->setColor("blue");
echo $car->getColor();  // 输出：blue

In the above example, we define a Car class to encapsulate the color and price in the class. Get and set colors through the public methods getColor() and setColor(). At the same time, we set the price attribute as protected and can only be accessed inside the class and subclasses.

2.2 Inheritance
Inheritance means that a class can inherit the properties and methods of another class. Subclasses can override the methods of the parent class and add their own properties and methods. The following is an example of inheritance:

class Car {
    protected $color;

    public function __construct($color) {
        $this->color = $color;
    }

    public function getColor() {
        return $this->color;
    }
}

class ElectricCar extends Car {
    private $batteryCapacity;

    public function __construct($color, $batteryCapacity) {
        parent::__construct($color);
        $this->batteryCapacity = $batteryCapacity;
    }

    public function getBatteryCapacity() {
        return $this->batteryCapacity;
    }
}

$electricCar = new ElectricCar("red", 50);
echo $electricCar->getColor();  // 输出：red
echo $electricCar->getBatteryCapacity();  // 输出：50

In the above example, we define a Car class and an ElectricCar class, and the ElectricCar class inherits from the Car class. The subclass ElectricCar calls the constructor of the parent class through the parent::__construct() method, and adds its own attributes and method getBatteryCapacity().

2.3 Polymorphism
Polymorphism means that the same method can call different behaviors based on different objects. That is, subclasses can override methods of parent classes to achieve polymorphism. The following is a polymorphic example:

class Shape {
    public function calculateArea() {
        return 0;
    }
}

class Rectangle extends Shape {
    private $width;
    private $height;

    public function setDimensions($width, $height) {
        $this->width = $width;
        $this->height = $height;
    }

    public function calculateArea() {
        return $this->width * $this->height;
    }
}

class Circle extends Shape {
    private $radius;

    public function setRadius($radius) {
        $this->radius = $radius;
    }

    public function calculateArea() {
        return pi() * $this->radius * $this->radius;
    }
}

$shapes = array(new Rectangle(), new Circle());
$shapes[0]->setDimensions(5, 3);
$shapes[1]->setRadius(2);

foreach ($shapes as $shape) {
    echo $shape->calculateArea() . "<br>";
}

In the above example, we define a Shape class and two subclasses Rectangle and Circle. They share a parent class method calculateArea(), but the subclass overrides this method to implement different area calculation behaviors.

Conclusion:
This article introduces the basic concepts and common syntax of object-oriented programming in PHP, and provides specific code examples. Object-oriented programming is a powerful programming way of thinking that can improve the reusability and scalability of code. I hope readers can gain a deeper understanding of object-oriented programming through this article and be able to use it flexibly in actual development.

The above is the detailed content of PHP study notes: Basics of object-oriented programming. For more information, please follow other related articles on the PHP Chinese website!