ознакомьтесь с частью 1, если вы еще не читали ее здесь
продолжая с того места, на котором мы остановились ... вот вторая часть серии ..
4. Конструкторы и методы.
Прошу прощения, если это становится слишком длинным ... Я не планировал, что это будет так долго, черт возьми, я никогда не писал что-то так долго, но эй, хорошие успехи?
Итак, методы и конструкторы. Подумайте о громких именах ... больших именах, но на самом деле это лишь некоторые украшения, чтобы простые вещи казались экзотическими. Я могу сравнить методы и конструкторы с действиями классов ... вспомните действия, которые мы говорили ранее о том, как автомобиль может тормозить, ускоряться и т. Д. Вот и все, что вы теперь знаете, что они из себя представляют, с точки зрения непрофессионала.
Метод - это набор операторов, которые выполняют определенную задачу и возвращают результат вызывающей стороне. Оказывается, конструктор - это особый метод, но сначала давайте посмотрим, как он выглядит.
общественный транспорт {
// ниже метод
// метод 1
public int Brake () {
// выполняем тормозное действие
возврат 1;
// 1 в приведенном выше утверждении - это просто заполнитель для целого числа, поскольку этот метод ожидает
// возвращено целое число
}
// еще один метод
// способ 2
public void drive (x, y) {
// выполняем действие привода
// обратите внимание, что вместо типа данных мы передали вместо него void
// это означает, что мы ничего не ожидаем от этого метода
}
// ниже - конструктор
// конструктор 1
общественный транспорт () {
// сделай что-нибудь
// обратите внимание, как он назван так же, как и класс
}
// у вас может быть несколько конструкторов, но обратите внимание на разницу
// конструктор 2
общественный транспорт (а) {
// сделай что-нибудь
// снова у нас есть еще один конструктор с именем класса
}
}
Не волнуйтесь, если это все еще не имеет смысла, помните, что мы находимся на теоретической стадии, нам придется поиграть со всем этим. Теперь давайте обратим внимание на метод 1. Синтаксис метода должен выглядеть для вас относительно простым и знакомым.
public int Brake () {
// что-то делаем
// не забудьте вернуть целое число
return 1;
}
Итак, сначала идет видимость (мы уже знаем, что она делает), а затем тип данных. Вам должно быть интересно, почему у нас это там есть. Тип данных появляется сразу после объявления видимости метода, и это просто означает, что мы ожидаем целое число, возвращенное методом, имя которого, очевидно, является тормозом. Отметьте ключевое слово return, потому что мы еще вернемся к нему. Перейдем к самому методу, и мы можем написать код нашего метода между фигурными скобками. Но подождите, я могу заметить пару скобок сразу после имени метода ... хорошо, если вы это заметили. Скобки обычно содержат параметры, передаваемые методу. Поскольку у метода 1 нет ничего между скобками, это означает, что нам не нужно предоставлять ему что-либо дополнительное при вызове метода. Помните, мы вызываем метод, чтобы он мог тормозить машину, верно?
Чтобы лучше продемонстрировать следующую часть, я собираюсь представить простую строчку, которую вы определенно не должны пытаться запомнить, просто просмотрите ее и поймите, что она делает. Это линия. (Мне тоже пришлось погуглить, чтобы убедиться, что я правильно понял :)… это должно вам кое-что сказать)
System.out.println («сюда можно передать любой текст»);
Приведенный выше оператор просто печатает текст , сюда мы можем передать любой текст. Вспомните, когда я уже говорил вам, что программирование в большинстве случаев похоже на игру с блоками лего, ну, это хорошая демонстрация для этого. Обратите внимание, что строка выше чувствительна к регистру… мы все, кроме тупого текста, который мы поместили туда. Если вы внимательно просмотрели эту строку, то могли заметить две точки после слов Система и out. Это другие классы, автоматически предоставляемые Java, это означает, что нам не нужно создавать все это, это не наше дело. * Drop mic
Просто обратите внимание на эту строку, потому что мы собираемся ее использовать.
Правильно
В настоящее время.
На метод 2
public void drive (int x, String y) {
// выполнить действие привода
}
Что ж, это все еще похоже на метод, но подождите, нет типа данных, вместо этого у нас есть ключ void непосредственно перед именем метода. Если присмотреться немного глубже, мы увидим, что пара скобок этого метода содержит содержимое. Прохладный? Итак, что должно означать пустота? Что ж, void буквально означает ~ отсутствие ~, и это должно говорить вам, что мы не ожидаем, что от метода ничего не будет возвращено. Простой.
Возникает вопрос: в каких случаях нам нужно что-то возвращать из наших методов, а в каких - нет?
Не волнуйтесь, мы справимся с этим через несколько секунд.
В фигурных скобках указано int x и String y, мы называем их параметрами. Это просто означает, что при вызове этого метода нам нужно предоставить целое число в качестве первого значения и String в качестве второго значения. Обратите внимание, что мы указали ожидаемый тип данных перед переменной параметра, использование другого типа данных или неправильный порядок приведет к ошибке. Мы предоставили два параметра, но это не означает, что в методах можно установить только 2 параметра, мы можем использовать как можно больше, но 5 - это максимальное рекомендуемое число, поскольку чем больше параметров вы передаете, тем сложнее становится ваш код. Это напоминает мне, что передача большего, чем ожидалось, или меньшего количества параметров, которые ожидаются в вызове метода, приводит к ошибке, всегда убедитесь, что вы установили точное необходимое количество, в правильном порядке и с правильным типом данных.
Итак, теперь давайте изменим наш метод так, чтобы он что-то печатал, используя линию, которую я обещал нам использовать.
Мы собираемся использовать два созданных нами метода, т.е. метод 1 и метод 2
Пример метода 1
public int Brake () {
// отступ, который вы могли заметить в коде, предназначен только для большей разборчивости
System.out.print («это просто предложение»);
// теперь вызов этого метода приведет к ..
// вы угадали, что утверждение ~ это просто предложение ~ будет напечатано на экране
}
Итак, мы уже узнали о добавлении параметров в наши методы, но вы, должно быть, захотите увидеть это в действии. Поехали ..
public void drive (int x, String y) {
// выполняем действие привода
System.out.print (y);
// обратите внимание, что я не использовал кавычки вокруг y, так как y - это переменная со значением
// передача его как «y» заставила бы метод распечатать ~ y ~, но теперь он должен печатать
// выводим содержимое y То есть мы инициализировали y, чтобы получить значение banana
// затем распечатывается ~ банан ~.
}
! Обратите внимание на использование двойных кавычек «» для строк, а не одинарных кавычек ‘’. одинарные кавычки предназначены для типов данных char.
Я чувствую, что мы достаточно узнали о методах, но когда-нибудь задумывались, как именно мы вызываем методы? Угадай ... это супер просто ...
Вот как ... просто проверьте имя, которое вы дали методу, и отметьте параметры, необходимые для выполнения метода, и мы буквально закончили ... ну, почти
Вот пример, который мы собираемся назвать "Тормозить и вести" ... и вот как мы это делаем.
тормоз ();
// только то
// диск (x, y)
// тоже так просто ... но обратите внимание, что во втором методе x и y - это переменные, которые у нас уже есть
// инициализируется заранее, чтобы теперь это выглядело так
общественный транспорт {
int somenumber = 4;
String randomSentence = «Я учусь программировать»;
// вызовем тормозной метод
тормоз ();
// позволяет вызвать метод привода и не забыть передать параметры
диск (somenumber, randomSentece);
public int Brake () {
System.out.print («это просто предложение»);
}
public void drive (int x, String y) {
System.out.print (y);
}
}
Прежде чем идти дальше, мы достигли точки, когда мне нужно что-то исправить или, скорее, ввести что-то еще. См. Приведенный выше случай, когда мы вызвали метод drive, мы решили передать туда некоторые значения, два, чтобы быть конкретными, int и String, поэтому мы назвали их параметрами, но в реальном смысле при вызове значения, которые мы передаем методу, называются аргументами. Это всего лишь параметры, когда мы говорим о самом методе. Думал, тебе стоит это знать.
Рекомендуется инициализировать переменные в начале класса, а также выполнять любые вызовы методов сразу после инициализации переменной.
А теперь мы переходим к специальному методу, называемому конструктором. Итак, что такое конструктор и для чего мы его используем? Обратитесь к примерам, помеченным как конструктор 1. Конструкторы обычно являются первыми методами, когда-либо вызываемыми при инициализации / создании класса. Это должно дать вам представление о том, почему бы тогда не вызвать наши методы в методе конструктора? Мы можем это сделать.
Итак, теперь наш класс должен выглядеть так.
общественный транспорт {
int somenumber = 4;
String randomSentence = «Я учусь программировать»;
общественный транспорт () {
// вызываем тормозной метод
тормоз ();
// позволяет вызвать метод привода и не забыть передать параметры
диск (somenumber, randomSentece);
}
public int Brake () {
System.out.print («это просто предложение»);
}
public void drive (int x, String y) {
System.out.print (y);
}
}
У каждого класса должен быть конструктор по умолчанию. С другой стороны, класс может иметь несколько конструкторов, их отличает количество необходимых параметров или типы данных параметров, необходимые для методов конструктора. Итак, теперь давайте представим второй параметр и посмотрим, как это работает.
общественный транспорт {
int somenumber = 4;
String randomSentence = «Я учусь программировать»;
общественный транспорт (x, y) {
// делаем что-то, например, вызываем другие методы
тормоз ();
диск (somenumber, randomSentece);
}
общественный транспорт () {
// вызываем тормозной метод
тормоз ();
// позволяет вызвать метод привода и не забыть передать параметры
диск (somenumber, randomSentece);
}
public int Brake () {
System.out.print («это просто предложение»);
}
public void drive (int x, String y) {
System.out.print (y);
}
}
И вот оно… у нашего класса теперь два конструктора. Эти два конструктора работают более или менее одинаково, за исключением ... ну, теперь, когда один ожидает аргументов, а другой нет, это должно быть уже знакомо, работая с методами, которые принимают аргументы, и с методами, которые не принимают.
! Помните, что методы, определенные с типом данных перед именем метода, должны ВОЗВРАЩАТЬ данные с этим точным типом данных.
Пример
public int stallvehicle () {
// сделай что-нибудь
возврат 1;
// в этом случае 1 - это просто заполнитель.
}
! Знаете ли вы, что вы также можете сделать переменные общедоступными / частными? Просто добавьте перед ним ключевое слово.
Пример:
общедоступный int numberOfWheels = 4;
Or
частное int numberOfWheels = 4;
Две приведенные выше инициализации означают, что общедоступный доступен для просмотра другим классам и другим частям нашего приложения, в то время как закрытый означает, что это не так. Вы меня правильно поняли. К закрытым переменным не могут получить доступ другие классы или части класса, за исключением того, которому принадлежит сама переменная. Мы увидим подобные ситуации, когда приступим к разработке Android, но пока стоит просто знать, что что-то в этом роде существует.
5. Объекты
Вот что-то новенькое, объекты, они позволяют подключиться к классу. Странно говорить о том, что мы создавали классы, но мы еще не использовали их или, скорее, показали, как именно их использовать. Под использованием я имею в виду доступ к классам и их свойствам и действиям (методам и переменным). Именно здесь конструктор действительно проявляет себя, потому что без него это было бы почти невозможным. Итак, в каких случаях нам нужно будет использовать методы класса ... ну, мы ведь не создали целый класс просто ради интереса, не так ли? Бывает, что почти весь или весь код JAVA в android размещен в классах ... это означает, что в некотором случае мы захотим получить доступ к специальной функции, которая доступна только в определенном классе, то есть классе транспортного средства. Может быть, мы хотим затормозить виртуальную машину, на которой мы едем. Итак, как мы это делаем, очень просто. Вот как.
Использование класса транспортного средства
Поскольку мы пытаемся получить доступ к классу из другого класса, давайте дадим этому классу имя Person
открытый класс Person {
// теперь для доступа к методу break в классе транспортного средства
// сначала создаем объект
// есть специальный синтаксис для наименования объекта
// начинаем с имени класса (класса, к которому мы пытаемся получить доступ), за которым следует имя, которое мы выбираем
// назовем объект
vehicle vehicleObject = новый автомобиль ();
// указанная выше строка только что создала объект в классе транспортного средства
// новый автомобиль - это то, как мы создаем объект, и это напрямую вызывает конструктор в классе
// это также должно вам сказать, что если бы у нас было два конструктора, мы также могли бы создать объект
// вот так
// транспортное средство VehicleObject = новое транспортное средство (x, y);
// аргументы x, y подразумевают, что конструктор их ожидает. Не забудьте использовать правильный
// тип данных и т. д.
// Теперь, когда мы создали объект класса, теперь мы можем получить доступ ко всем общедоступным методам в этом классе
// просто добавив точку к имени объекта и имени метода
// чтобы вызвать метод тормоза, просто сделайте это
vehicleObject.brake ();
}
6. Наследование
Вот удобная функция: наследование позволяет классам принимать свойства и действия других классов и иметь их как свои собственные. Проще говоря, так же, как дочерний элемент наследует определенные атрибуты от родителя, так же, как и классы, за исключением того, что в этом случае наследующий наследует все от родителя. При наследовании от существующего класса вы можете использовать методы и переменные родительского класса, как если бы вы изначально создали их в дочернем классе. Более того, вы также можете добавлять новые методы и поля в свой текущий дочерний класс. Вот пример, демонстрирующий вышеизложенное. Класс person будет унаследован от класса транспортного средства. Обратите внимание, что для наследования от класса мы используем ключевое слово extends
Пример.
открытый класс Person расширяет автомобиль {
// с указанным выше оператором extends включит методы и переменные транспортного средства
// для передачи в класс Person
// теперь, когда дочерний класс (Person) теперь является копией родительского класса (Vehicle)
// теперь мы владеем всеми методами и переменными, принадлежащими классу Vehicle, и теперь можем
// вызываем тормозной метод напрямую
тормоз ();
// в предыдущем методе, если бы мы попробовали это, это привело бы к ошибке, поскольку
// не было метода с именем Brake
// мы можем продолжить и добавить новые методы в класс Person, даже переменные, как обычно
// Все, что мы делаем в этом классе, никоим образом не повлияет на родительский класс
public int смех () {
// что-то делаем
возврат 1;
// обратите внимание, что я использую 1 в качестве заполнителя, так как этот метод ожидает возвращаемого типа данных int
// так что, чтобы все было правильно, я возвращаю случайное число для этой иллюстрации.
}
}
7. Перегрузка и переопределение метода
Помните, когда мы говорили, что у класса может быть несколько методов-конструкторов при условии, что параметры, необходимые для методов, различны. Оказывается, у класса также может быть несколько методов с одинаковым именем, а особенность заключается в том, что, как и у конструкторов, у них должны быть разные потребности в параметрах. Это само по себе и есть перегрузка метода. Таким образом, вызов методов приведет к примерно такому результату.
тормоз ();
тормоз (x);
// видим, что один из методов не ожидает аргумента, а другой ожидает его
Переопределение метода происходит в классах, которые наследуются от других классов, и это позволяет только переписать то, что метод делает в дочернем классе. Вот пример
public class Vehicle {
// это будет родительский класс
// дадим ему один метод
public void Brake () {
// сделай что-нибудь
}
}
А теперь в дочернем классе, наследующем вышеуказанный класс, мы собираемся переопределить метод тормоза.
открытый класс Person extends Vehicle {
// из приведенного выше мы наследуем от класса Vehicle
// так что теперь давайте перезапишем теперь унаследованный метод ... ой, извините, переопределите метод
// секреты вверх! переопределение - это просто создание / воссоздание унаследованного метода
// делаем все, что хочешь ... может быть, ты просто хочешь, чтобы он делал что-то по-другому
// помним, что все, что мы делаем с унаследованными свойствами, влияет на родительский класс
// достаточно сказано ... давайте переопределим метод тормоза
public void brake () {
// делаем что-нибудь другое
}
}
И это все. Просто да?
Думаю, я собираюсь здесь закончить эту довольно-таки очень длинную серию. Я мог бы продолжить и потеряться, рассказывая вам больше о Java, и напугать вас еще больше, но пока я решил закончить это здесь. Я хотел затронуть еще 5 тем, но тот факт, что я начал работать с Android, не зная о 5 оставшихся темах, означает, что вы справитесь с этим довольно хорошо. Самое приятное то, что с этой стороны будет легче сделать это, потому что мы еще не закончили обучение, и я все равно объясню все это, когда мы начнем работать с Android. Увидимся в следующей серии, где мы запачкаем руки, установим Android Studio и подготовимся к созданию нашего самого первого приложения для Android. Увидимся позже.
Я решил оставить здесь 5 тем, на случай, если некоторые из вас захотят попробовать. Опять же, я мог бы рассказать об этом, но блог постепенно превращался в книгу, и мои шутки к настоящему времени иссякли :(
l Класс Wrapper
l Анонимный класс
l заявления о попытках с ресурсами
l Обработка исключений
l Обобщения и коллекции
l Обработка исключений
Ознакомьтесь с частью 1 этой серии здесь https://medium.com/@wachiranduati/all-the-java-youll-ever-need-to-get-started-in-android-development-b4b2b5a8a082
ознакомьтесь с нашей следующей частью, где мы настраиваем студию Android и загружаем все зависимости, которые вам понадобятся для начала работы https://medium.com/@wachiranduati/getting-started-with-android-studio-installation-and-setting -it-up-f84cdfcaba8d
