인터페이스와 추상 클래스의 차이점은 정확히 무엇입니까?

인터페이스

인터페이스는 계약입니다 . 인터페이스를 작성하는 사람은 " 이봐, 나는 그런 식으로 보는 것을 받아들입니다 "라고 말하고, 인터페이스를 사용하는 사람은 " 좋아요. 내가 쓰는 클래스는 그렇게 보입니다 "라고 말합니다 .

인터페이스는 빈 쉘 입니다. 메소드의 서명 만 있습니다. 이는 메소드에 본문이 없음을 의미합니다. 인터페이스는 아무것도 할 수 없습니다. 패턴 일뿐입니다.

예를 들어 (의사 코드) :

// I say all motor vehicles should look like this:
interface MotorVehicle
{
    void run();

    int getFuel();
}

// My team mate complies and writes vehicle looking that way
class Car implements MotorVehicle
{

    int fuel;

    void run()
    {
        print("Wrroooooooom");
    }


    int getFuel()
    {
        return this.fuel;
    }
}

인터페이스를 구현하는 것은 클래스가 아니고 이름이 많기 때문에 CPU를 거의 소비하지 않으므로 값 비싼 조회가 필요하지 않습니다. 임베디드 장치와 같이 중요 할 때 유용합니다.

추상 수업

인터페이스와 달리 추상 클래스는 클래스입니다. 그것들을 상속받을 때 찾아야하기 때문에 사용하기가 더 비쌉니다.

추상 클래스는 인터페이스와 비슷하게 보이지만 더 많은 것이 있습니다. 동작을 정의 할 수 있습니다. " 이 수업은 그렇게 생겼어야하고 공통점이 있으므로 공란을 채우십시오! " 라고 말하는 사람에 대한 것입니다 .

예를 들면 다음과 같습니다.

// I say all motor vehicles should look like this:
abstract class MotorVehicle
{

    int fuel;

    // They ALL have fuel, so lets implement this for everybody.
    int getFuel()
    {
         return this.fuel;
    }

    // That can be very different, force them to provide their
    // own implementation.
    abstract void run();
}

// My teammate complies and writes vehicle looking that way
class Car extends MotorVehicle
{
    void run()
    {
        print("Wrroooooooom");
    }
}

이행

추상 클래스와 인터페이스는 다른 개념으로 간주되지만 구현으로 인해 해당 설명이 때때로 사실이 아닙니다. 때때로, 그들은 당신이 생각하는 것조차도 아닙니다.

Java에서는이 규칙이 강력하게 적용되는 반면, PHP에서는 인터페이스가 메소드가 선언되지 않은 추상 클래스입니다.

파이썬에서 추상 클래스는 ABC 모듈에서 얻을 수있는 프로그래밍 트릭이며 실제로 메타 클래스와 클래스를 사용하고 있습니다. 인터페이스는이 언어의 오리 타이핑과 더 관련이 있으며 설명자와 호출자를 호출하는 특수 메소드 (__method__ 메소드)가 혼합되어 있습니다.

프로그래밍과 마찬가지로 다른 언어로는 이론, 실습 및 실습이 있습니다.

추상 클래스 와 인터페이스 의 주요 기술적 차이점 은 다음 과 같습니다.

• 추상 클래스는 상수, 멤버, 메소드 스텁 (본문이없는 메소드) 및 정의 된 메소드를 가질 수 있지만 인터페이스는 상수 및 메소드 스텁 만 가질 수 있습니다 .

• 추상 클래스의 메소드와 멤버는 가시성 으로 정의 할 수 있지만 , 인터페이스의 모든 메소드는 public(기본적으로 public 으로 정의 됨)으로 정의해야합니다 .

• 추상 클래스를 상속 할 때 구체적인 자식 클래스 는 추상 메서드를 정의해야 하지만 추상 클래스는 다른 추상 클래스를 확장 할 수 있으며 부모 클래스의 추상 메서드는 정의 할 필요가 없습니다.

• 마찬가지로 다른 인터페이스를 확장하는 인터페이스 는 부모 인터페이스의 메소드를 구현할 책임 이 없습니다 . 인터페이스가 구현을 정의 할 수 없기 때문입니다.

• 자식 클래스는 단일 클래스 (개요 또는 구체적) 만 확장 할 수있는 반면 인터페이스는 확장하거나 클래스가 여러 다른 인터페이스를 구현할 수 있습니다 .

• 자식 클래스는 가시성 이 같거나 적은 추상 메소드를 정의 할 수 있지만, 인터페이스를 구현하는 클래스는 가시성이 동일한 메소드를 정의해야합니다 (공용).

인터페이스에는 기능의 정의 / 서명 만 포함되며, 공통 서명뿐만 아니라 몇 가지 공통 기능이있는 경우 추상 클래스를 사용해야합니다. 추상 클래스를 사용하면 동시에 동작과 기능을 모두 제공 할 수 있습니다. 추상 클래스를 상속받는 다른 개발자는 공백 만 채우면되기 때문에이 기능을 쉽게 사용할 수 있습니다.

에서 가져온 :

http://www.dotnetbull.com/2011/11/difference-between-abstract-class-and.html

http://www.dotnetbull.com/2011/11/what-is-abstract-class-in-c-net.html http://www.dotnetbull.com/2011/11/what-is-interface-in -c-net.html

설명은 여기에서 찾을 수 있습니다 : http://www.developer.com/lang/php/article.php/3604111/PHP-5-OOP-Interfaces-Abstract-Classes-and-the-Adapter-Pattern.htm

추상 클래스는 프로그래머가 부분적으로 만 구현하는 클래스입니다. 하나 이상의 추상 메소드를 포함 할 수 있습니다. 추상 메소드는 단순히 메소드가 하위 클래스에서 구현되어야 함을 프로그래머에게 알리는 기능 정의입니다.

인터페이스는 추상 클래스와 유사합니다. 실제로 인터페이스는 클래스 및 추상 클래스와 동일한 네임 스페이스를 차지합니다. 따라서 클래스와 이름이 같은 인터페이스를 정의 할 수 없습니다. 인터페이스는 완전히 추상적 인 클래스입니다. 그 메소드 중 어느 것도 구현되지 않으며 클래스 서브 클래스 대신 해당 인터페이스를 구현한다고합니다.

어쨌든 인터페이스에 대한이 설명이 다소 혼란 스럽습니다. 보다 일반적인 정의는 다음과 같습니다 . 인터페이스는 클래스를 구현해야하는 계약을 정의합니다. 인터페이스 정의는 구현 코드없이 공개 멤버의 서명으로 구성됩니다.

많은 답변에서 이미 언급 된 차이점을 강조하고 싶지 않습니다 (인터페이스의 변수에 대한 공개 정적 최종 수정 자 및 추상 클래스의 보호 된 개인 메소드 지원)

간단히 말해서 다음과 같이 말하고 싶습니다.

인터페이스 : 여러 관련없는 객체로 계약을 구현하려면

추상 클래스 : 여러 관련 개체간에 동일하거나 다른 동작을 구현하려면

오라클 문서에서

다음과 같은 경우 추상 클래스 사용을 고려하십시오 .

1. 밀접하게 관련된 여러 클래스간에 코드를 공유하려고합니다.
2. 추상 클래스를 확장하는 클래스에는 많은 공통 메소드 또는 필드가 있거나 public 이외의 액세스 수정 자 (예 : 보호 및 개인)가 필요합니다.
3. 비 정적 또는 최종이 아닌 필드를 선언하려고합니다.

다음과 같은 경우 인터페이스 사용을 고려하십시오 .

1. 관련없는 클래스가 인터페이스를 구현할 것으로 기대합니다. 예를 들어, 많은 관련이없는 객체가 Serializable인터페이스 를 구현할 수 있습니다.
2. 특정 데이터 유형의 동작을 지정하려고하지만 누가 그 동작을 구현하는지는 신경 쓰지 않습니다.
3. 여러 유형의 상속을 활용하려고합니다.

추상 클래스는 구체적인 클래스와 "is"관계를 설정합니다. 인터페이스는 클래스에 "있다"기능을 제공합니다.

Java프로그래밍 언어를 찾고 있다면 다음과 같은 몇 가지 추가 업데이트가 있습니다.

Java 8은 메소드 기능 을 제공하여 클래스 interface와 abstract클래스 사이의 간격 을 어느 정도 줄 default였습니다. 인터페이스에 메소드 구현 이 없으므로 더 이상 유효하지 않습니다.

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

더 잘 이해하기위한 코드 예제에 대해서는이 SE 질문을 살펴보십시오.

Interface와 Abstract 클래스의 차이점을 어떻게 설명해야합니까?

몇 가지 중요한 차이점 :

테이블 형태로 :

으로 javapapers에서 조에서 언급 :

1. 주요 차이점은 Java 인터페이스의 메소드는 내재적으로 추상적이며 구현이 불가능하다는 것입니다. Java 추상 클래스에는 기본 동작을 구현하는 인스턴스 메소드가있을 수 있습니다.

2. Java 인터페이스에 선언 된 변수는 기본적으로 final입니다. 추상 클래스에는 비 최종 변수가 포함될 수 있습니다.

Java 인터페이스의 멤버는 기본적으로 공용입니다. Java 추상 클래스는 개인, 보호 등과 같은 일반적인 클래스 멤버의 풍미를 가질 수 있습니다.

4.Java 인터페이스는 키워드 "구현물"을 사용하여 구현해야합니다. 키워드“extends”를 사용하여 Java 추상 클래스를 확장해야합니다.

5. 인터페이스는 다른 Java 인터페이스 만 확장 할 수 있으며 추상 클래스는 다른 Java 클래스를 확장하고 여러 Java 인터페이스를 구현할 수 있습니다.

6. Java 클래스는 여러 인터페이스를 구현할 수 있지만 하나의 추상 클래스 만 확장 할 수 있습니다.

7. 인터페이스는 절대적으로 추상적이며 인스턴스화 할 수 없습니다. Java 추상 클래스도 인스턴스화 할 수 없지만 main ()이 있으면 호출 할 수 있습니다.

8. 자바 추상 ​​클래스와 비교할 때 자바 인터페이스는 추가 간접 처리가 필요하므로 느립니다.

요점은 다음과 같습니다.

• 초록은 객체 지향 입니다. 그것은 '객체'가 가져야 할 기본 데이터 및 / 또는 기능을 제공합니다. 객체의 기본 특성 인 객체의 기능과 수행 가능한 작업에 관심이 있습니다. 따라서 동일한 추상 클래스에서 상속 된 객체는 기본 특성 (일반화)을 공유합니다.
• 인터페이스는 기능 지향적 입니다. 객체가 가져야하는 기능을 정의합니다. 인터페이스에 정의 된 이러한 기능을 수행 할 수있는 오브젝트가 무엇이든 상관 없습니다. 다른 모든 것을 무시합니다. 객체 / 클래스는 여러 기능 그룹을 포함 할 수 있습니다. 따라서 클래스가 여러 인터페이스를 구현할 수 있습니다.

상속 계층에서 다형성 동작을 제공하려면 추상 클래스를 사용하십시오.

완전히 관련이없는 클래스에 대해 다형성 동작을 원할 경우 인터페이스를 사용하십시오.

300 층 건물을 짓고 있습니다

건물의 청사진 인터페이스

• 예를 들어, Servlet (I)

최대 200 개의 층으로 지어진 건물 – 부분적으로 완성 됨 ---- 초록

• 부분 구현 (예 : 일반 및 HTTP 서블릿)

건물 건설 완료- 콘크리트

• 자체 서블릿과 같은 전체 구현

상호 작용

• 우리는 구현에 대해 아무것도 모르고 요구 사항 만 알고 있습니다. 우리는 인터페이스로 갈 수 있습니다.
• 모든 방법은 기본적으로 공개적이고 추상적입니다
• 100 % 순수한 추상 클래스입니다
• 공개를 선언하면 비공개 및 보호를 선언 할 수 없습니다
• abstract를 선언하면 final, static, synchronized, strictfp 및 native를 선언 할 수 없습니다
• 모든 인터페이스에는 공개, 정적 및 최종 인터페이스가 있습니다
• 인터페이스에서 인스턴스를 생성 할 수 없으므로 직렬화 및 임시는 적용 할 수 없습니다.
• 최종적이기 때문에 비 휘발성
• 모든 변수는 정적입니다
• 인터페이스 내에서 변수를 선언 할 때 선언하는 동안 변수를 초기화해야합니다
• 허용되지 않는 인스턴스 및 정적 블록

요약

• 부분 구현
• 추상적 인 방법이 있습니다. 또한 콘크리트를 사용
• 추상 클래스 메소드 수정 자에 대한 제한 없음
• 추상 클래스 변수 수정 자에 대한 제한 없음
• abstract를 제외한 다른 수정자를 선언 할 수 없습니다
• 변수를 초기화하는 데 제한이 없습니다

DurgaJobs 웹 사이트에서 가져온

이 질문에 다시 답합시다.

가장 먼저 알아야 할 것은 1/1과 1 * 1이 같지만 곱셈과 나눗셈이 동일하다는 의미는 아닙니다. 분명히, 그들은 좋은 관계를 유지하지만 둘 다 다르다는 것을 명심하십시오.

주요 차이점을 지적하고 나머지는 이미 설명했습니다.

추상 클래스는 클래스 계층을 모델링하는 데 유용합니다. 모든 요구 사항을 언뜻 보면 정확히 무엇을 구축 해야하는지 부분적으로 명확 하지만 무엇을 구축해야하는지 알고 있습니다. 따라서 추상 클래스는 기본 클래스입니다.

인터페이스는 다른 계층이나 클래스가 내가 할 수있는 일을 알 수 있도록하는 데 유용합니다. 그리고 내가 뭔가 할 수 있다고 말할 때, 당신은 그 능력이 있어야합니다. 인터페이스는 클래스가 동일한 기능을 구현하기 위해 필수로 표시합니다.

실제로는 매우 간단합니다.

인터페이스는 추상 메소드 만 허용되고 다른 것은 허용되지 않는 클래스로 생각할 수 있습니다.

따라서 인터페이스는 "선언"하고 클래스에 원하는 동작을 정의 할 수 없습니다.

추상 클래스를 사용하면 클래스에 원하는 동작을 정의 (전체 메서드 구현 사용) 할 수있을뿐만 아니라 선언 (추상 메서드 사용)을 수행 할 수 있습니다.

그리고 일반 클래스는 클래스가 갖고 싶은 행동 / 동작을 선언하는 것이 아니라 정의 만 허용합니다.

마지막 한가지,

Java에서는 여러 인터페이스를 구현할 수 있지만 하나만 확장 할 수 있습니다 (추상 클래스 또는 클래스).

즉, 정의 된 동작의 상속은 클래스 당 하나만 허용하도록 제한됩니다. 즉, 클래스 A, B & C에서 동작을 캡슐화 한 클래스를 원하는 경우 다음을 수행해야합니다. 클래스 A는 B를 확장하고 클래스 C는 A를 확장합니다. 다중 상속을 얻는 방법에 대한 약간의 라운드 ...

반면에 인터페이스는 간단하게 수행 할 수 있습니다. 인터페이스 C는 A, B를 구현합니다.

따라서 실제로 Java는 "선언 된 동작", 즉 인터페이스 및 정의 된 동작이있는 단일 상속에서만 다중 상속을 지원합니다.

잘만되면 그것은 의미가 있습니다.

인터페이스와 추상 클래스의 비교가 잘못되었습니다. 1) 인터페이스 대 클래스 와 2) 추상 대 최종 클래스 .

인터페이스 대 클래스

인터페이스 는 두 개체 간의 계약입니다. 예를 들어, 나는 우편 배달부이고 당신은 배달 할 패키지입니다. 배달 주소를 알고 싶습니다. 누군가 나에게 패키지를 제공하면 배송 주소를 알아야합니다.

interface Package {
  String address();
}

클래스 는 계약을 준수하는 객체 그룹입니다. 예를 들어, 저는 "박스"그룹의 박스이며 우편 배달부에서 요구하는 계약을 따릅니다. 동시에 나는 다른 계약에 순종합니다.

class Box implements Package, Property {
  @Override
  String address() {
    return "5th Street, New York, NY";
  }
  @Override
  Human owner() {
    // this method is part of another contract
  }
}

초록 대 결승

추상 클래스 는 불완전한 객체 그룹입니다. 그들은 일부 부품이 없기 때문에 사용할 수 없습니다. 예를 들어 추상 GPS 인식 상자입니다.지도에서 내 위치를 확인하는 방법을 알고 있습니다.

abstract class GpsBox implements Package {
  @Override
  public abstract String address();
  protected Coordinates whereAmI() {
    // connect to GPS and return my current position
  }
}

이 클래스는 다른 클래스에서 상속 / 확장 된 경우 매우 유용 할 수 있습니다. 그러나 그 자체로는 개체가 없기 때문에 쓸모가 없습니다. 추상 클래스는 최종 클래스의 요소를 구축 할 수 있습니다.

Final 클래스 는 완전한 개체 그룹으로, 사용할 수는 있지만 수정할 수는 없습니다. 그들은 일하는 방법과해야 할 일을 정확히 알고 있습니다. 예를 들어, 나는 항상 건설 중에 지정된 주소로 이동하는 Box입니다.

final class DirectBox implements Package {
  private final String to;
  public DirectBox(String addr) {
    this.to = addr;
  }
  @Override
  public String address() {
    return this.to;
  }
}

Java 또는 C ++와 같은 대부분의 언어에서 클래스 를 가질 수 있습니다. 추상 또는 최종 가 아닌 . 이러한 클래스는 상속 될 수 있으며 인스턴스화 될 수 있습니다. 나는 이것이 객체 지향 패러다임과 엄격하게 일치한다고 생각하지 않습니다.

다시, 추상 클래스와 인터페이스를 비교하는 것은 올바르지 않습니다.

간단히 말해서 차이점은 다음과 같습니다.

인터페이스 와 추상 클래스의 구문상의 차이점 :

1. 추상 클래스의 메소드와 멤버는 가시성을 가질 수 있습니다. 인터페이스 의 모든 메소드는 public 이어야합니다 . // 더 이상 Java 9에서 적용되지 않습니다
2. 추상 클래스의 구체적인 자식 클래스는 모든 추상 메소드를 정의해야합니다. 추상 아이 클래스는 추상 메소드를 가질 수 있습니다. 다른 인터페이스를 확장 하는 인터페이스 는 부모 인터페이스에서 상속 된 메소드에 기본 구현을 제공 할 필요가 없습니다.
3. 자식 클래스는 단일 클래스 만 확장 할 수 있습니다. 인터페이스 다수의 인터페이스를 확장 할 수있다. 클래스는 여러 인터페이스를 구현할 수 있습니다.
4. 자식 클래스는 가시성이 같거나 적은 추상 메소드를 정의 할 수 있지만, 인터페이스 를 구현하는 클래스 는 모든 인터페이스 메소드를 공용으로 정의해야합니다.
5. 추상 클래스 는 생성자를 가질 수 있지만 인터페이스 는 가질 수 없습니다 .
6. Java 9의 인터페이스에는 전용 정적 메소드가 있습니다.

인터페이스에서 :

public static-지원됨
public abstract-지원됨
public default-지원됨
private static-지원됨
private abstract-컴파일 오류
private default-컴파일 오류
private-지원됨

유일한 차이점은 하나는 다중 상속에 참여할 수 있고 다른 하나는 참여할 수 없다는 것입니다.

인터페이스 정의가 시간이 지남에 따라 변경되었습니다. 인터페이스에 메소드 선언 만 있고 계약일 뿐이라고 생각하십니까? 정적 최종 변수와 Java 8 이후의 기본 정의는 어떻습니까?

다중 상속과 관련된 다이아몬드 문제 로 인해 인터페이스가 Java에 도입되었으며 이것이 실제로 의도 한 것입니다.

인터페이스는 다중 상속 문제를 해결하기 위해 만들어진 구문이며 추상 메서드, 기본 정의 및 정적 최종 변수를 가질 수 있습니다.

계약 목적으로 만 인터페이스에서 정적 최종 변수를 허용하는 이유는 무엇입니까?를 참조하십시오 . .

인터페이스 : 회전 (좌회전, 우회전)

추상 클래스 : 휠.

클래스 : 스티어링 휠, 휠에서 파생, 인터페이스 회전 노출

하나는 다양한 사물에 걸쳐 제공 될 수있는 행동을 분류하기위한 것이고 다른 하나는 사물의 온톨로지를 모델링하기위한 것입니다.

여러 클래스에서 사용할 수있는 일반적인 메소드가 있으면 추상 클래스로 이동하십시오. 그렇지 않으면 클래스가 인터페이스에 대한 명확한 청사진을 따르기를 원한다면.

다음 예제는 이것을 보여줍니다.

자바의 추상 클래스 :

abstract class animals
{
    // They all love to eat. So let's implement them for everybody
    void eat()
    {
        System.out.println("Eating...");
    }
    // The make different sounds. They will provide their own implementation.
    abstract void sound();
}

class dog extends animals
{
    void sound()
    {
        System.out.println("Woof Woof");
    }
}

class cat extends animals
{
    void sound()
    {
        System.out.println("Meoww");
    }
}

다음은 Java 인터페이스 구현입니다.

interface Shape
{
    void display();
    double area();
}

class Rectangle implements Shape 
{
    int length, width;
    Rectangle(int length, int width)
    {
        this.length = length;
        this.width = width;
    }
    @Override
    public void display() 
    {
        System.out.println("****\n* *\n* *\n****"); 
    }
    @Override
    public double area() 
    {
        return (double)(length*width);
    }
} 

class Circle implements Shape 
{
    double pi = 3.14;
    int radius;
    Circle(int radius)
    {
        this.radius = radius;
    }
    @Override
    public void display() 
    {
        System.out.println("O"); // :P
    }
    @Override
    public double area() 
    { 
        return (double)((pi*radius*radius)/2);
    }
}

간단히 말해서 몇 가지 중요한 요점 :

1. Java 인터페이스에서 선언 된 변수는 기본적으로 final입니다. 추상 클래스는 비 최종 변수를 가질 수 있습니다.

2. Java 인터페이스에서 선언 된 변수는 기본적으로 정적입니다. 추상 클래스는 비 정적 변수를 가질 수 있습니다.

3. Java 인터페이스의 멤버는 기본적으로 공용입니다. Java 추상 클래스는 개인, 보호 등과 같은 일반적인 클래스 멤버의 풍미를 가질 수 있습니다.

많은 주니어 개발자들은 인터페이스, 추상 및 구체적인 클래스를 같은 것의 약간의 변형으로 생각하는 실수를 저지르고 기술적 인 측면에서 순수하게 선택 합니다. 다중 상속이 필요합니까? 일반적인 방법을 사용하려면 장소가 필요합니까? 구체적인 수업 이외의 다른 것을 귀찮게해야합니까? 이것은 잘못이며,이 질문에 숨겨져의 주요 문제 : "I" . 혼자서 코드를 작성할 때, 현재 또는 미래의 다른 개발자가 코드를 다루거나 작업하는 것을 거의 생각하지 않습니다.

인터페이스와 추상 클래스는 기술적 인 관점에서 분명히 비슷하지만 완전히 다른 의미와 목적을 가지고 있습니다.

요약

1. 인터페이스 는 일부 구현이 수행 할 계약 을 정의 합니다 .

2. 추상 클래스 는 구현에서 재사용 할 수 있는 기본 동작 을 제공합니다 .

대체 요약

1. 공용 API를 정의하기위한 인터페이스
2. 추상 클래스는 내부 용 및 SPI 정의용입니다.

구현 세부 사항 숨기기의 중요성

구체적인 수업은 실제 작업을 매우 구체적인 방식으로 수행합니다. 예를 들어, ArrayLista는 연속적인 메모리 영역을 사용하여 빠른 임의 액세스, 반복 및 내부 변경을 제공하지만 삽입, 삭제 및 때로는 추가 할 때 끔찍한 컴팩트 한 방식으로 객체 목록을 저장합니다. 한편,LinkedList 는 이중 링크 노드를 사용하여 객체 목록을 저장합니다. 대신 빠른 반복, 전체 변경, 삽입 / 삭제 / 추가를 제공하지만 임의 액세스에서는 끔찍합니다. 이 두 가지 유형의 목록은 다양한 사용 사례에 최적화되어 있으며 사용 방법에 매우 중요합니다. 상호 작용하는 목록에서 성능을 끌어 내려고 할 때 목록 유형을 선택할 때 자신이 원하는 항목을 신중하게 선택해야합니다.

반면에, 목록의 고급 사용자는 실제로 어떻게 구현되는지 신경 쓰지 않으며, 이러한 세부 사항으로부터 격리되어야합니다. Java가 List인터페이스를 공개하지는 않았지만 List실제로 LinkedList는 현재 구체적인 클래스 만 가지고 있다고 상상해 봅시다 . 모든 Java 개발자는 구현 세부 사항에 맞게 코드를 조정했을 것입니다. 랜덤 액세스를 피하고, 액세스 속도를 높이기 위해 캐시를 추가하거나 ArrayList자체적으로 다시 구현 해야 List합니다. 실제로는 다른 코드와는 호환되지 않습니다 . 그것은 끔찍할 것입니다 ...하지만 이제 Java 마스터는 실제로 링크 된 목록이 대부분의 실제 사용 사례에서 끔찍하다는 것을 알고 자신의 배열 목록으로 전환하기로 결정했다고 상상해보십시오.List수업 가능. 이것은 전 세계 모든 Java 프로그램의 성능에 영향을 미치며 사람들은 그것에 만족하지 않을 것입니다. 그리고 주요 원인은 구현 세부 사항을 사용할 수 있다는 것이며 개발자는 이러한 세부 사항을 신뢰할 수있는 영구 계약이라고 가정했습니다. 그렇기 때문에 구현 세부 사항을 숨기고 추상 계약 만 정의하는 것이 중요합니다. 이것은 인터페이스의 목적입니다. 프로그래머가 미래의 업데이트로 변경 될 수있는 내부 세부 사항에 맞게 코드를 조정하도록 유혹하는 모든 용기를 노출시키지 않으면 서 메소드가 허용하는 입력 종류와 예상되는 출력 종류를 정의하십시오. .

인터페이스와 구체적인 클래스 사이에 추상 클래스가 있습니다. 구현이 공통 또는 지루한 코드를 공유하는 데 도움이됩니다. 예를 들어, AbstractCollection기본적인 구현을 제공 isEmpty크기에 기초가 0 contains으로 반복하고, 비교로서, addAll반복적으로 add, 등등. 이를 통해 구현은 데이터를 실제로 저장하고 검색하는 방법과 차별화하는 중요한 부분에 집중할 수 있습니다.

API와 SPI

인터페이스는 코드의 다른 부분들 사이의 응집력이 낮은 게이트웨이 입니다. 내부적으로 변경 될 때 모든 라이브러리 사용자를 방해하지 않고 라이브러리가 존재하고 진화 할 수 있습니다. 그것은라고 프로그래밍 응용 프로그램 인터페이스 가 아닌 응용 프로그래밍 클래스. 더 작은 규모에서는 여러 개발자가 잘 문서화 된 인터페이스를 통해 다른 모듈을 분리하여 대규모 프로젝트에서 성공적으로 협업 할 수 있습니다.

추상 클래스는 인터페이스를 구현할 때 일정 수준의 구현 세부 사항을 가정 할 때 응집력이 높은 도우미 입니다. 또는 추상 클래스가 SPI, 서비스 제공자 인터페이스를 정의하는 데 사용됩니다.

API와 SPI의 차이점은 미묘하지만 중요합니다. API의 경우 API를 사용 하는 사람 에 중점을두고 SPI의 경우이를 구현 하는 사람에 중점을 둡니다 .

API에 메소드를 추가하는 것은 쉽지만 기존의 모든 API 사용자는 여전히 컴파일됩니다. 모든 서비스 제공 업체 (콘크리트 구현)가 새 메소드를 구현해야하기 때문에 SPI에 메소드를 추가하는 것은 어렵습니다. 인터페이스가 SPI를 정의하는 데 사용되는 경우 공급자는 SPI 계약이 변경 될 때마다 새 버전을 릴리스해야합니다. 추상 클래스가 대신 사용되는 경우 새 메소드는 기존 추상 메소드 또는 빈 throw not implemented exception스텁 으로 정의 될 수 있습니다.이 경우 스텁은 최소한 이전 버전의 서비스 구현이 여전히 컴파일 및 실행되도록 허용합니다.

Java 8 및 기본 메소드에 대한 참고 사항

Java 8은 인터페이스와 추상 클래스 사이의 경계를 더욱 흐리게 만드는 인터페이스에 대한 기본 메소드를 도입했지만, 구현이 코드를 재사용 할 수 있도록하는 것이 아니라 API와 SPI 모두를 제공하는 인터페이스를보다 쉽게 ​​변경할 수있었습니다. (또는 추상 클래스 대신 SPI를 정의하는 데 잘못 사용됨).

어느 것을 사용해야합니까?

1. 는 IS 일이 있기로되어 공개적으로 사용되는 코드의 다른 부분 또는 다른 외부 코드에 의해? 공용 추상 계약에서 구현 세부 사항을 숨기려면 인터페이스를 추가하십시오. 이는 일반적인 동작입니다.
2. 는 IS 일이 공통의 코드를 많이 여러 구현을 가지고 해야하는 일이? 인터페이스와 추상적이고 불완전한 구현을 만듭니다.
3. 구현이 하나만 있습니까? 다른 사람은 그것을 사용하지 않습니까? 그것을 구체적인 수업으로 만드십시오.
   1. "ever"는 오랜 시간 동안 안전하게 플레이 할 수 있으며 그 위에 인터페이스를 추가 할 수 있습니다.

당연한 결과 : 주위에 다른 방법은 종종 잘못 수행하십시오 사용할 때 일을 , 항상 당신이 실제로 필요로하는 대부분의 제네릭 클래스 / 인터페이스를 사용하려고합니다. 즉, ArrayList theList = new ArrayList()실제로 배열 목록 에 대한 의존성이 높고 다른 유형의 목록이 변수를 자르지 않으면 변수를로 선언하지 마십시오 . List theList = new ArrayList대신 또는 Collection theCollection = new ArrayList목록이라는 사실과 다른 유형의 컬렉션이 실제로 중요하지 않은 경우 에도 사용하십시오 .

실제로 원래 질문에 대한 답은 아니지만, 차이점에 대한 답을 얻으면 사용시기 별 딜레마를 입력하게됩니다. 언제 인터페이스 또는 추상 클래스를 사용해야합니까? 둘 다 언제 사용합니까?

나는 OOP에 대한 지식을 제한했지만 인터페이스에서 문법의 형용사와 동등한 것으로 보는 것은 지금까지 저에게 효과적이었습니다 (이 방법이 가짜라면 수정하십시오!). 예를 들어, 인터페이스 이름은 클래스에 부여 할 수있는 속성 또는 기능과 유사하며 클래스에는 ISerializable, ICountable, IList, ICacheable, IHappy 등의 여러 속성이있을 수 있습니다.

상속은 두 가지 목적으로 사용됩니다.

• 객체가 부모 유형의 데이터 멤버 및 메소드 구현을 고유 한 것으로 간주하도록합니다.

• 한 유형의 객체에 대한 참조를 수퍼 타입 ​​객체에 대한 참조가 필요한 코드에서 사용할 수 있도록합니다.

일반화 된 다중 상속을 지원하는 언어 / 프레임 워크에서 유형을 "인터페이스"또는 "추상 클래스"로 분류 할 필요가없는 경우가 많습니다. 그러나 인기있는 언어와 프레임 워크는 형식이 다른 형식의 데이터 멤버 나 메서드 구현을 다른 형식의 임의의 숫자로 대체 할 수있는 형식을 허용하더라도 형식을 다른 형식의 데이터 멤버 나 메서드 구현으로 간주 할 수 있습니다.

추상 클래스에는 데이터 멤버 및 메서드 구현이있을 수 있지만 다른 클래스에서 상속되지 않는 클래스 만 상속 할 수 있습니다. 인터페이스는 인터페이스를 구현하는 유형에 거의 제한을 두지 않지만 데이터 멤버 나 메소드 구현을 포함 할 수는 없습니다.

유형이 여러 가지로 대체 될 수있는 경우가 있습니다. 객체가 부모 타입 데이터 멤버와 메소드 구현을 자신의 것으로 간주하는 것이 유용한 다른 경우가 있습니다. 인터페이스와 추상 클래스를 구별하면 각 기능을 가장 관련성이 높은 경우에 사용할 수 있습니다.

키 포인트:

• 추상 클래스는 속성, 데이터 필드, 방법 (완료 / 불완전)을 모두 가질 수 있습니다.
• 메서드 또는 속성이 파생 클래스에서 재정의해야하는 추상 키워드로 정의 된 경우 (완전히 결합 된 기능으로 작동)
• 추상 클래스에서 메소드 또는 특성에 대한 추상 키워드를 정의하면 메소드 본문 및 특성에 대한 값을 가져 오거나 설정할 수 없으며 파생 클래스에서 대체해야합니다.
• 추상 클래스는 다중 상속을 지원하지 않습니다.
• 추상 클래스에는 생성자가 포함됩니다.
• 추상 클래스에는 하위, 함수, 속성에 대한 액세스 수정자가 포함될 수 있습니다.
• 추상 클래스의 완전한 멤버 만 정적 일 수 있습니다.
• 인터페이스는 다른 인터페이스에서만 상속 할 수 있으며 추상 클래스는 다른 추상 클래스 나 다른 인터페이스에서 상속 할 수있는 추상 클래스에서 상속 할 수 없습니다.

이점:

• 모든 서브 클래스가 동일한 계층 구조 또는 표준을 수행하도록하는 계약입니다.
• 다양한 구현이 동일한 종류이고 일반적인 동작 또는 상태를 사용하는 경우 추상 클래스를 사용하는 것이 좋습니다.
• 새 클래스를 추상 클래스에 추가하면 기본 구현을 제공하는 옵션이 있으므로 모든 기존 코드가 올바르게 작동 할 수 있습니다.
• 인터페이스보다 빠른 실행을 허용합니다. (인터페이스 해당 클래스에서 실제 메서드를 찾는 데 더 많은 시간이 필요합니다.)
• 타이트하고 느슨하게 커플 링하는 데 사용할 수 있습니다.

자세한 내용은 여기를 참조하십시오 ... http://pradeepatkari.wordpress.com/2014/11/20/interface-and-abstract-class-in-c-oops/

요약하자면 가장 짧은 방법은 interface 은 다음과 같습니다.

1. 완전히 추상적 인 방법 default과 static방법; 반면에 대한 정의 (메소드 서명 + 구현)가 있습니다.default 와 static메소드에 있지만 다른 메소드에 대한 선언 (메소드 시그니처) 만 있습니다.
2. 클래스에 비해 laxer 규칙에 따라 (클래스가 여러 구현할 수 interface들, 그리고이 interface여러에서 상속 할 수 있습니다 interface들). 모든 변수는 다음과 같이 명시 적으로 암시 적으로 일정합니다public static final . public지정 여부에 관계없이 모든 멤버는 암시 적으로 입니다.
3. 일반적으로 구현 클래스가 지정된 기능을 갖거나 동일한 인터페이스를 구현하는 다른 클래스와 호환된다는 보장으로 사용됩니다.

한편, abstract 수업은 다음과 같습니다.

1. 하나 이상을 갖는 경향이있는 완전히 추상적 인 것에서부터 완전히 구현 된 것까지 abstract 방법 . 선언이로 표시된 선언과 정의를 모두 포함 할 수 있습니다 abstract.
2. 본격적인 클래스이며 인스턴스화 할 수없는 조건 (완전히 구현되었다는 보장이 없기 때문에)은 다른 클래스를 지배하는 규칙 (한 클래스에서만 상속 할 수 있음)을 따릅니다. 상수가 아닌 멤버 변수를 가질 수 있습니다. , 멤버 액세스 제어를 구현으로 회원을 제한 할 수 protected, private또는 개인 패키지 (지정).
3. 일반적으로 여러 서브 클래스가 공유 할 수있는만큼 많은 구현을 제공하거나 프로그래머가 제공 할 수있는만큼 많은 구현을 제공하는 데 사용됩니다.

우리는 그것을 하나의 문장에 대한 모든 아래로 비등 할 경우 또는, 일 :이 interface구현 클래스가 무엇을 가지고 있지만 abstract클래스는 서브 클래스가 무엇인가 이다 .

의미있는 차이를 하나 더 추가하고 싶습니다. 예를 들어 수천 줄의 코드가있는 프레임 워크가 있습니다. 이제 enhanceUI () 메소드를 사용하여 코드 전체에 새로운 기능을 추가하려면 해당 메소드를 인터페이스가 아닌 추상 클래스에 추가하는 것이 좋습니다. 인터페이스에이 메소드를 추가하면 구현 된 모든 클래스에서이 메소드를 구현해야하지만 추상 클래스에서 메소드를 추가하는 경우에는 해당되지 않습니다.

간단하지만 명확한 답변을 제공하기 위해 컨텍스트를 설정하는 데 도움이됩니다. 전체 구현을 제공하지 않으려는 경우 둘 다 사용합니다.

주요 차이점은 인터페이스에는 전혀 구현이 없으며 (본문이없는 메소드 만) 추상 클래스는 본문이있는 멤버 및 메소드도 가질 수 있다는 것입니다. 즉 부분적으로 구현할 수 있습니다.

실제 구현을위한 추상 클래스와 인터페이스의 차이점

상호 작용 : 키워드이며 객체의 템플릿 또는 블루 프린트를 정의하는 데 사용되며 모든 하위 클래스가 동일한 프로토 타입을 따르도록 강제 실행합니다. 구현은 모든 하위 클래스가 기능을 자유롭게 구현할 수 있습니다 요구 사항입니다.

인터페이스를 사용해야하는 다른 사용 사례 중 일부입니다.

Interface here 인터페이스를 통해 수행되는 두 외부 객체 (응용 프로그램의 타사 통합) 간의 통신은 계약으로 작동합니다.

Abstract Class : Abstract, 키워드이며 클래스 전에이 키워드를 사용하면 추상 클래스가됩니다. 주로 템플릿과 객체의 일부 기본 기능을 정의해야 할 때 주로 사용됩니다. 하위 클래스 와이 방법으로 중복 코드와 추상 클래스를 사용할 수있는 하나 이상의 사용 사례를 제거합니다 . 예를 들어 다른 클래스가 클래스의 객체를 직접 인스턴스화 할 수는 없으며 파생 클래스만이 기능을 사용할 수 있기를 원합니다.

추상 클래스의 예 :

 public abstract class DesireCar
  {

 //It is an abstract method that defines the prototype.
     public abstract void Color();

  // It is a default implementation of a Wheel method as all the desire cars have the same no. of wheels.   
 // and hence no need to define this in all the sub classes in this way it saves the code duplicasy     

  public void Wheel() {          

               Console.WriteLine("Car has four wheel");
                }
           }


    **Here is the sub classes:**

     public class DesireCar1 : DesireCar
        {
            public override void Color()
            {
                Console.WriteLine("This is a red color Desire car");
            }
        }

        public class DesireCar2 : DesireCar
        {
            public override void Color()
            {
                Console.WriteLine("This is a red white Desire car");
            }
        }

인터페이스 예 :

  public interface IShape
        {
          // Defines the prototype(template) 
            void Draw();
        }


  // All the sub classes follow the same template but implementation can be different.

    public class Circle : IShape
    {
        public void Draw()
        {
            Console.WriteLine("This is a Circle");
        }
    }

    public class Rectangle : IShape
    {
        public void Draw()
        {
            Console.WriteLine("This is a Rectangle");
        }
    }

인터페이스 와 추상 클래스의 명확한 차이점을 찾을 수 있습니다 .

상호 작용

• 인터페이스에는 추상 메소드 만 포함됩니다.
• 인터페이스를 구현할 때 사용자가 모든 메소드를 구현하도록합니다.
• 최종 변수와 정적 변수 만 포함합니다.
• 인터페이스 키워드를 사용하여 선언하십시오.
• 인터페이스의 모든 메소드는 공용으로 정의해야합니다.
• 인터페이스가 확장되거나 클래스가 여러 개의 다른 인터페이스를 구현할 수 있습니다.

추상 클래스

• 추상 클래스에는 추상 및 비추 상 메서드가 포함됩니다.

• 추상 클래스를 상속받을 때 사용자가 모든 메소드를 강제로 구현하지 않습니다.

• 기본 및 비 기본을 포함한 모든 종류의 변수를 포함합니다

• 추상 키워드를 사용하여 선언하십시오.

• 추상 클래스의 메소드와 멤버는 가시성으로 정의 할 수 있습니다.

• 하위 클래스는 단일 클래스 (개요 또는 콘크리트) 만 확장 할 수 있습니다.

추상 클래스는 객체를 만들 수없는 클래스이거나 인스턴스화 할 수없는 클래스입니다. 추상 메소드는 클래스 추상을 만듭니다. 추상 클래스에서 선언 된 메소드를 대체하려면 추상 클래스를 상속해야합니다. 액세스 지정자에 대한 제한은 없습니다. 추상 클래스는 생성자 및 기타 구체적인 (비 abstarct 메소드) 메소드를 가질 수 있지만 인터페이스는 가질 수 없습니다.

인터페이스는 설계도 / 템플릿의 청사진입니다 (예 : 종이 위에 집이 주어지고 (인터페이스 하우스), 다른 건축가들이 아이디어를 사용하여이를 구축 할 것입니다 (하우스 인터페이스를 구현하는 건축가 클래스). 추상 메소드, 기본 메소드, 정적 메소드, 최종 변수 및 중첩 클래스 모든 멤버는 final 또는 public이며 보호 및 개인 액세스 지정자는 허용되지 않습니다. 오브젝트 작성은 허용되지 않습니다. 인터페이스를 구현하고 인터페이스에 선언 된 추상 메서드를 재정의합니다 인터페이스는 느슨한 커플 링의 좋은 예입니다 (동적 다형성 / 동적 바인딩) 인터페이스는 다형성과 추상화를 구현합니다. 구현 클래스입니다.sa 자동차 회사는 제조중인 모든 자동차에 대해 일부 기능이 동일하기를 원하므로 회사는 해당 기능을 가진 인터페이스 차량을 만들고 다른 종류의 자동차 (Maruti Suzkhi, Maruti 800 등)를 대체 할 인터페이스 차량을 만들고자합니다. 그 특징 (기능).

우리가 이미 추상 클래스를 가지고있을 때 왜 인터페이스인가? Java는 다단계 및 계층 상속 만 지원하지만 인터페이스를 사용하여 다중 상속을 구현할 수 있습니다.

실용 용어 (JAVA)에서 추상 클래스와 인터페이스의 주요 차이점은 추상 클래스가 상태를 보유 할 수 있다는 것입니다. 상태를 유지하는 것 외에도 Interface를 사용하여 나머지 작업을 수행 할 수 있습니다.

인터페이스에서 모든 메소드는 정의 일 뿐이고 단일 메소드는 구현하지 않아야합니다.

그러나 추상 클래스에는 정의 만있는 추상 메소드가 있어야하지만 다른 메소드는 구현이있는 추상 클래스에도있을 수 있습니다 ...

인터페이스와 추상 클래스 사이에는 다양한 구조적 / 구문 적 차이가 있습니다. 더 많은 차이점은

[1] 시나리오 기반 차이 :

추상 클래스는 사용자가 부모 클래스의 객체를 생성하도록 제한하려는 시나리오에서 사용되며 향후 더 많은 추상 메소드가 추가 될 것이라고 믿습니다.

더 이상 추상적 인 방법을 제공 할 수 없다고 확신 할 때 인터페이스를 사용해야합니다. 그런 다음 인터페이스 만 게시됩니다.

[2] 개념적 차이 :

"예제하면 더 추상적 인 방법을 제공해야합니까?"

(Java 1.7까지 가장 적절하고 유효한)

일반적으로 무언가의 핵심에 사용되는 추상 클래스이지만 주변 장치를 추가하는 데 사용되는 인터페이스입니다.

차량의 기본 유형을 만들려면 추상 클래스를 사용해야하지만 차량의 기본 개념의 일부가 아닌 일부 기능 또는 속성을 추가하려면 인터페이스를 사용해야합니다 (예 : "ToJSON ()"함수 추가). .

인터페이스는 추상 클래스가 아닌 광범위한 추상화를 가지고 있습니다. 인수를 전달하면이를 볼 수 있습니다.이 예제를보십시오.

차량을 인수로 사용하는 경우 파생 된 유형 중 하나 (버스 또는 자동차와 동일한 카테고리 만 차량 카테고리)를 사용할 수 있습니다. 그러나 IMoveable 인터페이스를 인수로 사용하면 더 많은 선택이 있습니다.