Реализует против расширяется: когда использовать? В чем же разница?

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

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

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

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

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

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

A class может расширить только один другой class. A class может реализовать несколько interfaces.

Если вместо этого вы больше заинтересованы в том, чтобы знать, когда использовать abstract classes и interfaces, обратитесь к этому потоку: Interface vs Abstract Class (general OO)

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

Extends : производный класс может расширять базовый класс. Вы можете переопределить поведение установившегося отношения. Производный класс "это а" тип базового класса

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

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

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

Интерфейс vs абстрактный класс (general 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

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

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

Пройдя через эти примеры, вы можете понять, что

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

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

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

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

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

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

• A расширяет B:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Обратитесь к документации oracle на странице interface для получения более подробной информации.

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

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

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

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

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

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

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

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

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

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();

}

Как показано на рисунке ниже, класс расширяет другой класс, интерфейс расширяет другой интерфейс, но класс реализует интерфейс.

Подробнее Подробнее

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

Пример:

1. расширяется с помощью класса

   Класс Родитель {

   }

   Класс Child расширяет Родительский{

   }

2. расширяется с помощью интерфейса

   Родительский Интерфейс {

   }

   Дочерний интерфейс расширяется Родитель{

   }

3. орудия труда

Интерфейс A {

}

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

}

комбинация расширений и реализаций

interface A{

}

class B

{

}

class C implements A,extends B{

}