Классы и создание объектов классов
На предыдущем занятии мы с вами познакомились с общей концепцией ООП. Но, чтобы вы могли все это использовать на практике, в частности, на языке Java, нужно знать как реализуются ее элементы. И, как всегда, начнем по порядку с самого начала – описания способа объявления классов и создания его объектов (экземпляров).
Во всех наших прежних программах у нас фигурировали строчки:
Смотрите, здесь вначале используется ключевое слово class, за которым следует его название – Main. Далее, открываются фигурные скобки и записывается функция main(), которая является точкой входа в программу. Это пример того, как можно объявлять класс. Начальный синтаксис здесь такой:
[модификаторы] class <
данные (переменные класса);
методы (функции класса);
другие классы и интерфейсы.
>
Как видите, внутри класса можно объявлять переменные, методы, вложенные классы и интерфейсы (что такое интерфейс мы будем говорить позже). Фактически, класс может содержать любые конструкции языка Java и иметь произвольный, самый изощренный функционал.
Конечно, сейчас мы изощряться не будем, а объявим в нашей программе простейший класс и, обычно, я выбираю класс для представления точек на плоскости:
Все, вот так просто можно добавить свой собственный класс в программу. Имя этого класса Point и он содержит два поля (две переменные) x и y.
Здесь сразу следует сделать два замечания:
1. В языке Java каждый новый класс принято записывать в отдельном файле проекта. Причем, имя файла должно совпадать с именем класса – это требование языка.
2. Объявление класса может находиться в любом месте программы. Это никак не влияет на возможность его использования, где бы то ни было в рамках проекта.
Например, мы можем создать ссылку типа Point в функции main(), несмотря на то, что сам класс объявлен после нее:
Я пока оставлю объявление класса в этом же файле для упрощения изложения материала. Итак, мы создали ссылку pt на класс Point. Посмотрим повнимательнее на эту запись. Что из нее следует? Да, имя класса можно воспринимать как новый тип данных. И этот тип данных формирует ссылки на соответствующие объекты. Обратите внимание, я произношу слово «ссылка», а не «переменная». В чем разница? Ссылка – это скрытый указатель, который хранит адрес объекта, на который ссылается, а переменная любого примитивного типа – это имя ячейки памяти, в которой непосредственно хранятся данные:
В этом принципиальная разница между ссылками и обычными переменными. Как же узнать, когда мы работаем со ссылками, а когда с переменными? Очень просто:
Если в качестве типа данных используется имя класса или интерфейса, то формируется ссылка. Если же используется примитивный тип данных (например, int, short, double, bool и т.п.), то объявляется обычная переменная.
Итак, мы создали ссылку на класс Point. Но самого объекта в памяти еще нет. Для его создания используется оператор new, за которым указывается имя класса создаваемого экземпляра:
Все, теперь у нас появился новый объект и на него ссылается переменная pt:
Что, если мы захотим создать еще один такой же объект. Давайте это сделаем вот так:
Мы здесь создаем еще один экземпляр класса Point в памяти устройства, и на него ссылается та же переменная pt. В итоге произойдет следующее:
Прежняя ссылка pt изменит свой адрес и будет ссылаться только на второй объект. Что произойдет с первым? Он так и останется в памяти «безымянным солдатом»? Без единой ссылки? Ссылок на него действительно не будет и пользоваться им мы уже не сможем. Но в памяти он не останется – он будет автоматически уничтожен сборщиком мусора. Это одно из ключевых отличий языка Java от языка C++ – наличие сборщика мусора. Благодаря ему, программист в Java может не беспокоиться об удалении ненужных объектов, то есть, объектов, на которые нет внешних ссылок. И это предотвращает неприятную историю, известную, как «утечка памяти», когда ненужные объекты остаются в памяти и постепенно накапливаются по мере работы программы. Это частая проблема языка C++ и, к счастью, в Java ничего подобного нет. Как мы потом увидим, это значительно упрощает программы и увеличивает гибкость программного кода.
Итак, мы научились объявлять классы и создавать его экземпляры. Как теперь обратиться к полям x, y созданного объекта и записать туда числовую информацию? Для этого используется следующий синтаксис:
Например, для доступа к полям через ссылку pt мы должны записать следующее:
В результате, в объект, на который ссылается переменная pt будут записаны числа 1 и 2:
Соответственно, их можно потом прочитать оттуда, например, так:
Вот так в самом простом варианте происходит запись и чтение данных из полей объекта. Причем, если создать еще один объект класса Point и записать туда другие числовые значения:
То это будут совершенно другие данные, никак не связанные с первыми. То есть, мы получим два независимых объекта класса Point.
Вот так в простейшем случае объявляются классы в Java и создаются их экземпляры. На следующем занятии мы продолжим эту тему и поговорим о конструкторах класса.
Подвиг 1. Объявить класс Point3D для хранения координат трехмерного пространства. Создать три таких объекта, записать в них различные координаты и вывести их поля в консоль.
Подвиг 2. Объявить класс Line, который бы хранил две координаты: начало и конец линии. Создать два таких объекта, записать и вывести по ним информацию в консоль.
Видео по теме
#11 Концепция объектно-ориентированного программирования (ООП)
#12 Классы и создание объектов классов
#13 Конструкторы, ключевое слово this, инициализаторы
#14 Методы класса, сеттеры и геттеры, public, private, protected
#15 Пакеты, модификаторы конструкторов и классов
#16 Ключевые слова static и final
#17 Внутренние и вложенные классы
#18 Как делается наследование классов
#19 Ключевое слово super, оператор instanceof
#20 Модификаторы private и protected, переопределение методов, полиморфизм
#21 Абстрактные классы и методы
#22 Интерфейсы — объявление и применение
#23 Интерфейсы — приватные, статические и дефолтные методы, наследование интерфейсов
#24 Анонимные внутренние классы
#25 Перечисления (enum)
#26 Обобщения классов (Generics)
#27 Ограничения типов, метасимвольные аргументы, обобщенные методы и конструкторы
#28 Обобщенные интерфейсы, наследование обобщенных классов
© 2021 Частичное или полное копирование информации с данного сайта для распространения на других ресурсах, в том числе и бумажных, строго запрещено. Все тексты и изображения являются собственностью сайта
Источник
Классы. Объектно-ориентированное программирование
Классы и объекты
Java является объектно-ориентированным языком, поэтому такие понятия как «класс» и «объект» играют в нем ключевую роль. Любую программу на Java можно представить как набор взаимодействующих между собой объектов.
Шаблоном или описанием объекта является класс , а объект представляет экземпляр этого класса. Можно еще провести следующую аналогию. У нас у всех есть некоторое представление о человеке — наличие двух рук, двух ног, головы, туловища и т.д. Есть некоторый шаблон — этот шаблон можно назвать классом. Реально же существующий человек (фактически экземпляр данного класса) является объектом этого класса.
Класс определяется с помощью ключевого слова сlass :
В данном случае класс называется Person. После названия класса идут фигурные скобки, между которыми помещается тело класса — то есть его поля и методы.
Любой объект может обладать двумя основными характеристиками: состояние — некоторые данные, которые хранит объект, и поведение — действия, которые может совершать объект.
Для хранения состояния объекта в классе применяются поля или переменные класса. Для определения поведения объекта в классе применяются методы. Например, класс Person, который представляет человека, мог бы иметь следующее определение:
В классе Person определены два поля: name представляет имя человека, а age — его возраст. И также определен метод displayInfo, который ничего не возвращает и просто выводит эти данные на консоль.
Теперь используем данный класс. Для этого определим следующую программу:
Как правило, классы определяются в разных файлах. В данном случае для простоты мы определяем два класса в одном файле. Стоит отметить, что в этом случае только один класс может иметь модификатор public (в данном случае это класс Program), а сам файл кода должен называться по имени этого класса, то есть в данном случае файл должен называться Program.java.
Класс представляет новый тип, поэтому мы можем определять переменные, которые представляют данный тип. Так, здесь в методе main определена переменная tom , которая представляет класс Person. Но пока эта переменная не указывает ни на какой объект и по умолчанию она имеет значение null . По большому счету мы ее пока не можем использовать, поэтому вначале необходимо создать объект класса Person.
Конструкторы
Кроме обычных методов классы могут определять специальные методы, которые называются конструкторами . Конструкторы вызываются при создании нового объекта данного класса. Конструкторы выполняют инициализацию объекта.
Если в классе не определено ни одного конструктора, то для этого класса автоматически создается конструктор без параметров.
Выше определенный класс Person не имеет никаких конструкторов. Поэтому для него автоматически создается конструктор по умолчанию, который мы можем использовать для создания объекта Person. В частности, создадим один объект:
Для создания объекта Person используется выражение new Person() . Оператор new выделяет память для объекта Person. И затем вызывается конструктор по умолчанию, который не принимает никаких параметров. В итоге после выполнения данного выражения в памяти будет выделен участок, где будут храниться все данные объекта Person. А переменная tom получит ссылку на созданный объект.
Если конструктор не инициализирует значения переменных объекта, то они получают значения по умолчанию. Для переменных числовых типов это число 0, а для типа string и классов — это значение null (то есть фактически отсутствие значения).
После создания объекта мы можем обратиться к переменным объекта Person через переменную tom и установить или получить их значения, например, tom.name = «Tom» .
В итоге мы увидим на консоли:
Если необходимо, чтобы при создании объекта производилась какая-то логика, например, чтобы поля класса получали какие-то определенные значения, то можно определить в классе свои конструкторы. Например:
Теперь в классе определено три коструктора, каждый из которых принимает различное количество параметров и устанавливает значения полей класса.
Консольный вывод программы:
Ключевое слово this
Ключевое слово this представляет ссылку на текущий экземпляр класса. Через это ключевое слово мы можем обращаться к переменным, методам объекта, а также вызывать его конструкторы. Например:
В третьем конструкторе параметры называются так же, как и поля класса. И чтобы разграничить поля и параметры, применяется ключевое слово this:
Так, в данном случае указываем, что значение параметра name присваивается полю name.
Кроме того, у нас три конструктора, которые выполняют идентичные действия: устанавливают поля name и age. Чтобы избежать повторов, с помощью this можно вызвать один из конструкторов класса и передать для его параметров необходимые значения:
В итоге результат программы будет тот же, что и в предыдущем примере.
Инициализаторы
Кроме конструктора начальную инициализацию объекта вполне можно было проводить с помощью инициализатора объекта. Инициализатор выполняется до любого конструктора. То есть в инициализатор мы можем поместить код, общий для всех конструкторов:
Источник
Что такое класс в Java
ООП — это то, на чём держится вся разработка на Java. С помощью объектов и классов можно создать любой функционал быстрее.
Объектно-ориентированное программирование — это подход к разработке приложений с помощью классов и объектов. Он позволяет писать значительно меньше кода и при этом реализовывать больше возможностей, чем при функциональном проектировании программ.
В программе, написанной по принципам ООП, отдельные компоненты рассматриваются как предметы из реального мира, такие как дом, дерево, кот, человек и даже Java-разработчик. У каждого объекта есть свои атрибуты. Вот какими они будут у принтера: цвет, марка, скорость печати, объём оставшейся краски и так далее.
Пишет о программировании, в свободное время создает игры. Мечтает открыть свою студию и выпускать ламповые RPG.
Также принтеру свойственно определённое «поведение»: печать, сканирование, копирование, проверка наличия краски, подключение к Wi-Fi и так далее — всё это называется методами.
Каждый принтер уникален, поэтому обладает своим идентификатором, по которому к нему можно обратиться, чтобы узнать или изменить тот или иной атрибут, а также вызвать метод:
Однако прописывать все атрибуты и методы для каждого объекта было бы слишком сложно, поэтому используются классы — общий шаблон того, как должен вести себя объект.
Допустим, существует класс Бумага, которому прописываются свои параметры и методы: цвет, цена, размер, толщина и так далее. Каждый отдельный объект является экземпляром класса. Например, можно создать объект листБумаги1, листБумаги2, листБумаги3 — у всех них будут одинаковые атрибуты и поведение, но разные значения:
Эту бумагу можно, например, передать объекту класса Принтер, чтобы её распечатать:
Без объектов нам бы пришлось создавать отдельные функции и работать с ними. Сейчас мы можем написать такой код:
То есть мы создаём объект и даём ему параметры: адрес и размер. Потом отправляем ему текст и лист бумаги, а он печатает это так, как прописано в теле метода.
Без классов нам бы пришлось создавать множество негруппированных переменных, в которых хранилась бы вся эта информация:
Представьте, как раздуется код от количества переменных и функций, которые нужны, чтобы распечатать обычный лист. А ведь нужно написать ещё и функцию заправки, сканирования, копирования и так далее.
Пришлось бы несколько раз дублировать одинаковые фрагменты кода, чтобы написать что-то. А ООП позволяет сократить код, а значит, быстрее разрабатывать программы, а также читать и переписывать их.
Как работают классы в Java
Создавая программу, нужно объявить класс с её именем, а потом добавить метод main — из него начинается работа приложения:
В Java всё, что не является объектом, является классом. Даже System, с помощью которого выводится текст, — это объект.
Можно создать переменные для этого класса — атрибуты:
Эти переменные вызываются из основного метода и умножаются. Вот как выглядит результат таких вычислений:
Пока не обращайте внимания на слова public и static — про них мы расскажем позже. Так же можно создавать методы, похожие на main. Для них укажите модификаторы доступа (public и static), возвращаемый тип и название:
Запустив программу, мы увидим результат работы метода GetCube():
Пока всё работает в пределах основного класса, но можно создать и другие. Для наглядности мы будем делать это на примере кода мессенджера. Здесь будут использоваться классы Сообщение (Message) и Пользователь (User).
Чтобы начать работать с классами, создайте папку для своего проекта: например, 01. Добавьте в неё ещё два каталога — src и bin. В первом будут храниться исходники, а во втором — скомпилированные файлы.
Теперь скомпилировать файл можно так:
А запустить — так:
Все классы должны находиться в отдельных файлах. которые нужно объединить в пакет. Его название должно выглядеть так: com.sitename.packagename. Хотя вы можете обойтись и без домена packagename. Чтобы создать пакет, сначала в папке src создайте следующую структуру:
В нашем случае для основного файла путь будет таким:
В тот же каталог поместите User.java и Message.java. После этого в начало каждого файла добавьте такую строчку:
Она означает, что этот код относится к определённому пакету. И чтобы воспользоваться каким-то классом, нужно добавить в начало основной программы несколько команд:
Теперь можно компилировать программу с помощью команды:
Если вы всё сделали правильно, в папке bin появится такая же структура, как в src. Вот код корневого файла приложения:
Теперь этот код можно запустить, прописав такую команду:
Вот что выведет консоль:
Этот процесс можно ускорить, если скачать IDE. Там для добавления нового класса достаточно будет выполнить несколько действий в графическом интерфейсе. Например, в Eclipse можно нажать File -> new -> class — этого будет достаточно.
Но если вы пока не уверены, что хотите продолжать работать на Java, можете поэкспериментировать в консоли.
Как создать класс в Java
Теперь можно приступить к созданию классов. Начнём с пользователя:
Слово public выступает модификатором доступа — он определяет, откуда будет доступен компонент. Для класса можно указать следующие модификаторы:
- public — доступно в любых частях программы (применимо и к другим компонентам);
- default — доступно только классам из того же пакета.
Теперь в основном файле можно создать объект класса User:
Мы указали для объекта user1 класс User, а после оператора присваивания указали ключевое слово new и запустили конструктор (об этом позже). Вот как будет выполнена программа:
Создание объекта называется объявлением экземпляра класса — тут же можно использовать конструктор, чтобы сразу задать значения атрибутам.
Для этого нужно в теле класса создать метод с таким же названием, что и класс. Ему можно передать аргументы, с которыми можно провести операции:
Обратите внимание, что внутри класса атрибуты вызываются с помощью ключевого слова this. Это нужно для того, чтобы компилятор не путался, с какой переменной работать — например, в случае, если у аргумента такое же имя, как и у атрибута:
Теперь, чтобы создать объект, нужно немного поменять код:
Дальше можно создать класс для работы с сообщениями:
Обратите внимание, что в этот раз для атрибутов from и to мы задали модификатор private, а в качестве типа стоит User. Private позволяет закрыть доступ к элементам извне — то есть их можно менять только внутри методов самого класса.
Это позволяет защитить атрибуты от незапланированного доступа. Если же вы хотите получать или менять атрибуты, можно воспользоваться getter и setter. Это специальные методы, которые позволяют обратиться к защищённой переменной:
Теперь можно написать код, который будет создавать сообщение:
Источник