Каково различие между Полиморфизмом и Несколькими Отправка?
Другое событие NullPointerException возникает, когда объявляется массив объектов, а затем сразу же пытается разыменовать его внутри.
String[] phrases = new String[10];
String keyPhrase = "Bird";
for(String phrase : phrases) {
System.out.println(phrase.equals(keyPhrase));
}
Этот конкретный NPE можно избежать, если порядок сравнения отменяется ; а именно, использовать .equals для гарантированного непустого объекта.
Все элементы внутри массива инициализируются их общим начальным значением ; для любого типа массива объектов, это означает, что все элементы null.
Вы должны инициализировать элементы в массиве перед доступом или разыменованием их.
String[] phrases = new String[] {"The bird", "A bird", "My bird", "Bird"};
String keyPhrase = "Bird";
for(String phrase : phrases) {
System.out.println(phrase.equals(keyPhrase));
}
7 ответов
Полиморфизм является средством, которое позволяет языку/программе принимать решения во время времени выполнения на который метод вызвать на основе типов параметров, отправленных в тот метод.
количество параметров, используемых языком/временем выполнения, определяет 'тип' полиморфизма, поддерживаемого языком.
Единственная отправка является типом полиморфизма, где только один параметр используется (получатель сообщения - this, или self) для определения вызова.
Несколько диспетчеризируют, тип полиморфизма, где в нескольких параметрах используются в определении который метод звонить. В этом случае получатель, а также типы параметров метода используется для сообщения который метод вызвать.
, Таким образом, можно сказать, что полиморфизм является общим термином и несколько и единственная отправка - определенные типы полиморфизма.
Приложение: Перегрузка происходит в течение времени компиляции. Это использует информацию о типе, доступную во время компиляции для определения который тип метода звонить. Единственная/несколько отправка происходит во время времени выполнения.
Пример кода:
using NUnit.Framework;
namespace SanityCheck.UnitTests.StackOverflow
{
[TestFixture]
public class DispatchTypes
{
[Test]
public void Polymorphism()
{
Baz baz = new Baz();
Foo foo = new Foo();
// overloading - parameter type is known during compile time
Assert.AreEqual("zap object", baz.Zap("hello"));
Assert.AreEqual("zap foo", baz.Zap(foo));
// virtual call - single dispatch. Baz is used.
Zapper zapper = baz;
Assert.AreEqual("zap object", zapper.Zap("hello"));
Assert.AreEqual("zap foo", zapper.Zap(foo));
// C# has doesn't support multiple dispatch so it doesn't
// know that oFoo is actually of type Foo.
//
// In languages with multiple dispatch, the type of oFoo will
// also be used in runtime so Baz.Zap(Foo) will be called
// instead of Baz.Zap(object)
object oFoo = foo;
Assert.AreEqual("zap object", zapper.Zap(oFoo));
}
public class Zapper
{
public virtual string Zap(object o) { return "generic zapper" ; }
public virtual string Zap(Foo f) { return "generic zapper"; }
}
public class Baz : Zapper
{
public override string Zap(object o) { return "zap object"; }
public override string Zap(Foo f) { return "zap foo"; }
}
public class Foo { }
}
}
С несколькими диспетчеризируют, метод может иметь несколько аргументов, переданных ему и какая реализация используется, зависит от типа каждого аргумента. Порядок, что типы оценены, зависит от языка. В LISP это проверяет каждый тип от начала до конца. Языки с несколькими диспетчеризируют, используют родовые функции, которые являются просто объявлениями функции и не похожи на общие методы, которые используют параметры типа.
Несколько диспетчеризируют, позволяет выделять подтипы в полиморфизме из аргументов в пользу вызовов метода.
Единственная отправка также допускает более ограниченный вид полиморфизма (использующий то же имя метода для объектов, которые реализуют тот же интерфейс или наследовали тот же базовый класс). Это - классический пример полиморфизма, где у Вас есть методы, которые переопределяются в подклассах.
Кроме того, дженерики обеспечивают параметрический полиморфизм типа (т.е. тот же универсальный интерфейс для использования с различными типами, даже если они не связаны — как List<T>: это может быть списком любого типа и используется тот же путь независимо).
Я никогда не слышал о Нескольких Отправку прежде, но после поглядывания на страницу Wikipedia она много походит на MD, тип полиморфизма, когда используется с аргументами методу.
Полиморфизм является по существу понятием, что объект может рассматриваться как любой тип, который является, это - основа. Таким образом, если Вы имеете Car и Truck, они могут оба рассматриваться как Vehicle. Это означает, что можно назвать любой Vehicle метод для любого.
Несколько подобных взглядов отправки, в котором это позволяет Вам назвать методы с аргументами нескольких типов, однако я не вижу определенных требований в описании. Во-первых, это, кажется, не требует типа общей базы (не, что я мог предположить реализовывать ЭТО без void*), и у Вас может быть несколько включенных объектов.
Так вместо того, чтобы звонить Start() метод на каждом объекте в списке (который является классическим примером полиморфизма), можно назвать StartObject(Object C) метод определенный в другом месте и кодировать его, чтобы проверить тип аргумента во время выполнения и обработать его соответственно. Различие здесь - то, что Start() метод должен быть встроен в класс, в то время как StartObject() метод может быть определен за пределами класса, таким образом, различные объекты не должны соответствовать интерфейсу.
Это могло быть хорошо, если бы Start() метод нужно было назвать с различными аргументами. Возможно Car.Start(Key carKey) по сравнению с [1 111]
, Но обоих можно было назвать как [1 112] или StartObject(theMissile)
Интересное понятие...
Несколько Отправка более сродни перегрузке функции (как замечено в Java/C++), кроме вызванной функции, зависят от типа выполнения аргументов, не их статического типа.
если Вы хотите, чтобы концептуальный эквивалент вызова метода
(obj_1, obj_2, ..., obj_n)->method
зависел от каждого определенного типа в кортеже, то Вы хотите, несколько диспетчеризируют. Полиморфизм соответствует случаю n=1 и является необходимой функцией ООП.
Несколько Отправка являются своего рода полиморфизмом. В Java/C#/C ++, существует полиморфизм посредством наследования и переопределения, но это не, несколько диспетчеризируют, который основан на двух или больше аргументах (не всего this, как в Java/C#/C ++)
Несколько Отправка полагаются на базирующийся полиморфизм. Типичный полиморфизм, с которым встречаются в C++, C#, VB.NET, и т.д.... использует единственную отправку - т.е. функция, которая вызвана, только зависит от экземпляра единого класса. Несколько диспетчеризируют, полагается на несколько экземпляров класса.