인터페이스 생성시기를 어떻게 알 수 있습니까?
개발 학습에서 인터페이스에 대해 더 많이 배워야 할 것 같은 시점에 있습니다.
나는 종종 그들에 대해 읽었지만 그것들을 이해할 수없는 것처럼 보입니다.
나는 'Walk', 'Run', 'GetLegs'등과 같은 것들을위한 IAnimal 인터페이스를 가진 Animal base class와 같은 예제를 읽었습니다. 여기!"
내가 무엇을 놓치고 있습니까? 내가 이해하기 어려운 개념 인 이유는 무엇입니까? 나는 그것을 이해하는 데 필요한 부분이 없기 때문에 하나의 구체적인 필요성을 깨닫지 못할 수도 있다는 사실에 겁이 난다! 개발자라는 측면에서 뭔가를 놓친 것처럼 느껴집니다! 누구든지 이와 같은 경험이 있고 획기적인 경우이 개념을 이해하는 방법에 대한 몇 가지 팁을 주셔서 감사합니다. 감사합니다.
이 구체적인 문제를 해결합니다.
4 가지 유형의 a, b, c, d가 있습니다. 코드 전체에 다음과 같은 것이 있습니다.
a.Process();
b.Process();
c.Process();
d.Process();
왜 IProcessable을 구현하지 않았습니까?
List<IProcessable> list;
foreach(IProcessable p in list)
p.Process();
예를 들어, 모두 같은 일을하는 50 가지 유형의 클래스를 추가하면 확장 성이 훨씬 향상됩니다.
또 다른 구체적인 문제 :
System.Linq.Enumerable을 살펴본 적이 있습니까? IEnumerable을 구현하는 모든 유형에서 작동하는 수많은 확장 메소드를 정의합니다. IEnumerable을 구현하는 것은 기본적으로 "정렬되지 않은 foreach 유형 패턴에서 반복을 지원합니다"라고 표시되므로 열거 가능한 유형에 대해 복잡한 동작 (Count, Max, Where, Select 등)을 정의 할 수 있습니다.
나는 지미의 대답을 많이 좋아하지만 그것에 무언가를 추가해야한다고 생각합니다. 모든 일의 핵심은 아이 프로세스의 "수"입니다 수. 인터페이스를 구현하는 개체의 기능 (또는 속성이지만 "C # 속성이 아니라"내재적 품질 "을 의미)을 나타냅니다. IAnimal은 아마도 인터페이스에 대한 좋은 예는 아니지만, IWalkable은 시스템이 걸을 수있는 많은 것들을 가지고 있다면 좋은 인터페이스가 될 수 있습니다. Dog, Cow, Fish, Snake와 같은 Animal에서 파생 된 클래스가있을 수 있습니다. 처음 두 개는 아마도 IWalkable을 구현하고 후자 두 개는 걷지 않으므로 그렇게하지 않습니다. 이제 "개와 소에서 파생 된 다른 슈퍼 클래스 인 WalkingAnimal을 왜 가지고 있지 않습니까?"라고 묻습니다. 대답은 로봇과 같이 걸을 수있는 상속 트리 외부에 무언가가있을 때입니다. 로봇은 IWalkable을 구현하지만 Animal에서 파생되지는 않았을 것입니다. 걸을 수있는 것들의 목록을 원한다면
이제 IWalkable을 IPersistable과 같은 소프트웨어로 대체하면 실제 프로그램에서 볼 수있는 것과 훨씬 유사 해집니다.
동일한 기능의 구현이 다를 경우 인터페이스를 사용하십시오.
공통의 구체적인 구현을 공유해야하는 경우 추상 / 기본 클래스를 사용하십시오.
계약과 같은 인터페이스를 생각하십시오. "이 클래스는 이러한 규칙을 따라야합니다."라고 말하는 방법입니다.
IAnimal 예제에서 "IAnimal을 구현하는 클래스에서 Run, Walk 등을 호출 할 수 있어야합니다."라고 말하는 방법입니다.
이것이 왜 유용한가요? 예를 들어 객체에서 Run and Walk를 호출 할 수 있어야한다는 사실에 의존하는 함수를 만들 수 있습니다. 다음을 가질 수 있습니다.
public void RunThenWalk(Monkey m) {
m.Run();
m.Walk();
}
public void RunThenWalk(Dog d) {
d.Run();
d.Walk();
}
... 그리고 당신이 알고있는 모든 물체에 대해 달리고 걸을 수있는 것을 반복하십시오. 그러나 IAnimal 인터페이스를 사용하면 다음과 같이 기능을 한 번 정의 할 수 있습니다.
public void RunThenWalk(IAnimal a) {
a.Run();
a.Walk();
}
인터페이스에 대해 프로그래밍하면 인터페이스의 의도를 구현하기 위해 클래스를 기본적으로 신뢰하게됩니다. 우리의 예에서 생각은 "나는 그들이 달리고 걷는 한, 달리고 걷는 방법에 관심이 없다 . 내 RunThenWalk는 그 동의를 이행하는 한 유효 할 것이다. 클래스."
이 관련 질문 에 대한 좋은 토론도 있습니다 .
너무 걱정하지 마십시오. 많은 개발자들이 인터페이스를 작성할 필요가 거의 없습니다. .NET 프레임 워크 내에서 사용 가능한 인터페이스를 자주 사용 하지만, 언제라도 작성할 필요가 없다고 생각하면 놀라운 일이 없습니다.
내가 항상 누군가에게주는 예는 Sailboat 클래스와 Viper 클래스가있는 경우입니다. 그들은 Boat 클래스와 Car 클래스를 각각 상속받습니다. 이제 이러한 모든 객체를 반복하고 해당 Drive()메소드를 호출해야한다고 가정하십시오 . 다음과 같은 코드를 작성할 수는 있지만
if(myObject is Boat)
((Boat)myObject).Drive()
else
if (myObject is Car)
((Car)myObject).Drive()
작성하는 것이 훨씬 간단합니다.
((IDrivable)myObject).Drive()
Jimmy는 여러 유형에 단일 변수를 사용할 수 있기를 원하지만 모든 유형은 인터페이스 선언을 통해 동일한 메소드를 구현합니다. 그런 다음 인터페이스 유형 변수에서 기본 메소드를 호출 할 수 있습니다.
그러나 인터페이스를 사용해야하는 두 번째 이유가 있습니다. 프로젝트 아키텍트가 구현 코더와 다른 사람이거나 여러 구현 코더와 하나의 프로젝트 관리자가있는 경우 담당자는 전체 인터페이스를 작성하고 시스템이 상호 운용되는지 확인한 다음 인터페이스를 구현 클래스로 채울 수 있도록 개발자에게 맡깁니다. 이 방법은 여러 사람이 호환 가능한 클래스를 작성하고 동시에 수행 할 수있는 가장 좋은 방법입니다.
나는 군대 비유를 좋아한다.
상사는 귀하가 소프트웨어 개발자 , 음악가 또는 변호사 인지 상관하지 않습니다 .
당신은 군인 으로 취급됩니다 .
그것은이다 쉽게 그가 함께 일하고있다 사람의 특정 세부 귀찮게하지 않는 상사에 대한
군인의 추상화로 치료 모두 (... 그들은 사람처럼 행동하지 않을 때이를 처벌).
사람들이 군인처럼 행동하는 능력을 다형성이라고합니다.
인터페이스는 다형성을 달성하는 데 도움이되는 소프트웨어 구성입니다.
필요 단순 귀하의 질문에 대한 답변입니다 달성하기 위해 추상적 인 세부 사항.
어원 적으로 "많은 형태"를 의미하는 다형성 은 기본 클래스의 하위 클래스의 개체를 기본 클래스의 개체 인 것처럼 처리하는 기능입니다. 따라서 기본 클래스는 기본 클래스 자체와 하위 클래스의 여러 형식으로 구성됩니다.
(..) 이렇게하면 코드를보다 쉽게 작성하고 다른 사람들이 쉽게 이해할 수 있습니다. 또한 다른 서브 클래스가 나중에 패밀리 유형에 추가 될 수 있고 새 서브 클래스의 오브젝트도 기존 코드와 함께 작동하므로 코드를 확장 할 수 있습니다.
경험상 인터페이스를 만드는 원동력은 조롱 프레임 워크로 단위 테스트를 시작할 때까지 발생하지 않았습니다. 인터페이스를 사용하면 조롱이 훨씬 쉬워 질 것입니다 (프레임 워크가 가상의 메소드에 의존하기 때문에). 일단 시작하면 구현에서 클래스로 인터페이스를 추상화하는 가치를 보았습니다. 실제 인터페이스를 만들지 않더라도 이제 메서드를 가상으로 만들려고합니다 (재정의 할 수있는 암시 적 인터페이스 제공).
인터페이스에 대한 리팩토링의 모범 사례를 강화하는 데는 다른 많은 이유가 있지만, 단위 테스트 / 조롱은 실제 경험의 초기 "아하 순간"을 제공 한 것입니다.
편집 : 명확히하기 위해 단위 테스트와 조롱으로 항상 실제 구현과 테스트에 사용되는 대체 모의 구현이라는 두 가지 구현이 있습니다. 두 가지 구현이 있으면 인터페이스의 가치가 분명해집니다. 인터페이스 측면에서 처리하여 언제든지 구현을 교체 할 수 있습니다. 이 경우 모의 인터페이스로 교체합니다. 클래스가 올바르게 구성되어 있으면 실제 인터페이스 없이이 작업을 수행 할 수 있지만 실제 인터페이스를 사용하면이 기능이 강화되어 더 명확 해집니다 (독자에게 더 명확합니다). 이러한 자극이 없다면 대부분의 클래스 만 단일 한 구체적인 구현을 가지고 있기 때문에 인터페이스의 가치를 높이 평가하지 못했을 것입니다.
프로그래밍에서 인터페이스의 적절한 사용을 보는 데 도움이되는 비 프로그래밍 예제
전기 장치와 전기 네트워크 사이에는 인터페이스가 있습니다 . 플러그와 소켓의 모양과 전압 및 전류에 관한 규칙 입니다. 새 전기 장치를 구현하려는 경우 플러그가 규칙을 따르는 한 네트워크에서 서비스를받을 수 있습니다. 이렇게하면 확장 성이 매우 쉬워지고 조정 비용을 제거하거나 줄일 수 있습니다. 전기 공급 업체에 새 장치의 작동 방식을 알리지 않고 새 장치를 네트워크에 연결하는 방법에 대한 별도의 계약을 체결 할 필요가 없습니다.
국가에는 표준 레일 게이지가 있습니다. 이로 인해 레일을 내리는 엔지니어링 회사와 해당 레일에서 기차를 타는 엔지니어링 회사 간의 업무 분담이 가능 해져 철도 회사가 전체 시스템을 재구성하지 않고도 열차 를 교체하고 업그레이드 할 수 있습니다.
비즈니스가 고객에게 제공하는 서비스 는 인터페이스로 설명 할 수 있습니다. 잘 정의 된 인터페이스 는 서비스를 강조하고 수단을 숨 깁니다 . 우편함에 편지를 넣을 때 우편 시스템이 지정된 시간 내에 편지를 배달 할 것으로 예상하지만 편지 배달 방법에 대한 기대는 없습니다. 알 필요가 없으며 우편 서비스는 유연성이 있습니다. 요구 사항과 현재 상황에 가장 잘 맞는 운송 수단 을 선택하십시오 . 이에 대한 예외는 고객이 항공 우편을 선택할 수있는 능력입니다. 현대 컴퓨터 프로그래머가 구현 한 인터페이스가 너무 많기 때문에 구현이 너무 많기 때문입니다.
자연의 예 : 나는 eats (), makesSound (), moves () 등의 예에 너무 열중하지 않습니다. 올바른 행동을 설명하지만 상호 작용과 활성화 방법을 설명 하지는 않습니다 . 자연의 상호 작용을 가능하게하는 인터페이스의 명백한 예는 번식과 관련이 있습니다. 예를 들어 꽃은 꿀벌에게 특정 인터페이스를 제공하여 수분이 발생할 수 있습니다.
평생 .net 개발자로 생활하고 자신의 인터페이스를 작성하지 마십시오. 결국, 우리는 수십 년 동안 그것들 없이도 잘 살아 남았고 우리 언어는 여전히 튜링 완료되었습니다.
왜 인터페이스가 필요한지 말할 수는 없지만 현재 프로젝트에서 인터페이스를 사용하는 위치 목록을 제공 할 수 있습니다.
플러그인 모델에서는 인터페이스별로 플러그인을로드하고 플러그인 작성자에게 해당 인터페이스를 제공합니다.
시스템 간 메시징 시스템에서 메시지 클래스는 모두 특정 인터페이스를 구현하며 인터페이스를 사용하여 "포장 해제"됩니다.
구성 관리 시스템은 구성 설정을 설정하고 검색하는 데 사용되는 인터페이스를 정의합니다.
불쾌한 순환 참조 문제를 피하기 위해 사용하는 하나의 인터페이스가 있습니다. (필요하지 않은 경우이 작업을 수행하지 마십시오.)
규칙이 있다면 is-a 관계 내에서 여러 클래스를 그룹화하려고 할 때 인터페이스를 사용해야하지만 기본 클래스에서 구현을 제공하고 싶지는 않습니다.
코드 예제 (앤드류와 인터페이스가 무엇인지에 대한 추가 정보와 함께 )는 다중 상속을 지원하지 않는 언어의 추상 클래스 대신 인터페이스가 필요한 이유를 설명합니다 (c # 및 자바):
interface ILogger
{
void Log();
}
class FileLogger : ILogger
{
public void Log() { }
}
class DataBaseLogger : ILogger
{
public void Log() { }
}
public class MySpecialLogger : SpecialLoggerBase, ILogger
{
public void Log() { }
}
FileLogger 및 DataBaseLogger에는 인터페이스가 필요하지 않습니다 (Logger 추상 기본 클래스 일 수 있음). 그러나 기본 클래스를 사용해야하는 써드 파티 로거를 사용해야합니다 (사용해야하는 보호 된 메소드를 노출한다고 가정하십시오). 언어가 다중 상속을 지원하지 않기 때문에 추상 기본 클래스 접근 방식을 사용할 수 없습니다.
결론은 코드에서 유연성을 높이기 위해 가능하면 인터페이스를 사용하는 것입니다. 구현이 덜 묶여 있으므로 변경에 더 적합합니다.
나는 지금 인터페이스를 사용했고 여기에 최신 사용법이 있습니다 (이름이 일반화되었습니다).
비즈니스 개체에 데이터를 저장해야하는 WinForm에 많은 사용자 지정 컨트롤이 있습니다. 한 가지 방법은 각 컨트롤을 개별적으로 호출하는 것입니다.
myBusinessObject.Save(controlA.Data);
myBusinessObject.Save(controlB.Data);
myBusinessObject.Save(controlC.Data);
이 구현의 문제점은 컨트롤을 추가 할 때마다 "데이터 저장"방법으로 가서 새 컨트롤을 추가해야한다는 것입니다.
SaveToBusinessObject (...) 메서드가있는 ISaveable 인터페이스를 구현하도록 컨트롤을 변경 했으므로 이제 "Save Data"메서드는 컨트롤을 반복하고 ISaveable 컨트롤을 찾으면 SaveToBusinessObject를 호출합니다. 이제 새로운 컨트롤이 필요할 때 누군가가해야 할 일은 해당 객체에 ISaveable을 구현하고 다른 클래스를 만지지 마십시오.
foreach(Control c in Controls)
{
ISaveable s = c as ISaveable;
if( s != null )
s.SaveToBusinessObject(myBusinessObject);
}
종종 인터페이스에 실현되지 않은 이점은 수정 사항을 현지화한다는 것입니다. 일단 정의되면 응용 프로그램의 전체 흐름을 거의 변경하지 않지만 종종 세부 수준에서 변경합니다. 특정 개체의 세부 정보를 유지하더라도 ProcessA의 변경 사항은 ProcessB의 변경 사항에 영향을 미치지 않습니다. (기본 수업도이 혜택을 제공합니다.)
편집 : 또 다른 이점은 행동의 특이성입니다. 내 예에서와 같이 데이터를 저장하기 만하면됩니다. 제어 유형이 무엇인지 또는 다른 작업을 수행 할 수 있는지 상관하지 않습니다. 데이터를 제어에 저장할 수 있는지 알고 싶습니다. 사용자 정의 컨트롤이 모든 것을 처리하기 때문에 텍스트, 숫자, 부울 또는 기타 여부를 확인하는 검사가 없습니다.
클래스의 동작을 강제해야하는 경우 인터페이스를 정의해야합니다.
동물의 행동에는 걷기, 먹기, 달리기 등이 포함될 수 있습니다. 따라서 동물을 인터페이스로 정의하십시오.
또 다른 실제 예는 ActionListener (또는 Runnable) 인터페이스입니다. 특정 이벤트를 추적해야 할 때이를 구현합니다. 따라서 actionPerformed(Event e)클래스 (또는 서브 클래스)에서 메소드 의 구현을 제공해야합니다 . 마찬가지로 Runnable 인터페이스의 경우 public void run()메소드 구현을 제공합니다 .
또한 이러한 인터페이스를 여러 클래스로 구현할 수 있습니다.
인터페이스가 Java에서 사용되는 또 다른 인스턴스는 C ++에서 제공되는 다중 상속을 구현하는 것입니다.
잠을 자려고 할 때 발생할 수있는 성가심을 모델링하고 싶다고 가정하자.
인터페이스 전 모델
class Mosquito {
void flyAroundYourHead(){}
}
class Neighbour{
void startScreaming(){}
}
class LampJustOutsideYourWindow(){
void shineJustThroughYourWindow() {}
}
당신이 분명히 보듯이 많은 '사물들'은 잠을 자려고 할 때 성 가실 수 있습니다.
인터페이스가없는 클래스 사용
그러나 이러한 클래스를 사용할 때 문제가 있습니다. 공통점이 없습니다. 각 메소드를 별도로 호출해야합니다.
class TestAnnoyingThings{
void testAnnoyingThinks(Mosquito mosquito, Neighbour neighbour, LampJustOutsideYourWindow lamp){
if(mosquito != null){
mosquito.flyAroundYourHead();
}
if(neighbour!= null){
neighbour.startScreaming();
}
if(lamp!= null){
lamp.shineJustThroughYourWindow();
}
}
}
인터페이스가있는 모델
이 프로브를 극복하기 위해 iterface를 도입 할 수 있습니다
interface Annoying{
public void annoy();
}
그리고 클래스 내에서 구현하십시오.
class Mosquito implements Annoying {
void flyAroundYourHead(){}
void annoy(){
flyAroundYourHead();
}
}
class Neighbour implements Annoying{
void startScreaming(){}
void annoy(){
startScreaming();
}
}
class LampJustOutsideYourWindow implements Annoying{
void shineJustThroughYourWindow() {}
void annoy(){
shineJustThroughYourWindow();
}
}
인터페이스 사용
이 클래스를 훨씬 쉽게 사용할 수 있습니다.
class TestAnnoyingThings{
void testAnnoyingThinks(Annoying annoying){
annoying.annoy();
}
}
가장 쉬운 예는 지불 처리기 (Paypal, PDS 등)입니다.
ProcessACH 및 ProcessCreditCard 메소드가있는 인터페이스 IPaymentProcessor를 작성한다고 가정하십시오.
이제 구체적인 Paypal 구현을 구현할 수 있습니다. 이러한 메소드를 작성하면 PayPal 고유 함수가 호출됩니다.
나중에 다른 제공자로 전환해야한다고 결정할 수 있습니다. 새로운 제공자를 위해 또 다른 구체적인 구현을 만드십시오. 인터페이스 (계약) 만 있으면되므로 사용하는 코드를 변경하지 않고도 응용 프로그램에서 사용하는 인터페이스를 바꿀 수 있습니다.
또한 모의 단위 테스트 (.Net)를 수행 할 수 있습니다. 클래스가 인터페이스를 사용하는 경우 단위 테스트에서 객체를 조롱하고 실제로 데이터베이스 나 웹 서비스에 충돌하지 않고 로직을 쉽게 테스트 할 수 있습니다.
.NET Framework 어셈블리를 탐색하고 표준 개체에 대한 기본 클래스를 드릴 다운하면 많은 인터페이스 (ISomeName이라는 멤버)가 나타납니다.
인터페이스는 기본적으로 크거나 작은 프레임 워크를 구현하기위한 것입니다. 내 자신의 프레임 워크를 작성하고 싶을 때까지 인터페이스에 대해 같은 방식을 느꼈습니다. 또한 인터페이스를 이해하면 프레임 워크를 훨씬 빠르게 익힐 수있었습니다. 거의 모든 것에 대해보다 우아한 솔루션을 작성하려는 순간, 인터페이스가 의미가 있다는 것을 알게 될 것입니다. 그것은 수업이 직업에 적합한 옷을 입게하는 방법과 같습니다. 더 중요한 것은 클래스가 인터페이스를 구현할 때 복잡한 객체가 덜 복잡 해져서 기능을 분류하는 데 도움이되기 때문에 인터페이스는 시스템이 훨씬 더 자체 문서화 될 수 있도록합니다.
클래스는 프레임 워크에 명시 적 또는 암시 적으로 참여할 수 있도록 인터페이스를 구현합니다. 예를 들어 IDisposable은 널리 사용되는 유용한 Dispose () 메서드에 메서드 서명을 제공하는 일반적인 인터페이스입니다. 프레임 워크에서 사용자 나 다른 개발자가 클래스에 대해 알아야 할 것은 IDisposable을 구현하면 정리 목적으로 ((IDisposable) myObject) .Dispose ()를 호출 할 수 있다는 것입니다.
기본 예 : IDisposable 인터페이스를 구현하지 않으면 C #에서 "using ()"키워드 구문을 사용할 수 없습니다. 매개 변수로 지정된 모든 개체를 암시 적으로 IDisposable로 캐스팅 할 수 있어야하기 때문입니다.
복잡한 예 :보다 복잡한 예는 System.ComponentModel.Component 클래스입니다. 이 클래스는 IDisposable과 IComponent를 모두 구현합니다. 비주얼 디자이너가 연결된 대부분의 .NET 객체는 IDE가 구성 요소와 상호 작용할 수 있도록 IComponent를 구현합니다.
결론 : .NET Framework에 익숙해 짐에 따라 Object Browser 또는 .NET Reflector (무료) 도구 ( http://www.red-gate.com )에서 새 클래스를 만날 때 가장 먼저해야 할 일 / products / reflector / )는 상속받은 클래스와 구현하는 인터페이스를 확인합니다. .NET 리플렉터는 파생 클래스를 볼 수 있기 때문에 객체 브라우저보다 훨씬 좋습니다. 이를 통해 특정 클래스에서 파생 된 모든 객체에 대해 학습 할 수 있으므로 존재하지 않았던 프레임 워크 기능에 대해 학습 할 수 있습니다. 이는 업데이트되거나 새로운 네임 스페이스가 .NET Framework에 추가 될 때 특히 중요합니다.
1 인칭 슈팅 게임을 만드는 것을 고려하십시오. 플레이어는 여러 총을 선택할 수 있습니다.
Gun함수를 정의 하는 인터페이스 를 가질 수 있습니다 shoot().
우리는 서로 다른 서브 클래스가 필요 Gun, 즉 클래스 ShotGun Sniper등등을.
ShotGun implements Gun{
public void shoot(){
\\shotgun implementation of shoot.
}
}
Sniper implements Gun{
public void shoot(){
\\sniper implementation of shoot.
}
}
슈터 클래스
범인은 그의 갑옷에 모든 총을 가지고 있습니다. List그것을 나타 내기 위해 를 만들 수 있습니다.
List<Gun> listOfGuns = new ArrayList<Gun>();
사수는 필요에 따라 기능을 사용하여 총을 순환합니다. switchGun()
public void switchGun(){
//code to cycle through the guns from the list of guns.
currentGun = //the next gun in the list.
}
위의 함수를 사용하여 현재 Gun을 설정하고 호출 shoot()되면 간단히 함수 를 호출 할 수 fire()있습니다.
public void fire(){
currentGun.shoot();
}
촬영 기능의 동작은 Gun인터페이스의 구현에 따라 다릅니다 .
결론
클래스 함수가 다른 클래스의 함수에 종속 되어 있으면 구현 된 클래스의 인스턴스 (객체)에 따라 동작이 변경 될 때 인터페이스를 만듭니다 .
예를 들어 class의 fire()함수 Shooter는 guns ( Sniper, ShotGun)가 shoot()함수 를 구현할 것으로 예상 합니다. 총을 쏴서 발사하면
shooter.switchGun();
shooter.fire();
fire()기능 의 동작을 변경했습니다 .
Larsenal이 말한 것을 확장합니다. 인터페이스는 모든 구현 클래스가 따라야하는 계약입니다. 이로 인해 계약 프로그래밍이라는 기술을 사용할 수 있습니다. 이를 통해 소프트웨어를 독립적으로 구현할 수 있습니다.
인터페이스는 일반적으로 객체가 나타낼 수있는 동작을 정의 할 때 사용됩니다.
.NET 세계에서 이에 대한 좋은 예는 IDisposable 인터페이스로, 수동으로 해제해야하는 시스템 리소스를 사용하는 모든 Microsoft 클래스에서 사용됩니다. 이를 구현하는 클래스에는 Dispose () 메서드가 있어야합니다.
(The Dispose() method is also called by the using language construct for VB.NET and C#, which only works on IDisposables)
Keep in mind that you can check if an object implements a specific interface by using constructs such as TypeOf ... Is (VB.NET), is (C#), instanceof (Java), etc...
As several people have probably already answered, interfaces can be used to enforce certain behaviors between classes that will not implement those behaviors the same way. So by implementing an interface you are saying that your class has the behavior of the interface. The IAnimal interface would not be a typical interface because Dog, Cat, Bird, etc. classes are types of animals, and should probably extend it, which is a case of inheritance. Instead, an interface would be more like animal behavior in this case, such as IRunnable, IFlyable, ITrainable, etc.
Interfaces are good for many things, one of the key things is pluggability. For example, declaring a method that has a List parameter will allow for anything that implements the List interface to be passed in, allowing the developer to remove and plug in a different list at a later time without having to rewrite a ton of code.
It is possible you'll never use interfaces, but if you're designing a project from scratch, especially a framework of some sort, you'll probably want to get familiar with them.
I would recommend reading the chapter on interfaces in Java Design by Coad, Mayfield, and Kern. They explain it a little better than the average introductory text. If you don't use Java, you can just read the beginning of the chapter, which is just mainly concepts.
As any programming technics that add flexibility to your system, interfaces also add some level of complexity. They are often great and you could use it everywhere (you can create an interface for all of your classes) -- but doing so, you would create a more complex system that would be harder to maintain.
There is a trade-off here, as usual : flexibility over maintainability. Which one is more important ? There is no answers - it depends on the project. But just remember that every softwares will have to be maintained...
So my advice : don't use interfaces until you really need them. (With Visual Studio, you can extract an interface from an existing class in 2 seconds - so don't hurry.)
Having said that, when do you need to create an interface ?
I do it when I'm refactoring a method that suddenly need to process two or more similar classes. I then create an interface, assign this interface to the two (or more) similar classes and I change the method parameter type (replace the class type with the interface type).
And it works :o)
One exception : when I when to mock objects, interface are much more easier to use. So I often create interface just for this.
PS : when I write "interface", I mean : "interface of any base class", including pure interface classes. Note that abstract classes are often a better bet then pure interfaces since you can add logic to them.
Regards, Sylvain.
Interfaces will become evident when you become a library developer (someone who codes for other coders). Most of us begin as application developers, where we use existing APIs and programming libraries.
Along the same lines that Interfaces are a contract, nobody mentioned yet that Interfaces are a great way to make some parts of your code stable. That's especially useful when it's a team project (or when you're developing code used by other developers). So, here's a concrete scenario for you:
When you are developing code in a team, others will possibly be using the code you write. They'll be most happy when they code to your (stable) interfaces, and you'll be happy when you have the freedom to change your implementations (hidden behind the interface) without breaking your team's code. It's a variant of information hiding (interfaces are public, implementations are hidden from the client programmers). Read more about protected variations.
Also see this related question about coding to an Interface.
There are so many purposes for using an interface.
Use in polymorphic behavior. Where you want to call specific methods of a child class with an inteface having a reference to the child class.
Having a contract with classes to implement all of the methods where it is necessary, like most common use is with COM objects , where a wrapper class is generated on a DLL which inherits the interface; these methods are called behind the scenes, and you just need to implement them but with the same structure as defined in the COM DLL which you can only know through the interface that they expose.
To reduce memory usage by loading specific methods in a class. Like if you have three business objects and they are implemented in a single class, you can use three interfaces.
E.g IUser, IOrder, IOrderItem
public interface IUser()
{
void AddUser(string name ,string fname);
}
// Same for IOrder and IOrderItem
//
public class BusinessLayer: IUser, IOrder, IOrderItem
{
public void AddUser(string name ,string fname)
{
// Do stuffs here.
}
// All methods from all interfaces must be implemented.
}
If you only want to add an user, do like this:
IUser user = new (IUser)BusinessLayer();
// It will load all methods into memory which are declared in the IUser interface.
user.AddUser();
참고URL : https://stackoverflow.com/questions/444245/how-will-i-know-when-to-create-an-interface
'IT' 카테고리의 다른 글
| ExpressJS에서 404 오류를 페이지로 리디렉션하는 방법은 무엇입니까? (0) | 2020.05.13 |
|---|---|
| iOS 6의 라벨 정렬-UITextAlignment 사용 중단 (0) | 2020.05.13 |
| Ruby에서 HTML 엔터티를 어떻게 인코딩 / 디코딩합니까? (0) | 2020.05.13 |
| 새로운 레일 대 생성 (0) | 2020.05.13 |
| 해시 및 범위 기본 키란 무엇입니까? (0) | 2020.05.13 |