Концепции ООП в Java с примерами

Давайте обсудим концепции OOPS в Java. В нашей статье представлена ​​каждая концепция, объяснены основы и приведены примеры. В конце концов, именно поэтому мы полагаемся на объектно-ориентированное программирование (ООП). Они практичны.

Хотя эта статья посвящена конкретно концепциям ООП в Java, эти идеи не зависят от языка. Концепции объектно-ориентированного программирования применимы ко всем языкам, поэтому вы сможете использовать их в C++, Ada, Pascal и Java.

Определение концепций ООП в Java

Прежде чем мы начнем, давайте обсудим основы. Что такое ООП?

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

• Класс. Подумайте о классе как о проекте или руководстве по эксплуатации определенной блочной структуры. Он расскажет вам, какие детали вам нужны и как они сочетаются друг с другом.
• Объект : это фактическая блочная структура, которую вы создаете с использованием этого проекта.
• Наследование : это как получить подержанный набор игрушек от старшего брата или сестры. В вашем новом наборе уже есть много деталей из старого набора, но вы можете добавить несколько новых или немного изменить его.
• Полиморфизм. Представьте, что у вас есть деталь, которая может менять свою форму в зависимости от того, где вы ее поместили в структуру. В мире программирования в зависимости от ситуации функция может действовать немного по-разному.
• Абстракция : вместо того, чтобы видеть каждую мельчайшую деталь и сложность вашей модели, вы просто видите общую форму и цвет. Это все равно, что прищуриться и посмотреть на общую картину без всех мелких деталей.
• Инкапсуляция : это похоже на постройку маленькой коробочки и решение, кто сможет ее открыть, кто сможет заглянуть внутрь или кто сможет изменить то, что находится внутри. У вас есть контроль над этим.
• Ассоциация : Думайте об этом как о различных наборах блоков, имеющих некоторую связь. Типа, блочный человек и блочная машина. У человека нет автомобиля, но он может на нем водить.
• Агрегация : здесь один набор блоков как бы владеет другим. Мол, у вас игрушечный дом, а внутри игрушечные наборы мебели. Мебель принадлежит дому, но может существовать и сама по себе.
• Состав : Это похоже на игрушечного человека и игрушечную шляпу. Если человек исчезнет (пуф!), шляпа тоже исчезнет, ​​потому что, ну, на кого она наденется?

Итак, Java, как и многие крутые современные языки, использует эти концепции. Это помогает сделать вещи аккуратными и организованными, а также гарантирует, что детали хорошо сочетаются друг с другом — как в мире игрушечных кубиков!

ООП-парадигма

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

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

Объект = Метод + Данные

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

Особенности ОПС

Некоторые особенности объектно-ориентированного программирования в Java:

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

Давайте разберем это на примере.

Представьте, что вы готовите на большой, загруженной кухне:

• Акцент делается на данных, а не на процедурах : это все равно что уделять больше внимания ингредиентам (например, помидорам, луку и специям), а не только рецепту. Вы знаете, что качество вашего блюда будет зависеть от свежести и полезности ингредиентов.
• Программы разделены на объекты. Представьте себе, что это разные станции на вашей кухне: станция для измельчения, сковорода и духовка. Каждый из них играет свою роль в приготовлении еды.
• Структуры данных характеризуют объекты : это похоже на наличие определенных контейнеров для каждого ингредиента — полка для специй, ящик для овощей, противень. Эти контейнеры многое расскажут вам о том, что находится внутри них.
• Методы объединены в структуру данных. Представьте, что к каждому контейнеру прикреплена карта рецептов. На карточке не только перечислены ингредиенты, но и указано, что с ними делать — например, нарезать, тушить или запекать.
• Данные скрыты; внешние функции не могут получить к нему доступ : это секретный соус шеф-повара! Знаешь, в этом есть что-то волшебное, но какой именно рецепт? Это заперто в хранилище. Другие могут наслаждаться вкусом, но не могут испортить оригинал.
• Объекты общаются посредством методов : это похоже на то, как плита сигнализирует вам, когда духовка разогрета, или блендер сообщает вам, что смешивание завершено. Они не разговаривают (очевидно), но у них есть способы (или методы) сообщить о своем статусе.
• Легко добавляйте новые методы и данные. Только что получили новый рецепт или свежий ингредиент? Не беспокойся! Вы можете легко добавить их в процесс приготовления. Это как обновить меню, не переделывая всю кухню.
• Подход «снизу вверх» в дизайне : вместо того, чтобы сначала выбирать полное меню, вы выбираете отдельные блюда. Типа: «Эй, я хочу приготовить потрясающие спагетти!» а потом вы думаете о том, чтобы добавить в смесь чесночный хлеб и салат.

Короче говоря, ООП в Java похоже на приготовление пиршества на хорошо организованной кухне. Всему свое место, и все вместе создает вкусный и сытный обед!

Список концепций OOPS в Java с примерами

Общие концепции OOPS в Java:

Объекты и классы

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

Например, «клиент» и «учетная запись» — это два объекта, которые могут отправлять сообщение объекту учетной записи с запросом баланса. Каждый объект содержит код и данные для управления данными. Объекты могут даже взаимодействовать, не зная деталей кода или данных друг друга.

Весь набор кода и данных объекта можно придать пользовательскому типу данных, используя концепцию класса. Класс — это «тип данных», а объект — это «переменная» этого типа. После создания класса можно создать любое количество объектов.

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

Представление объекта

Абстракция и инкапсуляция данных

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

Инкапсуляция объекта позволяет обращаться с объектами как с «черными ящиками», выполняющими определенную задачу, без какой-либо заботы о внутренней реализации.

Инкапсуляция — объекты как «черные ящики».

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

Абстрактные классы и абстрактные методы:

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

Способы достижения абстракции:

• Использование абстрактного ключевого слова
• Использование интерфейсов

Пример кода:

Код ниже показывает пример абстракции.

abstract class Car
{
Car()
{
System.out.println(«Car is built. «);
}
abstract void drive();
void gearChange()
{
System.out.println(«Gearchanged!!»);
}
}

class Tesla extends Car
{
void drive()
{
System.out.println(«Drive Safely»);
}
}

class Abstraction
{
public static void main (String args[])
{
Car obj = new Tesla();
obj.drive();
obj. gearChange();
}
}

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

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

Свойства наследования

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

Виды наследования

• Одинокий
• Несколько
• Многоуровневый
• Гибридный

Пример кода:

Код ниже иллюстрирует пример наследования.

class Animal
{
void eat()
{
System.out.println(«I am a omnivorous!! «);
}
}

class Mammal extends Animal
{
void nature()
{
System.out.println(«I am a mammal!! «);
}
}

class Dog extends Mammal
{
void sound()
{
System.out.println(«I bark!! «);
}
}

class Inheritance
{
public static void main(String args[])
{
Dog d = new Dog();
d.eat();
d.nature();
d.sound();
}
}

Полиморфизм

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

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

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

Полиморфизм может быть достигнут двумя способами:

Перегрузка метода

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

Когда мы вызываем метод в объекте, Java сначала сопоставляет имя метода, а затем количество и тип параметров, чтобы решить, какое определение выполнить.

Перегрузка метода достигается тремя способами:

times(int, int)
times(int, int, int)

times(int, int)
times(int, float)

times(int, float)
times(float, int)

Пример кода:

Код ниже демонстрирует концепцию перегрузки метода.

class CircleArea
{
double area(double x)
{
return 3.14 * x;
}
}

class SquareArea
{
int area(int x)
{
return x * x;
}
}

class RectangleArea
{
int area(int x, int y)
{
return x * y;
}
}

class TriangleArea
{
int area(int y, int x)
{
return (y * x)/2;
}
}

class Overloading
{
public static void main(String args[])
{
CircleArea ca = new CircleArea();
SquareArea sa = new SquareArea();
RectangleArea ra = new RectangleArea();
TriangleArea ta = new TriangleArea();

System.out.println(«Circle area = «+ ca.area(1));
System.out.println(«Square area = «+ sa.area(2));
System.out.println(«Rectangle area = «+ ra.area(3,4));
System.out.println(«Triangle area = «+ ta.area(6,3));
}
}

Переопределение метода

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

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

Пример кода:

Код ниже демонстрирует концепцию переопределения метода.

class Shape
{
void draw()
{
System.out.println(«Mention shape here»);
}

void numberOfSides()
{
System.out.println(«side = 0»);
}
}

class Circle extends Shape
{
void draw()
{
System.out.println(«CIRCLE «);
}

void numberOfSides()
{
System.out.println(«side = 0 «);
}
}

class Box extends Shape
{
void draw()
{
System.out.println(«BOX «);
}

void numberOfSides()
{
System.out.println(«side= 6»);
}
}

class Triangle extends Shape
{
void draw()
{
System.out.println(«TRIANGLE «);
}

void numberOfSides()
{
System.out.println(«side = 3 «);
}
}

class Overriding
{
public static void main (String args[])
{
Circle c = new Circle();
c.draw();
c.numberOfSides();

Box b = new Box();
b.draw();
b.numberOfSides();

Triangle t = new Triangle();
t.draw();
t.numberOfSides();
}
}

Динамическая привязка

Связывание — это процесс связывания вызова процедуры с кодом, который будет выполнен в ответ на вызов. Это означает, что код, связанный с данным вызовом процедуры, неизвестен до момента вызова во время выполнения. Это связано с наследованием и полиморфизмом.

Передача сообщений

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

• Создание классов, определяющих объекты и их поведение.
• Создание объектов
• Установление связи между объектами.

Сеть объектов, общающихся друг с другом

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

Например, рассмотрим утверждение.

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

Преимущества концепции ООП в Java

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

Применение концепции ООП в Java

• Системы реального времени
• Моделирование и моделирование
• Объектно-ориентированные базы данных
• Гипертекст и гипермедиа
• ИИ и экспертные системы
• Нейронные сети и параллельное программирование
• Системы автоматизации

Заключение

Иногда полезно рассматривать концепции ООП в Java как современный набор инструментов… потому что это, по сути, так и есть. Java — это инструменты и наборы инструментов. Инструменты подобны «объектам», а наборы инструментов, к которым принадлежит каждый тип инструментов, — это «классы». Когда вам нужно что-то исправить, вы достаёте конкретный инструмент (объект) из его набора инструментов (класса).

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