Блог

Я готовлюсь к выпускному экзамену по курсу сравнительных языков, и профессор устроил нам старый экзамен, чтобы мы почувствовали, что это такое на самом деле. Один вопрос, который я не понимаю, заключается в следующем:

«Наследование перегруженных методов в Java и C отличается фундаментальным образом. Наглядно покажите разницу в двух используемых подходах и аргументируйте, почему дизайнерское решение Java предпочтительнее.»

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

Я бы попросил лектора привести пример иерархии наследования, который демонстрирует «наследование перегруженных методов». Я бы предположил, что в C это означает что-то вроде следующего:

 struct A1 { };
struct A2 { };

struct B1 {
    virtual void f(A1*) = 0;
};

struct B2 {
    virtual void f(A2*) = 0;
};

struct D : B1, B2 { };

void f(Damp; d)
{
    A1 a1;
    A2 a2;
    d.f(amp;a1);
    d.f(amp;a2);
}
  

И следующее в Java (моя Java немного грубовата, поэтому я надеюсь, что я понял это примерно правильно):

 class M {
    class A1 { };
    class A2 { };

    interface B1 {
        void f(A1 a1);
    };
    interface B2 {
        void f(A2 a2);
    };

    abstract class D implements B1, B2 {
    }; 

    void f(D d)
    {
        A1 a1 = new A1();
        A2 a2 = new A2();
        d.f(a1);
        d.f(a2);
    }
};
  

Обратите внимание, что разница здесь в том, что код C не будет компилироваться, потому что f() неоднозначен. Тогда как код Java будет компилироваться. Если это то, о чем они говорят, вы могли бы возразить, что Java делает то, чего ожидает программист, тогда как C , вероятно, удивит программиста. Одна важная вещь, которую я узнал в университете, заключается в том, что прохождение курсов по программированию в университете иногда означает ответы на вопросы так, как от вас ожидает эксперт, в первую очередь и правильно во вторую.

кажется, что в большинстве ответов здесь говорится о наследовании и «Переопределении» метода в C / Java.

Однако ключевое слово в вопросе заставляет меня думать, что на самом деле он спрашивает о другом: «Наследование перегруженных методов»

Есть одно фундаментальное отличие, если я правильно помню, о наследовании перегрузке метода:

В C , если вы перегружаете метод в дочернем классе, который объявлен в родительском классе, это вызовет затенение метода. Это может вызвать некоторые удивления в вашем дизайне, если вы не знаете об этом. Если я правильно помню, если в родительском классе есть 2 метода перегрузки, а в дочернем классе вы переопределяете один из них, это все равно вызовет затенение.

Однако в Java все в порядке.

Если это действительно то, о чем спрашивается, то, честно говоря, способ Java предпочтительнее, потому что перегрузка метода не должна мешать наследованию и переопределению метода. И такое затенение вызывает многие проблемы проектирования, например, вы не сможете получить доступ к методу родительского класса напрямую в сценарии «перегрузка наследование затенение».

Наследование перегруженных методов в Java и C отличается фундаментальным образом.

1. В Java, когда базовый class метод переопределяется производным class , они оба связаны полиморфным образом по умолчанию. В C вы должны создать base метод как virtual
2. В Java вы можете остановить переопределение метода, создав его final . В текущем C это недоступно

аргументируйте, почему дизайнерское решение Java предпочтительнее.

Это спорно. Java применяет единый способ проектирования, который помогает программистам лучше / быстрее понимать код. Также уменьшает путаницу и использование языковых возможностей.

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