Topjava — онлайн-школа по обучению программированию на самом популярном в мире языке Java
Первое занятие бесплатно
Статьи
Отзывы студентов
Все
Принципы ООП на примере языка программирования Java
Знакомство с основами объектно-ориентированного
программирования в Java

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

    • Абстракция. Абстракция означает использование простых вещей для описания чего-то сложного. Например, мы все знаем как пользоваться телевизором, но в тоже время нам не нужно обладать знаниями о том, как он работает чтобы смотреть его. В Java под абстракцией подразумеваются такие вещи, как объекты, классы и переменные, которые в свою очередь лежат в основе более сложного кода. Использование данного принципа позволяет избежать сложности при разработке ПО.

    • Инкапсуляция. Под инкапсуляцией подразумевается сокрытие полей внутри объекта с целью защиты данных от внешнего, бесконтрольного изменения со стороны других объектов. Доступ к данным (полям) предоставляется посредством публичных методов (геттеров/сеттеров). Это защитный барьер позволяет хранить информацию в безопасности внутри объекта.

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

    • Полиморфизм. Данный принцип позволяет программистам использовать одни и те же термины для описания различного поведения, зависящего от контекста. Одной из форм полиморфизма в Java является переопределение метода, когда различные формы поведения определяются объектом из которого данный метод был вызван. Другой формой полиморфизма является перегрузка метода, когда его поведение определяется набором передаваемых в метод аргументов.
    Каким образом концепции ООП работают в Java
    Концепции ООП в Java позволяют программистам создавать компоненты, которые можно переиспользовать в различных частях программы не подвергая данные опасности.
    Принцип работы абстракции
    Основная цель использования данной концепции — это уменьшение сложности компонентов программы за счет скрытия от программиста, использующего эти компоненты, ненужных ему подробностей. Это позволяет реализовать более сложную логику поверх предоставленной абстракции, не вдаваясь в подробности ее реализации.

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

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

    Этот же подход можно использовать и в объектно-ориентированных языках программирования, таких как Java.
    Принцип работы инкапсуляции
    Инкапсуляция позволяет нам пользоваться возможностями класса без создания угрозы безопасности данных за счет ограничения прямого доступа к его полям. Также она позволяет изменять код классов не создавая проблем их пользователям (другим классам). В Java данный принцип достигается за счет использования ключевого слова private.
    Принцип работы наследования
    Наследование — еще одна важная концепция ООП, которая позволяет сэкономить время на написании кода. Возможности наследования раскрываются в том, что новому классу передаются свойства и методы уже описанного ранее класса. Класс, который наследуется называется дочерним (или подклассом). Класс, от которого наследуется новый класс — называется родительским, предком и т.д. В языке программирования Java используется ключевое слово extends для того, чтобы указать на класс-предок.
    Принцип работы полиморфизма
    Полиморфизм предоставляет возможность единообразно обрабатывать объекты с различной реализацией при условии наличия у них общего интерфейса или класса. По-простому: способность вызывать нужные методы у объектов, имеющие разные типы (но находящиеся в одной иерархии). При этом происходит автоматический выбор нужного метода в зависимости от типа объекта.

    Рассмотрим примеры полиморфизма в Java: переопределение и перегрузка методов.

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

    В случае же с перегрузкой, метод может проявлять различное поведение в зависимости от того, какие аргументы он принимает. В данном случае контекст вызова определяется набором параметров метода.
    Примеры концепций ООП в Java
    Давайте рассмотрим несколько распространенных примеров.
    Пример инкапсуляции
    В примере ниже рассмотрен один из принципов ООП — инкапсуляция. Поле name класса Student сокрыто от внешнего кода. Для доступа к этому полю определены методы getName() и setName(String name).
    package ru.topjava;
    
    public class Student {
    
        private String name;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name
        }
    }
    
    package ru.topjava;
    
    class Test {
    
        public static void main(String[] args) {
            Student student = new Student();
            student.setName("Josh");
            System.out.println(student.getName());
        }
    }
    Для компиляции перейдите в корневой каталог и выполните команду:
        javac -d out/ ru/topjava/*.java
    Для выполнения программы выполните команду:
        java -cp out/ ru.topjava.Test
    Вывод:
        Josh
    Пример использования наследования
    Для того чтобы воспользоваться механизмом наследования, необходимо использовать ключевое слово extends.
    package ru.topjava;
    
    public class Animal {
    
        //...
    }
    
    package ru.topjava;
    
    public class Dog extends Animal {
    
        //...
    }
    
    Пример использования полиморфизма
    Для демонстрации полиморфизма в Java, ниже опишем два класса Person и Employee. Класс Employee наследуется от класса Person с помощью ключевого слова extends. Далее, класс-наследник Employee переопределяет поведение метода walk() класса Person.
    package ru.topjava;
    
    class Person {
    
        void walk() {
            System.out.println("Can Run....");
        }
    }
    package ru.topjava;
    
    class Employee extends Person {
    
        void walk() {
            System.out.println("Running Fast...");
        }
    
        public static void main(String[] arg) {
            Person p = new Employee();
            p.walk();
        }
    }
    Советы для написания хорошего кода на языке программирования Java
    С тех пор, как принципы объектно-ориентированного программирования были приняты на вооружение многими языками, и по сей день помогая организовывать понятную и хорошо поддерживаемую архитектуру приложений, появилось множество практик, соблюдение которых способствует экономии времени программиста:
    • DRY (Don't Repeat Yourself — не повторяйся). Это один из основополагающих принципов разработки программного обеспечения в Java. Суть этого правила заключается в том, чтобы избегать появления одинакового кода в различных частях программы. Это достигается за счет вынесения дублирующихся строк кода в методы.

    • Если вы планируете в перспективе вносить изменения в программу, то инкапсулируйте по максимуму код, сделав приватными все его поля и методы. По мере того, как ваше приложение будет изменяться, расширяйте по мере необходимости доступ до protected, но не злоупотребляйте с public.

    • Single Responsibility (принцип единственной ответственности). Еще один важный принцип, пренебрегать которым не стоит. Суть его в том, что каждый класс должен иметь только одно назначение. Ответственность класса должна лежать исключительно в области его функциональности.

    • Open Closed Design (принцип открытости/закрытости). Делайте все методы и классы закрытыми для модификации, но открытыми для расширения.
    Более детально мы рассмотрим каждый из принципов объектно-ориентированного программирования в ближайших статьях.