인터페이스(Interface)
- 클래스 생성시 표준사항
- Interface 키워드
- I인터페이스명
- 구성요소 : 메소드, 프로퍼티, 인덱서, 이벤트
- 선언만 되며 본문은 정의X
- 접근 제한자 선언X (모든멤버가 public을 기본으로 함)
   -> 공용적으로 사용할 메소드, 속성등을 기술하기 때문에 public을 붙일 필요조차 없음.
       물론 그 안의 메소드도 접근 권한자가 필요 없고, 묵시적으로 가상 메소드이기 때문에 virtual이라는 가상 메소드를 나타내는 키워드도 필요없다.

- 인터페이스를 구현하는 클래스는 (상속받는 클래스) 반드시 모든 인터페이스 멤버를 구현
- 인터페이스 반환형과 구현 클래스에서 반환형 일치(시그너처에 반환형이 포함된다)
- 추상 클래스도 인터페이스 상속가능

   interface IExam
    {
       void Ans();
    }

    class Class1 : IExam
    {
       public void Ans()
       {
          Console.WriteLine("인티페이스의 메소드를 구현");
       }
    }

    class Class2
    {
       static void Main()
       {
          //IExam iE = new IExam(); 인터페이스는 개체를 생성할 수 없다.
          //구현 클래스의 생성자로 개체를 생성해야 한다.
          IExam ie = new Class1();
          ie.Ans();
       }
    }

인터페이스 다중상속

        using System;

        namespace Interface
        {
            interface ISound
            {
                void VolumeControl();
                void SpeakOut();
            }
            interface IMouse
            {
                void Move(int x, int y);
                void Click();
                //인터페이스 멤버는 파생클래스에서 본문을 꼭 구현해야한다.
            }
            abstract class Computer : ISound, IMouse    //인터페이스는 다중상속가능, 일반클래스는 단일상속만 가능
            {
                //인터페이스 멤버를 추상클래스가 상속받는다면, 파생클래스에서 선택적으로 구현이 가능하다.
                abstract public void VolumeControl();
                abstract public void SpeakOut();
                abstract public void Move(int x, int y);
                abstract public void Click();
            }

            class Desktop: Computer
            {
                public override void VolumeControl()
                {
                    Console.WriteLine("볼륨을 조절합니다");
                }
                public override void SpeakOut()
                {
                    Console.WriteLine("소리를 내보냅니다");
                }
                public override void Move(int x, int y)
                {
                    Console.WriteLine("{0}, {1} 위치로 마우스를 움직입니다",x,y);
                }
                public override void Click()
                {
                    Console.WriteLine("마우스를 클릭합니다");
                }
            }
            class SamSungDesktop: Computer
            {
                public override void VolumeControl()
                {
                    Console.WriteLine("삼성컴퓨터의 볼륨을 조절합니다");
                }
                public override void SpeakOut()
                {
                    Console.WriteLine("삼성컴퓨터의 소리를 내보냅니다");
                }
                public override void Move(int x, int y)
                {
                    Console.WriteLine("삼성컴퓨터의 {0}, {1} 위치로 마우스를 움직입니다",x,y);
                }
                public override void Click()
                {
                    Console.WriteLine("삼성컴퓨터의 마우스를 클릭합니다");
                }
            }
            class MainClass
            {
                public static void Main()
                {
                    Desktop mycom = new Desktop();
                    mycom.VolumeControl();
                    mycom.SpeakOut();
                    mycom.Move(10,20);
                    mycom.Click();

                    SamSungDesktop scom = new SamSungDesktop();
                    scom.VolumeControl();
                    scom.SpeakOut();
                    scom.Move(10,20);
                    scom.Click();

                    Computer com1 = mycom;
                    com1.VolumeControl();
                    Computer com1 = scom;
                    com2.VolumeControl();
                }
            }
        }

명시적 인터페이스 멤버 구현
- 다중 인터페이스 상속시 중복되는 멤버구현
- 인터페이스명.멤버명
- 명시적 인터페이스 구현시 접근제한자 명시 불가능
- 인터페이스 메소드 구현

인터페이스 메소드
- 동일한 접근 권한자이여야 한다. (public을 명시)
- 동일한 반환값, 메소드명, 인자리스트 여야 한다.

    using System;
    namespace Interface
    {
        interface IKorea
        {
            void Speak();
        }

        interface IEnglish
        {
            void Speak();
        }
       
        interface IJapanese
        {
            void Speak();
        }

        class Speaker : IKorea, IEnglish, IJapanese
        {
            //접근제한자 public 사용X
            //반드시 인터페이스를 통해서 접근가능

            void IKorea.Speak()
            {
                Console.WriteLine("안녕하세요");
            }
            void IEnglish.Speak()
            {
                Console.WriteLine("Hi~");
            }
            void IJapanese.Speak()
            {
                Console.WriteLine("오하요고자이마스");
            }

        }
        class MainClass
        {
            public static void Main()
            {
                Speaker man = new Speaker();

                //인터페이스를 통해서 사용
                IKorea kman = (IKorea)man;      //자식객체는 부모형태로 형변환 가능
                kman.Speak();                   //인터페이스를 통해서 접근

                IEnglish eman = (IEnglish)man;
                eman.Speak();

                IJapanese jman = (IJapanese)man;
                jman.Speak();
            }
        }
    }

부모객체 p = new 자식객체();
-> 위에서 코딩상 접근할때 p.으로 접근가능한 것은 부모객체의 메소드 뿐이지만
    실제로는 부모객체를 물려받은 자식객체의 메소드들도 참조한다.

    class Stream
    {
        public void Open(){}
    }
    class FileStream: Stream
    {
        public void Delete(){}
    }

    FileStream fs = new FileStream();       //자기자신 객체에만 접근가능

    Stream s = new FileStream();

    //코딩상 접근가능한것은 Stream객체지만 FileStream의 객체도 사용가능
    Stream s1 = new NetworkStream();

    Stream[] arr = new String[2];

    s[0] = s;
    s[1] = s1;
    (FileStream)s[0].Delete();

       
    //부모객체를 상속받은 서로다른 자식객체들을 일괄성있게 처리하고 나서
    //특정한 자식객체 하나가 자기자신의 객체를 사용하고자 할경우 사용용이

is연산자
- 클래스의 인터페이스 지원 여부 확인(호환성 검증)
- 클래스 객체 is 인터페이스

as연산자
- 호환성 검사 및 형변환
- 성공하면 변환값 반환. 실패하면 null값 반환

using System;

namespace Interface
{
    interface INothing
    {
        void INothing();
    }

    interface IKorea
    {
        void Speak();
    }
   
    class Speaker : IKorea
    {
        public void Speak()
        {
            Console.WriteLine("안녕하세요");
        }
    }
    class MainClass
    {
        public static void Main()
        {
            Speaker man = new Speaker();

            if(man is INothing) // 객체가 인터페이스와 호환이 가능한지 여부체크
                Console.WriteLine("INothing지원");
            else
                Console.WriteLine("INothing지원안함");
           
            IKorea kman = man as IKorea; //인터페이스와 호환가능여부 체크후 성공하면 변환값 반환. 실패하면 null값 반환

            if(kman != null)
                kman.Speak();
            else
                Console.WriteLine("IKorea 지원안함");

            IKorea kman2 = man as INothing;

            if(kman2 != null)
                Console.WriteLine("IKorea 지원함");
            else
                Console.WriteLine("IKorea 지원안함");
        }
    }
}