admin / 04.02.2018

Методы Java — как вызывать и использовать | GeekBrains — обучающий портал для программистов

.

Создание собственных классов в Java: свойства, методы, конструкторы

Создание класса: свойства и методы

Рассмотрим пример создания простейшего класса.

5. Java — Классы и объекты

Давайте с его помощью смоделируем окружности на координатной плоскости.

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

Пока не будем пытаться решать серьёзных задач с помощью класса, а наделим его следующими возможностями: созданную на основе класса окружность должно быть возможно выводить на экран (в виде описания её характеристик), перемещать (т.е. совершать преобразование движения, меняя координаты её центра) и масштабировать (т.е. совершать преобразование подобия, меняя радиус окружности).

// описываем отдельный новый класс class Circle { // свойства класса public double x; // абсцисса центра public double y; // ордината центра public double r; // радиус // методы класса // выводит на экран параметры окружности public void printCircle() { System.out.println("Окружность с центром ("+x+";"+y+") и радиусом "+r); } // перемещает центр, движение окружности public void moveCircle(double a, double b) { x = x + a; y = y + b; } // масштабируем, выполняем преобразование подобия с коэффициентом k public void zoomCircle(double k) { r = r * k; } } // описываем основной класс, содержащий метод main public class Main { public static void main(String[] args) { // Создаём объект (окружность класса Circle), у неё будет нулевой // радиус и центр в (0.0;0.0), поскольку все свойства получат // значения по умолчанию Circle o1 = new Circle(); // выводим на экран параметры окружности o1.printCircle(); // Меняем абсциссу центра, обращааясь к свойству x o1.x = 3; // Меняем радиус, обращааясь к свойству r o1.r = 12.3; // выводим на экран обновлённые параметры окружности o1.printCircle(); // Создаём другой объект того же класса Circle o2 = new Circle(); o2.r = 3.14; o2.zoomCircle(1.66); o2.printCircle(); // Окружность с центром (0.0;0.0) и радиусом 5.2124 } }

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

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

Значения по умолчанию для свойств зависят от их типа (0 или 0.0 для чиловых типов, false для логического типа и т.д.). 

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

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

class Circle { public double x; // абсцисса центра public double y; // ордината центра public double r; // радиус public void printCircle() { System.out.println("Окружность с центром ("+x+";"+y+") и радиусом "+r); } public void moveCircle(double a, double b) { x = x + a; y = y + b; } public void zoomCircle(double k) { r = r * k; } // конструктор по умолчанию, теперь сразу после создания объекта будем // получать окружность единичного радиуса с центром в начале координат public Circle() { x = 0.0; y = 0.0; r = 1.0; } } public class Main { public static void main(String[] args) { Circle o1 = new Circle(); o1.printCircle(); // Окружность с центром (0.0;0.0) и радиусом 1.0 } }

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

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

Описать подобный конструктор можно в дополнение к основному следующим образом:

public Circle(double a, double b, double s) { x = a; y = b; r = s; }

Теперь при создании объектов можно пользоваться любым конструктором на выбор:

Circle o1 = new Circle(); o1.printCircle(); // Окружность с центром (0.0;0.0) и радиусом 1.0 Circle o2 = new Circle(1,-1,14); o2.printCircle(); // Окружность с центром (1.0;-1.0) и радиусом 14.0

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

Доступ к членам класса из тела методов

Добавим в наш класс метод, вычисляющий площадь той окружности, к которой метод применён. Метод будет описывать так:

public double squareCircle() { double s = Math.PI * r * r; return s; }

Результат работы метода можно увидеть следующим образом:

System.out.println("Площадь круга o2: "+o2.squareCircle()); //615.75…

Обратите внимание: внутри каждого метода класса доступны свойства того объекта, для которого метод будет вызываться. То есть если мы вызываем метод для объекта o2, то внутри метода при его выполнении мы будем работать именно со свойствами объекта o2 (o2.x будет доступно x, o2.r будет доступно как r и т.д.).

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

Например, можно было бы начать описание метода для масштабирования таким образом:

public void zoomCircle(double r) {…

Как же в таком случае обращаться к свойствам объекта (ведь имена этих свойств перекрываются формальным параметром)?

Решение такой неоднозначности существует: к любому свойству внутри метода можно обращаться не только по имени, но и через ссылку this. То есть внутри метода можно написать x=13;, а можно this.x=13; — эффект будет идентичный. Соответственно, когда имя формального параметра перекрывает имя свойства, к имени свойства нужно обращаться через ссылку this. Тогда метод можно переписать таким образом:

public void zoomCircle(double r) { this.r = this.r * r; }

Понятно, что удобнее не допускать перекрывания имён свойств именами локальных параметров в методах. Иногда, впрочем, требуется внутри метода применить какой-то другой метод к текущему объекту, тогда без ссылки this не обойтись.

Добавим в класс метод, проверяющий, совпадают ли две окружности по площади.

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

Метод можно описать так:

public boolean equalsCircle(Circle cir) { if(this.squareCircle() == cir.squareCircle()) { return true; } else { return false; } }

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

if(o1.equalsCircle(o2)) { System.out.println("Круги o2 и o1 имеют равную площадь"); } else { System.out.println("Круги o2 и o1 имеют различную площадь"); }

Задачи

  1. Создайте в классе Circle метод, вычисляющий длину окружности.
  2. Создайте в классе Circle метод, перемещающий центр круга в случайную точку квадрата координатной плоскости с диагональю от [-99;-99] до [99;99]. Обратите внимание на то, что требуется создать обычный метод, применимый к уже существующему объекту, а не конструктор создающий новый объект.
  3. Измените в классе Circle конструктор по умолчанию так, чтобы в момент создания объекта с его помощью, координаты центра и радиус окружности пользователь вводил с клавиатуры.
  4. Создайте в классе Circle метод, вычисляющий расстояние между центрами двух окружностей.
  5. Создайте в классе Circle метод, проверяющий, касаются ли окружности в одной точке. Учтите, что возможен вариант, когда одна окружность содержится внутри другой и при этом всё равно возможно касание в одной точке.

Пример

class Circle { public double x; // абсцисса центра public double y; // ордината центра public double r; // радиус public void printCircle() { System.out.println(«Окружность с центром («+x+»;»+y+») и радиусом «+r); } public void moveCircle(double a, double b) { x = x + a; y = y + b; } public void zoomCircle(double r) { this.r = this.r * r; } public Circle() { x = 0.0; y = 0.0; r = 1.0; } public Circle(double a, double b, double s) { x = a; y = b; r = s; } // метод вычисляющий площадь круга public double squareCircle() { double s = Math.PI * r * r; return s; } // метод проверяющий равны ли окружности по площадям public boolean equalsCircle(Circle cir) { if(this.squareCircle() == cir.squareCircle()) { return true; } else { return false; } } } public class Main { public static void main(String[] args) { Circle o1 = new Circle(); o1.printCircle(); // Окружность с центром (0.0;0.0) и радиусом 1.0 Circle o2 = new Circle(1,-1,14); o2.printCircle(); // Окружность с центром (1.0;-1.0) и радиусом 14.0 System.out.println(«Площадь круга o2: «+o2.squareCircle()); //615.75…

o1.zoomCircle(14); if(o1.equalsCircle(o2)) { System.out.println(«Круги o2 и o1 имеют равную площадь»); } else { System.out.println(«Круги o2 и o1 имеют различную площадь»); } } }

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

Объекты
Ключевое слово instanceof — Проверка принадлежности к классу
import — Импорт класса
Класс Class

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

Классы

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

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

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

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

Объекты

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

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

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

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

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

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

Теперь подробнее.

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

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

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

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

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

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

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

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

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

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

Можно разбить конструкцию на отдельные части:

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

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

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

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

final int FILE_OPEN = 1;

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

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

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

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

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

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

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

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

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

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

import ClassNameToImport;

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

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

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

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

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

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

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

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

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

Класс Class

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

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

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

Получим варианты:

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

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

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

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

Реклама

Статья проплачена кошками — всемирно известными производителями котят.

Если статья вам понравилась, то можете поддержать проект.

Занятие 4. Начинаем вникать (начало)

На прошлом занятии мы создали, откомпилировали и запустили на исполнение очень простую программу на Java. Однако, рассмотрение того, как эта программа «устроена» мы оставили на потом. Сейчас мы этим и займемся.

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

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

Для начала познакомимся с тем, что такое класс и экземпляр класса. Воспользуемся аналогией и представим себе себе чертеж какого-нибудь сложного механизма, скажем, двигателя автомобиля. Еще один пример: лекало в швейном производстве, по которому изготавливается партия костюмов.

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

Очевидно, что сам по себе чертеж (лекало) – это не двигатель (и не костюм), а всего лишь его описание. А вот двигатели (костюмы), изготовленные по заданному чертежу (лекалу) – уже вполне реальные объекты и они-то и называются экземплярами класса.

Напомним исходный код нашей первой программы (для удобства ссылок строки пронумерованы):

1. public class MoneyForNothing {

2.     public static void main (String [] args) {

3.         System.out.println («Java programming is cool!!!»);

4.     }

5. }

Программы на Java создаются из классов — простые программы содержат один-два класа, сложные сотни и тысячи классов; просто запомните: все должно быть описано как класс или набор классов. Синтаксически, программы – это последовательности слов, символов, чисел и специальных знаков. Некоторые слова зарезервированы для специальных целей и должны использоваться так, как это предусмотрено спецификацией (фактически, стандартом) языка; это т.н. ключевые слова. Класс состоит из членов, относящиеся к двум категориям – поля и методы.

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

В нашем первом примере мы объявляем (описываем, вводим) класс (на это указывает слово «class») с названием «MoneyForNothing». Слово «class» — пример зарезервированного или ключевого слова. Класс имеет признак «public» — тоже, кстати, ключевое слово Java; этот признак регламентирует видимость этого класса, т.е., грубо говоря, кому можно его показывать или кому этот класс доступен. Здесь мы не будем задерживаться, хотя не трудно догадаться, что этот класс является публичным, т.е. он виден всем. Кстати, имя файла с исходным кодом класса должно полностью (с точностью до регистра) совпадать с именем класса. В одном файле можно описывать сколько угодно классов (хотя лучше так не делать и каждый класс размещать в отдельном файле), но только один из них должнен быть объявлен как public. Таковы требования Java и их надо принимать такими, как они есть.

Тело класса заключается в фигурные скобки (стр. 1 и 5).

Внутри класса определен один-единственный метод с именем «main» и целой «гирляндой» признаков. Метод – это программый код, выполняющий какую-либо последовательность действий над полями; напомним, что методы необходимы для изменения состояния объектов, путем воздействия на его поля. Этот метод также является публичным (на что указывает «public»). Метод может возвращать некоторое значение, а может ничего не возвращать: именно на этот случай предусмотрено ключевое слово void (которое можно перевести как «ничего» или «пустое значение»). Можно было бы подумать, что метод, ничего не возвращающий практически бесполезен, но это не так и в дальнейшем вы увидите множество примеров таких методов.

О ключевом слове «static», а также о параметрах методов мы поговорим вскоре, а пока заметим, что тело метода так же как и тело класса заключено в фигурные скобки (стр.2 и 4).

Внутри тела метода производится вывод (печать) на консоль строки «Java programming is cool!!!» (стр.3). Этот вывод не такой прямой, как во многих других языках программирования (где, например, используются конструкции print, write, put и им подобные). Возможности вывода в Java не являются частью самого языка, а «спрятаны» в одной из его библиотек. А поскольку все программы (и библиотеки, конечно же) в Java должны быть описаны в виде классов, то и вывод получается не столь прямолинейным, как можно было бы ожидать. Фактически в строке System.out.println происходит обращение к методу println, принадлежащего полю out, принадлежащего классу System (помните детское стихотворение «Дом, который построил Джек» с его многоуровневой вложенностью? Здесь мы наблюдаем нечто подобное). Все это может показаться «китайской грамотой», но не волнуйтесь – на самом деле все логично и надо только постепенно привыкнуть.

Тут, как нельзя кстати, оказывается полезной документация по Java. Фрагмент этой документации, относящийся к выводу строки о котором мы только что говорили, выглядит так:

Конечно, без некоторого навыка чтение документации не такое простое дело, но это поправимо. А пока имейте в виду, что овладеть Java (впрочем, как и любым другим языком программирования) без обращения к документации, практически невозможно. Вскоре вы привыкнете и научитесь пользоваться документацией; поверьте, она окажет вам бесценную помощь.

Нам осталось разобраться с ключевым словом static и параметрами метода main. Начнем с последнего.

Параметры – это список значений, разделенных запятыми, передаваемых в метод для последующей обработки. Тем, кто еще помнит математику, вызов метода с параметрами напоминает запись функции, такой, например как sin (x) или √x.

Класс (Java)

Последний пример (т.е. √x) — это функция квадратного корня, а x — параметр (неотрицательное число, не обязательно целое). Для x = 4, функция вернет 2, для x = 1.44 функция вернет 1.2 и т.д. В Java метод может получать 0, 1, 2 и любое другое число параметров (скобки, окружающие список параметров, опускать нельзя даже если ни один параметр не передается). В нашей программе в качестве (единственного) параметра выступает массив строковых значений; эти значения являются ни чем иным, как дополнительными данными при запуске программы на исполнение, например, так:

java MoneyForNothing список_параметров

Здесь «список_параметров» — необязательные дополнительные данные (часто их называют параметрами командной строки).

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

Дословный перевод этого слова – «статический» — мало о чем говорит. Назначение этого ключевого слова – особенным образом выделить поля и методы: поля и методы, снабженные признаком static существуют даже тогда, когда нет ни одного экземпляра класса.

Держим пари, что прочтя эту фразу вы ничего не поняли. Но все, на самом деле, логично. Для этого давайте присмотримся, что происходит, когда мы запускаем программу на исполнение (напоминаем, что для этого надо дать команду java MoneyForNothing).

Исполняющая среда Java (т.н. Java Virtual Machine или, короче, JVM) считывает инструкции из файла MoneyForNothing.class, созданного ранее компилятором. Ну хорошо, инструкции прочитаны, а дальше-то что, как и откуда начать выполнение?

Помните аналогию между классом и чертежом? Сейчас в памяти компьютера мы имеем только чертеж и ничего более: ни одного экземпляра класса (или иначе – ни одного объекта) еще не создано. Характерной особенностью ключевого слова static является то, что поля и методы, помеченные как static существуют даже если больше ничего не было создавалось! Т.е. метод main – это реально готовый к исполнению метод, а так как ничего другого в момент запуска программы еще нет, то JVM ничего не остается, как исполнить именно его, т.е. метод main.

Не случайно, метод main программисты называют «точкой входа», т.е. точкой с которой начинается выполнение программы.

Тем, кто программировал на таких языках как C или C++ метод main хорошо знаком. Разработчики Java в далеком уже 1995 году взяли в качестве образца именно эти языки программирования (но не повторили их, а пошли своим путем).

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

 

Занятие 3. Приступаем …

 

Занятие 5. Начинаем вникать (окончание)

 

Автор: Alex Tuesday

 

Все уроки … 27.01.2014

2. Урок по Java. Классы


Продолжим, это второй урок по классам.

В Java очень много завязано на классах.

Класс можно рассматривать например как шаблон, его свойства(переменные) и методы(как действия)

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

Если Вы читали прошлый урок http://snakeproject.ru/rubric/article.php?art=java_1 , то знаете как создать проект и класс на Java в Eclipse

 

1. Создадим новый проект(назовите по желанию)

2.

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

Создадим три класса:

General:

В этом классе мы объявляем переменны и методы.

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

Ключевое слово void говорит о том, что метод по сути ничего не возвращает, просто делает заложенный код.

Ключевое слово private говорит о том, что к переменной или методу можно обращаться только в рамках этого класса.

Ключевое слово String (может быть и другим типом возвращаемого значения, например int или char) говорит о том, что за тип данных возвращает метод

Ключевое слово return используется совместно с типом возвращения в методах

Так-же можно переменным задавать значения посредством возвращаемого значения методами (строка z = ext2();)

Методы могут принимать и не принимать значения(аргументы).

GeneralExtends:

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

GeneralExtends — конструктор класса(объявляется как и имя класса), является методом\блоком кода, который выполняется при инициализации класса. Т.е. проще говоря это код, который выполнится, когда мы создадим экземпляр класса.

Ключевое слово super дает нам возможность обращения к методам и свойствам класса, от которого мы наследовались

Extended:

public static void main(String[] args) — является входом в программу, он может принимать аргументы из командной строки передаваемые приложению(программе)

Создание экземпляров класса (по аналогии как с переменными указываем как тип имя класса и присваиваем значение):

GeneralExtends genext = new GeneralExtends();
General gen = new General();

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

На этом все, на заметку обратите внимание на методы ext1 в классе General.

У них одинаковое имя, но они принимают разное количество аргументов.

Такие методы называются перегруженными.


Комментарии пользователей

Анонимам нельзя оставоять комментарии, зарегистрируйтесь!

.

FILED UNDER : IT

Submit a Comment

Must be required * marked fields.

:*
:*