PHP study notes: implementation of inheritance and polymorphism

PHP study notes: The implementation of inheritance and polymorphism requires specific code examples

Inheritance and polymorphism are very important concepts in object-oriented programming. They allow us to Code can be better organized and managed, improving code reusability and maintainability. In PHP, we can achieve code reuse through class inheritance, and at the same time, through polymorphism, the same method can show different behaviors in different subclasses. Below we will discuss the implementation of inheritance and polymorphism and provide specific code examples for reference.

First, let us understand what inheritance is. Inheritance is one of the core concepts of object-oriented programming. It allows us to define a base class (parent class), then create one or more subclasses based on it, and let the subclasses inherit the properties and methods of the parent class. Subclasses can obtain the code in the parent class through inheritance, thereby improving code reusability. We can use the keyword extends to create a subclass, and use the keyword parent:: to call methods or properties in the parent class.

The following is a simple example showing the basic usage of inheritance:

class Animal {
   protected $name;
   protected $age;
   
   public function __construct($name, $age) {
      $this->name = $name;
      $this->age = $age;
   }
   
   public function getInfo() {
      return "Name: " . $this->name . ", Age: " . $this->age;
   }
}

class Dog extends Animal {
   public function bark() {
      return "Woof!";
   }
}

$dog = new Dog("Rex", 3);
echo $dog->getInfo();  // 输出 "Name: Rex, Age: 3"
echo $dog->bark();     // 输出 "Woof!"

In the above code, we define a Animal class as the parent class, which The class has name and age attributes, and provides a getInfo() method to obtain animal information. Then, we define a Dog class as a subclass, which obtains the name and age attributes by inheriting the Animal class, and adds A new bark() method is added to represent the barking of a dog. Finally, we created a Dog object and called the getInfo() method of the parent class and the bark() method of the subclass to output relevant information.

The next step is the implementation of polymorphism. Polymorphism means that the same method exhibits different behaviors on different objects. In PHP, we can achieve polymorphism through interfaces and abstract classes. An interface defines a set of method specifications, while an abstract class defines a set of abstract methods, and the specific implementation is completed by subclasses. Subclasses can implement multiple interfaces or inherit an abstract class and redefine the methods according to their own needs. Using polymorphism can improve the flexibility and scalability of your code.

The following is an example that demonstrates the use of interfaces and abstract classes:

interface Shape {
   public function area();
   public function perimeter();
}

class Rectangle implements Shape {
   private $length;
   private $width;
   
   public function __construct($length, $width) {
      $this->length = $length;
      $this->width = $width;
   }
   
   public function area() {
      return $this->length * $this->width;
   }
   
   public function perimeter() {
      return 2 * ($this->length + $this->width);
   }
}

class Circle implements Shape {
   private $radius;
   
   public function __construct($radius) {
      $this->radius = $radius;
   }
   
   public function area() {
      return pi() * pow($this->radius, 2);
   }
   
   public function perimeter() {
      return 2 * pi() * $this->radius;
   }
}

$rectangle = new Rectangle(5, 3);
$circle = new Circle(2);

echo $rectangle->area();     // 输出 "15"
echo $rectangle->perimeter();  // 输出 "16"

echo $circle->area();        // 输出 "12.566370614359"
echo $circle->perimeter();   // 输出 "12.566370614359"

In the above code, we define two classes Rectangle and Circle, they all implement the Shape interface and must implement the area() and perimeter() methods declared in the interface. The Rectangle class is used to calculate the area and perimeter of a rectangle, and the Circle class is used to calculate the area and perimeter of a circle. We can create Rectangle and Circle objects, and then call their area() and perimeter() methods to get the corresponding results.

Inheritance and polymorphism are very important concepts in PHP object-oriented programming. They allow us to better organize and manage code and improve code reusability and maintainability. Through inheritance, we can create a base class to define shared properties and methods, and then inherit these properties and methods through subclasses. Through polymorphism, we can make the same method behave differently on different objects. The code examples provided above can help beginners better understand and apply the concepts of inheritance and polymorphism. I hope this article can be helpful to your PHP learning!

The above is the detailed content of PHP study notes: implementation of inheritance and polymorphism. For more information, please follow other related articles on the PHP Chinese website!