Блог веб разработки

Блог веб-разработки статьи | видеообзоры | исходный код

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

Всем привет и приступим. PHP является процедурным языком программирования, то есть главным составляющим при структурировании и написании кода является использование функций(процедур). C развитием технологий в современном мире большую популярность приобрела концепция объектно-ориентированного программирования. Которое вскоре появилось и в php начиная с версий 4 и 5.

В результате чего php поддерживает две концепции программирования процедурный и объектно-ориентированный.

Ну вот , сухое введение подходит к концу и давайте рассмотрим следующий код:

class Main{
    private $name;
    private $age;

    function __construct($name, $age){
        $this->name = $name;
        $this->age = $age;
        echo 'Меня зовут '.$this->name.' мне '.$this->age;
    }
public function __destruct(){
    echo "<br/>Объект уничтожен";
}


}


$main = new Main('Андрей',24);

Здесь как вы видите мы создали класс Main. Создание классов происходит стандартно как и в других языках программирования поддерживающих ООП.

Затем мы инициализировали свойства класса с модификаторами доступа private.(private $name; private $age;) Тут тоже все стандартно(public - общедоступный, protected - доступ только классам, private - доступ в пределах одного класса). И так у нас модификатор private, то есть мы не можем за пределами этого класса обращаться к его свойствам.

Давайте попробуем обратиться к свойству name.

echo $main->name;

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

Едем дальше function __construct , вы уже наверное догадались что так в php инициализируется конструктор. Кто не знает что такое конструктор , то это метод который вызывается при создании объекта класса или по другому его экземпляра.

$this->name и $this->age - обращение к свойствам класса которые в нем определены.

Как видно, здесь мы присваиваем текущим свойствам класса параметры конструктора.

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

И на конец, с помощью $main = new Main('Андрей', 24); мы создаем сам объект main класса Main. В результате всех наших действий у нас выводится 'Меня зовут Андрей мне 24'.

Дальше рассмотрим как работать с методами в классе:

Допустим мы хотим на основе предыдущего класса создать метод который определяет уровень нашего возраста. Для этого создадим метод LevelAge.

class Main{
    public $name;
    private $age;

    function __construct($name,$age){
        $this->name = $name;
        $this->age = $age;
        echo 'Меня зовут '.$this->name.' мне '.$this->age;
    }
    public function LevelAge(){
        $text = "Уровень возраста: ";
        if($this->intervalInterval(1,6,$this->age)) return $text.' ясельный и дошкольный';
        if($this->intervalInterval(7,11,$this->age)) return $text.' школьный';
        if($this->intervalInterval(12,17,$this->age)) return $text.' подростковый';
        if($this->intervalInterval(18,21,$this->age)) return $text.' юношеский';
        if($this->intervalInterval(22,35,$this->age)) return $text.' взрослый';
        if($this->intervalInterval(36,60,$this->age)) return $text.' зрелый';
        if($this->intervalInterval(61,75,$this->age)) return $text.' пожилой';
        if($this->intervalInterval(75,130,$this->age)) return $text.'старческий';
    }

    protected function intervalInterval($min,$max,$val) {
        if ($val >= $min && $val <= $max) return true;
        else return false;
    }
public function __destruct(){
    echo "<br/>Объект уничтожен";
}


}


$main = new Main('Андрей',24);
echo "<br/>";
echo $main->LevelAge();

как видите методы в классе представляют собой функции которым задаются модификаторы доступа. Сам метод levelAge благодаря модификатору доступа public является доступным благодаря чему мы смогли его вызвать за пределами класса.

В самом теле levelAge () мы в условиях использовали вызов другого метода intervalInterval() который определен в данном классе.

Как вы наверное уже заметили для того чтобы обращаться к свойствам и методам внутри самого класса где они определены используется ключевое слово this ($this->свойство; $this->метод()).

Метод intervalInterval() имеет модификатор доступа protected, то есть он будет доступен только в текущем классе и его дочерних.

echo $main->intervalInterval(22,35,'Взрослый');

такая строчка кода уже не прокатит.

Теперь давайте рассмотрим статические свойства и методы, и как с ними работать:

class Main{
    public $name;
    private $age;
    static public $count = 0;
    static private $names = '';


    public  function Users($name,$age){
        $this->name = $name;
        $this->age = $age;
        echo "<br/>";
        echo 'Меня зовут '.$this->name.' мне '.$this->age;
        echo "<br/>";
        echo $this->LevelAge();
        echo "<br/><br/>";
        self::$count++;
        self::$names .=$name.", ";
    }
static public function namesUser(){
        echo  "Участники: ".self::$names;
}
    protected function LevelAge(){
        $text = "Уровень возраста: ";
        if($this->intervalInterval(1,6,$this->age)) return $text.' ясельный и дошкольный';
        if($this->intervalInterval(7,11,$this->age)) return $text.' школьный';
        if($this->intervalInterval(12,17,$this->age)) return $text.' подростковый';
        if($this->intervalInterval(18,21,$this->age)) return $text.' юношеский';
        if($this->intervalInterval(22,35,$this->age)) return $text.' взрослый';
        if($this->intervalInterval(36,60,$this->age)) return $text.' зрелый';
        if($this->intervalInterval(61,75,$this->age)) return $text.' пожилой';
        if($this->intervalInterval(75,130,$this->age)) return $text.'старческий';
    }

    protected function intervalInterval($min,$max,$val) {
        if ($val >= $min && $val <= $max) return true;
        else return false;
    }


}


$main = new Main();
$main->Users('Андрей',24);
$main->Users('Егор',16);
$main->Users('Денис',8);

echo "<br/>Количество человек ".Main::$count;
echo "<br/>";
Main::namesUser();

первое что вы должны понять ,статические свойства и методы принадлежать контексту класса в котором они определены.

В данном выше коде мы видим что в контексте класса определены два статических свойства $count - количество участников и $names - имена участников и также метод namesUser()

В процессе добавления участников через метод Users у нас происходить увеличение количества $count на единицу и добавление нового имени участника.

Обратите внимание что обращение внутри класса к статическим методам и свойствам происходить не через $this-> , а self::.За пределами класса обращение имеет вид (Имя класса::статический метод(или свойство) класса) .

Main::$count - обращение к статическому свойству $count класса Main в результате мы получили значение этого свойства $count

Main::nameUser() - обращение к статическому методу nameUser() класса Main в результате мы получили значение статического свойства $names

То есть к статическим свойствам и методам можно обращаться без инициализации объекта при условии конечно что модификатор доступа public. Тут следует понимать что в статических методах можно работать только со статическими свойствами, по крайней мере пока.

Дальше мы рассмотрим наследование классов. Итак поехали!

class Main{
    public $name;
    private $age;
  //Родительский класс

    function __construct(){

    }
    public  function Users($name,$age){
        $this->name = $name;
        $this->age = $age;
        echo "<br/>";
        echo 'Меня зовут '.$this->name.' мне '.$this->age;
        echo "<br/>";
        echo $this->LevelAge();
        echo "<br/><br/>";
    }

    protected function LevelAge(){
        $text = "Уровень возраста: ";
        if($this->intervalInterval(1,6,$this->age)) return $text.' ясельный и дошкольный';
        if($this->intervalInterval(7,11,$this->age)) return $text.' школьный';
        if($this->intervalInterval(12,17,$this->age)) return $text.' подростковый';
        if($this->intervalInterval(18,21,$this->age)) return $text.' юношеский';
        if($this->intervalInterval(22,35,$this->age)) return $text.' взрослый';
        if($this->intervalInterval(36,60,$this->age)) return $text.' зрелый';
        if($this->intervalInterval(61,75,$this->age)) return $text.' пожилой';
        if($this->intervalInterval(75,130,$this->age)) return $text.'старческий';
    }

    protected function intervalInterval($min,$max,$val) {
        if ($val >= $min && $val <= $max) return true;
        else return false;
    }


}

class child extends Main{
    //Дочерний класс
    public function __construct(){
        parent::__construct();
    }
}

$main = new child();
$main->Users('Андрей',24);
$main->Users('Егор',16);
$main->Users('Денис',8);

Здесь также без особых сюрпризов все стандартно. Мы создаем класс child и через ключевое слово extends указывает название класса родителя , теперь указав в конструкторе ссылку на родительский класс parent::__construct(); мы имеем доступ ко всем свойствам и методам родительского класса в классе child.

Следует учитывать что мы не можем определять для классов более одного родителя.

Работа с интерфейсами тоже особо ничем не отличается от стандартов ООП.

interface one{
    public function message($text);
}
class Main{
    public $name;
    private $age;
  //Родительский класс

    function __construct(){

    }
    public  function Users($name,$age){
        $this->name = $name;
        $this->age = $age;
        echo "<br/>";
        echo 'Меня зовут '.$this->name.' мне '.$this->age;
        echo "<br/>";
        echo $this->LevelAge();
        echo "<br/><br/>";
    }

    protected function LevelAge(){
        $text = "Уровень возраста: ";
        if($this->intervalInterval(1,6,$this->age)) return $text.' ясельный и дошкольный';
        if($this->intervalInterval(7,11,$this->age)) return $text.' школьный';
        if($this->intervalInterval(12,17,$this->age)) return $text.' подростковый';
        if($this->intervalInterval(18,21,$this->age)) return $text.' юношеский';
        if($this->intervalInterval(22,35,$this->age)) return $text.' взрослый';
        if($this->intervalInterval(36,60,$this->age)) return $text.' зрелый';
        if($this->intervalInterval(61,75,$this->age)) return $text.' пожилой';
        if($this->intervalInterval(75,130,$this->age)) return $text.'старческий';
    }

    protected function intervalInterval($min,$max,$val) {
        if ($val >= $min && $val <= $max) return true;
        else return false;
    }


}

class child extends Main implements one{
    //Дочерний класс
    public function __construct(){
        parent::__construct();
    }

    public function message($text){
        echo $text;
    }
}

$main = new child();
$main->Users('Андрей',24);
$main->Users('Егор',16);
$main->Users('Денис',8);
$main->message('Мой первый интерфейс');

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

Далее мы через ключевое слово implements присваиваем содержимое интерфейса классу child, скажу сразу что в отличии от наследования мы можем присваивать классу сколько угодно интерфейсов перечисляя их через запятую(пример child implements one1, one2 и т.д).

После присвоения интерфейса мы должны обязательно реализовать его методы в текущем классе, если этого не сделать произойдет ошибка.

class child extends Main implements one{
    //Дочерний класс
    public function __construct(){
        parent::__construct();
    }

    public function message($text){//Обязательно реализовать метод интерфейса
        echo $text;
    }
}

И напоследок давайте рассмотрим работу с абстрактными классами и методами.

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

Рассмотрим на примере нашего главного класса main

abstract class Main{
    public $name;
    private $age;
  //Родительский класс

    function __construct(){

    }
    public  function Users($name,$age){
        $this->name = $name;
        $this->age = $age;
        echo "<br/>";
        echo 'Меня зовут '.$this->name.' мне '.$this->age;
        echo "<br/>";
        echo $this->LevelAge();
        echo "<br/><br/>";
    }

    protected function LevelAge(){
        $text = "Уровень возраста: ";
        if($this->intervalInterval(1,6,$this->age)) return $text.' ясельный и дошкольный';
        if($this->intervalInterval(7,11,$this->age)) return $text.' школьный';
        if($this->intervalInterval(12,17,$this->age)) return $text.' подростковый';
        if($this->intervalInterval(18,21,$this->age)) return $text.' юношеский';
        if($this->intervalInterval(22,35,$this->age)) return $text.' взрослый';
        if($this->intervalInterval(36,60,$this->age)) return $text.' зрелый';
        if($this->intervalInterval(61,75,$this->age)) return $text.' пожилой';
        if($this->intervalInterval(75,130,$this->age)) return $text.'старческий';
    }

    protected function intervalInterval($min,$max,$val) {
        if ($val >= $min && $val <= $max) return true;
        else return false;
    }


}
$main = new Main();

как видите для того чтобы объявить класс абстрактным мы используем ключевое слово abstarct. При попытке создания объекта класса Main мы получили закономерную ошибку.

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

class child extends Main {
    //Дочерний класс
    public function __construct(){
        parent::__construct();
    }

    
}

$main = new child();
$main->Users('Андрей',24);
$main->Users('Егор',16);
$main->Users('Денис',8);

как видите класс child является дочерним по отношению к абстрактному классу Main и здесь мы можем реализовать все его методы и свойства. Тем самым нам ограничен прямой доступ к классу Main и мы можем работать с ним только через его дочерние классы.

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

Пример:

abstract  function theEnd();
     public  function Users($name,$age){
        $this->name = $name;
        $this->age = $age;
        echo "<br/>";
        echo 'Меня зовут '.$this->name.' мне '.$this->age;
        echo "<br/>";
        echo $this->LevelAge();
        echo "<br/><br/>";
    }

    protected function LevelAge(){
        $text = "Уровень возраста: ";
        if($this->intervalInterval(1,6,$this->age)) return $text.' ясельный и дошкольный';
        if($this->intervalInterval(7,11,$this->age)) return $text.' школьный';
        if($this->intervalInterval(12,17,$this->age)) return $text.' подростковый';
        if($this->intervalInterval(18,21,$this->age)) return $text.' юношеский';
        if($this->intervalInterval(22,35,$this->age)) return $text.' взрослый';
        if($this->intervalInterval(36,60,$this->age)) return $text.' зрелый';
        if($this->intervalInterval(61,75,$this->age)) return $text.' пожилой';
        if($this->intervalInterval(75,130,$this->age)) return $text.'старческий';
    }

    protected function intervalInterval($min,$max,$val) {
        if ($val >= $min && $val <= $max) return true;
        else return false;
    }


}

class child extends Main{
    //Дочерний класс
    public function __construct(){
        parent::__construct();
    }
    public function theEnd()
    {
        echo 'Данная статья подходить к концу';
    }


}

$main = new child();
$main->Users('Андрей',24);
$main->Users('Егор',16);
$main->Users('Денис',8);
$main->theEnd();

как видите в абстрактном классе Main мы ,опуская реализацию, объявили абстрактный метод с говорящим названием theEnd() реализация которого обязательна в дочернем классе child , что мы успешно и сделали.

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

А я же надеюсь что сумел вас познакомить c ООП в php и вы не раз еще воспользуетесь полученными знаниями.

Я желаю вам успехов и удачи! Пока!

Оцените статью

Еще статьи

Агрегатные функции в SQL

Javascript генераторы

клавиши js

CSS flexbox

база данных php

session php

out of range

FileSystem api

Комментарии

В данном разделе пока нет комментариев!

История

    НОВОСТИ

    • Всем привет! Запустил новый сервис для поиска и бесплатного скачивания, прослушивания аудиокниг. Здесь вы можете найти множество литературы и прослушать ее. Вскоре возобновлю написание статей.