구현 및 확장 : 사용시기 차이점이 뭐야?

이해하기 쉬운 언어로 또는 기사로 연결되는 링크로 설명하십시오.

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

동적 바인딩, 다형성 및 일반적으로 객체 지향 프로그래밍의 상속에 대해 좀 더 연구 할 것을 제안합니다.

프로필에 C ++ 질문이 있습니다. C ++에서 다중 상속 의 개념을 이해하면 (하나 이상의 다른 클래스에서 특성을 상속하는 클래스 참조) Java는이를 허용하지 않지만 interfaceC ++의 순수한 가상 클래스와 같은 키워드를 가지고 있습니다 . 많은 사람들이 언급했듯이, 당신 extend은 클래스 (그리고 당신은 하나에서 확장 할 수 있습니다)와 implement인터페이스를 제공하지만 클래스는 원하는만큼 인터페이스를 구현할 수 있습니다.

즉, 이러한 키워드와 사용 규칙은 Java에서 다중 상속 가능성을 설명합니다 (수퍼 클래스는 하나만있을 수 있지만 여러 인터페이스를 구현할 수 있음).

일반적으로 구현은 구현에 사용되는 인터페이스 및 연장 에 사용되는 확장 기본 클래스의 행동이나의 추상 클래스입니다.

extends : 파생 클래스는 기본 클래스를 확장 할 수 있습니다. 당신은 확립 된 관계의 행동을 재정의 할 수 있습니다. 파생 클래스 " 는 "기본 클래스 유형입니다.

구현합니다 : 계약을 구현하고 있습니다. ""인터페이스를 구현하는 클래스 에는 "기능이 있습니다.

Java 8 릴리스를 사용하면 interface 자체에 구현을 제공하는 interface에 기본 메소드 가있을 수 있습니다 .

각각의 사용시기에 대해서는이 질문을 참조하십시오.

인터페이스 대 추상 클래스 (일반 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

이 예제들을 살펴보면

관련없는 클래스는 인터페이스를 통해 기능을 가질 수 있지만 관련 클래스는 기본 클래스의 확장을 통해 동작을 대체합니다.

extends기본 클래스 에서 상속하는 경우 (예 : 기능 확장)입니다.

implements인터페이스를 구현할 때 사용 됩니다 .

시작하기에 좋은 장소는 다음과 같습니다 : Interfaces and Inheritance .

A는 class단지 "를 구현"할 수 있습니다 interface. 클래스는 "확장"만합니다 class. 마찬가지로을 interface다른 확장 할 수 있습니다 interface.

A class는 서로 만 확장 할 수 있습니다 class. A는 class여러 구현할 수 interface들.

대신 abstract classes와 interfaces 를 사용하는시기를 알고 싶은 경우이 스레드를 참조하십시오. 인터페이스 vs 추상 클래스 (일반 OO)

인터페이스는 객체가 수행 할 수있는 동작에 대한 설명입니다. 예를 들어 전등 스위치를 뒤집거나 전등이 켜질 때 어떻게되는지 신경 쓰지 않아도됩니다. 객체 지향 프로그래밍에서 인터페이스는 객체가 "X"가되기 위해 가져야하는 모든 기능에 대한 설명입니다. 다시 한 번, 예를 들어 라이트처럼 "ACTS LIKE"는 turn_on () 메소드와 turn_off () 메소드를 가져야합니다. 인터페이스의 목적은 컴퓨터가 이러한 속성을 적용하고 TYPE T (인터페이스가 무엇이든)의 개체에 X, Y, Z 등의 함수가 있어야한다는 것을 알 수 있도록하는 것입니다.

인터페이스는 컴퓨터가 객체 (클래스)에 특정 속성을 적용 할 수있는 프로그래밍 구조 / 구문입니다. 예를 들어 자동차 클래스와 스쿠터 클래스, 트럭 클래스가 있다고 가정 해 봅시다. 이 세 클래스 각각에는 start_engine () 액션이 있어야합니다. 각 차량에 대한 "엔진 시작"방법은 각 특정 클래스에 맡겨져 있지만 start_engine 조치가 있어야한다는 사실은 인터페이스 의 도메인입니다 .

아래 그림과 같이 클래스는 다른 클래스를 확장하고 인터페이스는 다른 인터페이스를 확장하지만 클래스는 인터페이스를 구현합니다.

자세한 내용 은

확장 : 부모 클래스의 속성을 기본 클래스로 가져 오는 데 사용되며 자식 클래스에서 재정의 할 수있는 이미 정의 된 메서드를 포함 할 수 있습니다.

구현 : 이것은 자식 클래스에서 인터페이스를 정의하여 인터페이스 (함수 서명 만있는 정의가 아닌 부모 클래스)를 구현하는 데 사용됩니다.

"새 인터페이스를 기존 인터페이스의 자식으로 사용하려면 어떻게합니까?"라는 특별한 조건이 있습니다. 위의 조건에서 하위 인터페이스 는 상위 인터페이스를 확장 합니다.

• A는 B를 확장합니다.

  A와 B는 둘 다 클래스이거나 인터페이스입니다.

• A는 B를 구현

  A는 클래스이고 B는 인터페이스입니다

• A가 인터페이스이고 B가 클래스 인 나머지 경우는 Java에서 유효하지 않습니다.

구현은 인터페이스에 사용되며 확장은 클래스를 확장하는 데 사용됩니다.

보다 쉬운 용어로 더 명확하게하기 위해, 인터페이스는 소리와 같습니다. 인터페이스 – 모델, 적용해야 할 아이디어, 아이디어를 따라야합니다.

Extend는 클래스에 사용됩니다. 여기서 더 많은 기능을 추가하여 이미 존재하는 것을 확장합니다.

몇 가지 참고 사항 :

인터페이스는 다른 인터페이스를 확장 할 수 있습니다.

인터페이스 구현 또는 특정 시나리오에 대한 클래스 확장 중에서 선택해야하는 경우 인터페이스를 구현하십시오. 클래스는 여러 인터페이스를 구현할 수 있지만 하나의 클래스 만 확장 할 수 있습니다.

서브 클래스가 클래스를 확장하면 서브 클래스가 수퍼 타입에 정의 된 코드를 상속 (재사용)하고 대체 할 수 있습니다. 클래스가 인터페이스를 구현하면 클래스에서 작성된 객체를 인터페이스 값을 예상하는 모든 컨텍스트에서 사용할 수 있습니다.

여기서 중요한 것은 우리가 무언가를 구현하는 동안 단순히 그 방법을 그대로 사용한다는 것을 의미합니다. 값과 반환 유형의 변경 범위는 없습니다.

그러나 우리가 무언가를 확장하면 그것은 당신의 수업의 확장이됩니다. 변경, 사용, 재사용이 가능하며 반드시 수퍼 클래스에서와 동일한 값을 반환 할 필요는 없습니다.

우리는 사용하는 서브 클래스가 확장 슈퍼 클래스를 서브 클래스가 이미 선언되어 일부 기능 (메소드 나 인스턴스 변수)를 사용하고자하는 경우에만 슈퍼 클래스를 , 아니면 약간의 기능을 수정하려면 슈퍼 클래스 (메소드 오버 라이딩을). 그러나 예를 들어 Animal 클래스 ( SuperClass ) 및 Dog 클래스 ( SubClass )가 있으며 Animal 클래스에 정의한 메소드가 거의 없습니다. doEat (); , doSleep (); ... 그리고 더 많은.

내 Dog 클래스는 단순히 Animal 클래스를 확장 할 수 있습니다. 만약 Dog가 Animal 클래스에 선언 된 메소드를 사용하도록하려면 Dog 객체를 생성하여 해당 메소드를 호출 할 수 있습니다. 이 방법으로 나는 먹고 자고 개가 원하는 다른 일을 할 수있는 개가 있다는 것을 보증 할 수 있습니다.

이제 어느 날 고양이 애호가가 우리의 작업 공간에 들어 와서 동물 클래스를 확장하려고한다고 상상해보십시오 (고양이도 먹고 자고 있습니다). 그녀는 Cat 객체를 만들고 메소드 호출을 시작합니다.

그러나 누군가 누군가 Animal 클래스의 객체를 만들려고합니다. 고양이가 어떻게 잠을자는 지, 개가 어떻게 먹는지, 코끼리가 어떻게 마신지를 말할 수 있습니다. 그러나 Animal 클래스의 객체를 만드는 것은 의미가 없습니다. 그것은 템플릿이기 때문에 일반적인 식사 방법을 원하지 않습니다.

대신 인스턴스화 할 수 없지만 다른 클래스의 템플릿으로 사용할 수있는 추상 클래스를 만드는 것이 좋습니다.

결론적으로 인터페이스는 메소드 구현이 아니라 정의 (템플릿) 만 포함하는 추상 클래스 (순수 추상 클래스) 일뿐입니다. 따라서 인터페이스를 구현하는 사람은 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();

}

Java 언어로 새 클래스를 작성할 때 두 키워드가 모두 사용됩니다.

차이점 : implements클래스에서 Java 인터페이스 요소를 사용하고 있음을 의미합니다. extends확장중인 기본 클래스의 서브 클래스를 작성하고 있음을 의미합니다. 자식 클래스에서 하나의 클래스 만 확장 할 수 있지만 원하는만큼 인터페이스를 구현할 수 있습니다.

자세한 내용 은 인터페이스의 Oracle 설명서 페이지 를 참조하십시오.

이를 통해 인터페이스가 무엇인지, 인터페이스 사용에 관한 규칙을 명확하게 설명 할 수 있습니다.

가장 간단한 용어로 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

클래스 와 인터페이스 는 모두 계약 입니다. 응용 프로그램의 다른 부분이 의존하는 방법과 속성을 제공합니다.

이 계약의 구현 세부 사항에 관심이없는 경우 인터페이스를 정의합니다 . 주의해야 할 것은 계약 (인터페이스)이 존재한다는 것입니다.

이 경우 계약 이행 방법에 대한 세부 사항을 처리 하기 위해 인터페이스를 구현 하는 클래스에 맡기십시오 . 클래스 만 인터페이스를 구현할 수 있습니다.

확장 은 기존 계약의 세부 사항을 바꾸고 싶을 때 사용됩니다. 이렇게하면 한 가지 방법으로 대체하여 다른 방법으로 계약을 이행 할 수 있습니다. 클래스는 다른 클래스를 확장 할 수 있으며 인터페이스는 다른 인터페이스를 확장 할 수 있습니다.

Extends자식 클래스 / 인터페이스에서 부모 클래스 / 인터페이스의 implements특성을 원할 때 사용되며 클래스에서 인터페이스의 특성을 원할 때 사용됩니다.

예:

1. 클래스를 사용하여 확장

   학부모 님 {

   }

   Child 클래스는 Parent를 확장합니다 {

   }

2. 인터페이스를 사용하여 확장

   인터페이스 Parent {

   }

   Child가 Parent를 확장하는 인터페이스 {

   }

3. 구현

인터페이스 A {

}

클래스 B는 A {

}

확장 및 구현의 조합

interface A{

}

class B

{

}

class C implements A,extends B{

}

연장하다

• 클래스는 하나의 클래스 만 확장합니다
• 인터페이스는 하나 이상의 인터페이스를 확장

구현하다

• 클래스는 하나 이상의 인터페이스를 구현
• 인터페이스는 아무것도 구현할 수 없습니다

추상 클래스는 확장 및 구현과 함께 클래스처럼 작동합니다.

이 두 키워드는 상속과 직접 첨부되며 OOP의 핵심 개념입니다. 클래스를 다른 클래스로 상속하면 extends 를 사용할 수 있지만 클래스에 일부 인터페이스를 상속 할 때는 extends를 사용할 수 없으며 구현 을 사용해야하며 extends 키워드를 사용 하여 다른 인터페이스에서 인터페이스를 상속 할 수 있습니다 .