Объектно-ориентированное программирование в PHP

Мы можем представить нашу вселенную из разных объектов, таких как солнце, земля, луна и т. Д. Подобным же образом мы можем представить нашу машину из разных предметов, таких как колесо, рулевое управление, редуктор и т. Д. Таким же образом существуют объектно-ориентированные концепции программирования, которые предполагают все как объект и реализовать программное обеспечение с использованием разных объектов.

Объектно-ориентированные концепции

Прежде чем идти подробно, давайте определим важные термины, связанные с объектно-ориентированным программированием.

• Класс - это тип данных, определенный программистом, который включает в себя локальные функции, а также локальные данные. Вы можете рассматривать класс как шаблон для создания множества экземпляров одного и того же типа (или класса) объекта.
• Объект - отдельный экземпляр структуры данных , определенного класса. Вы определяете класс один раз, а затем создаете много объектов, принадлежащих ему. Объекты также известны как экземпляр.
• Переменный члена - Они являются переменными , определенным внутри класса. Эти данные будут невидимы вне класса и могут быть доступны через функции-члены. Эти переменные называются атрибутом объекта после создания объекта.
• Функция члена - Это есть функция , определенная внутри класса и используется для доступа к данным объекта.
• Наследование. Когда класс определяется путем наследования существующей функции родительского класса, он называется наследованием. Здесь дочерний класс наследует все или несколько функций-членов и переменных родительского класса.
• Родительский класс - класс, унаследованный от другого класса. Это также называется базовым классом или суперклассом.
• Child Class - класс, который наследуется от другого класса. Это также называется подклассом или производным классом.
• Полиморфизм - Это является концепцией объектно - ориентированным , где тем же функция может быть использована для различных целей. Например, имя функции останется таким же, но оно принимает разные аргументы и может выполнять разные задачи.
• Перегрузка - тип полиморфизма, в котором некоторые или все операторы имеют разные реализации в зависимости от типов своих аргументов. Аналогичным образом функции также могут быть перегружены с другой реализацией.
• Данные Абстракт - Любое представление данных , в которых скрыты детали реализации (отведенный).
• Инкапсуляция - относится к концепции, в которой мы инкапсулируем все данные и функции-члены вместе, чтобы сформировать объект.
• Конструктор - относится к специальному типу функции, который будет вызываться автоматически всякий раз, когда есть образование объекта из класса.
• Деструктор - относится к специальному типу функции, который будет вызываться автоматически всякий раз, когда объект удаляется или выходит за рамки.

Определение классов PHP

Общий вид для определения нового класса в PHP выглядит следующим образом:

<?php
   class phpClass {
      var $var1;
      var $var2 = "constant string";
  
      function myfunc ($arg1, $arg2) {
         [..]
      }
      [..]
   }
?>

Вот описание каждой строки -

• Специальный класс формы , за которым следует имя класса, который вы хотите определить.
• Набор фигурных скобок, охватывающий любое количество объявлений переменных и определений функций.
• Объявления переменной начинаются со специальной формы var , за которой следует обычное имя переменной $; они также могут иметь начальное назначение для постоянного значения.
• Определения функций очень похожи на автономные функции PHP, но являются локальными для класса и будут использоваться для установки и доступа к данным объекта.

Вот пример, который определяет класс типа Books -

<?php
class Books {
/* Member variables */
var $price;
var $title;
/* Member functions */
function setPrice($par){
	$this--->price = $par;
	}
function getPrice(){
	echo $this->price ."
";
	}
function setTitle($par){
	$this->title = $par;
	}
function getTitle(){
	echo $this->title ." 
";
	}
}
?>

Переменная $this специальная переменная, и это относится к тому же объекту , т.е. . сам к себе.

Создание объектов в PHP

После того, как вы определили свой класс, вы можете создать столько объектов, сколько хотите этого типа. Ниже приведен пример создания объекта с использованием нового оператора.

$physics = new Books;
$maths = new Books;
$chemistry = new Books;

Здесь мы создали три объекта, и эти объекты независимы друг от друга, и они будут иметь свое существование отдельно. Далее мы увидим, как получить доступ к элементам-членам и переменным-членам процесса.

Вызов функций-членов

После создания ваших объектов вы сможете вызвать функции-члены, связанные с этим объектом. Одна функция-член может обрабатывать только переменную-член только связанного объекта.

В следующем примере показано, как установить заголовок и цены для трех книг, вызывая функции-члены.

$physics->setTitle("Physics for High School");
$chemistry->setTitle("Advanced Chemistry");
$maths->setTitle("Algebra");
$physics->setPrice(10);
$chemistry->setPrice(15);
$maths->setPrice(7);

Теперь вы вызываете другие функции-члены, чтобы получить значения, установленные в приведенном выше примере -

$physics->getTitle();
$chemistry->getTitle();
$maths->getTitle();
$physics->getPrice();
$chemistry->getPrice();
$maths->getPrice();

Это приведет к следующему результату -

Функции конструктора

Конструкторские функции - это особый тип функций, которые вызываются автоматически всякий раз, когда создается объект. Поэтому мы полностью используем это поведение, инициализируя многие вещи через функции конструктора.

PHP предоставляет специальную функцию __construct() для определения конструктора. Вы можете передать столько аргументов, сколько хотите в функцию конструктора.

В следующем примере будет создан один конструктор для класса Books, и он будет инициализировать цену и название для книги во время создания объекта.

function __construct( $par1, $par2 ) {
   $this->price = $par1;
   $this->title = $par2;
}

Теперь нам не нужно вызывать функцию set отдельно, чтобы установить цену и название. Мы можем инициализировать эти две переменные-члены во время создания объекта. Проверьте следующий пример ниже -

$physics = new Books( "Physics for High School", 10 );
$maths = new Books ( "Advanced Chemistry", 15 );
$chemistry = new Books ("Algebra", 7 );
/* Get those set values */
$physics->getTitle();
$chemistry->getTitle();
$maths->getTitle();
$physics->getPrice();
$chemistry->getPrice();
$maths->getPrice();

Это приведет к следующему результату -

Destructor - деструктор

Как и функция конструктора, вы можете определить функцию деструктора, используя функцию __destruct(). Вы можете освободить все ресурсы с помощью деструктора.

Наследование

Определения классов PHP могут необязательно наследоваться от определения родительского класса, используя предложение extends . Синтаксис следующий:

class Child extends Parent {
   <definition body="">
}
</definition>

Эффект наследования заключается в том, что дочерний класс (или подкласс или производный класс) имеет следующие характеристики:

• Автоматически имеет все объявления переменной-члена родительского класса.
• Автоматически имеет все те же функции-члены, что и родительский, который (по умолчанию) будет работать так же, как эти функции в родительском.

Следующий пример наследует класс Books и добавляет больше функциональности на основе этого требования.

class Novel extends Books{
   var publisher;
   function setPublisher($par){
      $this->publisher = $par;
   }
   function getPublisher(){
      echo $this->publisher. "
";
   }
}

Теперь, помимо унаследованных функций, класс Novel сохраняет две дополнительные функции-члены.

Переопределение функции

Определения функций в дочерних классах переопределяют определения с тем же именем в родительских классах. В дочернем классе мы можем изменить определение функции, унаследованной от родительского класса.

В следующем примере функции getPrice и getTitle переопределяются для возврата некоторых значений.

function getPrice(){
   echo $this->price . "
";
   return $this->price;
}
function getTitle(){
   echo $this->title . "
";
   return $this->title;
}

Public - Публичные члены

Если вы не указали иначе, свойства и методы класса являются общедоступными. Иными словами, к ним можно обратиться в трех возможных ситуациях:

• Снаружи класс, в котором он объявлен
• В классе, в котором он объявлен
• Из другого класса, который реализует класс, в котором он объявлен

До сих пор мы видели всех членов как публичных членов. Если вы хотите ограничить доступность членов класса, вы определяете членов класса как частные или защищенные.

Private - Частные члены

Назначая элемент private, вы ограничиваете его доступность классу, в котором он объявлен. Частный член не может быть отнесен к классам, которые наследуют класс, в котором он объявлен, и не могут быть доступны извне класса.

Член класса может быть закрыт, используя закрытое ключевое слово infront члена.

class MyClass {
   private $car = "skoda";
   $driver = "SRK";
  
   function __construct($par) {
      // Statements here run every time
      // an instance of the class
      // is created.
   }
  
   function myPublicFunction() {
      return("I'm visible!");
   }
  
   private function myPrivateFunction() {
      return("I'm  not visible outside!");
   }
}

Когда класс MyClass наследуется другим классом с помощью extends, myPublicFunction() будет виден, как и $ driver. Расширяющийся класс не будет иметь никакого представления или доступа к myPrivateFunction и $ car, потому что они объявлены частными.

Protected - Защищенные члены

Защищенное свойство или метод доступно в классе, в котором он объявлен, а также в классах, которые расширяют этот класс. Защищенные члены недоступны вне этих двух классов. Член класса может быть защищен с помощью защищенного ключевого слова перед членом.

Вот другая версия MyClass -

class MyClass {
   protected $car = "skoda";
   $driver = "SRK";
   function __construct($par) {
      // Statements here run every time
      // an instance of the class
      // is created.
   }
   function myPublicFunction() {
      return("I'm visible!");
   }
   protected function myPrivateFunction() {
      return("I'm  visible in child class!");
   }
}

Интерфейсы

Интерфейсы определены так, чтобы предоставить разработчикам общие имена функций. Различные разработчики могут реализовать эти интерфейсы в соответствии с их требованиями. Вы можете сказать, что интерфейсы представляют собой скелеты, которые реализуются разработчиками.

Начиная с PHP5, можно определить интерфейс, например:

interface Mail {
   public function sendMail();
}

Затем, если другой класс реализовал этот интерфейс, например:

class Report implements Mail {
   // sendMail() Definition goes here
}

Константы

Константа несколько напоминает переменную, поскольку она содержит значение, но на самом деле больше похоже на функцию, потому что константа неизменна. Когда вы объявляете константу, она не изменяется.

Объявление одной константы легко, как это делается в этой версии MyClass -

class MyClass {
   const requiredMargin = 1.7;
   function __construct($incomingValue) {
      // Statements here run every time
      // an instance of the class
      // is created.
   }
}

В этом классе requiredMargin является константой. Он объявляется с ключевым словом const и ни при каких обстоятельствах не может быть изменен ни на что иное, кроме 1.7. Обратите внимание, что имя константы не имеет ведущего значения $, как это делают имена переменных.

Абстрактные классы

Абстрактный класс - это тот, который не может быть инстанцирован, только унаследован. Вы объявляете абстрактный класс с ключевым словом abstract , например: При наследовании от абстрактного класса все методы, помеченные как абстрактные в объявлении класса родителя, должны определяться дочерним элементом; кроме того, эти методы должны быть определены с одинаковой видимостью.

abstract class MyAbstractClass {
   abstract function myAbstractFunction() {
   }
}

Обратите внимание, что в определениях функций внутри абстрактного класса также должен предшествовать абстрактный текст. Нелогично иметь абстрактные определения функций внутри не-абстрактного класса.

Статические классы или методы

Объявление классов или методов как статических делает их доступными без необходимости создания экземпляра класса. Член, объявленный как статический, не может быть доступен с помощью экземпляра объекта класса (хотя может использоваться статический метод).

Попробуйте следующий пример -

Конечное ключевое слово

PHP 5 представляет последнее ключевое слово, которое мешает дочерним классам переопределять метод, префикс определения с помощью final. Если сам класс определяется окончательным, то он не может быть расширен.

Следующий пример приводит к фатальной ошибке: невозможно переопределить конечный метод BaseClass::moreTesting()

<?php
   class BaseClass {
      public function test() {
         echo "BaseClass::test() called
";
      }
      final public function moreTesting() {
         echo "BaseClass::moreTesting() called
";
      }
   }
   class ChildClass extends BaseClass {
      public function moreTesting() {
         echo "ChildClass::moreTesting() called
";
      }
   }
?>

Вызов родительских конструкторов

Вместо того, чтобы писать совершенно новый конструктор для подкласса, давайте напишем его, вызвав явно конструктор родителя, а затем сделаем все, что необходимо дополнительно для создания экземпляра подкласса. Вот простой пример -

<?php
class Name{
   var $_firstName;
   var $_lastName;
   function Name($first_name, $last_name) {
      $this->_firstName = $first_name;
      $this->_lastName = $last_name;
   }
   function toString() {
      return($this->_lastName .", " .$this->_firstName);
   }
}
class NameSub1 extends Name {
   var $_middleInitial;
   function NameSub1($first_name, $middle_initial, $last_name) {
      Name::Name($first_name, $last_name);
      $this->_middleInitial = $middle_initial;
   }
   function toString() {
      return(Name::toString() . " " . $this->_middleInitial);
   }
}
?>

В этом примере у нас есть родительский класс (Name), который имеет конструктор с двумя аргументами и подкласс (NameSub1), который имеет конструктор с тремя аргументами. Конструктор функций NameSub1, вызвав его родительский конструктор явно , используя в: : синтаксисе (проходящие два своих аргументов вместе) , а затем установить дополнительное поле. Аналогично, NameSub1 определяет функцию non constructor toString ( ) в терминах родительской функции, которую он переопределяет.

ПРИМЕЧАНИЕ. Конструктор может быть определен с тем же именем, что и имя класса. Он определен в приведенном выше примере.

 С уважением, авторы сайта Компьютерапия

Понравилась статья? Поделитесь ею с друзьями и напишите отзыв в комментариях!