Что такое класс в программировании java
Перейти к содержимому

Что такое класс в программировании java

  • автор:

Классы. Объектно-ориентированное программирование

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

Шаблоном или описанием объекта является класс , а объект представляет экземпляр этого класса. Можно еще провести следующую аналогию. У нас у всех есть некоторое представление о человеке — наличие двух рук, двух ног, головы, туловища и т.д. Есть некоторый шаблон — этот шаблон можно назвать классом. Реально же существующий человек (фактически экземпляр данного класса) является объектом этого класса.

Класс определяется с помощью ключевого слова сlass :

class Person

В данном случае класс называется Person. После названия класса идут фигурные скобки, между которыми помещается тело класса — то есть его поля и методы.

Любой объект может обладать двумя основными характеристиками: состояние — некоторые данные, которые хранит объект, и поведение — действия, которые может совершать объект.

Для хранения состояния объекта в классе применяются поля или переменные класса. Для определения поведения объекта в классе применяются методы. Например, класс Person, который представляет человека, мог бы иметь следующее определение:

class Person < String name; // имя int age; // возраст void displayInfo()< System.out.printf("Name: %s \tAge: %d\n", name, age); >>

В классе Person определены два поля: name представляет имя человека, а age — его возраст. И также определен метод displayInfo, который ничего не возвращает и просто выводит эти данные на консоль.

Теперь используем данный класс. Для этого определим следующую программу:

public class Program < public static void main(String[] args) < Person tom; >> class Person < String name; // имя int age; // возраст void displayInfo()< System.out.printf("Name: %s \tAge: %d\n", name, age); >>

Как правило, классы определяются в разных файлах. В данном случае для простоты мы определяем два класса в одном файле. Стоит отметить, что в этом случае только один класс может иметь модификатор public (в данном случае это класс Program), а сам файл кода должен называться по имени этого класса, то есть в данном случае файл должен называться Program.java.

Класс представляет новый тип, поэтому мы можем определять переменные, которые представляют данный тип. Так, здесь в методе main определена переменная tom , которая представляет класс Person. Но пока эта переменная не указывает ни на какой объект и по умолчанию она имеет значение null . По большому счету мы ее пока не можем использовать, поэтому вначале необходимо создать объект класса Person.

Конструкторы

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

Если в классе не определено ни одного конструктора, то для этого класса автоматически создается конструктор без параметров.

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

public class Program < public static void main(String[] args) < Person tom = new Person(); // создание объекта tom.displayInfo(); // изменяем имя и возраст tom.name = "Tom"; tom.age = 34; tom.displayInfo(); >> class Person < String name; // имя int age; // возраст void displayInfo()< System.out.printf("Name: %s \tAge: %d\n", name, age); >>

Для создания объекта Person используется выражение new Person() . Оператор new выделяет память для объекта Person. И затем вызывается конструктор по умолчанию, который не принимает никаких параметров. В итоге после выполнения данного выражения в памяти будет выделен участок, где будут храниться все данные объекта Person. А переменная tom получит ссылку на созданный объект.

Если конструктор не инициализирует значения переменных объекта, то они получают значения по умолчанию. Для переменных числовых типов это число 0, а для типа string и классов — это значение null (то есть фактически отсутствие значения).

После создания объекта мы можем обратиться к переменным объекта Person через переменную tom и установить или получить их значения, например, tom.name = «Tom» .

В итоге мы увидим на консоли:

Name: null Age: 0 Name: Tom Age: 34

Если необходимо, чтобы при создании объекта производилась какая-то логика, например, чтобы поля класса получали какие-то определенные значения, то можно определить в классе свои конструкторы. Например:

public class Program < public static void main(String[] args) < Person bob = new Person(); // вызов первого конструктора без параметров bob.displayInfo(); Person tom = new Person("Tom"); // вызов второго конструктора с одним параметром tom.displayInfo(); Person sam = new Person("Sam", 25); // вызов третьего конструктора с двумя параметрами sam.displayInfo(); >> class Person < String name; // имя int age; // возраст Person() < name = "Undefined"; age = 18; >Person(String n) < name = n; age = 18; >Person(String n, int a) < name = n; age = a; >void displayInfo() < System.out.printf("Name: %s \tAge: %d\n", name, age); >>

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

Консольный вывод программы:

Name: Undefined Age: 18 Name: Tom Age: 18 Name: Sam Age: 25

Ключевое слово this

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

public class Program < public static void main(String[] args) < Person undef = new Person(); undef.displayInfo(); Person tom = new Person("Tom"); tom.displayInfo(); Person sam = new Person("Sam", 25); sam.displayInfo(); >> class Person < String name; // имя int age; // возраст Person() < this("Undefined", 18); >Person(String name) < this(name, 18); >Person(String name, int age) < this.name = name; this.age = age; >void displayInfo() < System.out.printf("Name: %s \tAge: %d\n", name, age); >>

В третьем конструкторе параметры называются так же, как и поля класса. И чтобы разграничить поля и параметры, применяется ключевое слово this:

this.name = name;

Так, в данном случае указываем, что значение параметра name присваивается полю name.

Кроме того, у нас три конструктора, которые выполняют идентичные действия: устанавливают поля name и age. Чтобы избежать повторов, с помощью this можно вызвать один из конструкторов класса и передать для его параметров необходимые значения:

Person(String name)

В итоге результат программы будет тот же, что и в предыдущем примере.

Инициализаторы

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

public class Program < public static void main(String[] args) < Person undef = new Person(); undef.displayInfo(); Person tom = new Person("Tom"); tom.displayInfo(); >> class Person < String name; // имя int age; // возраст /*начало блока инициализатора*/ < name = "Undefined"; age = 18; >/*конец блока инициализатора*/ Person() < >Person(String name) < this.name = name; >Person(String name, int age) < this.name = name; this.age = age; >void displayInfo() < System.out.printf("Name: %s \tAge: %d\n", name, age); >>
Name: Undefined Age: 18 Name: Tom Age: 18

Классы и объекты

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

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

Рассмотрим картинку, приведенную ниже. Объявлен класс Student , у которого есть переменные name и rollNo , а также методы setName() и setRollNo() для установки этих значений. На основе этого класса создано несколько объектов: Jenna, John, Maria, James. У каждого объекта, то есть студента, есть name и rollNo , но они разные.

Классы и объекты фото

2. Как создать класс в Java

Рассмотрим как создать класс в языке Java. Упрощенная общая форма определения класса:

class ИмяКласса < тип переменнаяЭкземпляра1; тип переменнаяЭкземпляра2; // . тип переменнаяЭкземпляраN; тип имяМетода 1 ( список параметров) < // тело метода >тип имяМетода2 (список параметров) < // тело метода >… тип имяМетодаN (список параметров ) < // тело метода >> 

После ключевого слова class пишется имя класса. В теле класса объявляются переменные и методы класса. Их может быть сколько угодно.

Опишем класс для объекта Box (коробка). У коробки есть три главные характеристики: ширина, высота и глубина, описанные с помощью переменных:

public class Box

3. Создание объекта в Java

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

Вох myBox = new Вох();

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

Создание объектов класса представляет собой двух этапный процесс:

    Объявление переменной типа класса. Эта переменная не определяет объект. Она является лишь переменной, которая может ссылаться на объект:

Вох myBox;​
myBox = new Вох();​

Объявление объектов фото

После объявления объекта класса Box , всем переменным класса присваивается значение по умолчанию для заданного типа. Для того чтобы обратиться к переменной класса и изменить ее или получить значение, используется имя переменной объекта:

public class BoxDemo1 < public static void main(String[] args) < Box myBox = new Box(); // присвоить значение переменным экземпляра mybox myBox.width = 10; myBox.height = 20; myBox.depth = 15; // рассчитать объем параллелепипеда double volume = myBox.width * myBox.height * myBox.depth; System.out.println("Объем равен " + volume); >> 

В следующем примере объявляется два объекта класса Box и каждому устанавливаются свои значения. Изменения в переменных экземпляре одного объекта не влияют на переменные экземпляра другого.

public class BoxDemo7 < public static void main(String[] args) < Box myBox1 = new Box(); Box myBox2 = new Box(); double volume; // присвоить значения переменным экземпляра myBox1 myBox1.width = 10; myBox1.height = 20; myBox1.depth = 15; //присвоить другие значения переменным экземпляра myBox2 myBox2.width = 3; myBox2.height = 6; myBox2.depth = 9; // рассчитать объем первого параллелепипеда volume = myBox1.width * myBox1.height * myBox1.depth; System.out.println("Объем равен " + volume); // рассчитать объем второго параллелепипеда volume = myBox2.width * myBox2.height * myBox2.depth; System.out.println(" Объем равен " + volume); >>

4. Присваивание переменным ссылок на объекты

Возможна ситуация, когда две переменные указывают на один и тот же объект в памяти:

Присваивание переменным ссылок на объекты фото

Рассмотрим как это происходит на следующем примере.

При объявлении переменной b1 создается новый объект в памяти. При объявлении переменной b2 , вместо создания нового объекта, переменной присваивается ссылка на объект b1 . Далее объекту, на который указывает переменная b1 , присваиваются значения 10, 20, 30. А ширине объекта, на который указывает переменная b2 , присваивается значение 3:

public class BoxDemo6 < public static void main(String[] args) < Box1 b1 = new Box1(); Box1 b2 = b1; b1.width = 10; b1.height = 20; b1.depth = 15; b2.width = 3; System.out.println("Width: " + b1.width); System.out.println("Width: " + b2.width); >>

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

Width: 3.0 Width: 3.0

5. Добавляем методы в класс

Кроме переменных класс может содержать методы. В следующем примере в класс Box добавляется два метода: getVolume() — для вычисления объема коробки и setDim() — для установки размера коробки. Обратите внимание, что теперь мы объявляем методы нестатические (без ключевого слова static). В обоих методах мы имеем доступ к переменным класса.

public class Box < double width; double height; double depth; /** * Подсчитать объем коробки * * @return Объем */ double getVolume() < return width * height * depth; >/** * Установить размер коробки * * @param w - ширина * @param h - высота * @param d - глубина */ void setDim(double w, double h, double d) < width = w; height = h; depth = d; >>

В следующей программе создаются два объекта класса Box и вместо инициализации каждой переменной класса, как мы делали ранее, вызывается метод setDim() , куда передаются необходимые значения для ширины, высоты и глубины. Таким образом программа становится более компактной. Нестатический метод класса всегда вызывается для какого-то объекта. Аналогично, для подсчета объема коробки вызываем метод getVolume() для каждого объекта отдельно:

public class BoxDemo2 < public static void main(String[] args) < Box myBox1 = new Box(); Box myBox2 = new Box(); myBox1.setDim(10, 20, 15); myBox2.setDim(1, 5, 5); System.out.println("Объем: " + myBox1.getVolume()); System.out.println("Объем: " + myBox2.getVolume()); >>
  • Процедурное и объектно-ориентированное программирование
  • Принципы ООП
  • Конструктор
  • Ключевое слово this
  • Перегрузка
  • Стек и куча
  • Передача объектов в методы
  • Java varargs
  • Рекурсия
  • Сборщик мусора и метод finalize
  • Наследование
  • Ключевое слово super
  • Модификаторы доступа
  • Геттеры и сеттеры
  • Переопределение методов
  • Абстрактные классы и методы
  • Ключевое слово final
  • Задания

Классы и объекты

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

Классы

Java позволяет создавать классы, которые представляют объекты из реального мира. Например, можно создать класс Car (автомобиль) или Animal (животное) и задать им различные свойства. Для класса Car логично создать такие свойства как двери, колёса, лобовое стекло и т.д. Имея класс Car, можно создать новые классы Легковушки, Грузовики, Автобусы, которые будут иметь все свойства класса Car, а также свои собственные свойства. У класса Animal соответственно можно задать свойства Лапы, Хвост, а затем создать наш любимый класс Cat, у которого будет ещё дополнительное свойство Усы. Иными словами, классы могут наследовать свойства от других классов. Родительский класс называется суперклассом. Внутри классов могут быть объявлены поля и методы.

Для объявления класса служит ключевое слово class. Вспомним стандартную строчку кода из Android-проекта:

 public class MainActivity extends Activity < // код внутри класса >

Упрощённая общая форма для класса может иметь следующий вид:

 class ИмяКласса < тип переменная_экземпляра1; тип имяМетода(список параметров)< // тело метода >> 

В Java принято начинать имена класса с большой буквы. В классе могут быть несколько переменных и методов. Переменные, определённые внутри класса (не метода), называются переменными экземпляра или полями (fields). Код пишется внутри класса. Методы и переменные внутри класса являются членами класса.

Объекты

Новый объект (или экземпляр) создаётся из существующего класса при помощи ключевого слова new:

 Cat barsik = new Cat(); // создали кота из класса Cat 

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

Слева от оператора присваивания = определяется имя переменной и его тип Cat. В правой части выражения происходит выделение памяти для нового экземпляра класса Cat и инициализируется экземпляр. Оператор присваивания присваивает переменной ссылку на только что созданный объект. Имена объектов не нужно начинать с большой буквы, как у класса. Так вы будете различать, где класс, а где экземпляр класса. Если имя экземпляра класса состоит из нескольких слов, то используется верблюжья нотация, когда все первые буквы слов, кроме первой, пишутся с большой — superBlackCat.

Если вы помните, при объявлении примитивных типов мы указывали нужный тип в самом начале.

 int catAge; 

Поэтому код Cat barsik также определяет его тип. Он не всегда может совпадать с именем класса.

 Pet barsik = new Cat(); 

В этом примере используется тип класса домашних любимцев Pet, а обращаемся к классу котов Cat.

Простой пример создания класса Box (коробка для кота):

 class Box < int width; // ширина коробки int height; // высота коробки int depth; // глубина коробки >

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

Вам нужно создать отдельный файл Box.java, в который следует вставить код, описанный выше. О том, как создавать новый файл для класса я не буду здесь расписывать.

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

 Box catBox = new Box; // создали реальный объект с именем catBox на основе шаблона Box 

Красивая получилась коробочка.

Объект catBox, объявленный в коде вашей программы, сразу займёт часть памяти на устройстве. При этом объект будет содержать собственные копии переменных экземпляра width, height, depth. Для доступа к этим переменным используется точка (.). Если мы хотим присвоить значение переменной width, то после создания объекта класса можете написать код:

 catBox.width = 400; // ширина коробки для кота 400 миллиметров 

Если мы хотим вычислить объём коробки, то нужно перемножить все значения размеров коробки:

 Box catBox = new Box(); catBox.width = 400; catBox.height = 200; catBox.depth = 250; int volume = catBox.width * catBox.height * catBox.depth; mInfoTextView.setText("Объём коробки: " + volume); 

Каждый объект содержит собственные копии переменных экземпляра. Вы можете создать несколько объектов на основе класса Box и присваивать разные значения для размеров коробки. При этом изменения переменных экземпляра одного объекта никак не влияют на переменные экземпляра другого объекта. Давайте объявим два объекта класса Box:

 Box bigBox = new Box(); // большая коробка Box smallBox = new Box(); // маленькая коробка int volume; // присвоим значения переменным для большой коробки bigBox.width = 400; bigBox.height = 200; bigBox.depth = 250; // присвоим значения переменным для маленькой коробки smallBox.width = 200; smallBox.height = 100; smallBox.depth = 150; // вычисляем объём первой коробки volume = bigBox.width * bigBox.height * bigBox.depth; mInfoTextView.setText("Объём большой коробки: " + volume + "\n"); // вычисляем объём маленькой коробки volume = smallBox.width * smallBox.height * smallBox.depth; mInfoTextView.append("Объём маленькой коробки: " + volume); 

Когда мы используем конструкцию типа Box bigBox = new Box();, то в одной строке выполняем сразу два действия — объявляем переменную типа класса и резервируем память под объект. Можно разбить конструкцию на отдельные части:

 Box bigBox; // объявляем ссылку на объект bigBox = new Box(); // резервируем память для объекта Box 

Обычно такую конструкцию из двух строк кода не используют на практике, если нет особых причин.

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

Ключевое слово final

Поле может быть объявлено как final (финальное). Это позволяет предотвратить изменение содержимого переменной, по сути, это становится константой. Финальное поле должно быть инициализировано во время его первого объявления.

final int FILE_OPEN = 1;

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

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

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

 class Cat < final void meow() < System.out.println("Мяу"); >> class Kittent extends Cat < // Этот метод создать не получится void meow() < System.out.println("Да хоть гав-гав, всё равно не заведётся"); >> 

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

 final class Tail < // . >// Следующий класс недопустим class BigTail extends Tail < // Ошибка! Класс Хвост нельзя переопределять. >

Ключевое слово instanceof — Проверка принадлежности к классу

Иногда требуется проверить, к какому классу принадлежит объект. Это можно сделать при помощи ключевого слова instanceof. Это булев оператор, и выражение foo instanceof Foo истинно, если объект foo принадлежит классу Foo или его наследнику, или реализует интерфейс Foo (или, в общем виде, наследует класс, который реализует интерфейс, который наследует Foo).

Возьмём пример с рыбками, которые знакомы котам не понаслышке. Пусть у нас есть родительский класс Fish и у него есть унаследованные подклассы SaltwaterFish и FreshwaterFish. Мы можем протестировать, относится ли заданный объект к классу или подклассу по имени

 SaltwaterFish nemo = new SaltwaterFish(); if(nemo instanceof Fish) < // рыбка Немо относится к классу Fish // это может быть класс Fish (родительский класс) или подкласс типа // SaltwaterFish или FreshwaterFish. if(nemo instanceof SaltwaterFish) < // Немо - это морская рыбка! >> 

Данная проверка удобна во многих случаях. В Android очень много классов, которые происходят от класса ViewTextView, CheckBox, Button, имеющие свои собственные наборы свойств. И если имеется метод с параметром View, то при помощи instanceof можно разделить логику кода:

 void checkforTextView(View view) < if(view instanceof TextView) < // Код для элемента TextView >else < // Для других элементов View >> 

import — Импорт класса

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

import ClassNameToImport;

За ключевым словом import следуют класс, который нужно импортировать, и точка с запятой. Имя класса должно быть полным, то есть включать свой пакет. Чтобы импортировать все классы из пакета, после имени пакета можно поместить .*.

В Android Studio импорт класса происходит автоматически при наборе кода. Также это срабатывает и при вставке кода. Если имена классов совпадают, то студия может запросить помощь. Тогда вам нужно вручную указать нужное полное имя класса.

Импорт позволяет избежать долгого набора имени класса. Без импорта нам пришлось бы писать все классы в коде программы полностью.

 ru.alexanderklimov.MyClass.Cat.sayMeow(); java.lang.System.out.println("Мяу"); 

Статический импорт

Существует ещё статический импорт, применяемый для импорта статических членов класса или интерфейса. Это позволяет сократить количество кода. Например, есть статические методы Math.pow(), Math.sqrt(). Для вычислений сложных формул с использованием математических методов, код становится перегружен. К примеру, вычислим гипотенузу.

 hypot = Math.sqrt(Math.pow(side1, 2) + Math.pow(side2, 2)); 

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

 import static java.lang.Math.sqrt; import static java.lang.Math.pow; . hypot = sqrt(pow(side1, 2) + pow(side2, 2)); 

После импорта уже нет необходимости указывать имя класса.

Второй допустимый вариант, позволяющий сделать видимыми все статические методы класса:

 import static java.lang.Math.*; 

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

Класс Class

На первый взгляд, класс Class звучит как «масло масляное». Тем не менее, класс с таким именем существует и он очень полезен.

Программно получить имя класса

Иногда из программы нужно получить имя используемого класса. Для этого есть специальные методы getClass().getName() и другие родственные методы. Допустим, нам нужно узнать имя класса кнопки, на которую мы нажимаем в программе.

 public void onClick(View view) < String className = view.getClass().getName(); String simpleName = view.getClass().getSimpleName(); String canonicalName = view.getClass().getCanonicalName(); if (canonicalName == null) < canonicalName = "null"; >String s = "Имя класса: " + className + "\n" + "SimpleName: " + simpleName + "\n" + "CanonicalName: " + canonicalName + "\n"; mInfoTextView.setText(s); > 
 Имя класса: android.support.v7.widget.AppCompatButton SimpleName: AppCompatButton CanonicalName: android.support.v7.widget.AppCompatButton 

getSimpleName() возвращает только имя класса без пакета, другие методы вернут полное название.

Если нужно узнать имя класса активности, то достаточно кода:

 // подставьте имя вашей активности String className = MainActivity.class.getName(); 

Если вам известно имя класса, то можете получить сам класс:

 try < // получим объект Class ClassmyClass = Class.forName("ru.alexanderklimov.test.MainActivity"); mInfoTextView.setText(myClass.getName()); // выводим в TextView Intent intent = new Intent(this, myClass); startActivity(intent); > catch (ClassNotFoundException e) < // TODO Auto-generated catch block e.printStackTrace(); >

Метод getSuperclass() возвращает имя суперкласса. Остальные несколько десятков методов не столь популярны.

Классы, объекты, методы

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

Шаблоном или описанием объекта является класс (class), а объект представляет экземпляр класса. Можно провести следующую аналогию. У нас у всех есть некоторое представление о машине — наличие двигателя, шасси, кузова и т.д. Есть некоторый шаблон auto — этот шаблон можно назвать классом. Реально же существующий автомобиль auto_solaris (фактически экземпляр данного класса) является объектом этого класса.

Определение класса

Класс определяется с помощью ключевого слова сlass. Вся функциональность класса представлена его членами — полями (полями называются переменные класса) и методами. Например, класс Book мог бы иметь следующее описание :

class Book < public String name; public String author; public int year; public void Info()< System.out.printf("Книга '%s' (автор %s) была издана в %d году \n", name, author, year); >>

Таким образом, в классе Book определены три переменных и один метод Info, который выводит значения этих переменных.

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

class Book < public String name; public String author; public int year; Book()< this.name = "неизвестно"; this.author = "неизвестно"; this.year = 0; >Book(String name, String author, int year) < this.name = name; this.author = author; this.year = year; >public void Info()

Класс Book имеет два конструктора. Первый конструктор без параметров присваивает «неопределенные» начальные значения полям. Второй конструктор присваивает полям класса значения, которые передаются через его параметры.

Так как имена параметров и имена полей класса в данном случае у нас совпадают — name, author, year, то мы используем ключевое слово this. Это ключевое слово представляет ссылку на текущий объект. Поэтому в выражении this.name = name; первая часть this.name означает, что name — это поле текущего класса, а не название параметра name. Если бы у нас параметры и поля назывались по-разному, то использовать слово this было бы необязательно.

Мы можем определить несколько конструкторов для установки разного количества параметров и затем вызывать один конструктор класса из другого :

public class Book < public String name; public String author; public int year; Book(String name, String author) < this.name = name; this.author = author; >Book(String name, String author, int year) < // вызов конструктора с двумя параметрами this(name, author); // определение третьего параметра this.year = year; >>

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

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

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

Book b; // объявление переменной определенного типа/класса b = new Book(); // выделение памяти под объект Book

После объявления переменной Book b; эта переменная еще не ссылается ни на какой объект и имеет значение null. Затем создаем непосредственно объект класса Book с помощью одного из конструкторов и ключевого слова new.

Инициализаторы

Кроме конструктора начальную инициализацию полей объекта можно проводить с помощью инициализатора объекта. Так можно заменить конструктор без параметров следующим блоком :

public class Book < public String name; public String author; public int year; /* начало блока инициализатора */ < name = "неизвестно"; author = "неизвестно"; year = 0; >/* конец блока инициализатора */ Book(String name, String author, int year) < this.name = name; this.author = author; this.year = year; >>

Методы класса

Метод класса в объектно-ориентированном программировании — это функция или процедура, принадлежащая какому-либо классу или объекту.

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

Различают простые методы и статические методы :

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

Методы предоставляют интерфейс, при помощи которого осуществляется доступ к данным объекта некоторого класса, тем самым, обеспечивая инкапсуляцию данных.

Кроме имени и тела (кода) у метода есть ряд других характеристик:

  • набор модификаторов;
  • тип возвращаемого значения;
  • набор аргументов (параметров).

Модификаторы метода — public, protected, private

Модификаторы метода определяют уровень доступа. В зависимости от того, какой уровень доступа предоставляет тот или иной метод, выделяют:

  • public : открытый — общий интерфейс для всех пользователей данного класса;
  • protected : защищённый — внутренний интерфейс для всех наследников данного класса;
  • private : закрытый — интерфейс, доступный только изнутри данного класса.

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

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

Класс может включать метод main, который должен иметь уровень доступа public; к нему обращается виртуальная машина Java, не являющаяся частью какого-либо пакета.

Абстрактный класс, abstract class

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

public abstract class Price < public abstract int getPriceCode(); public abstract double summPrice(int days); public int bonusPrice(int days) < return 1; >>

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

В реализации ReleasePrice, наследующего свойства класса Price, «реализуем» абстрактные методы и «переопределяем» метод с использованием аннотации @Override :

public class ReleasePrice extends Price < public int getPriceCode() < return Disk.NEW_RELEASE; >public double summPrice(int days) < double summ = days*3; return summ; >/* * Метод bonusPrice переопределяем. В родительском метод возвращал 1, а здесь уже идет расчет */ @Override public int bonusPrice(int days) < if (days >1) return 2; return 1; > >

Теперь, если в родительском класса Price метод bonusPrice будет удален или переименован, то среда разработки должна выдать соответствующее сообщение. Компилятор также выдаст сообщение об ошибке.

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

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

Пример класса Test с тремя перегруженными методами test :

public class Test < void test() < System.out.println("параметр отсутствует"); >void test(int a) < System.out.println("a = " + String.valueOf(a)); >void test (int a, int b) < System.out.println("a + b = " + String.valueOf(a + b)); >void test(double d) < System.out.println("d = " + String.valueOf(d)); >>

Пример использования класса Test:

public class Testing < public static void main(String args[]) < Test of = new Test(); double result = 30.25; of.test(); of.test(10); of.test(20, 10); of.test(result); >>

Java рекурсия

Рекурсией называется метод (функция), которая внутри своего тела вызывает сама себя.

Рассмотрим пример рекурсивного метода вычисления факториала. Для того чтобы вычислить n!, достаточно знать и перемножить между собой (n-1)! и n. Создадим метод, реализующий описанный способ.

static int fact (int n) < if (n == 1) < return 1; >else if (n == 2) < return 2; >else < return fact(n-1) * n; >>

Указанный рекурсивный метод вычисляет факториал натурального числа.

Рассмотрим пример, вычисляющий через рекурсию n-ое число Фибоначчи. Напомним, как выглядят первые элементы этого ряда: 1 1 2 3 5 8 13 …

static int fib (int n) < if (index else if (n == 1) return 1; else if (n == 2)) return 1; return fib (n-2) + fib (n-1); >

Суперкласс Object

В Java есть специальный суперкласс Object и все классы являются его подклассами. Поэтому ссылочная переменная класса Object может ссылаться на объект любого другого класса. Так как массивы являются тоже классами, то переменная класса Object может ссылаться и на любой массив.

У класса Object есть несколько важных методов:

Метод Описание
Object clone() Функция создания нового объекта, не отличающий от клонируемого
boolean equals(Object object) Функция определения равенства текущего объекта другому
void finalize() Процедура завершения работы объекта; вызывается перед удалением неиспользуемого объекта
Class getClass() Функция определения класса объекта во время выполнения
int hashCode() Функция получения хэш-кода объекта
void notify() Процедура возобновления выполнения потока, который ожидает вызывающего объекта
void notifyAll() Процедура возобновления выполнения всех потоков, которые ожидают вызывающего объекта
String toString() Функция возвращает строку описания объекта
void wait() Ожидание другого потока выполнения
void wait(long ms) Ожидание другого потока выполнения
void wait(long ms, int nano) Ожидание другого потока выполнения

Методы getClass(), notify(), notifyAll(), wait() являются «финальными» (final) и их нельзя переопределять.

Проверка принадлежности класса instanceof

Для проверки принадлежности класса какому-либо объекту необходимо использовать ключевого слова instanceof. Иногда требуется проверить, к какому классу принадлежит объект. Это можно сделать при помощи ключевого слова instanceof. Это логический оператор, и выражение foo instanceof Foo истинно, если объект foo принадлежит классу Foo или его наследнику, или реализует интерфейс Foo (или, в общем виде, наследует класс, который реализует интерфейс, который наследует Foo).

Пример с рыбками. Допустим имеется родительский класс Fish и у него есть унаследованные подклассы SaltwaterFish и FreshwaterFish. Необходимо протестировать, относится ли заданный объект к классу или подклассу по имени

SaltwaterFish nemo = new SaltwaterFish(); if(nemo instanceof Fish) < // рыбка Немо относится к классу Fish // это может быть класс Fish (родительский класс) или подкласс типа // SaltwaterFish или FreshwaterFish. if(nemo instanceof SaltwaterFish) < // Немо - это морская рыбка! >>

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

void checkforTextView(View v) < if(v instanceof TextView) < // Код для элемента TextView >else < // Для других элементов View >>

Импорт класса import

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

import packane_name.Class_Name_To_Import;

За ключевым словом следуют класс, который нужно импортировать. Имя класса должно быть полным, то есть включать свой пакет. Чтобы импортировать все классы из пакета, после имени пакета можно поместить ‘.*;’

IDE Eclipse упрощает импорт. При написании кода в редакторе Eclipse можно ввести имя класса, а затем нажать Ctrl+Shift+O. Eclipse определяет, какие классы нужно импортировать, и добавляет их автоматически. Если Eclipse находит два класса с одним и тем же именем, он выводит диалоговое окно с запросом, какой именно класс вы хотите добавить.

Статический импорт

Существует ещё статический импорт, применяемый для импорта статических членов класса или интерфейса. Например, есть статические методы Math.pow(), Math.sqrt(). Для вычислений сложных формул с использованием математических методов, код становится перегружен. К примеру, вычислим гипотенузу.

hypot = Math.sqrt(Math.pow(side1, 2) + Math.pow(side2, 2));

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

import static java.lang.Math.sqrt; import static java.lang.Math.pow; . hypot = sqrt(pow(side1, 2) + pow(side2, 2));

После импорта уже нет необходимости указывать имя класса.

Второй допустимый вариант, позволяющий сделать видимыми все статические методы класса:

import static java.lang.Math.*;

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

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *