Интерфейсы в Java
Объявите interface с пустыми заголовками методов, затем заполните эти методы в классе через implements. Напишите interface Signal с void horn(); без тела. Напишите class Truck implements Signal и дайте horn тело, которое печатает honk. В Yard.java создайте Truck и вызовите t.horn(). Скомпилируйте через javac Yard.java и запустите java Yard. На экране должен быть honk. Вторая демонстрация позволяет одному классу implements сразу два интерфейса. Enums оставьте для следующей страницы — этот урок про обещание метода и класс, который его держит.
Реализуйте один метод интерфейса
Страница override переписала horn у потомка, который уже имел extends Car. Эта страница начинается с обещания без тела. Откройте Yard.java. Держите имя public-класса Yard. Удалите оставшиеся демо Car/Truck с extends, если они хоронят историю интерфейса, печати конструкторов с super, демо путей и любой клавиатурный Scanner. Программа не должна ждать ввода. Строка import не нужна.
Объявите интерфейс над классами:
interface Signal {
void horn();
}
Заголовок заканчивается точкой с запятой. Внутри интерфейса на этой начинающей форме у horn нет тела { }.
Объявите класс, который держит обещание:
class Truck implements Signal {
Внутри Truck напишите public метод с тем же именем и заполните тело:
public void horn() {
System.out.println("honk");
}
Ключевое слово — implements, не extends. Класс должен дать тело каждому методу, перечисленному в интерфейсе. На этой странице это только horn.
Внутри Yard.main создайте truck и вызовите метод:
Truck t = new Truck();
t.horn();
Вызов выполняет тело, написанное у Truck, поэтому экран печатает honk.
interface Signal {
void horn();
}
class Truck implements Signal {
public void horn() {
System.out.println("honk");
}
}
public class Yard {
public static void main(String[] args) {
Truck t = new Truck();
t.horn();
}
}
Из папки, где лежит Yard.java, запустите javac Yard.java. Когда скобки, фигурные скобки и точки с запятой совпадают, javac не пишет собственной строки. Затем запустите java Yard — не java Yard.java. Уберите окончание .java из команды запуска. Держите один public-класс в файле, чтобы имя совпадало с Yard. Интерфейс Signal и вспомогательный класс Truck на этой начинающей форме остаются без public.
Экран показывает honk. Пройдите запуск один раз. Java стартует с Yard.main. new Truck() создаёт truck, который пообещал Signal. t.horn() выполняет тело у Truck и печатает honk. Вы никогда не пишете new Signal() — интерфейс называет методы; класс даёт тела и объект.
Если javac отказывает, проверьте три вещи. Во-первых, строка класса должна говорить implements Signal, а не extends Signal. Во-вторых, каждому методу интерфейса нужен соответствующий метод у класса. В-третьих, метод реализации на этой учебной форме — public, чтобы совпасть с публичным контрактом интерфейса. Если вы всё ещё видите beep из старого файла override, переключитесь на учебный файл интерфейса и снова запустите java Yard.
Произнесите правило вслух, глядя на экран: интерфейс называет вызов, класс заполняет тело, объект выполняет это тело. Держите implements на классе, которому принадлежит печать. Не изобретайте enum на этой странице. Enums ждут следующего урока.
Реализуйте два интерфейса на одном классе
Вторая программа сохраняет Yard и Truck. Теперь Truck реализует два интерфейса. Signal по-прежнему просит horn. Mark просит show. Класс заполняет оба тела. main вызывает оба метода.
interface Signal {
void horn();
}
interface Mark {
void show();
}
class Truck implements Signal, Mark {
public void horn() {
System.out.println("honk");
}
public void show() {
System.out.println("truck");
}
}
public class Yard {
public static void main(String[] args) {
Truck t = new Truck();
t.horn();
t.show();
}
}
Скомпилируйте через javac Yard.java, затем запустите java Yard. Экран показывает honk, затем truck. Первая строка приходит из обещания Signal, заполненного у Truck. Вторая строка приходит из обещания Mark, заполненного у того же класса. Разделяйте имена интерфейсов запятой в списке implements: implements Signal, Mark.
Прочитайте заголовок класса ещё раз. Один класс. Два интерфейса. Два тела методов. Это начинающая картина держать больше одного обещания без двух родителей extends. Java позволяет классу наследовать только один класс; он может реализовать несколько интерфейсов. Эта страница показывает такой список через запятую в маленьком файле Yard.
Если вы опустите show, пока Mark в списке, javac откажет, потому что каждому перечисленному методу интерфейса нужно тело. Если вы уберёте Mark из списка implements, но всё равно напишете show, у вас обычный метод, а не выполнение обещания интерфейса для Mark. Держите оба имени в строке класса, когда хотите, чтобы оба обещания проверялись.
Сравнение с override через extends
На странице override Truck extends Car и переписал horn, у которого уже было тело у родителя. На этой странице Signal начинается без тела, и Truck implements Signal даёт первое тело. Вы по-прежнему компилируете Yard.java и запускаете java Yard. Вы по-прежнему вызываете t.horn(). Новые токены — interface, implements и — во второй демо — список implements через запятую.
Если всё ещё открыт оставшийся файл override, вы увидите extends Car и, возможно, beep рядом с honk. Переключитесь на учебный файл интерфейса, чтобы вверху файла был interface Signal, а строка класса показывала implements. Держите демо enum вне этой страницы. Держите клавиатурный ввод вне этой страницы.
Что эта страница оставляет для enums
Эта страница заполняет методы интерфейса через implements. Следующая страница показывает enums, где тип перечисляет фиксированный набор именованных значений. Оставайтесь здесь с обещаниями интерфейса. Пока не заменяйте сегодняшние демо списком enum как требованием.
Когда позже вы будете использовать enums, вы всё ещё можете реализовывать интерфейсы на других типах в той же программе. Считайте эту страницу интерфейсной половиной соседней истории. Доведите обе демо Yard до автоматического ощущения honk — а потом honk плюс truck — прежде чем открывать урок enums.
Перед enums
Вы можете написать interface Signal с пустым horn(), реализовать его у Truck и увидеть honk от t.horn(). Вы можете реализовать Signal и Mark на одном классе и увидеть honk, затем truck. Компилируйте Yard.java и запускайте java Yard для каждой сохранённой демо по очереди. Класс держал обещания интерфейса. Следующая страница — enums, где тип перечисляет фиксированные имена.
Держите демо с одним интерфейсом и honk для ясной истории implements. Держите демо с двумя интерфейсами для ясного списка через запятую. Держите файлы enum вне этой страницы. Эти три привычки — контрольная точка перед переходом дальше. Когда после t.horn() появляется honk — и когда вторая демо после show() также печатает truck — интерфейсы сделали работу этого урока, и вы готовы к следующей теме про enums.
Ещё один проход по папке: один public Yard, заголовки интерфейсов с пустыми методами, класс который их implements, без ожидания клавиатуры, без принудительного enum. Ещё раз запустите javac Yard.java и java Yard на демо, которую держите открытой. Если экран всё ещё печатает заполнения интерфейса, которые вы написали, обещания крепки и курс может перейти к enums на следующей странице.
🧠 Проверьте Свои Знания
Проверьте Свои Знания
Бросьте себе вызов с помощью этой интерактивной викторины и узнайте, насколько хорошо вы понимаете тему
📝 Инструкции
- Внимательно прочитайте каждый вопрос
- Выберите лучший ответ на каждый вопрос
- Вы можете пересдавать тест столько раз, сколько захотите
- Ваш прогресс будет показан вверху