Разработка: Перегрузка метода - это статическая привязка во время компиляции, но не полиморфизм. Правильно ли соотносить статическое связывание с полиморфизмом?

Question

Прежде чем я задам свой вопрос, позвольте мне объяснить свое понимание и мнение.

У меня есть возражения, чтобы вызвать перегрузку метода как полиморфизм времени компиляции.
Я согласен, что перегрузка метода является статическим связыванием (время компиляции), но я не видел в этом полиморфизма.

Согласно Javadoc есть только полиморфизм
Нет времени компиляции или полиморфизма во время выполнения.

Согласно Javadoc в разделе " Определение методов" объясняется перегрузка методов. Но нет никаких строк, это говорит, что это полиморфизм времени компиляции.

По мне:
Если вы поместите полиморфизм в категорию полиморфизма времени выполнения
Полиморфизм времени компиляции вы можете увидеть только при изменении версии JDK.

If you switch from JDK version higher to lower you will start seeing compilation errors.
Same code behaving differently during compilation time, 
eg: lambda expression, diamond operator, string in switch case, generics etc

Позвольте мне высказать свое мнение, мой прогноз о том, как полиморфизм во время выполнения и полиморфизм во время компиляции пришли к блогам / учебным пособиям.

    Conversation1

Разработчик 1: Привет, я читал о полиморфизме сегодня. Если вы делаете кодирование для интерфейса, вы можете достичь полиморфизма. написание кодов, не тесно связанных с классом, но вместо этого записывающих их в интерфейс путем создания слабой связи, вызова метода суперкласса или метода интерфейса фактически вызывает метод подкласса в зависимости от переданного экземпляра.
Разработчик 2: Извините, я вас не понял.
Разработчик 1: Во время выполнения просто, какой экземпляр объекта вы передадите, этот метод экземпляра будет выполнен.
Разработчик 2: Ооо! Время выполнения Я понял.
Разработчик 1: Да, тот же кусок кода, но во время выполнения переданные экземпляры отличаются.
Разработчик 2: Run Time!!! оооооо понял

    Conversation2

Разработчик 2: Привет, вчера я встретил Developer1 вчера, он рассказывал о каком- то полиморфизме во время выполнения. Переопределив методы в подклассе, мы можем достичь этого.
Разработчик 3: Запустить полиморфизм времени путем переопределения методов?
Тогда что такое oveloading? полиморфизм времени компиляции?
Разработчик 2: Как вы говорите, перегрузка как полиморфизм времени компиляции?
Разработчик 3: Потому что это решается только во время компиляции.
Разработчик 2: Silent!!!

Полиморфизм и кодирование для наилучшего примера интерфейса - java.sql

    java.sql.Connection conn = DriverManager.getConnection(DB_URL,USER,PASS);
    java.sql.Statement stmt = conn.createStatement();
    java.sql.ResultSet rs = stmt.executeQuery(sql);

Один и тот же фрагмент кода ведет себя по-разному в зависимости от зарегистрированного драйвера.
Это означает, что если мы зарегистрируем Mysql Driver, из-за полиморфизма этот код выполняет методы экземпляров mysql. т.е. выполняет переопределенные методы. Если вы зарегистрируете драйвер Oracle, он работает для оракула....

Выше мы обнаружили, что один и тот же код ведет себя по-разному.

Теперь кто-нибудь может показать мне один и тот же код, ведущий себя по-разному во время компиляции. Или другими словами покажи мне add(3,4) метод, ограниченный различными методами (другими сигнатурными методами) во время компиляции

По словам Javadoc

Язык программирования Java поддерживает методы перегрузки, и Java может различать методы с разными сигнатурами методов.

Метод будет выполнен в зависимости от соответствия подписи. Наличие одного и того же имени для методов не означает, что существует полиморфизм, потому что сигнатура вызывающих методов отличается
Que1: Если вы не измените сигнатуру вызывающего метода, вызовет ли он другой метод, отличный от метода, для которого совпадает сигнатура?
В каких условиях он будет вести себя иначе?

Давайте посмотрим на метод перегрузки:

    public void add(int a, int b)
    {
        System.out.println(a+b);
    }

    public void add(int a, int b, int c)
    {
        System.out.println(a+b+c);
    }

    public static void main(String[] args)
    {
        add(3,4);
        add(3,4,5);
    }

Какой кусок кода ведет себя по-разному?? Где здесь полиморфизм??

Вопрос 2: Согласны ли вы с моим предложением о новом типе полиморфизма времени компиляции?

class SuperClass
{
    void test1() {}
}

class MiddleClass extends SuperClass
{
    void test2() {}
}

class LowerClass extends MiddleClass
{
    void test3() {}
}

public class Test
{
    public static void main(String[] args)
    {
        LowerClass lc = new LowerClass();
        lc.test1();
        lc.test2();
        lc.test3();

        MiddleClass mc = (MiddleClass) lc;
        mc.test1();
        mc.test2();
        mc.test3(); //compilation error

        SuperClass sc = (SuperClass) mc;
        sc.test1();
        sc.test2(); //compilation error
        sc.test3(); //compilation error
    }
}

Здесь экземпляр LoweClass сначала говорит, что у меня есть методы test1(),test2() и test3()
После обновления до MiddleClass он говорит, что у меня нет test3()
После обновления до суперкласса он говорит, что у меня нет test3(),test2()

Так как он ведет себя по-разному, как он транслируется в суперкласс, один и тот же экземпляр ведет себя по-разному, разве это не полиморфизм времени компиляции?

Пожалуйста, объясните мне, если что-то не так.

Спасибо

Answer 1

Люди говорят

1. переопределение - это полиморфизм времени выполнения и
2. перегрузка - это полиморфизм времени компиляции.
   

Оба ошибаются.
Только переопределение не является полиморфизмом. Но переопределение помогает достичь пломорфизма. Если нет апкастинга, вы не сможете достичь плойморфизма.

Перегрузка - это концепция, в которой имя метода вместе с сигнатурой аргумента используются для привязки вызова метода к телу метода, и это можно предсказать только во время компиляции. Но это нигде не связано с полиморфизмом. В случае перегрузки метода НИКАКОГО изменения поведения не происходит. Либо вы компилируете сегодня, либо компилируете через год, изменение поведения можно найти только в том случае, если вы измените подпись метода вызова, то есть только если вы измените код, скажемadd(3,4); к add(3,4,5);и, следовательно, перегрузка метода не является полиморфизмом.

Answer 2

В мире Java полиморфизм означает полиморфизм между классами. Т.е. ссылаясь на возможно несколько дочерних классов с их общим родителем. В Java нет полиморфизма между методами.

void add(int a, int b) а также void add(int a, int b, int c)- это совершенно разные методы в синтаксисе Java. Так не должно быть - например, в C++ вы можете преобразовывать их друг в друга, - но в Java это так.

Ключевым понятием для понимания здесь является подпись метода. Сигнатура метода определяет на языке, что идентифицирует индивидуальные методы. (Например, рядом сvoid add(int a, int b);, вы просто не можете объявить int add(int a, int b); method - возвращаемое значение не является частью сигнатуры метода в Java, поэтому компилятор интерпретировал бы его как переопределение метода.)