C\#의 인 터 페 이 스 를 깊이 이해 하 다.

C\#인터페이스
프로 그래 밍 에서 우 리 는 인 터 페 이 스 를 자주 사용 합 니 다.그것 은 무엇이 인터페이스 입 니까?
인 터 페 이 스 는 모든 클래스 나 구조 에 속 할 수 있 는 관련 기능 을 설명 하기 때문에 인터페이스의 클래스 나 구 조 를 실현 하려 면 인터페이스 정의 에서 지정 한 인터페이스 구성원 을 실현 해 야 한다.
인 터 페 이 스 는 interface 키 워드 를 사용 하여 정의 합 니 다.방법,속성,이벤트,색인 기 또는 이 네 가지 구성원 유형의 임 의 조합 으로 구성 할 수 있 습 니 다.
인터페이스의 특성:
1.인 터 페 이 스 는 추상 적 인 기류 와 유사 하기 때문에 인 터 페 이 스 를 직접 예화 할 수 없다.인터페이스 중의 방법 은 모두 추상 적 인 방법 으로 인 터 페 이 스 를 실현 하 는 모든 비 추상 적 인 유형 은 반드시 인터페이스의 모든 것 을 실현 해 야 한다.
성원
이 인터페이스의 구성원 을 명시 적 으로 실현 할 때 이 루어 진 구성원 은 클래스 인 스 턴 스 를 통 해 접근 할 수 없고 인터페이스 인 스 턴 스 를 통 해 만 접근 할 수 있 습 니 다.
이 인터페이스의 구성원 을 암시 적 으로 실현 할 때 실 현 된 구성원 은 클래스 인 스 턴 스 를 통 해 접근 할 수도 있 고 인터페이스 인 스 턴 스 를 통 해 접근 할 수도 있 지만 실 현 된 구성원 은 반드시 공유 해 야 한다.
2.인 터 페 이 스 는 상수,필드,연산 자,인 스 턴 스 구조 함수,석조 함수 또는 유형 을 포함 할 수 없고 정적 구성원 을 포함 할 수 없습니다.
3.인터페이스 구성원 은 자동 으로 공개 되 며 접근 수식 자 를 포함 할 수 없습니다.
4.인터페이스 자체 가 여러 개의 인터페이스 에서 계승 할 수 있 고 클래스 와 구 조 는 여러 개의 인 터 페 이 스 를 계승 할 수 있 으 나 인 터 페 이 스 는 계승 할 수 없다.
왜 인터페이스 에 있 는 방법의 수식 자 를 지정 할 수 없 습 니까?
인터페이스 에 있 는 방법 은 대상 간 통신 의 계약 을 정의 하 는 데 사용 되 며,인터페이스 에 있 는 방법 을 개인 또는 보호 로 지정 하 는 것 은 의미 가 없다.그것들 은 기본적으로 공유 방법 이다.

   interface IProgram  
  {     
       void Fun();  
  }   
   class Program:IProgram  
  {    
     //                
     void IProgram.Fun()     
     {        
           Console.WriteLine("I am Fun.");    
    }     
     staticvoid Main(string[] args)    
    {    
          IProgram p =new Program(); 
     //        ，                       
     p.Fun();        
     Console.Read();    
    }    
}

위 에서 언급 한 바 와 같이 인 터 페 이 스 를 실현 하면 현식 실현 과 은 식 실현 이 가능 하 다 면 이 두 가지 실현 은 도대체 어떤 장단 점 이 있 습 니까?
일반적인 상황 에서 유형 이나 구조 가 실현 해 야 할 것 은 하나의 인터페이스 이 고 암시 적 으로 실현 할 수 있다.
만약 에 클래스 나 구조 가 여러 개의 인 터 페 이 스 를 계승 하고 인터페이스 에 같은 이름 의 구성원 이 있 을 때 명시 적 으로 실현 해 야 한다.명시 적 실현 방식 이 존재 할 때 암시 적 실현 방식 은 효력 을 잃 는 다.

interface IProgram
    {
        void Fun();
    }
    interface IAProgram
    {
        void Fun();
    }
    class Program : IProgram, IAProgram
    {
        void IProgram.Fun()  //      IProgram
        {
            Console.WriteLine("I am IProgram Fun.");
        }
        void IAProgram.Fun()  //      IAProgram
        {
            Console.WriteLine("I am IAProgram Fun.");
        }
        //public void Fun()   //      
        //{
        //    Console.WriteLine("I am Program Fun.");
        //}
        staticvoid Main(string[] args)
        {
            //IProgram p = new Program();
            //p.Fun();
            //IAProgram ap = new Program();
            //ap.Fun();
            Program pro =new Program();
            ((IProgram)pro).Fun();
            ((IAProgram)pro).Fun();
            Console.Read();
        }
    }

결 과 는:
I am IProgram Fun. I am IAProgram Fun.
인터페이스의 계승:
인터페이스 계승 과 클래스 계승 이 다르다.우선,클래스 계승 은 계승 을 설명 할 뿐만 아니 라 계승 도 실현 한다.인터페이스 상속 은 상속 을 설명 하 는 것 일 뿐이다.
즉,파생 류 는 기 류 를 계승 하 는 방법 으로 이 루어 질 수 있 고 파생 된 인 터 페 이 스 는 부모 인터페이스의 구성원 방법 만 설명 하고 부모 인터페이스의 실현 을 계승 하지 않 는 다.
그 다음으로 C\#중 류 계승 은 단일 계승 만 허용 하지만 인터페이스 계승 은 다 중 계승 을 허용 하고 하나의 키 인 터 페 이 스 는 여러 개의 부모 인터페이스 가 있 을 수 있다.
인 터 페 이 스 는 0 또는 여러 인터페이스 에서 계승 할 수 있다.여러 인터페이스 에서 계승 할 때":"후 와 계승 되 는 인터페이스 이름,여러 인터페이스 이름 사이 에","분할"을 사용 합 니 다.
계승 되 는 인 터 페 이 스 는 접근 할 수 있어 야 합 니 다.예 를 들 어 private 형식 이나 internal 형식의 인터페이스 에서 계승 하 는 것 은 허용 되 지 않 습 니 다.
인 터 페 이 스 는 직접 또는 간접 적 으로 자신 에 게 서 물 려 받 을 수 없다.클래스 의 계승 과 비슷 하고 인터페이스의 계승 도 인터페이스 간 의 차원 구 조 를 형성한다.

interface IProgram
    {
        void Fun();
    }
    interface IAProgram:IProgram
    {
    }
    class Program :  IAProgram
    {
        void IProgram.Fun()
        {
            Console.WriteLine("I am IProgram Fun.");
        }
        staticvoid Main(string[] args)
        {
            Program pro =new Program();
            ((IAProgram)pro).Fun();
            Console.Read();
        }
    }

인터페이스의 덮어 쓰기:
인터페이스의 실현 은 방법 체 가 없고 추상 적 인 방법 도 방법 체 가 없 기 때문에 우리 가 인터페이스의 실현 방법 에서 추상 적 인 방법 을 호출 할 때 어떻게 집행 합 니까?

 interface IProgram
    {
        void Fun();
    }
    abstractclass AProgram : IProgram
    {
        publicabstractvoid AFun();
        void IProgram.Fun()
        {
            AFun();
        }
    }
    class Program:AProgram
    {
        publicoverridevoid AFun()
        {
            Console.WriteLine("I am AProgram.");
        }
        staticvoid Main(string[] args)
        {
            IProgram pro =new Program();
            pro.Fun();
            Console.Read();
        }
    }

결과:
I am Aprogram.
정지점 을 통 해 pro.Fun()을 실행 할 때 볼 수 있 습 니 다.이 때 먼저 인터페이스의 실현 방법 에 뛰 어 든 다음 에 추상 함수 의 실현 방법 을 호출 하고 추상 함수 의 방법 이 실 현 된 후에 인터페이스의 실현 방법 으로 돌아 가 집행 이 완 료 될 때 까지 한다.
우리 가 인 터 페 이 스 를 실현 하 는 방법 에서 가상 함 수 를 호출 할 때?

 interface IProgram
    {
        void Fun();
    }
    class AProgram : IProgram
    {
        publicvirtualvoid AFun()    //        
        {
            Console.WriteLine("I am virtual AFun.");
        }
        void IProgram.Fun()
        {
            AFun();
        }
    }
    class Program:AProgram
    {
        publicoverridevoid AFun()  //   Override  
        {
            Console.WriteLine("I am override AFun.");
        }
        staticvoid Main(string[] args)
        {
            IProgram pro =new Program();
            pro.Fun();
            Console.Read();
        }
    }

이때 우 리 는 집행 순서 가 이전 예 와 같다 는 것 을 발견 했다.그래서 결 과 는:
I am override AFun.
이 를 통 해 우 리 는 오 버 라 이 드 키 워드 를 new 로 바 꿀 때 계속 연상 할 수 있다.같은 결과 일 까,아니면 우리 가 이전에 말 한 예 와 마찬가지 로 숨 기 는 것 일 까?
우 리 는 위의 예 를 개선 했다.

interface IProgram
    {
        void Fun();
    }
    class AProgram : IProgram
    {
        publicvirtualvoid AFun()
        {
            Console.WriteLine("I am virtual AFun.");
        }
        void IProgram.Fun()
        {
            AFun();
        }
    }
    class Program:AProgram
    {
        publicnewvoid AFun()
        {
            Console.WriteLine("I am new AFun.");
        }
        staticvoid Main(string[] args)
        {
            Program pro =new Program();
            ((IProgram)pro).Fun();
            pro.AFun();
            Console.Read();
        }
    }

결 과 는:
I am virtual AFun. I am new AFun.
앞에서 말 했 듯 이 여 기 는 이에 대해 분석 하지 않 습 니 다.이 를 통 해 뉴 키 워드 를 사용 하 는 것 은 이 를 숨 기 는 것 임 을 알 수 있 습 니 다.인터페이스 실현 방법 에서 가상 방법 을 호출 할 때 클래스 의 실행 과정 과 같 습 니 다.
인터페이스 와 추상 류 의 차이.

인 터 페 이 스 는 규범 에 사용 되 고 추상 류 는 공통성 에 사용 된다.

인터페이스 에 서 는 방법,속성,이벤트,색인 기 만 설명 할 수 있 습 니 다.추상 류 에 서 는 방법 적 인 실현 이 있 을 수도 있 고 비정 상 변 수 를 정의 할 수도 있다.

추상 류 는 클래스 이기 때문에 단독으로 계승 할 수 있 지만 인 터 페 이 스 는 한 번 에 여러 개 를 실현 할 수 있다.

추상 류 는 특정한 방법의 일부 실현 을 제공 할 수 있 고 인 터 페 이 스 는 안 된다.

추상 류 의 실례 는 그의 하위 클래스 가 제시 한 것 이다.인터페이스의 인 스 턴 스 는 인 터 페 이 스 를 실현 하 는 클래스 입 니 다.

추상 류 에 방법 을 추가 하면 그의 자 류 는 동시에 이 방법 이 있다.인터페이스 에 새로운 방법 을 추가 하면 클래스 를 다시 작성 해 야 합 니 다(이것

인 터 페 이 스 는 왜 하나의 규범 이 라 고 말 합 니까?

인터페이스 구성원 은 공공 으로 정의 되 지만 추상 적 인 구성원 도 개인 적 이 고 보 호 받 으 며 내부 적 이거 나 보 호 받 는 내부 구성원 일 수 있다(그 중에서 보 호 받 는 내부 구성원 은 응용 프로그램의 코드 나 파생 류 에서 만 접근 할 수 있다).

그 밖 에 인 터 페 이 스 는 필드,구조 함수,분석 함수,정적 구성원 또는 상수 가 포함 되 지 않 습 니 다.

C\#의 인터페이스 와 클래스 는 어떤 차이 가 있 습 니까?
다른:

인 터 페 이 스 를 직접 예화 할 수 없다.

인 터 페 이 스 는 방법의 실현 을 포함 하지 않 습 니 다.

인 터 페 이 스 는 다 중 계승 을 실현 할 수 있 고 유형 은 단일 계승 만 할 수 있다.

클래스 정 의 는 서로 다른 원본 파일 사이 에서 나 눌 수 있 습 니 다.

같은:

인터페이스,클래스 와 구 조 는 여러 인터페이스 에서 계승 할 수 있다.

인 터 페 이 스 는 추상 적 인 기류 와 유사 하 다.인 터 페 이 스 를 계승 하 는 모든 비 추상 적 인 유형 은 인터페이스의 모든 구성원 을 실현 해 야 한다.

인 터 페 이 스 는 이벤트,색인 기,방법 과 속성 을 포함 할 수 있 습 니 다.

한 종 류 는 여러 개의 인 터 페 이 스 를 실현 할 수 있다.

본 논문 의 저작권 은 작가 와 블 로그 원 이 공유 하고 전 재 를 환영 하지만 작가 의 동의 없 이 이 성명 을 보류 하고 글 페이지 의 뚜렷 한 위치 에 하이퍼링크 형식 으로 출처 를 밝 혀 야 한다.그렇지 않 으 면 법률 적 책임 을 추궁 할 권 리 를 보류 해 야 한다.
총결산
이 글 은 여기까지 입 니 다.당신 에 게 도움 을 줄 수 있 기 를 바 랍 니 다.또한 당신 이 우리 의 더 많은 내용 에 관심 을 가 져 주 기 를 바 랍 니 다!