Реализует vs extends: Когда использовать? Какая разница?

Пожалуйста, объясните в удобном для понимания языке или ссылке на какую-либо статью.

ОТВЕТЫ

Ответ 1

extends для расширения класса.

implements для реализации интерфейса

Разница между интерфейсом и обычным классом заключается в том, что в интерфейсе нельзя реализовать ни один из объявленных методов. Только класс, который "реализует" интерфейс, может реализовать методы. C++ эквивалент интерфейса будет абстрактным классом (не ТОЧНО таким же, но в значительной степени).

Также Java не поддерживает множественное наследование для классов. Это решается с помощью нескольких интерфейсов.

 public interface ExampleInterface {
    public void doAction();
    public String doThis(int number);
 }

 public class sub implements ExampleInterface {
     public void doAction() {
       //specify what must happen
     }

     public String doThis(int number) {
       //specfiy what must happen
     }
 }

сейчас расширяю класс

 public class SuperClass {
    public int getNb() {
         //specify what must happen
        return 1;
     }

     public int getNb2() {
         //specify what must happen
        return 2;
     }
 }

 public class SubClass extends SuperClass {
      //you can override the implementation
      @Override
      public int getNb2() {
        return 3;
     }
 }

в этом случае

  Subclass s = new SubClass();
  s.getNb(); //returns 1
  s.getNb2(); //returns 3

  SuperClass sup = new SuperClass();
  sup.getNb(); //returns 1
  sup.getNb2(); //returns 2

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

Ответ 2

Я заметил, что у вас есть некоторые вопросы на С++ в вашем профиле. Если вы понимаете концепцию множественного наследования из С++ (ссылаясь на классы, которые наследуют характеристики из более чем одного другого класса), Java не позволяет этого, но имеет ключевое слово interface, которое похоже на чистый виртуальный класс в С++. Как упоминалось многими людьми, вы extend класс (и вы можете только расширять его), а вы implement интерфейс, но ваш класс может реализовать столько интерфейсов, сколько захотите.

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

Ответ 3

extends - это когда вы наследуете базовый класс (т.е. расширяете его функциональность).

implements предназначен для реализации интерфейса.

Вот хорошее место для начала: Интерфейсы и наследование.

Ответ 4

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

extends: производный класс может распространять базовый класс. Вы можете переопределить поведение установленного отношения. Тип производного класса -

реализует: вы выполняете контракт. Класс, реализующий интерфейс ", имеет".

С выпуском java 8 интерфейс может иметь методы по умолчанию в интерфейсе, который обеспечивает реализацию в самом интерфейсе.

Обратитесь к этому вопросу за тем, когда использовать каждый из них:

Интерфейс против абстрактного класса (общий OO)

Пример для понимания вещей.

public class ExtendsAndImplementsDemo{
    public static void main(String args[]){

        Dog dog = new Dog("Tiger",16);
        Cat cat = new Cat("July",20);

        System.out.println("Dog:"+dog);
        System.out.println("Cat:"+cat);

        dog.remember();
        dog.protectOwner();
        Learn dl = dog;
        dl.learn();

        cat.remember();
        cat.protectOwner();

        Climb c = cat;
        c.climb();

        Man man = new Man("Ravindra",40);
        System.out.println(man);

        Climb cm = man;
        cm.climb();
        Think t = man;
        t.think();
        Learn l = man;
        l.learn();
        Apply a = man;
        a.apply();

    }
}

abstract class Animal{
    String name;
    int lifeExpentency;
    public Animal(String name,int lifeExpentency ){
        this.name = name;
        this.lifeExpentency=lifeExpentency;
    }
    public void remember(){
        System.out.println("Define your own remember");
    }
    public void protectOwner(){
        System.out.println("Define your own protectOwner");
    }

    public String toString(){
        return this.getClass().getSimpleName()+":"+name+":"+lifeExpentency;
    }
}
class Dog extends Animal implements Learn{

    public Dog(String name,int age){
        super(name,age);
    }
    public void remember(){
        System.out.println(this.getClass().getSimpleName()+" can remember for 5 minutes");
    }
    public void protectOwner(){
        System.out.println(this.getClass().getSimpleName()+ " will protect owner");
    }
    public void learn(){
        System.out.println(this.getClass().getSimpleName()+ " can learn:");
    }
}
class Cat extends Animal implements Climb {
    public Cat(String name,int age){
        super(name,age);
    }
    public void remember(){
        System.out.println(this.getClass().getSimpleName() + " can remember for 16 hours");
    }
    public void protectOwner(){
        System.out.println(this.getClass().getSimpleName()+ " won't protect owner");
    }
    public void climb(){
        System.out.println(this.getClass().getSimpleName()+ " can climb");
    }
}
interface Climb{
    public void climb();
}
interface Think {
    public void think();
}

interface Learn {
    public void learn();
}
interface Apply{
    public void apply();
}

class Man implements Think,Learn,Apply,Climb{
    String name;
    int age;

    public Man(String name,int age){
        this.name = name;
        this.age = age;
    }
    public void think(){
        System.out.println("I can think:"+this.getClass().getSimpleName());
    }
    public void learn(){
        System.out.println("I can learn:"+this.getClass().getSimpleName());
    }
    public void apply(){
        System.out.println("I can apply:"+this.getClass().getSimpleName());
    }
    public void climb(){
        System.out.println("I can climb:"+this.getClass().getSimpleName());
    }
    public String toString(){
        return "Man :"+name+":Age:"+age;
    }
}

выход:

Dog:Dog:Tiger:16
Cat:Cat:July:20
Dog can remember for 5 minutes
Dog will protect owner
Dog can learn:
Cat can remember for 16 hours
Cat won't protect owner
Cat can climb
Man :Ravindra:Age:40
I can climb:Man
I can think:Man
I can learn:Man
I can apply:Man

Важные моменты для понимания:

  • Собаки и кошки - животные, и они расширили remember() и protectOwner(), разделив name,lifeExpentency с Animal
  • Кошка может подняться(), но собака этого не делает. Собака может думать(), но Кота нет. Эти специфические возможности добавляются к Cat и Dog, реализуя эту возможность.
  • Человек не животное, но он может Think,Learn,Apply,Climb

Просматривая эти примеры, вы можете понять, что

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

Ответ 5

A class может только "реализовать" interface. Класс только "расширяет" a class. Аналогично, interface может расширять еще один interface.

A class может распространять только один class. A class может реализовать несколько interface s.

Если вам больше интересно узнать, когда использовать abstract class es и interface s, обратитесь к этому потоку: Интерфейс против абстрактного класса (общий OO)

Ответ 6

Интерфейс - это описание действий, которые может выполнять объект... например, когда вы нажимаете на выключатель света, свет включается, вам все равно, как, просто так и происходит. В объектно-ориентированном программировании интерфейс - это описание всех функций, которые должен иметь объект, чтобы быть "Х". Опять же, в качестве примера, все, что "ACTS LIKE" источник света, должно иметь метод turn_on() и метод turn_off(). Назначение интерфейсов состоит в том, чтобы позволить компьютеру применять эти свойства и знать, что объект типа T (независимо от интерфейса) должен иметь функции с именами X, Y, Z и т.д.

Интерфейс - это структура/синтаксис программирования, которая позволяет компьютеру применять определенные свойства к объекту (классу). Например, скажем, у нас есть класс автомобилей, класс скутеров и класс грузовиков. Каждый из этих трех классов должен иметь действие start_engine(). Способ запуска двигателя для каждого транспортного средства остается за каждым конкретным классом, но тот факт, что они должны иметь действие start_engine, является областью интерфейса.

Ответ 7

Как показано на рисунке, приведенном ниже, класс расширяет другой класс, интерфейс расширяет другой интерфейс, но класс реализует интерфейс. enter image description here

Для более подробной информации

Ответ 8

  • A продолжается B:

    A и B - оба класса или оба интерфейса.

  • A реализует B

    A - класс, а B - интерфейс

  • Оставшийся случай, когда A является интерфейсом, а B - класс, не является законным в Java.

Ответ 9

Расширяет. Используется для получения атрибутов родительского класса в базовый класс и может содержать уже определенные методы, которые могут быть переопределены в дочернем классе.

Реализует. Это используется для реализации интерфейса (родительский класс с сигнатурами функций, но не их определениями), определяя его в дочернем классе.

Существует одно особое условие: "Что, если я хочу, чтобы новый интерфейс был дочерним элементом существующего интерфейса?". В вышеприведенном условии дочерний интерфейс расширяет родительский интерфейс.

Ответ 10

Реализации используются для интерфейсов, а extends используется для расширения класса.

Чтобы сделать его более понятным в простых терминах, интерфейс похож на звук - интерфейс - модель, которую вам нужно применять, следовать вместе с вашими идеями.

Расширение используется для классов, здесь вы расширяете то, что уже существует, добавляя к нему дополнительные функции.

Еще несколько примечаний:

интерфейс может расширять другой интерфейс.

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

Ответ 11

Когда подкласс расширяет класс, он позволяет наследовать (повторно использовать) подкласс и переопределять код, определенный в супертипе. Когда класс реализует интерфейс, он позволяет использовать объект, созданный из класса, в любом контексте, который ожидает значение интерфейса.

Настоящий улов здесь заключается в том, что, хотя мы реализуем что-либо, это просто означает, что мы используем эти методы как есть. Нет никаких возможностей для изменения их значений и типов возврата.

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

Ответ 12

Мы используем SubClass, который расширяет SuperClass только тогда, когда подкласс хочет использовать некоторую функциональность (методы или переменные экземпляра), которая уже объявлена ​​в SuperClass, или если я хочу немного изменить функциональность SuperClass (переопределение метода). Но скажем, например, у меня есть класс Animal (SuperClass) и класс Dog (SubClass), и есть несколько методов, которые я определил в классе Animal, например. doEat();, doSleep();... и многое другое.

Теперь мой класс Dog может просто расширить класс Animal, если я хочу, чтобы моя собака использовала любой из методов, объявленных в классе Animal, я могу вызвать эти методы, просто создав объект Dog. Таким образом, я могу гарантировать, что у меня есть собака, которая может есть и спать, и делать все, что я хочу, чтобы собака сделала.

Теперь, представьте, однажды какой-нибудь любитель кошек приходит в наше рабочее пространство, и она пытается расширить класс животных (кошки тоже едят и спят). Она создает объект Cat и начинает использовать методы.

Но, скажем, кто-то пытается создать объект класса Animal. Вы можете сказать, как кошка спит, вы можете сказать, как собака ест, вы можете сказать, как пьет слон. Но это не имеет никакого смысла в создании объекта класса Animal. Потому что это шаблон, и мы не хотим, чтобы общий способ питания.

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

Таким образом, интерфейс - это не что иное, как абстрактный класс (чистый абстрактный класс), который не содержит реализаций методов, а только определений (шаблонов). Итак, кто бы ни реализовал интерфейс, просто знает, что у них есть шаблоны doEat(); и doSleep(); но они должны определить свой собственный doEat(); и doSleep(); методы в соответствии с их потребностями.

Вы расширяетесь только тогда, когда хотите повторно использовать часть SuperClass (но имейте в виду, что вы всегда можете переопределить методы вашего SuperClass в соответствии с вашими потребностями), и вы реализуете, когда хотите шаблоны, и хотите их определить (по вашему желанию).

Я расскажу вам фрагмент кода: вы попробуете его с различными наборами входов и посмотрите результаты.

class AnimalClass {

public void doEat() {

    System.out.println("Animal Eating...");
}

public void sleep() {

    System.out.println("Animal Sleeping...");
}

}

public class Dog extends AnimalClass implements AnimalInterface, Herbi{

public static void main(String[] args) {

    AnimalInterface a = new Dog();
    Dog obj = new Dog();
    obj.doEat();
    a.eating();

    obj.eating();
    obj.herbiEating();
}

public void doEat() {
    System.out.println("Dog eating...");
}

@Override
public void eating() {

    System.out.println("Eating through an interface...");
    // TODO Auto-generated method stub

}

@Override
public void herbiEating() {

    System.out.println("Herbi eating through an interface...");
    // TODO Auto-generated method stub

}


}

Определенные интерфейсы:

public interface AnimalInterface {

public void eating();

}


interface Herbi {

public void herbiEating();

}

Ответ 13

В самых простых терминах extends используется для наследования от класса, а реализации используются для применения интерфейса в вашем классе.

расширяет:

public class Bicycle {
    //properties and methods
}
public class MountainBike extends Bicycle {
    //new properties and methods
}

реализует:

public interface Relatable {
    //stuff you want to put
}
public class RectanglePlus implements Relatable {
    //your class code
}

если у вас все еще есть путаница, прочитайте это: https://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html https://docs.oracle.com/javase/tutorial/java/IandI/usinginterface.html

Ответ 14

Оба ключевых слова используются при создании собственного нового класса на языке Java.

Разница: implements означает, что вы используете элементы интерфейса Java в своем классе. extends означает, что вы создаете подкласс базового класса, который вы расширяете. Вы можете расширить только один класс в своем дочернем классе, но вы можете реализовать столько интерфейсов, сколько хотите.

Дополнительную информацию см. на странице документации оракала interface.

Это может помочь прояснить, что такое интерфейс, и соглашения вокруг их использования.

Ответ 15

Extends используется, когда вы хотите, чтобы атрибуты родительского класса/интерфейса были в вашем дочернем классе/интерфейсе, а implements используются, когда вам нужны атрибуты интерфейса в вашем классе.

Пример:

  1. Расширяет использование класса

    class Parent {

    }

    класс Child расширяет Parent {

    }

  2. Расширяет использование интерфейса

    интерфейс Parent {

    }

    Интерфейс Child расширяет Parent {

    }

  3. инвентарь

интерфейс A {

}

класс B реализует A {

}

Сочетание расширяет и реализует

interface A{

}

class B

{

}

class C implements A,extends B{

}

Ответ 16

продолжается

  • класс расширяет только один класс
  • интерфейс расширяет один или несколько интерфейсов

инвентарь

  • класс реализует один или несколько интерфейсов
  • Интерфейсы "не может" реализует что-либо

абстрактные классы также действуют как классы с расширениями и реализациями

Ответ 17

Эти два ключевых слова непосредственно связаны с Наследством, это основная концепция ООП. Когда мы наследуем некоторый класс другому классу, мы можем использовать extends, но когда мы собираемся наследовать некоторые интерфейсы для нашего класса, мы не можем использовать extends, нам следует использовать реализует, и мы можем использовать расширяет ключевое слово, чтобы наследовать интерфейс от другого интерфейса.

Ответ 18

Классы и интерфейсы являются контрактами. Они предоставляют методы и свойства, на которые опираются другие части приложения.

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

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

extends используется, когда вы хотите заменить детали существующего контракта. Таким образом, вы заменяете один способ выполнения контракта другим способом. Классы могут расширять другие классы, а интерфейсы могут расширять другие интерфейсы.