1. В объявлении класса используйте ключевое слово расширяется для создания подкласса класса. Класс объявляет, что он использует один или несколько интерфейсов с помощью ключевого словаimplements.
Расширение означает наследование определенного класса. После наследования вы можете использовать методы родительского класса или переопределить методы родительского класса. Реализация означает реализацию нескольких интерфейсов. Методы интерфейса обычно пусты и должны быть переписаны, прежде чем их можно будет использовать. использовал.
2. Расширения наследуют родительский класс, пока класс не объявлен как окончательный или класс не определен как абстрактный, JAVA не поддерживает множественное наследование, но в этом случае его можно реализовать с помощью интерфейсов. Необходимо использовать инструменты. Наследование может наследовать только класс, но инструменты могут реализовывать несколько интерфейсов, просто разделите их запятыми. Например.
Скопируйте код кода следующим образом:
класс A расширяет B, реализует C,D,E
После долгого изучения сегодня я наконец понял реализацию. На самом деле это очень просто. Просто посмотрите на следующие примеры~~.
Некоторые концепции интерфейсов
<!--[if !supportLineBreakNewLine]-->
Скопируйте код кода следующим образом:
общественный внутренний бегун
{
интервал ID = 1;
недействительный запуск ();
}
интерфейс Animal расширяет Runner
{
недействительный вдох ();
}
класс Fish реализует Animal
{
публичный недействительный запуск()
{
System.out.println("рыба плывёт");
}
публичная передышка пустоты()
{
System.out.println("рыба пузырится");
}
}
абстракция LandAnimal реализует Animal
{
публичная пустота ()
{
System.out.println("LandAnimal дышит");
}
}
класс Student расширяет Person реализует Runner
{
...
публичный недействительный запуск()
{
System.out.println("ученик бежит");
}
...
}
интерфейс флаер
{
пустота летать ();
}
класс Bird реализует Runner, Flyer
{
публичный недействительный запуск()
{
System.out.println("птица бежит");
}
публичная пустота летать()
{
System.out.println("птица летит");
}
}
класс TestFish
{
public static void main (String args[])
{
Рыба f = новая рыба();
интервал j = 0;
j = Идентификатор бегуна;
j = f.ID;
}
}
Примечания по реализации интерфейса:
а. Реализовать интерфейс — значит реализовать все методы интерфейса (кроме абстрактных классов).
б. Методы интерфейса абстрактны.
в. Несколько несвязанных классов могут реализовывать один и тот же интерфейс, а один класс может реализовывать несколько несвязанных интерфейсов.
=============================================== =========
Разница между расширяет и реализует
Extends — это наследование родительского класса. Пока класс не объявлен как окончательный или класс не определен как абстрактный, JAVA не поддерживает множественное наследование, но в этом случае его можно реализовать с помощью интерфейсов. необходимо использовать инструменты. Наследование может наследовать только один класс, но инструменты могут реализовывать несколько интерфейсов, просто разделите их запятыми.
класс A расширяет B, реализует C,D,E
Класс объявляет, что он использует один или несколько интерфейсов с помощью ключевого словаimplements. В объявлении класса создайте подкласс класса с помощью ключевого слова Extensions.
Скопируйте код кода следующим образом:
имя подкласса класса расширяет имя родительского класса реализует имя интерфейса
{...
}
=============================================== =========
A a = new B(); В результате a является экземпляром класса A и может обращаться только к методам в A. Так в чем же разница между A a = new A();?
=============================================== ========
класс B расширяет A
После наследования обычно определяются некоторые члены или методы, которых нет в родительском классе.
А = новый B();
Это нормально, загрузите.
a является экземпляром объекта родительского класса и поэтому не может получить доступ к новым членам или методам, определенным подклассом.
=============================================== ========
Если определить так:
класс А {
интервал я;
недействительный f(){}
}
класс B расширяет A{
интервал j;
void f(){}//Переписать
недействительный г () {}
}
Затем:
B b = новый B();
b является экземпляром объекта подкласса. Он может иметь доступ не только к своим собственным свойствам и методам, но также к свойствам и методам родительского класса. Такие вещи, как bi, bj, bf(), bg(), являются законными. В это время bf() — это f() в B, к которому осуществляется доступ.
А = новый B();
Хотя a использует конструктор B, после преобразования он становится экземпляром объекта родительского класса и не может получить доступ к свойствам и методам подкласса. ai,af() допустимы, но aj,ag() незаконны. В настоящее время доступ к af() означает доступ к f() в B.
=============================================== ========
A a = new B(); На самом деле этот оператор имеет три процесса:
(1) А а;
Объявите объект родительского класса, который является просто ссылкой и пространство не выделяется.
(2) B temp = новый B();
Экземпляр объекта класса B устанавливается через конструктор класса B, то есть инициализируется
(3) а = (А) темп;
Преобразуйте временный объект подкласса в неродительский объект класса и назначьте его a. Это безопасная загрузка (upcast).
После трех вышеуказанных процессов объект a полностью стал экземпляром класса A.
Подклассы часто имеют больше свойств и методов, чем родительские классы. При загрузке они только отбрасываются, что безопасно, тогда как понижение иногда увеличивает их, что обычно небезопасно.
=============================================== =========
af() должен соответствовать методу f() класса B.
После вызова конструктора для создания экземпляра определяется вход в соответствующий метод.
С тех пор, хотя a был загружен как класс A, переопределенный метод f() по-прежнему остается методом f() класса B. То есть каждый объект знает, какой метод ему следует вызвать.
А a1 = новый B();
A a2 = новый C();
Хотя a1 и a2 являются объектами класса A, их соответствующие функции f() различны. Это именно то воплощение полиморфизма, о котором говорилось на первом этаже.
Такие вопросы очень ясно объяснены в «Мыслях о программировании на Java».
Реализация обычно реализует интерфейс. расширяет является унаследованным классом. Интерфейсы обычно имеют только объявления методов, но не имеют определений, поэтому для Java имеет смысл специально указать реализацию интерфейсов, поскольку наследование означает, что родительский класс реализовал методы, а интерфейсы не реализуют свои собственные методы, а только объявления, то есть Заголовок метода не имеет тела метода. Таким образом, вы можете понять, что интерфейс — это подкласс, который реализует объявления своих методов, а не наследует их. Но общие методы класса могут иметь тела методов, поэтому разумнее называть их наследованием. Импортируя пакет, можно использовать все реализованные классы, которые не являются в нем интерфейсами. Затем вы решаете, реализовывать интерфейс или нет. Если вы хотите его использовать, вы не можете вызвать интерфейс без его реализации, поскольку интерфейс представляет собой спецификацию, набор объявлений методов без тела метода. Позвольте мне привести вам пример: интерфейс можно сравнить с протоколом. Например, если я говорю, что протокол «убивает», то вы можете использовать мачете для реализации этого интерфейса. Что касается того, как убить, мачете может реализовать. Конечно, вы также можете использовать захват для реализации интерфейса убийства, но вы не можете использовать интерфейс убийства для убийства людей, потому что интерфейс убийства — это просто описание функции, а то, как это сделать, зависит от класса его реализации. . Поэтому, если в пакете есть интерфейс, вам не обязательно его реализовывать. Это не влияет на использование вами других классов.
реализует
«реализует» — это ключевое слово, используемое классом для реализации интерфейса. Оно используется для реализации абстрактных методов, определенных в интерфейсе. Например: люди — это интерфейс, в котором есть метод Say. открытый интерфейс люди() {общественный говорят();} Но у интерфейса нет тела метода. Тело метода может быть реализовано только через определенный класс. Например, класс Chinese реализует интерфейс людей. китайский публичный класс реализует людей { publicsay() {System.out.println("Привет!");}}
В Java реализация означает, что подкласс наследует родительский класс. Например, класс A наследует класс B и записывается как класс A реализует B{}.
Отличие от расширений
расширяется, вы можете реализовать родительский класс или вызвать родительский класс для инициализации this.parent(). И он перезапишет переменные или функции, определенные родительским классом. Преимущество этого в том, что архитектор может определить интерфейс и позволить инженеру реализовать его. Вся эффективность разработки проекта и затраты на разработку значительно снижаются.
реализует, реализует родительский класс, а подклассы не могут переопределять методы или переменные родительского класса. Даже если подкласс определяет те же переменные или функции, что и родительский класс, они будут заменены родительским классом.
Конкретное использование этих двух реализаций зависит от фактической ситуации в проекте и должно быть реализовано. Реализации не могут быть изменены. Необходимо конкретно реализовать только определенный интерфейс, или его можно изменить для обеспечения хорошей масштабируемости.
<!--[конец]-->