Существует три основные особенности объектно-ориентированного: инкапсуляция, наследование и полиморфизм. С определенной точки зрения инкапсуляция и наследство практически все приготовлены для полиморфизма. Это наша последняя концепция и самая важная точка знания.
1. Определение:
Полиморфизм: относится к разрешению объектов разных типов отвечать на одно и то же сообщение. То есть одно и то же сообщение может принять различные различные поведения в соответствии с различными отправленными объектами. (Отправка сообщения - это вызов функции)
2. Технология для реализации полиморфизма называется: динамическое обязательство, которое относится к оценке фактического типа указанного объекта во время выполнения и вызовом его соответствующего метода в соответствии с его фактическим типом.
3. Функция: устраните взаимосвязь связи между типами.
4. В действительности есть бесчисленные примеры полиморфизма. Например, нажатие клавиши F1, если документ справки AS3 в настоящее время появляется под интерфейсом Flash; Если слово справка в настоящее время появляется под словом; Если справка Windows в настоящее время появляется под помощью и поддержки Windows. То же самое событие происходит на разных объектах и дает разные результаты.
5. Ниже приведены три необходимые условия для полиморфного существования, которые требуют, чтобы все запомнили его во сне!
Три необходимые условия для полиморфизма
1. Должно быть наследование;
2. Там должно быть переписывается;
3. Ссылка на родительский класс указывает на объект класса дочернего класса.
6. Преимущества полиморфизма:
1) Заместимость: полиморфизм имеет взаимозаменяемость для существующего кода. Например, полиморфизм работает на классе Circle Circle, а также работает над любой другой круговой геометрией, такой как кружок.
2) Расширенность: полиморфизм расширяется для кода. Добавление новых подклассов не влияет на работу и работу полиморфизмов существующих классов, наследования и других характеристик. На самом деле, легче получить полиморфные функции, добавляя новые подклассы. Например, на основе реализации полиморфизма конусов, полуконов и полушарий легко добавить полиморфизмы сфер.
3) Способность интерфейса: полиморфизм достигается с помощью суперклассов посредством сигнатур методов, обеспечивая общий интерфейс для подклассов, а подклассы реализуются путем улучшения или перезаписи. Как показано на рисунке 8.3. На рисунке Super Class Shape указывает два метода интерфейса, которые реализуют полиморфизм, Computearea () и ComputeVolume (). Подклассы, такие как круг и сфера, улучшают или переопределяют эти два метода границы раздела для достижения полиморфизма.
4) Гибкость: он отражает гибкие и разнообразные операции в применении и повышает эффективность использования.
5) Простота: полиморфизм упрощает процесс написания и модификации кода и модификации прикладного программного обеспечения, особенно при работе с операциями и операциями большого количества объектов, эта функция особенно заметна и важна.
Код корпуса кошек и собак
класс животный {public void eat () {System.out.println ("eat");} public void sleep () {System.out.println ("Sleep");}} Class Dog расширяет Animal {public void eat () {System.out.println ("Dog Eat Meat");} public sleep () {System.out.println ("Dog et Meat");} public sleep () {System.out.println ("Dog Eat");} public sleep () {System.out.println ("Dog et Meat"); Extends Animal {public void eat () {System.out.println ("Cat Fish");} public void sleep () {System.out.println ("Кошка спит на животе");}} Классная свинья расширяет животное {public void eat () {System.out.println ("Pig Eats Eats"); {PUSTER SODE (PAODE.OUT. спит на своей стороне ");}} // Класс инструментов для операций животных класс AnimalTool {private Animaltool () {}/* // Вызовая функцию Cat Public Static void usecat (cat c) {c.eat (); C.Selep (); } // Вызов функции собаки Public static void useOg (dog d) {d.eat (); D.Selep (); } // Вызов функции свиньи public static void usepig (pig p) {p.eat (); P.Ssleep (); } */public static void useanimal (животное a) {a.eat (); a.sleep ();} // класс всех возможностей в животных} класс duotaidemo2 {public static void main (string [] args) {// Мне нравятся кошки, так что у меня есть кошка C = новая кошка (). Cat (); c2.eat (); c2.sleep (); // мне нравятся кошки, в частности, и у меня есть другая кошка C3 = новая кошка (); c3.eat (); c3.sleep (); // ... system.out.println («---------------------------------------»); // Проблема в том, что я поднял множество кошек, и это приемлемые, чтобы создавать объект // но в том, что? Но в том, что? Но в том, что? Вызывая метод, вы не думаете, что он очень похож? Просто имена объектов разные. // Мы планируем использовать методы для улучшения // Вызывая метод для улучшения версии // usecat (c); // usecat (c2); // usecat (c3); // Animaltool.usecat (c); // Animaltool.usecat (c2); // Animaltool.usecat (c2); // Animaltool.usecat ( C3); Animaltool.useanimal (C2); Animaltool.useanimal (C2); Animaltool.useanimal (c3); System.out.println ("----------------------------"); // i как собака Dog D = New Dog (); собака D2 = новая собака (); собака D3 = новый Dog (); // Animaltool.usedog (d); // Animaltool.usedog (D2); // Animaltool.usedog (D3); Animaltool.useanimal (d); Animaltool.useanimal (D2); Animaltool.useanimal ( d2);AnimalTool.useAnimal(d3);System.out.println("-------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Pig();//AnimalTool.usePig(p);//AnimalTool.usePig(p2);//AnimalTool.usePig(p3);AnimalTool.useAnimal(p2);AnimalTool.useAnimal(p2);AnimalTool.useAnimal(p3);System.out.println("-------------------------------");//I like pet wolf, tiger, Leopard ... // Определите соответствующий класс, наследуйте животное, переписывайте соответствующие методы, и мне нужно записано, у меня нет возражений // Однако класс инструментов меняется каждый раз, не волнуйтесь //. public static usecat (cat c) {c.eat ();7. Метод реализации полиморфизма в Java: реализация интерфейса, унаследование родительского класса для переписывания метода и методов перегрузки в том же классе.
8. Классификация полиморфизмов в Java:
На Java полиморфизмы могут быть примерно разделены на следующие ситуации:
1) Человек - это родительский класс, а студент - это урок ребенка. Тогда: personp = newStudent ();
2) Lalible - это интерфейс, а птица - это класс, который реализует интерфейс, так: Flailff = newbird ();
3) Lalible - это абстрактный класс, птица - это класс, который наследует, так: Flailff = newbird ();
При полиморфизме необходимо заявить, что P объявляет как ссылка на родительский класс, но на самом деле это ссылка на детский класс. Но он может назвать только методы в родительском классе. Если метод в подклассе переопределяет метод родительского класса, будет вызван метод родительского класса (вызов виртуального метода). То же самое относится и к полиморфизму интерфейса. Может быть, вы спросите, хочет ли F назвать свой собственный метод, разве это не ошибся? Фактически, это также охват метода, потому что подкласс, реализующий интерфейс, обязательно реализует методы в интерфейсе, поэтому в этом случае метод в птице называется. Но если у Bird есть метод, который не определен в интерфейсе, то F не может быть вызван.
9. INSTANCE OPERATOR:
Полиморфный механизм языка Java приводит к тому, что тип объявления контрольной переменной не соответствует типу фактического эталонного объекта. В сочетании с правилами вызова виртуального метода мы можем сделать вывод, что две эталонные переменные, объявленные как один и тот же тип, также могут иметь различное поведение при вызове одного и того же метода. Оператор экземпляра представлен здесь.
Так что, если я объявляю персонн = newStudent (); Могу ли я преобразовать P в студент? Конечно, это можно сделать, но это должно быть вынуждено (сын хочет быть отцом, и он придет напрямую, но если отец захочет стать сыном, он будет вынужден).
Обычно при кастинге добавляется экземпляр.
if (pinstanceofstudent) {студенты = (студент) p;}
Полиморфизм проходит через все обучение Java. Например, при написании операторов по выводу при обработке исключений мы предусматриваем, что исключения подкласса должны быть записаны в переднем, и исключения для родительского класса должны быть записаны сзади. Почему? Причина в полиморфизме. Наш формат оператора Catch: Catch (Exceptione). Когда генерируется исключение, программа Java автоматически генерирует объект исключения. Если первое исключение в классе дочернего класса создается, а исключение родительского класса написано впереди, это оператор Catch определенно будет выполнена в соответствии с полиморфизмом, и оно выпрыгнет после выполнения оператора Catch.
10. Пример:
Хотя я не очень хорошо понимаю полиморфизм Java, следующий пример заставляет меня понять:
Класс A {public String show (d obj) .. {return ("a and d");} public String show (a obj) .. {return ("a and a");}} класс B расширяет {public String show (b obj) .. {return ("b и b");} public String show (obj) .. {return ("b and"); B {} class e {public static void main (string [] args) {a a1 = new a (); a a2 = new b (); b b = new b (); c = new c (); d d = new D (); System.out.println (a1.show (b)); // ①system.out.println (a1.show (c)); // ②system.out.println (a1.show (d)); //③system.out.println(a2.show(b));//④system.out.println(a2.show(c));//⑤system.out.println(a2 ⑥System.out.println (b.show (b)); // ⑦system.out.println (b.show (c)); // ⑧system.out.println (b.show (d)); // ⑨}}}}}}}}}}}}}}}}}}}(Iii) Ответ
① a и a ② a и a ③ a и d ④ b и a ⑤ b и a a и d ⑦ b и b ⑧ b и b ⑨ a и d
**** есть ответ хорошего человека ****
Есть два ключевых момента в этой проблеме:
Одним из них является взаимосвязь между подклассом и родительским классом, а другой - проблема вызова перегруженных методов.
Объекты подкласса могут использоваться непосредственно в качестве родительских объектов, но в противном случае они не могут. Например, люди являются родительским классом, а ученики являются подклассом людей, поэтому студенты -объекты должны иметь атрибуты человеческих объектов, но человеческие объекты не обязательно имеют характеристики объектов студентов. Поэтому объекты студентов могут использоваться в качестве человеческих объектов, но человеческие объекты не могут использоваться в качестве объектов студентов. Обратите внимание, что при использовании объекта подкласса в качестве родительского объекта объект подкласса потеряет все характеристики подкласса и сохраняет только атрибуты и методы с тем же именем, что и родительский класс (тот же метод имени является не только одним именем функции, но и тип параметра должен быть одинаковым, в противном случае он не будет сохранен).
Если перегруженный метод определяется в классе, система автоматически выбирает и вызовет соответствующий метод в соответствии с типом параметра при вызове метода.
1) A1.shows (b), нет метода, содержащего параметры класса B в A, но метод, содержащий параметры класса A, называется в соответствии с принципом, что родительский класс объекта подкласса доступен, поэтому метод вызывается.
publicStringshow(Aobj)...{return("AandA");}
2) A1.Show (C), класс C является подклассом класса B, а класс B является подклассом класса A, поэтому объекты класса C могут использоваться в качестве объекта класса A. Результат такой же, как и выше.
3) a1.show (d), напрямую вызовите метод в соответствии с типом параметра
publicStringshow(Dobj)...{
return("AandD");}
4) a2.show (b), A2 изначально был объектом B, но он был назначен переменной класса A, поэтому A2 сохраняет только свойства и методы с тем же именем, что и родительский класс A. A2.show (b) вызывает зарезервированный метод в классе B с тем же именем, что и родительский класс, и тот же параметр, что и родительский класс
public String show(A obj)...{
return ("B and A");
}
5) a2.show (c), зарезервированный метод класса B не имеет методов параметров класса C, но существуют методы параметров родительского класса B, который содержит C, поэтому вызываемый метод
public String show(A obj)...{
return ("B and A");
}
Я думаю, что это объяснение более разумно: A2 изначально был объектом класса B, но значение было назначено классу A, C - это подкласс B, а B - подкласс A, поэтому A2 сохраняет свойства и методы в классе B с тем же именем, что и A.
6) a2.show (d), вызов из класса A
public String show(D obj)...{
return ("A and D");
}
7) B.show (b), вызовите
public String show(B obj)...{
return ("B and B");
}
8) b.show (c), нет метода с параметром C в классе B, но есть метод с параметром B, поэтому метод вызывается
public String show(B obj)...{
return ("B and B");
}
9) B.show (d), объяснение совпадает с 8
Суммировать
Выше приведено все содержание резюме этой статьи о полиморфизме Java, и я надеюсь, что это будет полезно для всех. Если у вас есть какие -либо вопросы, пожалуйста, оставьте сообщение в любое время и с нетерпением ждем ваших ценных комментариев!