Вопрос по interface, inheritance, extends, implements, java – Реализует против расширяет: когда использовать? Какая разница?

624

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

link Этот пример позволил легко понять интерфейс и абстрактный класс, то есть реализовать и расширить в Java. User Learning

Ваш Ответ

15   ответов
10

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

Для большегоподробности

5

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

extends:

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

implements:

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

6

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

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

Обратитесь к странице документации оракула наинтерфейс Больше подробностей.

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

11

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

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

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

Еще несколько заметок:

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

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

639

extends дляextending класс.

implements дляimplementing интерфейс

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

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

 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

Я предлагаю вам сделать еще несколько исследованийdynamic binding, polymorphism and in general inheritance in Object-oriented programming

& quot; можно указывать только методы. & quot; довольно вводит в заблуждение ...
Новая функция вJava 8 позволяет реализациюdefault поведение методов в интерфейсах, что делает пользовательскую реализацию этих методов необязательной. Поэтому утверждение"you can only specify methods, but not implement them" только полностью правильно дляJava 7 and below.
это что-то вроде модулей и миксинов в ruby?
"extends" предназначен для расширения класса ", немного сбивает с толку. Синусan interface and extends an interface too , Например:public interface ListIterator<E> extends Iterator<E>
Интерфейс может содержать гораздо больше, чем объявления методов: постоянные поля, аннотации, интерфейсы и даже классы.
30

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

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

Если вместо этого вы больше заинтересованы в знании, когда использоватьabstract classэс иinterfaces, обратитесь к этой теме:Интерфейс против абстрактного класса (общий ОО)

A class can only implement one interface. A class can extend several other classes. Я полагаю, вы получили это задом наперед.
Просто, чтобы уточнить комментарий от pb2q, ответ уже был отредактирован / исправлен. & quot; класс может расширять только один другой класс. Класс может реализовывать несколько интерфейсов & quot; это правильное утверждение.
Вы также можете расширить интерфейс.
14

A extends B:

A and B are both classes or both interfaces

A implements B

A is a class and B is an interface

The remaining case where A is an interface and B is a class is not legal in Java.

36

extends для тех случаев, когда вы наследуете отbase class (то есть расширение его функциональности).

implements для тех случаев, когда вы реализуетеinterface.

Вот хорошее место для начала:Interfaces and Inheritance.

Расширение также предназначено для расширения интерфейса :-).
7

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

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

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

25

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

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

Отличное объяснение; заслуживает большего признания.
14

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

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

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

75

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

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

1

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

Пример:

Extends using class

class Parent{

}

class Child extends Parent{

}

Extends using interface

interface Parent{

}

interface Child extends Parent{

}

Implements

интерфейс A {

}

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

}

Combination of extends and implements

interface A{

}

class B

{

}

class C implements A,extends B{

}
4

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

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

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

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

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

So to conclude, Interface is nothing but an abstract class(a pure abstract class) which contains no method implementations but only the definitions(the templates). So whoever implements the interface just knows that they have the templates of doEat(); and doSleep(); but they have to define their own doEat(); and doSleep(); methods according to their need.

Вы расширяете только тогда, когда хотите повторно использовать некоторую часть 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

}


}

Defined Interfaces :

public interface AnimalInterface {

public void eating();

}


interface Herbi {

public void herbiEating();

}
32

В общем-тоimplements используется для реализацииinterface а такжеextends используется дляextension поведения базового класса илиabstract учебный класс.

extends: Производный класс может расширять базовый класс. Вы можете переопределить поведение установленных отношений. Производный класс & quot;is a& Quot; тип базового класса

implements: Вы выполняете контракт. Класс, реализующий интерфейс & quot;has a& Quot; возможность.

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

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

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

Пример, чтобы понять вещи.

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 r,emember(){
        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

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

Dog and Cat are animals and they extended remember() and protectOwner() by sharing name,lifeExpentency from Animal Cat can climb() but Dog does not. Dog can think() but Cat does not. These specific capabilities are added to Cat and Dog by implementing that capability. Man is not an animal but he can Think,Learn,Apply,Climb

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

Unrelated classes can have capabilities through inter,face but related classes override behaviour through extension of base classes.

@Ravindrababu Большое спасибо за такое четкое объяснение.
Очень хорошо объяснил. Это просто щелкнуло. Огромное спасибо!
Если человек мыслитель, я установлю связь с удлинителями, а не с орудиями. У мыслителя могут быть некоторые состояния и другие роли / функции, но я буду реализовывать способность мышления только с помощью интерфейса. IS A - это стандартный термин, используемый для наследования.
Это действительно так? Я всегда думал, что "имеет" относится к тому, чтобы иметь что-то, обладать этим. Вы могли бы сказать, что у кошки есть способность к лазанию, но я бы сказал, перефразируйте ваш пример. Кошка "является" Альпинист "человек" является "человеком" & quot; мыслитель, ученик, альпинист & quot ;. Так как человек "является" мыслитель, он может делать то же, что и мыслитель. Это даже более понятно при работе с некоторыми протоколами - если у вас есть дом, у него есть дверь, но он не реализует pushingHandle. Это также "является" MaterialObject, то есть реализует интерфейс для подчинения гравитации; он не имеет «GravityObeyingSkill»; или что-то подобное.
здорово объяснил!

Похожие вопросы